dvb_eit.c

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

		return FALSE;

	//P->F->S1->S2->S3->....
	while(1)
	{
		//get S1
		//dvb_EitGetDbByIdx(u16StartIdx, &stTmpEitDb);
		if (GetEitDbFirst16Bytes(u16StartIdx, &stTmpEitDb) != EN_EITDB_NO_ERROR)
		{
			return FALSE;
		}	
		if(pstEventInfo->u16EventId == stTmpEitDb.stEitEvent.u16EventId ||
			pstEventInfo->u32StartTime == stTmpEitDb.stEitEvent.u32StartTime)
		{
			//EIT_DBG(("%s,%d> schedule event(%s) already existed in database!\n", __FFLL__, pstEventInfo->au8Name));

			*pu16TargetPreIdx = u16StartIdx;			
			return FALSE; // event already existed
		}
		
		//P->F->New_Target->S1->S2->S3->....
		if(pstEventInfo->u32StartTime < stTmpEitDb.stEitEvent.u32StartTime)
		{
			*pu16TargetPreIdx = stTmpEitDb.u16PreEventIdx;
			*pu16TargetNextIdx = u16StartIdx;
			return TRUE;
		}
		
		// if P->F->S1->NULL, then P->F->S1->New_Target->NULL
		if(stTmpEitDb.u16NextEventIdx == INVALID_LINK_IDX)
		{
			*pu16TargetPreIdx = u16StartIdx;
			*pu16TargetNextIdx = INVALID_LINK_IDX;
			return TRUE;
		}

		u16StartIdx = stTmpEitDb.u16NextEventIdx;
		
		// This just a prevent process falling into while loop
		if(++u16Count > 1200) //It's impossible has a service over 1200 events in 7 days. 
		{
			EIT_DBG(("%s,%d> Find EIT space error, no event->next=INVALID\n", __FFLL__));
			return FALSE;
		}
	}
}


/******************************************************************************************/
/* fill the short and extended desciptor in EPG mode */
bool8 eitbkcheckdesc (ST_EIT_EVENT *pstEventInfoSrc, ST_EIT_EVENT *pstEventInfoDes)
{
/* try to fill the short and extended descriptor */
	if (pstEventInfoDes->pu8ShortEventDesc)
	{
		/* do nothing because the event information already in event list */
		EIT_DBG (("{eitbkcheckdesc} already got the short desc\n"));
	}		
	else
	{
		if (pstEventInfoDes->pu8ExtendEventDesc)
		{
			return TRUE;
		}	
		EIT_DBG (("{eitbkcheckdesc} get the descriptor src[0x%x][0x%x] desc[0x%x][0x%x]\n",
			pstEventInfoSrc->pu8ShortEventDesc, pstEventInfoSrc->pu8ExtendEventDesc,
			pstEventInfoDes->pu8ShortEventDesc, pstEventInfoDes->pu8ShortEventDesc)); 
		pstEventInfoDes->pu8ShortEventDesc = pstEventInfoSrc->pu8ShortEventDesc;
		pstEventInfoDes->u16ShortEventDescLength = pstEventInfoSrc->u16ShortEventDescLength;
		
		pstEventInfoDes->pu8ExtendEventDesc = pstEventInfoSrc->pu8ExtendEventDesc;
		pstEventInfoDes->u16ExtendEventDescLength = pstEventInfoSrc->u16ExtendEventDescLength;
		
		if (pstEventInfoDes->pu8ExtendEventDesc)
		{	
			pstEventInfoDes->au8Text = pstEventInfoDes->pu8ExtendEventDesc;
		}
		else
		{
			pstEventInfoDes->au8Text = pstEventInfoDes->pu8ShortEventDesc;
		}
			    			
		/* reset short and extended descriptor to null. otherwise they will be free */
		pstEventInfoSrc->pu8ShortEventDesc = pstEventInfoSrc->pu8ExtendEventDesc = NULL;
	}
	return TRUE;
}			    		

