dvb_si.c

DVB软件,基于CT216软件的开发源程序.

#include "ct_type.h"
#include "ct_os.h"

#include <stdio.h>
#include <string.h>
#include "ct_filter.h"                 // daphne
#include "ap_si.h"
#include "dvb_sys.h"
#include "dvb_filt.h"
#include "db_defs.h"
#include "dvb_msg.h"
#include "dvb_fp.h"
#include "dvb_sibk.h"
#include "dvb_av.h"

#ifdef DVB_SYSTEM_S_T
	#include "dvb_dual_nim.h"
	#include "db_api.h"
	#include "user_nv.h"
#endif

#ifdef CONAX
	#include "cx_service.h"
#endif

#include "ap_defs.h"
/*******************************************************************************************/
#if 0
#define SI_MSG(p)
#else
#define SI_MSG(p)			printf p
#endif

#if 1
#define SI_DBG(p)
#else
#define SI_DBG(p) 		printf p
#endif

/*******************************************************************************************/          



#define SUPPORT_UNICODE

//#define RATING_TEST



//#define PMT_BURST_MODIFY

//wilson 2006.10.12 BY_PMT only defined in ap_defs.h
//and there is only 2 mode: PMT or BOTH(SDT is never used)
#ifdef CI_ENABLE
#define CHECK_SCRAMBLE_BY_PMT
#endif
#ifndef  CHECK_SCRAMBLE_BY_PMT
#define CHECK_SCRAMBLE_BY_BOTH
#endif
//#define CHECK_SCRAMBLE_BY_SDT

#ifdef CHECK_SCRAMBLE_BY_BOTH
#define FREE_TYPE       0xff
#define SCRAMBLE_TYPE   0xfe
#endif

//#define BUSY_WAIT
//#define PARALLEL_SDT
#define PUSHING_PID 0x00// 0x1fff

#define MAX_NUM_OF_SERVICE_ITEM 128 // it needs 64 *sizeof(DB_SrvDetail)= 2048 bytes
// and 64*4 = 256 bytes for PAT item
#define TDT_SECTION_LENGTH 16
#define TOT_SECTION_LENGTH 200

#define MAX_GERMANY_SERVICE_ID	117

typedef struct
{
	u16 u16ProgramNumber;
	u16 u16PID;

#ifdef PMT_BURST_MODIFY

	bool8 b8GroupPID;
	bool8 b8Received;
#endif

}stPATItem;

#ifdef ENABLE_LCN_SUPPORT
	#define LCN_VISIBLE_MASK	0x8000

	#define AUSTRALIA_LCN_MASK	0x03FF
	#define NORDIG_LCN_MASK		0x3FFF

	typedef struct _lcn_item
	{
		struct _lcn_item	*pNext;
		
		u16	u16ServiceID;
		u16	u16LCN;
	} ST_LCNItem;
#endif

#ifdef CI_ENABLE
/*************push add**********************************/

static u16 u16CAPMTSecLen, u16PMTSecLen;
static u8 *pu8PMTSec = NULL, *pu8CAPMTSec = NULL;
static DVB_SectionHeader *pstPMTSecHeader;
DVB_ServiceInfo pstServiceInfo;
CTOS_SEMAPHORE capmtSemaphore;
/***********************************************/
//added by linda20070322
static u16*			pu16CaSystemID1 = NULL;
static u16*			pu16CaSystemID2 = NULL;
static u16 			u16CASystemIDCount1=0;
static u16 			u16CASystemIDCount2=0;
#endif

static stPATItem*        pstPATItem=NULL;
static DB_SrvDetail*    pstSrvItem=NULL;
static DB_NetDetail m_stNetItem;

static u8 au8FID2ItemIdx [MAX_FILTER_NUMBER];
static u8* pu8Section=NULL;
static DVB_SectionHeader* pstSecHeader=NULL;
static u8 u8NumOfPatItem, u8OpenedFilter;

static bool8 b8MonitorTDTEnable=FALSE;
static bool8 b8MonitorTOTEnable=FALSE;

static u8 u8TOpenedFilter;
static u8 au8TFiterID[MAX_FILTER_NUMBER];

#ifdef ATSC_SYSTEM
	static u8 u8PioneerSectionOfTVCT, u8LastSectionOfTVCT;
	static u8 u8FIDofFirstTVCT = INVALID_FILTER_ID;
	static bool8 b8TVCTExist = FALSE;
	static u8 u8CurChNo = 0;
