usbloadergx/source/libwiigui/gui_sound_decoder_mpg.cpp

/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_sound_plugin_mpg.cpp
 *
 * by ardi 2009
 *
 * Decoder for MPEG-Audio Mpeg-1/-2 Layer I,II and III with libmad
 *
 * GUI class definitions
 ***************************************************************************/

#include <unistd.h>
#include <limits.h>
#include <asndlib.h>
#include <mad.h>
#include <string.h>
#include <new>


#include "gui_sound_decoder.h"

static inline s16 FixedToShort(mad_fixed_t Fixed) {
    /* Clipping */
    if (Fixed>=MAD_F_ONE)
        return(SHRT_MAX);
    if (Fixed<=-MAD_F_ONE)
        return(-SHRT_MAX);

    Fixed=Fixed>>(MAD_F_FRACBITS-15);
    return((s16)Fixed);
}

#define ADMA_BUFFERSIZE			(8192)
#define DATABUFFER_SIZE			(32768)
// http://www.fr-an.de/fragen/v06/02_01.htm


class GuiSoundDecoderMPG : public GuiSoundDecoder {
protected:
    GuiSoundDecoderMPG(const u8 * snd, u32 len, bool snd_is_allocated) {
        sound			= snd;
        length			= len;
        is_allocated	= snd_is_allocated;
        // Init mad-structures
        mad_stream_init(&madStream);
        mad_stream_buffer(&madStream, sound, length);
        mad_frame_init(&madFrame);
        mad_synth_init(&madSynth);
        madSynthPcmPos = 0;
        mad_timer_reset(&madTimer);
        guardBuffer	= NULL;
        is_running = false;

        // decode first Frame
        if (DecodeFirstFrame()) {
            mad_synth_finish(&madSynth);
            mad_frame_finish(&madFrame);
            mad_stream_finish(&madStream);
            throw("Stream Error");
        }
    }
public:
    ~GuiSoundDecoderMPG() {
        while (is_running) usleep(50);
        mad_synth_finish(&madSynth);
        mad_frame_finish(&madFrame);
        mad_stream_finish(&madStream);
        delete [] guardBuffer;
        if (is_allocated) delete [] sound;
    }
    static GuiSoundDecoder *Create(const u8 * snd, u32 len, bool snd_is_allocated) {
        struct mad_stream	madStream;
        struct mad_header madHeader;
        mad_stream_init(&madStream);
        mad_stream_buffer(&madStream, snd, len);
        mad_header_init(&madHeader);
        s32 ret = mad_header_decode(&madHeader, &madStream);
        if (ret == 0 || madStream.error==MAD_ERROR_LOSTSYNC) { // LOSTSYNC in first call is ok
            int i;
            for (i=0; i<4 && mad_header_decode(&madHeader, &madStream)==0; i++);
            if ( i == 4 ) {
                mad_header_finish(&madHeader);
                mad_stream_finish(&madStream);
                return new GuiSoundDecoderMPG(snd, len, snd_is_allocated);
            }
        }
        mad_header_finish(&madHeader);
        mad_stream_finish(&madStream);
        return NULL;
    }
    s32 GetFormat() {
        return MAD_NCHANNELS(&madFrame.header)==2 ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT;
    }
    s32 GetSampleRate() {
        return madFrame.header.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;
        if (MAD_NCHANNELS(&madFrame.header)==2) // stereo
            buffer_size &= ~0x0003; // make size to a kind of 4
        else
            buffer_size &= ~0x0001; // make size to a kind of 2
        u8 *write_pos = buffer;
        u8 *write_end = buffer+buffer_size;

        for (;;) {
            for (;madSynthPcmPos < madSynth.pcm.length; ++madSynthPcmPos) {
                if (write_pos >= write_end) {
                    is_running = false;
                    return write_pos-buffer;
                }
                *((s16*)write_pos) = FixedToShort(madSynth.pcm.samples[0][madSynthPcmPos]);
                write_pos+=2;
                if (MAD_NCHANNELS(&madFrame.header)==2) { // stereo
                    *((s16*)write_pos) = FixedToShort(madSynth.pcm.samples[1][madSynthPcmPos]);
                    write_pos+=2;
                }
            }

            madStream.error = MAD_ERROR_NONE;
            if (mad_frame_decode(&madFrame,&madStream)) {
                if (MAD_RECOVERABLE(madStream.error)) {
                    if (madStream.error!=MAD_ERROR_LOSTSYNC || !guardBuffer)
                        continue;
                } else if (madStream.error==MAD_ERROR_BUFLEN) {
                    if (!guardBuffer) {
                        u32 guardLen = (madStream.bufend-madStream.next_frame);
                        guardBuffer = new(std::nothrow) u8[guardLen + MAD_BUFFER_GUARD];
                        if (guardBuffer) {
                            memcpy(guardBuffer, madStream.next_frame, guardLen);
                            memset(guardBuffer+guardLen, 0, MAD_BUFFER_GUARD);
                            mad_stream_buffer(&madStream, guardBuffer, guardLen + MAD_BUFFER_GUARD);
                            continue;
                        }
                    }
                }
                break;
            }
            mad_timer_add(&madTimer,madFrame.header.duration);
            mad_synth_frame(&madSynth,&madFrame);
            madSynthPcmPos = 0;
        }
        is_running = false;
        return write_pos-buffer;
    }
    int Rewind() {
        while (is_running) usleep(50);
        delete [] guardBuffer;
        guardBuffer = NULL;
        mad_stream_buffer(&madStream, sound, length);
        mad_synth_finish(&madSynth);
        mad_synth_init(&madSynth);
        madSynthPcmPos = 0;
        mad_timer_reset(&madTimer);
        // decode first Frame
        return DecodeFirstFrame();
    }
private:
    int DecodeFirstFrame() {
        for (;;) {
            madStream.error = MAD_ERROR_NONE;
            if (mad_frame_decode(&madFrame,&madStream)) {
                if (MAD_RECOVERABLE(madStream.error))
                    continue;
                else
                    return -1;
            }
            mad_timer_add(&madTimer,madFrame.header.duration);
            mad_synth_frame(&madSynth,&madFrame);
            return 0;
        }
    }
    const u8			*sound;
    u32					length;
    bool				is_allocated;
    struct mad_stream	madStream;
    struct mad_frame	madFrame;
    struct mad_synth	madSynth;
    u16					madSynthPcmPos;
    mad_timer_t			madTimer;
    u8					*guardBuffer;
    bool				is_running;
};
REGISTER_GUI_SOUND_DECODER(GuiSoundDecoderMPG);