umc_mpeg2ts_spl.cpp

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

                        }
                        else
                        {
                            //video data bytes only
                            if(m_pESArray[i].m_videoStreamInfo.stream_type == MPEG2_VIDEO)
                                err = FillBufferMPEG2Video(&m_pESArray[i], m_uiCurrentPackSize, m_uiEndian);
                            else if(m_pESArray[i].m_videoStreamInfo.stream_type == MPEG4_VIDEO)
                                err = FillBufferMPEG4Video(&m_pESArray[i], m_uiCurrentPackSize, 0);
                            else if(m_pESArray[i].m_videoStreamInfo.stream_type == H264_VIDEO)
                                err = FillBufferH264Video(&m_pESArray[i], m_uiCurrentPackSize, m_uiEndian);
                            else
                                found = 0;
                        }
                    }
                    if(err == UMC_NOT_ENOUGH_DATA)
                        err = UMC_OK;

                    if(err != UMC_OK)
                        return err;

                    //TBD count packets
                    m_pESArray[i].m_uiNumReadPackets++;
                    m_pESArray[i].m_uiSizeReadPackets += m_uiCurrentPackSize;

                    break;
                }
                else if((m_pESArray[i].m_uiStreamSubID == PID) && //audio
                        (m_uiChoosedProgram == m_pESArray[i].m_uiProgramNum))
                {
                    if(m_bIgnoreAudio)
                    {
                        break;
                    }
                    m_dCurrAudioPts = -1;
                    err = AdaptationField(adaptation_field_control);
                    if(err != UMC_OK) return err;

                    if(payload_unit_start_indicator)
                    {

                        //pes packet come
                        err = MPEG2PESPack(m_uiCurrentPackSize, i, PID);
                    }
                    else
                    {
                        if(m_pESArray[i].m_audioStreamInfo.stream_type == AC3_AUDIO)
                        {
                            err = FindAC3Sync(&m_pESArray[i], m_uiCurrentPackSize);
                        }
                        else if((m_pESArray[i].m_audioStreamInfo.stream_type & MPEG1_AUDIO) ||
                                (m_pESArray[i].m_audioStreamInfo.stream_type & MPEG2_AUDIO))
                        {
                            err = FindMPEGASync(&m_pESArray[i], m_uiCurrentPackSize);
                        }
                        else if(m_pESArray[i].m_audioStreamInfo.stream_type == PCM_AUDIO)
                        {
                            err = FindPCM(m_uiCurrentPackSize);
                        }
                        else if(m_pESArray[i].m_audioStreamInfo.stream_type == LPCM_AUDIO)
                        {
                            unsigned char  byteCode;
                            err = m_pDataReader->CheckByte(&byteCode, 0);
                            if(err != UMC_OK) return err;
                            m_uiCurrentPackSize --;

                            if(byteCode == 0xa0)
                            {
                                err = m_pDataReader->GetByte(&byteCode);
                                if(err != UMC_OK) return err;
                                err = m_pDataReader->MovePosition(6);
                                if(err != UMC_OK) return err;

                                m_uiCurrentPackSize -= 7;
                            }

                            err = FindLPCM(m_uiCurrentPackSize);
                        }
                        else
                            VM_ASSERT(0);

                         //err = PutAudioDataT(&m_pESArray[i],
                        //                    adaptation_field_control,
                        //                   payload_unit_start_indicator);
                    }
                    if(err != UMC_OK) return err;

                    found = 1;
                    break;
                }
            }
            if(!found)
            {
                err = m_pDataReader->MovePosition( m_uiCurrentPackSize);
                if(err != UMC_OK) return err;
                m_uiCurrentPackSize = 0;
            }
        }
        break;
    }

    return err;
}




Status MPEG2TSSplitter::AdaptationField(int  adaptation_field_control)
{
    UMC::Status ret = UMC_OK;
    unsigned int hlen;
    unsigned char byteCode = 0;

    switch(adaptation_field_control)
    {
    case 3:
        ret = m_pDataReader->GetByte(&byteCode);
        if(ret != UMC_OK) return ret;
        hlen = (unsigned int)byteCode;
        ret = m_pDataReader->MovePosition(hlen);
        if(ret != UMC_OK) return ret;
        m_uiCurrentPackSize -= (hlen+1);

        break;
    case 2:
        ret = m_pDataReader->MovePosition(m_uiCurrentPackSize);
        if(ret != UMC_OK) return ret;
        m_uiCurrentPackSize = 0;
        break;
    case 1:
        break;
    default:
        VM_ASSERT(0);
        break;
    }

    return ret;
}





