/***************************************************************************
 * Copyright (C) 2010
 * by Dimok
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any
 * damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it and
 * redistribute it freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you
 * must not claim that you wrote the original software. If you use
 * this software in a product, an acknowledgment in the product
 * documentation would be appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and
 * must not be misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source
 * distribution.
 *
 * for WiiXplorer 2010
 ***************************************************************************/
#include <unistd.h>
#include <malloc.h>
#include <fs/CFile.hpp>
#include <gui/sounds/SoundHandler.hpp>
#include <gui/sounds/WavDecoder.hpp>
#include <gui/sounds/Mp3Decoder.hpp>
#include <gui/sounds/OggDecoder.hpp>
#include <sndcore2/core.h>

SoundHandler * SoundHandler::handlerInstance = NULL;

SoundHandler::SoundHandler()
    : CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 0, 0x8000) {
    Decoding = false;
    ExitRequested = false;
    for(uint32_t i = 0; i < MAX_DECODERS; ++i) {
        DecoderList[i] = NULL;
        voiceList[i] = NULL;
    }

    resumeThread();

    //! wait for initialization
    while(!isThreadSuspended())
        OSSleepTicks(OSMicrosecondsToTicks(1000));
}

SoundHandler::~SoundHandler() {
    ExitRequested = true;
    ThreadSignal();

    ClearDecoderList();
}

void SoundHandler::AddDecoder(int32_t voice, const char * filepath) {
    if(voice < 0 || voice >= MAX_DECODERS)
        return;

    if(DecoderList[voice] != NULL)
        RemoveDecoder(voice);

    DecoderList[voice] = GetSoundDecoder(filepath);
}

void SoundHandler::AddDecoder(int32_t voice, const uint8_t * snd, int32_t len) {
    if(voice < 0 || voice >= MAX_DECODERS)
        return;

    if(DecoderList[voice] != NULL)
        RemoveDecoder(voice);

    DecoderList[voice] = GetSoundDecoder(snd, len);
}

void SoundHandler::RemoveDecoder(int32_t voice) {
    if(voice < 0 || voice >= MAX_DECODERS)
        return;

    if(DecoderList[voice] != NULL) {
        if(voiceList[voice] && voiceList[voice]->getState() != Voice::STATE_STOPPED) {
            if(voiceList[voice]->getState() != Voice::STATE_STOP)
                voiceList[voice]->setState(Voice::STATE_STOP);

			 // it shouldn't take longer than 3 ms actually but we wait up to 20
            // on application quit the AX frame callback is not called anymore
            // therefore this would end in endless loop if no timeout is defined
            int timeOut = 20;
            while(--timeOut && (voiceList[voice]->getState() != Voice::STATE_STOPPED))
                OSSleepTicks(OSMicrosecondsToTicks(1000));
        }
        SoundDecoder *decoder = DecoderList[voice];
        decoder->Lock();
        DecoderList[voice] = NULL;
        decoder->Unlock();
        delete decoder;
    }
}

void SoundHandler::ClearDecoderList() {
    for(uint32_t i = 0; i < MAX_DECODERS; ++i)
        RemoveDecoder(i);
}

static inline bool CheckMP3Signature(const uint8_t * buffer) {
    const char MP3_Magic[][3] = {
        {'I', 'D', '3'},	//'ID3'
        {0xff, 0xfe},	   //'MPEG ADTS, layer III, v1.0 [protected]', 'mp3', 'audio/mpeg'),
        {0xff, 0xff},	   //'MPEG ADTS, layer III, v1.0', 'mp3', 'audio/mpeg'),
        {0xff, 0xfa},	   //'MPEG ADTS, layer III, v1.0 [protected]', 'mp3', 'audio/mpeg'),
        {0xff, 0xfb},	   //'MPEG ADTS, layer III, v1.0', 'mp3', 'audio/mpeg'),
        {0xff, 0xf2},	   //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
        {0xff, 0xf3},	   //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
        {0xff, 0xf4},	   //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
        {0xff, 0xf5},	   //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
        {0xff, 0xf6},	   //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
        {0xff, 0xf7},	   //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
        {0xff, 0xe2},	   //'MPEG ADTS, layer III, v2.5 [protected]', 'mp3', 'audio/mpeg'),
        {0xff, 0xe3},	   //'MPEG ADTS, layer III, v2.5', 'mp3', 'audio/mpeg'),
    };

    if(buffer[0] == MP3_Magic[0][0] && buffer[1] == MP3_Magic[0][1] &&
            buffer[2] == MP3_Magic[0][2]) {
        return true;
    }

    for(int32_t i = 1; i < 13; i++) {
        if(buffer[0] == MP3_Magic[i][0] && buffer[1] == MP3_Magic[i][1])
            return true;
    }

    return false;
}

