umc_transcoder_con_threads.cpp

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

}//Ipp32u VM_THREAD_CALLCONVENTION AudioEncodingThreadRoutine(void *lpvParam)

// audio decoding routine
Ipp32u Transcoder::AudioDecoding()
{
    if (!m_bInit)
    {
        vm_debug_message(VM_STRING("Transcoder isn't initialized\n"));
        error_status = true;
        return 0;
    }

    UMC::MediaData MediaSrc, MediaDst;
    UMC::Status umcRes;

    // main working cicle
    Ipp32u nToCopy;
    Ipp64f dSrcTime;

    while (false == m_bExit)
    {
        // get next audio potion
        umcRes = m_lpAudioSplitter->GetNextData(&MediaSrc, audio_track_num);

        // when end of stream is reached or error occurs
        if (UMC::UMC_OK != umcRes)
        {
            if (umcRes == UMC::UMC_ERR_NOT_ENOUGH_DATA)
            {
                vm_time_sleep(TIME_TO_SLEEP);
                continue;
            }

            if (umcRes != UMC::UMC_ERR_END_OF_STREAM)
                vm_debug_message(VM_STRING("m_lpAudioSplitter->GetNextAudioData: %d\n"), umcRes);

            break;
        }

        dSrcTime = MediaSrc.GetTime();
        if (m_lpDTAudioDecoder)
        {
            // copy data to audio decoder
            while ((false == m_bExit) && (0 != MediaSrc.GetDataSize()))
            {
                // get decoder free space (must be)
                umcRes = m_lpDTAudioDecoder->LockInputBuffer(&MediaDst);

                // dummy error handling
                if (UMC::UMC_OK == umcRes)
                {
                    // copy encoded byte(s)
                    nToCopy = (Ipp32u)min(MediaDst.GetBufferSize(), MediaSrc.GetDataSize());
                    memcpy((Ipp8u*)MediaDst.GetDataPointer(), (Ipp8u*)MediaSrc.GetDataPointer(), nToCopy);
                    MediaDst.SetDataSize(nToCopy);
                    MediaDst.SetTime(dSrcTime);

                    MediaSrc.MoveDataPointer(nToCopy);
                    // unclock buffer
                    m_lpDTAudioDecoder->UnLockInputBuffer(&MediaDst);

                    // decode audio data and pass data to encoder
                    do
                    {
                        // get encoders free buffer
                        do
                        {
                            umcRes = m_lpDTAudioEncoder->LockInputBuffer(&MediaDst);
                            if (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes)
                                vm_time_sleep(TIME_TO_SLEEP);

                        } while ((false == m_bExit) && (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes));

                        // get uncompressed audio data
                        if (UMC::UMC_OK == umcRes)
                            umcRes = m_lpDTAudioDecoder->GetFrame(&MediaDst);

                        // pass uncompressed data to encoder
                        if (UMC::UMC_OK == umcRes)
                            umcRes = m_lpDTAudioEncoder->UnLockInputBuffer(&MediaDst);

                    } while ((false == m_bExit) && (UMC::UMC_OK == umcRes));
                };
            };

            // error handling
            if ((UMC::UMC_ERR_NOT_ENOUGH_DATA != umcRes) && (UMC::UMC_ERR_NOT_ENOUGH_BUFFER != umcRes) && (UMC::UMC_OK != umcRes))
                vm_debug_message(VM_STRING("audio decoding failed, %d\n"), umcRes);
            vm_time_sleep(TIME_TO_SWITCH_THREAD);
        }
        else
        {
            do
            {
                // get encoders free buffer
                do
                {
                    umcRes = m_lpDTAudioEncoder->LockInputBuffer(&MediaDst);
                    if (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes)
                        vm_time_sleep(TIME_TO_SLEEP);

                } while ((false == m_bExit) && (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes));

                // get uncompressed audio data
                if (UMC::UMC_OK == umcRes)
                {
                    Ipp32u data_size = (Ipp32u)min(MediaDst.GetBufferSize(), MediaSrc.GetDataSize());
                    memcpy(MediaDst.GetDataPointer(), MediaSrc.GetDataPointer(), data_size);
                    MediaDst.SetDataSize(data_size);
                    MediaDst.SetTime(MediaSrc.GetTime());

                    umcRes = m_lpDTAudioEncoder->UnLockInputBuffer(&MediaDst);

                    MediaSrc.MoveDataPointer(data_size);
                }
            }while(UMC::UMC_OK == umcRes && MediaSrc.GetDataSize());

            if (umcRes != UMC::UMC_OK)
            {
                vm_debug_message(VM_STRING("audio decoding failed\n"));
                break;
            }
        }
    }
    // set END OF STREAM
    if (false == m_bExit)
    {
        do
        {
            umcRes = m_lpDTAudioEncoder->LockInputBuffer(&MediaDst);
            if (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes)
                vm_time_sleep(TIME_TO_SLEEP);

        } while ((false == m_bExit) && (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes));

        if (UMC::UMC_OK == umcRes)
        {
            MediaDst.SetDataSize(0);
            umcRes = m_lpDTAudioEncoder->UnLockInputBuffer(&MediaDst, UMC::UMC_ERR_END_OF_STREAM);
        }
    }

    bool audio_dec_errs = !(UMC::UMC_OK == umcRes || UMC::UMC_ERR_NOT_ENOUGH_DATA == umcRes || UMC::UMC_ERR_END_OF_STREAM == umcRes);
    error_status |= audio_dec_errs;

    return audio_dec_errs;

}; //unsigned Ipp32u Transcoder::AudioDecodingThreadRoutine(void *lpvParam)


