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 – 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 – 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 – 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;
        }
    }
}