usbloadergx/source/libwiigui/gui_sound.cpp

441 lines
10 KiB
C++
Raw Normal View History

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