#else
	static u8 u8PioneerSectionOfSDT, u8LastSectionOfSDT;
	static u8 u8FIDofFirstSDT = INVALID_FILTER_ID;
	static bool8 b8SDTExist = FALSE;
#endif /* end #ifndef ATSC_SYSTEM */
static u16 u16PreviousVideoPID=0;
static PERFER_AUDIO_TYPE enPerferAudioType=MPG;
/* Shawn add, to check whether there is SDT exist*/

#ifdef ENABLE_LCN_SUPPORT
	static u8 u8PioneerSectionOfNIT, u8LastSectionOfNIT, u8FIDofFirstNIT;
	static u8 u8idx;
	static u8 u8VersionNo;
	static u16 u16NetworkID;
	static EN_LCN_MODE	enLCN_Mode;
	static u16			u16LCNMask;
	static ST_LCNItem	*m_pstLCNList = NULL;
	
	static u16 u16GermanySrvMap [MAX_GERMANY_SERVICE_ID] =
	{
		0X000E, 0X0001, 0X0020, 0X0040, 0X0060, 0X0080, 0X00B0, 0X00D0, 0X00E0, 0X0100,
		0X00A0, 0X0202, 0X4018, 0X4604, 0X4681, 0X4603, 0X4C81, 0X4881, 0X4015, 0X4016, 
		0X401B, 0X4601, 0X4680, 0X4600, 0X4880, 0X4C80, 0X4013, 0X0002, 0X4022, 0X400A, 
		0X0205, 0X4010, 0X400E, 0X4025, 0X4008, 0X4024, 0X0004, 0X0005, 0X0006, 0X400C, 
		0X400D, 0X4020, 0X4021, 0X4012, 0X0082, 0X0084, 0X0081, 0X0083, 0X00A1, 0X0103, 
		0X0104, 0X0105, 0X0106, 0X0107, 0X0108, 0X0109, 0X0102, 0X0101, 0X000F, 0X0064, 
		0X0061, 0X0062, 0X0063, 0X00E1, 0X00E2, 0X0203, 0X00B2, 0X00B1, 0X000C, 0X000B, 
		0X0003, 0X000D, 0X0021, 0X0022, 0X0023, 0X0041, 0X0042, 0X0043, 0X4B00, 0X4D80, 
		0X00D1, 0X4026, 0X4E00, 0X4E01, 0X4E02, 0X4011, 0X4781, 0X4782, 0X4783, 0X4023, 
		0X40C0, 0X4882, 0X4A80, 0X401E, 0X401D, 0X401C, 0X401A, 0X4C82, 0X401F, 0X4E03, 
		0X4007, 0X4E04, 0X4800, 0X4004, 0X4003, 0X4002, 0X4005, 0X4006, 0X4D81, 0X4019, 
		0X400F, 0X400B, 0X4883, 0X0010, 0X4014, 0X4009, 0X4017
	};
	#ifdef LCN_COUNTRY_CHECK_DISABLE
	extern void SetLCNStartNumber (u16 u16Vlcn, u16 u16Alcn);
    extern u16 GetLCNStartNumber (EN_SERVICE_TYPE enSrvType);
	#else
	extern void SetLCNStartNumber (u16 u16lcn);
	#endif
#endif

static char acMsgLang [8]={0, 0, 0, 0, 0, 0, 0, 0};

static char acFirstAudio [8]={0, 0, 0, 0, 0, 0, 0, 0};
static char acSecondAudio [8]={0, 0, 0, 0, 0, 0, 0, 0};

static u8 au8CrcErrorCounter [MAX_FILTER_NUMBER];

static bool8 b8StartParserTP=FALSE;
static bool8 b8ResetLCNinDB = FALSE;

static u16 u16OrgNID=0xffff;
static u16 u16TPID=0xffff;


u8* DVB_ParserFindNextTag(u8 *pu8CurrentDescriptor, u8 *pu8FirstDescriptor, u8 u8Tag, s16 s16TotalLength);
void DVB_SI_HandleWithoutSDT(void);

// extern void sec_flt_show_para(u8 SecFltNo); daphne
void sec_flt_show_para( u8 SecFltNo ) {
//	SecftShowConfig(SecFltNo);
	} // daphne end 

//extern void sec_isr_show_int_count(u8 SecFltNo); daphne
void sec_isr_show_int_count( u8 SecFltNo ) {
//	CT_Secisr_ShowIntCounter(SecFltNo);
	}

