usbloadergx/source/libwiigui/gui_sound_decoder_bns.cpp

/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_sound_plugin_bns.cpp
 *
 * by ardi 2009
 *
 * Decoder for Wii bns-sound
 *
 * GUI class definitions
 ***************************************************************************/

#include <asndlib.h>
#include <unistd.h>

#include "gui_sound_decoder.h"
#define BIG_ENDIAN_HOST 1




class chanel_t
{
    public:
        void Reset()
        {
            currentPos = startPos;
            hist1 = hist2 = 0;
        }
        int DecodeNextBlock()
        {
            int Offset = 0;
            if ( currentPos == loopStart )
            {
                loop_hist1 = hist1;
                loop_hist2 = hist2;
            }
            if ( loop && currentPos >= endPos )
            {
                currentPos = loopStart;
                hist1   = loop_hist1;
                hist2   = loop_hist2;
                Offset  = loopOffset;

            }

            if ( currentPos + 8 <= endPos )
            {
                u16 index = ( *currentPos >> 4 ) & 0x07;
                s32 scale = 1 << ( *currentPos++ & 0x0F );
                for ( int i = 0; i < 14; i += 2 )
                {
                    nibbles[i] = ( ( s8 ) * currentPos ) >> 4;
                    nibbles[i+1] = ( ( s8 )( ( *currentPos++ ) << 4 ) ) >> 4;
                }
                for ( int i = 0; i < 14; ++i )
                {
                    s32 sample = ( scale * nibbles[i] ) << 11;
                    sample += coEfficients[index * 2] * hist1;
                    sample += coEfficients[index * 2 + 1] * hist2;
                    sample += 1024;
                    sample = sample >> 11;
                    if ( sample > 32767 )
                        sample = 32767;
                    else if ( sample < -32768 )
                        sample = -32768;
                    pcm[i] = sample;

                    hist2 = hist1;
                    hist1 = sample;
                }
                return Offset;
            }
            return -1;
        }

        const u8*   startPos;
        const u8*   endPos;
        const u8*   currentPos;
        s16         coEfficients[16];
        s16         nibbles[14];
        s16         pcm[14];
        s16         hist1;
        s16         hist2;
        bool        loop;
        const u8*   loopStart;
        u16         loopOffset;
        s16         loop_hist1;
        s16         loop_hist2;
};

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

            const u8 *in_ptr = sound;

            /////////////////
            // READ HEADER //
            /////////////////
            if ( be32inc( in_ptr ) != 0x424E5320 /*'BNS '*/ ) throw( "Not a BNS" );

            in_ptr += 4;    // skip 4 byte

            u32 bnssize = be32inc( in_ptr );
            if ( bnssize != len ) throw( "Wrong size" );

            in_ptr += 4;        // skip unknown1

            const u8* infoStart = sound + be32inc( in_ptr );
            in_ptr += 4;                    // skip const u8* infoEnd   = infoStart + be32inc(in_ptr);

            channel[0].startPos = sound + be32inc( in_ptr ) + 8;
            channel[0].endPos   = channel[0].startPos + be32inc( in_ptr ) - 8;

            ///////////////
            // READ INFO //
            ///////////////
            in_ptr = infoStart + 8;         // skip 'INFO' and Infosize

            in_ptr++;                       // skip u8 codeType     = *in_ptr++;

            channel[0].loop = channel[1].loop = *in_ptr++; // u8 loopFlag;

            channelCount    = *in_ptr++;

            in_ptr++;                       // skip unknown byte

            sampleRate = be16inc( in_ptr );

            in_ptr += 2;                    // skip unknown word

            u32 loopStart = be32inc( in_ptr );
            channel[0].loopStart    = channel[0].startPos + ( ( loopStart / 14 ) * 8 );//LoopPos to BlockStart
            channel[1].loopStart    = channel[1].startPos + ( ( loopStart / 14 ) * 8 );
            channel[0].loopOffset   = channel[1].loopOffset = loopStart % 14;

            in_ptr += 4;                    // skip u32 SampleCount = be32inc(in_ptr);

            in_ptr += 24;                   // skip unknown Bytes

            if ( channelCount == 2 )
            {
                in_ptr += 4;                // skip unknown long
                u32 ChannelSplit = be32inc( in_ptr );

                in_ptr += 8;                // skip 2x unknown long

                channel[1].endPos   = channel[0].endPos;
                channel[0].endPos   = channel[1].startPos = channel[0].startPos + ChannelSplit;

                channel[1].loopStart = channel[1].startPos + ( channel[0].loopStart - channel[0].startPos );
            }
            for ( int a = 0; a < 16; a++ )
            {
                channel[0].coEfficients[a] = ( s16 )be16inc( in_ptr );
            }
            if ( channelCount == 2 )
            {
                in_ptr += 16;               // skip 16 byte
                for ( int a = 0; a < 16; a++ )
                {
                    channel[1].coEfficients[a] = ( s16 )be16inc( in_ptr );
                }
            }
            channel[0].Reset();
            channel[1].Reset();
            currentBlockPos = 14;
        }
    public:
        ~GuiSoundDecoderBNS()
        {
            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 > 4 && snd[0] == 'B' && snd[1] == 'N' && snd[2] == 'S' && snd[3] == ' ' )
                return new GuiSoundDecoderBNS( snd, len, snd_is_allocated );
            return NULL;
        }
        s32 GetFormat()
        {
            return channelCount == 2 ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT;
        }
        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 )
        {
            is_running = true;
            u8 *write_pos = buffer;
            u8 *write_end = buffer + buffer_size;

            for ( ;; )
            {
                if ( currentBlockPos >= 14 )
                {
                    int Offset = channel[0].DecodeNextBlock();
                    if ( Offset < 0 || ( channelCount == 2 && channel[1].DecodeNextBlock() < 0 ) )
                    {
                        is_running = false;
                        return write_pos - buffer;
                    }
                    currentBlockPos = Offset;
                }
                for ( ; currentBlockPos < 14; ++currentBlockPos )
                {
                    if ( write_pos >= write_end )
                    {
                        is_running = false;
                        return write_pos - buffer;
                    }
                    *( ( s16* )write_pos ) = channel[0].pcm[currentBlockPos];
                    write_pos += 2;
                    if ( channelCount == 2 ) // stereo
                    {
                        *( ( s16* )write_pos ) = channel[1].pcm[currentBlockPos];
                        write_pos += 2;
                    }
                }
            }
            is_running = false;
            return 0;
        }
        int Rewind()
        {
            channel[0].Reset();
            channel[1].Reset();
            currentBlockPos = 14;
            return 0;
        }
    private:
        const u8        *sound;
        bool            is_allocated;
        bool            is_running;
        chanel_t        channel[2];
        u16             currentBlockPos;
        u16             channelCount;
        u32             sampleRate;
//  u16             loopOffset;
//  u16             bytePerSample;
//  const u8        *soundDataStart;
//  const u8        *soundDataEnd;
//  u32             soundDataLen;
};
REGISTER_GUI_SOUND_DECODER( GuiSoundDecoderBNS );