codec_pipeline.cpp

audio-video-codecs.rar语音编解码器

        rColorConverter.SetParams(&postProcessingParams);

        VDecParams.info                 = rVideoInfo;
        VDecParams.lFlags               = ulVideoDecoderFlags;//FLAG_VDEC_CONVERT | FLAG_VDEC_REORDER;
        VDecParams.numThreads           = numThreads;
        VDecParams.pPostProcessing      = &rColorConverter;

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

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

    return umcRes;
}

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

    delete rpVideoRender;

    if (UMC_OK == umcRes) {
        //  Init Render
        FWVideoRenderParams Params;
        Params.out_data_template.Init(ClipInfo.width, ClipInfo.height, RenderCFormat);
        Params.disp         = rectDisp;
        Params.range        = rectRange;
        Params.pOutFile     = (vm_string_strlen(szOutputVideo))?szOutputVideo:NULL;

        Params.lFlags = ulVideoRenderFlags;

        umcRes = SelectVideoRender(Params,
                                   rContext,
                                   rpVideoRender,
                                   ulPrefferedRender);
        Params.out_data_template.Close();
    }
    return umcRes;
}

void SetNextPreferredVideoRender(Ipp32u& 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_AGL_VIDEO_RENDER
        case AGL_VIDEO_RENDER:
            ulPrefferedRender = AGL_VIDEO_RENDER;
            break;
#endif // #ifdef UMC_ENABLE_AGL_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,
                                 Ipp32u ulPrefferedRender) //= DEF_VIDEO_RENDER
{
    Status umcRes = UMC_OK;
    rpRender = NULL;

    if (DEF_VIDEO_RENDER == ulPrefferedRender)
    {
#if defined(UMC_ENABLE_SDL_VIDEO_RENDER)
        ulPrefferedRender = SDL_VIDEO_RENDER;
#elif defined(UMC_ENABLE_AGL_VIDEO_RENDER)
        ulPrefferedRender = AGL_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
        VM_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(UMC_ENABLE_AGL_VIDEO_RENDER)
    if (NULL == rpRender &&
        AGL_VIDEO_RENDER == ulPrefferedRender)
    {
        AGLVideoRender* pAGLRender = new AGLVideoRender;
        if (NULL != pAGLRender) {
            umcRes = pAGLRender->Init(rVideoRenderParams);
            if (UMC_OK == umcRes)
            {   rpRender = pAGLRender;  }
            else {
                delete pAGLRender;
                SetNextPreferredVideoRender(ulPrefferedRender);
            }
        }
    }
#endif // defined(AGL_ON)

#if defined(WIN32)
    HWNDModuleContext* pHWNDContext = NULL;
    if (NULL == rpRender) {
        pHWNDContext =
            DynamicCast<HWNDModuleContext,ModuleContext>(&rContext);
        if (NULL == pHWNDContext) { umcRes = UMC_ERR_INIT;    }
    }
#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_ERR_INIT;  }

            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_ERR_INIT;
            }
        }
    }
#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_ERR_INIT;
            }
        }
    }
#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_ERR_INIT;
            }
        }
    }

    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.out_data_template.GetColorFormat()));
      return umcRes;
}