codec_pipeline.cpp

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

/* /////////////////////////////////////////////////////////////////////////////
//
//                  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-2007 Intel Corporation. All Rights Reserved.
//
//
*/

#include "umc_defs.h"
#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_audio_codec.h"
#include "umc_splitters.h"
#define UMC_DECODER_CREATE_FUNCTION
#include "umc_video_decoders.h"
#include "umc_video_renders.h"
#include "umc_video_processing.h"
#include "directsound_render.h"

#if defined(UMC_ENABLE_AMR_AUDIO_DECODER)
#include "umc_speech_decoder.h"
#include "fmt_container.h"
#endif

#include "umc_splitter_ex.h"

#undef USE_MPEG2SPLITTER

//#define VIDEO_CONF

using namespace UMC;

UMC::Status
CodecPipeline::SelectDataReader(UMC::ModuleContext& rContext,
                                UMC::DataReader*&   rpDataReader,
                                Ipp32u            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_trace((UMC::UMC_OK != umcRes) ? VM_DEBUG_ALL : VM_DEBUG_NONE,
                             VM_STRING("Fail to reach server\n"));
                delete pSocketReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ERR_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_trace((UMC::UMC_OK != umcRes) ? VM_DEBUG_ALL : VM_DEBUG_NONE,
                             VM_STRING("Fail to reach server\n"));
                delete pHttpReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ERR_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_trace((UMC::UMC_OK != umcRes) ? VM_DEBUG_ALL : VM_DEBUG_NONE,
                             VM_STRING("Fail to reach server\n"));
                delete pHttpReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ERR_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_ERR_INIT;    }
    }

#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_debug_message(VM_STRING("Can't open file: %s\n"),FileParams.m_file_name);
                delete pVobReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ERR_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_debug_message(VM_STRING("Can't open file: %s\n"),FileParams.m_file_name);
                delete pFileReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ERR_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_debug_message(VM_STRING("Can't open file: %s\n"),FileParams.m_file_name);
                delete pFileReader;
                return umcRes;
            }
        }
        else
        {   umcRes = UMC::UMC_ERR_ALLOC;    }
    }
#endif // defined(UMC_ENABLE_FIO_READER)

    return umcRes;
}

Status
CodecPipeline::SelectAudioRender(AudioRenderParams& rInit,
                                 AudioRender*& rpRender,
                                 Ipp32u 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_COREAUDIO_RENDER)
        ulPrefferedRender = COREAUDIO_RENDER;
#elif defined(UMC_ENABLE_WINMM_AUDIO_RENDER)
        ulPrefferedRender = WINMM_AUDIO_RENDER;
#elif defined(UMC_ENABLE_ALSA_AUDIO_RENDER)
        ulPrefferedRender = ALSA_AUDIO_RENDER;
#elif defined(UMC_ENABLE_OSS_AUDIO_RENDER)
        ulPrefferedRender = OSS_AUDIO_RENDER;
#elif defined(UMC_ENABLE_SDL_AUDIO_RENDER)
        ulPrefferedRender = SDL_AUDIO_RENDER;
#elif defined(UMC_ENABLE_FW_AUDIO_RENDER)
        ulPrefferedRender = FW_AUDIO_RENDER;
#else
//        VM_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_ERR_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_ERR_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_ALSA_AUDIO_RENDER
    if (NULL == rpRender &&
        ALSA_AUDIO_RENDER == ulPrefferedRender)
    {
        rpRender = new ALSAAudioRender;
        if (NULL == rpRender)
        {   umcRes = UMC_ERR_ALLOC; }
        else {
            umcRes = rpRender->Init(&rInit);
            if (UMC_OK != umcRes) {
                delete rpRender;
                rpRender = NULL;
                umcRes = UMC_OK;
            }
        }
    }
#endif  // UMC_ENABLE_ALSA_AUDIO_RENDER

#ifdef UMC_ENABLE_OSS_AUDIO_RENDER
    if (NULL == rpRender &&
        OSS_AUDIO_RENDER == ulPrefferedRender)
    {
        rpRender = new OSSAudioRender;
        if (NULL == rpRender)
        {   umcRes = UMC_ERR_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_COREAUDIO_RENDER
    if (NULL == rpRender &&
        COREAUDIO_RENDER == ulPrefferedRender)
    {
        rpRender = new CoreAudioRender;
        if (NULL == rpRender)
        {   umcRes = UMC_ERR_ALLOC; }
        else {
            umcRes = rpRender->Init(&rInit);
            if (UMC_OK != umcRes) {
                delete rpRender;
                rpRender = NULL;
                umcRes = UMC_OK;
            }
        }
    }
#endif  // UMC_ENABLE_COREAUDIO_RENDER

#ifdef UMC_ENABLE_SDL_AUDIO_RENDER
    if (NULL == rpRender &&
        SDL_AUDIO_RENDER == ulPrefferedRender)
    {
        rpRender = new SDLAudioRender;
        if (NULL == rpRender)
        {   umcRes = UMC_ERR_ALLOC; }
        else {
            umcRes = rpRender->Init(&rInit);
            if (UMC_OK != umcRes) {
                delete rpRender;
                rpRender = NULL;
                umcRes = UMC_OK;
            }
        }
    }
#endif  // UMC_ENABLE_SDL_AUDIO_RENDER

#ifdef UMC_ENABLE_FW_AUDIO_RENDER
        if (NULL == rpRender &&
            FW_AUDIO_RENDER == ulPrefferedRender)
        {
            rpRender = new FWAudioRender;
            if (NULL == rpRender)
            {   umcRes = UMC_ERR_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_ERR_ALLOC; }
        else {
            umcRes = rpRender->Init(&rInit);
            if (UMC_OK != umcRes) {
                delete rpRender;
                rpRender = NULL;