umc_mpeg2pes_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_mpeg2pes_spl.h"
#include <ipps.h>
#pragma warning(disable: 4244)

using namespace UMC;
Status MPEG2PESSplitter::InitProcessing()
{
    Status err = UMC_OK;


    ResetInfoFromPrevPES();

    CheckEndian(true);

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

    return err;

}

Status MPEG2PESSplitter::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 MPEG2PESSplitter::ProcessOnePacket(int get_size)
{
    Status err;
    unsigned int longCode;

    longCode = 0;

    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) break;

        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
            MoveToNextSyncWord();
        }
    }

    return err;
}

Status MPEG2PESSplitter::ProcessPackets(int count)
{
    Status err;
    int packCount = 0;

    if(count == -1)
        err = InitProcessing();

    if(err == UMC_OK)
    {
        do
        {
            err = ProcessOnePacket();

            packCount++;

        } while(!m_bStop        &&
                (err == UMC_OK) &&
                ((count == -1) || (packCount < count)));
    }

    if((count == -1) || (err == UMC_END_OF_STREAM))
        CloseProcessing();

    return err;
}


Status MPEG2PESSplitter::MoveToNextSyncWord()
{

    //need to find first packet start code
    //video PES = 0x000001e0 or audio PES = 0x000001c0
    Status err;
    unsigned char byteCode;
    unsigned int  longCode;

    err = m_pDataReader->CheckUInt(&longCode, 0);

    if((err == UMC_OK) &&
      (longCode < ID_PS_PROGRAM_STREAM_MAP) &&
      (longCode > ID_PROGRAM_STREAM_DIRECTORY))
    {
        do
        {
            err = m_pDataReader->GetByte(&byteCode);
            if(err != UMC_OK) break;

            err = m_pDataReader->CheckUInt(&longCode, 0);

        } while(!m_bStop        &&
                (err == UMC_OK) &&
                (longCode < ID_PS_PROGRAM_STREAM_MAP) &&
                (longCode > ID_PROGRAM_STREAM_DIRECTORY));
    }

    return err;
}


