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(loopStart > startPos && 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;
	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++;

		in_ptr++;						// u8 loopFlag		= *in_ptr++;
		
		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);