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

#include "umc_defs.h"

#ifdef UMC_ENABLE_SDL_AUDIO_RENDER

#include "vm_time.h"
#include "sdlaudio_render.h"

namespace UMC
{

SDLAudioRender::SDLAudioRender():
    m_pDrv(NULL),
    m_tickStartTime(0),
    m_tickPrePauseTime(0),
    m_dfStartPTS(-1.0)
{}

Status SDLAudioRender::Init(MediaReceiverParams* mparams)
{
    Status result = UMC_OK;
    AudioRenderParams* params = DynamicCast<AudioRenderParams, MediaReceiverParams>(mparams);

    if(NULL == params)
        result = UMC_ERR_NULL_PTR;

    if(UMC_OK == result)
        result = BasicAudioRender::Init(mparams);

    m_tickStartTime = 0;
    m_tickPrePauseTime = 0;
    m_dfStartPTS = -1.0;

    if (UMC_OK == result)
        m_pDrv = (SDLAudioDrv *)sdlaudioInit(params->info.sample_frequency,
                                             params->info.channels,
                                             params->info.bitPerSample);
    return result;
}

Status SDLAudioRender::SendFrame(MediaData* data)
{
    Status result = UMC_OK;

    if (UMC_OK == result)
    {
        if ((NULL == data) || (NULL == data->GetDataPointer()))
        result = UMC_ERR_NULL_PTR;
    }

    if (-1.0 == m_dfStartPTS)
        m_dfStartPTS = data->GetTime();

    if (UMC_OK == result)
    {
        if (0 == m_tickStartTime)
            m_tickStartTime = vm_time_get_tick();

        result = sdlaudioPlay(m_pDrv,
                              (Ipp8u *)data->GetDataPointer(),
                              data->GetDataSize());
    }
    return result;
}

Status SDLAudioRender::Pause(bool pause)
{
    Status result = UMC_OK;

    if (pause)
        result = sdlaudioPause(m_pDrv);
    else
        result = sdlaudioResume(m_pDrv);

    m_tickPrePauseTime += vm_time_get_tick() - m_tickStartTime;
    m_tickStartTime = 0;
    return result;
}

Ipp32f SDLAudioRender::SetVolume(Ipp32f volume)
{
    return sdlaudioSetVolume(m_pDrv, volume);
}

Ipp32f SDLAudioRender::GetVolume()
{
    return sdlaudioGetVolume(m_pDrv);
}

Status SDLAudioRender::Close()
{
    sdlaudioClose(m_pDrv); m_pDrv = NULL;
    m_dfStartPTS = -1.0;
    BasicAudioRender::Close();
    return UMC_OK;
}

Status SDLAudioRender::Reset()
{
    Status result = sdlaudioReset(m_pDrv);
    m_tickStartTime = 0;
    m_tickPrePauseTime = 0;
    m_dfStartPTS = -1.0;
    return UMC_OK;//BasicAudioRender::Reset();
}

Ipp64f SDLAudioRender::GetTimeTick()
{
    Ipp64f dfRes = -1;

    if (0 != m_tickStartTime)
    {
        dfRes = m_dfStartPTS + ((Ipp64f)(m_tickPrePauseTime +
                vm_time_get_tick() - m_tickStartTime)) / vm_time_get_frequency();
    } else
    {
        dfRes = m_dfStartPTS + ((Ipp64f)m_tickPrePauseTime) / vm_time_get_frequency();
    }
    Status result = BasicAudioRender::GetTimeTick(dfRes);
    return dfRes;
}

Status SDLAudioRender::SetParams(MediaReceiverParams *mparams,
                                 Ipp32u /*trickModes*/)
{
    Status result = UMC_OK;
    AudioRenderParams* params =
        DynamicCast<AudioRenderParams, MediaReceiverParams>(mparams);

    if (NULL == params)
        return UMC_ERR_NULL_PTR;
    return result;
}

};  // namespace UMC

#endif // UMC_ENABLE_COREAUDIO_RENDER