/****************************************************************************
 * libwiigui
 *
 * ardi 2009
 *
 * gui_sound_plugin_aif.cpp
 *
 * GUI class definitions
 ***************************************************************************/

#include <limits.h>
#include <asndlib.h>
#include <math.h>
#include <string.h>
#include <unistd.h>

#include "gui_sound_decoder.h"

// ------
// Copyright (C) 1988-1991 Apple Computer, Inc.
#ifndef HUGE_VAL
# define HUGE_VAL HUGE
#endif

# define UnsignedToFloat(u)         (((double)((long)(u - 2147483647L - 1))) + 2147483648.0)

static double ConvertFromIeeeExtended( const u8* bytes )
{
    double f;
    int expon;
    u32 hiMant, loMant;

    expon = ( ( bytes[0] & 0x7F ) << 8 ) | ( bytes[1] & 0xFF );
    hiMant  =    ( ( unsigned long )( bytes[2] & 0xFF ) << 24 )
                 |    ( ( unsigned long )( bytes[3] & 0xFF ) << 16 )
                 |    ( ( unsigned long )( bytes[4] & 0xFF ) << 8 )
                 |    ( ( unsigned long )( bytes[5] & 0xFF ) );
    loMant  =    ( ( unsigned long )( bytes[6] & 0xFF ) << 24 )
                 |    ( ( unsigned long )( bytes[7] & 0xFF ) << 16 )
                 |    ( ( unsigned long )( bytes[8] & 0xFF ) << 8 )
                 |    ( ( unsigned long )( bytes[9] & 0xFF ) );

    if ( expon == 0 && hiMant == 0 && loMant == 0 )
        f = 0;
    else
    {
        if ( expon == 0x7FFF )
            f = HUGE_VAL;
        else
        {
            expon -= 16383;
            f  = ldexp( UnsignedToFloat( hiMant ), expon -= 31 );
            f += ldexp( UnsignedToFloat( loMant ), expon -= 32 );
        }
    }

    if ( bytes[0] & 0x80 )
        return -f;
    else
        return f;
}
// ------

class GuiSoundDecoderAIFF : public GuiSoundDecoder
{
    protected:
        GuiSoundDecoderAIFF( const u8 * snd, u32 len, bool snd_is_allocated )
        {
            sound           = snd;
            length          = len;
            is_allocated    = snd_is_allocated;
            is_running = false;

            const u8 *in_ptr = sound;

            if ( be32inc( in_ptr ) != 0x464F524D /*'FORM'*/ )                            throw( "No FORM chunk" );
            if ( be32inc( in_ptr ) + 8 != len )                                                throw( "wrong Size" );
            if ( be32inc( in_ptr ) != 0x41494646 /*'AIFF'*/ )                            throw( "No AIFF chunk" );

            while ( in_ptr + 8 < sound + len )
            {
                u32 chunk_id                = be32inc( in_ptr );
                u32 chunk_size              = be32inc( in_ptr );
                const u8 *chunk_start   = in_ptr;
                switch ( chunk_id )
                {
                    case 0x434F4D4D /*'COMM'*/:
                        channelCount = be16inc( in_ptr );
                        in_ptr += 4;                                // skip numSampleFrames
                        bytePerSample = ( be16inc( in_ptr ) + 7 ) / 8;
                        if ( bytePerSample < 1 && bytePerSample > 2 )              throw( "wrong bits per Sample" );
                        sampleRate = ConvertFromIeeeExtended( in_ptr );
                        break;
                    case 0x53534E44 /*'SSND'*/:
                        pcm_start   = in_ptr + 8;
                        pcm_end     = chunk_start + chunk_size;
                        break;
                }
                in_ptr = chunk_start + chunk_size;
            }
            currentPos = pcm_start;
        }
    public:
        ~GuiSoundDecoderAIFF()
        {
            while ( is_running ) usleep( 50 );
            if ( is_allocated ) delete [] sound;
        }
        static GuiSoundDecoder *Create( const u8 * snd, u32 len, bool snd_is_allocated )
        {
            if ( snd && len > 12 && snd[0] == 'F' && snd[1] == 'O' && snd[2] == 'R' && snd[3] == 'M'
                    && snd[8] == 'A' && snd[9] == 'I' && snd[10] == 'F' && snd[11] == 'F' )
                return new GuiSoundDecoderAIFF( snd, len, snd_is_allocated );
            return NULL;
        }
        s32 GetFormat()
        {
            if ( bytePerSample == 2 )
                return channelCount == 2 ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT;
            else
                return channelCount == 2 ? VOICE_STEREO_8BIT : VOICE_MONO_8BIT;
        }
        s32 GetSampleRate()
        {
            return sampleRate;
        }
        /*  Read reads data from stream to buffer
            return: >0 = readed bytes;
                    0 = EOF;
                    <0 = Error;
        */
        int Read( u8 * buffer, int buffer_size )
        {
            if ( currentPos >= pcm_end )
                return 0; // EOF

            is_running = true;
            if ( currentPos + buffer_size > pcm_end )
                buffer_size = pcm_end - currentPos;
            memcpy( buffer, currentPos, buffer_size );
            currentPos += buffer_size;
            is_running = false;
            return buffer_size;
        }
        int Rewind()
        {
            while ( is_running ) usleep( 50 );
            currentPos = pcm_start;
            return 0;
        }
    private:
        const u8    *sound;
        u32         length;
        bool        is_allocated;
        bool        is_running;

        u32         sampleRate;
        u16         channelCount;
        u16         bytePerSample;
        const u8    *pcm_start;
        const u8    *pcm_end;
        const u8    *currentPos;
};

REGISTER_GUI_SOUND_DECODER( GuiSoundDecoderAIFF );