bool8 eitbksets2firstevent (EN_SERVICE_TYPE enSrvType, u16 u16SrvIdx, u16 u16EventIdx, u32 u32EventStartTime)
{
#ifndef S2_FLAG_FOR_ALL_SEV			
	u8 u8i;

	if (u16SrvIdx >= MAX_NUM_OF_SRV)
	{
		EIT_DBG (("fail {eitbksets2firstevent} u16SrvIdx[0x%x]\n", u16SrvIdx));	
		return FALSE;
	}
	
	if (u16EventIdx >= EIT_MAX_EVENT_NUM)
	{
		EIT_DBG (("fail {eitbksets2firstevent} u16EventIdx[0x%x]\n", u16EventIdx));	
		return FALSE;
	}	 	
		
	for (u8i = 0; u8i < stTPService.u8Num; u8i ++)
	{
//EIT_DBG (("[%d][%d]-[%d]\n", u8i, stTPService.au16SrvIdx[u8i], u16SrvIdx));
		
		if (stTPService.au16SrvIdx[u8i] == u16SrvIdx)
		{
			if ((stTPService.au32S2StartTime[u8i] > u32EventStartTime)
				|| (stTPService.au32S2StartTime[u8i] == 0))
			{
			
				stTPService.au32S2StartTime[u8i] = u32EventStartTime;
				stTPService.au16S2EventDbIdx[u8i] = u16EventIdx;
			}
			
			return TRUE;		
		}		
	}	
	
	EIT_DBG (("XXXXXXXX{eitbksets2firstevent} wrong to find service u16SrvIdx[0x%x]\n", u16SrvIdx));
	return FALSE;
#else
	u16 u16SrvNumber;
	
	u16SrvNumber = DVB_ServiceGetTotal(enSrvType);
	
	if (u16SrvIdx >= u16SrvNumber)
	{
		EIT_DBG( ("fail {eitbksets2firstevent} u16SrvIdx[0x%x] out of range max[%d]\n", 
			u16SrvIdx, u16SrvNumber));	
		return FALSE;
	}
	
	if (u16SrvIdx >= MAX_NUM_OF_SRV)
	{
		EIT_DBG (("fail {eitbksets2firstevent} u16SrvIdx[0x%x] out of range\n", u16SrvIdx));	
		return FALSE;
	}
	
	if (u16EventIdx >= EIT_MAX_EVENT_NUM)
	{
		EIT_DBG (("fail {eitbksets2firstevent} u16EventIdx[0x%x]\n", u16EventIdx));	
		return FALSE;
	}

	if ((au32S2StartTime [u16SrvIdx] > u32EventStartTime)
		|| (au32S2StartTime [u16SrvIdx] == 0))
	{
//EIT_DBG (("{eitbksets2firstevent} u16SrvIdx[0x%x] EventIdx[0x%x]\n", u16SrvIdx, u16EventIdx));			
		au16S2EventDbIdx [u16SrvIdx] = u16EventIdx;
		au32S2StartTime [u16SrvIdx] = u32EventStartTime;		
	}
	return TRUE;		
#endif	
}	 			


/* **************************************************************************************** */
/* return TRUE : already got section */
/* return FALSE : not yet got section */
/* **************************************************************************************** */
bool8 gotsection (u8 *secarray)
{
	u8 u8i = 0;
	bool8 bgot = FALSE;
	
	for (u8i = 0; u8i < MAX_NUM_SECTION_GROUP; u8i ++)
	{
		if (secarray[u8i] != 0)
		{
			bgot = TRUE;
			break;
		}	
	}	
	
	return bgot;
}
	    		
