usbloadergx/source/libwiigui/gui_sound_decoder_wav.cpp
ardi@ist-einmalig.de a0182d0c4c * GuiSound stuff rewritten it makes modular
* ogg decoder added (old oggplayer removed)
  * mp3 decoder added (mp3's cane use as backgroundsounds)
  * WAVE decoder added (but only uncompressed WAVE's)
  * AIFF decoder added (only uncrompressed)
  * BNS decoder added
    all soundformats can use as backgroundsounds
    dimoks GameSound class removed it is replaced with the new GuiSound stuff

* Many small fixes and other changes
2009-11-09 23:03:13 +00:00

237 lines
5.4 KiB
C++

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