codec_pipeline.cpp

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

        case MPEG1_AUDIO:
        case MPEG2_AUDIO:
            rpAudioDecoder = DynamicCast<BaseCodec>(new MP3DecoderInt);
            if (NULL == rpAudioDecoder)
            { umcRes = UMC_ALLOC; }
            break;
#endif // defined(UMC_ENABLE_MP3_AUDIO_DECODER)

#if defined(UMC_ENABLE_AAC_AUDIO_DECODER)
        case AAC_AUDIO:
        case AAC_MPEG4_STREAM:
            rpAudioDecoder = DynamicCast<BaseCodec>(new AACDecoder);
            if (NULL == rpAudioDecoder)
            { umcRes = UMC_ALLOC; }
            break;
#elif defined(UMC_ENABLE_AAC_INT_AUDIO_DECODER)
        case AAC_AUDIO:
        case AAC_MPEG4_STREAM:
            rpAudioDecoder = DynamicCast<BaseCodec>(new AACDecoderInt);
            if (NULL == rpAudioDecoder)
            { umcRes = UMC_ALLOC; }
            break;
#endif // defined(UMC_ENABLE_AAC_INT_AUDIO_DECODER)

#if defined(UMC_ENABLE_AC3_AUDIO_DECODER)
        case AC3_AUDIO:
                rpAudioDecoder = DynamicCast<BaseCodec>(new AC3Decoder);
                if (NULL == rpAudioDecoder)
                { umcRes = UMC_ALLOC; }
                break;
#endif // defined(UMC_ENABLE_AC3_AUDIO_DECODER)

        case UNDEF_AUDIO:
        case TWINVQ_AUDIO:
        default:
            vm_message(VM_STRING("Unsupported audio format!\n"));
            rpAudioDecoder = NULL;
            umcRes = UMC_BAD_FORMAT;
            break;
        }
    }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4,VM_STRING("BaseCodec::SelectAudioDecoder failed!\n"));   }

    return umcRes;
}

