frameparser.c

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

        }

        if (*(fp->CurUnitHeader+2) & 0x01) //have starttime
            fp->VideoDataHeaderLength -= VIDEO_DATA_HEADER_UNIT_PARAM_WIDTH+2;
        else
            fp->VideoDataHeaderLength -= VIDEO_DATA_HEADER_UNIT_PARAM_WIDTH;

        fp->ParserState = TP_FP_STATE_GET_VIDEO_DATA;
    }
    else // Video data header end
    {
        pf_free(fp->VideoDataHeader);
        if (fp->VideoFieldLength > 0)
        {
            fp->FrameData += fp->VideoFieldLength;
            fp->FrameDataLen -= fp->VideoFieldLength;
        }
        fp->ParserState = TP_FP_STATE_GET_AUDIO_DATA_HEADER_UNITNUM;
    }
}

VOID GetVideoDataContent(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{    
    if (fp->FrameDataLen >= fp->CurUnitLen)
    {
    #ifdef TP_DATA_ENCRYPTION
        if (fp->HeaderTag.Encryption_Indicator == ENCRYPTION_TYPE_ENCRYPTED)
            DecryptionData(fp->FrameData, fp->CurUnitLen);
    #endif
        pf_memcpy(fp->CurVideoFrame->Data+fp->CurVideoFrame->Size, fp->FrameData, fp->CurUnitLen);
        fp->CurVideoFrame->Size += fp->CurUnitLen;
        TP_DEBUG_PRINT("GetVideoDataContent:%d \n", fp->CurUnitLen);

        if (*(fp->CurUnitHeader+2) & 0x02) // frame end flag
        {
            fp->CurVideoFrame->State = TP_FRAME_DATA_STATE_READY;
            stream->ReadyVideoFrameCount++;
        }

        if (*(fp->CurUnitHeader+2) & 0x01) //have starttime
            fp->CurUnitHeader += VIDEO_DATA_HEADER_UNIT_PARAM_WIDTH+2;
        else
            fp->CurUnitHeader += VIDEO_DATA_HEADER_UNIT_PARAM_WIDTH;

        fp->FrameData += fp->CurUnitLen;
        fp->FrameDataLen -= fp->CurUnitLen;
        fp->VideoFieldLength -= fp->CurUnitLen;
        fp->ParserState = TP_FP_STATE_GET_VIDEO_DATA_HEADER_CONTENT;
    }
    else
        fp->Error = TP_RET_DATA_NONE_ERR;
}

VOID GetAudioDataHeaderUnitnum(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{
    if (!fp->HeaderTag.AudioField_isValid)
    {
        fp->ParserState = TP_FP_STATE_GET_OTHER_DATA_HEADER_UNITNUM;
        return;
    }

    if (fp->FrameDataLen > AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH)
    {
        fp->AudioUnitNum = *(fp->FrameData);
        fp->ParserState = TP_FP_STATE_GET_AUDIO_DATA_HEADER;
    }
    else
        fp->Error = TP_RET_DATA_NONE_ERR;
}

VOID GetAudioDataHeader(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{
    TP_INT32   i,headerlen;
    
    if (fp->FrameDataLen >= fp->AudioUnitNum*AUDIO_DATA_HEADER_UNIT_PARAM_WIDTH+HEADER_CRC_FIELD_WIDTH+AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH)
    {
        headerlen = fp->AudioUnitNum*AUDIO_DATA_HEADER_UNIT_PARAM_WIDTH+AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH;
        if (!CheckCRC(fp->FrameData, headerlen, fp->FrameData+headerlen))
        {            
            if (fp->AudioFieldLength > fp->FrameDataLen)
            {
                fp->DisCardDatalen = fp->AudioFieldLength - fp->FrameDataLen;
                fp->FrameData += fp->FrameDataLen;
                fp->FrameDataLen = 0;
                fp->Error = TP_RET_DATA_NONE_ERR;
            }
            else
            {
                fp->FrameData += fp->AudioFieldLength;
                fp->FrameDataLen -= fp->AudioFieldLength;
            }
            fp->ParserState = TP_FP_STATE_GET_OTHER_DATA_HEADER_UNITNUM;
            return;
        }
        
        fp->AudioDataHeader = (TP_UINT8*)pf_alloc(headerlen-AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH);
        pf_memcpy(fp->AudioDataHeader, fp->FrameData+AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH, headerlen-AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH);  
        fp->CurUnitHeader = fp->AudioDataHeader;
    
        // get playing audio stream id
        for(i=0; i<TP_AUDIO_STREAM_NUM_MAX; i++)
        {
            if (fp->Language == stream->StreamParam.AudioParam[i].Language)
            {
                fp->PlayingAudioStream = i;
                break;
            }
        }
            
        fp->FrameData += fp->AudioUnitNum*AUDIO_DATA_HEADER_UNIT_PARAM_WIDTH 
                              + HEADER_CRC_FIELD_WIDTH + AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH;
        fp->FrameDataLen -= fp->AudioUnitNum*AUDIO_DATA_HEADER_UNIT_PARAM_WIDTH
                                 + HEADER_CRC_FIELD_WIDTH + AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH;
        fp->AudioFieldLength -=  fp->AudioUnitNum*AUDIO_DATA_HEADER_UNIT_PARAM_WIDTH
                                 + HEADER_CRC_FIELD_WIDTH + AUDIO_DATA_HEADER_UNIT_NUM_FIELD_WIDTH;
        fp->ParserState = TP_FP_STATE_GET_AUDIO_DATA_HEADER_CONTENT;
    }
    else
        fp->Error = TP_RET_DATA_NONE_ERR;
}

VOID GetAudioDataHeaderContent(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{
    TP_UINT16  streamid;
    TP_UINT32  framelen;

    if (fp->AudioUnitNum > 0)
    {
        streamid = *(fp->CurUnitHeader+2)>>5;
        framelen = (*fp->CurUnitHeader<<8) + *(fp->CurUnitHeader+1);
        fp->CurUnitLen = framelen;
        if (fp->PlayingAudioStream == streamid)
        {
            if (stream->AudioFrame == 0)
            {
                stream->AudioFrame = pf_alloc(sizeof(TP_STREAM_AUDIO_FRAME_T));
                fp->CurAudioFrame = stream->AudioFrame;
            }
            else
            {
                fp->CurAudioFrame->next = pf_alloc(sizeof(TP_STREAM_AUDIO_FRAME_T));
                fp->CurAudioFrame = fp->CurAudioFrame->next;
            }
            
            pf_memset(fp->CurAudioFrame, 0, sizeof(TP_STREAM_AUDIO_FRAME_T));
            fp->CurAudioFrame->Data = pf_alloc(framelen);
            fp->CurAudioFrame->State = TP_FRAME_DATA_STATE_READING;
            fp->CurAudioFrame->StreamId = (TP_UINT8)streamid;
            fp->CurAudioFrame->StartPlayTime = (*(fp->CurUnitHeader+3)<<8) + *(fp->CurUnitHeader+4);
        }

        fp->AudioUnitNum--;
        fp->ParserState = TP_FP_STATE_GET_AUDIO_DATA;
    }
    else //None audio
    {
        pf_free(fp->AudioDataHeader);
        if (fp->AudioFieldLength > 0)
        {
            fp->FrameData += fp->AudioFieldLength;
            fp->FrameDataLen -= fp->AudioFieldLength;
        }
        fp->ParserState = TP_FP_STATE_GET_OTHER_DATA_HEADER_UNITNUM;
    }
}

VOID GetAudioDataContent(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{
    TP_UINT16  streamid;
    TP_UINT32  i, latmpackagelen;

    if (fp->FrameDataLen >= fp->CurUnitLen)
    {
        streamid = *(fp->CurUnitHeader+2)>>5;
        if (fp->PlayingAudioStream == streamid)
        {
        #ifdef TP_DATA_ENCRYPTION
            if (fp->HeaderTag.Encryption_Indicator == ENCRYPTION_TYPE_ENCRYPTED)
            {
                ret = DecryptionData(fp->FrameData, fp->CurUnitLen);
                if (ret)
                {
                    pf_free(fp->AudioDataHeader);
                     fp->Error = ret;
                    return;
                }
            }
        #endif
            i = 0;
            latmpackagelen = 0;
            // depack latm
            do
            {
                latmpackagelen += fp->FrameData[i]; 
                if (i > MAXLATMLENGTH-1)
                {
                    pf_free(fp->AudioDataHeader);
                    fp->Error = TP_RET_DATA_ERR;
                    return;
                }
            }while(fp->FrameData[i++] == 0xFF);
            
			if (latmpackagelen >= fp->CurUnitLen)
			{
			    pf_free(fp->AudioDataHeader);
				fp->Error = TP_RET_DATA_ERR;
				return;
			}

            pf_memcpy(fp->CurAudioFrame->Data, fp->FrameData+i, latmpackagelen);
            fp->CurAudioFrame->Size = latmpackagelen;
            fp->CurAudioFrame->State = TP_FRAME_DATA_STATE_READY;
            stream->ReadyAudioFrameCount++;
        }

        fp->CurUnitHeader += AUDIO_DATA_HEADER_UNIT_PARAM_WIDTH;

        fp->FrameData += fp->CurUnitLen;
        fp->FrameDataLen -= fp->CurUnitLen;
        fp->AudioFieldLength -= fp->CurUnitLen;
        fp->ParserState = TP_FP_STATE_GET_AUDIO_DATA_HEADER_CONTENT;
    }
    else
        fp->Error = TP_RET_DATA_NONE_ERR;
}

VOID GetOtherDataHeaderUnitNum(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{
    if (!fp->HeaderTag.OtherField_isValid)
    {
        fp->ParserState = TP_FP_STATE_END;
        return;
    }
    
    if (fp->FrameDataLen > OTHER_DATA_HEADER_UNIT_NUM_FIELD_WIDTH)
    {
        fp->OtherUnitNum = *(fp->FrameData);
        fp->ParserState = TP_FP_STATE_GET_OTHER_DATA_HEADER;
    }
    else
        fp->Error = TP_RET_DATA_NONE_ERR;
}


VOID GetOtherDataHeader(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{
    TP_INT32   i,headerlen;
    TP_STREAM_OTHER_DATA_FRAME_T *CurFrame;
    TP_UINT8   *framedatap;
    
    if (fp->FrameDataLen >= fp->OtherUnitNum*OTHER_DATA_HEADER_UNIT_PARAM_WIDTH+HEADER_CRC_FIELD_WIDTH+OTHER_DATA_HEADER_UNIT_NUM_FIELD_WIDTH)
    {
        headerlen = fp->OtherUnitNum*OTHER_DATA_HEADER_UNIT_PARAM_WIDTH+OTHER_DATA_HEADER_UNIT_NUM_FIELD_WIDTH;
        if (!CheckCRC(fp->FrameData, headerlen, fp->FrameData+headerlen))
        {
            fp->Error = TP_RET_CRC_ERR;
            return;
        }
        
        framedatap = fp->FrameData+OTHER_DATA_HEADER_UNIT_NUM_FIELD_WIDTH;
        stream->OtherFrame = pf_alloc(sizeof(TP_STREAM_OTHER_DATA_FRAME_T));
        pf_memset(stream->OtherFrame, 0, sizeof(TP_STREAM_OTHER_DATA_FRAME_T));
        CurFrame = stream->OtherFrame;
        for(i=0; i<fp->OtherUnitNum-1; i++)
        {
            CurFrame->next = pf_alloc(sizeof(TP_STREAM_OTHER_DATA_FRAME_T));
            pf_memset(CurFrame->next, 0, sizeof(TP_STREAM_OTHER_DATA_FRAME_T));
            CurFrame = CurFrame->next;
        }
        
        for(CurFrame=stream->OtherFrame; CurFrame!=NULL; CurFrame=CurFrame->next)
        {
            CurFrame->Type = *framedatap;
            CurFrame->Size = (*(framedatap+1)<<8) + *(framedatap+2);
            CurFrame->State = TP_FRAME_DATA_STATE_READING;
            CurFrame->Data = pf_alloc(CurFrame->Size);
            framedatap += 3;
        }
            
        fp->FrameData += fp->OtherUnitNum*OTHER_DATA_HEADER_UNIT_PARAM_WIDTH 
                                + HEADER_CRC_FIELD_WIDTH+OTHER_DATA_HEADER_UNIT_NUM_FIELD_WIDTH;
        fp->FrameDataLen -= fp->OtherUnitNum*OTHER_DATA_HEADER_UNIT_PARAM_WIDTH
                                 + HEADER_CRC_FIELD_WIDTH + OTHER_DATA_HEADER_UNIT_NUM_FIELD_WIDTH;
                                 
        fp->CurOtherFrame = stream->OtherFrame;
        fp->ParserState = TP_FP_STATE_GET_OTHER_DATA;
    }
    else
        fp->Error = TP_RET_DATA_NONE_ERR;
}


VOID GetOtherDataContent(FRAME_PARSER_T *fp, TP_DTV_STREAM_T *stream)
{
    if (fp->FrameDataLen >= fp->CurOtherFrame->Size)
    {
    #ifdef TP_DATA_ENCRYPTION
        if (fp->CurOtherFrame->Type < TP_OTHER_DATA_TYPE_ECM || fp->CurOtherFrame->Type > TP_OTHER_DATA_TYPE_EMM)
            if (fp->HeaderTag.Encryption_Indicator == ENCRYPTION_TYPE_ENCRYPTED)
            {
                ret = DecryptionData(fp->FrameData, fp->CurOtherFrame->Size);
                if (ret != TP_RET_SUC)
                {
                    fp->Error = ret;
                    FreeOtherDataMem(stream, 1);
                    retrun;
                }
            }
    #endif
        pf_memcpy(fp->CurOtherFrame->Data, fp->FrameData, fp->CurOtherFrame->Size);
        fp->CurOtherFrame->State = TP_FRAME_DATA_STATE_READY;

        fp->FrameData += fp->CurOtherFrame->Size;
        fp->FrameDataLen -= fp->CurOtherFrame->Size;
        
        if (fp->CurOtherFrame->next)
        {
            fp->CurOtherFrame = fp->CurOtherFrame->next;
            fp->ParserState = TP_FP_STATE_GET_OTHER_DATA;
        }
        else
            fp->ParserState = TP_FP_STATE_END;
    }