// audio encoding routine
Ipp32u Transcoder::AudioEncoding()
{
    if (!m_bInit)
    {
        vm_debug_message(VM_STRING("Transcoder isn't initialized\n"));
        error_status = true;
        return 0;
    }
    UMC::MediaData MediaSrc;
    UMC::MediaData MediaDst;
    UMC::Status umcRes;

    UMC::SelfDestructionPointer<Ipp8u> lpbCompressedBuffer;
    UMC::BaseCodecParams AudioParams;

    // allocate uncompressed audio buffer
    lpbCompressedBuffer = new Ipp8u[ENCODED_AUDIO_BUFFER_SIZE];
    if (NULL == lpbCompressedBuffer)
    {
        error_status = true;
        return 0;
    }

    MediaDst.SetBufferPointer(lpbCompressedBuffer, ENCODED_AUDIO_BUFFER_SIZE);

    UMC::MediaData mux_data;

    // main working cicle
    while (false == m_bExit)
    {
        // encode audio
        do
        {
            umcRes = m_lpDTAudioEncoder->GetFrame(&MediaDst);
            if (UMC::UMC_ERR_NOT_ENOUGH_DATA == umcRes)
                vm_time_sleep(TIME_TO_SLEEP);

        } while ((false == m_bExit) && (UMC::UMC_ERR_NOT_ENOUGH_DATA == umcRes));
        // handle END OF STREAM & error(s)
        if (UMC::UMC_OK != umcRes)
        {
            if (umcRes != UMC::UMC_ERR_END_OF_STREAM)
                vm_debug_message(VM_STRING("audio encoding failed: %d\n"), umcRes);

            break;
        }
        mux_data.SetBufferPointer((Ipp8u*)MediaDst.GetBufferPointer(), MediaDst.GetBufferSize());
        memcpy(mux_data.GetDataPointer(), MediaDst.GetDataPointer(), MediaDst.GetDataSize());
        mux_data.SetDataSize(MediaDst.GetDataSize());
        mux_data.SetTime(MediaDst.GetTime());

        // put encoded data to muxer
        do
        {
            umcRes = m_lpMuxer->PutAudioData(&mux_data);
            if (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes)
                vm_time_sleep(TIME_TO_SLEEP);

        } while ((false == m_bExit) && (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes));

        // error handling
        if (UMC::UMC_OK != umcRes)
        {
            vm_debug_message(VM_STRING("m_lpMuxer->PutAudioData: %d\n"), umcRes);
            break;
        }
        // sleep after work
        vm_time_sleep(TIME_TO_SWITCH_THREAD);
    }

    for (Ipp32s track = 0; track < number_of_audio_tracks; track ++)
        m_lpMuxer->PutEndOfStream(track);

    bool audio_enc_errs = !(UMC::UMC_OK == umcRes || UMC::UMC_ERR_NOT_ENOUGH_DATA == umcRes || UMC::UMC_ERR_END_OF_STREAM == umcRes);
    error_status |= audio_enc_errs;

    return audio_enc_errs;
}; //unsigned Ipp32u Transcoder::AudioEncodingThreadRoutine(void *lpvParam)