usbloadergx/source/libwiigui/gui_sound.cpp

/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_sound.cpp
 *
 * decoder modification by ardi 2009
 *
 * GUI class definitions
 ***************************************************************************/

#include "gui.h"
#include <unistd.h>
#include "gecko.h"

#include "gui_sound_decoder.h"


#define BUFFER_SIZE 8192


/***************************************************************
 *
 * D E C O D E R <EFBFBD> L I S T
 *
 *
 ***************************************************************/

GuiSoundDecoder::DecoderListEntry *GuiSoundDecoder::DecoderList = NULL;
GuiSoundDecoder::DecoderListEntry &GuiSoundDecoder::RegisterDecoder(DecoderListEntry &Decoder, GuiSoundDecoderCreate fnc)
{
	if(Decoder.fnc != fnc)
	{
		Decoder.fnc = fnc;
		Decoder.next = DecoderList;
		DecoderList = &Decoder;
	}
	return Decoder;
}
GuiSoundDecoder *GuiSoundDecoder::GetDecoder(const u8 * snd, u32 len, bool snd_is_allocated)
{
	for(DecoderListEntry *de = DecoderList; de; de=de->next)
	{
		GuiSoundDecoder *d = NULL;
		try{ d = de->fnc(snd, len, snd_is_allocated); }
		catch(const char *error){
		gprintf("%s", error); }
		catch(...){}
		if(d) return d;
	}
	return NULL;
}


/***************************************************************
 *
 * D E C O D E R <EFBFBD> T H R E A D
 *
 *
 ***************************************************************/

static GuiSound *GuiSoundPlayer[16] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};

static lwp_t GuiSoundDecoderThreadHandle	= LWP_THREAD_NULL;
static bool GuiSoundDecoderThreadRunning	= false;
static bool GuiSoundDecoderDataRquested	= false;

void *GuiSoundDecoderThread(void *args)
{
	GuiSoundDecoderThreadRunning = true;
	do
	{
		if(GuiSoundDecoderDataRquested)
		{
			GuiSoundDecoderDataRquested = false;
			GuiSound **players = GuiSoundPlayer;
			for( int i = 0; i < 16; ++i , ++players)
			{
				GuiSound *player = *players;
				if(player)
					player->DecoderCallback();
			}
		}
		if(!GuiSoundDecoderDataRquested)
			usleep(50);
	} while(GuiSoundDecoderThreadRunning);
	return 0;
}

/***************************************************************
 *
 * A S N D <EFBFBD> C A L L B A C K
 *
 *
 ***************************************************************/

void GuiSoundPlayerCallback(s32 Voice)
{
	if(Voice >= 0 && Voice < 16 && GuiSoundPlayer[Voice])
	{
		GuiSoundPlayer[Voice]->PlayerCallback();
		GuiSoundDecoderDataRquested = true;
	}
}

/***************************************************************
 *
 *   R A W - D E C O D E R
 *   Decoder for Raw-PCM-Datas (16bit Stereo 48kHz)
 *
 ***************************************************************/
class GuiSoundDecoderRAW : public GuiSoundDecoder
{
protected:
	GuiSoundDecoderRAW(const u8 * snd, u32 len, bool snd_is_allocated)
	{
		pcm_start		= snd;
		is_allocated	= snd_is_allocated;
		pcm_end			= pcm_start+len;
		pos				= pcm_start;
		is_running		= false;

    }
public:
	~GuiSoundDecoderRAW()
	{
		while(is_running) usleep(50);
		if(is_allocated) delete [] pcm_start;
	}
	static GuiSoundDecoder *Create(const u8 * snd, u32 len, bool snd_is_allocated)
	{
		try { return new GuiSoundDecoderRAW(snd, len, snd_is_allocated); }
		catch(...) {}
		return NULL;
	}
	s32 GetFormat()
	{
		return VOICE_STEREO_16BIT;
	}
	s32 GetSampleRate()
	{
		return 48000;
	}
	/*  Read reads data from stream to buffer
		return:	>0 = readed bytes;
	            0 = EOF;
				<0 = Error;
	*/
	int Read(u8 * buffer, int buffer_size)
	{
		if(pos >= pcm_end)
			return 0; // EOF

		is_running = true;
		if(pos + buffer_size > pcm_end)
			buffer_size = pcm_end-pos;
		memcpy(buffer, pos, buffer_size);
		pos += buffer_size;
		is_running = false;
		return buffer_size;
	}
	int Rewind()
	{
		pos = pcm_start;
		return 0;
	}
private:
	const u8		*pcm_start;
	const u8		*pcm_end;
	bool			 is_allocated;
	const u8		*pos;
	bool			is_running;

};

