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);