umc_mpeg2_spl_av.cpp

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

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2003-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "umc_mpeg2_spl_defs.h"
#include "umc_mpeg2_spl_av.h"
#include "umc_mpeg4_pure_detect.h"
#include "umc_mpeg2_spl_dword_pointer.h"
#include "vm_sys_info.h"
#include <ipps.h>

using namespace UMC;

MPEG2AVSplitter::MPEG2AVSplitter():MPEG2SplitterBase()
{
    m_bFistAudioFrame[0] = false;
    m_bFistAudioFrame[1] = false;
    m_bFirstValidAPTS       = false;
    m_bFirstValidVPTS       = false;
    m_uiTargetMPEGASyncWord = 0;

    m_uiStartCodePos        = 0;
    m_uiStartCodeOff        = 0;
    m_uiVideoFrameCount     = 0;

    m_pTmpDataBuffAct       = NULL;

    //main video header was not find
    m_bSequenceFound        = false;
    m_isInFrame             = 0;
    m_returnedbytes         = 0;

    m_bForwardDirection     = false; //reverse playback

    m_uiVideoAcceptanceLevel=4;//I frames only
    m_h264Headers.m_bBrokenHeader =false;

}

Status MPEG2AVSplitter::FindPCM(int len)
{
    m_uiOutputAudioSize = 1920*2;
    //output original data without swapping
    return FillAudioBuffer(len, 0);

}


Status MPEG2AVSplitter::FindLPCM(int len)
{

    m_uiOutputAudioSize = 1920*2;
    //LPCM requires 2 bytes swapping
    return FillAudioBuffer(len, 1);

}

Status  MPEG2AVSplitter::CheckEndian(bool wantSwap)
{
    if(wantSwap == false)
    {
      m_splitter_flags &= ~FLAG_VSPL_4BYTE_ACCESS;
    }

    return UMC_OK;
}

Status MPEG2AVSplitter::FindAC3Sync(ElementaryStream* pEs, int len)
{
    UMC::Status      ret;
    unsigned char temp;
    unsigned char aux_byte;
    unsigned int  tmp_len = len;

    while(m_bFistAudioFrame[m_uiCurrInputBuffNum])
    {
        ret = m_pDataReader->CheckByte(&temp, len - tmp_len);
        if(ret != UMC_OK) return ret;
        tmp_len--;

        if(!tmp_len || ret != UMC_OK)
            break;

        while((temp) != 0x0b && tmp_len && (ret == UMC_OK))
        {
            ret = m_pDataReader->CheckByte(&temp, len - tmp_len);
            if(ret != UMC_OK) return ret;
            tmp_len--;

        }
        if(!tmp_len || ret != UMC_OK)
            break;

        ret = m_pDataReader->CheckByte(&temp, len - tmp_len);
        if(ret != UMC_OK) return ret;

        tmp_len--;

        if(!tmp_len)
            break;

        if(temp != 0x77) continue;


        ret = m_pDataReader->CheckByte(&aux_byte, len - tmp_len + 2);
        if(ret != UMC_OK) return ret;

        int fscod                = (aux_byte & 0xc0)>> 6;
        int frmsizecod            = (aux_byte & 0x3f);

        pEs->m_audioStreamInfo.sample_frequency  = AC3Fequency[fscod];
        pEs->m_audioStreamInfo.channels                 = 2;
        pEs->m_audioStreamInfo.bitPerSample             = 16;
        pEs->m_audioStreamInfo.bitrate                 = AC3FrameSize[frmsizecod].bit_rate;

        if(frmsizecod > 38 || frmsizecod < 0  || fscod > 2)
        {
            continue;
        }
        //ret = m_pDataReader->MovePosition(len - tmp_len);

        m_bFistAudioFrame[m_uiCurrInputBuffNum] = false;

    }

    m_uiOutputAudioSize = tmp_len < 1152? 1152*4:tmp_len*4;//1920*2;
    if(m_dCurrAudioPts != -1.0)
        m_bFirstValidAPTS = true;

    if(m_bFistAudioFrame[m_uiCurrInputBuffNum] || !m_bFirstValidAPTS)
    {
        ret = m_pDataReader->MovePosition(len);
    }
    else
    {
        //output original data without swapping
        ret = FillAudioBuffer(len, 0);
    }


    return ret;

}


