umc_mpeg2ps_spl.cpp

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

        vm_time_sleep(5);
    } while(!m_bStop && retBuff == UMC_NOT_ENOUGH_BUFFER);

    if(UMC_OK == retBuff && m_pVideoAuxData)
    do {
        retBuff = m_pVideoAuxData->LockInputBuffer(&m_startCodesData);
        if(retBuff == UMC_NOT_ENOUGH_BUFFER)
            vm_time_sleep(5);
    } while(!m_bStop && retBuff == UMC_NOT_ENOUGH_BUFFER);

    /* m_dCurrVideoPts and m_dCurrVideoDts
        have been saved in GetPrevGOP function*/

    m_lockedVideoBuffer.SetTime(m_dCurrVideoPts, m_dCurrVideoDts);

    ResetInfoFromPrevPES();

    m_dPrevVideoPts = -1;
    m_uiStartCodePos = 0;
    m_uiStartCodeOff = 0;

    err =m_pDataReader->SetPosition(p_packege_start);
    if(err != UMC_OK) return err;
    while (isLoop&&(m_bStop == 0) )
    {
        err = MPEG2PSPackHeader();
        if(err != UMC_OK) return err;

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

        while ((id >= ID_PS_PROGRAM_STREAM_MAP) &&
            (id < ID_PROGRAM_STREAM_DIRECTORY)&&
            isLoop&&!m_bStop)
        {
            //err = MPEG2PESPack();
            if(err != UMC_OK) return err;
            err = m_pDataReader->GetUInt(&id);
            if(err != UMC_OK) return err;

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

            curr_position = m_pDataReader->GetPosition();

            if ((id == pid) && (curr_position + len > p_start) )
            {
                m_InfoFromPrevPES.m_video_pts = m_dCurrVideoPts;
                m_InfoFromPrevPES.m_video_dts = m_dCurrVideoDts;
                err = MPEG2PESPacketHeader(&timeStamp, &dts, gotBytes);
                if(err != UMC_OK)
                    return err;
                GetVideoTime(&m_dCurrVideoPts, timeStamp);
                m_dCurrVideoDts = dts;

                if (p_start>curr_position)
                {
                        err =m_pDataReader->SetPosition(p_start);
                        if(err != UMC_OK) return err;
                        gotBytes = (int)(p_start - curr_position);
                }
                if (p_end<curr_position+len)
                {
                    gotBytes += curr_position+len - p_end;
                    isLoop = false;

                }

                int i = CheckIfNewES(false, id, -1);

                pCurrES = &m_pESArray[i];

                if (len- gotBytes>0)
                {
                    switch (m_pESArray[0].m_videoStreamInfo.stream_type)
                    {
                        case     MPEG1_VIDEO:
                        case     MPEG2_VIDEO:
                            err = FillBufferMPEG2Video(pCurrES, len- gotBytes, m_uiEndian);
                            break;
                        default:
                            return UMC::UMC_NOT_IMPLEMENTED;

                    }

                }
                switch (err)
                {
                    case UMC_OK:
                    case UMC_NOT_ENOUGH_DATA:
                        err = UMC_OK;
                        break;
                    default:
                        return err;
                }
             }
            else
            {
                // this packege is missed
                err = m_pDataReader->MovePosition(len);
                if(err != UMC_OK) return err;
            }

            if (!isLoop)
                break;
            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 )
            {
                //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(&id , 0);
                if(err != UMC_OK) return err;
            }
        }
    }
    return err;
}
Status MPEG2PSSplitter::ProcessPackets(int count)
{
    Status err = UMC_OK;
    int packCount = 0;

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

    if(err == UMC_OK)
    {
        do
        {
            //m_uiPosCurrPacket=m_pDataReader->GetPosition();
            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  MPEG2PSSplitter::ForwardInit()
{
    Status ret;
    int packCount = 0;

    ret = InitProcessing();

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

            packCount++;

        } while(!m_bStop        &&
                (ret == UMC_OK) &&
                !m_bSequenceFound);
    }

    if(m_bSequenceFound == true)
        return UMC_OK;

    return UMC_NOT_INITIALIZED;
}

Status  MPEG2PSSplitter::ForwardSearch()
{
    Status err = UMC_OK;
    int packCount = 0;
    bool   frame_found = false;

    int count = m_uiVideoFrameCount;

    //clear all previous data, because we seek from anothe position
    m_lockedVideoBuffer.SetDataSize(0);

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

            packCount++;

            if(m_uiVideoFrameCount - count > 1)
                frame_found = true;

        } while(!m_bStop        &&
                (err == UMC_OK) &&
                !frame_found);
    }

    if(frame_found == true)
        return UMC_OK;

    return err;
}