Status MPEG2PESSplitter::MPEG2PESPack(int size, int index, int PID)
{
    Status          err = UMC_OK;
    unsigned char   byteCode;
    unsigned int    longCode;
    unsigned short  shortCode = 0;
    double          timeStamp;
    double          dts;
    int             PES_packet_length = 0;
    int             gotBytes = 0;
    int             streamID;
    int             useful_data = 0;
    ElementaryStream* pCurrES = NULL;

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

    streamID = longCode;
    {
        if( longCode    != ID_PS_PROGRAM_STREAM_MAP
            && longCode != ID_PADDING_STREAM
            && longCode != ID_PRIVATE_STREAM_2
            && longCode != ID_ECM_STREAM
            && longCode != ID_EMM_STREAM
            && longCode != ID_PROGRAM_STREAM_DIRECTORY
            && longCode != ID_DSMCC_STREAM
            && longCode != ID_ITU_TREC_H222_TYPE_E_STREAM)
        {

            //get PES length
            err = m_pDataReader->GetShort(&shortCode);
            if(err != UMC_OK) return err;
            if(size == 0)
            {
                //program stream. pes packet size is valid
                PES_packet_length = shortCode;
            }
            else
            {
                PES_packet_length = size - 6;
            }

            useful_data = 0;

            //PES_packet_length allowed only TS packets
            VM_ASSERT((PES_packet_length != 0) ||
                   (PES_packet_length == 0 &&
                   (m_systemStreamInfo.stream_type &
                                            MPEGx_TRANSPORT_STREAM)));

            //process RES packet
             err = MPEG2PESPacketHeader(&timeStamp, &dts, gotBytes);
            if(err != UMC_OK) return err;

            //get data here
            if((!m_bIgnoreVideo) &&
               (streamID  >= ID_ISO_IEC_MPEG12_VIDEO_STREAM_0) &&
               (streamID  <= ID_ISO_IEC_MPEG12_VIDEO_STREAM_16))
            {
               if(PID != -1)
                    streamID = PID;

               int i = CheckIfNewES(false, streamID, index);

               pCurrES = &m_pESArray[i];

                pCurrES->m_videoStreamInfo.streamPID = streamID;
               if(m_iChoosedVideo != streamID)
                {
                    //skip packet if not chosed ES
                    err = m_pDataReader->MovePosition(PES_packet_length- gotBytes);
                    if(err != UMC_OK) return err;
                    m_uiSkippedDataSize += PES_packet_length- gotBytes;
                }
                else
                {
                    m_InfoFromPrevPES.m_video_pts =m_dCurrVideoPts;
                    m_InfoFromPrevPES.m_video_dts =m_dCurrVideoDts;
                    GetVideoTime(&m_dCurrVideoPts, timeStamp);
                    m_dCurrVideoDts = dts;

                    vm_debug_trace(0, VM_STRING("PTS found: %lf\n"), timeStamp);

                    if(pCurrES->m_videoStreamInfo.stream_type == MPEG4_VIDEO)
                        err = FillBufferMPEG4Video(pCurrES, PES_packet_length- gotBytes, 0);
                    else if(pCurrES->m_videoStreamInfo.stream_type == H264_VIDEO)
                        err = FillBufferH264Video(pCurrES, PES_packet_length- gotBytes, m_uiEndian);
                    else//(pCurrES->m_videoStreamInfo.stream_type == MPEG2_VIDEO)
                        err = FillBufferMPEG2Video(pCurrES, PES_packet_length- gotBytes, m_uiEndian);
                    if(err == UMC_NOT_ENOUGH_DATA)
                        err = UMC_OK;
                    if(err != UMC_OK)
                        return err;
                }
            }
            else if((!m_bIgnoreVideo) &&
               (streamID  >= 0x000001fa))
            {
               if(PID != -1)
                    streamID = PID;

               int i = CheckIfNewES(false, streamID, index);

               pCurrES = &m_pESArray[i];

               if(m_iChoosedVideo != streamID)
                {
                    //skip packet if not chosed ES
                    err = m_pDataReader->MovePosition(PES_packet_length- gotBytes);
                    if(err != UMC_OK) return err;
                    m_uiSkippedDataSize += PES_packet_length- gotBytes;
                    pCurrES->m_videoStreamInfo.streamPID = streamID;
                }
                else
                {
                    GetVideoTime(&m_dCurrVideoPts, timeStamp);
                    m_dCurrVideoDts = dts;

                    err = FillBufferMPEG4Video(pCurrES, PES_packet_length- gotBytes, 0);
                    //err = FillVideoBuffer(PES_packet_length- gotBytes, 2);
                    if(err == UMC_NOT_ENOUGH_DATA)
                        err = UMC_OK;
                    if(err != UMC_OK)
                        return err;
                }
            }
            else if((!m_bIgnoreAudio) &&
                    (streamID >= ID_ISO_IEC_MPEG12_AUDIO_STREAM_0) &&
                    (streamID  <= ID_ISO_IEC_MPEG12_AUDIO_STREAM_32))
            {
               if(PID != -1)
                    streamID = PID;
                int i = CheckIfNewES(true, streamID, index);

                pCurrES = &m_pESArray[i];
                pCurrES->m_audioStreamInfo.streamPID   = streamID;
                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;
                    m_uiSkippedDataSize += PES_packet_length- gotBytes;
                    pCurrES->m_audioStreamInfo.stream_type = MPEG2_AUDIO;
                }
                else
                {
                    m_uiCurrInputBuffNum = 0;
                    if((m_iChoosedAudio[1] == streamID))
                        m_uiCurrInputBuffNum = 1;
                    GetAudioTime(&m_dCurrAudioPts, timeStamp);

                    //fill buffer with MPEG audio data
                    //m_bFirstValidAPTS = true;
                    if((err = FindMPEGASync(pCurrES, PES_packet_length- gotBytes)) != UMC_OK)
                        return err;
                    pCurrES->m_uiNumReadPackets++;
                    pCurrES->m_uiSizeReadPackets += PES_packet_length- gotBytes;

                }
            }
            else if((!m_bIgnoreAudio) &&
                    (streamID == ID_PRIVATE_STREAM_1))
            {
                if(PID != -1)
                    streamID = PID;
                //we can check if DVD AC-3 or LPCM present in private stream 1
                GetAudioTime(&m_dCurrAudioPts, timeStamp);

                byteCode = (unsigned char)streamID;

                int i = 0;
                if(m_systemStreamInfo.stream_type == MPEG2_PROGRAMM_STREAM)
                {
                    err = m_pDataReader->GetByte(&byteCode);
                    if(err != UMC_OK) return err;

                    gotBytes++;
                    streamID = byteCode;

                    i = CheckIfNewES(true, streamID, index);
                }
                else
                {
                    i = CheckIfNewES(true, streamID, index);
                }



                pCurrES = &m_pESArray[i];