/***************************************************************************
 *     Copyright (c) 2011, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile:  $
 * $brcm_Revision:  $
 * $brcm_Date: $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log:  $
 *
 ****************************************************************************/

#include "bstd.h"
#include "bkni.h"
#include "ts_priv.h"
#include "ts_psi.h"
#include "ministd.h"
#include "dvb_parser.h"

#include "si.h"
#include "si_util.h"

BDBG_MODULE(dvb_sdt);

#define MAX_NUM_STREAM 32

static uint8_t sdt_stream_cnt ;
static uint16_t sdt_stream_id[MAX_NUM_STREAM];
static uint8_t sdt_version_num[MAX_NUM_STREAM];
static uint8_t sdt_last_section[MAX_NUM_STREAM];
static uint32_t sdt_section_mask[MAX_NUM_STREAM][8];

static sdt_map_t sdt_map;
static dvb_sdt_cb_t *sdt_cb = NULL;

#ifdef BCM_DEBUG
static void dump_sdt_map(void);
#endif

void dvb_sdt_init(dvb_sdt_cb_t *cb)
{
	int i,j;
	
	sdt_cb = cb;
	BKNI_Memset(&sdt_map, 0, sizeof(sdt_map));
	sdt_stream_cnt = 0;
	for (i=0; i<MAX_NUM_STREAM; i++) {
		sdt_stream_id[i] = 0xFFFF;
		sdt_version_num[i] = MAX_NUM_STREAM;
		sdt_last_section[i] = 0;
		for (j=0; j<8; j++)
			sdt_section_mask[i][j] = 0;
	}
}

int dvb_sdt_parse(const uint8_t *sdt_buf, size_t *psize)
{
	uint16_t section_len, data_len, stream_id, original_network_id, desc_loop_len;
	uint8_t version_num, section_number, last_section;
	uint8_t tid;
	struct bit_state_t bs;
	int st_idx;

	sdt_t *p_sdt;
	
	BDBG_ASSERT((sdt_buf && psize));
	BDBG_MSG(("%s: enter", __func__));

	bs.bindex = 0;
	bs.data = (unsigned char *)sdt_buf;

	tid = get_bits(8, &bs);	
	if ((DVB_TID_SDT_ACT != tid) && (DVB_TID_SDT_OTH != tid)) {
		BDBG_WRN(("%s: Invalid SD Table ID (0x%02x)", __func__, tid));
		return 0;
	}

	get_bits(4, &bs);	
	section_len = get_bits(12, &bs);

	if (*psize < (section_len + 3)) {
		BDBG_WRN(("%s: incomplete section", __func__));
		return 0;
	}

	stream_id = get_bits(16, &bs);
	get_bits(2, &bs); /* skip reserved */
	version_num = get_bits(5, &bs);
	get_bits(1, &bs); /* skip current_next_indicator */
	section_number = get_bits(8, &bs);
	last_section = get_bits(8, &bs);
	original_network_id = get_bits(16, &bs);
	get_bits(8, &bs); /* skip reserved_future_use */

	for (st_idx=0; st_idx<sdt_stream_cnt; st_idx++) {
		if (sdt_stream_id[st_idx] == stream_id) {
			break;
		}
	}

	if (st_idx == sdt_stream_cnt) {
		sdt_stream_id[st_idx] = stream_id;
		sdt_stream_cnt++;
	}

	if (version_num != sdt_version_num[st_idx]) {
		SI_Init_Section_Mask((unsigned long *)sdt_section_mask[st_idx], last_section);
		sdt_last_section[st_idx] = last_section;
	}
	else if (SI_Chk_Section_mask((unsigned long *)sdt_section_mask[st_idx], section_number)) {
		return 0;
	}

	BDBG_WRN(("SDT updated to %d->%d: stream_id:%x", sdt_version_num[st_idx], version_num, stream_id));
	/* TODO:: update (not from initial value ) */

	sdt_version_num[st_idx] = version_num;
	SI_Set_Section_mask((unsigned long *)sdt_section_mask[st_idx], section_number);

	data_len = section_len + 3 - DVB_SDT_LEN - 4; /* crc */ 

	/* services */
	while (data_len>0) {
		p_sdt = &sdt_map.sdt[sdt_map.num_sdt];
		BKNI_Memset(p_sdt, 0, sizeof(sdt_t));
	
		p_sdt->stream_id = stream_id;
		p_sdt->service_id = get_bits(16, &bs);
		get_bits(6, &bs); /* skip reserved_future_use */
		p_sdt->eit_schedule_flag = get_bits(1, &bs);
		p_sdt->eit_pf_flag = get_bits(1, &bs);
		p_sdt->running_status = get_bits(3, &bs);
		p_sdt->free_ca_mode = get_bits(1, &bs);
		desc_loop_len = get_bits(12, &bs);

		BDBG_MSG(("SDT [%d] service_id-0x%x, eit_sched:%d, eit_pf:%d, running:%d, ca:%d",
			sdt_map.num_sdt, p_sdt->service_id, p_sdt->eit_schedule_flag, p_sdt->eit_pf_flag,
			p_sdt->running_status, p_sdt->free_ca_mode));

		p_sdt->frequency = dvb_find_frequency_for_stream_id(stream_id);
		if (p_sdt->frequency) {
			dvb_parse_descriptors((uint8_t *)&sdt_buf[bs.bindex/8], desc_loop_len, DVB_TID_SDT_ACT, p_sdt);
			bs.bindex = bs.bindex + desc_loop_len*8;
			data_len -= desc_loop_len + DVB_SDT_DESCR_LEN;
			sdt_map.num_sdt++;

			if (sdt_cb && sdt_cb->cb) {
				sdt_cb->cb(p_sdt, sdt_cb->data);
			}
		}
		else {
			BDBG_WRN(("Frequency entry wasn't defined.."));
			bs.bindex = bs.bindex + desc_loop_len*8;
			data_len -= desc_loop_len + DVB_SDT_DESCR_LEN;
		}
	}

#ifdef BCM_DEBUG
	dump_sdt_map();	
#endif
	/* crc */
	BDBG_MSG(("%s: leave", __func__));

	return 1;
}

bool dvb_sdt_complete(int num_stream)
{
	int i;
	int result;	
	if (sdt_stream_cnt < num_stream) { /* sdt info for all streams are not delivered yet */
		return false;
	}

	for (i=0; i<sdt_stream_cnt; i++) { /* for each SDT, check all sections are delivered */
		result = SI_Chk_Section_complete((unsigned long *)sdt_section_mask[i], sdt_last_section[i]);
		if (result != SI_SUCCESS) return false;
	}
	return true;
}

#ifdef BCM_DEBUG
static void dump_sdt_map(void)
{
	int i;

	BDBG_WRN(("%d SDT entry", sdt_map.num_sdt));
	for (i=0; i<sdt_map.num_sdt; i++) {
		BDBG_MSG(("[%02d] %06d KHz, 0x%04x service %04x, %s",
			i, sdt_map.sdt[i].frequency, sdt_map.sdt[i].stream_id,
			sdt_map.sdt[i].service_id, sdt_map.sdt[i].service_name));
	}
}
#endif