SoundDecoder * SoundHandler::GetSoundDecoder(const char * filepath) {
    uint32_t magic;
    CFile f(filepath, CFile::ReadOnly);
    if(f.size() == 0)
        return NULL;

    do {
        f.read((uint8_t *) &magic, 1);
    } while(((uint8_t *) &magic)[0] == 0 && f.tell() < f.size());

    if(f.tell() == f.size())
        return NULL;

    f.seek(f.tell()-1, SEEK_SET);
    f.read((uint8_t *) &magic, 4);
    f.close();

    if(magic == 0x4f676753) { // 'OggS'
        return new OggDecoder(filepath);
    } else if(magic == 0x52494646) { // 'RIFF'
        return new WavDecoder(filepath);
    } else if(CheckMP3Signature((uint8_t *) &magic) == true) {
        return new Mp3Decoder(filepath);
    }

    return new SoundDecoder(filepath);
}

SoundDecoder * SoundHandler::GetSoundDecoder(const uint8_t * sound, int32_t length) {
    const uint8_t * check = sound;
    int32_t counter = 0;

    while(check[0] == 0 && counter < length) {
        check++;
        counter++;
    }

    if(counter >= length)
        return NULL;

    uint32_t * magic = (uint32_t *) check;

    if(magic[0] == 0x4f676753) { // 'OggS'
        return new OggDecoder(sound, length);
    } else if(magic[0] == 0x52494646) { // 'RIFF'
        return new WavDecoder(sound, length);
    } else if(CheckMP3Signature(check) == true) {
        return new Mp3Decoder(sound, length);
    }

    return new SoundDecoder(sound, length);
}

void SoundHandler::executeThread() {
    /*// v2 sound lib can not properly end transition audio on old firmwares
    if (OS_FIRMWARE >= 400 && OS_FIRMWARE <= 410)
    {
        ProperlyEndTransitionAudio();
    }*/


    //! initialize 48 kHz renderer
    AXInitParams params;
    memset(&params, 0, sizeof(params));
    params.renderer = AX_INIT_RENDERER_48KHZ;

    // TODO: handle support for 3.1.0 with dynamic libs instead of static linking it
    //if(AXInitWithParams != 0)
    AXInitWithParams(&params);
    //else
    //    AXInit();

    // The problem with last voice on 500 was caused by it having priority 0
    // We would need to change this priority distribution if for some reason
    // we would need MAX_DECODERS > Voice::PRIO_MAX
    for(uint32_t i = 0; i < MAX_DECODERS; ++i) {
        int32_t priority = (MAX_DECODERS - i) * Voice::PRIO_MAX  / MAX_DECODERS;
        voiceList[i] = new Voice(priority); // allocate voice 0 with highest priority
    }

    AXRegisterAppFrameCallback(SoundHandler::axFrameCallback);


    uint16_t i = 0;
    while (!ExitRequested) {
        suspendThread();

        for(i = 0; i < MAX_DECODERS; ++i) {
            if(DecoderList[i] == NULL)
                continue;

            Decoding = true;
            if(DecoderList[i])
                DecoderList[i]->Lock();
            if(DecoderList[i])
                DecoderList[i]->Decode();
            if(DecoderList[i])
                DecoderList[i]->Unlock();
        }
        Decoding = false;
    }

    for(uint32_t i = 0; i < MAX_DECODERS; ++i)
        voiceList[i]->stop();

    AXRegisterAppFrameCallback(NULL);
    AXQuit();

    for(uint32_t i = 0; i < MAX_DECODERS; ++i) {
        delete voiceList[i];
        voiceList[i] = NULL;
    }
}

void SoundHandler::axFrameCallback(void) {
    for (uint32_t i = 0; i < MAX_DECODERS; i++) {
        Voice *voice = handlerInstance->getVoice(i);

        switch (voice->getState()) {
        default:
        case Voice::STATE_STOPPED:
            break;

        case Voice::STATE_START: {
            SoundDecoder * decoder = handlerInstance->getDecoder(i);
            decoder->Lock();
            if(decoder->IsBufferReady()) {
                const uint8_t *buffer = decoder->GetBuffer();
                const uint32_t bufferSize = decoder->GetBufferSize();
                decoder->LoadNext();

                const uint8_t *nextBuffer = NULL;
                uint32_t nextBufferSize = 0;

                if(decoder->IsBufferReady()) {
                    nextBuffer = decoder->GetBuffer();
                    nextBufferSize = decoder->GetBufferSize();
                    decoder->LoadNext();
                }

                voice->play(buffer, bufferSize, nextBuffer, nextBufferSize, decoder->GetFormat() & 0xff, decoder->GetSampleRate());

                handlerInstance->ThreadSignal();

                voice->setState(Voice::STATE_PLAYING);
            }
            decoder->Unlock();
            break;
        }
        case Voice::STATE_PLAYING:
            if(voice->getInternState() == 1) {
                if(voice->isBufferSwitched()) {
                    SoundDecoder * decoder = handlerInstance->getDecoder(i);
                    decoder->Lock();
                    if(decoder->IsBufferReady()) {
                        voice->setNextBuffer(decoder->GetBuffer(), decoder->GetBufferSize());
                        decoder->LoadNext();
                        handlerInstance->ThreadSignal();
                    } else if(decoder->IsEOF()) {
                        voice->setState(Voice::STATE_STOP);
                    }
                    decoder->Unlock();
                }
            } else {
                voice->setState(Voice::STATE_STOPPED);
            }
            break;
        case Voice::STATE_STOP:
            if(voice->getInternState() != 0)
                voice->stop();
            voice->setState(Voice::STATE_STOPPED);
            break;
        }
    }
}