frameparser.c

来自「君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图」· C语言 代码 · 共 1,611 行 · 第 1/5 页

    else
        fp->Error = TP_RET_DATA_NONE_ERR;
}

VOID FrameEnd(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{
    FrameParserClean(fp);
#ifdef DEBUG_USE_FULL_MULTIPLEX_FRAME_DATA
    if (fp->multiplexcount > 0)
    {
        fp->ParserState = TP_FP_STATE_GET_HEADER_LENGTH;
        fp->multiplexcount--;
    }
#endif
}

VOID FreeSysConfDataMem(TP_DTV_STREAM_T *stream)
{
    TP_SYS_SERVICE_T    *cur, *next;
    TP_SYS_EADT_SERVICE_T   *EadtServCur,*EadtServNext;
    TP_SYS_ESGDT_SERVICE_CONF_T    *EsgdtServConfCur,*EsgdtServConfNext;
    TP_SYS_ESGDT_DATA_CONF_T    *EsgdtDataConfCur,*EsgdtDataConfNext;
    TP_SYS_ESGDT_DATA_BLOCK_CONF_T *EsgdtDataBlockConfCur,*EsgdtDataBlockConfNext;
    
    //NIT
    stream->SysConf.NitConf.Updated = FALSE;
    //CSCT
    if (stream->SysConf.CsctConf.Updated 
        && (stream->SysConf.CsctConf.State==TP_FRAME_DATA_STATE_PLAYED))
    {
        cur = stream->SysConf.CsctConf.Service;
        while(cur != NULL)
        {
            next = cur->next;
            pf_free(cur);
            cur = next;
        }
        stream->SysConf.CsctConf.State = TP_FRAME_DATA_STATE_NONE;
        stream->SysConf.CsctConf.Service = NULL;
        stream->SysConf.CsctConf.Updated = FALSE;
    }
    //SSCT
    if (stream->SysConf.SsctConf.Updated
        && (stream->SysConf.SsctConf.State==TP_FRAME_DATA_STATE_PLAYED))
    {
        cur = stream->SysConf.SsctConf.Service;
        while(cur != NULL)
        {
            next = cur->next;
            pf_free(cur);
            cur = next;
        }
        stream->SysConf.SsctConf.State = TP_FRAME_DATA_STATE_NONE;
        stream->SysConf.SsctConf.Service = NULL;
        stream->SysConf.SsctConf.Updated = FALSE;
    }
    //ESGDT
    if (stream->SysConf.EsgdtConf.Updated
        && (stream->SysConf.EsgdtConf.State==TP_FRAME_DATA_STATE_PLAYED))
    {
        EsgdtServConfCur = stream->SysConf.EsgdtConf.ServConf;
        while(EsgdtServConfCur != NULL)
        {
            EsgdtServConfNext = EsgdtServConfCur->next;
            pf_free(EsgdtServConfCur);
            EsgdtServConfCur = EsgdtServConfNext;
        }
        EsgdtDataConfCur = stream->SysConf.EsgdtConf.DataConf;
        while(EsgdtDataConfCur != NULL)
        {
            EsgdtDataConfNext = EsgdtDataConfCur->next;
            EsgdtDataBlockConfCur = EsgdtDataConfCur->DataBlockConf;
            while(EsgdtDataBlockConfCur != NULL)
            {
                EsgdtDataBlockConfNext = EsgdtDataBlockConfCur->next;
                pf_free(EsgdtDataBlockConfCur);
                EsgdtDataBlockConfCur = EsgdtDataBlockConfNext;
            }
            pf_free(EsgdtDataConfCur);
            EsgdtDataConfCur = EsgdtDataConfNext;
        }
        stream->SysConf.EsgdtConf.ServConf = NULL;
        stream->SysConf.EsgdtConf.DataConf = NULL;
        stream->SysConf.EsgdtConf.State = TP_FRAME_DATA_STATE_NONE;
        stream->SysConf.EsgdtConf.Updated = FALSE;
    }
    //EADT
    if (stream->SysConf.EadtConf.Updated
        && (stream->SysConf.EadtConf.State==TP_FRAME_DATA_STATE_PLAYED))
    {
        EadtServCur = stream->SysConf.EadtConf.Service;
        while(EadtServCur != NULL)
        {
            EadtServNext = EadtServCur->next;
            pf_free(EadtServCur);
            EadtServCur = EadtServNext;
        }
        stream->SysConf.EadtConf.State = TP_FRAME_DATA_STATE_NONE;
        stream->SysConf.EadtConf.Service = NULL;
        stream->SysConf.EadtConf.Updated = FALSE;
    }
}

VOID FreeEbDataMem(TP_DTV_STREAM_T *stream)
{
    if (stream->EbStream.Valid)
    {
        stream->EbStream.State = TP_FRAME_DATA_STATE_NONE;
        stream->EbStream.Valid = FALSE;
        pf_free(stream->EbStream.Data);
        stream->EbStream.Data = NULL;
    }
}

VOID FreeVideoDataMem(TP_DTV_STREAM_T *stream, TP_BOOL freeall)
{
    TP_STREAM_VIDEO_FRAME_T *CurFrame;
    TP_STREAM_VIDEO_FRAME_T *PriorFrame;
    TP_STREAM_VIDEO_FRAME_T *NextFrame;
    
    if (freeall)
    {
        for(CurFrame=stream->VideoFrame; CurFrame!=NULL; CurFrame=NextFrame)
        {
            NextFrame = CurFrame->next;
            pf_free(CurFrame->Data);
            pf_free(CurFrame);
        }
        
        stream->VideoFrame = NULL;
    }
    else
    {
        PriorFrame = NULL;
        for(CurFrame=stream->VideoFrame; CurFrame!=NULL; CurFrame=NextFrame)
        {
            NextFrame = CurFrame->next;
            if (CurFrame->State == TP_FRAME_DATA_STATE_PLAYED)
            {
                if (PriorFrame == NULL)
                    stream->VideoFrame = NextFrame;
    
                pf_free(CurFrame->Data);
                pf_free(CurFrame);
            }
            else
            {
                if (PriorFrame != NULL)
                    PriorFrame->next = CurFrame;
                PriorFrame = CurFrame;
            }
        }
    }
}

VOID FreeAudioDataMem(TP_DTV_STREAM_T *stream, TP_BOOL freeall)
{
    TP_STREAM_AUDIO_FRAME_T *CurFrame;
    TP_STREAM_AUDIO_FRAME_T *PriorFrame;
    TP_STREAM_AUDIO_FRAME_T *NextFrame;

    if (freeall)
    {
        for(CurFrame=stream->AudioFrame; CurFrame!=NULL; CurFrame=NextFrame)
        {
            NextFrame = CurFrame->next;
            pf_free(CurFrame->Data);
            pf_free(CurFrame);
        }
        
        stream->AudioFrame = NULL;
    }
    else
    {
        PriorFrame = NULL;
        for(CurFrame=stream->AudioFrame; CurFrame!=NULL; CurFrame=NextFrame)
        {
            NextFrame = CurFrame->next;
            if (CurFrame->State == TP_FRAME_DATA_STATE_PLAYED)
            {
                if (PriorFrame == NULL)
                    stream->AudioFrame = NextFrame;
    
                pf_free(CurFrame->Data);
                pf_free(CurFrame);
            }
            else
            {
                if (PriorFrame != NULL)
                    PriorFrame->next = CurFrame;
                PriorFrame = CurFrame;
            }
        }
    }
}

VOID FreeOtherDataMem(TP_DTV_STREAM_T *stream, TP_BOOL freeall)
{
    TP_STREAM_OTHER_DATA_FRAME_T *CurFrame;
    TP_STREAM_OTHER_DATA_FRAME_T *PriorFrame;
    TP_STREAM_OTHER_DATA_FRAME_T *NextFrame;

    if (freeall)
    {
        for(CurFrame=stream->OtherFrame; CurFrame!=NULL; CurFrame=NextFrame)
        {
            NextFrame = CurFrame->next;
            pf_free(CurFrame->Data);
            pf_free(CurFrame);
        }
        
        stream->OtherFrame = NULL;
    }
    else
    {
        PriorFrame = NULL;
        for(CurFrame=stream->OtherFrame; CurFrame!=NULL; CurFrame=NextFrame)
        {
            NextFrame = CurFrame->next;
            if (CurFrame->State == TP_FRAME_DATA_STATE_PLAYED)
            {
                if (PriorFrame == NULL)
                    stream->OtherFrame = NextFrame;

                pf_free(CurFrame->Data);
                pf_free(CurFrame);
            }
            else
            {
                if (PriorFrame != NULL)
                    PriorFrame->next = CurFrame;
                PriorFrame = CurFrame;
            }
        }
    }
}

/****************************************************************************** 
*                       CheckCRC                                              * 
*   Description: Check the CRC value.                                         * 
*   Input:                                                                    * 
*       str: source string.                                                   * 
*       slen: source string length.                                           * 
*       crcvalue: CRC value.                                                  * 
*   Output:                                                                   *
*       None                                                                  *
*   Return:                                                                   * 
*       TRUE:  correct.                                                       * 
*       FALSE: incorrect.                                                     * 
*   Note:                                                                     * 
*       None                                                                  * 
*******************************************************************************/
TP_BOOL CheckCRC(TP_UINT8 *str, TP_UINT32 slen, TP_UINT8 *crcstr)
{
    TP_UINT32 i;
    TP_UINT32 m_CRC = 0xFFFFFFFF;
    TP_UINT32 crcvalue;

    for (i=0; i<slen; i++)
    {
        m_CRC = (m_CRC << 8) ^ crc32_table[(m_CRC >> 24) ^ str[i]];
    }

    //source crc value    
    crcvalue = *crcstr++;
    crcvalue <<= 8;
    crcvalue += *crcstr++;
    crcvalue <<= 8;
    crcvalue += *crcstr++;
    crcvalue <<= 8;
    crcvalue += *crcstr;

    if (crcvalue == m_CRC)
        return TRUE;
    else
        return FALSE;
}


/****************************************************************************** 
*                       CmpStreamParam                                        * 
*   Description: Compare two stream param.                                    * 
*   Input:                                                                    * 
*       src: source stream param.                                             * 
*       dst: destination stream param.                                        * 
*   Output:                                                                   *
*       None                                                                  *
*   Return:                                                                   * 
*       TRUE:  equal.                                                         * 
*       FALSE: not equal.                                                     * 
*   Note:                                                                     * 
*       None                                                                  * 
*******************************************************************************/
TP_BOOL CmpStreamParam(TP_STREAM_PARAM_T *src, TP_STREAM_PARAM_T *dst)
{
    TP_INT32 i;

    if (src->StartPlayTime != dst->StartPlayTime)
        return FALSE;

    for(i=0; i<TP_VIDEO_STREAM_NUM_MAX; i++)
    {
        if (pf_memcmp(&src->VideoParam[i], &dst->VideoParam[i], sizeof(TP_VIDEO_PARAM_T)) != 0)
            return FALSE;
        if (pf_memcmp(&src->AudioParam[i], &dst->AudioParam[i], sizeof(TP_AUDIO_PARAM_T)) != 0)
            return FALSE;
    }
    return TRUE;
}

#ifdef   __cplusplus
    }
#endif