umc_transcoder_con_initialize.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_transcoder_con.h"

#include "umc_mpeg2_video_encoder.h"
#include "umc_mpeg4_video_encoder.h"
#include "umc_h264_video_encoder.h"
#include "umc_vc1_video_encoder.h"

#include "umc_file_writer.h"

#include "umc_mpeg2_muxer.h"
#include "umc_mp4_mux.h"
#include "vc1_pure_video_muxer.h"

#include "umc_mp3_encoder.h"
#include "umc_aac_encoder.h"

// Get stream info and return it in video_info and audio_info
UMC::Status Transcoder::GetStreamInfo(UMC::VideoStreamInfo& video_info, UMC::AudioStreamInfo& audio_info)
{
    if (!m_bInit)
        return UMC::UMC_ERR_NOT_INITIALIZED;

    if (video_track_num >= 0)
        video_info = m_video_info;

    if (audio_track_num >= 0)
        audio_info = m_audio_info;

    return UMC::UMC_OK;
}//UMC::Status Transcoder::GetStreamInfo(UMC::VideoStreamInfo& video_info, UMC::AudioStreamInfo& audio_info)

// Initialize splitter(s) and get stream info from it.
UMC::Status Transcoder::GetStreamInfo()
{
    // check if audio and video sources are different
    bool dif_audio_and_video = false;
    if ((m_TranscoderParams.input_audio_filename != m_TranscoderParams.input_video_filename) &&
         m_TranscoderParams.input_audio_filename != NULL)
        dif_audio_and_video = true;

    UMC::Status umcRes = UMC::UMC_OK;

    // select flags for splitter
    Ipp32u splitter_flags = 0;
    if (m_TranscoderParams.video_stream_type != UMC::UNDEF_VIDEO)
        splitter_flags |= UMC::VIDEO_SPLITTER;

    if (m_TranscoderParams.audio_stream_type != UMC::UNDEF_AUDIO && !dif_audio_and_video)
        splitter_flags |= UMC::AUDIO_SPLITTER;

    //select splitter for audio if video and audio sources are different
    if (dif_audio_and_video)
    {
        UMC::LocalReaderContext   a_readContext;
        vm_string_strcpy(a_readContext.m_szFileName, m_TranscoderParams.input_audio_filename);

        // init audio data reader
        umcRes = CodecPipeline::SelectDataReader(a_readContext, m_lpDataReaderAudio, FILE_DATA_READER);
        if (umcRes != UMC::UMC_OK)
        {
            vm_debug_message(VM_STRING("CodecPipeline::SelectDataReader failed: %d\n"), umcRes);
            vm_string_printf("source file not found %s\n", m_TranscoderParams.input_audio_filename);
            return UMC::UMC_ERR_FAILED;
        }

        //select and init auido splitter
        umcRes = CodecPipeline::SelectSplitter(m_lpDataReaderAudio, UMC::AUDIO_SPLITTER, m_lpAudioSplitter);
        if (umcRes != UMC::UMC_OK)
        {
            vm_debug_message(VM_STRING("CodecPipeline::SelectSplitter falied: %d\n"), umcRes);
            return UMC::UMC_ERR_FAILED;
        }
    }

    // init video data reader
    UMC::LocalReaderContext   v_readContext;
    vm_string_strcpy(v_readContext.m_szFileName, m_TranscoderParams.input_video_filename);

    umcRes = CodecPipeline::SelectDataReader(v_readContext, m_lpDataReaderVideo, FILE_DATA_READER);
    if (umcRes != UMC::UMC_OK)
    {
        vm_debug_message(VM_STRING("CodecPipeline::SelectDataReader failed: %d\n"), umcRes);
        vm_string_printf("source file not found %s\n", m_TranscoderParams.input_video_filename);
        return UMC::UMC_ERR_FAILED;
    }

    // select and init video splitter
    umcRes = CodecPipeline::SelectSplitter(m_lpDataReaderVideo, splitter_flags, m_lpVideoSplitter,
                                           NULL);
    if (umcRes != UMC::UMC_OK)
    {
        vm_debug_message(VM_STRING("CodecPipeline::SelectSplitter falied: %d\n"), umcRes);
        return UMC::UMC_ERR_FAILED;
    }

    if (!dif_audio_and_video)
    {
        m_lpDataReaderAudio = m_lpDataReaderVideo;
        m_lpAudioSplitter   = m_lpVideoSplitter;
    }

    UMC::SplitterInfo* pVideoSplitterInfo = NULL;
    // get info from video splitter
    m_lpVideoSplitter->GetInfo(&pVideoSplitterInfo);

    bool found = false;;
    for (Ipp32u track = 0; track < pVideoSplitterInfo->m_nOfTracks; track++)
        if (pVideoSplitterInfo->m_ppTrackInfo[track]->m_Type & UMC::TRACK_ANY_VIDEO)
        {
            if (!found)
            {
                video_track_num = track;
                found = true;
            }
            number_of_video_tracks ++;
        }

    UMC::SplitterInfo* pAudioSplitterInfo = NULL;
    if (dif_audio_and_video) // get info from audio splitter
        m_lpAudioSplitter->GetInfo(pAudioSplitterInfo);
    else
        pAudioSplitterInfo = pVideoSplitterInfo;

    found = false;
    for (Ipp32u track = 0; track < pAudioSplitterInfo->m_nOfTracks; track++)
        if (pAudioSplitterInfo->m_ppTrackInfo[track]->m_Type & UMC::TRACK_ANY_AUDIO)
        {
            if (!found)
            {
                audio_track_num = track;
                found = true;
            }
            number_of_audio_tracks ++;
        }

    if (video_track_num < 0)
        m_TranscoderParams.video_stream_type = UMC::UNDEF_VIDEO;
    else
    {
        m_lpVideoDecSpecInfo = pVideoSplitterInfo->m_ppTrackInfo[video_track_num]->m_pDecSpecInfo;
        m_video_info = *((UMC::VideoStreamInfo*)pVideoSplitterInfo->m_ppTrackInfo[video_track_num]->m_pStreamInfo);
    }

    if (audio_track_num < 0)
        m_TranscoderParams.audio_stream_type = UMC::UNDEF_AUDIO;
    else
    {
        m_lpAudioDecSpecInfo = pAudioSplitterInfo->m_ppTrackInfo[audio_track_num]->m_pDecSpecInfo;
        m_audio_info = *((UMC::AudioStreamInfo*)pAudioSplitterInfo->m_ppTrackInfo[audio_track_num]->m_pStreamInfo);
    }

    return UMC::UMC_OK;
}//UMC::Status Transcoder::GetStreamInfo()