/******************************************************************************************/
static EN_EITDB_STATUS dvb_EitSetS_Event(ST_SECTION_INFO_T *pstSecInfo, ST_EIT_HEADER_T *pstEitHeader, u8 u8SecVer, ST_EIT_EVENT *pstEventInfo, bool8 b8ExistExtended)
{
	u8 u8OffsetIdx=0, u8Idx;
	u16 u16CurIdx=0, u16TargetIdx=0;
	u16 u16PreIdx=0, u16NextIdx=0;
	u16 EmptyEventIdx=0, u16DeletedEventIdx=0;
	u8 u8RealSecVer;
	ST_EIT_DB stTmpEitDb;	

	if ((!pstSecInfo) || (!pstEitHeader) || (!pstEventInfo))
	{
		EIT_DBG (("fail {dvb_EitSetS_Event} pstSecInfo[0x%x] pstEitHeader[0x%x] pstEventInfo[0x%x]\n",
			(int)pstSecInfo, (int)pstEitHeader, (int)pstEventInfo));		
		return EN_EITDB_ERROR;
	}
	
	if (!pstSecInfo->pu8SecBuffer)
	{
		EIT_DBG (("fail {dvb_EitSetS_Event} pstSecInfo->pu8SecBuffer\n"));		
		return EN_EITDB_ERROR;
	}	 	
		

	EN_RETRIEVE_EVENT_TYPE enEventType = EN_RETRIEVE_EVENT_PF;
	if (pstSecInfo->pu8SecBuffer[0] == EIT_S1_TABLEID)
	{
		enEventType = EN_RETRIEVE_EVENT_S1; 	
	}	    	
	else if (pstSecInfo->pu8SecBuffer[0] == EIT_S2_TABLEID)
	{
		enEventType = EN_RETRIEVE_EVENT_S2;
	}
	
	if (enEventType == EN_RETRIEVE_EVENT_PF)
	{
		EIT_DBG (("XXXXXXXXXXXXXX {dvb_EitSetS_Event} something is strange [%d]\n",
			pstSecInfo->pu8SecBuffer[0]));
		return EN_EITDB_ERROR;	 
	}	

	
	//section version just uses 5 bits and 6th bit is for indicating this version is belong to which table id(6th bit, 0: 0x50, 1: 0x51).
	u8RealSecVer = u8SecVer & 0x1F; 
	if((pstEitHeader->u8PF_S_Flag & SCHEDULE_MASK) != 0)
	{
		if((((u8SecVer & 0x20) == 0) && (pstEitHeader->u8S1_Ver != u8RealSecVer)) 
			||(((u8SecVer & 0x20) == 1) && (pstEitHeader->u8S2_Ver != u8RealSecVer)))
		{
			// delete all schedule events
EIT_DBG (("#### will call del SID[0x%x] u8SecVer[0x%x] S1Ver[0x%x] S2Ver[0x%x] ver[0x%x]\n",
	pstSecInfo->u16SrvID, u8SecVer,
	pstEitHeader->u8S1_Ver, pstEitHeader->u8S2_Ver, u8RealSecVer));
		 			
			dvb_EitDelAll_S_Event(pstEitHeader);

#ifdef S2_FLAG_FOR_ALL_SEV
			eitbkclears2flag (pstSecInfo->u16SrvIdx);
#endif /* end #ifdef S2_FLAG_FOR_ALL_SEV */			
			if (pstSecInfo)
			{
				memset(pstSecInfo->au8NonGetSection_S1, 0, sizeof(pstSecInfo->au8NonGetSection_S1));
				memset(pstSecInfo->au8NonGetSection_S2, 0, sizeof(pstSecInfo->au8NonGetSection_S2));
			}	
		}
//		else
//		{
//EIT_DBG (("SID[0x%x] u8SecVer[0x%x] S1Ver[0x%x] S2Ver[0x%x] ver[0x%x] \n",
//	pstSecInfo->u16SrvID, u8SecVer, pstEitHeader->u8S1_Ver, pstEitHeader->u8S2_Ver, u8RealSecVer));			
//		}	
	}

	if((pstEitHeader->u8PF_S_Flag & PRESENT_MASK) != 0)
		u8OffsetIdx++; //This service exists a present event
	if((pstEitHeader->u8PF_S_Flag & FOLLOWING_MASK) != 0)
		u8OffsetIdx++; //This service exists a following event	

	if(u8OffsetIdx==0)	//if the service doesn't have present and following event
	{
		// if H->NULL, there aren't any schedule events now.
		if(pstEitHeader->u16HeadEventIdx == INVALID_LINK_IDX)
		{
			//First event can't be extended descriptor body.
			if(b8ExistExtended == TRUE)
				return EN_EITDB_ERROR;
				
			if(SearchEmptySpace(EN_EIT_EVENT_FLAG, &EmptyEventIdx) == FALSE)
			{
				// Todo: del expired or some events to acquire empty event
				//event full, try to del event
				if(dvb_EitDelEvent4DbFull(pstEitHeader->u16HeadEventIdx, EN_EIT_EVENT_FLAG)==FALSE)
				{
					return EN_EITDB_MEMORY_FULL;
				}	
				
				//search empty space again
				if(SearchEmptySpace(EN_EIT_EVENT_FLAG, &EmptyEventIdx) == FALSE)
				{
					return EN_EITDB_MEMORY_FULL;
				}	
			}
			//creative a schedule, H->S
			memcpy(&(stTmpEitDb.stEitEvent), pstEventInfo, sizeof(ST_EIT_EVENT));
			// This is first event of the service, so pre and next is invalid.
			stTmpEitDb.u16PreEventIdx = INVALID_LINK_IDX;
			stTmpEitDb.u16NextEventIdx = INVALID_LINK_IDX;
			dvb_EitSaveDbByIdx(EmptyEventIdx, &stTmpEitDb);
			
			pstEitHeader->u16HeadEventIdx = EmptyEventIdx;
			pstEitHeader->u16AllEventNum++;
			
			pstEitHeader->u8PF_S_Flag |= SCHEDULE_MASK;
			if( (u8SecVer & 0x20) == 0 )
			{
				pstEitHeader->u8S1_Ver = u8RealSecVer;
//EIT_DBG ((">>>> 3 [0x%x] S1 ver[0x%x]\n", pstEitHeader->u16AllEventNum, pstEitHeader->u8S1_Ver));				
			}	
			else
			{
				pstEitHeader->u8S2_Ver = u8RealSecVer;
//EIT_DBG ((">>>> 3 [0x%x] S2 ver[0x%x]\n", pstEitHeader->u16AllEventNum, pstEitHeader->u8S2_Ver));								
			}	
			
		#if DEBUG_SEHEDULE
			EIT_DBG(("%d> Pre:%04d  Cur:%04d  Next:%04d  AllEvent:%d,  ID:%05ld\n\n",__LINE__, 
				stTmpEitDb.u16PreEventIdx, EmptyEventIdx, stTmpEitDb.u16NextEventIdx, pstEitHeader->u16AllEventNum, (u32)pstEventInfo->u16EventId));
		#endif


			if (enEventType == EN_RETRIEVE_EVENT_S2)
			{
				eitbksets2firstevent (pstSecInfo->enSrvType, pstSecInfo->u16SrvIdx, EmptyEventIdx, pstEventInfo->u32StartTime);
			}

	
EIT_DBG (("add 1 [0x%x] Num[%d]\n", pstSecInfo->u16SrvID, pstEitHeader->u16AllEventNum));		
			return EN_EITDB_ADD;
		}
		else //H->S1->S2->S3->....
		{
			//get S1, stTmpEitDb is used by S1
			if (dvb_EitGetDbByIdx(pstEitHeader->u16HeadEventIdx, &stTmpEitDb) != EN_EITDB_NO_ERROR)
			{
				EIT_DBG (("read header error\n")); 				
				return EN_EITDB_ERROR;
			}
			// Could I use event id to compare them ?
			if(pstEventInfo->u16EventId == stTmpEitDb.stEitEvent.u16EventId ||
				pstEventInfo->u32StartTime == stTmpEitDb.stEitEvent.u32StartTime)
			{
			    if(b8ExistExtended == FALSE)
			    {

					if (enEventType == EN_RETRIEVE_EVENT_S1)
					{	
						eitbkcheckdesc (pstEventInfo, (ST_EIT_EVENT *)&(stTmpEitDb.stEitEvent));
						dvb_EitSaveDbByIdx(pstEitHeader->u16HeadEventIdx, &stTmpEitDb);

					}

EIT_DBG (("exist 1\n"));			    				
					return EN_EITDB_EXIST; // event already existed, doesn't save it
				}
    			else
    			{
    			}
			}
				
			u16CurIdx = pstEitHeader->u16HeadEventIdx; // u16CurIdx = S1
			//New event will be the first event. H->New_S->S1->S2->S3->....
			if(pstEventInfo->u32StartTime < stTmpEitDb.stEitEvent.u32StartTime) 
			{
			    //First event can't be extended descriptor body.
			    if(b8ExistExtended == TRUE)
			    {
				    return EN_EITDB_ERROR;
				}
			    
				if(SearchEmptySpace(EN_EIT_EVENT_FLAG, &EmptyEventIdx) == FALSE)
				{
					// Todo: del expired or some events to acquire empty event
					//event full, try to del event
					if(dvb_EitDelEvent4DbFull(pstEitHeader->u16HeadEventIdx, EN_EIT_EVENT_FLAG)==FALSE)
					{
						//try to delete last event in this service
						if(dvb_EitDelLastEventByHead(pstEitHeader, &u16DeletedEventIdx)==TRUE)
							pstEitHeader->u16AllEventNum--;
						else
						{
							return EN_EITDB_MEMORY_FULL;
						}	
					}
					
					//search empty space again
					if(SearchEmptySpace(EN_EIT_EVENT_FLAG, &EmptyEventIdx) == FALSE)
					{
						return EN_EITDB_MEMORY_FULL;
					}	
				}
				stTmpEitDb.u16PreEventIdx = EmptyEventIdx; //set S1->pre = New_S
				dvb_EitSaveDbByIdx(u16CurIdx, &stTmpEitDb); //save S1
				
				//stTmpEitDb is used by New_S
				memcpy(&(stTmpEitDb.stEitEvent), pstEventInfo, sizeof(ST_EIT_EVENT));
				// Now New_S is first event of the service, so pre is invalid.
				stTmpEitDb.u16PreEventIdx = INVALID_LINK_IDX;
				// set New_S->next = S1
				stTmpEitDb.u16NextEventIdx = u16CurIdx;
				dvb_EitSaveDbByIdx(EmptyEventIdx, &stTmpEitDb); //Save New_S
				
				pstEitHeader->u16HeadEventIdx = EmptyEventIdx;
				pstEitHeader->u16AllEventNum++;
//EIT_DBG ((">>>> 5 [0x%x]\n", pstEitHeader->u16AllEventNum));				
				/*pstEitHeader->u8PF_S_Flag |= SCHEDULE_MASK;
				if( (u8SecVer & 0x20) == 0 )
					pstEitHeader->u8S1_Ver = u8RealSecVer;
				else
					pstEitHeader->u8S2_Ver = u8RealSecVer;
				*/
			#if DEBUG_SEHEDULE
				EIT_DBG(("%d> Pre:%04d  Cur:%04d  Next:%04d  AllEvent:%d,  ID:%05ld\n\n",__LINE__, 
					stTmpEitDb.u16PreEventIdx, EmptyEventIdx, stTmpEitDb.u16NextEventIdx, pstEitHeader->u16AllEventNum, (u32)pstEventInfo->u16EventId));
			#