bool MPEG2PSSplitter::IsAcceptableVideoBuffer()
{
    if(!m_bForwardDirection)//reverse playback
    {
        static bool count = true;
        void* ptr = m_lockedVideoBuffer.GetBufferPointer();

        bool ret = (((*((unsigned int*)ptr)>>19)& 3) < m_uiVideoAcceptanceLevel) || ((*((unsigned int*)ptr)) == 435);

        //if((*((unsigned int*)ptr)) == 435)
        //    return true;
        //else
        //    count = !count;

        return (ret);//&&count);
    }

    return true;
}


Status MPEG2PSSplitter::MoveToNextSyncWord()
{
    //need to find first packet start code = 0x000001ba
    Status err;
    unsigned char byteCode;
    unsigned int  longCode;

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

    if((err == UMC_OK) && (longCode != ID_PS_PACK_START_CODE))
    {
        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_PACK_START_CODE));
    }

    return err;
}


Status MPEG2PSSplitter::MPEG2PSPackHeader()
{
    unsigned int  longCode;
    unsigned short shortCode;
    unsigned int  muxRate;
    Status err;

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

    err = m_pDataReader->GetUInt(&longCode );
    if(err != UMC_OK) return err;


    err = m_pDataReader->GetUInt(&longCode );
    if(err != UMC_OK) return err;

    if(longCode & 0x40000000) // MPEG2 Programm stream
    {
//        vm_sizet size = 0;
        //'01' 2 bits
        //system_clock_reference_base [32..30] 3 bits
        //marker_bit 1 bit
        //system_clock_reference_base [29..15] 15 bits
        //marker_bit 1 bit
        //system_clock_reference_base [14..0] 15 bits
        //marker_bit 1 bit
        //system_clock_reference_extension 9 bits
        //marker_bit 1 bit

        //4 bytes were token befor, need 2 bytes more
        err = m_pDataReader->GetShort(&shortCode );
        if(err != UMC_OK) return err;

        m_systemStreamInfo.stream_type  = MPEG2_PROGRAMM_STREAM;
        //program_mux_rate 22 bits
        //marker_bit 1 bit
        //marker_bit 1 bit
        //reserved   5 bits
        //pack_stuffing_length 3 bits

        err = m_pDataReader->GetUInt(&longCode);
        if(err != UMC_OK) return err;
        muxRate = longCode >> 10;

        m_systemStreamInfo.muxrate  = muxRate*50;//bytes/sec

        //skip stuffing bytes:
        err = m_pDataReader->MovePosition(longCode & 7);
        if(err != UMC_OK) return err;
    }
    else
    {
        if(longCode & 0x20000000) // MPEG1 Prorgamm stream
        {
//            vm_sizet size = 0;
            //'0010'                                    4 bits
            //system_clock_reference [32..30]            3 bits
            //marker_bit                                1 bits
            //system_clock_reference [29..15]            15bits
            //marker_bit                                1 bits
            //system_clock_reference [14..0]            15bits
            //marker_bit                                1 bit
            //marker_bit                                1 bit
            //mux_rate                                    22bits
            //marker_bit                                1 bit

            //4 bytes were token before, need 4 bytes more
            m_systemStreamInfo.stream_type  = MPEG1_PROGRAMM_STREAM;

            err = m_pDataReader->GetUInt(&longCode);
            if(err != UMC_OK) return err;
            muxRate = (longCode >> 1) & 0x003fffff;

            m_systemStreamInfo.muxrate  = muxRate*50;//bytes/sec

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

    if (longCode == ID_PS_SYSTEM_HEADER_START_CODE)
    {
         //get system header start code
        err = m_pDataReader->GetUInt(&longCode );
        if(err != UMC_OK) return err;

        //err = MPEG2PSSystemHeader();
        //if(err != UMC_OK) return err;

        //Alternate skip system header
        err = m_pDataReader->GetShort(&shortCode);
        if(err != UMC_OK) return err;

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


    }

    return err;
}