/***************************************************************
 *
 *   G u i S o u n d
 *
 *
 ***************************************************************/
#define GuiSoundBufferReady	0x01
#define GuiSoundBufferEOF	0x02
#define GuiSoundFinish		0x04
static int GuiSoundCount = 0;
/**
 * Constructor for the GuiSound class.
 */
GuiSound::GuiSound(const u8 *s, int l, int v/*=100*/, bool r/*=true*/, bool a/*=false*/)
{
	if(GuiSoundCount++ == 0 || GuiSoundDecoderThreadHandle == LWP_THREAD_NULL)
	{
		LWP_CreateThread(&GuiSoundDecoderThreadHandle,GuiSoundDecoderThread,NULL,NULL,32768,80);
	}
	voice = -1;
	play_buffer[0]	= (u8*)memalign(32, BUFFER_SIZE*3);	// tripple-buffer first is played
	play_buffer[1]	= play_buffer[0] + BUFFER_SIZE;		//						second is waiting
	play_buffer[2]	= play_buffer[1] + BUFFER_SIZE;		//						third is decoding
	buffer_nr		= 0;			// current playbuffer
	buffer_pos		= 0;			// current idx to write in buffer
	buffer_ready	= false;
	buffer_eof		= false;
	loop			= false;		// play looped
	volume			= v;			// volume
	decoder			= NULL;
	if(play_buffer[0])			// playbuffer ok
		Load(s, l, r, a);
}
bool GuiSound::Load(const u8 *s, int l, bool r/*=false*/, bool a/*=false*/)
{
	Stop();
	if(!play_buffer[0]) return false;
	GuiSoundDecoder *newDecoder = GuiSoundDecoder::GetDecoder(s, l, a);
	if(!newDecoder && r) newDecoder = GuiSoundDecoderRAW::Create(s, l, a);
	if(newDecoder)
	{
		delete decoder;
		decoder = newDecoder;
		return true;
	}
	else if(a)
		delete [] s;
	return false;
}
GuiSound::GuiSound(const char *p, int v/*=100*/)
{
	if(GuiSoundCount++ == 0 || GuiSoundDecoderThreadHandle == LWP_THREAD_NULL)
	{
		LWP_CreateThread(&GuiSoundDecoderThreadHandle,GuiSoundDecoderThread,NULL,NULL,32*1024,80);
	}
	voice = -1;
	play_buffer[0]	= (u8*)memalign(32, BUFFER_SIZE*3);	// tripple-buffer first is played
	play_buffer[1]	= play_buffer[0] + BUFFER_SIZE;		//						second is waiting
	play_buffer[2]	= play_buffer[1] + BUFFER_SIZE;		//						third is decoding
	buffer_nr		= 0;					// current playbuffer
	buffer_pos		= 0;					// current idx to write in buffer
	buffer_ready	= false;
	buffer_eof		= false;
	loop			= false;				// play looped
	volume			= v;					// volume
	decoder			= NULL;
	if(play_buffer[0])			// playbuffer ok
		Load(p);
}
bool GuiSound::Load(const char *p)
{
	Stop();							// stop playing
	if(!play_buffer[0]) return false;

	bool ret = false;
	voice = -2;						// -2 marks loading from file
	u32 filesize = 0;
	u8 *buffer = NULL;
	size_t result;

	FILE * pFile = fopen (p, "rb");
	if(pFile)
	{
		// get file size:
		fseek (pFile , 0 , SEEK_END);
		filesize = ftell (pFile);
		fseek (pFile , 0 , SEEK_SET);

		// allocate memory to contain the whole file:
		buffer = new(std::nothrow) u8[filesize];
		if (buffer)
		{
			// copy the file into the buffer:
			result = fread (buffer, 1, filesize, pFile);
			if (result == filesize)
				ret= Load(buffer, filesize, false, true);
			else
				delete [] buffer;
		}
		fclose (pFile);
	}
	return ret;
}

/**
 * Destructor for the GuiSound class.
 */
GuiSound::~GuiSound()
{
	if(!loop)	while(voice >= 0) usleep(50);
	Stop();
	if(--GuiSoundCount == 0 && GuiSoundDecoderThreadHandle != LWP_THREAD_NULL)
	{
		GuiSoundDecoderThreadRunning = false;
		LWP_JoinThread(GuiSoundDecoderThreadHandle,NULL);
		GuiSoundDecoderThreadHandle = LWP_THREAD_NULL;
	}
	delete decoder;
	free(play_buffer[0]);
}

