MercurySoundSourceWAV.cpp

Go to the documentation of this file.

//#include <iostream>
#include "global.h"
#include "MercurySoundSourceWAV.h"
#include "MercuryLog.h"
#include "MercurySoundDriverALSA.h"

MercurySoundSourceWAV::MercurySoundSourceWAV()
    :m_file(NULL)
{
}

MercurySoundSourceWAV::~MercurySoundSourceWAV()
{
    if (m_playState==PLAYING)
        MercurySoundDriverALSA::GetInstance().RemoveSound(this);
    SAFE_DELETE( m_file );
}

bool MercurySoundSourceWAV::Open(const MString& path)
{
    RiffChunk chunk;
    WaveHead head;
    FmtChunk dataHead;
    
    m_file = FILEMAN.Open( path );
    if (!m_file)
    {
        LOG.Warn("Could not open " + path);
        return false;
    }
    
    m_file->Read(&head, sizeof(WaveHead));
    head.info.id = Swap32(head.info.id); //to little endian
    TO_ENDIAN( head.info.id );
    head.type = Swap32(head.type); //to little endian
    TO_ENDIAN( head.type );

    if (head.info.id != 0x52494646)
    {
        LOG.Log(GetType() + ":" + path + " not a valid RIFF");
        return false;
    }

    if (head.type != 0x57415645)
    {
        LOG.Log(GetType() + ":" + "Only type WAVE supported");
        return false;
    }

    m_file->Read(&chunk, sizeof(RiffChunk)); //The compiler pads this one, manually set size 8
    m_file->Read(&dataHead, chunk.size); //The compiler pads this one, manually set size
    chunk.id = Swap32(chunk.id); //to little endian
    TO_ENDIAN( chunk.id );

    if (chunk.id != 0x666D7420)
    {
        LOG.Log(GetType() + ":" + "Invalid chunk, only fmt chunks supported");
        return false;
    }   

    TO_ENDIAN2(dataHead.comp );
    TO_ENDIAN2(dataHead.channels );
    TO_ENDIAN( dataHead.srate );
    if (dataHead.comp != 1)
    {
        LOG.Log(GetType() + ":" + "WAV not PCM");
        return false;
    }

    if (dataHead.channels > 2)
    {
        LOG.Log(GetType() + ":" + "Only mono or stereo is supported");
        return false;
    }
    
    m_chunkSize = 0;
    m_chunkPosition = 0;
    m_atAudioChunk = false;
    m_destroyOnStop = false;
}

bool MercurySoundSourceWAV::LocateAudioData()
{
    RiffChunk chunk;
    while (!m_file->Eof())
    {
        char str[5];
        str[4] = '\0';
        m_file->Read(&chunk, sizeof(RiffChunk));
        memcpy(str, &chunk.id, 4);
        chunk.id = Swap32(chunk.id);
        TO_ENDIAN( chunk.id );
        TO_ENDIAN( chunk.size );
        
        if (chunk.id == 0x64617461)
        {
            m_chunkSize = chunk.size;
            m_chunkPosition = 0;
            m_atAudioChunk = true;
            return true;
        }
        else
        {
            LOG.Info( GetType() + ":" + "Skipping unknown chunk." );
            m_file->Seek( m_file->Tell() + chunk.size);
        }
    }
    return false;
}

float* Read(unsigned long samples);


float* MercurySoundSourceWAV::ReadData(unsigned long samples)
{
    if (m_chunkPosition >= m_chunkSize)
        m_atAudioChunk = false;
        
    if (!m_atAudioChunk)
        LocateAudioData();
    
    if (!m_atAudioChunk)
    {
        Stop();
        return NULL;
    }
    
    unsigned long bytes( samples*sizeof(int16_t) );
    int16_t* data = new int16_t[samples];
    float* fdata = new float[samples];
    
    memset(data, 0 , bytes);
    m_file->Read(data, bytes);
    m_chunkPosition += bytes;
    
    for (unsigned int i = 0; i < samples; ++i)
        fdata[i] = Clamp(data[i]/32767.0f, -1.0f, 1.0f);
    
    delete data;
    return fdata;
}

bool MercurySoundSourceWAV::Play()
{
    if (m_playState == PLAYING)
    {
        LOG.Info(GetType() + ":" + "Streamed sound already playing");
        return false;
    }
    m_playState = PLAYING;
    MercurySoundDriverALSA::GetInstance().AddSound(this);
    return true;
}

bool MercurySoundSourceWAV::Stop()
{
    m_playState = STOPPED;
    MercurySoundDriverALSA::GetInstance().RemoveSound(this);
    if (m_destroyOnStop)
        delete this;
}
void MercurySoundSourceWAV::Pause(bool pause)
{
    if ( (m_playState==PLAYING)&&pause )
        m_playState = PAUSED;
    else if ((m_playState==PAUSED)&&!pause)
        m_playState = PLAYING;
}

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