MercurySoundDriverALSA.cpp

Go to the documentation of this file.

#include <math.h>
#include "MercurySoundDriverALSA.h"
#include "MercuryLog.h"

MercurySoundDriverALSA::MercurySoundDriverALSA()
    :MercurySoundDriver(), m_pcmHandle(NULL)
{
}

MercurySoundDriverALSA::~MercurySoundDriverALSA()
{
}

void MercurySoundDriverALSA::ALSACallback(snd_async_handler_t *pcm_callback)
{
    MercurySoundDriverALSA* sd = (MercurySoundDriverALSA*)snd_async_handler_get_callback_private(pcm_callback);
    sd->WriteSoundFrames();
#if defined( NO_THREADS )
    sd->ProcessPlayingSounds();
#endif
}

void MercurySoundDriverALSA::Init()
{
    MercurySoundDriver::Init();
    m_name = "default";

    int err = snd_pcm_open(&m_pcmHandle, m_name.c_str(), SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
    if (err < 0)
        printf("can not open audio device %s (%s)\n", m_name.c_str(), snd_strerror(err) );

    SetupHWParams();
    SetupSWParams();
    
    m_buffer = new int16_t[m_bufferSize*m_channels];
    memset(m_buffer, 0, m_bufferSize*m_channels*sizeof(int16_t));
    m_buffer2 = new int16_t[m_bufferSize*m_channels];
    memset(m_buffer2, 0, m_bufferSize*m_channels*sizeof(int16_t));
    
    snd_pcm_prepare (m_pcmHandle);
    Start();    
    
    ProcessPlayingSounds();

    snd_async_handler_t *pcm_callback;
    snd_async_add_pcm_handler(&pcm_callback, m_pcmHandle, MercurySoundDriverALSA::ALSACallback, this);
    void *private_data = snd_async_handler_get_callback_private(pcm_callback);
}

void MercurySoundDriverALSA::WriteSoundFrames()
{
    m_mutex.Wait();
    
    snd_pcm_sframes_t avail( snd_pcm_avail_update(m_pcmHandle) );   
    while ( (avail >= m_writeSize) && (m_sentFrames < m_bufferSize) )
    {
        unsigned long numFrames = avail<(m_bufferSize-m_sentFrames)?avail:(m_bufferSize-m_sentFrames);
        unsigned long byteOffset = m_sentFrames*m_channels;
        int wrote = snd_pcm_writei(m_pcmHandle, (*m_front)+byteOffset, numFrames);
//      printf("numframes:%d -> %d\n", numFrames, wrote);
        
        if (wrote < 0)
        {
            Recover(wrote);
//          WriteSoundFrames();
            Start();
            m_mutex.UnLock();
            return;
        }
        
        m_sentFrames += wrote;
        avail = snd_pcm_avail_update(m_pcmHandle);
    }
    
    if (m_sentFrames >= m_bufferSize)
    {
        m_sentFrames = 0;
        m_needData = true;
    }
        
    m_mutex.UnLock();
}

void MercurySoundDriverALSA::Recover(int error)
{
    if( error == -EPIPE )
    {
        LOG.Warn("ALSA buffer underrun");
        snd_pcm_prepare(m_pcmHandle);
    }
    if( error == -ESTRPIPE )
    {
        LOG.Warn("ALSA suspend");
        while (snd_pcm_resume(m_pcmHandle) == -EAGAIN)
            usleep(10000); // 10ms
    }
}

void MercurySoundDriverALSA::SetupHWParams()
{
    snd_pcm_hw_params_t *hw_params;
    snd_pcm_hw_params_malloc(&hw_params);
    
    snd_pcm_hw_params_any(m_pcmHandle, hw_params);

    snd_pcm_hw_params_set_access(m_pcmHandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
    snd_pcm_hw_params_set_format(m_pcmHandle, hw_params, SND_PCM_FORMAT_S16_LE);
    snd_pcm_hw_params_set_rate_near(m_pcmHandle, hw_params, &m_rate, NULL);
    snd_pcm_hw_params_set_channels(m_pcmHandle, hw_params, m_channels);
    snd_pcm_hw_params_set_buffer_size_near(m_pcmHandle, hw_params, &m_bufferSize);
    snd_pcm_hw_params_set_period_size_near(m_pcmHandle, hw_params, &m_writeSize, NULL);

    snd_pcm_hw_params(m_pcmHandle, hw_params);
    snd_pcm_hw_params_free(hw_params);
}

void MercurySoundDriverALSA::SetupSWParams()
{
    snd_pcm_sw_params_t *sw_params;

    snd_pcm_sw_params_malloc(&sw_params);
    snd_pcm_sw_params_current(m_pcmHandle, sw_params);
    snd_pcm_sw_params_set_start_threshold(m_pcmHandle, sw_params, m_bufferSize - m_writeSize);
    snd_pcm_sw_params_set_avail_min(m_pcmHandle, sw_params, m_writeSize);
    snd_pcm_sw_params(m_pcmHandle, sw_params);
    snd_pcm_sw_params_free (sw_params);
}

void MercurySoundDriverALSA::Cleanup()
{
    snd_pcm_close(m_pcmHandle);
}

void MercurySoundDriverALSA::Start()
{
    int wrote = snd_pcm_writei (m_pcmHandle, *m_front, m_bufferSize);
    snd_pcm_start(m_pcmHandle);
}

/* 
 * Copyright (c) 2007 Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by