usbloadergx/source/libwiigui/gui_sound_decoder_wav.cpp

/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_sound_plugin_wav.cpp
 *
 * by ardi 2009
 *
 * Decoder for WAVE PCM
 *
 * GUI class definitions
 ***************************************************************************/

#include <asndlib.h>
#include <map>
#include <vector>
#include <unistd.h>

#include "gui_sound_decoder.h"

typedef struct
{
        u32 cueID;
        u32 len;
        u32 loops;
} plst_t;
typedef struct
{
        const u8 *start;
        const u8 *end;
        u32 loops;
} playlist_t;

class GuiSoundDecoderWAV: public GuiSoundDecoder
{
    protected:
        GuiSoundDecoderWAV(const u8 * snd, u32 len, bool snd_is_allocated)
        {
            sound = snd;
            is_running = false;
            is_allocated = snd_is_allocated;

            const u8 *in_ptr = sound;

            if (be32inc( in_ptr ) != 0x52494646 /*'RIFF' (WAV)*/) throw("Not a WAV");

            u32 riffsize = le32inc( in_ptr );
            if (riffsize > (len - 8)) throw("Wrong size");

            if (be32inc( in_ptr ) != 0x57415645 /*'WAVE'*/) throw("No  WAVE-Tag");

            if (be32inc( in_ptr ) != 0x666D7420 /*'fmt '*/) throw("No fmt-Tag");

            u32 fmtLen = le32inc( in_ptr );

            if (le16inc( in_ptr ) != 1) throw("Not PCM data");

            channelCount = le16inc( in_ptr );
            if (channelCount < 1 || channelCount > 2) throw("only mono or stereo");

            sampleRate = le32inc( in_ptr );

            in_ptr += 6; // skip <bytes/second> and <block align>

            bytePerSample = (le16inc( in_ptr ) + 7) / 8;
            if (bytePerSample < 1 || bytePerSample > 2) throw("only 1-16 bit/Sample");

            in_ptr += fmtLen - 16;

            if (be32inc( in_ptr ) != 0x64617461 /*'data'*/) throw("No data-Tag");

            soundDataStart = in_ptr + 4;
            soundDataEnd = soundDataStart + le32(in_ptr);

            in_ptr = soundDataEnd;

            std::map<u32, u32> cue;
            std::vector<plst_t> plst;

            if (((u32) in_ptr) & 0x0001UL) in_ptr++;
            while ((in_ptr + 4) < (sound + riffsize))
            {
                u32 tag = be32inc( in_ptr );
                switch (tag)
                {
                    case 0x63756520 /*'cue '*/:
                        in_ptr += 4; // skip size
                        for (u32 count = le32inc( in_ptr ); count > 0; count--)
                        {
                            u32 ID = be32inc( in_ptr );
                            in_ptr += 4; // skip dwPosition
                            if (be32inc( in_ptr ) == 0x64617461 /*'data'*/)
                            {
                                in_ptr += 8; // skip chunkStart - dwBlockStart
                                cue[ID] = le32inc( in_ptr );
                            }
                            else in_ptr += 12; // skip chunkStart - SammpleOffset
                        }
                        break;
                    case 0x706C7374 /*' plst'*/:
                        in_ptr += 4; // skip size
                        for (u32 count = le32inc( in_ptr ); count > 0; count--)
                            plst.push_back(( plst_t )
                            {   le32inc( in_ptr ), le32inc( in_ptr ), le32inc( in_ptr )});
                        break;
                    default:
                        in_ptr -= 2;
                        break;
                }
            }
            for (std::vector<plst_t>::iterator i = plst.begin(); i != plst.end(); ++i)
            {
                const u8 *start = soundDataStart + cue[i->cueID];
                const u8 *end = soundDataStart + (i->len * bytePerSample * channelCount);
                u32 loops = i->loops;
                playlist.push_back(( playlist_t )
                {   start, end, loops});
            }
            if (playlist.size() == 0)
            {
                playlist.push_back(( playlist_t )
                {   soundDataStart, soundDataEnd, 1});
            }
            Rewind();
        }
    public:
        ~GuiSoundDecoderWAV()
        {
            while (is_running)
                usleep(50);
            if (is_allocated) delete[] sound;
        }
        static GuiSoundDecoder *Create(const u8 * snd, u32 len, bool snd_is_allocated)
        {
            if (snd && len > 4 && snd[0] == 'R' && snd[1] == 'I' && snd[2] == 'F' && snd[3] == 'F' && snd[8] == 'W'
                    && snd[9] == 'A' && snd[10] == 'V' && snd[11] == 'E') return new GuiSoundDecoderWAV(snd, len,
                    snd_is_allocated);
            return NULL;
        }
        s32 GetFormat()
        {
            if (bytePerSample == 2)
                return channelCount == 2 ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT;
            else return channelCount == 2 ? VOICE_STEREO_8BIT : VOICE_MONO_8BIT;
        }
        s32 GetSampleRate()
        {
            return sampleRate;
        }
        /*  Read reads data from stream to buffer
         return: >0 = readed bytes;
         0 = EOF;
         <0 = Error;
         */
        int Read(u8 * buffer, int buffer_size)
        {
            is_running = true;
            u8 *write_pos = buffer;
            u8 *write_end = buffer + buffer_size;

            for (;;)
            {
                while (currentPos < currentEnd)
                {
                    if (write_pos >= write_end)
                    {
                        is_running = false;
                        return write_pos - buffer;
                    }
                    if (bytePerSample == 2)
                    {
                        *((s16*) write_pos) = le16inc( currentPos );
                        write_pos += 2;
                        if (channelCount == 2) // stereo
                        {
                            *((s16*) write_pos) = le16inc( currentPos );
                            write_pos += 2;
                        }
                    }
                    else
                    {
                        *write_pos++ = *currentPos++;
                        if (channelCount == 2) // stereo
                        *write_pos++ = *currentPos++;
                    }
                }
                if (currentLoops > 1)
                {
                    currentLoops--;
                    currentPos = currentStart;
                    continue;
                }
                if (currentPlaylist != playlist.end()) currentPlaylist++;
                if (currentPlaylist != playlist.end())
                {
                    currentStart = currentPos = currentPlaylist->start;
                    currentEnd = currentPlaylist->end;
                    currentLoops = currentPlaylist->loops;
                    continue;
                }
                else
                {
                    is_running = false;
                    return write_pos - buffer;
                }
            }
            is_running = false;
            return 0;
        }
        int Rewind()
        {
            currentPlaylist = playlist.begin();
            currentStart = currentPos = currentPlaylist->start;
            currentEnd = currentPlaylist->end;
            currentLoops = currentPlaylist->loops;
            return 0;
        }
    private:
        const u8 *sound;
        bool is_allocated;
        bool is_running;

        u16 channelCount;
        u32 sampleRate;
        u16 bytePerSample;
        const u8 *soundDataStart;
        const u8 *soundDataEnd;
        std::vector<playlist_t> playlist;
        std::vector<playlist_t>::iterator currentPlaylist;
        const u8 *currentStart;
        const u8 *currentEnd;
        u32 currentLoops;
        const u8 *currentPos;

};
REGISTER_GUI_SOUND_DECODER( GuiSoundDecoderWAV );