Status
CodecPipeline::SelectDTAudioDecoder(sAudioStreamInfo& rAudioInfo,
                                    BaseCodec*& rpAudioDecoder,
                                    DualThreadedCodec*& rpDSAudioCodec,
                                    MediaBuffer*& rpMediaBuffer,
                                    MediaData* FirstFrameA)
{
    Status umcRes = UMC_OK;

    if (UMC_OK == umcRes)
    {   umcRes = SelectAudioDecoder(rAudioInfo, rpAudioDecoder);    }

    //  Init from splitter
    if (UMC_OK == umcRes &&
        UNDEF_AUDIO != rAudioInfo.stream_type &&
        NULL != rpAudioDecoder)
    {
        AudioCodecParams audioParams;
        MediaBufferParams CyclicBufferPrm;
        DualThreadCodecParams CodecPrm;

        if (NULL != rpDSAudioCodec) {   delete rpDSAudioCodec;  }
        if (NULL != rpMediaBuffer) {   delete rpMediaBuffer;    }

        rpDSAudioCodec = new DualThreadedCodec;
        if (NULL == rpAudioDecoder) {  umcRes = UMC_ALLOC; }

        if (UMC_OK == umcRes) {
            if (rAudioInfo.stream_type != UMC::AAC_MPEG4_STREAM)
                rpMediaBuffer = DynamicCast<MediaBuffer>(new LinearBuffer);
            else {
                // due to nature of AAC bitstream wrapped into MP4 files
                // sample buffer is required
                rpMediaBuffer = DynamicCast<MediaBuffer>(new SampleBuffer);
            }

            if (NULL == rpMediaBuffer) {  umcRes = UMC_ALLOC; }
        }

        if (UMC_OK == umcRes) {
            audioParams.m_info_in              = rAudioInfo;
            audioParams.m_info_out             = rAudioInfo;
            audioParams.m_pData                = FirstFrameA;

//            audioParams.m_info_in.channels = audioParams.m_info.channels;
//            audioParams.m_info_out.channels = audioParams.m_info.channels;
            CyclicBufferPrm.m_numberOfFrames        = 100;
            if(FirstFrameA)
            {
                int size = FirstFrameA->GetDataSize();
                CyclicBufferPrm.m_prefInputBufferSize   =  size < 188? 188: size;
            }
            else
                CyclicBufferPrm.m_prefInputBufferSize   = 2304;

            CodecPrm.m_pCodec             = rpAudioDecoder;
            CodecPrm.m_pMediaBuffer       = rpMediaBuffer;
            CodecPrm.m_pCodecInitParams   = &audioParams;
            CodecPrm.m_pMediaBufferParams = &CyclicBufferPrm;



            umcRes = rpDSAudioCodec->InitCodec(&CodecPrm);

            //  It's not a loop but some approach to error handling
            while (1)
            {
                MediaData data;

                umcRes = rpMediaBuffer->LockInputBuffer(&data);

                if (UMC_OK != umcRes)
                {   break;  }

                if (data.GetBufferSize() < FirstFrameA->GetDataSize())
                {
                    umcRes = UMC_FAILED_TO_ALLOCATE_BUFFER;
                    break;
                }

                // copy
                memcpy(data.GetDataPointer(),FirstFrameA->GetDataPointer(),FirstFrameA->GetDataSize());
                data.SetDataSize(FirstFrameA->GetDataSize());
                data.SetTime(FirstFrameA->GetTime());

                umcRes = rpMediaBuffer->UnLockInputBuffer(&data);

                break;
            }
        }

        if (UMC_OK != umcRes) {
            if (NULL != rpAudioDecoder) {
                delete rpAudioDecoder;
                rpAudioDecoder = NULL;
            }
            if (NULL != rpDSAudioCodec) {
                delete rpDSAudioCodec;
                rpDSAudioCodec = NULL;
            }

            if (NULL != rpMediaBuffer) {
                delete rpMediaBuffer;
                rpMediaBuffer = NULL;
            }
        }
    }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4,__VM_STRING("DualThreadedCodec::SelectDualThreadedCodec failed!\n"));   }

    return umcRes;
}

Status CodecPipeline::SelectSplitter(SourceInfo *lpSourceInfo,
                                     vm_var32 uiSplitterFlags,
                                     Splitter*& rpSplitter,
                                     MediaDataEx& rFirstFrame,
                                     vm_var32 uiSelectedVideoPID,
                                     vm_var32 uiSelectedAudioPID)
{
    Status umcRes = UMC_OK;
    SourceInfoCam *lpCamInfo = NULL;
    SourceInfoNet *lpNetInfo = NULL;
    SourceInfoFile *lpFileInfo = NULL;
    SelfDestructionObject<SplitterParams> lpSplParams;

    // delete existing splitter
    if (rpSplitter)
        delete rpSplitter;
    rpSplitter = NULL;

    // try to create cam splitter
    if (lpCamInfo = DynamicCast<SourceInfoCam> (lpSourceInfo))
    {

#if defined(WIN32) && !defined(_WIN32_WCE) && defined (UMC_ENABLE_TRANSCODING)
        lpSplParams = new SplitterParams();
        if (NULL == lpSplParams)
            umcRes = UMC::UMC_OPERATION_FAILED;

        rpSplitter = new CaptureEx();
#endif // defined(WIN32) && !defined(_WIN32_WCE)

        if (NULL == rpSplitter)
            umcRes = UMC::UMC_OPERATION_FAILED;
    }
    // try to create net splitter
    else if (lpNetInfo = DynamicCast<SourceInfoNet> (lpSourceInfo))
    {
        umcRes = UMC::UMC_NOT_IMPLEMENTED;
    }
    // try to create file splitter
    else if (lpFileInfo = DynamicCast<SourceInfoFile> (lpSourceInfo))
    {
        return SelectSplitter(lpFileInfo->m_lpDataReader,
                              uiSplitterFlags,
                              rpSplitter,
                              rFirstFrame,
                              uiSelectedVideoPID, uiSelectedAudioPID);
    }
    // try to create unknown splitter
    else
        umcRes = UMC::UMC_UNSUPPORTED;

    // initialize created splitter
    if (UMC_OK == umcRes)
    {
        lpSplParams->m_lFlags = uiSplitterFlags;

        umcRes = rpSplitter->Init(*lpSplParams);
        if (UMC_OK != umcRes)
            vm_message(__VM_STRING("Failed to initialize splitter "));
    }

    return umcRes;

} //Status CodecPipeline::SelectSplitter(SourceInfo *lpSourceInfo,

