/***************************************************************************
 *     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 "ch_map.h"
#include "dvb_parser.h"
#include "dvb_descriptor.h"

BDBG_MODULE(dvb_descriptor);

static unsigned char* constellation_str[] = {"QPSK", "QAM_16", "QAM_16", "Undefined"};
static unsigned char* modulation_str[] = {"Undefined", "QAM_16", "QAM_32", "QAM_64", "QAM_128", "QAM_256"};

static void dvb_parse_descriptor(uint8_t *buf, desc_hdr_t *hdr);
static void dump_dvb_content(uint8_t content);

void dvb_parse_descriptors(uint8_t *buf, uint16_t length, uint8_t table_id, void *entry)
{
	uint16_t parsed = 0;
//	uint8_t *ptr = buf;
	uint8_t desc_tag, len;
	int i;	
	struct bit_state_t bs;

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

	if (!entry) { /* don't need to parse */
		return;
	}
	while (parsed < length)
	{
		desc_tag = buf[bs.bindex/8];

		switch (table_id) 
		{
			case DVB_TID_NIT_ACT:
			{
				nit_t *nit_entry = entry;
				if (desc_tag == TS_PSI_DT_DVB_CableDelivery) 
				{
					cable_delivery_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
					nit_entry->type = desc_tag;
					nit_entry->frequency = desc.frequency;
					nit_entry->modulation = desc.modulation;
					switch (desc.modulation) {
						case 0x01: /* 16 QAM */
							nit_entry->modulation = eDVB_QAM_16; break;
						case 0x02: /* 32 QAM */
							nit_entry->modulation = eDVB_QAM_32; break;
						case 0x03: /* 64 QAM */
							nit_entry->modulation = eDVB_QAM_64; break;
						case 0x04: /* 128 QAM */
							nit_entry->modulation = eDVB_QAM_128; break;
						case 0x05: /* 256 QAM */
							nit_entry->modulation = eDVB_QAM_256; break;
						default:
							nit_entry->modulation = eDVB_QAM_Scan; break;
					}
					nit_entry->symbol_rate = desc.symbol_rate;
					nit_entry->code_rate = desc.code_rate;
					if (desc.modulation>5) desc.modulation = 0;

					BDBG_WRN(("cable: freq=%d KHz, modulation:%s, symbol_rate:%d Ksymbols",
						desc.frequency, modulation_str[desc.modulation], desc.symbol_rate));
				}
				else if (desc_tag == TS_PSI_DT_DVB_TerrestrialDeliverySystem) 
				{
					terrestrial_delivery_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
					nit_entry->type = desc_tag;
					nit_entry->frequency = desc.frequency;
					switch (desc.constellation) {
						case 0x01: /* 16 QAM */
							nit_entry->modulation = eDVB_QAM_16; break;
						case 0x02: /* 64 QAM */
							nit_entry->modulation = eDVB_QAM_64; break;
						case 0x00: /* QPSK */
						default:
							nit_entry->modulation = eDVB_QAM_Scan; break;
					}
					nit_entry->bandwidth = desc.bandwidth;
					if (desc.constellation>2) desc.constellation = 3;
					BDBG_WRN(("Terrestrial : %d khz, bandwidth:%d, constellation:%s",
						desc.frequency, desc.bandwidth, constellation_str[desc.constellation]));

				}
				else if (desc_tag == TS_PSI_DT_DVB_ServiceList) 
				{
					service_list_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
					nit_entry->program_cnt = desc.num_list;
					for (i=0; i<desc.num_list; i++) {
						nit_entry->program_id[i] = desc.service_id[i];
					}	
				}
				else if (desc_tag == TS_PSI_DT_DVB_FrequencyList)
				{
					freq_list_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
				}
				else if (desc_tag == TS_PSI_DT_DVB_SatelliteDelivery)
				{
					satellite_delivery_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
				}
				else {
					dvb_parse_descriptor(&buf[bs.bindex/8], NULL);
				}	
				break;
			}
			case DVB_TID_SDT_ACT:
			{
				sdt_t *sdt_entry = (sdt_t *)entry;
				if (desc_tag == TS_PSI_DT_DVB_Service) {
					service_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
					sdt_entry->service_type = desc.service_type;
					if (desc.provider_name[0])
						BKNI_Memcpy(sdt_entry->provider_name, desc.provider_name, MAX_NAME_LEN);
					if (desc.service_name[0])
						BKNI_Memcpy(sdt_entry->service_name, desc.service_name, MAX_NAME_LEN);
				}
				else if (desc_tag == TS_PSI_DT_DVB_CA_Indentifier) {
					ca_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc) ;
				}		
				break;
			}
			case DVB_TID_EIT_ACT:
			{
				eit_t *eit_entry = (eit_t *)entry;
				if (desc_tag == TS_PSI_DT_DVB_ShortEvent) {
					short_event_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
		
					if (desc.event_name[0])
						BKNI_Memcpy(eit_entry->event_name, desc.event_name, strlen(desc.event_name));
					if (desc.event_text[0])
						BKNI_Memcpy(eit_entry->event_text, desc.event_text, strlen(desc.event_text));
				}
				else if (desc_tag == TS_PSI_DT_DVB_ParentalRating) {
					rating_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
					BKNI_Memcpy(eit_entry->rating_code, desc.country_code, 3);
					eit_entry->rating_age = desc.rating;
				}
				else if (desc_tag == TS_PSI_DT_DVB_ExtendedEvent) {
					extend_event_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
				}
				else if (desc_tag == TS_PSI_DT_DVB_TimeShiftedEvent) {
					timeshift_event_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
				}
				else if (desc_tag == TS_PSI_DT_DVB_Component) {
					component_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
				}
				else if (desc_tag == TS_PSI_DT_DVB_Content) {
					content_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
				}
				break;
			}
			case DVB_TID_TIME_OFFSET:
			{
				tot_map_t *tmp_map = (tot_map_t *)entry;
				if (desc_tag == TS_PSI_DT_DVB_LocalTimeOffset) {
					time_offset_desc_t desc;
					dvb_parse_descriptor(&buf[bs.bindex/8], (desc_hdr_t *)&desc);
					BDBG_MSG(("time_offset : %d", desc.num_offset));
					if (desc.num_offset > 0) {
						tmp_map->num_tot = desc.num_offset;
						for (i=0; i<tmp_map->num_tot; i++) {
							BKNI_Memcpy(tmp_map->tot[i].country, desc.offsets[i].country, 3);
							tmp_map->tot[i].region_id = desc.offsets[i].region_id;
							tmp_map->tot[i].polarity = desc.offsets[i].polarity;
							tmp_map->tot[i].offset = desc.offsets[i].offset;
							tmp_map->tot[i].toc = desc.offsets[i].toc;
							tmp_map->tot[i].next_offset = desc.offsets[i].next_offset;
							BDBG_MSG(("[%d] %c%c%c region:0x%x %d %d %d %d",
								i, desc.offsets[i].country[0], desc.offsets[i].country[1], desc.offsets[i].country[2],
								desc.offsets[i].region_id, desc.offsets[i].polarity, desc.offsets[i].offset,
								desc.offsets[i].toc, desc.offsets[i].next_offset));
						}
					}
				}
				break;
			}
			default:
				break;
		}

		get_bits(8, &bs); /* tag */
		len = get_bits(8, &bs);
		parsed += len + 2;
		bs.bindex = bs.bindex + len*8;
	}
}

