umc_mpeg2ps_spl.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_mpeg2ps_spl.h"
#include <ipps.h>

using namespace UMC;

Status MPEG2PSSplitter::InitProcessing()
{
    Status err = UMC_OK;


    ResetInfoFromPrevPES();

    if(!m_bIgnoreVideo)
    {
        InitVideoHelperBuffer(PORTION_TO_READ);
    }

    CheckEndian(true);

    return err;

}

Status MPEG2PSSplitter::CloseProcessing()
{
    if(m_lockedVideoBuffer.GetDataSize() > 16 && !m_bStop)
    {
        unsigned char* ptr = (unsigned char*)m_lockedVideoBuffer.GetBufferPointer();
        int pos = m_lockedVideoBuffer.GetDataSize();

        ptr[pos] = 0; ptr[pos+1] = 0; ptr[pos+2] = 1; ptr[pos+3] = 0xb7;
        m_lockedVideoBuffer.SetDataSize(m_lockedVideoBuffer.GetDataSize() + 4);
        m_lockedVideoBuffer.SetDataSize((m_lockedVideoBuffer.GetDataSize() + 15)&~15);
        if(m_uiEndian == 2)
        {
            //if start code was find make buffer size 16 bytes aligned
            //and swap data if needed
            Swap4Bytes((unsigned char*)m_lockedVideoBuffer.GetBufferPointer(),
                                        m_lockedVideoBuffer.GetDataSize());
        }
        m_pVideoBuffer->UnLockInputBuffer(&m_lockedVideoBuffer);
        m_uiVideoFrameCount++;
        m_lockedVideoBuffer.SetTime(m_dCurrVideoPts, m_dCurrVideoDts);

        StoreLastPositionAndPTS(m_lockedVideoBuffer.GetTime(),
                                m_pDataReader->GetPosition() -
                                m_readVideoStream.GetDataSize());

    }

    if(m_pTmpDataBuffAct)
    {
        ippsFree(m_pTmpDataBuffAct);
        m_pTmpDataBuffAct = NULL;

    }

    return UMC_OK;
}
Status MPEG2PSSplitter::GetPrevGop( unsigned int pid, vm_sizet p_start,vm_sizet &posIFrame,vm_sizet &posPackege)
{
    vm_sizet    PrevPESEndPosition=0;
    vm_sizet    PrevPacketPosition=0;
    vm_sizet    CurrPacketPosition=0;
    vm_sizet    PacketPosition=0;

    vm_sizet    start;
    vm_sizet    end;
    vm_sizet    saved_start;
    vm_sizet    video_start;

    bool            bFirstFrame = false;
    bool            bSyncWord   = true;
    unsigned char   LastBytes[]={0xff,0xff,0xff,0xff,0xff,0xff};
    Status  err;
    int     i=5;

    double  currPTS=-1.0, currDTS=-1.0;
    double  prevPTS=-1.0, prevDTS=-1.0;

    ElementaryStream* pCurrES = NULL;

    if (m_uiMAXGOPLength==0)
          m_uiMAXGOPLength=300000;



    int ii = CheckIfNewES(false, pid, -1);
    pCurrES = &m_pESArray[ii];
    end         =   p_start;
    saved_start =   p_start;
    start       =   p_start;
    video_start =   0;
    posIFrame   =   0;
    posPackege  =   0;

    memset (LastBytes,0xff,sizeof(LastBytes));

    while(!m_bStop)
    {
        unsigned int id=0;
        unsigned short length;


        if ((start>=end)&&(posIFrame==0))
        {
            // Interval [saved_start, end] was checked and I frame hasn't been found

            if (bFirstFrame)
                return UMC_END_OF_STREAM; // the first frame has been unpacked.
            if (end-m_uiMAXGOPLength <= 0)
            {
                bFirstFrame=true;
                err = m_pDataReader->SetPosition((vm_sizet)(0));
                if (err != UMC_OK) return err;
            }
            else
            {
                // Step back on m_uiMAXGOPLength
                err = m_pDataReader->SetPosition(end-m_uiMAXGOPLength);
                if (err != UMC_OK)
                    return err;
            }
            memset (LastBytes,0xff,sizeof(LastBytes));
            err = MoveToNextSyncWord();
            if (err != UMC_OK)
                return err;
            bSyncWord = true;

            start       =   m_pDataReader->GetPosition();
            end         =   (video_start>0)?video_start:saved_start;
            saved_start =   start;
            video_start =   0;


            if (start>=end)
                continue;
        }
        else if ((start>=end)&&(posIFrame>0))
        {
            // I frame was found, interval was checked
            break;
        }

        if (bSyncWord)
        {
            PacketPosition = m_pDataReader->GetPosition();
            err = MPEG2PSPackHeader();
            if (err != UMC_OK)
                return err;
            start       =   m_pDataReader->GetPosition();
            if (start>=end)
                continue;
            bSyncWord   = false;
        }

        err = m_pDataReader->CheckUInt(&id,0);
        if (err != UMC_OK)
            return err;


        if ((id >= ID_PS_PROGRAM_STREAM_MAP) &&    (id < ID_PROGRAM_STREAM_DIRECTORY))
        {
            // pes packet

            err = m_pDataReader->GetUInt(&id);
            if (err != UMC_OK) return err;
            err = m_pDataReader->GetShort(&length); // length of package
            if (err != UMC_OK) return err;


             if (id == pid)
            {
                // video PES packet was found

                double          timeStamp;
                int             gotBytes = 0;
                int             size;
                int             iIFrameStart;

                PrevPacketPosition = CurrPacketPosition;
                CurrPacketPosition = PacketPosition;

                prevDTS = currDTS;
                prevPTS = currPTS;


                err = MPEG2PESPacketHeader(&timeStamp, &currDTS, gotBytes);
                GetVideoTime(&currPTS, timeStamp);

                vm_sizet pos = m_pDataReader->GetPosition();

                if (video_start==0)
                     video_start = pos + 6; // when we step back, start code on the edge should not be lost


                if (err != UMC_OK)
                    return err;
                size = ((length - gotBytes) < (int)(end - pos))? (length - gotBytes) : (int)(end - pos);
                switch (m_pESArray[0].m_videoStreamInfo.stream_type)
                {
                    case     MPEG1_VIDEO:
                    case     MPEG2_VIDEO:
                        err = FindIPicturePositionMPEG2(size, LastBytes, i, iIFrameStart);
                        break;
                    default:
                        return UMC::UMC_NOT_IMPLEMENTED;
                }

                if (iIFrameStart>0)
                {
                    // I frame was found in this PES packet
                    if (i-iIFrameStart<=size)
                    {
                        //I picture starts in this PES packet
                        posIFrame = pos + size - (i-iIFrameStart);
                        posPackege =  CurrPacketPosition;


                    }
                    else
                    {
                        //I picture starts in prev. PES packet
                        posIFrame = PrevPESEndPosition + size - (i-iIFrameStart);
                        posPackege = PrevPacketPosition;

                    }
                    if (i-iIFrameStart<=size-4)
                    {
                        //I picture start code starts in this PES packet
                        m_dCurrVideoPts=currPTS;
                        m_dCurrVideoDts=currDTS;
                     }
                    else
                    {
                       //I picture start code starts in prev PES packet
                        m_dCurrVideoPts=prevPTS;
                        m_dCurrVideoDts=prevDTS;
                    }

                }

                 start = pos + size;
                 PrevPESEndPosition = pos + size;


            } // if PID==id
             else
            {
                // this package should be missed
                start += (length);

                err = m_pDataReader->MovePosition(length);
                if (err != UMC_OK) return err;
            }// PID != id



            // prepare next packege
            err = m_pDataReader->CheckUInt(&id , 0);
            if(err != UMC_OK) return err;
            while(id == 0)
            {
                //skip all padding zeroes in packet start code
                err = m_pDataReader->GetUInt(&id);
                if(err != UMC_OK) return err;

                err = m_pDataReader->CheckUInt(&id , 0);
                if(err != UMC_OK) return err;
            }
            if((id & 0xffffff00) != 0x00000100 )
            {
                err = MoveToNextSyncWord();
                if(err != UMC_OK)
                    return err;
                bSyncWord = true;
                start = m_pDataReader->GetPosition();
                if (start>=end)
                    continue;

             }
        }// if pes packet
        else
        {
            err = MoveToNextSyncWord();
            if(err != UMC_OK)
                return err;
            bSyncWord = true;
            start = m_pDataReader->GetPosition();
            if (start>=end)
                continue;
        }

    }// end of while

    //curr_position = m_pDataReader->SetPosition((vm_sizet)curr_position);
    return UMC_OK;
}
Status MPEG2PSSplitter::ProcessOnePacket(int get_size)
{
    Status err;
    unsigned int longCode;

    longCode = 0;
    err = MPEG2PSPackHeader();
    if(err != UMC_OK) return err;

    err = m_pDataReader->CheckUInt(&longCode , 0);
    if(err != UMC_OK) return err;

    while ((longCode >= ID_PS_PROGRAM_STREAM_MAP) &&
        (longCode < ID_PROGRAM_STREAM_DIRECTORY))
    {
        err = MPEG2PESPack();
        if(err != UMC_OK) return err;

        err = m_pDataReader->CheckUInt(&longCode , 0);
        if(err != UMC_OK) return err;
        while(longCode == 0)
        {
            //skip all padding zeroes in packet start code
            err = m_pDataReader->GetUInt(&longCode);
            if(err != UMC_OK) return err;

            err = m_pDataReader->CheckUInt(&longCode , 0);
            if(err != UMC_OK) return err;
        }
        if((longCode & 0xffffff00) != 0x00000100 )
        {
            //resync to next packet if error happened

            int skipSize = 0;
            /*
            err = FindPacketStartCodeFrom(&longCode, skipSize);
            if(err != UMC_OK) return err;
            err = m_pDataReader->MovePosition( skipSize - 4);
            if(err != UMC_OK) return err;
            */
            MoveToNextSyncWord();
            m_uiSkippedDataSize += skipSize - 4;
            err = m_pDataReader->CheckUInt(&longCode , 0);
            if(err != UMC_OK) return err;
        }
    }

    return err;
}
Status MPEG2PSSplitter::ProcessPackets_back(unsigned int pid,
                                           vm_sizet p_packege_start,
                                           vm_sizet p_start,
                                           vm_sizet p_end)
{
    Status err;
    unsigned int id=0;
    unsigned short len=0;
    vm_sizet curr_position;
    double          timeStamp;
    int             gotBytes = 0;
    bool            isLoop=true;
    double          dts;

    ElementaryStream* pCurrES = NULL;
    Status retBuff;

    do
    {
        retBuff = m_pVideoBuffer->LockInputBuffer(&m_lockedVideoBuffer);
        if(retBuff == UMC_NOT_ENOUGH_BUFFER)