int MPEG2TSSplitter::ProgramAssociationSection(int payload_indicator)
{
    unsigned char ucharVal;
//    unsigned int crc;

    unsigned char table_id;                 //    8    uimsbf
    unsigned char section_syntax_indicator; //    1    bslbf
    unsigned char zero_bit;                 // '0'    1    bslbf
//    unsigned char reserved1;                //  2    bslbf
    unsigned short section_length;                    //12    uimsbf
    unsigned short transport_stream_id;                //16    uimsbf
    //unsigned char reserved2;                //2    bslbf
    unsigned char version_number;            //5    uimsbf
    unsigned char current_next_indicator;    //1    bslbf
    unsigned char section_number;            //8    uimsbf
    unsigned char last_section_number;        //8    uimsbf

    int sizetoget = 0;
    int gotBytes = 3;
       Status err = m_pDataReader->GetByte(&table_id);
    if(UMC_OK != err) return err;

    payload_indicator = !!payload_indicator;

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

    section_syntax_indicator = (unsigned char)((section_length&0x8000) >> 15);
    zero_bit = (unsigned char)(section_length&0x4000);
    VM_ASSERT(zero_bit == 0);
    section_length &= 0x0FFF;
    VM_ASSERT((section_length & 0x0c00) == 0 && (section_length < 1021));

    if(payload_indicator)
    {
           err = m_pDataReader->GetByte(&ucharVal);
        if(UMC_OK != err) return err;

        sizetoget = (ucharVal - 5)/4;
        gotBytes++;
    }
    else
    {
        sizetoget = (section_length-10)/4;
    }

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

       err = m_pDataReader->GetByte(&ucharVal);
    if(UMC_OK != err) return err;

       version_number = (unsigned char)((ucharVal & 0x1f) >> 1);
    current_next_indicator = (unsigned char)(ucharVal&1);

    err = m_pDataReader->GetByte(&section_number);
    if(UMC_OK != err) return err;

       err = m_pDataReader->GetByte(&last_section_number);
    if(UMC_OK != err) return err;

    gotBytes += 5;

    int i;
    for (i = 0; i < sizetoget; i++)
    {
        unsigned short program_number;            //16    uimsbf
//        unsigned char reserved3;                //3        bslbf
        unsigned short program_map_PID = 0;     //13    uimsbf
        unsigned short network_PID;                //13    uimsbf

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

        if(program_number == 0)
        {
            err = m_pDataReader->GetShort(&network_PID);
            if(UMC_OK != err) return err;

            network_PID &= 0x1fff;
        }
        else
        {
            err = m_pDataReader->GetShort(&program_map_PID);
            if(UMC_OK != err) return err;

            program_map_PID &= 0x1fff;
        }
        //TBD change here
        if(program_map_PID < 0x1fff && m_inESCount < 10)
        {
            int existFlag = 0;
            int j;
            for(j = 0; j < m_inESCount; j++)
            {
                if(m_pESArray[j].m_uiProgramNum  == program_number)
                {
                    existFlag = 1;
                }
            }
            if(!existFlag)
            {
                m_pESArray[j].m_uiProgramNum = program_number;
                m_pESArray[j].m_uiPMSecID    = program_map_PID;
                m_inESCount++;
            }
        }
        gotBytes += 4;
    }
    //CRC_32    32    rpchof
       //err = m_pDataReader->GetUInt(&crc);
       return  gotBytes;


}
int MPEG2TSSplitter::TSProgramMapSection(int payload_indicator, int index)
{
    unsigned char table_id;
    unsigned char ucharVal;
    unsigned char section_syntax_indicator;
    unsigned char reserved;
    unsigned short section_length;
    unsigned short program_number;
//    int version_number;
//    int current_next_indicator;
    unsigned char section_number;
    unsigned char last_section_number;
    unsigned short PCR_PID;
    unsigned short reserved1;
    int  program_info_length;
    unsigned int CRC_32;
    int  code;
    int bytecount = 13;
    Status err;
    int sizetoget;

    payload_indicator = !!payload_indicator;

    err = m_pDataReader->GetByte(&table_id);
    if(UMC_OK != err) return err;

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

    section_syntax_indicator = (unsigned char)((section_length&0x8000)>>15);
//    VM_ASSERT(section_syntax_indicator == 1);
    code = (unsigned char)((section_length&0x4000));
    VM_ASSERT(code == 0);
    section_length &= 0x0fff;
    VM_ASSERT(section_length < 1021);

    if(payload_indicator)
    {
           err = m_pDataReader->GetByte(&ucharVal);
        if(UMC_OK != err) return err;

        sizetoget = ucharVal;
    }
    else
    {
        sizetoget = section_length;
    }

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

    err = m_pDataReader->GetByte(&reserved);//reserved                  2 bits
                                            //version_number            5bits
                                            //current_next_indicator    1bits

    if(UMC_OK != err) return err;

    err = m_pDataReader->GetByte(&section_number);     //section_number 8bits
    if(UMC_OK != err) return err;

    err = m_pDataReader->GetByte(&last_section_number);//last_section_number 8bits
    if(UMC_OK != err) return err;

    err = m_pDataReader->GetShort(&PCR_PID);// reserved     3 bits
                                            // PCR_PID      13bits
    if(UMC_OK != err) return err;

    PCR_PID                 &= 0x1fff;
    //TBD fill corresponding program info
    //m_pESArray[index]->PCR_PID = PCR_PID;

    err = m_pDataReader->GetShort(&reserved1);  //reserved              4 bits
                                                //program_info_length   12bits
    if(UMC_OK != err) return err;

    program_info_length = reserved1 & 0x0fff;

    bytecount += program_info_length;
    while (program_info_length > 0)
    {
        program_info_length -= GetDescriptor(index);
        if(program_info_length < 0)
        {
            bytecount += -program_info_length;
        }
    }

    while (bytecount < sizetoget)
    {
        unsigned char stream_type;
        unsigned short elementary_PID;
        unsigned short ES_info_length;
        short signed_ES_info_length;
//        int exist = 0;

        //stream_type 8bits
        err = m_pDataReader->GetByte(&stream_type);
        if(UMC_OK != err) return err;


        //reserved        3 bits
        //elementary_PID  13bits
        err = m_pDataReader->GetShort(&elementary_PID);
        if(UMC_OK != err) return err;
        elementary_PID &= 0x1fff;

        //reserved        4bits
        //ES_info_length 12bits
        err = m_pDataReader->GetShort(&ES_info_length);
        if(UMC_OK != err) return err;

        ES_info_length &= 0x0fff;

        bytecount += 5;
        switch(stream_type)
        {
        case 1: // ISO/IEC 11172 Video
            if(m_bIgnoreVideo)
                break;
            //m_sSplInfo.m_video_info.stream_type = MPEG1_VIDEO;
            //TBD fill corresponding program info
            CheckEndian(true);
            m_pESArray[index].m_uiStreamID    = elementary_PID;
            m_pESArray[index].m_videoStreamInfo.stream_type    = MPEG1_VIDEO;
            break;
        case 2://ITU-T Rec. H.262 | ISO/IEC 13818-2 Video
               //or ISO/IEC 11172-2 constrained parameter video stream
            if(m_bIgnoreVideo)
                break;
            //m_sSplInfo.m_video_info.stream_type = MPEG2_VIDEO;
            //TBD fill corresponding program info
            CheckEndian(true);
            m_pESArray[index].m_uiStreamID = elementary_PID;
            m_pESArray[index].m_videoStreamInfo.stream_type    = MPEG2_VIDEO;
            break;
        case 3://ISO/IEC 11172 Audio
            if(m_bIgnoreAudio)
                break;
             if(UNDEF_AUDIO == m_pESArray[index].m_audioStreamInfo.stream_type)
             {
                 //m_sSplInfo.m_audio_info.stream_type             = MPEG1_AUDIO;
                 //TBD fill corresponding program info
                 m_pESArray[index].m_audioStreamInfo.stream_type  = MPEG1_AUDIO;
                 m_pESArray[index].m_uiStreamSubID = elementary_PID;
             }
             break;
        case 4: //ISO/IEC 13818-3 Audio
            if(m_bIgnoreAudio)
                break;
             if(UNDEF_AUDIO == m_pESArray[index].m_audioStreamInfo.stream_type)
             {
                 //m_sSplInfo.m_audio_info.stream_type             = MPEG2_AUDIO;
                 //TBD fill corresponding program info
                 m_pESArray[index].m_audioStreamInfo.stream_type  = MPEG2_AUDIO;
                 m_pESArray[index].m_uiStreamSubID = elementary_PID;