extern bool8 pid_flt_show_config(u8 u8PidFltNo);
/*******************************************************************************************/          

void dump_section( u8* pu8Section )
{
	u16 u16SectionLength, u16idx;

	if (pu8Section==NULL)
	{
		return;
	}
	u16SectionLength=PU8TOU16(pu8Section+1)&0x0fff;
	u16SectionLength+=3;
	SI_DBG(("\n\nsection length %d at %x", u16SectionLength, (u32)pu8Section));

#if 1

	for (u16idx=0; u16idx<4; u16idx++)
	{
		SI_DBG((" %02hx,", pu8Section [u16idx]));
	}
	for (u16idx=(u16SectionLength-4); u16idx<u16SectionLength; u16idx++)
	{
		SI_DBG((" %02hx,", pu8Section [u16idx]));
	}	
#else

	for (u16idx=0; u16idx<u16SectionLength; u16idx++)
	{
		if (u16idx%16==0)
		{
			SI_DBG(("\n"));
		}	
		SI_DBG((" %02hx,", pu8Section [u16idx]));
	}
#endif

	SI_DBG(("\n"));
}
/*******************************************************************************************/          

void parse_CloseFilter( u8 u8FID )
{
	au8CrcErrorCounter [u8FID]=0;

	DVB_FilterClose(u8FID);
	u8OpenedFilter--;
}
/*******************************************************************************************/          

#ifdef PMT_BURST_MODIFY

// 	return TRUE  : this PID can open an filter
//	return FALSE : this PID already open an Filter

bool8 CheckPmtOpenFilter( u16 u16PID )
{
	u8 u8FilterCount;

	for (u8FilterCount=0; u8FilterCount<MAX_FILTER_NUMBER; u8FilterCount++)
	{
		if (u16PID==(pstPATItem+au8FID2ItemIdx [u8FilterCount])->u16PID)
		{
			return FALSE;
		}
	}

	return TRUE;
}
/*******************************************************************************************/          

// return TRUE ;  This Filter can close
// return FALSE ;  This Filter can't close
bool8 CheckPmtCloseFilter( u8 u8FID )
{
	u8 u8PatCount;

	for (u8PatCount=0; u8PatCount<u8NumOfPatItem; u8PatCount++)
	{
		if ((pstPATItem+au8FID2ItemIdx [u8FID])->u16PID==(pstPATItem+u8PatCount)->u16PID)
		{
			if ((pstPATItem+u8PatCount)->b8GroupPID==FALSE)
			{
				return TRUE;
			}
			else
			{
				if ((pstPATItem+u8PatCount)->b8Received==FALSE)
				{
					return FALSE;
				}
			}
		}
	}

	return TRUE;
}
/*******************************************************************************************/          

bool8 FindPatItemNumber( u16 u16ProgramNumber, u8* pu8PatItemNumber )
{
	u8 u8PatCount;

	for (u8PatCount=0; u8PatCount<u8NumOfPatItem; u8PatCount++)
	{
		if (u16ProgramNumber==(pstPATItem+u8PatCount)->u16ProgramNumber)
		{
			*pu8PatItemNumber=u8PatCount;

			return TRUE;
		}
	}

	return FALSE;
}
#endif
/*******************************************************************************************/          

u8 bprint=FALSE;

u8 copy_text_from_si( u8 *pu8Des, u8 *pu8Src, u8 u8DesMaxLen, u8 u8SrcLen )
{
	bool8 b8TwoByteChar;

	u8 u8Count, u8StrLen;

	b8TwoByteChar=FALSE;
	u8StrLen=0;

#if 0

	SI_DBG(("\nSI Text: "));

	for (u8Count=0; u8Count<u8SrcLen; u8Count++)
	{
		SI_DBG(("0x%02hx ", pu8Src [u8Count]));
	}

	SI_DBG(("\n"));
#endif

	//please refer EN300 468 AnnexA.2

	if (pu8Src [0]<0x20)
	{
		// specific char table
		if (pu8Src [0]>=0x10&&pu8Src [0]<=0x14)
		{
			b8TwoByteChar=TRUE;
		}
	}

	for (u8Count=0; u8Count<u8SrcLen; u8Count++)
	{

#ifdef SUPPORT_UNICODE

		if (( u8StrLen>=(u8DesMaxLen-3))&&(b8TwoByteChar==TRUE))
		{
			break;
		}
		if (( u8StrLen>=(u8DesMaxLen-1))&&(b8TwoByteChar==FALSE))
		{
			break;
		}	
#else

		if (u8StrLen>=(u8DesMaxLen-1))
		{
			break;
		}	
#endif

		if (b8TwoByteChar==TRUE)
		{

#ifdef SUPPORT_UNICODE

			if ((pu8Src [u8Count]==0x00)&&(pu8Src [0]!=0x14))
#else

				if (pu8Src [u8Count]==0x00)
#endif

				{ // 0x00 makes trouble when string process
					continue;
				}
		}
		else
		{
			if (pu8Src [u8Count]>=0x80&&pu8Src [u8Count]<=0x9F)
			{ // please refer EN300 468 AnnexA.1
				continue;
			}
		}

		pu8Des [u8StrLen]=pu8Src [u8Count];
		u8StrLen++;
	}

	pu8Des [u8StrLen]=0;

#ifdef SUPPORT_UNICODE

	if (pu8Src [0]==0x14)
	{
		pu8Des [u8StrLen+1]=0;
	}
#endif

	return u8StrLen;
}

