codec_pipeline.cpp

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

/* /////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2003-2005 Intel Corporation. All Rights Reserved.
//
//
*/

#include "codec_pipeline.h"
#include "vm_debug.h"

#include "umc_cyclic_buffer.h"
#include "umc_self_destruction_pointer.h"

#include "umc_readers.h"
#include "umc_audio_decoders.h"
#include "umc_audio_renders.h"
#include "umc_splitters.h"
#include "umc_video_decoders.h"
#include "umc_video_renders.h"

#include "umc_splitter_ex.h"

//#define VIDEO_CONF

using namespace UMC;

UMC::Status
CodecPipeline::SelectDataReader(UMC::ModuleContext& rContext,
                                UMC::DataReader*&   rpDataReader,
                                vm_var32            ulPrefferedReader)
{
    UMC::Status umcRes = UMC::UMC_OK;

    delete rpDataReader;
    rpDataReader = NULL;

    if (DEF_DATA_READER == ulPrefferedReader)
    {   ulPrefferedReader = FILE_DATA_READER;   }

    UMC::RemoteReaderContext* pRemoteReaderContext = NULL;
    if (UMC::UMC_OK == umcRes && NULL == rpDataReader)
    {
        pRemoteReaderContext =
            DynamicCast<UMC::RemoteReaderContext,UMC::ModuleContext>(&rContext);
    }

#if defined(UMC_ENABLE_SOCKET_READER)
    if (UMC::UMC_OK == umcRes &&
        NULL        == rpDataReader &&
        SOCKET_DATA_READER == ulPrefferedReader)
    {
        UMC::SocketReader* pSocketReader = new UMC::SocketReader();

        if (NULL != pSocketReader)
        {
            UMC::SocketReaderParams SocketParams;
            SocketParams.port_number       = pRemoteReaderContext->m_uiPortNumber; //8200;
            SocketParams.transmission_mode = pRemoteReaderContext->m_transmissionMode; //UMC::MULTIPLE_CLIENTS;
            vm_string_strcpy(SocketParams.server_name, pRemoteReaderContext->m_szServerName);

            umcRes = pSocketReader->Init(&SocketParams);

            if (UMC::UMC_OK == umcRes)
            {   rpDataReader = pSocketReader;   }
            else
            {
                vm_debug_msg((UMC::UMC_OK != umcRes) ? 7 : 0,
                             VM_STRING("Fail to reach server\n"));
                delete pSocketReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ALLOC;    }
    }
#endif // defined(UMC_ENABLE_SOCKET_READER)

#if defined(UMC_ENABLE_HTTP_READER)
    if (UMC::UMC_OK      == umcRes &&
        NULL             == rpDataReader &&
        HTTP_DATA_READER == ulPrefferedReader)
    {
        UMC::HttpReader* pHttpReader = new UMC::HttpReader();

        if (NULL != pHttpReader)
        {
            UMC::HttpReaderParams HttpParams;
            vm_string_strcpy(HttpParams.uri,
                             pRemoteReaderContext->m_szServerName);
            HttpParams.portion_size = 10*1024;
            HttpParams.buffer_size  = 100*1024;

            umcRes = pHttpReader->Init(&HttpParams);

            if (UMC::UMC_OK == umcRes)
            {   rpDataReader = pHttpReader;   }
            else
            {
                vm_debug_msg((UMC::UMC_OK != umcRes) ? 7 : 0,
                             VM_STRING("Fail to reach server\n"));
                delete pHttpReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ALLOC;    }
    }
#endif // defined(UMC_ENABLE_HTTP_READER)

#if defined(UMC_ENABLE_MFC_HTTP_READER)
    if (UMC::UMC_OK      == umcRes &&
        NULL             == rpDataReader &&
        HTTP_DATA_READER == ulPrefferedReader)
    {
        UMC::MFCHttpReader* pHttpReader = new UMC::MFCHttpReader();

        if (NULL != pHttpReader)
        {
            UMC::MFCHttpReaderParams HttpParams;
            vm_string_strcpy(HttpParams.m_url,
                             pRemoteReaderContext->m_szServerName);
            HttpParams.m_portion_size = 10*1024;
            HttpParams.m_buffer_size  = 100*1024;

            umcRes = pHttpReader->Init(&HttpParams);

            if (UMC::UMC_OK == umcRes)
            {   rpDataReader = pHttpReader;   }
            else
            {
                vm_debug_msg((UMC::UMC_OK != umcRes) ? 7 : 0,
                             VM_STRING("Fail to reach server\n"));
                delete pHttpReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ALLOC;    }
    }
#endif // defined(UMC_ENABLE_HTTP_READER)


    UMC::LocalReaderContext* pLockalReaderContext = NULL;
    if (UMC::UMC_OK == umcRes && NULL == rpDataReader)
    {
        pLockalReaderContext =
            DynamicCast<UMC::LocalReaderContext,UMC::ModuleContext>(&rContext);

        if (NULL == pLockalReaderContext)
        { umcRes = UMC::UMC_FAILED_TO_INITIALIZE;    }
    }

#if defined(UMC_ENABLE_VOB_READER)
    if (UMC::UMC_OK      == umcRes &&
        NULL             == rpDataReader &&
        VOB_DATA_READER  == ulPrefferedReader)
    {
        UMC::VobReader* pVobReader = new UMC::VobReader();

        if (NULL != pVobReader)
        {
            UMC::FileReaderParams FileParams;
            FileParams.m_portion_size = 0;
            vm_string_strcpy(FileParams.m_file_name,
                             pLockalReaderContext->m_szFileName);

            umcRes = pVobReader->Init(&FileParams);

            if (UMC::UMC_OK == umcRes)
            {   rpDataReader = pVobReader;   }
            else
            {
                vm_message(VM_STRING("Can't open file: %s\n"),FileParams.m_file_name);
                delete pVobReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ALLOC;    }
    }
#endif // defined(UMC_ENABLE_VOB_READER)

#if defined(UMC_ENABLE_FILE_READER)
    if (UMC::UMC_OK       == umcRes &&
        NULL              == rpDataReader &&
        FILE_DATA_READER  == ulPrefferedReader)
    {
        UMC::FileReader* pFileReader = new UMC::FileReader();

        if (NULL != pFileReader)
        {
            UMC::FileReaderParams FileParams;
            FileParams.m_portion_size = 0;
            vm_string_strcpy(FileParams.m_file_name,
                             pLockalReaderContext->m_szFileName);

            umcRes = pFileReader->Init(&FileParams);

            if (UMC::UMC_OK == umcRes)
            {   rpDataReader = pFileReader; }
            else
            {
                vm_message(VM_STRING("Can't open file: %s\n"),FileParams.m_file_name);
                delete pFileReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ALLOC;    }
    }
#endif // defined(UMC_ENABLE_FILE_READER)

#if defined(UMC_ENABLE_FIO_READER)
    if (UMC::UMC_OK       == umcRes &&
        NULL              == rpDataReader &&
        FILE_DATA_READER  == ulPrefferedReader)
    {
        UMC::FIOReader* pFileReader = new UMC::FIOReader();

        if (NULL != pFileReader)
        {
            UMC::FileReaderParams FileParams;
            FileParams.m_portion_size = 0;
            vm_string_strcpy(FileParams.m_file_name,
                             pLockalReaderContext->m_szFileName);

            umcRes = pFileReader->Init(&FileParams);

            if (UMC::UMC_OK == umcRes)
            {   rpDataReader = pFileReader; }
            else
            {
                vm_message(VM_STRING("Can't open file: %s\n"),FileParams.m_file_name);
                delete pFileReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ALLOC;    }
    }
#endif // defined(UMC_ENABLE_FIO_READER)

    return umcRes;
}

Status
CodecPipeline::SelectAudioRender(AudioRenderParams& rInit,
                                 AudioRender*& rpRender,
                                 vm_var32 ulPrefferedRender)
{
    Status umcRes = UMC_OK;

    if (DEF_AUDIO_RENDER == ulPrefferedRender) {
#if defined(UMC_ENABLE_DSOUND_AUDIO_RENDER)
        ulPrefferedRender = DSOUND_AUDIO_RENDER;
#elif defined(UMC_ENABLE_WINMM_AUDIO_RENDER)
        ulPrefferedRender = WINMM_AUDIO_RENDER;
#elif defined(UMC_ENABLE_OSS_AUDIO_RENDER)
        ulPrefferedRender = OSS_AUDIO_RENDER;
#elif defined(UMC_ENABLE_FW_AUDIO_RENDER)
        ulPrefferedRender = FW_AUDIO_RENDER;
#else
//        assert(false); //  Unknown architecture
#endif
    }
#if defined(UMC_ENABLE_DSOUND_AUDIO_RENDER)
    if (NULL == rpRender &&
        DSOUND_AUDIO_RENDER == ulPrefferedRender)
    {
        rpRender = new DSoundAudioRender;
        if (NULL == rpRender) { umcRes = UMC_ALLOC; }
        else {
            umcRes = rpRender->Init(&rInit);
            if (UMC_OK != umcRes) {
                delete rpRender;
                rpRender = NULL;
                umcRes = UMC_OK;
            }
        }
    }
#endif  // UMC_ENABLE_DSOUND_AUDIO_RENDER

#if defined(UMC_ENABLE_WINMM_AUDIO_RENDER)
    if (NULL == rpRender &&
        WINMM_AUDIO_RENDER == ulPrefferedRender)
    {
        rpRender = new WinMMAudioRender;
        if (NULL == rpRender)
        {   umcRes = UMC_ALLOC; }
        else {
            umcRes = rpRender->Init(&rInit);
            if (UMC_OK != umcRes) {
                delete rpRender;
                rpRender = NULL;
                umcRes = UMC_OK;
            }
        }
    }
#endif // defined(UMC_ENABLE_WINMM_AUDIO_RENDER)

#ifdef UMC_ENABLE_OSS_AUDIO_RENDER
    if (NULL == rpRender &&
        OSS_AUDIO_RENDER == ulPrefferedRender)
    {
        rpRender = new OSSAudioRender;
        if (NULL == rpRender)
        {   umcRes = UMC_ALLOC; }
        else {
            umcRes = rpRender->Init(&rInit);
            if (UMC_OK != umcRes) {
                delete rpRender;
                rpRender = NULL;
                umcRes = UMC_OK;
            }
        }
    }
#endif  // UMC_ENABLE_OSS_AUDIO_RENDER

#ifdef UMC_ENABLE_FW_AUDIO_RENDER
        if (NULL == rpRender &&
            FW_AUDIO_RENDER == ulPrefferedRender)
        {
            rpRender = new FWAudioRender;
            if (NULL == rpRender)
            {   umcRes = UMC_ALLOC; }
            else {
                umcRes = rpRender->Init(&rInit);
                if (UMC_OK != umcRes) {
                    delete rpRender;
                    rpRender = NULL;
                    umcRes = UMC_OK;
                }
            }
        }
#endif  // UMC_ENABLE_FW_AUDIO_RENDER

    if (NULL == rpRender)
    {
        ulPrefferedRender = NULL_AUDIO_RENDER;
        rpRender = new NULLAudioRender;
        if (NULL == rpRender)
        {   umcRes = UMC_ALLOC; }
        else {
            umcRes = rpRender->Init(&rInit);
            if (UMC_OK != umcRes) {
                delete rpRender;
                rpRender = NULL;
            }
        }
    }

    if (NULL != rpRender)
        vm_string_printf(VM_STRING("Audio Render :\t\t%s\n"), UMC::GetAudioRenderTypeString((UMC::AudioRenderType)ulPrefferedRender));

    return umcRes;
}

Status
CodecPipeline::SelectAudioRender(sAudioStreamInfo& rAudioInfo,
                                 ModuleContext& rContext,
                                 AudioRender*& rpAudioRender,
                                 vm_var32 ulPrefferedRender )
{
    Status umcRes = UMC_OK;

    delete rpAudioRender;

    AudioRenderParams AudioRenderInit;
    AudioRenderInit.info = rAudioInfo;
    AudioRenderInit.pModuleContext = &rContext;

    if (UMC_OK == umcRes) {
        umcRes = SelectAudioRender(AudioRenderInit, rpAudioRender,ulPrefferedRender);
        if (UMC_OK != umcRes) {
            vm_message(__VM_STRING("CodecPipeline::SelectAudioRender Failed to init"));
        }
    }

    return umcRes;
}

Status
CodecPipeline::SelectAudioDecoder(sAudioStreamInfo& rAudioInfo,
                                  BaseCodec*& rpAudioDecoder)
{
    Status umcRes = UMC_OK;

    delete rpAudioDecoder;

    if (UMC_OK == umcRes)
    {
        switch(rAudioInfo.stream_type)
        {
        case PCM_AUDIO:
        case LPCM_AUDIO:
            rpAudioDecoder = NULL;
            break;
#if defined(UMC_ENABLE_MP3_AUDIO_DECODER)
        case MP1L2_AUDIO:
        case MP1L3_AUDIO:
        case MP2L2_AUDIO:
        case MP2L3_AUDIO:
        case MPEG1_AUDIO:
        case MPEG2_AUDIO:
            rpAudioDecoder = DynamicCast<BaseCodec>(new MP3Decoder);
            if (NULL == rpAudioDecoder)
            { umcRes = UMC_ALLOC; }
            break;
#elif defined(UMC_ENABLE_MP3_INT_AUDIO_DECODER)
        case MP1L2_AUDIO:
        case MP1L3_AUDIO:
        case MP2L2_AUDIO:
        case MP2L3_AUDIO: