basic_audio_render.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 "basic_audio_render.h"
#include "umc_audio_codec.h"

unsigned int
BasicAudioRenderThreadProc(void* vpParam)
{
    assert(NULL != vpParam);
    UMC::BasicAudioRender* pThis =
                            reinterpret_cast<UMC::BasicAudioRender*>(vpParam);
    pThis->ThreadProc();
    return 0;
}

UMC::BasicAudioRender::BasicAudioRender():
    m_tStartTime(0),
    m_tStopTime(0),
    m_bStop(false),
    m_dfNorm(1)
{
    m_tFreq = vm_time_get_frequency();
    m_eventSyncPoint.Init(1, 1);
    m_eventSyncPoint1.Init(1, 0);
    m_bPrepareForReposition = false;
    m_dDynamicChannelPTS = -1;
    m_wDynamicChannels   = -1;
}

UMC::BasicAudioRender::~BasicAudioRender()
{   Close();    }

UMC::Status
UMC::BasicAudioRender::Init(MediaReceiverParams* pInit)
{
    Status umcRes = UMC_OK;
    AudioRenderParams* pParams =
        DynamicCast<AudioRenderParams, MediaReceiverParams>(pInit);

    m_bPrepareForReposition = false;

    if (NULL == pParams)
    {   umcRes = UMC_NULL_PTR;  }

    if (UMC_OK == umcRes)
    {
        MediaBufferParams Params;
        int iSamples = 0;
        sAudioStreamInfo* pAudioInfo = &pParams->info;

        m_dfNorm = 1.0 / pAudioInfo->sample_frequency /
                         (pAudioInfo->bitPerSample >> 3) /
                         pAudioInfo->channels;

        m_wInitedChannels   = pAudioInfo->channels;
        m_dwInitedFrequency = pAudioInfo->sample_frequency ;
        switch (pAudioInfo->stream_type)
        {
            case AC3_AUDIO:
                iSamples = 256*6;
                break;
            case MP1L2_AUDIO:
            case MP1L3_AUDIO:
                iSamples = 1152;
                break;
            case MP2L3_AUDIO:
                iSamples = 576;
                break;
            default: iSamples = 1024;
        }

        Params.m_prefInputBufferSize = //2304;
                                       pAudioInfo->channels *
                                       (pAudioInfo->bitPerSample >> 3) *
                                       iSamples*2;
        Params.m_numberOfFrames = 100;
        Params.m_prefOutputBufferSize =
                                        Params.m_prefInputBufferSize;
                                        //2304;//4 * 1024;

        umcRes = m_DataBuffer.Init(&Params);
    }

    if (UMC_OK == umcRes)
    {
        m_bStop = false;
        umcRes = m_Thread.Create(BasicAudioRenderThreadProc, this);
    }

    return umcRes;
}

void
UMC::BasicAudioRender::ThreadProc()
{
    Status umcRes = UMC_OK;
    AudioData data;

    vm_debug_trace(4, VM_STRING("BasicAudioRender::ThreadProc: Start\n"));

    while (UMC_OK == umcRes && !m_bStop)
    {
        if (UMC_OK == umcRes)
        {   umcRes = m_DataBuffer.LockOutputBuffer(&data);  }

        if (UMC_END_OF_STREAM == umcRes)
        {   break;  }
        else if (UMC_NOT_ENOUGH_DATA == umcRes)
        {
            umcRes = UMC_OK;
            vm_time_sleep(10);
            if(!m_bPrepareForReposition)
                continue;
            else
            {
                break;
            }
        }

        double dfEndTime = data.GetTime() + m_dfNorm * data.GetDataSize();
        assert(UMC_OK == umcRes || UMC_TIMEOUT == umcRes || UMC_WAIT_FOR_REPOSITION == umcRes);
        if (UMC_OK == umcRes)
        {
            data.SetTime(data.GetTime(), dfEndTime);
            umcRes = SendFrame(&data);
        }

        if (UMC_OK == umcRes)
        {
            data.SetTime(dfEndTime);
            data.MoveDataPointer(data.GetDataSize());
            umcRes = m_DataBuffer.UnLockOutputBuffer(&data);
        }
        if(umcRes == UMC_WAIT_FOR_REPOSITION)
        {
            break;
        }
    }

    // stop audio playback
    if(!m_bPrepareForReposition)
    {
        m_bStop = true;
        Pause(true);
    }

    vm_debug_trace(4, VM_STRING("BasicAudioRender::ThreadProc: Exit\n"));
}

// Audio Reference Clock
double
UMC::BasicAudioRender::GetTime()
{
    m_tStartTime = vm_time_get_tick();
    double dfTime = -1.0;
    if (!m_bStop)
    {   dfTime = GetTimeTick(); }

    m_tStopTime = vm_time_get_tick();

    // we must return -1 if playback is already stopped, so zero GetDelay()
    // result is required
    if (-1.0 == dfTime)
    {   m_tStartTime = m_tStopTime; }

    return dfTime >= 0 ? dfTime : -1.0;
}


UMC::Status UMC::BasicAudioRender::GetTimeTick(double pts)
{
    Status umcRes = UMC::UMC_OPERATION_FAILED;

    if((m_dDynamicChannelPTS > 0) && (pts >= m_dDynamicChannelPTS))
    {
        AudioRenderParams par;

        memset(&par.info, 0, sizeof(AudioStreamInfo));
        par.pModuleContext = NULL;
        par.info.sample_frequency = m_dwInitedFrequency;
        par.info.channels         = m_wDynamicChannels;
        par.info.bitPerSample     = 16;

        umcRes = SetParams(&par);

        if(UMC_OK == umcRes)
        {
            m_dDynamicChannelPTS = -1;
        }
    }

    return umcRes;
}
// Estimated value of device latency
double
UMC::BasicAudioRender::GetDelay()
{
    return (double)(vm_var64s)(m_tStopTime - m_tStartTime)/
                                            (double)(vm_var64s)m_tFreq;
}

UMC::Status
UMC::BasicAudioRender::LockInputBuffer(MediaData *in)
{
    vm_debug_trace(0, VM_STRING("BasicAudioRender::LockInputBuffer\n"));
    if(!m_bPrepareForReposition)
        return m_DataBuffer.LockInputBuffer(in);
    else
        return UMC_WAIT_FOR_REPOSITION;
}

UMC::Status
UMC::BasicAudioRender::UnLockInputBuffer(MediaData *in,
                                         Status StreamStatus)
{
    Status umcRes = UMC_OK;

    if (UMC_OK == umcRes)
    {   umcRes = m_DataBuffer.UnLockInputBuffer(in, StreamStatus);  }
    AudioData* pData =
        DynamicCast<AudioData, MediaData>(in);

    if(pData)
    {
        if(m_wInitedChannels == pData->m_info.channels &&
           m_dwInitedFrequency != pData->m_info.sample_frequency)
           {
               AudioRenderParams param;
               param.info = pData->m_info;
               if(UMC_OK == SetParams(&param))
               {
                    m_wInitedChannels   = pData->m_info.channels;
                    m_dwInitedFrequency = pData->m_info.sample_frequency;
               }
           }
           else if((m_wInitedChannels != pData->m_info.channels) &&
                   (m_dDynamicChannelPTS == -1))
           {
                m_dDynamicChannelPTS = in->GetTime();
                m_wDynamicChannels   = pData->m_info.channels;
           }
     }

    return umcRes;
}

UMC::Status
UMC::BasicAudioRender::Stop()
{   return m_DataBuffer.Stop(); }

UMC::Status
UMC::BasicAudioRender::Close()
{
    if (m_Thread.IsValid())
    {
        m_bStop = true;
        Pause(true);
        m_Thread.Wait();
        m_bStop = false;
    }
    m_DataBuffer.Close();
    m_bPrepareForReposition = false;
    return UMC_OK;
}
UMC::Status
UMC::BasicAudioRender::Reset()
{
    m_Thread.Wait();

    m_DataBuffer.Reset();

    return UMC_OK;
}

UMC::Status
UMC::BasicAudioRender::SetParams(MediaReceiverParams *pMedia)
{
    Status umcRes = UMC_OK;

    AudioRenderParams* pParams =
        DynamicCast<AudioRenderParams, MediaReceiverParams>(pMedia);
    if (NULL == pParams)
    {   umcRes = UMC_NULL_PTR;  }

    if (UMC_OK == umcRes)
    {
        sAudioStreamInfo* info = NULL;
        info = &pParams->info;
        if(info->sample_frequency && info->bitPerSample && info->channels)
        {
            m_dfNorm = 1.0 / info->sample_frequency /
                                (info->bitPerSample >> 3) /
                                info->channels;
            m_wInitedChannels = info->channels;
            m_dwInitedFrequency = info->sample_frequency;
        }
        else
            umcRes = UMC::UMC_OPERATION_FAILED;
    }

    return umcRes;
}