📄 dvb_eit.c
字号:
eitbkfreesectioninfo (pstSecInfo);
CT_OS_FreeSemaphore (&EITSetSection_Sem);
EIT_DBG ((" ######### eitbkresetsectionInfo end \n"));
return TRUE;
}
#ifdef S2_FLAG_FOR_ALL_SEV
void eitbkclears2flag (u16 u16SrvIdx)
{
au16S2EventDbIdx[u16SrvIdx] = 0x00;
au32S2StartTime[u16SrvIdx] = 0x00;
}
void eitbkclearalls2flag (void)
{
memset (au16S2EventDbIdx, 0x00, sizeof (au16S2EventDbIdx));
memset (au32S2StartTime, 0x00, sizeof (au32S2StartTime));
}
#endif /* end #ifdef S2_FLAG_FOR_ALL_SEV */
void eitbkfreeeventmemory (ST_EIT_EVENT *pstEventInfo)
{
//EIT_DBG (("eitbkfreeeventmemory --- 11\n"));
//CT_OS_MempoolInfo();
if (pstEventInfo)
{
//TempFreeRecord (pstEventInfo->au8Name);
#ifdef EIT_NAME_ARRAY_ENABLE
memset (pstEventInfo->au8Name, 0x00, MAX_LEN_SHORT_EVENT_NAME);
#else /* #ifdef EIT_NAME_ARRAY_ENABLE */
if (pstEventInfo->au8Name)
{
freep = 52;
DVB_MemoryFree((u8*)pstEventInfo->au8Name);
}
pstEventInfo->au8Name = NULL;
#endif /* end #ifdef EIT_NAME_ARRAY_ENABLE */
if (pstEventInfo->pu8ShortEventDesc)
{
freep = 53;
DVB_MemoryFree((u8*)pstEventInfo->pu8ShortEventDesc);
}
pstEventInfo->pu8ShortEventDesc = NULL;
pstEventInfo->u16ShortEventDescLength = 0;
if (pstEventInfo->pu8ExtendEventDesc)
{
freep = 54;
DVB_MemoryFree((u8*)pstEventInfo->pu8ExtendEventDesc);
}
pstEventInfo->pu8ExtendEventDesc = NULL;
pstEventInfo->u16ExtendEventDescLength = 0;
pstEventInfo->au8Text = NULL;
}
//EIT_DBG( ("eitbkfreeeventmemory --- 22\n"));
//CT_OS_MempoolInfo();
}
//This function use to check, set, and clear flag of header and event space
static bool8 EditDbFlag(u16 u16HeaderNo, EN_FLAG_EDITOR enEditor, EN_FLAG_ACTION enAction)
{
u8 u8BitNo;
u8 *pu8DbFlag;
u16 u16Group;
u16 u16MaxNum;
EN_EITDB_STATUS enRetError;
ST_EIT_DB stDelEitDb;
if(enEditor == EN_EIT_HEADER_FLAG)
{
u16MaxNum = EIT_MAX_HEADER_NUM;
pu8DbFlag = au8HeaderFlag;
}
else
{
u16MaxNum = EIT_MAX_EVENT_NUM;
pu8DbFlag = au8EventFlag;
}
if(u16HeaderNo > u16MaxNum)
return FALSE; // This u16HeaderNo doesn't exist.
u16Group = u16HeaderNo/MAX_NUM_IN_A_GROUP;
u8BitNo = u16HeaderNo%MAX_NUM_IN_A_GROUP;
switch(enAction)
{
case EN_CHECK_FLAG:
if((pu8DbFlag[u16Group]&au8FlagMask[u8BitNo]) != 0)
return TRUE; //flag exist
else
return FALSE; //flag not exist
break;
case EN_SET_FLAG:
pu8DbFlag[u16Group] |= au8FlagMask[u8BitNo];
return TRUE; // set success
break;
case EN_CLEAR_FLAG:
if (enEditor == EN_EIT_EVENT_FLAG)
{
enRetError = dvb_EitGetDbByIdx(u16HeaderNo, &stDelEitDb);
if (enRetError == EN_EITDB_NO_ERROR)
{
#if 0
if (stDelEitDb.stEitEvent.u16EventId == 0x4069)
{
EIT_DBG( ("+++ 33 EditDbFlag event id [0x%x] startime[0x%x] dur[0x%x] name[%s] pn[0x%x] ps[0x%x]\n",
stDelEitDb.stEitEvent.u16EventId, stDelEitDb.stEitEvent.u32StartTime,
stDelEitDb.stEitEvent.u32Duration,
stDelEitDb.stEitEvent.au8Name,
stDelEitDb.stEitEvent.au8Name,
stDelEitDb.stEitEvent.pu8ShortEventDesc));
EIT_DBG( ("EditDbFlag --- 11\n"));
CT_OS_MempoolInfo();
}
#endif
eitbkfreeeventmemory (&(stDelEitDb.stEitEvent));
}
}
pu8DbFlag[u16Group] &= ~au8FlagMask[u8BitNo];
return TRUE; // clear success
break;
default:
return FALSE;
}
}
/******************************************************************************************/
static bool8 SearchEmptySpace(EN_FLAG_EDITOR enEditor, u16 *pu16RetIdx)
{
u8 *pu8DbFlag;
u8 u8BitNo;
u16 u16Group;
u16 u16MaxNum;
ST_EIT_HEADER_T stEitHeader;
ST_EIT_DB stTmpEitDb;
// EIT_DBG(("%s,%d> search empty space\n", __FFLL__));
if(enEditor == EN_EIT_HEADER_FLAG)
{
u16MaxNum = MAX_HEADER_FLAG;
pu8DbFlag = au8HeaderFlag;
}
else
{
u16MaxNum = MAX_EVENT_FLAG;
pu8DbFlag = au8EventFlag;
}
u16Group = 0;
while(u16Group<u16MaxNum)
{
//EIT_DBG(("pu8DbFlag[%d] = %hd\n", u16Group,pu8DbFlag[u16Group]));
for(u8BitNo=0;u8BitNo<MAX_NUM_IN_A_GROUP;u8BitNo++)
{
//find a empty space
if((pu8DbFlag[u16Group]&au8FlagMask[u8BitNo]) == 0)
{
*pu16RetIdx = u16Group*MAX_NUM_IN_A_GROUP + u8BitNo;
//EIT_DBG(("%s,%d> search ok\n", __FFLL__));
if(enEditor == EN_EIT_HEADER_FLAG)
{
//init pstHeader
memset(&stEitHeader, 0, sizeof(ST_EIT_HEADER_T));
//save header
SaveHeader2Dram(*pu16RetIdx, &stEitHeader);
}
else
{
//init pstHeader
memset(&stTmpEitDb, 0, sizeof(ST_EIT_DB));
// save event
dvb_EitSaveDbByIdx(*pu16RetIdx, &stTmpEitDb);
}
return TRUE;
}
}
u16Group++;
}
//doesn't find any empty space
EIT_DBG(("%s,%d> enEditor(%d) search failed\n", __FFLL__, (int)enEditor));
return FALSE;
}
/******************************************************************************************/
static EN_EITDB_STATUS dvb_EitGetHeaderInfo(EN_SERVICE_TYPE enSrvType, u16 u16SrvIdx, ST_EIT_HEADER_T *pstHeader, u16 *pu16RetHeadIdx)
{
u32 dwStart;
u32 dwAddrOffset;
u16 u16TmpSrvNum;
u16TmpSrvNum = DVB_ServiceGetTotal(enSrvType);
if (b8EitBuffInit != TRUE)
{
return EN_EITDB_MEMORY_NULL;
}
if(u16SrvIdx >= u16TmpSrvNum)
{
EIT_DBG(("%s,%d> Error! Wrong parameters\n", __FFLL__));
return EN_EITDB_WRONG_PARAMETER;
}
/*DVB_ServiceRead(enSrvType, u16SrvIdx, &stTmpSrvInfo);
if(stTmpSrvInfo.u16EitHeaderIdx == INVALID_LINK_IDX)*/
_u16DbEitHeaderIdx = DVB_DBGetEitHeader(enSrvType, u16SrvIdx);
if(_u16DbEitHeaderIdx == INVALID_LINK_IDX)
{
// EIT_DBG(("%s,%d> Error! Srv(%d), EIT header doesn't exist\n", __FFLL__, u16SrvIdx));
return EN_EITDB_HEADER_NOT_EXIST;
}
if(EditDbFlag(_u16DbEitHeaderIdx, EN_EIT_HEADER_FLAG, EN_CHECK_FLAG) == FALSE)
{
// Because the header of this service doesn't exist, we set u16EitHeaderIdx to INVALID_LINK_IDX
/*stTmpSrvInfo.u16EitHeaderIdx = INVALID_LINK_IDX;
SetItemOfPgmListInDram(enSrvType, u16SrvIdx, &stTmpSrvInfo);*/
_u16DbEitHeaderIdx = INVALID_LINK_IDX;
DVB_DBSetEitHeader(enSrvType, u16SrvIdx, _u16DbEitHeaderIdx);
EIT_DBG(("%s,%d> Error! Srv(%d) EIT header doesn't exist\n", __FFLL__, u16SrvIdx));
return EN_EITDB_HEADER_NOT_EXIST;
}
//dwStart = EIT_HEADER_BUFFER_START_ADDR<<2;
dwStart = EIT_HEADER_BUFFER_START_ADDR;
dwAddrOffset = (u32)_u16DbEitHeaderIdx * EIT_HEADER_LENGTH;
//W99AV_ReadDRAMBurst(dwStart+dwAddrOffset, (u32 *)pstHeader, EIT_HEADER_LENGTH);
//DVB_DramRead(dwStart+dwAddrOffset, (u8 *)pstHeader, EIT_HEADER_LENGTH);
memcpy((u8 *)pstHeader, (u8*)(dwStart+dwAddrOffset), EIT_HEADER_LENGTH);
*pu16RetHeadIdx = _u16DbEitHeaderIdx;
return EN_EITDB_NO_ERROR;
}
/******************************************************************************************/
static bool8 SaveHeader2Dram(u16 u16HeadIdx, ST_EIT_HEADER_T *pstHeader)
{
u32 dwStart;
u32 dwAddrOffset;
if (b8EitBuffInit != TRUE)
{
return FALSE;
}
if(u16HeadIdx >= EIT_MAX_HEADER_NUM)
return FALSE;
//dwStart = EIT_HEADER_BUFFER_START_ADDR<<2;
dwStart = EIT_HEADER_BUFFER_START_ADDR;
dwAddrOffset = (u32)u16HeadIdx * EIT_HEADER_LENGTH;
//W99AV_WriteDRAMBurst(dwStart+dwAddrOffset, (u32 *)pstHeader, EIT_HEADER_LENGTH);
memcpy( (u8*)(dwStart+dwAddrOffset), (u8 *)pstHeader, EIT_HEADER_LENGTH);
return TRUE;
}
/******************************************************************************************/
static EN_EITDB_STATUS dvb_EitCreateHeader(EN_SERVICE_TYPE enSrvType, u16 u16SrvIdx, ST_EIT_HEADER_T *pstHeader, u16 *pu16RetHeadIdx)
{
u16 u16TmpSrvNum;
//EIT_DBG(("%s,%d> create a header\n", __FFLL__));
u16TmpSrvNum = DVB_ServiceGetTotal(enSrvType);
if(u16SrvIdx >= u16TmpSrvNum)
return EN_EITDB_WRONG_PARAMETER;
//DVB_ServiceRead(enSrvType, u16SrvIdx, &stTmpSrvInfo);
_u16DbEitHeaderIdx = DVB_DBGetEitHeader(enSrvType, u16SrvIdx);
//search empty header space
if(SearchEmptySpace(EN_EIT_HEADER_FLAG, pu16RetHeadIdx) == FALSE)
{
//header full, try to del header, first parameter 0 is not useful in this situation.
if(dvb_EitDelEvent4DbFull(0, EN_EIT_HEADER_FLAG) == FALSE)
return EN_EITDB_MEMORY_FULL;
//search empty header again
if(SearchEmptySpace(EN_EIT_HEADER_FLAG, pu16RetHeadIdx) == FALSE)
return EN_EITDB_MEMORY_FULL;
}
//stTmpSrvInfo.u16EitHeaderIdx = *pu16RetHeadIdx;
_u16DbEitHeaderIdx = *pu16RetHeadIdx;
//save stTmpSrvInfo to sdram
//SetItemOfPgmListInDram(enSrvType, u16SrvIdx, &stTmpSrvInfo);
DVB_DBSetEitHeader(enSrvType, u16SrvIdx, _u16DbEitHeaderIdx);
//init pstHeader
memset(pstHeader, 0, sizeof(ST_EIT_HEADER_T));
pstHeader->u16HeadEventIdx = INVALID_LINK_IDX;
//save header
if(SaveHeader2Dram(*pu16RetHeadIdx, pstHeader)==TRUE)
{
//EIT_DBG(("%s,%d> edit flag\n", __FFLL__));
EditDbFlag(*pu16RetHeadIdx, EN_EIT_HEADER_FLAG, EN_SET_FLAG);
//EIT_DBG(("%s,%d> finish edit flag\n", __FFLL__));
return EN_EITDB_NO_ERROR;
}
else
{
EIT_DBG(("%s,%d> %s create a header error\n", __FFLL__));
return EN_EITDB_ERROR;
}
}
/******************************************************************************************/
static EN_EITDB_STATUS dvb_EitGetDbByIdx(u16 u16DbIdx, ST_EIT_DB *pstDb)
{
u32 dwStart;
u32 dwAddrOffset;
#ifdef UNIFORM_LANGUAGE
u8 i;
#endif
if (!pstDb)
{
EIT_DBG((" fail {dvb_EitGetDbByIdx} pstDb is null\n"));
return EN_EITDB_WRONG_PARAMETER;
}
#if 1
if (b8EitBuffInit != TRUE)
{
return EN_EITDB_MEMORY_NULL;
}
if(u16DbIdx >= EIT_MAX_EVENT_NUM)
return EN_EITDB_WRONG_PARAMETER;
if(EditDbFlag(u16DbIdx, EN_EIT_EVENT_FLAG, EN_CHECK_FLAG) == FALSE)
return EN_EITDB_EVENT_NOT_EXIST;
#endif
//dwStart = EIT_EVENT_BUFFER_START_ADDR<<2;
dwStart = EIT_EVENT_BUFFER_START_ADDR;
dwAddrOffset = (u32)u16DbIdx * EIT_DB_LENGTH;
//W99AV_ReadDRAMBurst(dwStart+dwAddrOffset, (u32 *)pstDb, EIT_DB_LENGTH);
//DVB_DramRead(dwStart+dwAddrOffset, (u8 *)pstDb, EIT_DB_LENGTH);
memcpy((u8 *)pstDb, (u8*)(dwStart+dwAddrOffset), EIT_DB_LENGTH);
#ifdef UNIFORM_LANGUAGE
for(i=0;i<3;i++)
{
if((pstDb->stEitEvent.au8LangCode[i]>='A')&&(pstDb->stEitEvent.au8LangCode[i]<='Z'))
pstDb->stEitEvent.au8LangCode[i] = pstDb->stEitEvent.au8LangCode[i]+('a'-'A');
}
if(memcmp(pstDb->stEitEvent.au8LangCode,"zho",3)==0)
{
memcpy(pstDb->stEitEvent.au8LangCode,"chi",3);
}
#endif
return EN_EITDB_NO_ERROR;
}
/******************************************************************************************/
static EN_EITDB_STATUS dvb_EitSaveDbByIdx(u16 u16DbIdx, ST_EIT_DB *pstDb)
{
u32 dwStart;
u32 dwAddrOffset;
#if 1
if (b8EitBuffInit != TRUE)
{
return EN_EITDB_MEMORY_NULL;
}
if(u16DbIdx >= EIT_MAX_EVENT_NUM)
return EN_EITDB_WRONG_PARAMETER;
//set flag means this space is occupied by a event.
EditDbFlag(u16DbIdx, EN_EIT_EVENT_FLAG, EN_SET_FLAG);
#endif
//dwStart = EIT_EVENT_BUFFER_START_ADDR<<2;
dwStart = EIT_EVENT_BUFFER_START_ADDR;
dwAddrOffset = (u32)u16DbIdx * EIT_DB_LENGTH;
//W99AV_WriteDRAMBurst(dwStart+dwAddrOffset, (u32 *)pstDb, EIT_DB_LENGTH);
memcpy( (u8*)(dwStart+dwAddrOffset), (u8 *)pstDb, EIT_DB_LENGTH);
return EN_EITDB_NO_ERROR;
}
/******************************************************************************************/
bool8 DVB_EitDbInitMemory(void)
{
b8EitBuffInit = FALSE;
if (pu8EitHedaderBufferStartPtr != NULL)
{
DVB_MemoryFree((u8*)pu8EitHedaderBufferStartPtr);
pu8EitHedaderBufferStartPtr = NULL;
}
if (pi8EitEventBufferStartPtr != NULL)
{
DVB_MemoryFree((u8*)pi8EitEventBufferStartPtr);
pi8EitEventBufferStartPtr = NULL;
}
gen_point = 128;
pu8EitHedaderBufferStartPtr = (u8*)DVB_MemoryAllocate((EIT_MAX_HEADER_NUM*EIT_HEADER_LENGTH));
if (pu8EitHedaderBufferStartPtr == NULL)
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -