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