// set video encoding parameters, read it from par-file, sets resolution, framerate as in source stream
UMC::Status Transcoder::SetVideoEncoderParams()
{
    // select video encoder params
    switch(m_TranscoderParams.video_stream_type)
    {
#if defined UMC_ENABLE_MPEG2_VIDEO_ENCODER
        case UMC::MPEG2_VIDEO:
            m_lpVideoEncoderParams = new UMC::MPEG2EncoderParams;
            break;
#endif
#if defined UMC_ENABLE_MPEG4_VIDEO_ENCODER
        case UMC::MPEG4_VIDEO:
            m_lpVideoEncoderParams = new UMC::MPEG4EncoderParams;
            break;
#endif
#if defined UMC_ENABLE_H264_VIDEO_ENCODER
        case UMC::H264_VIDEO:
            m_lpVideoEncoderParams = new UMC::H264EncoderParams;
            break;
#endif
#if defined UMC_ENABLE_VC1_VIDEO_ENCODER
        case UMC::VC1_VIDEO:
            m_lpVideoEncoderParams = new UMC::VC1EncoderParams;
            break;
#endif
        default:
            vm_debug_message(VM_STRING("selected destination video format isn't supported\n"));
            vm_string_printf("selected destination video format isn't supported\n");
            return UMC::UMC_ERR_UNSUPPORTED;

    }

    Ipp64f framerate = m_video_info.framerate;
    Ipp32u bitrate = m_video_info.bitrate;
    // trying to read params from par-file
    if (m_lpVideoEncoderParams->ReadParamFile(m_TranscoderParams.par_filename) != UMC::UMC_OK)
    {
        bitrate   = DEFAULT_VIDEO_BITRATE;
        vm_debug_message(VM_STRING("can't open file: \t%s, default params will be setted\n"), m_TranscoderParams.par_filename);
    }

    // set resolution (the same as in source stream)
    m_lpVideoEncoderParams->info.clip_info = m_video_info.clip_info;

    // set framerate (the same as in source stream)
    m_lpVideoEncoderParams->info.framerate = (framerate == 0) ? DEFAULT_FRAMERATE : framerate;

    // set bitrate (which stated in par-file or the same as in source stream)
    if (m_lpVideoEncoderParams->info.bitrate == 0)
        m_lpVideoEncoderParams->info.bitrate  = (bitrate == 0) ? DEFAULT_VIDEO_BITRATE : bitrate;

    return UMC::UMC_OK;
}//UMC::Status Transcoder::SetVideoEncoderParams()

// create and initilalize video encoder
UMC::Status Transcoder::CreateVideoEncoder(void)
{
    UMC::Status umcRes = UMC::UMC_OK;

    // set parameters
    if (UMC::UMC_OK != SetVideoEncoderParams() || !m_lpVideoEncoderParams)
        return UMC::UMC_ERR_FAILED;

    // select video encoder
    switch (m_TranscoderParams.video_stream_type)
    {
#if defined UMC_ENABLE_MPEG2_VIDEO_ENCODER
        case UMC::MPEG2_VIDEO:
            m_lpVideoEncoder = new UMC::MPEG2VideoEncoder();
            break;
#endif
#if defined UMC_ENABLE_MPEG4_VIDEO_ENCODER
        case UMC::MPEG4_VIDEO:
            m_lpVideoEncoder = new UMC::MPEG4VideoEncoder();
            break;
#endif
#if defined UMC_ENABLE_H264_VIDEO_ENCODER
        case UMC::H264_VIDEO:
            m_lpVideoEncoder = new UMC::H264VideoEncoder();
            break;
#endif
#if defined UMC_ENABLE_VC1_VIDEO_ENCODER
        case UMC::VC1_VIDEO:
            m_lpVideoEncoder = new UMC::VC1VideoEncoder();
            break;
#endif
        // unknown video type
        default:
        {
            vm_debug_message(VM_STRING("selected video format isn't supported\n"));
            vm_string_printf("selected video format isn't supported\n");
            return UMC::UMC_ERR_UNSUPPORTED;
        }
    }

    if (NULL == m_lpVideoEncoder)
        return UMC::UMC_ERR_ALLOC;

    //init video encoder
    if (UMC::UMC_OK != (umcRes = m_lpVideoEncoder->Init(m_lpVideoEncoderParams)))
    {
        vm_debug_message(VM_STRING("m_lpVideoEncoder->Init failed:%d\n"), umcRes);
        return UMC::UMC_ERR_INIT;
    }

    return umcRes;
} //UMC::Status Transcoder::CreateVideoEncoder(void)

// Set audio encoder parameters
UMC::Status Transcoder::SetAudioEncoderParams()