umc_mpeg2pes_spl.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

                pCurrES->m_audioStreamInfo.streamPID = byteCode;
                if((m_iChoosedAudio[0] != streamID) && (m_iChoosedAudio[1] != streamID))
                {
                    //skip packet if not chosed ES
                    err = m_pDataReader->MovePosition(PES_packet_length- gotBytes);
                    if(err != UMC_OK) return err;

                    if((m_systemStreamInfo.stream_type == MPEG2_TRANSPORT_STREAM) ||
                       ((byteCode & 0xfc) == 0x80))
                    {
                        pCurrES->m_audioStreamInfo.stream_type = AC3_AUDIO;
                    }
                    else if((byteCode & 0xfe)== 0xa0)
                    {
                        pCurrES->m_audioStreamInfo.stream_type  = LPCM_AUDIO;
                    }
                    m_uiSkippedDataSize += PES_packet_length- gotBytes;
                }
                else
                {
                    m_uiCurrInputBuffNum = 0;
                    if((m_iChoosedAudio[1] == streamID))
                        m_uiCurrInputBuffNum = 1;

                    //1000 0000b default english
                    //1000 00xx  other languages
                    if((m_systemStreamInfo.stream_type == MPEG2_TRANSPORT_STREAM) ||
                       ((byteCode & 0xfc) == 0x80) ||
                       ((byteCode & 0xff) == 0x0b)) //chose language here
                    {
                        pCurrES->m_audioStreamInfo.stream_type = AC3_AUDIO;

                        if(m_systemStreamInfo.stream_type == MPEG2_PROGRAMM_STREAM)
                        {
                            pCurrES->m_uiStreamSubID = streamID;

                            if((err = ParseAC3PacketHeader(&m_pESArray[i])) != UMC_OK)
                               return err;

                            gotBytes += 3;
                         }

                        //TBD find start codes and fill buffer

                        //m_bFirstValidAPTS = true;
                        err = FindAC3Sync(pCurrES, PES_packet_length- gotBytes);
                        if(err != UMC_OK) return err;

                        pCurrES->m_uiNumReadPackets++;
                        pCurrES->m_uiSizeReadPackets += PES_packet_length- gotBytes;

                    }
                    //1010 000*b *=LPCM substream number
                    else if((byteCode & 0xfe)== 0xa0)
                    {
                        pCurrES->m_audioStreamInfo.stream_type  = LPCM_AUDIO;

                        pCurrES->m_uiStreamSubID = streamID;

                        if((err = ParseLPCMPacketHeader(pCurrES)) != UMC_OK)
                            return err;

                        gotBytes += 6;

                        //read LPCM data
                        if((err = FindLPCM(PES_packet_length- gotBytes )) != UMC_OK)
                            return err;

                        pCurrES->m_uiNumReadPackets++;
                        pCurrES->m_uiSizeReadPackets += PES_packet_length- gotBytes;


                    }
                    else
                    {
                        //skip this packet in any other cases
                        //don't know how to interpret it
                        err = m_pDataReader->MovePosition(PES_packet_length- gotBytes - 1);
                        if(err != UMC_OK) return err;
                        m_uiSkippedDataSize += PES_packet_length- gotBytes - 1;
                    }
                }
            }
            else
            {
                //skip this data packet in any other cases
                //don't know how to interpret it
                err = m_pDataReader->MovePosition(PES_packet_length- gotBytes);
                if(err != UMC_OK) return err;
                m_uiSkippedDataSize += PES_packet_length- gotBytes;
            }

            m_uiSkippedDataSize += PES_packet_length - useful_data;

        }
        else if(longCode == ID_PS_PROGRAM_STREAM_MAP)
        {
            //skip program map section in any other cases
            //TBD need to clarify its purpose

            //get PES length
            err = m_pDataReader->GetShort(&shortCode);
            if(err != UMC_OK) return err;
            PES_packet_length = shortCode;

            err = m_pDataReader->MovePosition(PES_packet_length- gotBytes);
            if(err != UMC_OK) return err;

            //m_uiSkippedDataSize += PES_packet_length- gotBytes;
            //process program map
            //err = PSProgramMapSection(0);
            //if(err != UMC_OK) return err;


            m_uiSkippedDataSize += shortCode;

        }
        else if(longCode == ID_PADDING_STREAM)
        {
            //skip useless padding
            //get stream id
            //err = m_pDataReader->GetUInt(&longCode);

            //if(err != UMC_OK) return err;
            //skip padding stream
            err = m_pDataReader->GetShort(&shortCode);
            if(err != UMC_OK) return err;

            err = m_pDataReader->MovePosition( shortCode);
            if(err != UMC_OK) return err;

            m_uiSkippedDataSize += shortCode;
        }
        else
        {
            //skip streams:
            // private_stream_2
            // ECM
            // EMM
            // program_stream_directory
            // DSMCC_stream
            // ITU-T Rec. H.222.1 type E stream

            //get stream id
            //err = m_pDataReader->GetUInt(&longCode);
            //if(err != UMC_OK) return err;

            err = m_pDataReader->GetShort(&shortCode);
            if(err != UMC_OK) return err;

            err = m_pDataReader->MovePosition( shortCode);
            if(err != UMC_OK) return err;

            m_uiSkippedDataSize += shortCode;

       }

    }

    return err;

}

