Context Navigation

DST_Parser.cpp

Last change on this file was 2, checked in by phkim, 11 years ago

1.phkim

revision copy newcon3sk r27

File size: 99.5 KB

Rev	Line
[2]	1	#include "DST_Parser.h"
	2
	3	#define DHL_FAIL_NULL_POINTER 0x02
	4	#define DHL_FAIL_INVALID_SIZE 0x07
	5	#define DHL_FAIL_INVALID_PARAM 0x08
	6	#define DHL_FAIL_OUT_OF_RESOURCE 0x0A
	7	#define DHL_FAIL_INVALID_TABLEID 0x23
	8	#define DHL_FAIL_INVALID_VERSION 0x24
	9
	10	#ifndef SysASSERT
	11	#ifdef DTAR
	12	#define SysASSERT(cond) do { if (!((cond)) { fprintf(stderr, "\|%s:%d\| ASSERT failed.\n", __FUNCTION__, __LINE__); } } while(0)
	13	#else
	14	#define SysASSERT(cond)
	15	#endif
	16	#endif
	17
	18	#define checkMemoryError(p) if (p == 0) {err = DHL_FAIL_OUT_OF_RESOURCE ; goto ParseExit;}
	19
	20
	21	#if 0
	22	____MEM_CHAIN____()
	23	#endif
	24
	25	typedef struct memElement {
	26	void* userData;
	27	struct memElement *next;
	28	} memElement_t, *memElementPtr_t;
	29
	30	typedef struct memChainHead {
	31	memElementPtr_t element;
	32	} memChainHead_t, *memChainHeadPtr_t;
	33
	34	typedef struct memChainHead* memId_t;
	35
	36	/* API */
	37	#define memChainCreate(a) _memChainCreate((a), __func__, __LINE__)
	38	#define memChainDestroy(a) _memChainDestroy((a), __func__, __LINE__)
	39	#define memChainAlloc(a, b) _memChainAlloc((a), (b), __func__, __LINE__)
	40
	41	static int _memChainCreate (memId_t memId, const char func, int nLine)
	42	{
	43	if (memId == 0) return DHL_FAIL_INVALID_PARAM;
	44	memChainHeadPtr_t memChainHeadPtr = (memChainHeadPtr_t)_DST_OS_Calloc(sizeof(memChainHead_t), 1, func, nLine);
	45	if (memChainHeadPtr == 0) return DHL_FAIL_OUT_OF_RESOURCE;
	46	memChainHeadPtr->element = 0;
	47	memId = memChainHeadPtr; / set instance */
	48	return 0;
	49	}
	50
	51	static void _memChainDestroy (memId_t memId, const char *func, int nLine)
	52	{
	53	if (!memId) return;
	54	memChainHeadPtr_t memChainHeadPtr = (memChainHeadPtr_t)memId;
	55	/* free the memElements */
	56	memElementPtr_t currElem = memChainHeadPtr->element;
	57	while (currElem != 0) {
	58	memElementPtr_t prevElem = currElem;
	59	currElem = currElem->next;
	60	_DST_OS_Free(prevElem , func, nLine);
	61	}
	62	/* lastly, free the memChainHead */
	63	_DST_OS_Free(memChainHeadPtr , func, nLine);
	64	}
	65
	66	static void* _memChainAlloc (memId_t memId, DS_U32 size, const char *func, int nLine)
	67	{
	68	memElementPtr_t memElementPtr = (memElementPtr_t)_DST_OS_Calloc(sizeof(memElement_t) + size + 8, 1, func, nLine);
	69	if (memElementPtr == 0) return 0;
	70
	71	void p = (void )(((DS_U8 *)(memElementPtr) + sizeof(memElement_t)));
	72	/* align on 64-bit boundary */
	73	memElementPtr->userData = (void )((DS_U32)(((DS_U8 )p)+8) & ((~0) << 3));
	74	void *rptr = memElementPtr->userData;
	75	/* insert element in list */
	76	memChainHeadPtr_t memChainHeadPtr = (memChainHeadPtr_t)memId;
	77	memElementPtr->next = memChainHeadPtr->element;
	78	memChainHeadPtr->element = memElementPtr;
	79	return (rptr);
	80	}
	81
	82	#if 0
	83	____PAT____()
	84	#endif
	85
	86	int DHL_PSI_ParsePAT( DS_U8 sectionArr, MPEG_PAT returnPat)
	87	{
	88	if (sectionArr == 0 \|\| sectionArr[0] == 0 \|\| returnPat == 0) return (DHL_FAIL_NULL_POINTER);
	89	int numSections = get_last_section_number(sectionArr[0]) + 1;
	90
	91	/* now verify all other sections are present */
	92	for (int i = 1; i < numSections; i++) if (sectionArr[i] == 0) return (DHL_FAIL_NULL_POINTER);
	93
	94	int numPrograms = 0;
	95	int err = 0;
	96	for (int i = 0; i < numSections; ++i)
	97	{
	98	DS_U8 *p = sectionArr[i];
	99	if (p[SECTION_TID] != PROGRAM_ASSOCIATION_SECTION)
	100	{
	101	//This thing isn't a PAT. Stop right here.
	102	DST_Printf("PAT: Bad table ID.");
	103	err = DHL_FAIL_INVALID_TABLEID;
	104	break;
	105	}
	106	if ((p[SECTION_LEN_HI] & 0x80) != 0x80)
	107	{
	108	DST_Printf("PAT: section_syntax_indicator not set");
	109	}
	110	if ((p[SECTION_LEN_HI] & 0x40) != 0x00)
	111	{
	112	DST_Printf("PAT: private_indicator set");
	113	}
	114	if (i > p[SECTION_NUM_LAST])
	115	{
	116	DST_Printf("PAT: last_section_number > section_number");
	117	}
	118	/*
	119	* The PAT has a fixed number of bytes in its main loop with no
	120	* descriptors. We have the standard 8 byte header and the trailing
	121	* 4 byte CRC. The rest should be an integral number of programs.
	122	*/
	123	int len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3;
	124	if (len < 16 \|\| (len - 12) % 4 != 0)
	125	{
	126	DST_Printf("PAT: Inappropriate section length(%d)\n",len);
	127	//LEON_20050916 \| ADD for add patch
	128	// - hangup when input abnormal PAT section.
	129	err = DHL_FAIL_INVALID_TABLEID;
	130	break;
	131	}
	132	int slots = (len - 12) / 4;
	133	p += SECTION_HEADER_LENGTH;
	134	for (int j = 0; j < slots; ++j, p += 4) {
	135	int program_number = (p[0] << 8) + p[1];
	136	if (program_number != 0)
	137	{
	138	numPrograms++;
	139	}
	140	}
	141	}
	142	if (err) return err;
	143	/* create the memChain */
	144	memId_t memId = 0;
	145	err = memChainCreate(&memId);
	146	if (err) return err;
	147
	148	MPEG_PAT pat = (MPEG_PAT )((memId_t *)(memChainAlloc(memId,sizeof(MPEG_PAT)+sizeof(memId_t))) + 1);
	149	if (pat == 0)
	150	{
	151	memChainDestroy(memId);
	152	return DHL_FAIL_OUT_OF_RESOURCE;
	153	}
	154
	155	pat->programs = (MPEG_PAT_program )memChainAlloc(memId,sizeof(MPEG_PAT_program)numPrograms);
	156	if (pat->programs == 0)
	157	{
	158	memChainDestroy(memId);
	159	return DHL_FAIL_OUT_OF_RESOURCE;
	160	}
	161
	162	pat->section_number = 0;
	163	pat->last_section_number = 0;
	164	pat->isWholePAT = true;
	165
	166	/*
	167	* Second pass, we fill in the table.
	168	* We assume that everything we verified or warned about above is still
	169	* true. We already bailed out on fatal errors
	170	*/
	171	int index = 0;
	172	for (int i = 0; i < numSections; ++i)
	173	{
	174	DS_U8 *p = sectionArr[i];
	175	int len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3;
	176
	177	int transport_stream_id = ((p[SECTION_TID_EXT_HI] << 8) \|
	178	p[SECTION_TID_EXT_LO]);
	179	int version_number = (p[SECTION_VERSION] & SECTION_VERSION_MASK) >>
	180	SECTION_VERSION_SHIFT;
	181	bool current_next_indicator = (p[SECTION_VERSION] & SECTION_CNI_MASK) != 0;
	182
	183	if (i == 0)
	184	{
	185	pat->transport_stream_id = transport_stream_id;
	186	pat->version_number = version_number;
	187	pat->current_next_indicator = current_next_indicator;
	188	}
	189	else
	190	{
	191	if (pat->transport_stream_id != transport_stream_id)
	192	{
	193	DST_Printf("PAT: Inconsistent transport_stream_id");
	194	}
	195	if(pat->version_number != version_number)
	196	{
	197	DST_Printf("ParsePAT: inconsistent version_number");
	198	}
	199	if(pat->current_next_indicator != current_next_indicator)
	200	{
	201	DST_Printf("ParsePAT: inconsistent current_next_indicator");
	202	}
	203	}
	204	int slots = (len - 12) / 4;
	205	p += SECTION_HEADER_LENGTH;
	206	for (int j = 0; j < slots; ++j, p += 4)
	207	{
	208	int program_number = (p[0]<<8) + p[1];
	209	int pid = ((p[2]<<8) + p[3]) & PID_MASK;
	210	if (program_number == 0)
	211	{
	212	if (pat->networkPIDPresent)
	213	{
	214	DST_Printf("PAT: More than one network_PID");
	215	}
	216	else
	217	{
	218	pat->networkPIDPresent = true;
	219	pat->network_PID = pid;
	220	}
	221	}
	222	else
	223	{
	224	bool bDuplicate = false;
	225	for (int k = 0; k < index; ++k)
	226	{
	227	if (pat->programs[k].program_number != program_number) continue;
	228	DST_Printf("PAT: Duplicate program number");
	229	bDuplicate = true;
	230	break;
	231	}
	232	if (bDuplicate == false)
	233	{
	234	pat->programs[index].program_number = program_number;
	235	pat->programs[index].program_map_PID = pid;
	236	index++;
	237	}
	238	}
	239	}
	240	}
	241	pat->numPrograms = index;
	242	(((memId_t )pat)-1) = memId;
	243	*returnPat = pat;
	244	return(err);
	245	}
	246
	247	#if 0
	248	____SDT____()
	249	#endif
	250
	251	static int GetMpegDescriptor (DS_U8 *descriptors, DS_U16 len, DS_U8 tag,
	252	DS_U16 instance, DS_U8 **descriptor)
	253	{
	254	if (descriptors == 0 \|\| len == 0 \|\| descriptor == 0) return DHL_FAIL_INVALID_PARAM;
	255
	256	DS_U16 nCount = 0;
	257	int nPos = 0;
	258	while (nPos < len)
	259	{
	260	DS_U8 nTag = descriptors[nPos];
	261	DS_U8 nLen = descriptors[nPos+1];
	262	if (nPos + nLen + 2 > len) break; // ÀÔ·ÂµÈµ¥ÀÌÅÍÀÇ ¹üÀ§¸¦ ¹ù¾î³ª µ¥ÀÌÅÍ°¡ ÀÖ´Â°æ¿ì
	263	if (nTag == tag)
	264	{
	265	if (nCount == instance)
	266	{
	267	*descriptor = &descriptors[nPos];
	268	return 0;
	269	}
	270	nCount++;
	271	}
	272	nPos += (nLen + 2);
	273	}
	274	return DHL_FAIL_INVALID_PARAM;
	275	}
	276
	277	static int GetMpegDescriptorCount (DS_U8 *descriptors, DS_U16 len, DS_U8 tag)
	278	{
	279	if (descriptors == 0 \|\| len == 0) return 0;
	280
	281	int nCount = 0;
	282	int nPos = 0;
	283	while (nPos < len)
	284	{
	285	DS_U8 nTag = descriptors[nPos];
	286	DS_U8 nLen = descriptors[nPos+1];
	287	if (nPos + nLen + 2 > len) break; // ÀÔ·ÂµÈµ¥ÀÌÅÍÀÇ ¹üÀ§¸¦ ¹ù¾î³ª µ¥ÀÌÅÍ°¡ ÀÖ´Â°æ¿ì
	288	if (nTag == tag) nCount++;
	289	nPos += (nLen + 2);
	290	}
	291	return nCount;
	292	}
	293
	294	static void DHL_PSI_ParseServiceDescriptor(DS_U8 p_desc, memId_t memId, dvb_service_descriptor_t *pp_service_desc)
	295	{
	296	if ( !p_desc \|\| !pp_service_desc ) return;
	297	dvb_service_descriptor_t p_service = (dvb_service_descriptor_t )memChainAlloc(memId, sizeof(dvb_service_descriptor_t));
	298	p_service->service_type = p_desc[2];
	299	p_service->i_provider_name_length = p_desc[3];
	300	p_service->p_provider_name = 0;
	301	if (p_service->i_provider_name_length)
	302	{
	303	p_service->p_provider_name = (DS_U8 *)memChainAlloc(memId, p_service->i_provider_name_length);
	304	memcpy( p_service->p_provider_name, &p_desc[4], p_service->i_provider_name_length );
	305	}
	306	p_service->i_service_name_length = p_desc[4+p_service->i_provider_name_length];
	307	p_service->p_service_name = 0;
	308	if (p_service->i_service_name_length)
	309	{
	310	p_service->p_service_name = (DS_U8 *)memChainAlloc(memId, p_service->i_service_name_length);
	311	memcpy( p_service->p_service_name, &p_desc[5+p_service->i_provider_name_length], p_service->i_service_name_length );
	312	}
	313	*pp_service_desc = p_service;
	314	}
	315
	316	static void DHL_PSI_ParseLogoTransmissionDescriptor( DS_U8 p, memId_t memId, arib_logo_transmission_descriptor_t *pp_logo_transmission )
	317	{
	318	DS_U8 len = p[1];
	319	if (len < 2) return;
	320	arib_logo_transmission_descriptor_t p_logo_transmission = (arib_logo_transmission_descriptor_t )memChainAlloc(memId, sizeof(arib_logo_transmission_descriptor_t));
	321	p_logo_transmission->logo_transmission_type = p[2];
	322	switch (p_logo_transmission->logo_transmission_type)
	323	{
	324	case 0x01:
	325	p_logo_transmission->logo_id = (( p[3] & 0x1 ) << 8 ) + p[4];
	326	p_logo_transmission->logo_version = (( p[5] & 0x7 ) << 8 ) + p[6];
	327	p_logo_transmission->download_data_id = ( p[7] << 8 ) + p[8];
	328	break;
	329	case 0x02:
	330	p_logo_transmission->logo_id = (( p[3] & 0x1 ) << 8 ) + p[4];
	331	break;
	332	case 0x03:
	333	p_logo_transmission->logo_char = (DS_U8 *)memChainAlloc(memId, len-1);
	334	memcpy(p_logo_transmission->logo_char, &p[3], len-2);
	335	p_logo_transmission->logo_char[len-2] = 0; // make null terminate
	336	break;
	337	}
	338	*pp_logo_transmission = p_logo_transmission;
	339	}
	340
	341	int DHL_PSI_ParseDvbSdt(DS_U8 sectionArr, bool b_actual, dvb_sdt_t pp_sdt)
	342	{
	343	if (!sectionArr \|\| !pp_sdt \|\| !sectionArr[0]) return DHL_FAIL_NULL_POINTER;
	344	int numSections = get_last_section_number(sectionArr[0]) + 1;
	345	/* now verify all other sections are present */
	346	for (int i = 1; i < numSections; i++) if (sectionArr[i] == 0) return DHL_FAIL_NULL_POINTER;
	347	// First pass, we verify section syntax and count the number of programs
	348	int numChannels = 0;
	349	for (int i = 0; i < numSections; ++i)
	350	{
	351	DS_U8 *p = sectionArr[i];
	352	if ( (b_actual && p[SECTION_TID] != DVB_TID_service_description_section_actual) \|\|
	353	(!b_actual && p[SECTION_TID] != DVB_TID_service_description_section_other) )
	354	{
	355	DST_Printf("SDT: Bad table ID. (0x%02X)\n", p[SECTION_TID]);
	356	return DHL_FAIL_INVALID_TABLEID;
	357	}
	358	if ((p[SECTION_LEN_HI] & 0x80) != 0x80) DST_Printf("SDT: section_syntax_indicator not set\n");
	359
	360	int len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3 - 4; // + header - crc
	361	int nPos = 11;
	362	while (len - nPos >= 5)
	363	{
	364	numChannels++;
	365	DS_U16 descriptor_length = ((p[nPos+3]<<8)+p[nPos+4]) & 0xFFF;
	366	nPos += (descriptor_length + 5);
	367	}
	368	}
	369	/* create the memChain */
	370	memId_t memId = 0;
	371	if (memChainCreate(&memId)) return DHL_FAIL_OUT_OF_RESOURCE;
	372
	373	dvb_sdt_t p_sdt = (dvb_sdt_t )((memId_t *)(memChainAlloc(memId,sizeof(dvb_sdt_t)+sizeof(memId_t))) + 1);
	374	if (!p_sdt)
	375	{
	376	memChainDestroy(memId);
	377	return DHL_FAIL_OUT_OF_RESOURCE;
	378	}
	379	p_sdt->numServices = numChannels;
	380	p_sdt->services = 0;
	381	if (numChannels)
	382	{
	383	p_sdt->services = (dvb_sdt_service_t )memChainAlloc(memId,sizeof(dvb_sdt_service_t)numChannels);
	384	if (!p_sdt->services)
	385	{
	386	memChainDestroy(memId);
	387	return DHL_FAIL_OUT_OF_RESOURCE;
	388	}
	389	}
	390	// Now fill-out all the remaining fields over the all sections.
	391	int index = 0;
	392	for (int i = 0; i < numSections; ++i)
	393	{
	394	DS_U8 *p = sectionArr[i];
	395	if (i == 0) /* First section */
	396	{
	397	p_sdt->transport_stream_id = ((p[SECTION_TID_EXT_HI] << 8) \| p[SECTION_TID_EXT_LO]);
	398	p_sdt->version_number = (p[SECTION_VERSION] & SECTION_VERSION_MASK) >> SECTION_VERSION_SHIFT;
	399	p_sdt->original_network_id = ((p[8]<<8) + p[9]);
	400	p_sdt->section_number = p[SECTION_NUM];
	401	p_sdt->last_section_number = p[SECTION_NUM_LAST];
	402	}
	403	int len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3 - 4;// + header - crc
	404	int nPos = 11;
	405	while (len - nPos >= 5)
	406	{
	407	dvb_sdt_service_t *p_service = &p_sdt->services[index];
	408	p_service->service_id = ((p[nPos+0]<<8)+p[nPos+1]);
	409	p_service->EIT_user_defined_flags = (p[nPos+2]>>2) & 0x07;
	410	p_service->EIT_schedule_flag = (p[nPos+2] & 0x02) ? true : false;
	411	p_service->EIT_present_following_flag = (p[nPos+2] & 0x01) ? true : false;
	412	p_service->running_status = (p[nPos+3]>>5) & 0x07;
	413	p_service->free_CA_mode = ((p[nPos+3]>>4) & 0x01) ? true : false;
	414	p_service->descriptor_length = ((p[nPos+3]<<8)+p[nPos+4]) & 0xFFF;
	415	p_service->descriptors = 0;
	416	if (p_service->descriptor_length)
	417	{
	418	p_service->descriptors = (DS_U8 *)memChainAlloc( memId, p_service->descriptor_length);
	419	if (!p_service->descriptors)
	420	{
	421	memChainDestroy(memId);
	422	return DHL_FAIL_OUT_OF_RESOURCE;
	423	}
	424	memcpy(p_service->descriptors, &p[nPos+5], p_service->descriptor_length);
	425	}
	426	DS_U8* p_desc = 0;
	427	int err=GetMpegDescriptor(p_service->descriptors, p_service->descriptor_length, DVB_TAG_service_descriptor, 0, &p_desc);
	428	p_service->p_service_desc = 0;
	429	if ( p_desc && err == 0 ) DHL_PSI_ParseServiceDescriptor( p_desc, memId, &(p_service->p_service_desc) );
	430	// Parse service_descriptor if available.
	431	p_desc = 0;
	432	err=GetMpegDescriptor( p_service->descriptors, p_service->descriptor_length, ARIB_TAG_logo_transmission_descriptor, 0, &p_desc );
	433	p_service->logo_tx_desc = 0;
	434	if ( p_desc && err == 0 ) DHL_PSI_ParseLogoTransmissionDescriptor( p_desc, memId, &(p_service->logo_tx_desc) );
	435
	436	index++;
	437	nPos += (p_service->descriptor_length + 5);
	438	}
	439	}
	440	(((memId_t )p_sdt)-1) = memId;
	441	*pp_sdt = p_sdt;
	442	return 0;
	443	}
	444
	445	void DHL_PSI_FreeMpegSection (void *sectionPtr)
	446	{
	447	if (sectionPtr) memChainDestroy((((memId_t )sectionPtr)-1));
	448	}
	449
	450	void DHL_PSI_ParseNetworkNameDescriptor(DS_U8 p_desc, memId_t memId, DS_U8 pp_network_name, DS_U8 p_length)
	451	{
	452	if (!p_desc \|\| !pp_network_name \|\| !p_length) return;
	453	*p_length = p_desc[1];
	454	pp_network_name = (DS_U8 )memChainAlloc( memId, *p_length);
	455	memcpy(pp_network_name, &p_desc[2], p_length);
	456	}
	457
	458	static int DHL_PSI_ParseSystemManagementDescriptor(DS_U8* p, DS_U16* p_system_management_id)
	459	{
	460	if (!p_system_management_id \|\| !p \|\| p[1] < 2) return -1;
	461	*p_system_management_id = (p[2]<<8) + p[3];
	462	return 0;
	463	}
	464
	465	static void DHL_PSI_ParseServiceListDescriptor(DS_U8 p_desc, memId_t memId, dvb_service_list_descriptor_t *pp_service_list)
	466	{
	467	(*pp_service_list) = 0;
	468	if (p_desc[1] < 3) return;
	469	(pp_service_list) = (dvb_service_list_descriptor_t )memChainAlloc(memId, sizeof(dvb_service_list_descriptor_t));
	470	(*pp_service_list)->numServices = p_desc[1]/3;
	471	(pp_service_list)->p_service = (dvb_service_t )memChainAlloc(memId, sizeof(dvb_service_t)((pp_service_list)->numServices));
	472	for (int i=0; i < (*pp_service_list)->numServices; i++)
	473	{
	474	(pp_service_list)->p_service[i].service_id = (p_desc[i3+2] << 8) + p_desc[i*3+3];
	475	(pp_service_list)->p_service[i].service_type = p_desc[i3+4];
	476	}
	477	}
	478
	479	static int DHL_PSI_ParseTSInformationDescriptor(DS_U8* p, memId_t memId, arib_ts_information_descriptor_t **pp_ts_info)
	480	{
	481	if (p[1] < 2) return DHL_FAIL_INVALID_SIZE;
	482
	483	arib_ts_information_descriptor_t p_ts_info = pp_ts_info = (arib_ts_information_descriptor_t *)memChainAlloc(memId,sizeof(arib_ts_information_descriptor_t));
	484	p_ts_info->remote_control_key_id = p[2];
	485	p_ts_info->ts_name_length = (p[3]>>2) & 0x3F;
	486	p_ts_info->transmission_type_count = p[3]&0x03;
	487
	488	if (p_ts_info->ts_name_length)
	489	{
	490	p_ts_info->ts_name = (DS_U8 *)memChainAlloc(memId, p_ts_info->ts_name_length);
	491	memcpy(p_ts_info->ts_name, &p[4], p_ts_info->ts_name_length);
	492	}
	493
	494	if (!p_ts_info->transmission_type_count) return 0;
	495
	496	arib_transmission_type_t p_tx_type = p_ts_info->transmission_type = (arib_transmission_type_t )memChainAlloc(memId, sizeof(arib_transmission_type_t)*p_ts_info->transmission_type_count);
	497	int off = 4 + p_ts_info->ts_name_length;
	498	for (int i=0; i < p_ts_info->transmission_type_count; i++)
	499	{
	500	p_tx_type[i].transmission_type_info = p[off];
	501	p_tx_type[i].number_of_service = p[off+1];
	502	p_tx_type[i].service_id = 0;
	503	off += 2;
	504	if (p_tx_type[i].number_of_service)
	505	{
	506	DS_U16 p_service_id = p_tx_type[i].service_id = (DS_U16 )memChainAlloc(memId, (p_tx_type[i].number_of_service) * sizeof(DS_U16));
	507	for (int j=0; j <p_tx_type[i].number_of_service; j++)
	508	{
	509	p_service_id[j] = (p[off]<<8)+p[off+1];
	510	off += 2;
	511	}
	512	}
	513	}
	514	return 0;
	515	}
	516
	517
	518	int DHL_PSI_ParseDvbNit(DS_U8 sectionArr, bool b_actual, dvb_nit_t pp_nit)
	519	{
	520	if (!sectionArr \|\| !pp_nit \|\| !sectionArr[0]) return DHL_FAIL_NULL_POINTER;
	521	int numSections = get_last_section_number(sectionArr[0]) + 1;
	522	/* now verify all other sections are present */
	523	for (int i=1; i<numSections; i++) if (sectionArr[i] == 0) return (DHL_FAIL_NULL_POINTER);
	524
	525	// First pass, we verify section syntax and count the number of programs
	526	int numStreams = 0;
	527	for (int i = 0; i < numSections; ++i)
	528	{
	529	DS_U8* p = sectionArr[i];
	530
	531	if ( (b_actual && p[SECTION_TID] != DVB_TID_network_information_section_actual) \|\|
	532	(!b_actual && p[SECTION_TID] != DVB_TID_network_information_section_other) )
	533	{
	534	DST_Printf("NIT: Bad table ID. (0x%02X)", p[SECTION_TID]);
	535	return DHL_FAIL_INVALID_TABLEID;
	536	}
	537
	538	if ((p[SECTION_LEN_HI] & 0x80) != 0x80) DST_Printf("NIT: section_syntax_indicator not set");
	539
	540	// Counts number of transport_stream.
	541	int network_descriptor_length = ((p[8]<<8) + p[9]) & 0xFFF;
	542	int transport_loop_length = ((p[10+network_descriptor_length]<<8) + p[11+network_descriptor_length]) & 0xFFF;
	543	p = &sectionArr[i][12+network_descriptor_length];
	544	for(int k=0; k<transport_loop_length; )
	545	{
	546	int original_network_id = ((p[k+2]<<8)+p[k+3]);
	547	if (original_network_id) numStreams++;
	548	int transport_descriptor_length = ((p[k+4]<<8)+p[k+5]) & 0xFFF;
	549	k += (6+transport_descriptor_length);
	550	}
	551	}
	552
	553	/* create the memChain */
	554	memId_t memId = 0;
	555	if (memChainCreate(&memId)) return DHL_FAIL_OUT_OF_RESOURCE;
	556
	557	dvb_nit_t p_nit = (dvb_nit_t )memChainAlloc(memId, sizeof(dvb_nit_t));
	558	if (!p_nit)
	559	{
	560	memChainDestroy(memId);
	561	return DHL_FAIL_OUT_OF_RESOURCE;
	562	}
	563	p_nit->num_transport_stream = numStreams;
	564	if (numStreams)
	565	{
	566	p_nit->transport_streams = (transport_stream_t )memChainAlloc(memId,sizeof(transport_stream_t)numStreams);
	567	if (!p_nit->transport_streams)
	568	{
	569	memChainDestroy(memId);
	570	return DHL_FAIL_OUT_OF_RESOURCE;
	571	}
	572	}
	573
	574	// Now fill-out all the remaining fields over the all sections.
	575	transport_stream_t *p_ts = p_nit->transport_streams;
	576	for (int i = 0; i < numSections; ++i)
	577	{
	578	DS_U8* p = sectionArr[i];
	579	int network_id = ((p[SECTION_TID_EXT_HI] << 8) \| p[SECTION_TID_EXT_LO]);
	580	int version_number = (p[SECTION_VERSION] & SECTION_VERSION_MASK) >> SECTION_VERSION_SHIFT;
	581	int network_descriptor_length = ((p[8]<<8) + p[9]) & 0xFFF;
	582	int last_section_number = p[SECTION_NUM_LAST];
	583
	584	if (i == 0) /* First section */
	585	{
	586	p_nit->network_id = network_id;
	587	p_nit->version_number = version_number;
	588	p_nit->section_number = p[SECTION_NUM];
	589	p_nit->last_section_number = last_section_number;
	590	p_nit->network_descriptor_length = network_descriptor_length;
	591	if (network_descriptor_length)
	592	{
	593	DS_U8 *p_desc = 0;
	594	p_nit->network_descriptors = (DS_U8 *)memChainAlloc(memId, network_descriptor_length);
	595	memcpy(p_nit->network_descriptors, &p[10], network_descriptor_length);
	596	int err=GetMpegDescriptor(p_nit->network_descriptors, network_descriptor_length, DVB_TAG_network_name_descriptor, 0, &p_desc);
	597	if (!err) DHL_PSI_ParseNetworkNameDescriptor( p_desc, memId, &(p_nit->p_network_name), &(p_nit->network_name_length) );
	598	err=GetMpegDescriptor( p_nit->network_descriptors, network_descriptor_length, ARIB_TAG_system_management_descriptor, 0, &p_desc );
	599	if (!err)
	600	{
	601	if (!DHL_PSI_ParseSystemManagementDescriptor( p_desc, &p_nit->system_management_id ))
	602	p_nit->b_system_management_id = true;
	603	}
	604	}
	605	}
	606	int transport_loop_length = ((p[10+network_descriptor_length]<<8) + p[11+network_descriptor_length]) & 0xFFF;
	607	p = &sectionArr[i][12+network_descriptor_length];
	608	for(int k=0; k < transport_loop_length; )
	609	{
	610	int original_network_id = ((p[k+2]<<8)+p[k+3]);
	611	int transport_descriptor_length = ((p[k+4]<<8)+p[k+5]) & 0xFFF;
	612	if (original_network_id)
	613	{
	614	p_ts->transport_stream_id = ((p[k+0]<<8)+p[k+1]);
	615	p_ts->original_network_id = original_network_id;
	616	p_ts->transport_descriptor_length = transport_descriptor_length;
	617	if ( transport_descriptor_length )
	618	{
	619	p_ts->transport_descriptors = (DS_U8 *)memChainAlloc( memId, transport_descriptor_length);
	620	if (!p_ts->transport_descriptors)
	621	{
	622	memChainDestroy(memId);
	623	return DHL_FAIL_OUT_OF_RESOURCE;
	624	}
	625	memcpy( p_ts->transport_descriptors, &p[k+6], transport_descriptor_length);
	626	DS_U8* p_desc = 0;
	627	int err=GetMpegDescriptor( p_ts->transport_descriptors, transport_descriptor_length,
	628	DVB_TAG_service_list_descriptor, 0, &p_desc );
	629	if (!err) DHL_PSI_ParseServiceListDescriptor( p_desc, memId, &(p_ts->p_service_list) );
	630	err=GetMpegDescriptor( p_ts->transport_descriptors, transport_descriptor_length,
	631	ARIB_TAG_ts_information_descriptor, 0, &p_desc );
	632	if (!err) DHL_PSI_ParseTSInformationDescriptor( p_desc, memId, &(p_ts->p_ts_info) );
	633	}
	634	p_ts++;
	635	}
	636	k += (6+transport_descriptor_length);
	637	}
	638	}
	639	(((memId_t )p_nit)-1) = memId;
	640	*pp_nit = p_nit;
	641	return 0;
	642	}
	643
	644	static void DHL_PSI_ParseSIParameterDescriptor( DS_U8 p, memId_t memId, arib_si_parameter_descriptor_t *pp_si_parameter )
	645	{
	646	*pp_si_parameter = 0;
	647	if ( p[1] < 3 ) return;
	648
	649	arib_si_parameter_descriptor_t p_si_parameter = pp_si_parameter = (arib_si_parameter_descriptor_t *)memChainAlloc(memId, sizeof(arib_si_parameter_descriptor_t));
	650	p_si_parameter->parameter_version = p[2];
	651	p_si_parameter->update_time = ( p[3] << 8 ) + p[4];
	652	if ( p[1] < 5) return;
	653	int numTable = 0;
	654	for (int i = 5; i <= p[1];)
	655	{
	656	int table_id = p[i];
	657	int table_description_length = p[i+1];
	658	if (table_id) numTable++;
	659	i += (2+table_description_length);
	660	}
	661	if (numTable == 0) return;
	662	p_si_parameter->numTable = numTable;
	663	arib_table_description_t p_table_description = p_si_parameter->table_description = (arib_table_description_t )memChainAlloc(memId, numTable*sizeof(arib_table_description_t));
	664	for (int i = 5; i <= p[1];)
	665	{
	666	int table_id = p[i];
	667	int table_description_length = p[i+1];
	668	if (table_id)
	669	{
	670	p_table_description->table_id = table_id;
	671	p_table_description->table_description_length = table_description_length;
	672	if (p_table_description->table_description_length)
	673	{
	674	p_table_description->table_description_byte = (DS_U8 *)memChainAlloc(memId, p_table_description->table_description_length);
	675	memcpy(p_table_description->table_description_byte, &p[i+2], p_table_description->table_description_length);
	676	}
	677	p_table_description++;
	678	}
	679	i += (2+table_description_length);
	680	}
	681	}
	682
	683	static void DHL_PSI_ParseExtendedBroadcasterDescriptor(DS_U8 p_desc, memId_t memId, arib_extended_broadcaster_descriptor_t *pp_ex_broad)
	684	{
	685	DS_U8 *p = p_desc;
	686	arib_extended_broadcaster_descriptor_t *p_ex_broad;
	687	int i, j, len, off;
	688	int num, numId;
	689
	690	if (!p_desc \|\| !pp_ex_broad \|\| !memId)
	691	return;
	692
	693	len = p_desc[1];
	694	if ( len<4 )
	695	return;
	696
	697	p_ex_broad = (arib_extended_broadcaster_descriptor_t *)memChainAlloc(memId, sizeof(arib_extended_broadcaster_descriptor_t));
	698	p_ex_broad->broadcaster_type = (p[2] >> 4) & 0x0F;
	699
	700	off = 3;
	701
	702	if ( p_ex_broad->broadcaster_type == 0x1 )
	703	{
	704	p_ex_broad->terrestrial_broadcaster_id = (p[off+0] << 8) + p[off+1];
	705	p_ex_broad->num_affiliation_id = (p[off+2] & 0xF0) >> 4;
	706	p_ex_broad->num_broadcaster_id = p[off+2] & 0xF;
	707	off += 3;
	708
	709	if ( p_ex_broad->num_affiliation_id )
	710	{
	711	num = p_ex_broad->num_affiliation_id;
	712	p_ex_broad->affiliation_id = (DS_U8 *)memChainAlloc(memId, num);
	713	memcpy(p_ex_broad->affiliation_id, &p[off], num);
	714	off += num;
	715	}
	716
	717	if ( p_ex_broad->num_broadcaster_id )
	718	{
	719	numId = p_ex_broad->num_broadcaster_id;
	720	p_ex_broad->origin_network_id = (DS_U16 )memChainAlloc(memId, numId2);
	721	p_ex_broad->broadcaster_id = (DS_U8 *)memChainAlloc(memId, numId);
	722
	723	for ( i=0, j=0 ; j < p_ex_broad->num_broadcaster_id ; i++, j+=3 )
	724	{
	725	p_ex_broad->origin_network_id[i] = (p[off+0] << 8) + p[off+1];
	726	p_ex_broad->broadcaster_id[i] = p[off+2];
	727	off += 3;
	728	p_ex_broad->origin_network_id++;
	729	p_ex_broad->broadcaster_id++;
	730	}
	731	}
	732	}
	733	else if ( p_ex_broad->broadcaster_type == 0x2 )
	734	{
	735	p_ex_broad->terrestrial_broadcaster_id = (p[off+0] << 8) + p[off+1];
	736	p_ex_broad->num_affiliation_id = (p[off+2] >> 4) & 0xF;
	737	p_ex_broad->num_broadcaster_id = p[off+2] & 0xF;
	738	off += 3;
	739
	740	if ( p_ex_broad->num_affiliation_id )
	741	{
	742	num = p_ex_broad->num_affiliation_id;
	743	p_ex_broad->affiliation_id = (DS_U8 *)memChainAlloc(memId, num);
	744	memcpy(p_ex_broad->affiliation_id, &p[off], num);
	745	off += num;
	746	}
	747
	748	if ( p_ex_broad->num_broadcaster_id )
	749	{
	750	numId = p_ex_broad->num_broadcaster_id;
	751	p_ex_broad->origin_network_id = (DS_U16 )memChainAlloc(memId, numId2);
	752	p_ex_broad->broadcaster_id = (DS_U8 *)memChainAlloc(memId, numId);
	753
	754	for ( i=0, j=0 ; j < p_ex_broad->num_broadcaster_id ; i++, j+=3 )
	755	{
	756	p_ex_broad->origin_network_id[i] = (p[off+0] << 8) + p[off+1];
	757	p_ex_broad->broadcaster_id[i] = p[off+2];
	758	off += 3;
	759	p_ex_broad->origin_network_id++;
	760	p_ex_broad->broadcaster_id++;
	761	}
	762	}
	763	}
	764	else
	765	{
	766	p_ex_broad->affiliation_id = (DS_U8 *)0;
	767	p_ex_broad->origin_network_id = (DS_U16 *)0;
	768	p_ex_broad->broadcaster_id = (DS_U8 *)0;
	769	}
	770
	771	*pp_ex_broad = p_ex_broad;
	772	}
	773
	774	int DHL_PSI_ParseDvbBit(DS_U8 sectionArr, dvb_bit_t pp_bit)
	775	{
	776	int err = 0;
	777	int i, k;
	778	int len, lenBroadcaster;
	779	int numBroadcaster;
	780	int numSections;
	781	// int index;
	782	const DS_U8 *p;
	783	dvb_bit_t *p_bit = 0;
	784	int version_number;
	785	int first_descriptor_length;
	786	// bool current_next_indicator;
	787	// bool broadcast_view_propriety;
	788	memId_t memId = 0;
	789	// memChainSetup_t memSetup = {MEM_LIMIT,0,0};
	790	broadcaster_t *p_broadcaster;
	791
	792	if ((sectionArr == 0) \|\| (pp_bit == 0))
	793	{
	794	return (DHL_FAIL_NULL_POINTER);
	795	}
	796
	797	if (sectionArr[0] == 0)
	798	{
	799	return (DHL_FAIL_NULL_POINTER);
	800	}
	801	else
	802	{
	803	numSections = get_last_section_number(sectionArr[0]) + 1;
	804	}
	805
	806	/* now verify all other sections are present */
	807	for (i=1; i<numSections; i++)
	808	{
	809	if (sectionArr[i] == 0) {
	810	return (DHL_FAIL_NULL_POINTER);
	811	}
	812	}
	813
	814	/*
	815	* First pass, we verify section syntax and count the number of broadcaster.
	816	*/
	817	numBroadcaster = 0;
	818	for (i = 0; i < numSections; ++i)
	819	{
	820	p = sectionArr[i];
	821
	822	if( p == 0 )
	823	{
	824	DST_Printf( "%s: 0 section", __func__);
	825	return DHL_FAIL_NULL_POINTER;
	826	}
	827
	828	if ( p[SECTION_TID] != DVB_TID_broadcaster_information_section )
	829	{
	830	/*
	831	* This thing isn't a PAT. Stop right here.
	832	*/
	833	DST_Printf("BIT: Bad table ID. (0x%02X)", p[SECTION_TID]);
	834	err = DHL_FAIL_INVALID_TABLEID;
	835	goto ParseExit;
	836	}
	837
	838	if ((p[SECTION_LEN_HI] & 0x80) != 0x80)
	839	{
	840	DST_Printf("BIT: section_syntax_indicator not set");
	841	}
	842
	843	len = ((p[1]<<8) + p[2]) & 0xFFF;
	844
	845	/*
	846	* Counts number of broadcaster.
	847	*/
	848	// broadcast_view_propriety = ((p[8] >> 4) & 0x1);
	849	first_descriptor_length = ((p[8]<<8) + p[9]) & 0xFFF;
	850	lenBroadcaster = len - (7+first_descriptor_length+4);
	851	p = &sectionArr[i][10+first_descriptor_length];
	852
	853	for ( k=0 ; k < lenBroadcaster ; )
	854	{
	855	int broadcaster_id;
	856	int broadcaster_descriptor_length;
	857
	858	broadcaster_id = p[k+0];
	859	broadcaster_descriptor_length = ((p[k+1]<<8) + p[k+2]) & 0xFFF;
	860
	861	if ( broadcaster_id )
	862	numBroadcaster++;
	863
	864	k += 3+broadcaster_descriptor_length;
	865	}
	866	}
	867
	868	/* create the memChain */
	869	err = memChainCreate(&memId);
	870
	871	if (err)
	872	{
	873	goto ParseExit;
	874	}
	875
	876	p_bit = (dvb_bit_t )((memId_t )(memChainAlloc(memId,sizeof(dvb_bit_t)+sizeof(memId_t))) + 1);
	877	checkMemoryError(p_bit);
	878
	879	p_bit->num_broadcaster = numBroadcaster;
	880
	881	if ( numBroadcaster > 0 )
	882	{
	883	p_bit->broadcaster = (broadcaster_t )memChainAlloc(memId,sizeof(broadcaster_t)numBroadcaster);
	884	checkMemoryError(p_bit->broadcaster);
	885	}
	886	else
	887	{
	888	p_bit->broadcaster = (broadcaster_t *)0;
	889	}
	890
	891	/*
	892	* Now fill-out all the remaining fields over the all sections.
	893	*/
	894	// index = 0;
	895	p_bit->first_descriptors = (DS_U8 *)0;
	896	p_broadcaster = p_bit->broadcaster;
	897
	898	for (i = 0 ; i < numSections ; ++i)
	899	{
	900	DS_U8 last_section_number;
	901	int original_network_id;
	902
	903	p = &sectionArr[i][0];
	904	len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3; // lenth + 3 ( p[0] (TID) + p[1] + p[2] )
	905
	906	original_network_id = ((p[SECTION_TID_EXT_HI] << 8) \| p[SECTION_TID_EXT_LO]);
	907	version_number = (p[SECTION_VERSION] & SECTION_VERSION_MASK) >>
	908	SECTION_VERSION_SHIFT;
	909	// current_next_indicator = (p[SECTION_VERSION] & SECTION_CNI_MASK) != 0;
	910	first_descriptor_length = ((p[8]<<8) + p[9]) & 0xFFF;
	911	last_section_number = p[SECTION_NUM_LAST];
	912
	913	if (i == 0)
	914	{
	915	/* First section */
	916	p_bit->original_network_id = original_network_id;
	917	p_bit->version_number = version_number;
	918	p_bit->section_number = p[SECTION_NUM];
	919	p_bit->last_section_number = last_section_number;
	920
	921	if ( p_bit->first_descriptors == (DS_U8 *)0 && first_descriptor_length )
	922	{
	923	DS_U8 p_desc = (DS_U8 )0;
	924
	925	p_bit->first_descriptor_length = first_descriptor_length;
	926	p_bit->first_descriptors = (DS_U8 *)memChainAlloc(memId, first_descriptor_length);
	927	memcpy(p_bit->first_descriptors, &p[10], first_descriptor_length);
	928	/*
	929	* Parse SI Parameter Descriptor
	930	*/
	931	err = GetMpegDescriptor( p_bit->first_descriptors,
	932	first_descriptor_length,
	933	ARIB_TAG_si_parameter_descriptor,
	934	0, /* only find first one. */
	935	&p_desc );
	936
	937	if ( p_desc && !err )
	938	{
	939	DHL_PSI_ParseSIParameterDescriptor( p_desc, memId, &(p_bit->p_si_parameter));
	940	}
	941	else
	942	{
	943	// DST_Printf("BIT: cannot find si_parameter descriptor.\n");
	944	p_bit->p_si_parameter = (arib_si_parameter_descriptor_t *)0;
	945	}
	946
	947	}
	948	}
	949	else
	950	{
	951	if (p_bit->original_network_id != original_network_id)
	952	DST_Printf("BIT: Inconsistent original_network_id (0x%x, 0x%x)\n", p_bit->original_network_id, original_network_id);
	953	if (p_bit->version_number != version_number)
	954	DST_Printf("BIT: inconsistent version_number (0x%x, 0x%x)\n", p_bit->version_number, version_number);
	955	if (p_bit->first_descriptor_length != first_descriptor_length)
	956	DST_Printf("BIT: Inconsistent first_descriptor_length (0x%x, 0x%x)\n", p_bit->first_descriptor_length, first_descriptor_length );
	957	if (p_bit->last_section_number != last_section_number )
	958	DST_Printf("BIT: Inconsistent last_section_number (0x%x, 0x%x)\n", p_bit->last_section_number, last_section_number);
	959	}
	960
	961	lenBroadcaster = len - first_descriptor_length - 4 - 3 - 7;
	962
	963	if ( !p_broadcaster && lenBroadcaster )
	964	{
	965	DST_Printf("BIT: broadcaster length is not 0, but broadcaster is 0.\n");
	966	err = DHL_FAIL_INVALID_TABLEID;
	967	goto ParseExit;
	968
	969	}
	970
	971	p = &sectionArr[i][10+first_descriptor_length];
	972
	973	for ( k = 0 ; k < lenBroadcaster ; )
	974	{
	975	int broadcaster_id;
	976	int broadcaster_descriptor_length;
	977
	978	broadcaster_id = p[k+0];
	979	broadcaster_descriptor_length = ((p[k+1]<<8) + p[k+2]) & 0xFFF;
	980	p_broadcaster->broadcaster_id = broadcaster_id;
	981	p_broadcaster->broadcaster_descriptor_length = broadcaster_descriptor_length;
	982
	983	if ( broadcaster_descriptor_length )
	984	{
	985	DS_U8 p_desc = (DS_U8 )0;
	986
	987	p_broadcaster->broadcaster_descriptors = (DS_U8 *)memChainAlloc(memId, broadcaster_descriptor_length);
	988
	989	if ( !(p_broadcaster->broadcaster_descriptors) )
	990	{
	991	err = DHL_FAIL_OUT_OF_RESOURCE;
	992	goto ParseExit;
	993	}
	994
	995	memcpy(p_broadcaster->broadcaster_descriptors, &p[k+3], broadcaster_descriptor_length);
	996
	997	/*
	998	* Parse Extended Broadcaster Descriptor
	999	*/
	1000	err = GetMpegDescriptor( p_broadcaster->broadcaster_descriptors,
	1001	broadcaster_descriptor_length,
	1002	ARIB_TAG_extended_broadcaster_descriptor,
	1003	0, /* only find first one. */
	1004	&p_desc );
	1005
	1006	if ( p_desc && !err )
	1007	{
	1008	DHL_PSI_ParseExtendedBroadcasterDescriptor(p_desc, memId, &(p_broadcaster->p_ex_broad));
	1009	}
	1010	else
	1011	{
	1012	// DST_Printf("BIT: cannot find extended_broadcaster descriptor.\n");
	1013	p_broadcaster->p_ex_broad = (arib_extended_broadcaster_descriptor_t *)0;
	1014	}
	1015
	1016	p_desc = (DS_U8 *)0;
	1017
	1018	/*
	1019	* Parse SI Parameter Descriptor
	1020	*/
	1021	err = GetMpegDescriptor( p_broadcaster->broadcaster_descriptors,
	1022	broadcaster_descriptor_length,
	1023	ARIB_TAG_si_parameter_descriptor,
	1024	0, /* only find first one. */
	1025	&p_desc );
	1026
	1027	if ( p_desc && !err )
	1028	{
	1029	DHL_PSI_ParseSIParameterDescriptor( p_desc, memId, &(p_broadcaster->p_si_parameter));
	1030	}
	1031	else
	1032	{
	1033	// DST_Printf("BIT: cannot find si_parameter descriptor.\n");
	1034	p_broadcaster->p_si_parameter = (arib_si_parameter_descriptor_t *)0;
	1035	}
	1036	}
	1037	else
	1038	{
	1039	p_broadcaster->broadcaster_descriptors = (DS_U8 *)0;
	1040	p_broadcaster->p_ex_broad = (arib_extended_broadcaster_descriptor_t *)0;
	1041	p_broadcaster->p_si_parameter = (arib_si_parameter_descriptor_t *)0;
	1042	}
	1043
	1044	k += 3+broadcaster_descriptor_length;
	1045	p_broadcaster++;
	1046	}
	1047	}
	1048
	1049	err = 0;
	1050	(((memId_t )p_bit)-1) = memId;
	1051	DST_Printf("p_bit = 0x%x\n",(int)memId);
	1052	*pp_bit = p_bit;
	1053	memId = 0; /* Don't delete below */
	1054
	1055	ParseExit:
	1056	if (memId)
	1057	{
	1058	/* delete the patSection memory */
	1059	memChainDestroy(memId);
	1060	}
	1061
	1062	return(err);
	1063	}
	1064
	1065	static void DHL_PSI_ParseLocalTimeOffsetDescriptor( DS_U8 p, int numItems, dvb_local_time_t p_desc )
	1066	{
	1067	int len, idx;
	1068	int num_lto;
	1069	dvb_local_time_t *p_lt;
	1070	DS_U8 *puc;
	1071
	1072	if ( !p \|\| !p_desc )
	1073	return;
	1074
	1075	len = p[1];
	1076	num_lto = len / 13;
	1077
	1078	p_lt = p_desc;
	1079	for (idx=0; idx<num_lto; idx++)
	1080	{
	1081	puc = &p[idx*13 + 2];
	1082
	1083	p_lt->country_code = (puc[2]<<16)+(puc[1]<<8)+puc[0];
	1084	p_lt->country_region_id = puc[3]>>2;
	1085	p_lt->local_time_offset_polarity = puc[3] & 1;
	1086	p_lt->local_time_offset = (puc[4]<<8)+puc[5];
	1087	p_lt->time_of_change_date = (puc[6]<<8)+puc[7];
	1088	p_lt->time_of_change_time = (puc[8]<<16)+(puc[9]<<8)+puc[10];
	1089	p_lt->next_time_offset = (puc[11]<<8)+puc[12];
	1090
	1091	p_lt++;
	1092	}
	1093	}
	1094
	1095	int DHL_PSI_ParseDvbTot(DS_U8 sectionArr, dvb_tot_t *pp_tot)
	1096	{
	1097	int err = 0;
	1098	const DS_U8 *p;
	1099	int len, descriptor_length;
	1100	dvb_tot_t *p_tot = 0;
	1101	memId_t memId = 0;
	1102	// memChainSetup_t memSetup = {MEM_LIMIT,0,0};
	1103
	1104	if (sectionArr == 0 \|\| (pp_tot == 0))
	1105	{
	1106	return (DHL_FAIL_NULL_POINTER);
	1107	}
	1108
	1109	p = sectionArr;
	1110	if ( p[SECTION_TID] != DVB_TID_time_offset_section )
	1111	{
	1112	/*
	1113	* This thing isn't a TDT. Stop right here.
	1114	*/
	1115	DST_Printf("TOT: Bad table ID. (0x%02X)\n", p[SECTION_TID]);
	1116	err = DHL_FAIL_INVALID_TABLEID;
	1117	goto ParseExit;
	1118	}
	1119
	1120	if ((p[SECTION_LEN_HI] & 0x80) != 0x00) {
	1121	DST_Printf("TOT: section_syntax_indicator set\n");
	1122	}
	1123
	1124	len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3;
	1125	if ( len < 8 )
	1126	{
	1127	err = DHL_FAIL_INVALID_TABLEID;
	1128	goto ParseExit;
	1129	}
	1130
	1131	/* create the memChain */
	1132	err = memChainCreate(&memId);
	1133	if (err) {
	1134	goto ParseExit;
	1135	}
	1136
	1137	p_tot = (dvb_tot_t )((memId_t )(memChainAlloc(memId,sizeof(dvb_tot_t)+sizeof(memId_t))) + 1);
	1138	checkMemoryError(p_tot);
	1139
	1140	p_tot->date = (p[3]<<8)+p[4];
	1141	p_tot->time = (p[5]<<16)+(p[6]<<8)+p[7];
	1142
	1143	p_tot->p_lto = (dvb_local_time_offset_descriptor_t *)0;
	1144	p_tot->descriptor_length = 0;
	1145	p_tot->descriptors = (DS_U8 *)0;
	1146	if ( len >= 11 )
	1147	{
	1148	DS_U8 p_desc = (DS_U8 )0;
	1149	dvb_local_time_t *p_lt;
	1150	int numLocaltime;
	1151
	1152	descriptor_length = ((p[8]<<8)+p[9]) & 0xFFF;
	1153	if ( descriptor_length > 1024 )
	1154	{
	1155	DST_Printf("TOT: too long descriptor length %d\n", descriptor_length);
	1156	goto NoDescExit;
	1157	}
	1158
	1159	/*
	1160	* Counts number of local_time.
	1161	*/
	1162	err=GetMpegDescriptor( (DS_U8 *)&p[10],
	1163	descriptor_length,
	1164	DVB_TAG_local_time_offset_descriptor,
	1165	0,
	1166	&p_desc );
	1167	if (err==0 && p_desc)
	1168	{
	1169	numLocaltime = p_desc[1] / 13;
	1170	if (numLocaltime <= 0)
	1171	goto NoDescExit;
	1172
	1173	p_tot->p_lto = (dvb_local_time_offset_descriptor_t *)memChainAlloc(memId, sizeof(dvb_local_time_offset_descriptor_t));
	1174	checkMemoryError(p_tot->p_lto);
	1175
	1176	p_lt = p_tot->p_lto->p_local_time = (dvb_local_time_t )memChainAlloc(memId, sizeof(dvb_local_time_t)numLocaltime);
	1177	checkMemoryError(p_tot->p_lto->p_local_time);
	1178
	1179	p_tot->p_lto->i_num_local_time = numLocaltime;
	1180	DHL_PSI_ParseLocalTimeOffsetDescriptor( p_desc, numLocaltime, p_lt );
	1181	}
	1182	else
	1183	{
	1184	DST_Printf("TOT: cannot find local_time_offset descriptor.\n");
	1185	}
	1186	}
	1187
	1188	NoDescExit:
	1189	err = 0;
	1190	(((memId_t )p_tot)-1) = memId;
	1191	*pp_tot = p_tot;
	1192	memId = 0; /* Don't delete below */
	1193
	1194	ParseExit:
	1195
	1196	if (memId)
	1197	{
	1198	/* delete the patSection memory */
	1199	memChainDestroy(memId);
	1200	}
	1201
	1202	return(err);
	1203	}
	1204
	1205	static void DHL_PSI_ParseDataContentDescriptor( DS_U8 p, memId_t memId, arib_data_content_descriptor_t *pp_data_content )
	1206	{
	1207	int i=0, j=0, k=0, len;
	1208	int err=0;
	1209	arib_data_content_descriptor_t *p_data_content;
	1210
	1211	len = p[1];
	1212
	1213	if ( len < 8 )
	1214	return;
	1215
	1216	p_data_content = (arib_data_content_descriptor_t *)memChainAlloc(memId, sizeof(arib_data_content_descriptor_t));
	1217
	1218	if ( p_data_content == (arib_data_content_descriptor_t *)0 )
	1219	{
	1220	err = DHL_FAIL_OUT_OF_RESOURCE;
	1221	goto ParseDescriptorExit;
	1222	}
	1223
	1224	p_data_content->data_component_id = ( p[2] << 8 ) + p[3];
	1225	p_data_content->entry_component = p[4];
	1226	p_data_content->selector_length = p[5];
	1227
	1228	if ( p_data_content->selector_length > 0 )
	1229	{
	1230	DS_U8 *p_selector_byte;
	1231
	1232	p_selector_byte = p_data_content->selector_byte = (DS_U8 *)memChainAlloc( memId, p_data_content->selector_length );
	1233
	1234	if ( p_selector_byte == (DS_U8 *)0 )
	1235	{
	1236	err = DHL_FAIL_OUT_OF_RESOURCE;
	1237	goto ParseDescriptorExit;
	1238	}
	1239
	1240	for ( i = 0 ; i < p_data_content->selector_length ; i++ )
	1241	{
	1242	*p_selector_byte = p[i+6];
	1243	p_selector_byte++;
	1244	}
	1245	}
	1246
	1247	p_data_content->num_of_component_ref = p[i+6];
	1248
	1249	if ( p_data_content->num_of_component_ref > 0 )
	1250	{
	1251	DS_U8 *p_component_ref;
	1252
	1253	p_component_ref = p_data_content->component_ref = (DS_U8 *)memChainAlloc( memId, p_data_content->num_of_component_ref );
	1254
	1255	if ( p_component_ref == (DS_U8 *)0 )
	1256	{
	1257	err = DHL_FAIL_OUT_OF_RESOURCE;
	1258	goto ParseDescriptorExit;
	1259	}
	1260
	1261	for ( j = 0 ; j < p_data_content->num_of_component_ref ; j++ )
	1262	{
	1263	*p_component_ref = p[i+j+7];
	1264	p_component_ref++;
	1265	}
	1266	}
	1267
	1268	p_data_content->ISO_639_language_code = ( p[i+j+7] << 16 ) + ( p[i+j+8] << 8 ) + p[i+j+9];
	1269	p_data_content->text_length = p[i+j+10];
	1270
	1271	if ( p_data_content->text_length > 0 )
	1272	{
	1273	p_data_content->text_char = (DS_U8 *)memChainAlloc( memId, p_data_content->text_length+1 );
	1274
	1275	if ( p_data_content->text_char == (DS_U8 *)0 )
	1276	{
	1277	err = DHL_FAIL_OUT_OF_RESOURCE;
	1278	goto ParseDescriptorExit;
	1279	}
	1280
	1281	for ( k = 0 ; k < p_data_content->text_length ; k++ )
	1282	{
	1283	p_data_content->text_char[k] = p[i+j+k+11];
	1284	}
	1285
	1286	p_data_content->text_char[k] = '\0';
	1287	}
	1288
	1289	*pp_data_content = p_data_content;
	1290
	1291	ParseDescriptorExit:
	1292	if ( err )
	1293	{
	1294	DST_Printf("ERROR: %s returns %d!\n", __func__, err);
	1295	}
	1296	}
	1297
	1298	static void DHL_PSI_ParseShortEventDescriptor(DS_U8 p_desc, memId_t memId, dvb_short_event_descriptor_t *pp_short_event)
	1299	{
	1300	dvb_short_event_descriptor_t *p_short_event;
	1301	int event_name_length, text_length;
	1302	DS_U32 ISO_639_language_code;
	1303
	1304	if (!p_desc \|\| !pp_short_event)
	1305	return;
	1306
	1307	if (p_desc[0] != DVB_TAG_short_event_descriptor \|\| p_desc[1] < 5)
	1308	{
	1309	DST_Printf("%s: invalid tag or length, tag: 0x%x, length: 0x%x\n", __func__, p_desc[0], p_desc[1]);
	1310	return;
	1311	}
	1312
	1313	ISO_639_language_code = (p_desc[2]<<16) + (p_desc[3]<<8) + p_desc[4];
	1314
	1315	p_short_event = (dvb_short_event_descriptor_t *)memChainAlloc(memId, sizeof(dvb_short_event_descriptor_t));
	1316	if ( !p_short_event )
	1317	return;
	1318
	1319	p_short_event->ISO_639_language_code = ISO_639_language_code;
	1320	p_short_event->event_name_length = event_name_length = p_desc[5];
	1321	p_short_event->p_event_name = (DS_U8 *)0;
	1322	if (event_name_length)
	1323	{
	1324	p_short_event->p_event_name = (DS_U8 *)memChainAlloc(memId, event_name_length+1);
	1325	SysASSERT(p_short_event->p_event_name);
	1326	memcpy( p_short_event->p_event_name, &p_desc[6], event_name_length );
	1327	p_short_event->p_event_name[event_name_length] = '\0';
	1328	}
	1329
	1330	p_short_event->text_length = text_length = p_desc[6+event_name_length];
	1331	p_short_event->p_text = (DS_U8 *)0;
	1332	if (text_length)
	1333	{
	1334	p_short_event->p_text = (DS_U8 *)memChainAlloc(memId, text_length+1);
	1335	SysASSERT(p_short_event->p_event_name);
	1336	memcpy(p_short_event->p_text, &p_desc[7+event_name_length], text_length);
	1337	p_short_event->p_text[text_length] = '\0';
	1338	}
	1339
	1340	*pp_short_event = p_short_event;
	1341
	1342	return;
	1343	}
	1344
	1345	static void DHL_PSI_ParseAudioComponentDescriptor( DS_U8 p, memId_t memId, arib_audio_component_descriptor_t *pp_audio_component )
	1346	{
	1347	int i, len;
	1348	DS_U8 count;
	1349	int err=0;
	1350	arib_audio_component_descriptor_t *p_audio_component;
	1351
	1352	len = p[1];
	1353
	1354	if ( len < 8 )
	1355	return;
	1356
	1357	p_audio_component = (arib_audio_component_descriptor_t *)memChainAlloc(memId, sizeof(arib_audio_component_descriptor_t));
	1358
	1359	if ( p_audio_component == (arib_audio_component_descriptor_t *)0 )
	1360	{
	1361	err = DHL_FAIL_OUT_OF_RESOURCE;
	1362	goto ParseDescriptorExit;
	1363	}
	1364
	1365	p_audio_component->stream_content = ( p[2] & 0xF );
	1366	p_audio_component->component_type = p[3];
	1367	p_audio_component->component_tag = p[4];
	1368	p_audio_component->stream_type = p[5];
	1369	p_audio_component->simulcast_group_tag = p[6];
	1370	p_audio_component->ES_multi_lingual_flag = ( p[7] & 0x80 ) >> 7;
	1371	p_audio_component->main_component_flag = ( p[7] & 0x40 ) >> 6;
	1372	p_audio_component->quality_indicator = ( p[7] & 0x30 ) >> 4;
	1373	p_audio_component->sampling_rate = ( p[7] & 0xE ) >> 1;
	1374	p_audio_component->ISO_639_language_code = ( p[8] << 16 ) + ( p[9] << 8 ) + p[10];
	1375
	1376	if ( p_audio_component->ES_multi_lingual_flag == 1 )
	1377	{
	1378	// DS_U8 *p_text_char;
	1379
	1380	p_audio_component->ISO_639_language_code_2 = ( p[11] << 16 ) + ( p[12] << 8 ) + p[13];
	1381	count = len - 12;
	1382	p_audio_component->text_char = (DS_U8 *)memChainAlloc( memId, count+1 );
	1383
	1384	if ( p_audio_component->text_char == (DS_U8 *)0 )
	1385	{
	1386	err = DHL_FAIL_OUT_OF_RESOURCE;
	1387	goto ParseDescriptorExit;
	1388	}
	1389
	1390	for ( i = 0 ; i < count ; i++ )
	1391	{
	1392	p_audio_component->text_char[i] = (p[i+14]);
	1393	}
	1394
	1395	p_audio_component->text_char[i] = '\0';
	1396	}
	1397	else
	1398	{
	1399	count = len - 9;
	1400	p_audio_component->text_char = (DS_U8 *)memChainAlloc( memId, count+1 );
	1401
	1402	if ( p_audio_component->text_char == (DS_U8 *)0 )
	1403	{
	1404	err = DHL_FAIL_OUT_OF_RESOURCE;
	1405	goto ParseDescriptorExit;
	1406	}
	1407
	1408	for ( i = 0 ; i < count ; i++ )
	1409	{
	1410	p_audio_component->text_char[i] = (p[i+11]);
	1411	}
	1412
	1413	p_audio_component->text_char[i] = '\0';
	1414	}
	1415
	1416	*pp_audio_component = p_audio_component;
	1417
	1418	ParseDescriptorExit:
	1419	if ( err )
	1420	{
	1421	DST_Printf("ERROR: %s returns %d!\n", __func__, err);
	1422	}
	1423	}
	1424
	1425	static void DHL_PSI_ParseExtendedEventDescriptor(DS_U8 p_desc, memId_t memId, dvb_extended_event_descriptor_t *pp_extended_event)
	1426	{
	1427	dvb_extended_event_descriptor_t *p_extended_event;
	1428	DS_U32 ISO_639_language_code;
	1429	int length_of_items, text_length;
	1430	int i, numItems;
	1431	DS_U8 p = (DS_U8 )0;
	1432
	1433	if (!p_desc \|\| !pp_extended_event)
	1434	return;
	1435
	1436	if (p_desc[0] != DVB_TAG_extended_event_descriptor \|\| p_desc[1] < 6)
	1437	{
	1438	DST_Printf("%s: invalid tag or length, tag: 0x%x, length: 0x%x\n", __func__, p_desc[0], p_desc[1]);
	1439	return;
	1440	}
	1441
	1442	ISO_639_language_code = (p_desc[3]<<16) + (p_desc[4]<<8) + (p_desc[5]);
	1443
	1444	p_extended_event = (dvb_extended_event_descriptor_t *)memChainAlloc(memId, sizeof(dvb_extended_event_descriptor_t));
	1445	if (!p_extended_event)
	1446	return;
	1447
	1448	p_extended_event->descriptor_number = (p_desc[2]>>4) & 0x0F;
	1449	p_extended_event->last_descriptor_number = (p_desc[2]) & 0x0F;
	1450	p_extended_event->ISO_639_language_code = ISO_639_language_code;
	1451
	1452	length_of_items = p_desc[6];
	1453	p_extended_event->numItems = 0;
	1454	p_extended_event->items = (dvb_ext_event_item_t *)0;
	1455
	1456	if (length_of_items)
	1457	{
	1458	int item_description_length;
	1459	int item_length;
	1460	dvb_ext_event_item_t *p_item;
	1461
	1462	/*
	1463	* Calculate number of items.
	1464	*/
	1465	numItems = 0;
	1466
	1467	p = &p_desc[7];
	1468	for(i=0; i<length_of_items; /* i is incremented in the loop */)
	1469	{
	1470	item_description_length = p[i+0];
	1471	item_length = p[i+item_description_length+1];
	1472
	1473	i += item_description_length+item_length+2;
	1474	numItems++;
	1475	}
	1476
	1477	p_extended_event->numItems = numItems;
	1478	p_item = p_extended_event->items = (dvb_ext_event_item_t )memChainAlloc(memId, sizeof(dvb_ext_event_item_t)numItems);
	1479	for(i=0; i<length_of_items; /* i is incremented in the loop */)
	1480	{
	1481	item_description_length = p[i+0];
	1482	item_length = p[i+item_description_length+1];
	1483
	1484	p_item->item_description_length = item_description_length;
	1485	if (item_description_length)
	1486	{
	1487	p_item->p_item_description = (DS_U8 *)memChainAlloc(memId, item_description_length+1);
	1488	memcpy(p_item->p_item_description, &p[i+1], item_description_length);
	1489	p_item->p_item_description[item_description_length] = '\0';
	1490	}
	1491
	1492	p_item->item_length = item_length;
	1493	if (item_length)
	1494	{
	1495	p_item->p_item_char = (DS_U8 *)memChainAlloc(memId, item_length+1);
	1496	memcpy(p_item->p_item_char, &p[i+2+item_description_length], item_length);
	1497	p_item->p_item_char[item_length] = '\0';
	1498	}
	1499
	1500	i += item_description_length+item_length+2;
	1501	p_item++;
	1502	}
	1503	}
	1504
	1505	text_length = p_desc[7+length_of_items];
	1506	p_extended_event->text_length = text_length;
	1507	p_extended_event->p_text = (DS_U8 *)0;
	1508	if (text_length)
	1509	{
	1510	p_extended_event->p_text = (DS_U8 *)memChainAlloc(memId, text_length);
	1511	memcpy(p_extended_event->p_text, &p_desc[8+length_of_items], text_length);
	1512	}
	1513
	1514	*pp_extended_event = p_extended_event;
	1515	return;
	1516	}
	1517
	1518	static void DHL_PSI_ParseParentalRatingDescriptorEx (DS_U8* p, memId_t memId, dvb_parental_rating_descriptor_t **pp_desc)
	1519	{
	1520	//memId_t memId;
	1521	//memChainSetup_t memSetup = {MEM_LIMIT,0,0};
	1522	DS_U8 length;
	1523	int err=0;
	1524	dvb_parental_rating_descriptor_t *p_desc;
	1525	dvb_parental_rating_entry_t *p_entry;
	1526	int i, numEntries;
	1527	DS_U8 *p_data;
	1528
	1529	length = p[1];
	1530
	1531	#if 0
	1532	/* create the memChain */
	1533	err = memChainCreate(&memId);
	1534	if (err != 0)
	1535	goto ParseDescriptorExit;
	1536	#endif
	1537
	1538	/* create the descriptor memory */
	1539	p_desc = (dvb_parental_rating_descriptor_t *)(memChainAlloc(memId,sizeof(dvb_parental_rating_descriptor_t)));
	1540	if (p_desc == (dvb_parental_rating_descriptor_t *)0)
	1541	{
	1542	err = DHL_FAIL_OUT_OF_RESOURCE;
	1543	goto ParseDescriptorExit;
	1544	}
	1545
	1546	numEntries = length>>2;
	1547	if (numEntries<=0)
	1548	goto ParseDescriptorExit;
	1549
	1550	p_entry = (dvb_parental_rating_entry_t )memChainAlloc(memId, sizeof(dvb_parental_rating_entry_t)numEntries);
	1551	if (p_entry == (dvb_parental_rating_entry_t *)0)
	1552	{
	1553	err = DHL_FAIL_OUT_OF_RESOURCE;
	1554	goto ParseDescriptorExit;
	1555	}
	1556	p_desc->i_num_ratings = numEntries;
	1557	p_desc->p_ratings = p_entry;
	1558
	1559	p_data = &p[2];
	1560	for (i=0; i<numEntries; i++)
	1561	{
	1562	p_entry->country_code = (p_data[0]<<16) + (p_data[1]<<8) + (p_data[2]<<0);
	1563	p_entry->rating_value = p_data[3];
	1564	p_data += 4;
	1565	p_entry++;
	1566	}
	1567
	1568	(((memId_t )(p_desc))-1) = memId;
	1569	memId = 0; /* so memChain not deleted */
	1570	*pp_desc = p_desc;
	1571
	1572	ParseDescriptorExit:
	1573	if (memId) {
	1574	/* delete the descriptor memory */
	1575	memChainDestroy(memId);
	1576	}
	1577
	1578	if (err)
	1579	{
	1580	DST_Printf("ERROR: %s returns %d!\n", __func__, err);
	1581	}
	1582	}
	1583
	1584	static void DHL_PSI_ParseEventGroupDescriptor(DS_U8 p_desc, memId_t memId, arib_event_group_descriptor_t *pp_event_grp)
	1585	{
	1586	DS_U8 *p = p_desc;
	1587	arib_event_group_descriptor_t *p_event_grp;
	1588	arib_event_t *p_event;
	1589	arib_other_event_t *p_other_event;
	1590	int i, len, off;
	1591	// int numEvent;
	1592
	1593	if (!p_desc \|\| !pp_event_grp \|\| !memId)
	1594	return;
	1595
	1596	len = p_desc[1];
	1597	if (len<5)
	1598	return;
	1599
	1600	p_event_grp = (arib_event_group_descriptor_t *)memChainAlloc(memId, sizeof(arib_event_group_descriptor_t));
	1601	p_event_grp->group_type = (p[2] >> 4) & 0x0F;
	1602	p_event_grp->numEvents = p[2]&0x0F;
	1603
	1604	off = 3 /3=descriptor_tag+length+group_type + event_cnt/;
	1605	if ( p_event_grp->numEvents )
	1606	{
	1607	p_event = p_event_grp->p_event = (arib_event_t )memChainAlloc(memId, sizeof(arib_event_t) p_event_grp->numEvents);
	1608	for (i=0; i<p_event_grp->numEvents && off <= (len+2); i++)
	1609	{
	1610	p_event->service_id = (p[0+off]<<8)+p[1+off];
	1611	p_event->event_id = (p[2+off]<<8)+p[3+off];
	1612
	1613	off += 4;
	1614	p_event++;
	1615	}
	1616	}
	1617
	1618	p_event_grp->numOtherNetworkEvents = 0;
	1619	if ( p_event_grp->group_type == 4 \|\| p_event_grp->group_type == 5 )
	1620	{
	1621	p_event_grp->numOtherNetworkEvents = (len-off-2)/8;
	1622	if (p_event_grp->numOtherNetworkEvents)
	1623	{
	1624	p_other_event = p_event_grp->p_other_event = (arib_other_event_t )memChainAlloc(memId, sizeof(arib_other_event_t) p_event_grp->numOtherNetworkEvents);
	1625	for (i=0; i<p_event_grp->numOtherNetworkEvents; i++)
	1626	{
	1627	p_other_event->original_network_id = (p[0+off]<<8)+p[1+off];
	1628	p_other_event->transport_stream_id = (p[2+off]<<8)+p[3+off];
	1629	p_other_event->service_id = (p[4+off]<<8)+p[5+off];
	1630	p_other_event->event_id = (p[6+off]<<8)+p[7+off];
	1631
	1632	off += 8;
	1633	p_other_event++;
	1634	}
	1635	}
	1636	}
	1637
	1638	*pp_event_grp = p_event_grp;
	1639	}
	1640
	1641	int DHL_PSI_ParseDvbEit(DS_U8 sectionArr, DVB_EIT pp_eit)
	1642	{
	1643	if (!sectionArr \|\| !sectionArr[0] \|\| !pp_eit) return DHL_FAIL_NULL_POINTER;
	1644	*pp_eit = 0;
	1645	// 2013.10.07 section ¸ðµå·Î EIT¸¦ ¹ÞÀ¸¹Ç·Î Ç×»ó section °¹¼ö´Â 1ÀÌ´Ù.
	1646	int numSections = 1; //get_last_section_number(sectionArr[0]) + 1;
	1647	// First pass, we verify section syntax and count the number of events.
	1648	int numEvents = 0;
	1649	for (int i = 0; i < numSections; ++i)
	1650	{
	1651	if (!sectionArr[i]) break;
	1652	DS_U8* p = sectionArr[i];
	1653	if ((p[SECTION_LEN_HI] & 0x80) != 0x80) DST_Printf("EIT: section_syntax_indicator not set\n");
	1654	int len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3;
	1655	DS_U16 service_id = (p[SECTION_TID_EXT_HI] << 8) + p[SECTION_TID_EXT_LO];
	1656	if (service_id == 0) continue;
	1657	// Counts number of services.
	1658	int event_length = len - 14/table_id to last_table_id/ - 4/crc_32/;
	1659	if ( event_length < 12 ) continue; // No events are available for this section.
	1660	p = &sectionArr[i][14];
	1661	for(int k=0; (k+12+4)<event_length; )
	1662	{
	1663	int descriptor_loop_length = ((p[k+10]<<8)+p[k+11]) & 0xFFF;
	1664	numEvents++;
	1665	k += 12+descriptor_loop_length;
	1666	}
	1667	}
	1668	if (numEvents == 0) return 0;
	1669	// DST_Printf("EIT: numEvents: %d\n", numEvents);
	1670
	1671	// create the memChain
	1672	memId_t memId = 0;
	1673	if (memChainCreate(&memId)) return DHL_FAIL_OUT_OF_RESOURCE;
	1674
	1675	dvb_eit_t* p_eit = (dvb_eit_t )((memId_t )(memChainAlloc(memId,sizeof(dvb_eit_t)+sizeof(memId_t))) + 1);
	1676	if (p_eit == 0)
	1677	{
	1678	memChainDestroy(memId);
	1679	return DHL_FAIL_OUT_OF_RESOURCE;
	1680	}
	1681	dvb_eit_event_t p_event = p_eit->eit_events = (dvb_eit_event_t )memChainAlloc(memId,sizeof(dvb_eit_event_t)*numEvents);
	1682	if (p_eit->eit_events == 0)
	1683	{
	1684	memChainDestroy(memId);
	1685	return DHL_FAIL_OUT_OF_RESOURCE;
	1686	}
	1687	p_eit->numEvents = numEvents;
	1688
	1689	// Now fill-out all the remaining fields over the all sections.
	1690	// int index = 0;
	1691	for (int i = 0; i < numSections; ++i)
	1692	{
	1693	if(!sectionArr[i]) break;
	1694	DS_U8* p = sectionArr[i];
	1695	int len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3;
	1696	DS_U16 service_id = ((p[SECTION_TID_EXT_HI] << 8) \| p[SECTION_TID_EXT_LO]);
	1697	if (service_id == 0) continue;
	1698	DS_U8 version_number = (p[SECTION_VERSION] & SECTION_VERSION_MASK) >> SECTION_VERSION_SHIFT;
	1699	DS_U8 last_section_number = p[SECTION_NUM_LAST];
	1700	DS_U8 table_id = p[SECTION_TID];
	1701	DS_U16 transport_stream_id = ((p[8]<<8) + p[9]);
	1702	DS_U16 original_network_id = ((p[10]<<8) + p[11]);
	1703	DS_U8 segment_last_section_number = p[12];
	1704	DS_U8 last_table_id = p[13];
	1705
	1706	if (i == 0)
	1707	{
	1708	p_eit->table_id = table_id;
	1709	p_eit->service_id = service_id;
	1710	p_eit->version_number = version_number;
	1711	p_eit->section_number = p[6];
	1712	p_eit->last_section_number = last_section_number;
	1713	p_eit->segment_last_section_number = segment_last_section_number;
	1714	p_eit->transport_stream_id = transport_stream_id;
	1715	p_eit->original_network_id = original_network_id;
	1716	p_eit->last_table_id = last_table_id;
	1717	}
	1718	int event_length = len - 14/table_id to last_table_id/ - 4/crc_32/;
	1719	if ( event_length < 12 ) continue; // No events are available for this section.
	1720	p = &sectionArr[i][14];
	1721	for(int k=0; (k+12+4)<event_length; )
	1722	{
	1723	int descriptor_length = p_event->descriptor_length = ((p[k+10]<<8)+p[k+11]) & 0xFFF;
	1724	p_event->event_id = (p[k+0]<<8)+p[k+1];
	1725	p_event->start_date = (p[k+2]<<8)+p[k+3];
	1726	p_event->start_time = (p[k+4]<<16)+(p[k+5]<<8)+p[k+6];
	1727	p_event->duration = (p[k+7]<<16)+(p[k+8]<<8)+p[k+9];
	1728	p_event->running_status = (p[k+10]>>5) & 0x07;
	1729	p_event->free_CA_mode = (p[k+10]>>4) & 0x01;
	1730	if (p_event->descriptor_length)
	1731	{
	1732	DS_U8 p_desc_sect = p_event->descriptors = (DS_U8)memChainAlloc(memId, p_event->descriptor_length);
	1733	memcpy(p_event->descriptors, &p[k+12], p_event->descriptor_length);
	1734
	1735	// ShortEventDescriptor°¡ 2°³ ÀÌ»óÀÎ °æ¿ì¸¦ À§ÇÏ¿© ¾øÀ» ¶§ ±îÁö Ã£¾Æ¼ Parse.
	1736	p_event->numShortEvents = GetMpegDescriptorCount(p_desc_sect, descriptor_length, DVB_TAG_short_event_descriptor);
	1737	p_event->pp_short_event = (dvb_short_event_descriptor_t *)memChainAlloc(memId, sizeof(dvb_short_event_descriptor_t ) * p_event->numShortEvents);
	1738	for (int m = 0; m < p_event->numShortEvents; m++)
	1739	{
	1740	DS_U8* p_desc = 0;
	1741	if (GetMpegDescriptor( p_desc_sect, descriptor_length, DVB_TAG_short_event_descriptor, m, &p_desc )) continue;
	1742	DHL_PSI_ParseShortEventDescriptor(p_desc, memId, &p_event->pp_short_event[m]);
	1743	}
	1744
	1745	// extended_event_descriptor°¡ 2°³ ÀÌ»óÀÎ °æ¿ì¸¦ À§ÇÏ¿© ¾øÀ» ¶§ ±îÁö Ã£¾Æ¼ Parse.
	1746	p_event->numExtendedEvents = GetMpegDescriptorCount(p_desc_sect, descriptor_length, DVB_TAG_extended_event_descriptor);
	1747	p_event->pp_extended_event = (dvb_extended_event_descriptor_t *)memChainAlloc(memId, sizeof(dvb_extended_event_descriptor_t ) * p_event->numExtendedEvents);
	1748	for (int m = 0; m < p_event->numExtendedEvents; m++)
	1749	{
	1750	DS_U8* p_desc = 0;
	1751	if (GetMpegDescriptor( p_desc_sect, descriptor_length, DVB_TAG_extended_event_descriptor, m, &p_desc )) continue;
	1752	DHL_PSI_ParseExtendedEventDescriptor(p_desc, memId, &p_event->pp_extended_event[m]);
	1753	}
	1754
	1755	// Find Parental_Rating descriptor.
	1756	p_event->numParentalRating = GetMpegDescriptorCount(p_desc_sect, descriptor_length, DVB_TAG_parental_rating_descriptor);
	1757	p_event->pp_pr_desc = (dvb_parental_rating_descriptor_t *)memChainAlloc(memId, sizeof(dvb_parental_rating_descriptor_t ) * p_event->numParentalRating);
	1758	for (int m = 0; m < p_event->numParentalRating; m++)
	1759	{
	1760	DS_U8* p_desc = 0;
	1761	if (GetMpegDescriptor( p_desc_sect, descriptor_length, DVB_TAG_parental_rating_descriptor, m, &p_desc )) continue;
	1762	DHL_PSI_ParseParentalRatingDescriptorEx(p_desc, memId, &p_event->pp_pr_desc[m]);
	1763	}
	1764
	1765	// Find Event Group descriptor.
	1766	DS_U8* p_desc = 0;
	1767	if (!GetMpegDescriptor( p_desc_sect, descriptor_length, ARIB_TAG_event_group_descriptor, 0, &p_desc ))
	1768	{
	1769	DHL_PSI_ParseEventGroupDescriptor( p_desc, memId, &p_event->p_event_group );
	1770	}
	1771
	1772	// Find Audio component descriptor.
	1773	p_event->numAudioComponent = GetMpegDescriptorCount(p_desc_sect, descriptor_length, ARIB_TAG_audio_component_descriptor);
	1774	p_event->pp_audio_component = (arib_audio_component_descriptor_t *)memChainAlloc(memId, sizeof(arib_audio_component_descriptor_t ) * p_event->numAudioComponent);
	1775	for (int m = 0; m < p_event->numAudioComponent; m++)
	1776	{
	1777	DS_U8* p_desc = 0;
	1778	if (GetMpegDescriptor( p_desc_sect, descriptor_length, ARIB_TAG_audio_component_descriptor, m, &p_desc )) continue;
	1779	DHL_PSI_ParseAudioComponentDescriptor(p_desc, memId, &p_event->pp_audio_component[m]);
	1780	}
	1781
	1782	// Data component descriptor
	1783	p_event->numDataContent = GetMpegDescriptorCount(p_desc_sect, descriptor_length, ARIB_TAG_data_content_descriptor);
	1784	p_event->pp_data_content = (arib_data_content_descriptor_t *)memChainAlloc(memId, sizeof(arib_data_content_descriptor_t ) * p_event->numDataContent);
	1785	for (int m = 0; m < p_event->numDataContent; m++)
	1786	{
	1787	DS_U8* p_desc = 0;
	1788	if (GetMpegDescriptor( p_desc_sect, descriptor_length, ARIB_TAG_data_content_descriptor, m, &p_desc )) continue;
	1789	DHL_PSI_ParseDataContentDescriptor(p_desc, memId, &p_event->pp_data_content[m]);
	1790	}
	1791	}
	1792	k += 12+descriptor_length;
	1793	p_event++;
	1794	}
	1795	}
	1796	(((memId_t )p_eit)-1) = memId;
	1797	*pp_eit = p_eit;
	1798	return 0;
	1799	}
	1800
	1801	static int DHL_PSI_ParseStreamIdentifierDescriptor(DS_U8 p, DS_U8 p_component_tag)
	1802	{
	1803	if (p[1] < 1) return -1;
	1804	*p_component_tag = p[2];
	1805	return 0;
	1806	}
	1807
	1808	int DHL_PSI_ParsePMT( DS_U8 section, MPEG_PMT *returnPmt)
	1809	{
	1810	int err = 0;
	1811	DS_S32 j, k;
	1812	// DS_S32 index;
	1813	DS_S32 numStreams;
	1814	DS_S32 len, len2;
	1815	MPEG_PMT *pmt;
	1816	DS_S32 program_info_length, es_info_length;
	1817	// memChainSetup_t memSetup = {MEM_LIMIT,0,0};
	1818	memId_t memId = 0;
	1819	const DS_U8 *p;
	1820	DS_U8 *q;
	1821	int pmtSize = 0;
	1822
	1823	if( section == 0 \|\| returnPmt == 0 )
	1824	return DHL_FAIL_NULL_POINTER;
	1825	/*
	1826	* First pass, we verify section syntax and count the number of streams
	1827	*/
	1828	p = section;
	1829
	1830	numStreams = 0;
	1831	if (p[SECTION_TID] != TS_PROGRAM_MAP_SECTION) {
	1832	/*
	1833	* This thing isn't a PMT. Stop right here.
	1834	*/
	1835	DST_Printf("PMT: Bad table ID.");
	1836	err = DHL_FAIL_INVALID_TABLEID;
	1837	goto ParseExit;
	1838	}
	1839	if ((p[SECTION_LEN_HI] & 0x80) != 0x80) {
	1840	DST_Printf("PAT: section_syntax_indicator not set");
	1841	}
	1842	if ((p[SECTION_LEN_HI] & 0x40) != 0x00) {
	1843	DST_Printf("PAT: private_indicator set");
	1844	}
	1845	len = (((p[SECTION_LEN_HI] & 0x0F) << 8) \| p[SECTION_LEN_LO]) + 3;
	1846	if (p[SECTION_NUM] != 0) {
	1847	DST_Printf("PMT: section_number != 0");
	1848	}
	1849	if (p[SECTION_NUM_LAST] != 0) {
	1850	DST_Printf("PAT: last_section_number != 0");
	1851	}
	1852	program_info_length = ((p[10]<<8) + p[11]) & 0x0FFF;
	1853	if (program_info_length & 0x0C00) {
	1854	DST_Printf("PMT: first 2 bits of program_info_length not 00");
	1855	}
	1856	len2 = len - program_info_length - 16;
	1857	if (len2 < 0) {
	1858	DST_Printf("PMT: program descriptors extend beyond section");
	1859	err = DHL_FAIL_INVALID_PARAM;
	1860	goto ParseExit;
	1861	}
	1862	p += program_info_length + 12;
	1863	while (len2 > 0) {
	1864	if (len2 < 5) {
	1865	DST_Printf("PMT: junk bytes at end of table");
	1866	break;
	1867	}
	1868	es_info_length = ((p[3]<<8) + p[4]) & 0x0FFF;
	1869	if (es_info_length & 0x0C00) {
	1870	DST_Printf("PMT: first 2 bits of ES_info_length not 00");
	1871	}
	1872	if (len2 - es_info_length < 5) {
	1873	DST_Printf("PMT: elementary stream descriptors extend beyond section");
	1874	break;
	1875	}
	1876	/*
	1877	* This is a hack to repair corrupted PMT's which we have received
	1878	*/
	1879	{
	1880	DS_S32/BK2003.11.18 <-DS_U32 by cafrii/ hlen = es_info_length;
	1881	DS_U8 hp = (DS_U8 )&p[5];
	1882	DS_U32 dtype, dlen;
	1883	while(hlen > 0) {
	1884	dtype = hp[0];
	1885	dlen = hp[1];
	1886	if (dtype == 10 && dlen == 3) {
	1887	hp[1] = 4;
	1888	es_info_length++;
	1889	((DS_U8 *)p)[3] = es_info_length>>8;
	1890	((DS_U8 *)p)[4] = es_info_length&255;
	1891	break;
	1892	}
	1893	hp += (dlen+2);
	1894	hlen -= (dlen+2);
	1895	}
	1896	}
	1897	/*
	1898	* End corrupted PMT hack
	1899	*/
	1900	len2 = len2 - es_info_length - 5;
	1901	p += es_info_length + 5;
	1902	numStreams++;
	1903	}
	1904	/*
	1905	* At this point, numStreams has the number of streams, which we can
	1906	* base the size of the PMT from.
	1907	*/
	1908	/* create the memChain */
	1909	err = memChainCreate(&memId);
	1910	if (err) {
	1911	goto ParseExit;
	1912	}
	1913	/* allocate memory for pmtSection */
	1914	pmtSize = MPEG_PMTSize(numStreams);
	1915	pmt = (MPEG_PMT )((memId_t )(memChainAlloc(memId, pmtSize + sizeof(memId_t))) + 1);
	1916	checkMemoryError(pmt);
	1917
	1918	/*
	1919	* Second pass, we fill in the table.
	1920	* We assume that everything we verified or warned about above is still
	1921	* true. We already bailed out on fatal errors
	1922	*/
	1923	// index = 0;
	1924	p = section;
	1925	/* pmt->PID = desc->pid;*/
	1926	pmt->program_number = ((p[SECTION_TID_EXT_HI] << 8) \|
	1927	p[SECTION_TID_EXT_LO]);
	1928	pmt->version_number = (p[SECTION_VERSION] & SECTION_VERSION_MASK) >>
	1929	SECTION_VERSION_SHIFT;
	1930	pmt->current_next_indicator = (p[SECTION_VERSION] & SECTION_CNI_MASK) != 0;
	1931	pmt->PCR_PID = ((p[8] << 8) \| p[9]) & PID_MASK;
	1932	pmt->numStreams = numStreams;
	1933
	1934	len2 = len - program_info_length - 16;
	1935
	1936	p += 12;
	1937	pmt->descriptor_length = program_info_length;
	1938	pmt->descriptors = (DS_U8 )memChainAlloc(memId,program_info_lengthsizeof(DS_U8));
	1939	checkMemoryError(pmt->descriptors);
	1940	for (j=0; j<program_info_length; j++) {
	1941	pmt->descriptors[j] = *p++;
	1942	}
	1943
	1944	for (j = 0; j < numStreams; ++j) {
	1945	pmt->streams[j].stream_type = p[0];
	1946	pmt->streams[j].elementary_PID = ((p[1]<<8) \| p[2]) & PID_MASK;
	1947	es_info_length = ((p[3]<<8) + p[4]) & 0x0FFF;
	1948	p += 5;
	1949	pmt->streams[j].descriptor_length = es_info_length;
	1950	pmt->streams[j].descriptors = (DS_U8 )memChainAlloc(memId,es_info_lengthsizeof(DS_U8));
	1951	checkMemoryError(pmt->streams[j].descriptors);
	1952	for (k=0; k<es_info_length; k++) {
	1953	pmt->streams[j].descriptors[k] = *p++;
	1954	}
	1955	// if (GetMpegDescriptor(pmt->streams[j].descriptors,es_info_length,
	1956	// video_stream_tag,0/instance/,&q) == 0) {
	1957	// DHL_PSI_ParseVideoStreamDescriptor(q,memId,&pmt->streams[j].videoStreamDescriptor);
	1958	// }
	1959	// if (GetMpegDescriptor(pmt->streams[j].descriptors,es_info_length,
	1960	// video_decode_control_tag,0/instance/,&q) == 0) {
	1961	// DHL_PSI_ParseVideoDecodeControlDescriptor(q,memId,&pmt->streams[j].videoDecodeControlDescriptor);
	1962	// }
	1963	pmt->streams[j].b_component_tag_valid = false;
	1964	if (GetMpegDescriptor(pmt->streams[j].descriptors,es_info_length,
	1965	DVB_TAG_stream_identifier_descriptor, 0, &q)==0) {
	1966	if ( DHL_PSI_ParseStreamIdentifierDescriptor(q,&(pmt->streams[j].component_tag)) == 0 )
	1967	pmt->streams[j].b_component_tag_valid = true;
	1968	}
	1969	}
	1970	(((memId_t )pmt)-1) = memId;
	1971	*returnPmt = pmt;
	1972	memId = 0; /* Don't delete below */
	1973
	1974	ParseExit:
	1975	if (memId) {
	1976	/* delete the patSection memory */
	1977	memChainDestroy(memId);
	1978	}
	1979
	1980
	1981
	1982	return(err);
	1983	}
	1984
	1985
	1986	/*==============================================================================
	1987	DHL_RESULT ParseTVCTSection (DS_U8 section, tvctSectionPtr_t tvctSectionPtr)
	1988
	1989	*section: Pointer to the first byte of the section.
	1990	*tvctSectionPtr: Return pointer to a parsed TVCT section.
	1991
	1992	Parses an TVCT section and returns the decoded section via the provided
	1993	handle.
	1994	==============================================================================*/
	1995	static int DHL_PSI_ParseTVCTSection (DS_U8 section, tvctSectionPtr_t tvctSectionPtr)
	1996	{
	1997	T();
	1998	if (get_section_syntax_indicator(section) == 0)
	1999	{
	2000	DST_Printf("TVCT: section_syntax_indicator not set\n");
	2001	}
	2002	if (get_private_indicator(section) == 0)
	2003	{
	2004	DST_Printf("TVCT: private_indicator not set\n");
	2005	}
	2006
	2007	int err = 0;
	2008	DS_U16 section_length = get_section_length(section);
	2009	DST_Printf("section_length=%d\n", section_length);
	2010	if (section_length > 1021)
	2011	{
	2012	DST_Printf("TVCT: section_length=%d\n",section_length);
	2013	return DHL_FAIL_INVALID_PARAM;
	2014	}
	2015
	2016	memId_t memId = (memId_t)0; /* create the memChain */
	2017	err = memChainCreate(&memId);
	2018	if (err)
	2019	{
	2020	return DHL_FAIL_OUT_OF_RESOURCE;
	2021	}
	2022	/* allocate memory for tvctSection */
	2023	tvctSectionPtr_t tvctSectPtr = (tvctSectionPtr_t)((memId_t *)(memChainAlloc(memId,sizeof(tvctSection_t)+sizeof(memId_t))) + 1);
	2024	// checkMemoryError(tvctSectPtr);
	2025
	2026	DS_U8 *p = section+3;
	2027	/* parse section */
	2028	tvctSectPtr->transport_stream_id = p[0] * 256 + p[1];
	2029	tvctSectPtr->version_number = (p[2] >> 1) & 0x3F;
	2030	tvctSectPtr->current_next_indicator = p[2] & 0x01;
	2031	tvctSectPtr->section_number = p[3];
	2032	tvctSectPtr->last_section_number = p[4];
	2033
	2034	DS_U8 protocol_version = p[5];
	2035
	2036	if (protocol_version > 0)
	2037	{
	2038	DST_Printf("TVCT : invalid protocol version.(0x%x).\r\n" , protocol_version );
	2039	if (memId) memChainDestroy(memId);
	2040	return DHL_FAIL_INVALID_VERSION;
	2041	}
	2042
	2043	int count_i = tvctSectPtr->num_channels_in_section = p[6];
	2044	DST_Printf("tvctSectPtr->num_channels_in_section=%d\n" , tvctSectPtr->num_channels_in_section );
	2045	if( count_i > 0 )
	2046	{
	2047	tvctSectPtr->channel = (tvctChannelPtr_t)memChainAlloc(memId,count_i*sizeof(tvctChannel_t));
	2048	checkMemoryError(tvctSectPtr->channel);
	2049	}
	2050
	2051	p = p+7;
	2052	for (int i=0; i<count_i; i++)
	2053	{
	2054	for (int j=0; j<7; j++)
	2055	{
	2056	tvctSectPtr->channel[i].short_name[j] = p[j2] 256 + p[j*2+1];
	2057	}
	2058	tvctSectPtr->channel[i].major_channel_number = (p[14] & 0x0F) * 64 + ((p[15] >> 2) & 0x3F);
	2059	tvctSectPtr->channel[i].minor_channel_number = (p[15] & 0x03) * 256 + p[16];
	2060
	2061	DST_Printf("tvctSectPtr->channel[i].major_channel_number == %d\n",tvctSectPtr->channel[i].major_channel_number);
	2062	DST_Printf("tvctSectPtr->channel[i].minor_channel_number == %d\n",tvctSectPtr->channel[i].minor_channel_number);
	2063
	2064	tvctSectPtr->channel[i].modulation_mode = (modulation_mode_k)p[17];
	2065	tvctSectPtr->channel[i].carrier_frequency = p[18] * 0x1000000 + p[19] * 0x10000 + p[20] * 0x100 + p[21];
	2066	tvctSectPtr->channel[i].channel_TSID = p[22] * 0x100 + p[23];
	2067	tvctSectPtr->channel[i].program_number = p[24] * 0x100 + p[25];
	2068	tvctSectPtr->channel[i].ETM_location = (ETM_location_k)((p[26] >> 6) & 0x03);
	2069	tvctSectPtr->channel[i].access_controlled = (p[26] >> 5) & 0x01;
	2070	tvctSectPtr->channel[i].hidden = (p[26] >> 4) & 0x01;
	2071	tvctSectPtr->channel[i].show_guide = (p[26] >> 1) & 0x01;
	2072	tvctSectPtr->channel[i].service_type = (service_type_k)(p[27]& 0x3F);
	2073	tvctSectPtr->channel[i].source_id = p[28] * 256 + p[29];
	2074	int count_j = tvctSectPtr->channel[i].descriptor_length = (p[30]&0x03) * 256 + p[31];
	2075	tvctSectPtr->channel[i].descriptors = (DS_U8 *)memChainAlloc(memId,count_j);
	2076	checkMemoryError(tvctSectPtr->channel[i].descriptors);
	2077	DST_Printf("tvctSectPtr->channel[i].descriptor_lengthr == %d\n",tvctSectPtr->channel[i].descriptor_length);
	2078	for (int j=0; j<count_j; j++)
	2079	{
	2080	tvctSectPtr->channel[i].descriptors[j] = p[32+j];
	2081	}
	2082	p = p + 32 + count_j;
	2083	}
	2084	count_i = tvctSectPtr->additional_descriptor_length = (p[0]&0x03) * 256 + p[1];
	2085	tvctSectPtr->additional_descriptors = (DS_U8 *)memChainAlloc(memId,count_i);
	2086	checkMemoryError(tvctSectPtr->additional_descriptors);
	2087
	2088	for (int i=0; i<count_i; i++)
	2089	{
	2090	tvctSectPtr->additional_descriptors[i] = p[2+i];
	2091	}
	2092
	2093	/* parsing complete */
	2094	(((memId_t )tvctSectPtr)-1) = memId;
	2095	memId = (memId_t)0; /* so memChain not deleted */
	2096	ParseExit:
	2097	// if (bits) {
	2098	// /* clean up the bitBuffer */
	2099	// bitBufferDestroy(bits);
	2100	// }
	2101	if (memId) {
	2102	/* delete the tvctSection memory */
	2103	memChainDestroy(memId);
	2104	}
	2105
	2106	*tvctSectionPtr = tvctSectPtr;
	2107	return (err);
	2108	}
	2109
	2110	/*==============================================================================
	2111	DHL_RESULT DHL_PSI_ParseTVCT (DS_U8 *sectionArr, tvctPtr_t tvctPtr)
	2112
	2113	**sectionArr: Array of pointers to all TVCT sections.
	2114	*tvctPtr: Returned pointer to the parsed TVCT.
	2115
	2116	Parses an TVCT and returns the parsed table via the return pointer.
	2117	==============================================================================*/
	2118	int DHL_PSI_ParseTVCT (DS_U8 *sectionArr, tvctPtr_t tvctPtr)
	2119	{
	2120	T();
	2121	if (sectionArr == 0)
	2122	{
	2123	DST_Printf("%s\|%d\|sectionArr == 0\n", __func__, __LINE__);
	2124	return (DHL_FAIL_NULL_POINTER);
	2125	}
	2126	if (sectionArr[0] == 0)
	2127	{
	2128	DST_Printf("%s\|%d\|sectionArr[0] == 0\n", __func__, __LINE__);
	2129	return (DHL_FAIL_NULL_POINTER);
	2130	}
	2131	if (tvctPtr == 0)
	2132	{
	2133	DST_Printf("%s\|%d\|tvctPtr == 0\n", __func__, __LINE__);
	2134	return (DHL_FAIL_NULL_POINTER);
	2135	}
	2136	*tvctPtr = 0;
	2137
	2138	DS_U8 numSections = get_last_section_number(sectionArr[0]) + 1;
	2139	DST_Printf("numSections = %d\n", numSections);
	2140	for (int i=1; i < numSections; i++) /* now verify all other sections are present */
	2141	{
	2142	if (sectionArr[i] == 0)
	2143	{
	2144	DST_Printf("%s\|%d\|null section found.\n", __func__, __LINE__);
	2145	return (DHL_FAIL_NULL_POINTER);
	2146	}
	2147	}
	2148	for( int i=0; i < numSections; i++ ) /chech the protocol_version of each secion./
	2149	{
	2150	if( sectionArr[i][8] != 0x00 )
	2151	{
	2152	DST_Printf("%s\|%d\|invalid protocol version\n", __func__, __LINE__);
	2153	return DHL_FAIL_INVALID_VERSION;
	2154	}
	2155	}
	2156
	2157	/* create the memChain */
	2158	memId_t memId = (memId_t)0;
	2159	int err = memChainCreate(&memId);
	2160	if (err)
	2161	{
	2162	DST_Printf("%s\|%d\|memChainCreate fail\n", __func__, __LINE__);
	2163	return DHL_FAIL_OUT_OF_RESOURCE;
	2164	}
	2165	/* allocate memory for tvct */
	2166	tvctPtr = (tvctPtr_t)((memId_t )(memChainAlloc(memId,sizeof(tvct_t)+sizeof(memId_t))) + 1);
	2167	// checkMemoryError(*tvctPtr);
	2168
	2169	/* Get the total number of channels in all sections */
	2170	DS_U16 numChannels = 0;
	2171	for (int i=0; i<numSections; i++)
	2172	{
	2173	numChannels += sectionArr[i][9];
	2174	}
	2175
	2176	(*tvctPtr)->numChannels = numChannels;
	2177
	2178	/* allocate space in tvct for channels */
	2179	(tvctPtr)->channel = (tvctChannelPtr_t)memChainAlloc(memId,numChannelssizeof(tvctChannel_t));
	2180	checkMemoryError((*tvctPtr)->channel);
	2181
	2182	// #ifdef PSI_DBG
	2183	// DST_Printf("DHL_PSI_ParseTVCT, numSection = %d\r\n", numSections);
	2184	// #endif
	2185
	2186	/* Parse each section and copy channels */
	2187	numChannels = 0;
	2188	for (int i=0; i<numSections; i++)
	2189	{
	2190	/* Parse the section */
	2191	tvctSectionPtr_t tvctSectPtr = 0;
	2192	if (DHL_PSI_ParseTVCTSection(sectionArr[i], &tvctSectPtr) != 0)
	2193	{
	2194	err = DHL_FAIL_OUT_OF_RESOURCE;
	2195	goto ParseExit;
	2196	}
	2197
	2198	if (i == 0)
	2199	{
	2200	/* duplicate fields copied once */
	2201	(*tvctPtr)->transport_stream_id = tvctSectPtr->transport_stream_id;
	2202	(*tvctPtr)->version_number = tvctSectPtr->version_number;
	2203
	2204	/* allocate space for descriptors and copy (if any) */
	2205	if (tvctSectPtr->additional_descriptor_length > 0)
	2206	{
	2207	(tvctPtr)->additional_descriptors = (DS_U8 )memChainAlloc(memId,tvctSectPtr->additional_descriptor_length);
	2208	if ((*tvctPtr)->additional_descriptors == 0)
	2209	{
	2210	DHL_PSI_FreeMpegSection(tvctSectPtr);
	2211	err = DHL_FAIL_OUT_OF_RESOURCE;
	2212	goto ParseExit;
	2213	}
	2214
	2215	(*tvctPtr)->additional_descriptor_length = tvctSectPtr->additional_descriptor_length;
	2216	memcpy((tvctPtr)->additional_descriptors, tvctSectPtr->additional_descriptors, (tvctPtr)->additional_descriptor_length);
	2217	}
	2218	}
	2219	for (int j=0; j<tvctSectPtr->num_channels_in_section; j++)
	2220	{
	2221	memcpy(&((*tvctPtr)->channel[numChannels]), &(tvctSectPtr->channel[j]), sizeof(tvctChannel_t));
	2222	/* allocate space for descriptors and copy (if any) */
	2223	if (tvctSectPtr->channel[j].descriptor_length > 0)
	2224	{
	2225	(tvctPtr)->channel[numChannels].descriptors = (DS_U8 )memChainAlloc(memId,tvctSectPtr->channel[j].descriptor_length*sizeof(DS_U8));
	2226	if ((*tvctPtr)->channel[numChannels].descriptors == 0)
	2227	{
	2228	DHL_PSI_FreeMpegSection(tvctSectPtr);
	2229	err = DHL_FAIL_OUT_OF_RESOURCE;
	2230	goto ParseExit;
	2231	}
	2232	memcpy((tvctPtr)->channel[numChannels].descriptors,tvctSectPtr->channel[j].descriptors, (tvctPtr)->channel[numChannels].descriptor_length);
	2233	}
	2234	numChannels++;
	2235	}
	2236	DHL_PSI_FreeMpegSection(tvctSectPtr);
	2237	}
	2238
	2239	/* parsing complete */
	2240	(((memId_t )(*tvctPtr))-1) = memId;
	2241	memId = 0; /* so memChain not deleted */
	2242
	2243	ParseExit:
	2244	if (memId) {
	2245	/* delete the tvct memory */
	2246	memChainDestroy(memId);
	2247	}
	2248	return (err);
	2249	}
	2250
	2251	/*==============================================================================
	2252	ParseCaptionServiceDescriptor
	2253	*p: Pointer to the un-parsed descriptor.
	2254	*descripPtr Pointer to parsed descriptor passed here.
	2255
	2256	Parses the descriptor and passes the result back via the descripPtr variable.
	2257	==============================================================================*/
	2258	int DHL_PSI_ParseCaptionServiceDescriptor (DS_U8* p, captionServiceDescriptorPtr_t *descripPtr)
	2259	{
	2260	memId_t memId;
	2261	if (memChainCreate(&memId)) return DHL_FAIL_OUT_OF_RESOURCE; /* create the memChain */
	2262	/* create the descriptor memory */
	2263	descripPtr = (captionServiceDescriptorPtr_t)((memId_t )(memChainAlloc(memId,sizeof(captionServiceDescriptor_t)+sizeof(memId_t))) + 1);
	2264	if (*descripPtr == 0)
	2265	{
	2266	memChainDestroy(memId);
	2267	return DHL_FAIL_OUT_OF_RESOURCE;
	2268	}
	2269	/* parse the descriptor */
	2270	int count_i = (*descripPtr)->number_of_services = p[2] & 0x1F;
	2271	DST_Printf("count_i = %d\n", count_i);
	2272	(descripPtr)->service = (captionServicePtr_t)memChainAlloc(memId,count_isizeof(captionService_t));
	2273	if ((*descripPtr)->service == 0)
	2274	{
	2275	memChainDestroy(memId);
	2276	return DHL_FAIL_OUT_OF_RESOURCE;
	2277	}
	2278	int nPos = 3;
	2279	for (int i=0; i<count_i; i++) {
	2280	(*descripPtr)->service[i].language[0] = p[nPos++];
	2281	(*descripPtr)->service[i].language[1] = p[nPos++];
	2282	(*descripPtr)->service[i].language[2] = p[nPos++];
	2283	(*descripPtr)->service[i].language[3] = 0;
	2284	(*descripPtr)->service[i].cc_type = (cc_type_k)((p[nPos] >> 7) & 0x01);
	2285	if ((*descripPtr)->service[i].cc_type == cct_line21)
	2286	{
	2287	(*descripPtr)->service[i].cc_id.line21_field = (line21_field_k)(p[nPos] &0x01);
	2288	}
	2289	else
	2290	{
	2291	(*descripPtr)->service[i].cc_id.caption_service_number = (p[nPos] &0x3F);
	2292	}
	2293	nPos++;
	2294	(*descripPtr)->service[i].easy_reader = (p[nPos] >> 7) & 0x01;
	2295	(*descripPtr)->service[i].wide_aspect_ratio = (p[nPos] >> 6) & 0x01;
	2296	(*descripPtr)->service[i].korean_code = (p[nPos] >> 5) & 0x01;
	2297	nPos += 2;
	2298	}
	2299
	2300	/* parsing complete */
	2301	(((memId_t )(*descripPtr))-1) = memId;
	2302	memId = 0; /* so memChain not deleted */
	2303
	2304	//ParseDescriptorExit:
	2305	memChainDestroy(memId); /* delete the descriptor memory */
	2306	return 0;
	2307	}
	2308
	2309	/*==============================================================================
	2310	void DHL_PSI_FreeMpegDescriptor (void *descriptorPtr)
	2311
	2312	descriptorPtr Pointer to a parsed descriptor.
	2313
	2314	Frees the memory associated with a parsed descriptor.
	2315	==============================================================================*/
	2316	void DHL_PSI_FreeMpegDescriptor (void *descriptorPtr)
	2317	{
	2318	if(descriptorPtr ) memChainDestroy((((memId_t )descriptorPtr)-1));
	2319	}
	2320
	2321	/*==============================================================================
	2322	ParseAc3AudioStreamDescriptor
	2323
	2324	*p: Pointer to the un-parsed descriptor.
	2325	*descripPtr Pointer to parsed descriptor passed here.
	2326
	2327	Parses the descriptor and passes the result back via the descripPtr variable.
	2328	==============================================================================*/
	2329	int DHL_PSI_ParseAc3AudioStreamDescriptor (DS_U8* p, ac3AudioStreamDescriptorPtr_t *descripPtr)
	2330	{
	2331	/* create the memChain */
	2332	memId_t memId;
	2333	if (memChainCreate(&memId)) return DHL_FAIL_OUT_OF_RESOURCE;
	2334	/* create the descriptor memory */
	2335	descripPtr = (ac3AudioStreamDescriptorPtr_t)((memId_t )(memChainAlloc(memId,sizeof(ac3AudioStreamDescriptor_t)+sizeof(memId_t))) + 1);
	2336	if (*descripPtr == 0)
	2337	{
	2338	memChainDestroy(memId);
	2339	return DHL_FAIL_OUT_OF_RESOURCE;
	2340	}
	2341
	2342	/* parse the descriptor */
	2343	DS_U8 length = p[1];
	2344	(*descripPtr)->sample_rate_code = (sample_rate_code_k)((p[2] >> 5) & 0x07);
	2345	(*descripPtr)->bsid = (p[2] & 0x1F);
	2346	(*descripPtr)->bit_rate_code = (bit_rate_code_k) ((p[3] >> 2) & 0x3F);
	2347	(*descripPtr)->surround_mode = (surround_mode_k)(p[3] & 0x03);
	2348	(*descripPtr)->bsmod = (bit_stream_mode_k)((p[4] >> 5) & 0x07);
	2349	(*descripPtr)->num_channels = (num_channels_k)((p[4] >> 1) & 0x0F);
	2350	(*descripPtr)->full_svc = (p[4] & 0x01);
	2351	int nPos = 5;
	2352	if (length > 3) {
	2353	(*descripPtr)->additional_elements1 = true;
	2354	(*descripPtr)->langcod = (language_code_k)p[nPos++];
	2355
	2356	/* compute length of lang2 field */
	2357	DS_U8 lang2_len = (*descripPtr)->num_channels == nc_acmod_1_1 ? 1 : 0;
	2358
	2359	if (length > 4 && lang2_len) {
	2360	(*descripPtr)->langcod2 = (language_code_k)p[nPos++];
	2361	}
	2362
	2363	if (length > 4+lang2_len) {
	2364	(*descripPtr)->additional_elements2 = true;
	2365	if ((*descripPtr)->bsmod < 2) {
	2366	(*descripPtr)->bsmod_ext.mainid = (p[nPos++] >> 5) & 0x07;
	2367	}
	2368	else {
	2369	(*descripPtr)->bsmod_ext.asvcflags = (p[nPos++] >> 5);
	2370	}
	2371
	2372	if (length > 5+lang2_len) {
	2373	DS_U16 count_i = (*descripPtr)->textlen = (p[nPos] >> 1) & 0x7F;
	2374	(*descripPtr)->text_code = (text_code_k)(p[nPos++] & 0x01);
	2375	(*descripPtr)->text = 0;
	2376	if (count_i > 0)
	2377	{
	2378	(descripPtr)->text = (DS_U8 )memChainAlloc(memId,count_i*sizeof(DS_U8));
	2379	if ((*descripPtr)->text == 0)
	2380	{
	2381	memChainDestroy(memId);
	2382	return DHL_FAIL_OUT_OF_RESOURCE;
	2383	}
	2384	for (int i=0; i<count_i; i++)
	2385	{
	2386	(*descripPtr)->text[i] = p[nPos++];
	2387	}
	2388	}
	2389	(*descripPtr)->langflag = 0;
	2390	(*descripPtr)->langflag_2 = 0;
	2391	(*descripPtr)->language[0] = 0;
	2392	(*descripPtr)->language[1] = 0;
	2393	(*descripPtr)->language[2] = 0;
	2394	(*descripPtr)->language[3] = 0;
	2395	(*descripPtr)->language2[0] = 0;
	2396	(*descripPtr)->language2[1] = 0;
	2397	(*descripPtr)->language2[2] = 0;
	2398	(*descripPtr)->language2[3] = 0;
	2399	if (length > 5+lang2_len+1+count_i)
	2400	{
	2401	/* see if we have 0, 1, or 2 ISO 639 language fields */
	2402	(*descripPtr)->langflag = (p[nPos] >> 7) & 0x01;
	2403	(*descripPtr)->langflag_2 =(p[nPos] >> 6) & 0x01;
	2404	nPos++;
	2405	int lang639_len = 6 + lang2_len + 1 + count_i;
	2406	if (((*descripPtr)->langflag) &&
	2407	(length >= lang639_len + 3))
	2408	{
	2409	lang639_len += 3; /* so lang2 is independent! */
	2410	(*descripPtr)->language[0] =p[nPos++];
	2411	(*descripPtr)->language[1] =p[nPos++];
	2412	(*descripPtr)->language[2] =p[nPos++];
	2413	(*descripPtr)->language[3] = 0;
	2414	}
	2415
	2416	if (((*descripPtr)->langflag_2) &&
	2417	(length >= lang639_len + 3))
	2418	{
	2419	(*descripPtr)->language2[0] = p[nPos++];
	2420	(*descripPtr)->language2[1] = p[nPos++];
	2421	(*descripPtr)->language2[2] = p[nPos++];
	2422	(*descripPtr)->language2[3] = 0;
	2423	}
	2424	}
	2425	}
	2426	}
	2427	}
	2428
	2429	/* Ignore remaining 'additional_info' bytes */
	2430
	2431	/* parsing complete */
	2432	(((memId_t )(*descripPtr))-1) = memId;
	2433	memId = 0; /* so memChain not deleted */
	2434
	2435	// ParseDescriptorExit:
	2436	// if (bits) {
	2437	// /* delete the bitBuffer */
	2438	// bitBufferDestroy(bits);
	2439	// }
	2440	if (memId) {
	2441	/* delete the descriptor memory */
	2442	memChainDestroy(memId);
	2443	}
	2444	return 0;
	2445	}
	2446
	2447	/*==============================================================================
	2448	DHL_RESULT DHL_PSI_ParseMGTSection (DS_U8 section, mgtSectionPtr_t mgtSectionPtr)
	2449
	2450	*section: Pointer to the first byte of the section.
	2451	*mgtSectionPtr: Return pointer to a parsed MGT section.
	2452
	2453	Parses an MGT section and returns the decoded section via the provided
	2454	handle.
	2455	==============================================================================*/
	2456	int DHL_PSI_ParseMGTSection (DS_U8 section, mgtSectionPtr_t mgtSectionPtr)
	2457	{
	2458	if (get_section_syntax_indicator(section) == 0)
	2459	{
	2460	DST_Printf("MGT: section_syntax_indicator not set\n");
	2461	}
	2462	if (get_private_indicator(section) == 0)
	2463	{
	2464	DST_Printf("MGT: private_indicator not set\n");
	2465	}
	2466
	2467	int section_length = get_section_length(section);
	2468	if (section_length > 4093)
	2469	{
	2470	DST_Printf("MGT: section_length=%d\n",section_length);
	2471	return DHL_FAIL_INVALID_PARAM;
	2472	}
	2473
	2474	/* create the memChain */
	2475	memId_t memId;
	2476	if (memChainCreate(&memId))
	2477	{
	2478	return DHL_FAIL_OUT_OF_RESOURCE;
	2479	}
	2480	/* allocate memory for mgtSection */
	2481	mgtSectionPtr_t mgtSectPtr = (mgtSectionPtr_t)((memId_t *)(memChainAlloc(memId,sizeof(mgtSection_t)+sizeof(memId_t))) + 1);
	2482	if (mgtSectPtr == 0)
	2483	{
	2484	memChainDestroy(memId);
	2485	return DHL_FAIL_OUT_OF_RESOURCE;
	2486	}
	2487
	2488	DS_U8 *p = section;
	2489
	2490
	2491
	2492	/* parse section */
	2493	DS_U16 table_id_extension = p[3]256+p[4];//(p[nPos++]256) + p[nPos++];
	2494	if (table_id_extension != 0x0000) {
	2495	/DST_Printf("MGT: table_id_extension != 0x0000");/
	2496	}
	2497	DST_Printf("table_id_extension=%d\n",table_id_extension);
	2498	mgtSectPtr->version_number = (p[5] >> 1) & 0x1F;
	2499
	2500	int current_next_indicator = p[5]&0x01;
	2501	DST_Printf("mgtSectPtr->version_number=%d\n",mgtSectPtr->version_number);
	2502	DST_Printf("current_next_indicator=%d\n",current_next_indicator);
	2503
	2504	if (current_next_indicator != 1) {
	2505	DST_Printf("MGT: current_next_indicator != 1\n");
	2506	}
	2507	int section_number = p[6];
	2508	DST_Printf("section_number=%d\n",section_number);
	2509	if (section_number != 0x00)
	2510	{
	2511	DST_Printf("MGT: section_number != 0x00\n");
	2512	}
	2513	int last_section_number = p[7];
	2514	DST_Printf("last_section_number=%d\n",last_section_number);
	2515	if (last_section_number != 0x00)
	2516	{
	2517	DST_Printf("MGT: last_section_number != 0x00\n");
	2518	}
	2519	int protocol_version = p[8];
	2520	DST_Printf("protocol_version=%d\n",protocol_version);
	2521	if (protocol_version > 0x00/* PSIP_PROTOCOL_VERSION*/)
	2522	{
	2523	memChainDestroy(memId);
	2524	return DHL_FAIL_INVALID_VERSION;
	2525	}
	2526
	2527	int count_i = mgtSectPtr->tables_defined = p[9]*256 + p[10];
	2528	mgtSectPtr->table = (mgtTablePtr_t)memChainAlloc(memId,count_i*sizeof(mgtTable_t));
	2529	if (mgtSectPtr->table == 0)
	2530	{
	2531	memChainDestroy(memId);
	2532	return DHL_FAIL_OUT_OF_RESOURCE;
	2533	}
	2534	int nPos = 11;
	2535	for (int i=0; i<count_i; i++)
	2536	{
	2537	mgtSectPtr->table[i].table_type = (table_type_k)(p[nPos]*256 + p[nPos+1]);
	2538	nPos += 2;
	2539	mgtSectPtr->table[i].table_type_PID = (p[nPos]&0x1F)*256 + p[nPos+1];
	2540	nPos += 2;
	2541	mgtSectPtr->table[i].table_type_version_number = p[nPos++]&0x1F;
	2542	mgtSectPtr->table[i].number_bytes = p[nPos] * 0x1000000 + p[nPos+1] * 0x10000 + p[nPos+2] * 0x100 + p[nPos+3];
	2543	nPos += 4;
	2544	int count_j = mgtSectPtr->table[i].descriptor_length= (p[nPos]&0x0F)*256 + p[nPos+1];
	2545	nPos += 2;
	2546	mgtSectPtr->table[i].descriptors = (DS_U8 *)memChainAlloc(memId,count_j);
	2547	if (mgtSectPtr->table[i].descriptors == 0)
	2548	{
	2549	memChainDestroy(memId);
	2550	return DHL_FAIL_OUT_OF_RESOURCE;
	2551	}
	2552
	2553	for (int j=0; j<count_j; j++)
	2554	{
	2555	mgtSectPtr->table[i].descriptors[j] = p[nPos++];
	2556	}
	2557	}
	2558	count_i = mgtSectPtr->descriptor_length = (p[nPos]&0x0F)*256 + p[nPos+1];
	2559	nPos += 2;
	2560	mgtSectPtr->descriptors = (DS_U8 *)memChainAlloc(memId,count_i);
	2561	if (mgtSectPtr->descriptors == 0)
	2562	{
	2563	memChainDestroy(memId);
	2564	return DHL_FAIL_OUT_OF_RESOURCE;
	2565	}
	2566
	2567	for (int i=0; i<count_i; i++)
	2568	{
	2569	mgtSectPtr->descriptors[i] = p[nPos++];
	2570	}
	2571
	2572	mgtSectPtr->CRC32 = p[nPos] * 0x1000000 + p[nPos+1] * 0x10000 + p[nPos+2] * 0x100 + p[nPos+3];
	2573	nPos += 4;
	2574	/* parsing complete */
	2575	(((memId_t )mgtSectPtr)-1) = memId;
	2576	memId = 0; /* so memChain not deleted */
	2577
	2578	//ParseExit:
	2579	memChainDestroy(memId);
	2580	*mgtSectionPtr = mgtSectPtr;
	2581	return 0;
	2582	}
	2583
	2584	/*==============================================================================
	2585	DHL_RESULT DHL_PSI_ParseEIT (DS_U8 *sectionArr, eitPtr_t eitPtr)
	2586
	2587	**sectionArr: Array of pointers to all EIT sections.
	2588	*eitPtr: Returned pointer to the parsed EIT.
	2589
	2590	Parses an EIT and returns the parsed table via the return pointer.
	2591	==============================================================================*/
	2592	int DHL_PSI_ParseEIT (DS_U8 *sectionArr, eitPtr_t eitPtr)
	2593	{
	2594	// DS_U8 numSections;
	2595	// DS_U16 numEvents;
	2596	// DS_U16 section_length;
	2597	// DS_U8 protocol_version;
	2598	// DS_U16 i,j,k;
	2599	// DS_U16 count_j, count_k;
	2600	// memChainSetup_t memSetup = {MEM_LIMIT,0,0};
	2601	// memId_t memId = 0;
	2602	// bitBufferPtr_t bits = 0;
	2603	// DHL_RESULT err;
	2604
	2605	if (sectionArr == 0 \|\| (eitPtr == 0))
	2606	{
	2607	return (DHL_FAIL_NULL_POINTER);
	2608	}
	2609	if (sectionArr[0] == 0)
	2610	{
	2611	return (DHL_FAIL_NULL_POINTER);
	2612	}
	2613	int numSections = get_last_section_number(sectionArr[0]) + 1;
	2614
	2615	/* now verify all other sections are present */
	2616	for (int i=1; i<numSections; i++)
	2617	{
	2618	if (sectionArr[i] == 0)
	2619	{
	2620	DST_Printf("EIT : null section found.\r\n");
	2621	return (DHL_FAIL_NULL_POINTER);
	2622	}
	2623	}
	2624
	2625	/check protocol version of each section./
	2626	for (int i=0; i< numSections ; i++ )
	2627	{
	2628	if(sectionArr[i][8] != 0/PSIP_PROTOCOL_VERSION/)
	2629	{
	2630	DST_Printf("EIT : invalid Protocol Version.\r\n");
	2631	return DHL_FAIL_INVALID_VERSION;
	2632	}
	2633	}
	2634	/* create the memChain */
	2635	memId_t memId = 0;
	2636	if (memChainCreate(&memId))
	2637	{
	2638	return DHL_FAIL_OUT_OF_RESOURCE;
	2639	}
	2640	/* allocate memory for eit */
	2641	eitPtr = (eitPtr_t)((memId_t )(memChainAlloc(memId,sizeof(eit_t)+sizeof(memId_t))) + 1);
	2642	if (eitPtr == 0)
	2643	{
	2644	memChainDestroy(memId);
	2645	return DHL_FAIL_OUT_OF_RESOURCE;
	2646	}
	2647
	2648	/* Get the total number of channels in all sections */
	2649	int numEvents = 0;
	2650	for (int i=0; i<numSections; i++)
	2651	{
	2652	numEvents += sectionArr[i][9];
	2653	}
	2654
	2655	(*eitPtr)->numEvents = numEvents;
	2656
	2657	/* allocate space in eit for events */
	2658	(eitPtr)->event = (eitEventPtr_t)memChainAlloc(memId,numEventssizeof(eitEvent_t));
	2659	if ((*eitPtr)->event == 0)
	2660	{
	2661	memChainDestroy(memId);
	2662	return DHL_FAIL_OUT_OF_RESOURCE;
	2663	}
	2664
	2665	/* Parse each section and copy channels */
	2666	numEvents = 0;
	2667	for (int i=0; i<numSections; i++)
	2668	{
	2669	/* create the bitBuffer */
	2670	//int section_length = get_section_length(sectionArr[i]);
	2671	//err = bitBufferCreate(&bits,&(sectionArr[i][3]),section_length);
	2672	//if (err) {
	2673	// goto ParseExit;
	2674	//}
	2675	DS_U8 *p = &sectionArr[i][3];
	2676	/* Parse the section */
	2677	(eitPtr)->source_id = p[0] 256 + p[1];
	2678	//bitBufferSkipBits(bits,2); /* reserved */
	2679	(*eitPtr)->version_number = (p[2] >> 1) & 0x1F;
	2680	//bitBufferSkipBits(bits,1); /* current_next_indicator */
	2681	//bitBufferSkipBits(bits,8); /* section_number */
	2682	//bitBufferSkipBits(bits,8); /* last_section_number */
	2683	int protocol_version = p[5];
	2684	if (protocol_version > 0/PSIP_PROTOCOL_VERSION/)
	2685	{
	2686	memChainDestroy(memId);
	2687	return DHL_FAIL_INVALID_VERSION;
	2688	}
	2689	int count_j = p[6];//bitBufferGetBits(bits,8);
	2690	int nPos = 7;
	2691	for (int j=0; j<count_j; j++) {
	2692	//bitBufferSkipBits(bits,2); /* reserved */
	2693	(eitPtr)->event[numEvents].event_id = (p[nPos]&0x3F)0x100 + p[nPos+1]; //bitBufferGetBits(bits,14);
	2694	nPos += 2;
	2695	(eitPtr)->event[numEvents].start_time = p[nPos] 0x1000000 + p[nPos+1] * 0x10000 + p[nPos+2] * 0x100 + p[nPos+3];//bitBufferGetBits(bits,32);
	2696	nPos += 4;
	2697	//bitBufferSkipBits(bits,2); /* reserved */
	2698	(*eitPtr)->event[numEvents].ETM_location = (ETM_location_k)((p[nPos] >> 4) & 0x03); //(ETM_location_k)bitBufferGetBits(bits,2);
	2699	(eitPtr)->event[numEvents].length_in_seconds = (p[nPos]&0x0F) 0x10000 + p[nPos+1] * 0x100 + p[nPos+2];//bitBufferGetBits(bits,20);
	2700	nPos += 3;
	2701	int count_k = (*eitPtr)->event[numEvents].title_length = p[nPos]; //bitBufferGetBits(bits,8);
	2702	nPos += 1;
	2703	(eitPtr)->event[numEvents].title = (DS_U8 )memChainAlloc(memId, count_k);
	2704	//checkMemoryError((*eitPtr)->event[numEvents].title);
	2705	if ((*eitPtr)->event[numEvents].title == 0)
	2706	{
	2707	memChainDestroy(memId);
	2708	return DHL_FAIL_OUT_OF_RESOURCE;
	2709	}
	2710	for (int k=0; k<count_k; k++)
	2711	{
	2712	(*eitPtr)->event[numEvents].title[k] = p[nPos++];
	2713	}
	2714
	2715	//bitBufferSkipBits(bits,4); /* reserved */
	2716	count_k = (eitPtr)->event[numEvents].descriptor_length= (p[nPos]&0x0F) 0x100 + p[nPos+1] ;//bitBufferGetBits(bits,12);
	2717	nPos += 2;
	2718	(eitPtr)->event[numEvents].descriptors = (DS_U8 )memChainAlloc(memId,count_k);
	2719	if ((*eitPtr)->event[numEvents].descriptors == 0)
	2720	{
	2721	memChainDestroy(memId);
	2722	return DHL_FAIL_OUT_OF_RESOURCE;
	2723	}
	2724
	2725	for (int k=0; k<count_k; k++) {
	2726	(*eitPtr)->event[numEvents].descriptors[k]= p[nPos++];
	2727	}
	2728
	2729	numEvents++;
	2730	}
	2731
	2732	// bitBufferDestroy(bits);
	2733	// bits = 0;
	2734	}
	2735
	2736	/* parsing complete */
	2737	(((memId_t )(*eitPtr))-1) = memId;
	2738	memId = 0; /* so memChain not deleted */
	2739
	2740	//ParseExit:
	2741	// if (bits) {
	2742	// bitBufferDestroy(bits);
	2743	// }
	2744	if (memId) {
	2745	/* delete the cvct memory */
	2746	memChainDestroy(memId);
	2747	}
	2748	return 0;
	2749	}
	2750
	2751	/*==============================================================================
	2752	DHL_RESULT DHL_PSI_ParseETTSection (DS_U8 section, ettSectionPtr_t ettSectionPtr)
	2753
	2754	*section: Pointer to the first byte of the section.
	2755	*ettSectionPtr: Return pointer to a parsed ETT section.
	2756
	2757	Parses an ETT section and returns the decoded section via the provided
	2758	handle.
	2759	==============================================================================*/
	2760	int DHL_PSI_ParseETTSection (DS_U8 section, ettSectionPtr_t ettSectionPtr)
	2761	{
	2762	if (get_section_syntax_indicator(section) == 0)
	2763	{
	2764	DST_Printf("ETT: section_syntax_indicator not set\n");
	2765	}
	2766	if (get_private_indicator(section) == 0)
	2767	{
	2768	DST_Printf("ETT: private_indicator not set\n");
	2769	}
	2770
	2771	int section_length = get_section_length(section);
	2772	if (section_length > 4093)
	2773	{
	2774	DST_Printf("ETT: section_length=%d\n",section_length);
	2775	return DHL_FAIL_INVALID_PARAM;
	2776	}
	2777
	2778	/* create the memChain */
	2779	memId_t memId = 0;
	2780	if (memChainCreate(&memId))
	2781	{
	2782	return DHL_FAIL_OUT_OF_RESOURCE;
	2783	}
	2784	/* allocate memory for ettSection */
	2785	ettSectionPtr_t ettSectPtr = (ettSectionPtr_t)((memId_t *)(memChainAlloc(memId,sizeof(ettSection_t)+sizeof(memId_t))) + 1);
	2786	//checkMemoryError(ettSectPtr);
	2787	if (ettSectPtr == 0)
	2788	{
	2789	memChainDestroy(memId);
	2790	return DHL_FAIL_OUT_OF_RESOURCE;
	2791	}
	2792
	2793	/* parse section */
	2794	DS_U8 *p = &section[3];
	2795	int table_id_extension = p[0] * 0x100 + p[1];
	2796	if (table_id_extension != 0x0000) {
	2797	/DST_Printf("ETT: table_id_extension != 0x0000\n");/
	2798	}
	2799	ettSectPtr->version_number = (p[2]>>1)&0x1F;
	2800	int current_next_indicator = p[2] & 0x01;
	2801	if (current_next_indicator != 1)
	2802	{
	2803	DST_Printf("ETT: current_next_indicator != 1\n");
	2804	}
	2805	int section_number = p[3];
	2806	//DST_Printf("section_number=%d\n",section_number);
	2807	if (section_number != 0x00)
	2808	{
	2809	DST_Printf("ETT: section_number != 0x00\n");
	2810	}
	2811	int last_section_number = p[4];
	2812	//DST_Printf("last_section_number=%d\n",last_section_number);
	2813	if (last_section_number != 0x00)
	2814	{
	2815	DST_Printf("ETT: last_section_number != 0x00\n");
	2816	}
	2817	int protocol_version = p[5];
	2818	//DST_Printf("protocol_version=%d\n",protocol_version);
	2819	//T();
	2820	if (protocol_version > 0/PSIP_PROTOCOL_VERSION/)
	2821	{
	2822	memChainDestroy(memId);
	2823	return DHL_FAIL_INVALID_VERSION;
	2824	}
	2825
	2826	ettSectPtr->ETM_id = p[6]0x1000000 + p[7]0x10000 + p[8]*0x100 + p[9];
	2827	//DST_Printf("ettSectPtr->ETM_id=%d\n",ettSectPtr->ETM_id);
	2828	int count_i = ettSectPtr->extended_text_message_length = section_length - 14;
	2829	ettSectPtr->extended_text_message = (DS_U8 *)memChainAlloc(memId, count_i);
	2830	if (ettSectPtr->extended_text_message == 0)
	2831	{
	2832	memChainDestroy(memId);
	2833	return DHL_FAIL_OUT_OF_RESOURCE;
	2834	}
	2835	for (int i=0; i<count_i; i++)
	2836	{
	2837	ettSectPtr->extended_text_message[i] = p[10+i];
	2838	}
	2839
	2840	/* parsing complete */
	2841	(((memId_t )ettSectPtr)-1) = memId;
	2842	memId = 0; /* so memChain not deleted */
	2843
	2844	if (memId) {
	2845	/* delete the cvctSection memory */
	2846	memChainDestroy(memId);
	2847	}
	2848
	2849	*ettSectionPtr = ettSectPtr;
	2850	return 0;
	2851	}
	2852
	2853	/*==============================================================================
	2854	DHL_RESULT DHL_PSI_ParseCVCTSection (DS_U8 section, cvctSectionPtr_t cvctSectionPtr)
	2855
	2856	*section: Pointer to the first byte of the section.
	2857	*cvctSectionPtr: Return pointer to a parsed CVCT section.
	2858
	2859	Parses an CVCT section and returns the decoded section via the provided
	2860	handle.
	2861	==============================================================================*/
	2862	static int DHL_PSI_ParseCVCTSection (DS_U8 section, cvctSectionPtr_t cvctSectionPtr)
	2863	{
	2864	// cvctSectionPtr_t cvctSectPtr = 0;
	2865	// memChainSetup_t memSetup = {MEM_LIMIT,0,0};
	2866	// DS_U16 section_length;
	2867	// DS_U8 protocol_version;
	2868	//
	2869	// bitBufferPtr_t bits = 0;
	2870	// DS_S32 count_i,count_j;
	2871	// DS_S32 i,j;
	2872	// DHL_RESULT err = DHL_OK;
	2873
	2874	if (get_section_syntax_indicator(section) == 0)
	2875	{
	2876	DST_Printf("CVCT: section_syntax_indicator not set\n");
	2877	}
	2878	if (get_private_indicator(section) == 0)
	2879	{
	2880	DST_Printf("CVCT: private_indicator not set\n");
	2881	}
	2882
	2883	DS_U16 section_length = get_section_length(section);
	2884	if (section_length > 1021)
	2885	{
	2886	DST_Printf("CVCT: section_length=%d\n",section_length);
	2887	return DHL_FAIL_INVALID_PARAM;
	2888	}
	2889	memId_t memId = 0;
	2890	if (memChainCreate(&memId)) /* create the memChain */
	2891	{
	2892	return DHL_FAIL_OUT_OF_RESOURCE;
	2893	}
	2894	/* allocate memory for cvctSection */
	2895	cvctSectionPtr_t cvctSectPtr = (cvctSectionPtr_t)((memId_t *)(memChainAlloc(memId,sizeof(cvctSection_t)+sizeof(memId_t))) + 1);
	2896	if (cvctSectPtr == 0)
	2897	{
	2898	memChainDestroy(memId);
	2899	return DHL_FAIL_OUT_OF_RESOURCE;
	2900	}
	2901	DS_U8 *p = section + 3;
	2902	/* parse section */
	2903	cvctSectPtr->transport_stream_id = p[0] * 0x100 + p[1];
	2904	//bitBufferSkipBits(bits,2); /* reserved */
	2905	cvctSectPtr->version_number = (p[2] >> 1) & 0x1F;
	2906	cvctSectPtr->current_next_indicator = p[2] & 0x01;
	2907	cvctSectPtr->section_number = p[3];
	2908	cvctSectPtr->last_section_number = p[4];
	2909
	2910	DS_U8 protocol_version = p[5];
	2911	if (protocol_version > 0 /PSIP_PROTOCOL_VERSION/)
	2912	{
	2913	memChainDestroy(memId);
	2914	return DHL_FAIL_INVALID_VERSION;
	2915	}
	2916
	2917	int count_i = cvctSectPtr->num_channels_in_section = p[6];
	2918	cvctSectPtr->channel = (cvctChannelPtr_t)memChainAlloc(memId,count_i*sizeof(cvctChannel_t));
	2919	if (cvctSectPtr->channel == 0)
	2920	{
	2921	memChainDestroy(memId);
	2922	return DHL_FAIL_OUT_OF_RESOURCE;
	2923	}
	2924	p += 7;
	2925	int nPos = 0;
	2926	for (int i=0; i<count_i; i++)
	2927	{
	2928	for (int j=0; j<7; j++)
	2929	{
	2930	cvctSectPtr->channel[i].short_name[j] = p[nPos] * 0x100 + p[nPos+1];
	2931	nPos+=2;
	2932	}
	2933	//bitBufferSkipBits(bits,4); /* reserved */
	2934	cvctSectPtr->channel[i].major_channel_number = ((p[nPos] >> 4) & 0x0F) * 0x40 + ((p[nPos+1] >> 2) & 0x3F);
	2935	#ifdef ENABLE_SYNTAX_CHECKING
	2936	if (cvctSectPtr->channel[i].major_channel_number < CABL_MAJOR_CHAN_MIN \|\| cvctSectPtr->channel[i].major_channel_number > CABL_MAJOR_CHAN_MAX) {
	2937	DST_Printf("CVCT: major_channel_number=%d\n",cvctSectPtr->channel[i].major_channel_number);
	2938	err = DHL_FAIL_INVALID_PARAM;
	2939	goto ParseExit;
	2940	}
	2941	#endif /* ENABLE_SYNTAX_CHECKING */
	2942	cvctSectPtr->channel[i].minor_channel_number = (p[nPos+1] & 0x03) * 0x100 + p[nPos+2];
	2943	#ifdef ENABLE_SYNTAX_CHECKING
	2944	if (cvctSectPtr->channel[i].minor_channel_number > CABL_MINOR_CHAN_MAX) {
	2945	DST_Printf("CVCT: minor_channel_number=%d\n",cvctSectPtr->channel[i].minor_channel_number);
	2946	err = DHL_FAIL_INVALID_PARAM;
	2947	goto ParseExit;
	2948	}
	2949	#endif /* ENABLE_SYNTAX_CHECKING */
	2950	nPos+=3;
	2951	cvctSectPtr->channel[i].modulation_mode = (modulation_mode_k)p[nPos++];
	2952	cvctSectPtr->channel[i].carrier_frequency = p[nPos] * 0x1000000 + p[nPos+1] * 0x10000 + p[nPos+2] * 0x100 + p[nPos+3];
	2953	nPos+=4;
	2954	cvctSectPtr->channel[i].channel_TSID = p[nPos] * 0x100 + p[nPos+1];
	2955	nPos+=2;
	2956	cvctSectPtr->channel[i].program_number = p[nPos] * 0x100 + p[nPos+1];
	2957	nPos+=2;
	2958	cvctSectPtr->channel[i].ETM_location = (ETM_location_k)((p[nPos] >> 6) & 0x03);
	2959	cvctSectPtr->channel[i].access_controlled = ((p[nPos] >> 5) & 0x01);
	2960	cvctSectPtr->channel[i].hidden = ((p[nPos] >> 4) & 0x01);
	2961	cvctSectPtr->channel[i].path_select = (path_select_k) ((p[nPos] >> 3) & 0x01);
	2962	cvctSectPtr->channel[i].out_of_band = ((p[nPos] >> 2) & 0x01);
	2963	cvctSectPtr->channel[i].show_guide = ((p[nPos] >> 1) & 0x01);
	2964	//bitBufferSkipBits(bits,3); /* reserved */
	2965	nPos++;
	2966	cvctSectPtr->channel[i].service_type = (service_type_k)(p[nPos++] & 0x3F);
	2967	cvctSectPtr->channel[i].source_id = p[nPos] * 0x100 + p[nPos+1];
	2968	nPos+=2;
	2969	//bitBufferSkipBits(bits,6); /* reserved */
	2970	int count_j = cvctSectPtr->channel[i].descriptor_length = (p[nPos]&0x03) * 0x100 + p[nPos+1];
	2971	nPos+=2;
	2972	cvctSectPtr->channel[i].descriptors = (DS_U8 *)memChainAlloc(memId,count_j);
	2973	if (cvctSectPtr->channel[i].descriptors == 0)
	2974	{
	2975	memChainDestroy(memId);
	2976	return DHL_FAIL_OUT_OF_RESOURCE;
	2977	}
	2978	for (int j=0; j<count_j; j++) {
	2979	cvctSectPtr->channel[i].descriptors[j] = p[nPos++];
	2980	}
	2981	}
	2982	//bitBufferSkipBits(bits,6); /* reserved */
	2983	cvctSectPtr->additional_descriptors = (DS_U8 *)memChainAlloc(memId,count_i);
	2984	if (cvctSectPtr->additional_descriptors == 0)
	2985	{
	2986	memChainDestroy(memId);
	2987	return DHL_FAIL_OUT_OF_RESOURCE;
	2988	}
	2989
	2990	for (int i=0; i<count_i; i++) {
	2991	cvctSectPtr->additional_descriptors[i] = p[nPos++];
	2992	}
	2993
	2994	/* parsing complete */
	2995	(((memId_t )cvctSectPtr)-1) = memId;
	2996	memId = 0; /* so memChain not deleted */
	2997
	2998	//ParseExit:
	2999
	3000	if (memId) {
	3001	/* delete the cvctSection memory */
	3002	memChainDestroy(memId);
	3003	}
	3004
	3005	*cvctSectionPtr = cvctSectPtr;
	3006	return 0;
	3007	}
	3008
	3009	/*==============================================================================
	3010	DHL_RESULT DHL_PSI_ParseCVCT (DS_U8 *sectionArr, cvctPtr_t cvctPtr)
	3011
	3012	**sectionArr: Array of pointers to all CVCT sections.
	3013	*cvctPtr: Returned pointer to the parsed CVCT.
	3014
	3015	Parses an CVCT and returns the parsed table via the return pointer.
	3016	==============================================================================*/
	3017	int DHL_PSI_ParseCVCT (DS_U8 *sectionArr, cvctPtr_t cvctPtr)
	3018	{
	3019	// DS_U8 numSections;
	3020	// DS_U16 numChannels;
	3021	//
	3022	// DS_U16 i,j;
	3023	// memChainSetup_t memSetup = {MEM_LIMIT_BIG,0,0};
	3024	// memId_t memId = 0;
	3025	// DHL_RESULT err;
	3026
	3027
	3028	if (sectionArr == 0 \|\| (cvctPtr == 0))
	3029	{
	3030	return (DHL_FAIL_NULL_POINTER);
	3031	}
	3032
	3033	if (sectionArr[0] == 0)
	3034	{
	3035	return (DHL_FAIL_NULL_POINTER);
	3036	}
	3037	DS_U8 numSections = get_last_section_number(sectionArr[0]) + 1;
	3038
	3039	/* now verify all other sections are present */
	3040	for (int i=1; i<numSections; i++)
	3041	{
	3042	if (sectionArr[i] == 0)
	3043	{
	3044	DST_Printf("CVCT : invalid section found.\r\n");
	3045	return (DHL_FAIL_NULL_POINTER);
	3046	}
	3047	}
	3048
	3049	/check protocol version of each section./
	3050	for (int i=0; i< numSections ; i++ )
	3051	{
	3052	if(sectionArr[i][8] != 0/PSIP_PROTOCOL_VERSION/)
	3053	{
	3054	DST_Printf("CVCT : invalid Protocol Version.\r\n");
	3055	return DHL_FAIL_INVALID_VERSION;
	3056	}
	3057	}
	3058
	3059	memId_t memId = (memId_t)0;
	3060	if (memChainCreate(&memId)) /* create the memChain */
	3061	{
	3062	return DHL_FAIL_OUT_OF_RESOURCE;
	3063	}
	3064	/* allocate memory for cvct */
	3065	cvctPtr = (cvctPtr_t)((memId_t )(memChainAlloc(memId,sizeof(cvct_t)+sizeof(memId_t))) + 1);
	3066	if (*cvctPtr == 0)
	3067	{
	3068	memChainDestroy(memId);
	3069	return DHL_FAIL_OUT_OF_RESOURCE;
	3070	}
	3071
	3072	/* Get the total number of channels in all sections */
	3073	DS_U16 numChannels = 0;
	3074	for (int i=0; i<numSections; i++)
	3075	{
	3076	numChannels += sectionArr[i][9];
	3077	}
	3078
	3079	(*cvctPtr)->numChannels = numChannels;
	3080
	3081	/* allocate space in cvct for channels */
	3082	(cvctPtr)->channel = (cvctChannelPtr_t)memChainAlloc(memId,numChannelssizeof(cvctChannel_t));
	3083	if ((*cvctPtr)->channel == 0)
	3084	{
	3085	memChainDestroy(memId);
	3086	return DHL_FAIL_OUT_OF_RESOURCE;
	3087	}
	3088
	3089	/* Parse each section and copy channels */
	3090	numChannels = 0;
	3091	for (int i=0; i<numSections; i++) {
	3092	/* Parse the section */
	3093	cvctSectionPtr_t cvctSectPtr = 0;
	3094	int err = DHL_PSI_ParseCVCTSection(sectionArr[i], &cvctSectPtr);
	3095	if (err != 0)
	3096	{
	3097	memChainDestroy(memId);
	3098	return err;
	3099	}
	3100
	3101	if (i == 0) {
	3102	/* duplicate fields copied once */
	3103	(*cvctPtr)->transport_stream_id = cvctSectPtr->transport_stream_id;
	3104	(*cvctPtr)->version_number = cvctSectPtr->version_number;
	3105
	3106	/* allocate space for descriptors and copy (if any) */
	3107	if (cvctSectPtr->additional_descriptor_length > 0)
	3108	{
	3109	(cvctPtr)->additional_descriptors = (DS_U8 )memChainAlloc(memId,cvctSectPtr->additional_descriptor_length*sizeof(DS_U8));
	3110	if ((*cvctPtr)->additional_descriptors == 0)
	3111	{
	3112	DHL_PSI_FreeMpegSection(cvctSectPtr);
	3113	memChainDestroy(memId);
	3114	return DHL_FAIL_OUT_OF_RESOURCE;
	3115	}
	3116	memcpy((cvctPtr)->additional_descriptors,cvctSectPtr->additional_descriptors, (cvctPtr)->additional_descriptor_length);
	3117	}
	3118	}
	3119	for (int j=0; j<cvctSectPtr->num_channels_in_section; j++)
	3120	{
	3121	memcpy(&((*cvctPtr)->channel[numChannels]), &(cvctSectPtr->channel[j]), sizeof(cvctChannel_t));
	3122
	3123	/* allocate space for descriptors and copy (if any) */
	3124	if (cvctSectPtr->channel[j].descriptor_length > 0)
	3125	{
	3126	(cvctPtr)->channel[numChannels].descriptors = (DS_U8 )memChainAlloc(memId,cvctSectPtr->channel[j].descriptor_length*sizeof(DS_U8));
	3127	if ((*cvctPtr)->channel[numChannels].descriptors == 0)
	3128	{
	3129	DHL_PSI_FreeMpegSection(cvctSectPtr);
	3130	memChainDestroy(memId);
	3131	return DHL_FAIL_OUT_OF_RESOURCE;
	3132	}
	3133
	3134	/memcpy((cvctPtr)->channel[numChannels].descriptors,cvctSectPtr->channel[j].descriptors, (cvctPtr)->channel[j].descriptor_length);/
	3135	/cafrii 030910, bugfix/
	3136	memcpy((cvctPtr)->channel[numChannels].descriptors,cvctSectPtr->channel[j].descriptors, (cvctPtr)->channel[numChannels].descriptor_length);
	3137	}
	3138	numChannels++;
	3139	}
	3140	DHL_PSI_FreeMpegSection(cvctSectPtr);
	3141	}
	3142
	3143	/* parsing complete */
	3144	(((memId_t )(*cvctPtr))-1) = memId;
	3145	memId = 0; /* so memChain not deleted */
	3146
	3147	//ParseExit:
	3148	if (memId) {
	3149	/* delete the cvct memory */
	3150	memChainDestroy(memId);
	3151	}
	3152	return 0;
	3153	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: svn/trunk/zasc/app/DST_Parser.cpp

Download in other formats: