umc_mpeg2_spl_video.cpp

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

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

        } while(!m_bStop        &&
                (err == UMC_OK) &&
                ((longCode & 0xffffff00) != 0x00000100));
    }

    return err;
}


Status MPEG4VideoSplitter::GetPosition(double& /*pos*/)
{
    return UMC_OK;
}


Status MPEG4VideoSplitter::GetInfo(SplitterInfo* pSplInfo)
{
    MPEG2AVSplitter::GetInfo(pSplInfo);

    return UMC_OK;
}

/////////////////////////////////////////////////////////////////////////////////
//////////////////////////MPEG4-10 pure video///////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
Status H264VideoSplitter::InitProcessing()
{
    Status         ret;


    m_inESCount         = 1;
    m_bSequenceFound    = false;
    m_bFirstValidVPTS   = false;


    ResetInfoFromPrevPES();

    m_pESArray[0].m_videoStreamInfo.stream_type = H264_VIDEO;
    m_pESArray[0].m_audioStreamInfo.stream_type = UNDEF_AUDIO;
    m_pESArray[0].m_videoStreamInfo.streamPID = 0;
    //reset chosen PIDS since only one stream availble in pure
    m_iChoosedVideo = 0;
    m_iChoosedAudio[0] = -1;
    m_iChoosedAudio[1] = -1;

    CheckEndian(true);

    ret = InitVideoHelperBuffer(PORTION_TO_READ);

    return ret;

}

Status H264VideoSplitter::CloseProcessing()
{
    if(m_lockedVideoBuffer.GetDataSize() > 8 && !m_bStop)
    {
        if(m_uiEndian == 2)
        {
            //if start code was find make buffer size 16 bytes aligned
            //and swap data if needed
            int size = m_lockedVideoBuffer.GetDataSize();

            Swap4BytesH264((unsigned char*)m_lockedVideoBuffer.GetBufferPointer(),size);
            size = ((size+3)&~3);

            m_lockedVideoBuffer.SetDataSize(size);
        }
        m_pVideoBuffer->UnLockInputBuffer(&m_lockedVideoBuffer);
        m_uiVideoFrameCount++;
        m_lockedVideoBuffer.SetTime(m_dCurrVideoPts, m_dCurrVideoDts);

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

    }
    m_eInitVideo.Set();

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

    }

    return UMC_OK;
}

Status H264VideoSplitter::ProcessOnePacket(int get_size)
{
   return  FillBufferH264Video(&m_pESArray[0], get_size, m_uiEndian);

}

Status H264VideoSplitter::ProcessPackets(int count)
{
    int curr_count = 0;
    Status         ret;
    vm_sizet       full_size =  m_pDataReader->GetSize();
    //stream will be read with portions size = PORTION_TO_READ
    unsigned int   get_size  =  full_size >
                                PORTION_TO_READ?
                                PORTION_TO_READ:
                                full_size;

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

    if(UMC_OK == ret)
    {
        while(!m_bStop        &&
              (full_size > 0) &&
              ((count == -1) || (curr_count < count)))
        {
            ret = ProcessOnePacket(get_size);
            if((UMC_OK != ret) && (UMC_NOT_ENOUGH_DATA != ret)) break;
            full_size -= get_size;
            get_size   =  full_size > PORTION_TO_READ?PORTION_TO_READ:full_size;
            curr_count++;
        }
    }

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


    return ret;
}


Status  H264VideoSplitter::MoveToNextSyncWord()
{
    return UMC_OK;
}


Status H264VideoSplitter::GetPosition(double& /*pos*/)
{

    return UMC_OK;
}


Status H264VideoSplitter::GetInfo(SplitterInfo* pSplInfo)
{
    MPEG2AVSplitter::GetInfo(pSplInfo);

    return UMC_OK;
}



/////////////////////////////////////////////////////////////////////////////////
//////////////////////////H.261 pure video///////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
Status H261VideoSplitter::InitProcessing()
{
    Status         ret;

    m_inESCount         = 1;
    m_bSequenceFound    = false;
    m_bFirstValidVPTS   = false;

    ResetInfoFromPrevPES();




    m_pESArray[0].m_videoStreamInfo.stream_type = H261_VIDEO;
    m_pESArray[0].m_audioStreamInfo.stream_type = UNDEF_AUDIO;
    m_pESArray[0].m_videoStreamInfo.streamPID = 0;
    //reset chosen PIDS since only one stream availble in pure
    m_iChoosedVideo = 0;
    m_iChoosedAudio[0] = -1;
    m_iChoosedAudio[1] = -1;

    CheckEndian(false);

    m_uiEndian = 0;

    ret = InitVideoHelperBuffer(PORTION_TO_READ);

    return ret;

}

