umc_transcoder_con_initialize.cpp

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

{
    m_lpAudioEncoderParams                         = new UMC::AudioCodecParams;
    m_lpAudioEncoderParams->m_info_in              = m_lpAudioEncoderParams->m_info_out =
        m_audio_info;
    m_lpAudioEncoderParams->m_info_in.bitrate      = m_lpAudioEncoderParams->m_info_out.bitrate = DEFAULT_AUDIO_BITRATE;
    m_lpAudioEncoderParams->m_info_out.stream_type = m_TranscoderParams.audio_stream_type;

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

//create and initialize audio encoder
UMC::Status Transcoder::CreateAudioEncoder(void)
{
    UMC::Status umcRes = UMC::UMC_OK;

    UMC::DualThreadCodecParams codec_init;
    UMC::MediaBufferParams     BufferPrm;

    // set parameters
    if (UMC::UMC_OK != SetAudioEncoderParams() || !m_lpAudioEncoderParams)
        return UMC::UMC_ERR_FAILED;

    // select audio encoder
    switch (m_TranscoderParams.audio_stream_type)
    {
#if defined UMC_ENABLE_MP3_AUDIO_ENCODER
        case UMC::MP1L3_AUDIO:
            m_lpAudioEncoder = new UMC::MP3Encoder();
            break;
#endif
#if defined UMC_ENABLE_AAC_AUDIO_ENCODER
        case UMC::AAC_AUDIO:
            m_lpAudioEncoder = new UMC::AACEncoder();
            break;
#endif
        default:
            vm_debug_message(VM_STRING("selected audio format isn't supported\n"));
            return UMC::UMC_ERR_UNSUPPORTED;
    };

    if (!m_lpAudioEncoder)
        return UMC::UMC_ERR_ALLOC;

    m_lpDTAudioEncoder = new UMC::DualThreadedCodec;
    if (NULL == m_lpDTAudioEncoder)
        umcRes = UMC::UMC_ERR_ALLOC;

    if (UMC::UMC_OK == umcRes)
    {
        m_lpPCMBuffer = new UMC::LinearBuffer();
        if (NULL == m_lpPCMBuffer)
            umcRes = UMC::UMC_ERR_ALLOC;
    }

    if (UMC::UMC_OK == umcRes) {

        BufferPrm.m_numberOfFrames      = BUF_NUMBER_OF_FRAMES;
        BufferPrm.m_prefInputBufferSize = BUF_INPUT_SIZE;

        codec_init.m_pCodec             = m_lpAudioEncoder;
        codec_init.m_pMediaBuffer       = m_lpPCMBuffer;

        codec_init.m_pCodecInitParams   = m_lpAudioEncoderParams;
        codec_init.m_pMediaBufferParams = &BufferPrm;
    }

    // initialize audio decoder
    if ((UMC::UMC_OK == umcRes) &&
        UMC::UMC_OK != (umcRes = m_lpDTAudioEncoder->InitCodec(&codec_init)))
    {
        vm_debug_message(VM_STRING("m_lpAudioEncoder->Init failed: %d\n"), umcRes);
        return UMC::UMC_ERR_INIT;
    };

    return UMC::UMC_OK;
}; //UMC::Status Transcoder::CreateAudioEncoder(void)

//set muxer parameters
UMC::Status Transcoder::SetMuxerParams()
{
    UMC::Status umcRes = UMC::UMC_OK;

    // init data writer
    m_lpDataWriter = new UMC::FileWriter;
    UMC::FileWriterParams fw_params;
    vm_string_strcpy(fw_params.m_file_name, m_TranscoderParams.output_filename);

    umcRes = m_lpDataWriter->Init(&fw_params);
    if (umcRes != UMC::UMC_OK)
    {
        vm_debug_message(VM_STRING("m_lpDataWriter->Init failed: %d\n"), umcRes);
        return UMC::UMC_ERR_INIT;
    }

    // create muxer parameters
    switch (m_TranscoderParams.system_stream_type)
    {
        case UMC::MPEG2_PROGRAMM_STREAM:
        case UMC::MPEG2_TRANSPORT_STREAM:
        case UMC::MPEG2_PES_PACKETS_STREAM:
        case UMC::MPEG2_PURE_VIDEO_STREAM:
        case UMC::MPEG4_PURE_VIDEO_STREAM:
        case UMC::H264_PURE_VIDEO_STREAM:
        case UMC::MPEGx_PURE_VIDEO_STREAM:
        case UMC::MPEGx_PURE_AUDIO_STREAM:
            {
                UMC::MPEG2MuxerParams* mp2_params = new UMC::MPEG2MuxerParams;
                mp2_params->m_dSystemTimeDelay = 0.0;

                m_lpMuxerParams = mp2_params;
            }
            break;
        case UMC::MP4_ATOM_STREAM:
        case UMC::VC1_PURE_VIDEO_STREAM:
           m_lpMuxerParams = new UMC::MuxerParams;
           break;
        default:
            return UMC::UMC_ERR_UNSUPPORTED;
    }

    // set muxer parameters             '
    m_lpMuxerParams->m_SystemType = m_TranscoderParams.system_stream_type;
    m_lpMuxerParams->m_lpDataWriter = m_lpDataWriter;

    m_lpMuxerParams->m_nNumberOfTracks = 0;

    if(m_TranscoderParams.audio_stream_type != UMC::UNDEF_AUDIO && m_TranscoderParams.video_stream_type != UMC::UNDEF_VIDEO)
        m_lpMuxerParams->m_nNumberOfTracks = number_of_audio_tracks + number_of_video_tracks;

    else if (m_TranscoderParams.audio_stream_type == UMC::UNDEF_AUDIO && m_TranscoderParams.video_stream_type != UMC::UNDEF_VIDEO)
        m_lpMuxerParams->m_nNumberOfTracks = number_of_video_tracks;

    else if (m_TranscoderParams.audio_stream_type != UMC::UNDEF_AUDIO && m_TranscoderParams.video_stream_type == UMC::UNDEF_VIDEO)
        m_lpMuxerParams->m_nNumberOfTracks = number_of_audio_tracks;

    m_lpMuxerParams->pTrackParams = new UMC::TrackParams[m_lpMuxerParams->m_nNumberOfTracks];
    if(!m_lpMuxerParams->pTrackParams)
       return UMC::UMC_ERR_ALLOC;

    Ipp32s track = 0;
    if (m_TranscoderParams.audio_stream_type != UMC::UNDEF_AUDIO)
        for(track = 0; track < number_of_audio_tracks; track ++)
        {
            m_lpMuxerParams->pTrackParams[track].type                    = UMC::AUDIO_TRACK;
            m_lpMuxerParams->pTrackParams[track].info.audio              = &m_lpAudioEncoderParams->m_info_out;
            m_lpMuxerParams->pTrackParams[track].info.audio->stream_type = m_TranscoderParams.audio_stream_type;
        }

    if (m_TranscoderParams.video_stream_type != UMC::UNDEF_VIDEO)
        for(;track < m_lpMuxerParams->m_nNumberOfTracks; track ++)
        {
            m_lpMuxerParams->pTrackParams[track].type                    = UMC::VIDEO_TRACK;
            m_lpMuxerParams->pTrackParams[track].info.video              = &m_lpVideoEncoderParams->info;
            m_lpMuxerParams->pTrackParams[track].info.video->stream_type = m_TranscoderParams.video_stream_type;

            if (m_TranscoderParams.system_stream_type == UMC::MP4_ATOM_STREAM)
            {
                m_lpMuxerParams->pTrackParams[track].info.video->stream_subtype =
                    (m_TranscoderParams.video_stream_type == UMC::H264_VIDEO) ? UMC::AVC1_VIDEO : UMC::MPEG4_VIDEO_QTIME;
            }
            else
                m_lpMuxerParams->pTrackParams[track].info.video->stream_subtype = UMC::UNDEF_VIDEO_SUBTYPE;
        }

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

//create amd initilalize muxer
UMC::Status Transcoder::CreateMuxer()
{
    // set parameters
    if (UMC::UMC_OK != SetMuxerParams() || !m_lpMuxerParams)
        return UMC::UMC_ERR_FAILED;

    //select muxer
    switch (m_TranscoderParams.system_stream_type)
    {
        case UMC::MPEG2_PROGRAMM_STREAM:
        case UMC::MPEG2_TRANSPORT_STREAM:
        case UMC::MPEG2_PES_PACKETS_STREAM:
        case UMC::MPEG2_PURE_VIDEO_STREAM:
        case UMC::MPEG4_PURE_VIDEO_STREAM:
        case UMC::H264_PURE_VIDEO_STREAM:
        case UMC::MPEGx_PURE_VIDEO_STREAM:
        case UMC::MPEGx_PURE_AUDIO_STREAM:
            m_lpMuxer = new UMC::MPEG2Muxer();
            break;
        case UMC::MP4_ATOM_STREAM:
            m_lpMuxer = new UMC::MP4Muxer();
            break;
        case UMC::VC1_PURE_VIDEO_STREAM:
            m_lpMuxer = new VC1Muxer;
            break;
        default:
            vm_debug_message(VM_STRING("selected destination system stream type isn't supported\n"));
            return UMC::UMC_ERR_UNSUPPORTED;
    }

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

    UMC::Status umcRes = UMC::UMC_OK;
    // initialize muxer
    if (UMC::UMC_OK != (umcRes = m_lpMuxer->Init(m_lpMuxerParams)))
    {
        vm_debug_message(VM_STRING("m_lpMuxer->Init failed: %d\n"), umcRes);
        return UMC::UMC_ERR_FAILED;
    }

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

// Initialize all components
UMC::Status Transcoder::Init(TranscoderParams transcoder_params)
{
    Close();

    m_TranscoderParams = transcoder_params;

    UMC::Status umcRes = UMC::UMC_OK;

    umcRes = GetStreamInfo();
    if (umcRes != UMC::UMC_OK)
        return UMC::UMC_ERR_FAILED;

    // video decoder and encoder initializatiom
    if (m_TranscoderParams.video_stream_type != UMC::UNDEF_VIDEO)
    {
        // init video decoder
        m_lpVideoProcessing = new UMC::VideoProcessing;

        umcRes = CodecPipeline::SelectVideoDecoder(m_video_info,
                                                   m_lpVideoDecSpecInfo,
                                                   1, UMC::NO_DEINTERLACING,  0,
                                                   UMC::FLAG_VDEC_REORDER,
                                                   *m_lpVideoProcessing,
                                                   m_lpVideoDecoder);
        if (umcRes != UMC::UMC_OK)
        {
            vm_debug_message(VM_STRING("CodecPipeline::SelectVideoDecoder failed: %d\n"), umcRes);
            return UMC::UMC_ERR_INIT;
        }

        // create video encoder
        umcRes = CreateVideoEncoder();
        if (umcRes != UMC::UMC_OK)
            return UMC::UMC_ERR_INIT;
    }
    // audio decoder and encoder initializatiom
    if (m_TranscoderParams.audio_stream_type != UMC::UNDEF_AUDIO)
    {
        // init audio decoder
        umcRes = CodecPipeline::SelectDTAudioDecoder(m_audio_info,
                                                     m_lpAudioDecoder, m_lpDTAudioDecoder,
                                                     m_lpMediaBuffer,
                                                     m_lpAudioDecSpecInfo);
        if (umcRes != UMC::UMC_OK)
        {
            vm_debug_message(VM_STRING("CodecPipeline::SelectDTAudioDecoder failed: %d\n"), umcRes);
            return UMC::UMC_ERR_INIT;
        }

        umcRes = CreateAudioEncoder();
        if (umcRes != UMC::UMC_OK)
            return UMC::UMC_ERR_INIT;
    }

    umcRes = CreateMuxer();
    if (umcRes != UMC::UMC_OK)
        return UMC::UMC_ERR_INIT;

    m_bInit = true;
    return UMC::UMC_OK;
}//UMC::Status Transcoder::Init(TranscoderParams transcoder_params)