Status
CodecPipeline::SelectSplitter(DataReader* pDataReader,
                              vm_var32 uiSplitterFlags,
                              Splitter*& rpSplitter,
                              MediaDataEx& rFirstFrame,
                              vm_var32 uiSelectedVideoPID,
                              vm_var32 uiSelectedAudioPID)
{
    Status umcRes = UMC_OK;

    delete rpSplitter;

    SelfDestructionObject<SplitterParams> lpSplParams;

    if (UMC_OK == umcRes) {
        switch(Splitter::GetStreamType(pDataReader))
        {
#if defined(UMC_ENABLE_MPEG2_SPLITTER)
        case MPEGx_SYSTEM_STREAM:
        {
            MpegSplitterParams *lpParams;
            rpSplitter = new MPEG2Splitter();
            lpSplParams = lpParams = new MpegSplitterParams();
            if (0 == lpSplParams)
            {   umcRes = UMC_ALLOC; }
            else
            {   lpParams->m_mediaData = &rFirstFrame; }
        };
        break;
#endif // UMC_ENABLE_MPEG2_SPLITTER

#if defined(UMC_ENABLE_MP4_SPLITTER)
        case MP4_ATOM_STREAM:
        {
            MpegSplitterParams *lpParams;
            rpSplitter = new MP4Splitter();
            lpSplParams = lpParams = new MpegSplitterParams();
            if (0 == lpSplParams)
            {   umcRes = UMC_ALLOC; }
            else
            {   lpParams->m_mediaData = &rFirstFrame; }
        };
        break;
#endif // defined(UMC_ENABLE_ATOM_SPLITTER)

#if defined(UMC_ENABLE_AVI_SPLITTER)
        case AVI_STREAM:
            rpSplitter  = (Splitter*)new AVISplitter();
            lpSplParams = new SplitterParams();
            if (0 == lpSplParams || 0 == rpSplitter)
            {   umcRes = UMC_ALLOC; }
            break;
#endif // defined(UMC_ENABLE_AVI_SPLITTER)

        default:
            umcRes = UMC_UNSUPPORTED;
        }
    }

    if (UMC_OK == umcRes && NULL == rpSplitter)
    {   umcRes = UMC_ALLOC; }

    if (UMC_OK == umcRes) {
        lpSplParams->m_lFlags       = uiSplitterFlags;
        lpSplParams->m_pDataReader  = pDataReader;
        lpSplParams->m_uiSelectedAudioPID = uiSelectedAudioPID;
        lpSplParams->m_uiSelectedVideoPID = uiSelectedVideoPID;

        umcRes = rpSplitter->Init(*lpSplParams);
        if (UMC_OK != umcRes) {
            vm_message(VM_STRING("Failed to initialize splitter\n"));
        }
    }

    return umcRes;
}


