codec_pipeline.cpp

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

        case FLAG_CCNV_RESIZE_2S:
            uiFactor = 2;
            break;
        case FLAG_CCNV_RESIZE_4S:
            uiFactor = 4;
            break;
        case FLAG_CCNV_RESIZE_8S:
            uiFactor = 8;
            break;

        }
        if (NULL == lpDestSize)
        {
            ColorInit.SizeDest.width    = rVideoInfo.clip_info.width / uiFactor;
            ColorInit.SizeDest.height   = rVideoInfo.clip_info.height / uiFactor;
        }
        else
            ColorInit.SizeDest = *lpDestSize;
        ColorInit.lFlags                    = ulReduceCoeff;
        ColorInit.lDeinterlace              = lPostProc & FLAG_CCNV_DEINTERLACE;
        ColorInit.lInterpolation            = lInterpolation;

        VDecParams.info                     = rVideoInfo;
        VDecParams.cformat                  = DstColorFormat;
        VDecParams.lFlags                   = ulVideoDecoderFlags;//FLAG_VDEC_CONVERT | FLAG_VDEC_UVMERGED | FLAG_VDEC_REORDER;
        VDecParams.lpConverter              = &rColorConverter;
        VDecParams.lpConvertInit            = &ColorInit;
        VDecParams.uiLimitThreads           = numThreads;

        umcRes = rpVideoDecoder->Init(&VDecParams);
    }

    if (UMC_OK != umcRes)
    {   vm_message(VM_STRING("VideoDecoder::SelectVideoDecoder Failed\n"));   }

    return umcRes;
}

Status
CodecPipeline::SelectVideoRender(ModuleContext& rContext,
                                 sClipInfo ClipInfo,
                                 UMC::RECT rectDisp,
                                 UMC::RECT rectRange,
                                 ColorFormat RenderCFormat,
                                 vm_var32 ulVideoRenderFlags,
                                 VideoRender*& rpVideoRender,
                                 vm_var32 ulPrefferedRender //= DEF_VIDEO_RENDER
                                 )
{
    Status umcRes = UMC_OK;

    delete rpVideoRender;

    if (UMC_OK == umcRes) {
        //  Init Render
        VideoRenderParams Params;
        Params.color_format = RenderCFormat;
        Params.info         = ClipInfo;
        Params.disp         = rectDisp;
        Params.range        = rectRange;

        Params.lFlags = ulVideoRenderFlags;

        umcRes = SelectVideoRender(Params,
                                   rContext,
                                   rpVideoRender,
                                   ulPrefferedRender);
    }

    return umcRes;
}

void SetNextPreferredVideoRender(vm_var32& ulPrefferedRender)
{
        switch (ulPrefferedRender) {
#ifdef UMC_ENABLE_DX_VIDEO_RENDER
                case DX_VIDEO_RENDER:
        #ifdef UMC_ENABLE_BLT_VIDEO_RENDER
                        ulPrefferedRender = BLT_VIDEO_RENDER;
                        break;
        #endif
        #ifdef UMC_ENABLE_GDI_VIDEO_RENDER
                        ulPrefferedRender = GDI_VIDEO_RENDER;
                        break;
        #endif
#endif // #ifdef UMC_ENABLE_DX_VIDEO_RENDER

#ifdef UMC_ENABLE_BLT_VIDEO_RENDER
                case BLT_VIDEO_RENDER:
        #ifdef UMC_ENABLE_GDI_VIDEO_RENDER
                        ulPrefferedRender = GDI_VIDEO_RENDER;
                        break;
        #endif
#endif // #ifdef UMC_ENABLE_BLT_VIDEO_RENDER

#ifdef UMC_ENABLE_GDI_VIDEO_RENDER
                case GDI_VIDEO_RENDER:
                        break;
#endif // #ifdef UMC_ENABLE_GDI_VIDEO_RENDER

#ifdef UMC_ENABLE_SDL_VIDEO_RENDER
                case SDL_VIDEO_RENDER:
        #if defined(UMC_ENABLE_FB_VIDEO_RENDER)
                                ulPrefferedRender = FB_VIDEO_RENDER;
        #elif defined(UMC_ENABLE_BLT_VIDEO_RENDER)
                                ulPrefferedRender = BLT_VIDEO_RENDER;
        #endif
                                break;
#endif // #ifdef UMC_ENABLE_SDL_VIDEO_RENDER

#ifdef UMC_ENABLE_DXWCE_VIDEO_RENDER
                case DXWCE_VIDEO_RENDER:
        #ifdef UMC_ENABLE_GX_VIDEO_RENDER
                        ulPrefferedRender = GX_VIDEO_RENDER;
                        break;
        #endif
        #ifdef UMC_ENABLE_GDI_VIDEO_RENDER
                        ulPrefferedRender = GDI_VIDEO_RENDER;
                        break;
        #endif
#endif // #ifdef UMC_ENABLE_DXWCE_VIDEO_RENDER

#ifdef UMC_ENABLE_GX_VIDEO_RENDER
                case GX_VIDEO_RENDER:
        #ifdef UMC_ENABLE_GDI_VIDEO_RENDER
                        ulPrefferedRender = GDI_VIDEO_RENDER;
                        break;
        #endif
#endif // #ifdef UMC_ENABLE_GX_VIDEO_RENDER
                default:
                        ulPrefferedRender = DEF_VIDEO_RENDER;
                        break;
        } // switch
}

