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);