/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_sound_plugin_ogg.cpp
 *
 * by ardi 2009
 *
 * Decoder for ogg-vorbis with libtremor
 *
 * GUI class definitions
 ***************************************************************************/

#include <unistd.h>
#include <asndlib.h>
#include <tremor/ivorbiscodec.h>
#include <tremor/ivorbisfile.h>
#include <string.h>

#include "gui_sound_decoder.h"

/* functions to read the Ogg file from memory */

static struct
{
        char *mem;
        int size;
        int pos;
} file[4];

static int f_read(void * punt, int bytes, int blocks, int *f)
{
    int b;
    int c = 0;
    int d;

    if (bytes * blocks <= 0) return 0;

    blocks *= bytes;

    while (blocks > 0)
    {
        b = blocks;
        if (b > 4096) b = 4096;

        d = (*f) - 0x666;
        if ((unsigned) (d) <= (0x669 - 0x666))
        {
            if (file[d].size == 0) return -1;
            if ((file[d].pos + b) > file[d].size) b = file[d].size - file[d].pos;
            if (b > 0)
            {
                memcpy(punt, file[d].mem + file[d].pos, b);
                file[d].pos += b;
            }
        }
        else b = read(*f, ((char *) punt) + c, b);

        if (b <= 0)
        {
            return c / bytes;
        }
        c += b;
        blocks -= b;
    }
    return c / bytes;
}

static int f_seek(int *f, ogg_int64_t offset, int mode)
{
    if (f == NULL) return (-1);

    int k;
    mode &= 3;

    int d = (*f) - 0x666;
    if ((unsigned) (d) <= (0x669 - 0x666))
    {
        k = 0;

        if (file[d].size == 0) return -1;

        if (mode == 0)
        {
            if ((offset) >= file[d].size)
            {
                file[d].pos = file[d].size;
                k = -1;
            }
            else if ((offset) < 0)
            {
                file[d].pos = 0;
                k = -1;
            }
            else file[d].pos = offset;
        }
        else if (mode == 1)
        {
            if ((file[d].pos + offset) >= file[d].size)
            {
                file[d].pos = file[d].size;
                k = -1;
            }
            else if ((file[d].pos + offset) < 0)
            {
                file[d].pos = 0;
                k = -1;
            }
            else file[d].pos += offset;
        }
        else if (mode == 2)
        {

            if ((file[d].size + offset) >= file[d].size)
            {
                file[d].pos = file[d].size;
                k = -1;
            }
            else if ((file[d].size + offset) < 0)
            {
                file[d].pos = 0;
                k = -1;
            }
            else file[d].pos = file[d].size + offset;
        }

    }
    else k = lseek(*f, (int) offset, mode);

    if (k < 0)
        k = -1;
    else k = 0;
    return k;
}

static int f_close(int *f)
{
    int d = (*f) - 0x666;
    if ((unsigned) (d) <= (0x669 - 0x666))
    {
        file[d].size = 0;
        file[d].pos = 0;
        if (file[d].mem)
        {
            file[d].mem = (char *) 0;
        }
        return 0;
    }
    else return close(*f);
    return 0;
}

static long f_tell(int *f)
{
    int k;

    int d = (*f) - 0x666;
    if ((unsigned) (d) <= (0x669 - 0x666))
    {
        k = file[d].pos;
    }
    else k = lseek(*f, 0, 1);

    return (long) k;
}

static int mem_open(char * ogg, int size)
{
    static int one = 1;
    int n;
    if (one)
    {
        one = 0;

        file[0].size = 0;
        file[1].size = 0;
        file[2].size = 0;
        file[3].size = 0;
        file[0].mem = ogg;
        file[0].size = size;
        file[0].pos = 0;
        return (0x666);
    }

    for (n = 0; n < 4; n++)
    {
        if (file[n].size == 0)
        {
            file[n].mem = ogg;
            file[n].size = size;
            file[n].pos = 0;
            return (0x666 + n);
        }
    }
    return -1;
}

static int mem_close(int fd)
{
    if ((unsigned) ((fd) - 0x666) <= (0x669 - 0x666)) // it is a memory file descriptor?
    {
        fd -= 0x666;
        file[fd].size = 0;
        return 0;
    }
    else return f_close(&fd);
}

static ov_callbacks callbacks = { (size_t(*)(void *, size_t, size_t, void *)) f_read,
        (int(*)(void *, ogg_int64_t, int)) f_seek, (int(*)(void *)) f_close, (long(*)(void *)) f_tell };

class GuiSoundDecoderOGG: public GuiSoundDecoder
{
    protected:
        GuiSoundDecoderOGG(const u8 * snd, u32 len, bool snd_is_allocated)
        {
            sound = snd;
            is_allocated = snd_is_allocated;
            ogg_fd = mem_open((char *) snd, len);
            if (ogg_fd < 0) throw("mem open failed");

            if (ov_open_callbacks((void*) &ogg_fd, &ogg_file, NULL, 0, callbacks) < 0)
            {
                mem_close(ogg_fd);
                throw("ogg open failed");
            }
            ogg_info = ov_info(&ogg_file, -1);
            bitstream = 0;
            is_running = false;
        }
    public:
        ~GuiSoundDecoderOGG()
        {
            while (is_running)
                usleep(50);
            ov_clear(&ogg_file);
            if (is_allocated) delete[] sound;
        }
        static GuiSoundDecoder *Create(const u8 * snd, u32 len, bool snd_is_allocated)
        {
            if (snd && len > 4 && snd[0] == 'O' && snd[1] == 'g' && snd[2] == 'g' && snd[3] == 'S') return new GuiSoundDecoderOGG(
                    snd, len, snd_is_allocated);
            return NULL;
        }
        s32 GetFormat()
        {
            return ogg_info->channels == 2 ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT;
        }
        s32 GetSampleRate()
        {
            return ogg_info->rate;
        }
        /*  Read reads data from stream to buffer
         return: >0 = readed bytes;
         0 = EOF;
         <0 = Error;
         */
        int Read(u8 * buffer, int buffer_size)
        {
            is_running = true;
            int ret = ov_read(&ogg_file, (char *) buffer, buffer_size, &bitstream);
            if (ret < 0)
            {
                /* error in the stream.  Not a problem, just reporting it in
                 case we (the app) cares.  In this case, we don't. */
                if (ret != OV_HOLE) ret = 0; // we says EOF
            }
            is_running = false;
            return ret;
        }
        int Rewind()
        {
            return ov_time_seek(&ogg_file, 0);
        }
    private:
        const u8 *sound;
        bool is_allocated;
        int ogg_fd;
        OggVorbis_File ogg_file;
        vorbis_info *ogg_info;
        int bitstream;
        bool is_running;
};
REGISTER_GUI_SOUND_DECODER( GuiSoundDecoderOGG );