MercurySoundDriver.cpp

Go to the documentation of this file.

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

void* MercurySoundDriver::TheadFunctCaller(void* x)
{
    MercurySoundDriver* y = (MercurySoundDriver*)x;
    y->ThreadLoop();
    return 0;
}

MercurySoundDriver& MercurySoundDriver::GetInstance()
{
    static MercurySoundDriver* instance = NULL;
    if (!instance)
    {
        instance = new MercurySoundDriverALSA;
        instance->Init();
        instance->CreateThread();
    }
    return *instance;
}

MercurySoundDriver::MercurySoundDriver()
{
}

MercurySoundDriver::~MercurySoundDriver()
{
    Cleanup();
    //halt the thread so we don't try to write to the buffer after it is gone
    m_thread.Halt();
    delete(m_buffer);
}

void MercurySoundDriver::CreateThread()
{
#if !defined( NO_THREADS )
    printf("make thread\n");
    m_thread.Create(MercurySoundDriver::TheadFunctCaller, this);
#endif
}

void MercurySoundDriver::ThreadLoop()
{
    while (true)
    {
        ProcessPlayingSounds();
        Sleep(10);
    }
}

void MercurySoundDriver::Init()
{
    m_rate = 44100;
    m_bufferSize = 4096;
    m_writeSize = 512;
    m_channels = 2;
    m_sentFrames = 0;
    m_front = &m_buffer;
    m_back = &m_buffer2;
    m_needData = false;
}

void MercurySoundDriver::ProcessPlayingSounds()
{
    m_mutex.Wait();
    if (m_needData)
    {
        unsigned long samples = m_bufferSize*m_channels;
        float mixedData[samples];
        for (unsigned int i = 0; i < samples; ++i)
            mixedData[i] = 0;
        for (unsigned long i = 0; i < m_playingSounds.size(); ++i)
        {
            float* data = m_playingSounds[i]->IsPaused()?NULL:m_playingSounds[i]->ReadData(samples);
            if (!data)
                continue;
            for (unsigned long i = 0; i < samples; ++i)
                mixedData[i] += data[i];
            delete data;
        }

        for (unsigned long i = 0; i < samples; ++i)
            (*m_back)[i] = lrintf(Clamp(mixedData[i], -1.0f, 1.0f)*32767);

        int16_t** tmp = m_front;
        m_front = m_back;
        m_back = m_front;

        m_needData = false;
    }
    m_mutex.UnLock();
}

void MercurySoundDriver::AddSound(MercurySoundSourceWAV* sound)
{
    m_mutex.Wait();
    m_playingSounds.push_back(sound);
    m_mutex.UnLock();
}

void MercurySoundDriver::RemoveSound(MercurySoundSourceWAV* sound)
{
    m_mutex.Wait();
    for (unsigned int i = 0; i < m_playingSounds.size(); ++i)
        if (m_playingSounds[i] == sound)
            m_playingSounds.remove(i);
//          m_playingSounds.erase( m_playingSounds.begin() + i );
    m_mutex.UnLock();
}

/* 
 * 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