Status MPEG2PESSplitter::MPEG2PESPacketHeader(double* out_pts, double* out_dts, int &gotBytes)
{
    Status            ret = UMC_OK;
    unsigned char    byte_code;
    unsigned short    shortCode;
    unsigned int    ptstmp;
    unsigned char   head_data_len;
    int PTSDTSflag;
    int headGotByte = 0;

    gotBytes = 0;
    *out_pts = -1.0;
    *out_dts = -1.0;

    if(m_systemStreamInfo.stream_type & (MPEG2_SYSTEM_STREAM&~MPEGx_SYSTEM_STREAM))
    {
        ret = m_pDataReader->GetShort(&shortCode);
        if(ret != UMC_OK) return ret;
        gotBytes +=2;
        VM_ASSERT((shortCode>>14)==2);
        PTSDTSflag      = (shortCode & 0x00c0) >> 6;
        int ESCR_flag   = (shortCode & 0x0020) >> 5;
        int ES_rate_flag= (shortCode & 0x0010) >> 4;
        int DSM_trick_mode_flag= (shortCode & 0x0008) >> 3;
        int additional_copy_info_flag= (shortCode & 0x0004) >> 2;
        int PES_CRC_flag= (shortCode & 0x0002) >> 1;
        int PES_extension_flag= (shortCode & 0x0001);


        ret = m_pDataReader->GetByte(&head_data_len);
        if(ret != UMC_OK) return ret;
        gotBytes ++;

        if((PTSDTSflag & 2) == 2)
        {
            unsigned char c1;
            ret = m_pDataReader->GetByte(&c1);
            if(ret != UMC_OK) return ret;
            headGotByte++;

            c1 = (unsigned char)((c1 & 0x0f) >> 1);
            ret = m_pDataReader->GetUInt(&ptstmp);
            if(ret != UMC_OK) return ret;
            headGotByte+=4;

            ptstmp >>= 1;
            ptstmp = (ptstmp & 0x7fff) | (((ptstmp >> 16) & 0x7fff) << 15);
            *out_pts = ((double)ptstmp + (double)(c1 * 1073741824.0)) / 90000.0;


        }
        if(PTSDTSflag == 3)
        {
            unsigned char c1;
            ret = m_pDataReader->GetByte(&c1);
            if(ret != UMC_OK) return ret;
            headGotByte++;

            c1 = (unsigned char)((c1 & 0x0f) >> 1);
            ret = m_pDataReader->GetUInt(&ptstmp);
            if(ret != UMC_OK) return ret;
            headGotByte+=4;

            ptstmp >>= 1;
            ptstmp = (ptstmp & 0x7fff) | (((ptstmp >> 16) & 0x7fff) << 15);
            *out_dts = ((double)ptstmp + (double)(c1 * 1073741824.0)) / 90000.0;

            /*ret = m_pDataReader->MovePosition(5);
            if(ret != UMC_OK) return ret;
            headGotByte+=5;*/
        }
        if(ESCR_flag)
        {
            ret = m_pDataReader->MovePosition(6);
            if(ret != UMC_OK) return ret;
            headGotByte+=6;
        }
        if(ES_rate_flag)
        {
            int es_rate = 0;
            unsigned int es_size = 3;
            ret = m_pDataReader->GetData(&es_rate, &es_size);
            if(ret != UMC_OK) return ret;
            headGotByte+=3;
        }
        if (DSM_trick_mode_flag)
        {
            ret = m_pDataReader->MovePosition(1);
            if(ret != UMC_OK) return ret;
            headGotByte ++;
        }
        if ( additional_copy_info_flag)
        {
            ret = m_pDataReader->MovePosition(1);
            if(ret != UMC_OK) return ret;
            headGotByte ++;
        }
        if ( PES_CRC_flag)
        {
            ret = m_pDataReader->MovePosition(2);
            if(ret != UMC_OK) return ret;
            headGotByte +=2;
        }
        if ( PES_extension_flag)
        {
            int PES_private_data_flag;                    //1    bslbf
            int pack_header_field_flag;                    //1    bslbf
            int program_packet_sequence_counter_flag;    //1    bslbf
            int P_STD_buffer_flag;                        //1    bslbf
            //int reserved;                                //3    bslbf
            int PES_extension_flag_2;                    //1    bslbf

            ret = m_pDataReader->GetByte(&byte_code);
            if(ret != UMC_OK) return ret;
            headGotByte ++;

            PES_private_data_flag = byte_code&0x80;
            pack_header_field_flag = byte_code&0x40;
            program_packet_sequence_counter_flag = byte_code&0x20;
            P_STD_buffer_flag = byte_code&0x10;
            PES_extension_flag_2 = byte_code&1;

            if (PES_private_data_flag)
            {
                //PES_private_data    //128    bslbf
                ret = m_pDataReader->MovePosition(16);
                if(ret != UMC_OK) return ret;
                headGotByte +=16;
            }
            if (pack_header_field_flag)
            {
                VM_ASSERT(0);
                /*pack_field_length    //8    uimsbf
                pack_header()        */
                //MPEG2PSPackHeader();
            }
            if(program_packet_sequence_counter_flag)
            {
                //marker_bit                        //1    bslbf
                //program_packet_sequence_counter    //7    uimsbf
                //marker_bit                        //1    bslbf
                //MPEG1_MPEG2_identifier            //1    bslbf
                //original_stuff_length                //6    uimsbf
                ret = m_pDataReader->MovePosition(2);
                if(ret != UMC_OK) return ret;
                headGotByte +=2;
            }
            if (P_STD_buffer_flag)
            {
                //'01'                            //2    bslbf
                //P-STD_buffer_scale            //1    bslbf
                //P-STD_buffer_size                //13uimsbf
                ret = m_pDataReader->MovePosition(2);
                if(ret != UMC_OK) return ret;
                headGotByte +=2;
            }
            if (PES_extension_flag_2)
            {
                //marker_bit                        //1    bslbf
                int PES_extension_field_length;        //7    uimsbf
                ret = m_pDataReader->GetByte(&byte_code);
                if(ret != UMC_OK) return ret;
                headGotByte ++;

                PES_extension_field_length = (int)byte_code;

                ret = m_pDataReader->MovePosition(PES_extension_field_length);
                if(ret != UMC_OK) return ret;
                headGotByte +=PES_extension_field_length;
                /*for(i=0;i<PES_extension_field_length;i++)
                {
                    reserved                    //8    bslbf
                }*/
            }
        }
        if(headGotByte < head_data_len)
        {
            unsigned char stuffing_byte;
            ret = m_pDataReader->CheckByte(&stuffing_byte, 0);
            if(ret != UMC_OK) return ret;

            while(((stuffing_byte == 0xff)||(stuffing_byte == 0)) && (headGotByte < head_data_len))
            {
                ret = m_pDataReader->GetByte(&stuffing_byte);
                if(ret != UMC_OK) return ret;
                headGotByte++;

                ret = m_pDataReader->CheckByte(&stuffing_byte, 0);
                if(ret != UMC_OK) return ret;
            }
        }

       gotBytes +=headGotByte;

    }
    else if(m_systemStreamInfo.stream_type & MPEG1_SYSTEM_STREAM)