static uint32_t calc_frequency(uint8_t coding_type, uint32_t freq)
{
	uint32_t out_freq = 0;
	int i, mul = 1;
	uint8_t buf[4] ;

	switch (coding_type) {
		case 2: /* cable */
			buf[0] = (freq>>24)&0xFF;
			buf[1] = (freq>>16)&0xFF;
			buf[2] = (freq>>8)&0xFF;
			buf[3] = freq&0xFF;
			mul = 1000000;
			for (out_freq = 0, i=0; i<4; i++) {
				out_freq += (buf[i]>>4)*mul; mul /= 10;
				out_freq += (buf[i]&0x0F)*mul; mul/=10;
			}
			break;
		case 3: /* terrestrial */
			out_freq = freq/100;
			break;
		case 1: /* satellite */
		default:
			BDBG_WRN(("undefined.. coding type"));
			break;
	}
	return out_freq;
}

static void dvb_parse_descriptor(uint8_t *buf, desc_hdr_t *hdr)
{
	uint8_t tag, len;
	uint16_t idx;
	int i, mul = 1;
	struct bit_state_t bs;

	if (hdr == NULL) {
		BDBG_MSG(("don't need process : 0x%02x", hdr->tag));
		return;
	}

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

	tag = get_bits(8, &bs);

	switch (tag)
	{
		case TS_PSI_DT_DVB_NetworkName:
		{
			network_name_desc_t *desc = (network_name_desc_t *)hdr;

			BKNI_Memset(desc, 0, sizeof(network_name_desc_t));
			len = get_bits(8, &bs);
			desc->hdr.tag = tag;
            if (len) 
				BKNI_Memcpy(desc->name, &buf[bs.bindex/8], (len>MAX_NAME_LEN)?MAX_NAME_LEN:len);
			BDBG_WRN(("network name : %s", desc->name));
			break;
		}
		case TS_PSI_DT_DVB_CableDelivery:
		{
			cable_delivery_desc_t *desc = (cable_delivery_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(cable_delivery_desc_t));
			desc->hdr.tag = tag;
			len = get_bits(8, &bs);		
			desc->frequency = calc_frequency(2, get_bits_aligned(32, &bs));
			get_bits(16, &bs); /* skip reserved_future_use, FEC_outer */
			desc->modulation = get_bits(8, &bs);
			
			mul = 100000;
			for (desc->symbol_rate=0, i=0; i<6; i++) { /* k symbols */
				desc->symbol_rate += get_bits(4, &bs)*mul; 
				mul /= 10;
			}
			get_bits(4, &bs); /* discard under khz */
			desc->code_rate = get_bits(4, &bs);
			break;
		}
		case TS_PSI_DT_DVB_Service:
		{
			service_desc_t *desc = (service_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(service_desc_t));
			desc->hdr.tag = tag;
			get_bits(8, &bs);
			desc->service_type = get_bits(8, &bs);
			len = get_bits(8, &bs);
			if (len)
				BKNI_Memcpy(desc->provider_name, &buf[bs.bindex/8], (len>MAX_NAME_LEN)?MAX_NAME_LEN:len);
			bs.bindex = bs.bindex + len*8;
			len = get_bits(8, &bs);
			if (len)
				BKNI_Memcpy(desc->service_name, &buf[bs.bindex/8], (len>MAX_NAME_LEN)?MAX_NAME_LEN:len);
			BDBG_MSG(("service: type:%d provider-%s, service-%s",
				desc->service_type, desc->provider_name, desc->service_name));
			break;
		}
		case TS_PSI_DT_DVB_ShortEvent:
		{
			short_event_desc_t *desc = (short_event_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(short_event_desc_t));
			desc->hdr.tag = tag;
			len = get_bits(8, &bs);
			for (i=0; i<3; i++)
				desc->lang_code[i] = get_bits(8, &bs);
			len = get_bits(8, &bs);
			if (len)
				BKNI_Memcpy(desc->event_name, &buf[bs.bindex/8], (len>MAX_EVENT_NAME)?MAX_EVENT_NAME:len);
			bs.bindex = bs.bindex + len*8;
	
			len = get_bits(8, &bs);
			if (len)
				BKNI_Memcpy(desc->event_text, &buf[bs.bindex/8], len);
			BDBG_MSG(("short event: %s, %s", desc->event_name, desc->event_text));
			break;
		}
		case TS_PSI_DT_DVB_ExtendedEvent:
		{
			extend_event_desc_t *desc = (extend_event_desc_t *)hdr;
			uint8_t desc_num, last_num, parsed, item_len;
		
			BKNI_Memset(desc, 0, sizeof(extend_event_desc_t));
			desc->hdr.tag = tag;
			len = get_bits(8, &bs);
			desc_num = get_bits(4, &bs);
			last_num = get_bits(4, &bs);

			for (i=0; i<3; i++)
				desc->lang_code[i] = get_bits(8, &bs);
	
			len = get_bits(8, &bs);
			parsed = 0;

			while (parsed<len) {
				item_len = get_bits(8, &bs);
				if (item_len) 
					BKNI_Memcpy(desc->item_desc, &buf[bs.bindex/8], (item_len>MAX_EVENT_NAME)?MAX_EVENT_NAME:item_len);

				bs.bindex = bs.bindex + item_len*8;
				parsed += 1+item_len;
				item_len = get_bits(8, &bs);
				if (item_len)
					BKNI_Memcpy(desc->item_char, &buf[bs.bindex/8], item_len);
				bs.bindex = bs.bindex + item_len*8;
				parsed += 1+item_len;
            }
			len = get_bits(8, &bs);
			if (len)
				BKNI_Memcpy(desc->text_char, &buf[bs.bindex/8], len);
			BDBG_MSG(("extended event: %c%c%c, %s, %s, %s:",
				desc->lang_code[0], desc->lang_code[1], desc->lang_code[2],
				desc->item_desc, desc->item_char, desc->text_char));
			break;
		}
		case TS_PSI_DT_DVB_ParentalRating:
		{
			rating_desc_t *desc = (rating_desc_t *)hdr;
			uint8_t parsed = 0; 

			BKNI_Memset(desc, 0, sizeof(rating_desc_t));
			desc->hdr.tag = tag;
			len = get_bits(8, &bs);

			while (parsed<len) {
				for (i=0; i<3; i++)
					desc->country_code[i] = get_bits(8, &bs);
				
				desc->rating = get_bits(8, &bs);
				parsed += 4;
				BDBG_MSG(("rating: %c%c%c year %d", desc->country_code[0], desc->country_code[1], desc->country_code[2],
					(desc->rating>0&&desc->rating<0x10)?3+desc->rating:desc->rating));
			}
			break;
		}
		case TS_PSI_DT_DVB_ServiceList:
		{
			service_list_desc_t *desc = (service_list_desc_t *)hdr;

			BKNI_Memset(desc, 0, sizeof(service_list_desc_t));
			desc->hdr.tag = tag;

			len = get_bits(8, &bs);
			desc->num_list = len/3;
			if (desc->num_list>MAX_SERVICE_LIST) 
				desc->num_list = MAX_SERVICE_LIST;

			BDBG_MSG(("service list"));
			for (i=0; i<desc->num_list; i++) {
				desc->service_id[i] = get_bits(16, &bs);
				desc->service_type[i] = get_bits(8, &bs);
				BDBG_MSG(("[%d] 0x%x type(%d)", i, desc->service_id[i], desc->service_type[i]));
			}
			break;
		}
		case TS_PSI_DT_DVB_Content:
		{
			content_desc_t *desc = (content_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(content_desc_t));
			desc->hdr.tag = tag;
			len = get_bits(8, &bs);

			for (i=0; i<len/2; i++) {
				desc->content = get_bits(8, &bs);
				desc->user = get_bits(8, &bs);
				dump_dvb_content(desc->content);
			}
			break;
		}
		case TS_PSI_DT_DVB_PrivateDataSpecifier:
		case TS_PSI_DT_DVB_Linkage:
		{
			len = get_bits(8, &bs);
			BDBG_MSG(("linkage: length - %d", len));
			bs.bindex = bs.bindex + len*8;
			break;
		}
		case TS_PSI_DT_DVB_PDC:
		{
			pdc_desc_t *desc = (pdc_desc_t *)hdr;
			desc->hdr.tag = tag;
			len = get_bits(8, &bs);

			get_bits(4, &bs); /* skip reserved_future_use */
			desc->day = get_bits(5, &bs);
			desc->month = get_bits(4, &bs);
			desc->hour = get_bits(5, &bs);
			desc->minute = get_bits(6, &bs);
			BDBG_MSG(("PDC : month(%d) day(%d) hour(%d) minute(%d)", desc->month, desc->day, desc->hour, desc->minute));
			break;
		}
		case TS_PSI_DT_DVB_Component:
		{
			component_desc_t *desc = (component_desc_t *)hdr;
			int text_len ;

			BKNI_Memset(desc, 0, sizeof(component_desc_t));
			desc->hdr.tag = tag;
			len = get_bits(8, &bs);

			get_bits(4, &bs); /* skip reserved_future_use */
			desc->content = get_bits(4, &bs);
			desc->type = get_bits(8, &bs);
			desc->tag = get_bits(8, &bs);

			for (i=0; i<3; i++)
				desc->lang[i] = get_bits(8, &bs);

			text_len = len-6;
			if (text_len > MAX_EVENT_TEXT)
				text_len = MAX_EVENT_TEXT;
			if (text_len) 
				BKNI_Memcpy(desc->text, &buf[bs.bindex/8], text_len);
			BDBG_MSG(("component: c(%d), t(%d), tg(%d), (%c%c%c), %s)",
				desc->content, desc->type, desc->tag, desc->lang[0], desc->lang[1], desc->lang[2], desc->text));
			break;
		}
		case TS_PSI_DT_DVB_TimeShiftedEvent:
		{
			timeshift_event_desc_t *desc = (timeshift_event_desc_t *)hdr;
			len = get_bits(8, &bs);
			desc->hdr.tag = tag;

			desc->service_id = get_bits(16, &bs);
			desc->event_id = get_bits(16, &bs);
			break;
		}
		case TS_PSI_DT_DVB_TerrestrialDeliverySystem:
		{
			terrestrial_delivery_desc_t *desc = (terrestrial_delivery_desc_t *)hdr;
	
			BKNI_Memset(desc, 0, sizeof(terrestrial_delivery_desc_t));
			len = get_bits(8, &bs);
			desc->hdr.tag = tag;

			desc->frequency = get_bits_aligned(32, &bs)/100;  /* khz unit. centre_frequency is in the 10Hz unit */
			desc->bandwidth = get_bits(3, &bs);
			get_bits(5, &bs); /* skip reserved_future_use */
			desc->constellation = get_bits(2, &bs);
#if 0
			desc->hierarchy = get_bits(3, &bs);
			desc->HP = get_bits(3, &bs);
			desc->LP = get_bits(3, &bs);
			desc->interval = get_bits(2, &bs);
			desc->transmission = get_bits(2, &bs);
			desc->flag = get_bits(1, &bs);
			get_bits_aligned(32, &bs); /* skip reserved_future_use */
#endif
			break;
		}
		case TS_PSI_DT_DVB_CA_Indentifier:
		{
			ca_desc_t *desc = (ca_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(ca_desc_t));
			len = get_bits(8, &bs);
			desc->hdr.tag = tag;

			desc->ca_system_id = get_bits(16, &bs); /* TODO:: 1-n ca_system_id */
			BDBG_MSG(("ca_system_id : %x", desc->ca_system_id));
			break;
		}
		case TS_PSI_DT_DVB_FrequencyList:
		{
			freq_list_desc_t *desc = (freq_list_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(freq_list_desc_t));
			len = get_bits(8, &bs);
			desc->hdr.tag = tag;

			get_bits(6, &bs); /* skip reserved_future_use */
			desc->coding_type = get_bits(2, &bs);

			desc->num_freq = (len-1)/4;
			BDBG_MSG(("frequency list : %d", desc->coding_type));
			for (i=0; i<desc->num_freq; i++) {
				desc->frequency[i] = calc_frequency(desc->coding_type, get_bits_aligned(32, &bs));
				BDBG_MSG((" [%d] %d (%x)", i, desc->frequency[i], desc->frequency[i]));
			}
			break;
		}
		case TS_PSI_DT_DVB_LocalTimeOffset:
		{
			time_offset_desc_t *desc = (time_offset_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(time_offset_desc_t));

			len = get_bits(8, &bs);
			desc->hdr.tag = tag;

			desc->num_offset = len/13;
			if (desc->num_offset > MAX_TIMEOFFSET)
				desc->num_offset = MAX_TIMEOFFSET;

			for (i=0; i<desc->num_offset; i++) {
				desc->offsets[i].country[0] = get_bits(8, &bs);
				desc->offsets[i].country[1] = get_bits(8, &bs);
				desc->offsets[i].country[2] = get_bits(8, &bs);

				desc->offsets[i].region_id = get_bits(6, &bs);
				get_bits(1, &bs); /* skip reserved */
				desc->offsets[i].polarity = get_bits(1, &bs);
				idx = bs.bindex/8;
				desc->offsets[i].offset = BCD_TO_MIN(buf[idx], buf[idx+1]); 
				desc->offsets[i].toc = MJD_TO_TIME(buf[idx+2], buf[idx+3]) + 
						BCD_TO_SEC(buf[idx+4], buf[idx+5], buf[idx+6]);
				desc->offsets[i].next_offset = 	BCD_TO_MIN(buf[idx+7], buf[idx+8]);
				bs.bindex += 72;
			}
			break;
		}
		case TS_PSI_DT_DVB_SatelliteDelivery:
		{
			satellite_delivery_desc_t *desc = (satellite_delivery_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(satellite_delivery_desc_t));

			desc->hdr.tag = tag;
			len = get_bits(8, &bs);
			idx = bs.bindex/8;
			BDBG_WRN(("satellite : %x%x%x.%x%x%x%x%x", 	buf[idx], buf[idx+1], buf[idx+2],
				buf[idx+3], buf[idx+4], buf[idx+5], buf[idx+6], buf[idx+7]));
			break;
		}
		case TS_PSI_DT_DVB_BouquetName:
		{
			bouquet_name_desc_t *desc = (bouquet_name_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(bouquet_name_desc_t));

			desc->hdr.tag = tag;
			len = get_bits(8, &bs);
			if (len) {
				BKNI_Memcpy(desc->bouquet_name, (uint8_t *)&buf[bs.bindex/8], (len>MAX_NAME_LEN)?MAX_NAME_LEN:len);
			}
			break;
		}
		case TS_PSI_DT_DVB_Teletext:
		case TS_PSI_DT_DVB_VBI_Teletext:
		{
			teletext_desc_t *desc = (teletext_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(teletext_desc_t));

			desc->hdr.tag = tag;
			len = get_bits(8, &bs);
			for (i=0; i<3; i++)
				desc->lang[i] = get_bits(8, &bs);
			desc->type = get_bits(5, &bs);
			desc->magazine = get_bits(3, &bs);
			desc->page = get_bits(8, &bs);
			break;
		}
		case TS_PSI_DT_DVB_Subtitling:
		{
			subtitling_desc_t *desc = (subtitling_desc_t *)hdr;
			BKNI_Memset(desc, 0, sizeof(subtitling_desc_t));

			desc->hdr.tag = tag;
			len = get_bits(8, &bs);
			for (i=0; i<3; i++) 
				desc->lang[i] = get_bits(8, &bs);
			desc->type = get_bits(8, &bs);
			desc->composition_page = get_bits(16, &bs);
			desc->ancillary_page = get_bits(16, &bs);
			break;
		}
		case TS_PSI_DT_DVB_DataBroadcast:
		case TS_PSI_DT_DVB_Stuffing:
		case TS_PSI_DT_DVB_VBI_Data:
		case TS_PSI_DT_DVB_CountryAvailablity:
		case TS_PSI_DT_DVB_NVOD_Reference:
		case TS_PSI_DT_DVB_TimeShiftedService:
		case TS_PSI_DT_DVB_Mosaic:
		case TS_PSI_DT_DVB_StreamIdentifier:
		case TS_PSI_DT_DVB_Telephone:
		case TS_PSI_DT_DVB_MultilingualNetworkName:
		case TS_PSI_DT_DVB_MultilingualBouquetName:
		case TS_PSI_DT_DVB_MultilingualServiceName:
		case TS_PSI_DT_DVB_MultilingualComponent:
		case TS_PSI_DT_DVB_ServiceMove:
		case TS_PSI_DT_DVB_ShortSmoothingBuffer:
		case TS_PSI_DT_DVB_PartialTransportStream:
		case TS_PSI_DT_DVB_Scrambling:
		case TS_PSI_DT_DVB_DataBroadcastID:
		case TS_PSI_DT_DVB_TransportStream:
		case TS_PSI_DT_DVB_DSNG:
		case TS_PSI_DT_DVB_AC3:
		case TS_PSI_DT_DVB_AncillaryData:
		case TS_PSI_DT_DVB_CellList:
		case TS_PSI_DT_DVB_CellFrequencyLink:
		case TS_PSI_DT_DVB_AnnouncementSupport:
		case TS_PSI_DT_DVB_ApplicationSignalling:
		case TS_PSI_DT_DVB_AdaptationFieldData:
		case TS_PSI_DT_DVB_ServiceIdentifier:
		case TS_PSI_DT_DVB_ServiceAvailability:
		case TS_PSI_DT_DVB_DefaultAuthority:
		case TS_PSI_DT_DVB_RelatedContent:
		case TS_PSI_DT_DVB_TVA_ID:
		case TS_PSI_DT_DVB_ContentIdentifier:
		case TS_PSI_DT_DVB_TimeSliceFEC:
		case TS_PSI_DT_DVB_ECMRepetitionRate:
		case TS_PSI_DT_DVB_S2SatelliteDeliverySystem:
		case TS_PSI_DT_DVB_EnhancedAC3:
		case TS_PSI_DT_DVB_DTS:
		case TS_PSI_DT_DVB_AAC:
		case TS_PSI_DT_DVB_DRA:	
		default:
			break;
	}
}

static void dump_dvb_content(uint8_t content)
{
	switch (content&0xF0)
	{
		case 0x10: BDBG_MSG(("Movie/Drama (0x%x)", content&0x0F)); break;
		case 0x20: BDBG_MSG(("News/Current affairs (0x%x)", content&0x0F)); break;
		case 0x30: BDBG_MSG(("Show/Game show (0x%x)", content&0x0F)); break;
		case 0x40: BDBG_MSG(("Sports (0x%x)", content&0x0F)); break;
		case 0x50: BDBG_MSG(("Children's/Youth Programmes (0x%x)", content&0x0F)); break;
		case 0x60: BDBG_MSG(("Music/Ballet/Dance (0x%x)", content&0x0F)); break;
		case 0x70: BDBG_MSG(("Arts/Culture (0x%x)", content&0x0F)); break;
		case 0x80: BDBG_MSG(("Social/Political Issues/Economics (0x%x)", content&0x0F)); break;
		case 0x90: BDBG_MSG(("Education/Science/Factual topics (0x%x)", content&0x0F)); break;
		case 0xA0: case 0xB0: BDBG_MSG(("Leisure hobbies (0x%x)", content&0x0F)); break;
		default: break;
	}
}