/*******************************************************************************************/          

bool8 addtfilter (u8 u8FilterID)
{
	u8 u8idx = 0;
	
	if (u8FilterID == INVALID_FILTER_ID)
	{
		return FALSE;
	}	
	for (u8idx = 0; u8idx < MAX_FILTER_NUMBER; u8idx ++)
	{
		if (au8TFiterID[u8idx] == INVALID_FILTER_ID)
		{
			u8TOpenedFilter ++;
			au8TFiterID[u8idx] = u8FilterID;
			return TRUE;
		}	
	}	
	
	return FALSE;
}	
/*******************************************************************************************/          

bool8 deletetfilter (u8 u8FilterID)
{
	u8 u8idx = 0;
	
	if (u8FilterID == INVALID_FILTER_ID)
	{
		return FALSE;
	}	
	for (u8idx = 0; u8idx < MAX_FILTER_NUMBER; u8idx ++)
	{
		if (au8TFiterID[u8idx] == u8FilterID)
		{
			u8TOpenedFilter --;
			au8TFiterID[u8idx] = INVALID_FILTER_ID;
			return TRUE;
		}	
	}	
	
	return FALSE;
}
/*******************************************************************************************/          

void parser_pat( stPATItem* pstPATBuffer, u8* pu8SectionBuffer )
{
	u8 u8PatCount;

#ifdef PMT_BURST_MODIFY

	u8 u8SearchCount;
#endif

	if (pu8SectionBuffer==NULL||pstPATBuffer==NULL)
	{
		return;
	}
	u16TPID = (u16)((((*(pu8Section+3))<<8)&0xFF00)|((*(pu8Section+4))&0x00FF));

	pu8SectionBuffer+=8;
	SI_DBG(("PAT Item # = %d\n", (int)u8NumOfPatItem));

	for (u8PatCount=0; u8PatCount<u8NumOfPatItem; u8PatCount++)
	{
		/* fill program number & PMT PID */
		(pstPATBuffer+u8PatCount)->u16ProgramNumber=PU8TOU16(pu8SectionBuffer+0);

		(pstPATBuffer+u8PatCount)->u16PID=PU8TOU16(pu8SectionBuffer+2)&0x1fff;

		//SI_DBG(("pat u8PatCount[%d] programno[%d]\n", u8PatCount, (pstPATBuffer+u8PatCount)->u16ProgramNumber));
#ifdef PMT_BURST_MODIFY

		(pstPATBuffer+u8PatCount)->b8Received=FALSE;
		(pstPATBuffer+u8PatCount)->b8GroupPID=FALSE;

		for (u8SearchCount=0; u8SearchCount<u8PatCount; u8SearchCount++)
		{
			if ((pstPATBuffer+u8PatCount)->u16PID==(pstPATBuffer+u8SearchCount)->u16PID)
			{
				(pstPATBuffer+u8SearchCount)->b8GroupPID=TRUE;

				(pstPATBuffer+u8PatCount)->b8GroupPID=TRUE;
				break;
			}
		}
#endif

#ifndef PMT_BURST_MODIFY

		SI_DBG(("Item %03d, SID: %04X, PID: %04X\n",
				  (int)u8PatCount,
				  (pstPATBuffer+u8PatCount)->u16ProgramNumber,
				  (pstPATBuffer+u8PatCount)->u16PID));