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