usbloadergx/source/libwiigui/gui_sound_decoder_ogg.cpp

/****************************************************************************
 * libwiigui
 *
 * Tantric 2009
 *
 * gui_sound_plugin_ogg.cpp
 *
 * by ardi 2009
 *
 * Decoder for ogg-vorbis with libtremor
 *
 * GUI class definitions
 ***************************************************************************/

#include <unistd.h>
#include <asndlib.h>
#include <tremor/ivorbiscodec.h>
#include <tremor/ivorbisfile.h>
#include <string.h>

#include "gui_sound_decoder.h"

/* functions to read the Ogg file from memory */

static struct
{
	char *mem;
	int size;
	int pos;
} file[4];

static int f_read(void * punt, int bytes, int blocks, int *f)
{
	int b;
	int c = 0;
	int d;

	if (bytes * blocks <= 0)
		return 0;

	blocks *= bytes;

	while (blocks > 0)
	{
		b = blocks;
		if (b > 4096)
			b = 4096;

		d = (*f) - 0x666;
		if((unsigned)(d) <= (0x669 - 0x666))
		{
			if (file[d].size == 0)
				return -1;
			if ((file[d].pos + b) > file[d].size)
				b = file[d].size - file[d].pos;
			if (b > 0)
			{
				memcpy(punt, file[d].mem + file[d].pos, b);
				file[d].pos += b;
			}
		}
		else
			b = read(*f, ((char *) punt) + c, b);

		if (b <= 0)
		{
			return c / bytes;
		}
		c += b;
		blocks -= b;
	}
	return c / bytes;
}

static int f_seek(int *f, ogg_int64_t offset, int mode)
{
	if(f==NULL) return(-1);

	int k;
	mode &= 3;

	int d = (*f) - 0x666;
	if((unsigned)(d) <= (0x669 - 0x666))
	{
		k = 0;

		if (file[d].size == 0)
			return -1;

		if (mode == 0)
		{
			if ((offset) >= file[d].size)
			{
				file[d].pos = file[d].size;
				k = -1;
			}
			else if ((offset) < 0)
			{
				file[d].pos = 0;
				k = -1;
			}
			else
				file[d].pos = offset;
		}
		else if (mode == 1)
		{
			if ((file[d].pos + offset) >= file[d].size)
			{
				file[d].pos = file[d].size;
				k = -1;
			}
			else if ((file[d].pos + offset) < 0)
			{
				file[d].pos = 0;
				k = -1;
			}
			else
				file[d].pos += offset;
		}
		else if (mode == 2)
		{

			if ((file[d].size + offset) >= file[d].size)
			{
				file[d].pos = file[d].size;
				k = -1;
			}
			else if ((file[d].size + offset) < 0)
			{
				file[d].pos = 0;
				k = -1;
			}
			else
				file[d].pos = file[d].size + offset;
		}

	}
	else
		k = lseek(*f, (int) offset, mode);

	if (k < 0)
		k = -1;
	else
		k = 0;
	return k;
}

static int f_close(int *f)
{
	int d = (*f) - 0x666;
	if((unsigned)(d) <= (0x669 - 0x666))
	{
		file[d].size = 0;
		file[d].pos = 0;
		if (file[d].mem)
		{
			file[d].mem = (char *) 0;
		}
		return 0;
	}
	else
		return close(*f);
	return 0;
}

static long f_tell(int *f)
{
	int k;

	int d = (*f) - 0x666;
	if((unsigned)(d) <= (0x669 - 0x666))
	{
		k = file[d].pos;
	}
	else
		k = lseek(*f, 0, 1);

	return (long) k;
}

static int mem_open(char * ogg, int size)
{
	static int one = 1;
	int n;
	if (one)
	{
		one = 0;

		file[0].size = 0;
		file[1].size = 0;
		file[2].size = 0;
		file[3].size = 0;
		file[0].mem = ogg;
		file[0].size = size;
		file[0].pos = 0;
		return (0x666);
	}

	for (n = 0; n < 4; n++)
	{
		if (file[n].size == 0)
		{
			file[n].mem = ogg;
			file[n].size = size;
			file[n].pos = 0;
			return (0x666 + n);
		}
	}
	return -1;
}

static int mem_close(int fd)
{
	if((unsigned)((fd) - 0x666) <= (0x669 - 0x666)) // it is a memory file descriptor?
	{
		fd -= 0x666;
		file[fd].size = 0;
		return 0;
	}
	else
		return f_close(&fd);
}

static ov_callbacks callbacks = {
	(size_t (*)(void *, size_t, size_t, void *))  f_read,
	(int (*)(void *, ogg_int64_t, int))           f_seek,
	(int (*)(void *))                             f_close,
	(long (*)(void *))                            f_tell
};

class GuiSoundDecoderOGG : public GuiSoundDecoder
{
protected:
	GuiSoundDecoderOGG(const u8 * snd, u32 len, bool snd_is_allocated)
	{
		sound			= snd;
		is_allocated	= snd_is_allocated;
		ogg_fd			= mem_open((char *)snd, len);
		if(ogg_fd < 0) throw("mem open failed");

		if (ov_open_callbacks((void*)&ogg_fd, &ogg_file, NULL, 0, callbacks) < 0)
		{
			mem_close(ogg_fd); 
			throw("ogg open failed");
		}
		ogg_info		= ov_info(&ogg_file, -1);
		bitstream		= 0;
		is_running	= false;
    }
public:
	~GuiSoundDecoderOGG()
	{
		while(is_running) usleep(50);
		ov_clear(&ogg_file);
		if(is_allocated) delete [] sound;
	}
	static GuiSoundDecoder *Create(const u8 * snd, u32 len, bool snd_is_allocated)
	{
		if(snd && len>4 && snd[0]=='O' && snd[1]=='g' && snd[2]=='g' && snd[3]=='S')
			return new GuiSoundDecoderOGG(snd, len, snd_is_allocated);
		return NULL;
	}
	s32 GetFormat()
	{
		return ogg_info->channels==2 ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT;
	}
	s32 GetSampleRate()
	{
		return ogg_info->rate;
	}
	/*  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;
		int ret = ov_read(&ogg_file, (char *)buffer, buffer_size, &bitstream);
		if (ret < 0) 
		{
			/* error in the stream.  Not a problem, just reporting it in
			 case we (the app) cares.  In this case, we don't. */
			if (ret != OV_HOLE)
				ret = 0; // we says EOF
		}
		is_running = false;
		return ret;
	}
	int Rewind()
	{
		return ov_time_seek(&ogg_file, 0);	
	}
private:
	const u8		*sound;
	bool			is_allocated;
	int				ogg_fd;
	OggVorbis_File	ogg_file;
	vorbis_info		*ogg_info;
	int				bitstream;
	bool			is_running;
};
REGISTER_GUI_SOUND_DECODER(GuiSoundDecoderOGG);