Status MPEG2AVSplitter::FindMPEGASync(ElementaryStream* pEs,int len)
{
    UMC::Status      ret;
    unsigned char temp;
    unsigned int  tmp_len = len;
    MediaData     data;

    while(m_bFistAudioFrame[m_uiCurrInputBuffNum])
    {
        ret = m_pDataReader->CheckByte(&temp, len - tmp_len);
        if(ret != UMC_OK) return ret;
        tmp_len--;

        if(!tmp_len || ret != UMC_OK)
            break;

        while((temp) != 0xff && tmp_len && (ret == UMC_OK))
        {
            ret = m_pDataReader->CheckByte(&temp, len - tmp_len);
            if(ret != UMC_OK) return ret;
            tmp_len--;

        }
        if(!tmp_len || ret != UMC_OK)
            break;

        ret = m_pDataReader->CheckByte(&temp, len - tmp_len);
        if(ret != UMC_OK) return ret;
        tmp_len--;

        if(!tmp_len || ret != UMC_OK)
            break;

        if(m_uiTargetMPEGASyncWord == 0)
        {
            //if((temp & 0xfc)!= 0xfc)
            //    continue;
        }
        else
        {
            if((temp & 0xfe)!= (unsigned char)(m_uiTargetMPEGASyncWord&0xff))
                continue;
        }

        unsigned char aux_byte1;
        unsigned char aux_byte2;
        unsigned char aux_byte3;

        ret = m_pDataReader->CheckByte(&aux_byte1, len - tmp_len - 1);
        if(ret != UMC_OK) return ret;
        ret = m_pDataReader->CheckByte(&aux_byte2, len - tmp_len + 0);
        if(ret != UMC_OK) return ret;
        ret = m_pDataReader->CheckByte(&aux_byte3, len - tmp_len + 1);
        if(ret != UMC_OK) return ret;

        int id    = (aux_byte1&0x08)>>3;
        int la    = ((aux_byte1&0x06)>>1);
        int br  = (aux_byte2&0xf0) >> 4;
        int fr  = (aux_byte2&0x0c)>>2;
        int md  = (aux_byte3&0xc0)>>6;

        if((la == 0) && (id == 1))
        {
            VM_ASSERT(0);

            pEs->m_audioStreamInfo.sample_frequency   = MPEGAFequency[id][fr];
            pEs->m_audioStreamInfo.channels           = MPEGAChannels[md];
            pEs->m_audioStreamInfo.bitPerSample       = 16;
            pEs->m_audioStreamInfo.bitrate            = MPEGABitrate[id][la][br];

        } else {
            if(!pEs->m_audioStreamInfo.sample_frequency)
            {
                pEs->m_audioStreamInfo.sample_frequency = MPEGAFequency[id][fr];
            }
            pEs->m_audioStreamInfo.channels         = MPEGAChannels[md];
            pEs->m_audioStreamInfo.bitPerSample     = 16;
            pEs->m_audioStreamInfo.bitrate          = MPEGABitrate[id][la][br];
        }
        if(m_uiTargetMPEGASyncWord == 0)
        {
            m_uiTargetMPEGASyncWord = 0x0000ff00| (temp&0xfe);
            switch((temp & 0xfe))
            {
            case 0xf2:
                pEs->m_audioStreamInfo.stream_type       = MP2L3_AUDIO;
                break;
            case 0xf4:
                pEs->m_audioStreamInfo.stream_type       = MP2L2_AUDIO;
                break;
            case 0xf6:
                pEs->m_audioStreamInfo.stream_type       = MP2L1_AUDIO;
                break;
            case 0xf8:
                pEs->m_audioStreamInfo.stream_type       = AAC_AUDIO;
                break;
            case 0xfa:
                pEs->m_audioStreamInfo.stream_type       = MP1L3_AUDIO;
                break;
            case 0xfc:
                pEs->m_audioStreamInfo.stream_type       = MP1L2_AUDIO;
                break;
            case 0xfe:
                pEs->m_audioStreamInfo.stream_type       = MP1L1_AUDIO;
                break;
            default:
                break;
            }
        }

        tmp_len += 2;
        tmp_len = len;
        //ret = m_pDataReader->MovePosition(len - tmp_len);
        //if(ret != UMC_OK)   return ret;
        m_bFistAudioFrame[m_uiCurrInputBuffNum]    = false;

    }

    m_uiOutputAudioSize = tmp_len < 1152? 1152*8:tmp_len*8;
    if(m_dCurrAudioPts != -1.0)
        m_bFirstValidAPTS = true;

    if(m_bFistAudioFrame[m_uiCurrInputBuffNum] || !m_bFirstValidAPTS)
    {
        //remove all data until first frame with valid PTS
        //is found, it is required only for AV sync strams
        //for pure audio files PTS does nor required
        ret = m_pDataReader->MovePosition(len);
    }
    else
    {
    //output original data without swapping
          ret = FillAudioBuffer(tmp_len, 0);
    }

    return ret;

}


Status MPEG2AVSplitter::FindMPEG2StartCode(MediaData*       input,
                                           MediaData*       output,
                                           InfoFromPrevPES &    sInfoFromPrevPES,
                                           StartCodePos*    pStartCodePos,
                                           unsigned int&    rStartCodeMax,
                                           unsigned int     uiStartCodeOff,
                                           bool             breakIfSeq,
                                           bool&            isSeqFound,
                                           int              flagInit) // only seq.header

{
    int            i          = 0;
    unsigned int   code_count = 0;
    int            uiDataLen  = input->GetDataSize();
    unsigned char* pucInData;
    unsigned char* pucOutData;
    Status         ret        = UMC_NOT_ENOUGH_DATA;