Status H261VideoSplitter::CloseProcessing()
{
    if(m_lockedVideoBuffer.GetBufferSize() > 3 && !m_bStop)
    {
        m_pVideoBuffer->UnLockInputBuffer(&m_lockedVideoBuffer);
        m_uiVideoFrameCount++;
        m_lockedVideoBuffer.SetTime(m_dCurrVideoPts, m_dCurrVideoDts);

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

    }
    m_eInitVideo.Set();

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

    }

    return UMC_OK;
}

Status H261VideoSplitter::ProcessOnePacket(int get_size)
{
   return  FillBufferH261Video(&m_pESArray[0], get_size, m_uiEndian);

}

Status H261VideoSplitter::ProcessPackets(int count)
{
    int curr_count =0;
    Status         ret;
    vm_sizet       full_size =  m_pDataReader->GetSize();
    //stream will be read with portions size = PORTION_TO_READ
    unsigned int   get_size  =  full_size >
                                PORTION_TO_READ?
                                PORTION_TO_READ:
                                full_size;

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

    if(UMC_OK == ret)
    {
        while(!m_bStop        &&
              (full_size > 0) &&
              ((count == -1) || (curr_count < count)))
        {
            ret = ProcessOnePacket(get_size);
            if((UMC_OK != ret) && (UMC_NOT_ENOUGH_DATA != ret)) break;
            full_size -= get_size;
            get_size   =  full_size > PORTION_TO_READ?PORTION_TO_READ:full_size;
            curr_count++;
        }
    }

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

    return ret;
}


bool H261VideoSplitter::IfFrameRequared()
{
    m_eInitVideo.Wait();
    return (m_lFlagsReq & FLAG_VSPL_VIDEO_FRAME_REQ);
}

Status  H261VideoSplitter::MoveToNextSyncWord()
{
    return UMC_OK;
}


Status H261VideoSplitter::GetPosition(double& /*pos*/)
{

    return UMC_OK;
}


Status H261VideoSplitter::GetInfo(SplitterInfo* pSplInfo)
{
    MPEG2AVSplitter::GetInfo(pSplInfo);

    return UMC_OK;
}


/////////////////////////////////////////////////////////////////////////////////
//////////////////////////H.263 pure video///////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
Status H263VideoSplitter::InitProcessing()
{
    Status         ret;

    m_inESCount         = 1;
    m_bSequenceFound    = false;
    m_bFirstValidVPTS   = false;

    ResetInfoFromPrevPES();


    m_pESArray[0].m_videoStreamInfo.stream_type = H263_VIDEO;
    m_pESArray[0].m_audioStreamInfo.stream_type = UNDEF_AUDIO;
    m_pESArray[0].m_videoStreamInfo.streamPID = 0;
    //reset chosen PIDS since only one stream availble in pure
    m_iChoosedVideo = 0;
    m_iChoosedAudio[0] = -1;
    m_iChoosedAudio[1] = -1;

    CheckEndian(false);

    m_uiEndian = 0;

    ret = InitVideoHelperBuffer(PORTION_TO_READ);

    return ret;

}

Status H263VideoSplitter::CloseProcessing()
{
    if(m_lockedVideoBuffer.GetBufferSize() > 3 && !m_bStop)
    {
        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 H263VideoSplitter::ProcessOnePacket(int get_size)
{
   return  FillBufferH263Video(&m_pESArray[0], get_size, m_uiEndian);
}

Status H263VideoSplitter::ProcessPackets(int count)
{
    int curr_count = 0;
    Status         ret;
    vm_sizet       full_size =  m_pDataReader->GetSize();
    //stream will be read with portions size = PORTION_TO_READ
    unsigned int   get_size  =  full_size >
                                PORTION_TO_READ?
                                PORTION_TO_READ:
                                full_size;

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

    if(UMC_OK == ret)
    {
        while(!m_bStop        &&
              (full_size > 0) &&
              ((count == -1) || (curr_count < count)))
        {
            ret = ProcessOnePacket(get_size);
            if((UMC_OK != ret) && (UMC_NOT_ENOUGH_DATA != ret)) break;
            full_size -= get_size;
            get_size   =  full_size > PORTION_TO_READ?PORTION_TO_READ:full_size;
            curr_count++;
        }
    }

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

    return ret;
}


bool H263VideoSplitter::IfFrameRequared()
{
    m_eInitVideo.Wait();
    return (m_lFlagsReq & FLAG_VSPL_VIDEO_FRAME_REQ);
}

Status  H263VideoSplitter::MoveToNextSyncWord()
{
    return UMC_OK;
}


Status H263VideoSplitter::GetPosition(double& /*pos*/)
{

    return UMC_OK;
}


Status H263VideoSplitter::GetInfo(SplitterInfo* pSplInfo)
{
    MPEG2AVSplitter::GetInfo(pSplInfo);

    return UMC_OK;
}


//End of file