/*
 * In this module we implement our RTP handling: obtaining a PSTN-side
 * RTP endpoint from themwi-rtp-mgr, then handling read select on RTP
 * and RTCP UDP sockets.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "../include/tmgw_const.h"
#include "../include/rtp_defs.h"
#include "../librtpalloc/rtp_alloc_simple.h"

struct sockaddr_in rtp_local_addr;
int rtp_udp_fd, rtcp_udp_fd;

static int rtp_start_flag, rtp_bad_flag, rtp_ssrc_chg_flag;
static int rtp_seq_brk_flag, rtp_seq_zero_flag, rtp_seq_neg_flag;
static int rtp_ts_brk_flag;
static uint32_t rtp_ssrc;
static uint32_t rtp_last_ts;
static uint16_t rtp_last_seq;
static int got_some_rtcp;

static const uint8_t hdr_pattern[20] =	{0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
					 0, 1, 1, 0, 1, 0, 1, 0, 0, 1};

static uint8_t is_hunt_buf[320];

static void
reset_is_hunt()
{
	memset(is_hunt_buf, 0xFF, 320);
}

static void
is_hunt_proc(input, input_pos)
	uint8_t *input;
	unsigned input_pos;
{
	unsigned offset, n;

	memmove(is_hunt_buf, is_hunt_buf + 16, 304);
	memcpy(is_hunt_buf + 304, input, 16);
	for (offset = 0; offset < 16; offset++) {
		for (n = 0; n < 20; n++)
			if ((is_hunt_buf[offset + n*16] & 1) != hdr_pattern[n])
				break;
		if (n == 20)
			break;
	}
	if (n == 20)
		printf("Found IS_Header, last bit offset %u\n",
			input_pos * 16 + offset);
}

void
obtain_rtp_endp()
{
	int rc;
	struct rtp_alloc_simple res;

	rc = rtp_alloc_simple(TMGW_EP_TYPE_PSTN_ONLY, &res);
	if (rc < 0)
		exit(1);	/* error msg already printed */
	bcopy(&res.pstn_addr, &rtp_local_addr, sizeof(struct sockaddr_in));
	rtp_udp_fd = res.pstn_rtp_fd;
	rtcp_udp_fd = res.pstn_rtcp_fd;
	reset_is_hunt();
}

void
rtp_rx_select()
{
	struct rtp_packet pkt;
	struct sockaddr_in sin_from;
	socklen_t addrlen;
	int16_t seq_delta;
	int32_t ts_delta;
	int rc;
	unsigned is_chunk;

	addrlen = sizeof(struct sockaddr_in);
	rc = recvfrom(rtp_udp_fd, &pkt, sizeof pkt, 0,
			(struct sockaddr *) &sin_from, &addrlen);
	if (rc < 0)
		return;
	if (rc != RTP_PACKET_SIZE_PSTN) {
bad_rtp_pkt:	if (!rtp_bad_flag) {
			printf("Got a bad RTP packet\n");
			rtp_bad_flag = 1;
		}
		return;
	}
	if (pkt.v_p_x_cc != 0x80)
		goto bad_rtp_pkt;
	switch (pkt.m_pt & 0x7F) {
	case PSTN_CODEC_PCMU:
	case PSTN_CODEC_PCMA:
		break;
	default:
		goto bad_rtp_pkt;
	}
	if (rtp_start_flag && pkt.ssrc != rtp_ssrc) {
		if (!rtp_ssrc_chg_flag) {
			printf("Rx RTP stream changed SSRC\n");
			rtp_ssrc_chg_flag = 1;
		}
		reset_is_hunt();
	} else if (rtp_start_flag) {
		seq_delta = ntohs(pkt.seq) - rtp_last_seq;
		ts_delta = ntohl(pkt.tstamp) - rtp_last_ts;
		if (seq_delta == 0) {
			if (!rtp_seq_zero_flag) {
				printf("Rx RTP seq zero increment\n");
				rtp_seq_zero_flag = 1;
			}
			return;
		}
		if (seq_delta < 0) {
			if (!rtp_seq_neg_flag) {
				printf("Rx RTP seq negative increment\n");
				rtp_seq_neg_flag = 1;
			}
			return;
		}
		if (seq_delta != 1) {
			if (!rtp_seq_brk_flag) {
				printf("Rx RTP stream seq break\n");
				rtp_seq_brk_flag = 1;
			}
			reset_is_hunt();
		} else if (ts_delta != 160) {
			if (!rtp_ts_brk_flag) {
				printf("Rx RTP stream tstamp break\n");
				rtp_ts_brk_flag = 1;
			}
			reset_is_hunt();
		}
	}
	rtp_ssrc = pkt.ssrc;
	rtp_last_ts = ntohl(pkt.tstamp);
	rtp_last_seq = ntohs(pkt.seq);
	if (!rtp_start_flag) {
		printf("Rx RTP stream begins with seq=%u ts=%u\n",
			rtp_last_seq, rtp_last_ts);
		rtp_start_flag = 1;
	}
	for (is_chunk = 0; is_chunk < 10; is_chunk++)
		is_hunt_proc(pkt.payload + is_chunk * 16, is_chunk);
}

void
rtcp_rx_select()
{
	u_char buf[512];

	recv(rtcp_udp_fd, buf, sizeof buf, 0);
	if (!got_some_rtcp) {
		printf("Got some RTCP\n");
		got_some_rtcp = 1;
	}
}