Status
CodecPipeline::SelectVideoRender(VideoRenderParams& rVideoRenderParams,
                                 ModuleContext& rContext,
                                 VideoRender*& rpRender,
                                 vm_var32 ulPrefferedRender //= DEF_VIDEO_RENDER
                                 )
{
    Status umcRes = UMC_OK;
    Status umcResCom = UMC_OK;
    rpRender = NULL;

    if (DEF_VIDEO_RENDER == ulPrefferedRender) {
#if defined(UMC_ENABLE_SDL_VIDEO_RENDER)
        ulPrefferedRender = SDL_VIDEO_RENDER;
#elif defined(UMC_ENABLE_BLT_VIDEO_RENDER)
        ulPrefferedRender = BLT_VIDEO_RENDER;
#elif defined(UMC_ENABLE_DX_VIDEO_RENDER)
        ulPrefferedRender = DX_VIDEO_RENDER;
#elif defined(UMC_ENABLE_DXWCE_VIDEO_RENDER)
        ulPrefferedRender = DXWCE_VIDEO_RENDER;
#elif defined(UMC_ENABLE_GX_VIDEO_RENDER)
        ulPrefferedRender = GX_VIDEO_RENDER;
#elif defined(UMC_ENABLE_MTWGX_VIDEO_RENDER)
        ulPrefferedRender = GX_VIDEO_RENDER;
#elif defined(UMC_ENABLE_GDI_VIDEO_RENDER)
        ulPrefferedRender = GDI_VIDEO_RENDER;
#elif defined(UMC_ENABLE_FB_VIDEO_RENDER)
        ulPrefferedRender = FB_VIDEO_RENDER;
#else
        assert(false); //  Unknown architecture
#endif
    }

#if defined(UMC_ENABLE_SDL_VIDEO_RENDER)
    if (NULL == rpRender &&
        SDL_VIDEO_RENDER == ulPrefferedRender)
    {
        SDLVideoRender* pSDLRender = new SDLVideoRender;
        if (NULL != pSDLRender) {
            umcRes = pSDLRender->Init(rVideoRenderParams);
            if (UMC_OK == umcRes)
            {   rpRender = pSDLRender;  }
            else {
                delete pSDLRender;
                SetNextPreferredVideoRender(ulPrefferedRender);
            }
        }
    }
#endif  //  defined(SDL_ON)

#if defined(WIN32)
    HWNDModuleContext* pHWNDContext = NULL;
    if (NULL == rpRender) {
        pHWNDContext =
            DynamicCast<HWNDModuleContext,ModuleContext>(&rContext);
        if (NULL == pHWNDContext) { umcRes = UMC_FAILED_TO_INITIALIZE;    }
    }
#endif // defined(WIN32)

#if defined(UMC_ENABLE_DX_VIDEO_RENDER)
    if (NULL == rpRender &&
        DX_VIDEO_RENDER == ulPrefferedRender)
    {
        DXVideoRender* pDXRender = new DXVideoRender;
        if (NULL != pDXRender) {
            DXVideoRenderParams Init;
            static_cast<VideoRenderParams&>(Init) = rVideoRenderParams;
            Init.m_hWnd = pHWNDContext->m_hWnd;
            Init.m_ColorKey = pHWNDContext->m_ColorKey;
            umcRes = pDXRender->Init(Init);
            if (UMC_OK == umcRes)
            {   rpRender = pDXRender;   }
            else {
                delete pDXRender;
                SetNextPreferredVideoRender(ulPrefferedRender);
            }
        }
    }
#endif // defined(UMC_ENABLE_DX_VIDEO_RENDER)

#if defined(UMC_ENABLE_DXWCE_VIDEO_RENDER)
    if (NULL == rpRender &&
        DXWCE_VIDEO_RENDER == ulPrefferedRender)
    {
        DXWCEVideoRender* pDXRender = new DXWCEVideoRender;
        if (NULL != pDXRender) {
            DXWCEVideoRenderParams Init;
            static_cast<VideoRenderParams&>(Init) = rVideoRenderParams;
            Init.m_hWnd = pHWNDContext->m_hWnd;
            umcRes = pDXRender->Init(&Init);
            if (UMC_OK == umcRes)
            {   rpRender = pDXRender;   }
            else {
                delete pDXRender;
                SetNextPreferredVideoRender(ulPrefferedRender);
            }
        }
    }
#endif // defined(ENABLE_DXWCE_VIDEO_RENDER)

#if defined(UMC_ENABLE_BLT_VIDEO_RENDER)
    if (NULL == rpRender &&
        BLT_VIDEO_RENDER == ulPrefferedRender)
    {
        BLTVideoRender* pBLTRender = new BLTVideoRender;
        if (NULL != pBLTRender) {
            DXVideoRenderParams Init;
            static_cast<VideoRenderParams&>(Init) = rVideoRenderParams;
            Init.m_hWnd = pHWNDContext->m_hWnd;
            Init.m_ColorKey = pHWNDContext->m_ColorKey;
            umcRes = pBLTRender->Init(Init);
            if (UMC_OK == umcRes)
            {   rpRender = pBLTRender;  }
            else {
                delete pBLTRender;
                SetNextPreferredVideoRender(ulPrefferedRender);
            }
        }
    }
#endif // defined(_WIN32_WINNT)

#if defined(UMC_ENABLE_MTWGX_VIDEO_RENDER)
    if (NULL == rpRender &&
        GX_VIDEO_RENDER == ulPrefferedRender)
    {
        VideoRender* pGXRender = new MTWREGVideoRender;
        if (NULL != pGXRender) {
            VideoRenderParams Init;

            if (UMC_OK == umcRes)
            {   umcRes = pGXRender->Init(&Init);    }

            if (UMC_OK == umcRes)
            {   rpRender = pGXRender;   }
            else
            {
                delete pGXRender;
                 ulPrefferedRender = GDI_VIDEO_RENDER;
            }
        }
    }
#endif // defined(UMC_ENABLE_MTWGX_VIDEO_RENDER)

#if defined(UMC_ENABLE_GX_VIDEO_RENDER)
    if (NULL == rpRender &&
        GX_VIDEO_RENDER == ulPrefferedRender)
    {
        VideoRender* pGXRender = new GXVideoRender;

        if (NULL != pGXRender)
        {
            GXVideoRenderParams Init;
            static_cast<VideoRenderParams&>(Init) = rVideoRenderParams;
            HWNDModuleContext* hwnd =
                DynamicCast<HWNDModuleContext,ModuleContext>(&rContext);

            if (NULL == hwnd)
            {   umcRes = UMC_FAILED_TO_INITIALIZE;  }

            if (UMC_OK == umcRes)
            {
                Init.m_hWnd = hwnd->m_hWnd;
                Init.m_ColorKey = hwnd->m_ColorKey;
                umcRes = pGXRender->Init(&Init);
            }

            if (UMC_OK == umcRes)
            {   rpRender = pGXRender;   }
            else
            {
                delete pGXRender;
                SetNextPreferredVideoRender(ulPrefferedRender);
            }
        }
    }
#endif // UMC_ENABLE_GX_VIDEO_RENDER

#if defined(UMC_ENABLE_GDI_VIDEO_RENDER)
    if (NULL == rpRender &&
        GDI_VIDEO_RENDER == ulPrefferedRender)
    {
        GDIVideoRender* pGDIRender = new GDIVideoRender;
        if (NULL != pGDIRender) {
            GDIVideoRenderParams Init;
            static_cast<VideoRenderParams&>(Init) = rVideoRenderParams;
            Init.m_hWnd = pHWNDContext->m_hWnd;
            umcRes = pGDIRender->Init(Init);
            if (UMC_OK == umcRes)
            {   rpRender = pGDIRender;  }
            else {
                delete pGDIRender;
            }
        }
    }
#endif // defined(UMC_ENABLE_GDI_VIDEO_RENDER)

#if defined(UMC_ENABLE_OVL2_VIDEO_RENDER)
    if (NULL == rpRender &&
        OVL2_VIDEO_RENDER == ulPrefferedRender)
    {
        OVL2VideoRender* pFBRender = new OVL2VideoRender;
        if (NULL != pFBRender) {
            umcRes = pFBRender->Init(&rVideoRenderParams);
            if (UMC_OK == umcRes)
            {   rpRender = pFBRender;   }
            else
            {
                delete pFBRender;
            }
        }
    }
#endif // UMC_ENABLE_OVL2_VIDEO_RENDER

#if defined(UMC_ENABLE_FB_VIDEO_RENDER)
    if (NULL == rpRender &&
        FB_VIDEO_RENDER == ulPrefferedRender)
    {
        FBVideoRender* pFBRender = new FBVideoRender;
        if (NULL != pFBRender) {
            umcRes = pFBRender->Init(&rVideoRenderParams);
            if (UMC_OK == umcRes)
            {   rpRender = pFBRender;   }
            else
            {
                delete pFBRender;
            }
        }
    }
#endif  // UMC_ENABLE_FB_VIDEO_RENDER

    if (NULL == rpRender &&
        NULL_VIDEO_RENDER == ulPrefferedRender)
    {
        NULLVideoRender* pNULLRender = new NULLVideoRender;
        if (NULL != pNULLRender) {
            umcRes = pNULLRender->Init(rVideoRenderParams);
            if (UMC_OK == umcRes)
            {   rpRender = pNULLRender; }
            else {
                delete pNULLRender;
                umcRes = UMC_FAILED_TO_INITIALIZE;
            }
        }
    }
#if defined (UMC_ENABLE_FILE_WRITER)
    if (NULL == rpRender &&
        FW_VIDEO_RENDER == ulPrefferedRender)
    {
        FWVideoRender* pFWRender = new FWVideoRender;
        if (NULL != pFWRender) {
            umcRes = pFWRender->Init(rVideoRenderParams);
            if (UMC_OK == umcRes)
            {   rpRender = pFWRender;   }
            else {
                delete pFWRender;
                umcRes = UMC_FAILED_TO_INITIALIZE;
            }
        }
    }
#endif //UMC_ENABLE_FILE_WRITER
    if (NULL == rpRender)
    {
        ulPrefferedRender = NULL_VIDEO_RENDER;
        NULLVideoRender* pNULLRender = new NULLVideoRender;
        if (NULL != pNULLRender) {
            umcRes = pNULLRender->Init(rVideoRenderParams);
            if (UMC_OK == umcRes)
            {   rpRender = pNULLRender; }
            else {
                delete pNULLRender;
                umcRes = UMC_FAILED_TO_INITIALIZE;
            }
        }
    }

    if (NULL != rpRender)
        vm_string_printf(VM_STRING("Video Render :\t\t%s\n"), UMC::GetVideoRenderTypeString((UMC::VideoRenderType)ulPrefferedRender));
        vm_string_printf(VM_STRING("-RenderFormat:\t\t%s\n"), UMC::GetFormatTypeString(rVideoRenderParams.color_format));
    return umcRes;
}