void GuiSound::Play()
{
	Stop();									// stop playing if it played
	if(!play_buffer[0]) return;
	if(!decoder) return;					// no decoder or no play_buffer -> no playing
	// initialize the buffer
	buffer_nr		= 0; 					// allways starts with buffer 0
	buffer_pos		= 0;					// reset position
	buffer_ready	= false;
	buffer_eof		= false;
	decoder->Rewind();						// play from begin
	DecoderCallback();						// fill first buffer;
	if(!buffer_ready || buffer_eof)			// if first buffer not ready -> no play
		return;
	voice = ASND_GetFirstUnusedVoice();
	if(voice >= 0)
	{
		s32 vol			= (255*volume)/100;
		s32 format		= decoder->GetFormat();
		s32 samplerate	= decoder->GetSampleRate();
		s32 first_pos	= buffer_pos;
		// switch to next buffer
		buffer_nr		= 1;
		buffer_pos		= 0;
		buffer_ready	= false;
		buffer_eof		= false;
		DecoderCallback();						// fill second buffer;
		GuiSoundPlayer[voice] = this;			// activate Callbacks for this voice
		// Play the voice
		ASND_SetVoice(voice, format, samplerate, 0, play_buffer[0], first_pos, vol, vol, GuiSoundPlayerCallback);
	}
}
/*
int GuiSound::PlayOggFile(char * path)
{
	if(Load(path))
		Play();
	return 1;
}
*/
void GuiSound::Stop()
{
	if(voice < 0) return ;
	GuiSoundPlayer[voice] = NULL; // disable Callbacks
	SND_StopVoice(voice);
	voice = -1;
}

void GuiSound::Pause()
{
	if(voice < 0) return ;
	ASND_PauseVoice(voice, 1);
}

void GuiSound::Resume()
{
	if(voice < 0) return ;
	ASND_PauseVoice(voice, 0);
}

bool GuiSound::IsPlaying()
{
	return voice >= 0;
}

void GuiSound::SetVolume(int vol)
{
	volume = vol;
	if(voice < 0) return ;
	int newvol = 255*(volume/100.0);
	ASND_ChangeVolumeVoice(voice, newvol, newvol);
}

void GuiSound::SetLoop(bool l)
{
	loop = l;
}

void GuiSound::DecoderCallback()
{
	if(buffer_ready || buffer_eof) // if buffer ready or EOF -> nothing
		return;
	bool error=false;
	while(buffer_pos < BUFFER_SIZE)
	{
		int ret = decoder->Read(&play_buffer[buffer_nr][buffer_pos], BUFFER_SIZE-buffer_pos);
		if(ret > 0)
			buffer_pos += ret;					// ok -> fill the buffer more
		else if(ret == 0)						// EOF from decoder
		{
			if(loop)
				decoder->Rewind();				// if loop -> rewind and fill the buffer more
			else if(buffer_pos)
				break;							// has data in buffer -> play the buffer
			else
				buffer_eof = true;				// no data in buffer -> return EOF
				return;
		}
		else if(ret < 0)						// an ERROR
		{
			if(buffer_pos)
				break;							// has data in buffer -> play the buffer
			else if(loop)
			{
				if(!error)						// if no prev error
				{
					decoder->Rewind();			// if loop -> rewind
					error = true;				// set error-state
					continue;					// and fill the buffer more
				}
				buffer_eof = true;				// has prev error -> error in first block -> return EOF
				return;
			}
			else
			{
				buffer_eof = true;				// no loop -> return EOF
				return;
			}
		}
		error = false;							// clear error-state
	}
	buffer_ready = true;
}
void GuiSound::PlayerCallback()
{
	if(buffer_eof)								// if EOF
	{
		if(ASND_TestPointer(voice, play_buffer[(buffer_nr+2)%3])==0)	// test prev. Buffer
			Stop();
	}
	else if(buffer_ready)				// if buffer ready
	{
		if(ASND_AddVoice(voice, play_buffer[buffer_nr], buffer_pos)==SND_OK)	// add buffer
		{
			// next buffer
			buffer_nr	= (buffer_nr+1)%3;
			buffer_pos	= 0;
			buffer_ready= false;
			buffer_eof	= false;
		}
	}
}