Status
CodecPipeline::SelectVideoDecoder(sVideoStreamInfo& rVideoInfo,
                                  MediaData&        rFirstFrame,
                                  UMC::ColorFormat  DstColorFormat,
                                  unsigned int      ulReduceCoeff,
                                  unsigned int      lInterpolation,
                                  unsigned int      lPostProc,
                                  unsigned int      numThreads,
                                  unsigned int      ulVideoDecoderFlags,
                                  BaseColorSpaceConverter& rColorConverter,
                                  VideoDecoder*&    rpVideoDecoder,
                                  sClipInfo *       lpDestSize)
{
    Status umcRes = UMC_OK;

    delete rpVideoDecoder;

    VideoDecoderParams VDecParams;
    ColorConversionInfo ColorInit;

    if (UMC_OK == umcRes) {
        switch(rVideoInfo.stream_type)
        {
#if defined(UMC_ENABLE_MPEG2_VIDEO_DECODER)
        case MPEG1_VIDEO:
        case MPEG2_VIDEO:
            rpVideoDecoder  =(VideoDecoder*)    new MPEG2VideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            break;
#endif // defined(UMC_ENABLE_MPEG2_VIDEO_DECODER)

#if defined(UMC_ENABLE_DV_VIDEO_DECODER)
#if defined(UMC_ENABLE_DV50_VIDEO_DECODER)
        case DIGITAL_VIDEO_50:
            rpVideoDecoder  = (VideoDecoder*)   new DV50VideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            break;
#endif // defined(UMC_ENABLE_DV50_VIDEO_DECODER)

        case DIGITAL_VIDEO_SD:
            rpVideoDecoder  = (VideoDecoder*)   new DVVideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            break;
#endif // defined(UMC_ENABLE_DV_VIDEO_DECODER)

#if defined(UMC_ENABLE_MPEG4_VIDEO_DECODER)
        case MPEG4_VIDEO:
            rpVideoDecoder  = (VideoDecoder*)   new MPEG4VideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            break;
#endif // defined(UMC_ENABLE_MPEG4_VIDEO_DECODER)

#if defined(UMC_ENABLE_H263_VIDEO_DECODER)
        case H263_VIDEO:
            rpVideoDecoder  = (VideoDecoder*)   new H263VideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            break;
#endif // defined(UMC_ENABLE_H263_VIDEO_DECODER)

#if defined(UMC_ENABLE_H261_VIDEO_DECODER)
        case H261_VIDEO:
            rpVideoDecoder  = (VideoDecoder*)   new H261VideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            break;
#endif // defined(UMC_ENABLE_H261_VIDEO_DECODER)

#if defined(UMC_ENABLE_H264_VIDEO_DECODER)
        case H264_VIDEO:
            rpVideoDecoder  = (VideoDecoder*)   new H264VideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            break;
#endif // defined(UMC_ENABLE_H264_VIDEO_DECODER)

#if defined(UMC_ENABLE_MJPEG_VIDEO_DECODER)
        case MJPEG_VIDEO:
            rpVideoDecoder  = (VideoDecoder*)   new MJPEGVideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            break;
#endif // defined(UMC_ENABLE_MJPEG_VIDEO_DECODER)

#if defined (UMC_ENABLE_TRANSCODING)
        case UNCOMPRESSED_VIDEO:
            rpVideoDecoder  = (VideoDecoder*)   new UncompressedVideoDecoder();
            VDecParams.m_pData  = &rFirstFrame;
            ColorInit.FormatSource = rVideoInfo.color_format;
            break;
#endif
        default:
            vm_message(__VM_STRING("Unknown video stream type\n"));
            umcRes = UMC_UNSUPPORTED;
        }
    }

    if (UMC_OK == umcRes && NULL == rpVideoDecoder)
    {   umcRes = UMC_ALLOC; }

    if (0 == rFirstFrame.GetDataSize())
    {    VDecParams.m_pData  = NULL;    }

    if (UMC_OK == umcRes) {

        ColorInit.FormatDest        = DstColorFormat;
        ColorInit.SizeSource.width  = rVideoInfo.clip_info.width;
        ColorInit.SizeSource.height = rVideoInfo.clip_info.height;
        vm_var32 uiFactor = 1;

        switch(ulReduceCoeff)
        {
        case FLAG_CCNV_NONE:
        case FLAG_CCNV_CONVERT:
            uiFactor = 1;
            break;