diff --git a/source/ngc/gui.cpp b/source/ngc/gui.cpp
new file mode 100644
index 0000000..20aaace
--- /dev/null
+++ b/source/ngc/gui.cpp
@@ -0,0 +1,529 @@
+#include <gccore.h>
+#include <ogcsys.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wiiuse/wpad.h>
+#include <malloc.h>
+
+#include <pngu/pngu.h>
+#include <ft2build.h>
+#include <zlib.h>
+#include FT_FREETYPE_H
+
+#include "video.h"
+#include "snes9xGX.h"
+#include "gui.h"
+
+struct sGui Gui;
+
+GXTexObj texobj_BG, texobj_MENU;
+u8 texdata_bg[640 * 480 * 4] ATTRIBUTE_ALIGN (32);	// stores the blended menu backdrop
+u8 texdata_menu[640 * 480 * 4] ATTRIBUTE_ALIGN (32);	// stores the menu overlay
+
+extern GXTexObj texobj;
+extern int vwidth, vheight;
+extern s16 square[];
+extern Mtx view;
+extern int whichfb;
+extern unsigned int copynow;
+extern int screenheight;
+extern unsigned int *xfb[2];
+extern GXRModeObj *vmode;
+
+extern FT_Library ftlibrary;
+extern FT_Face face;
+extern FT_GlyphSlot slot;
+extern FT_UInt glyph_index;
+
+extern int WaitButtonAB ();
+
+
+// MAIN
+
+static void
+draw_vert (u8 pos, u8 c, f32 s, f32 t)
+{
+	GX_Position1x8 (pos);
+	GX_Color1x8 (c);
+	GX_TexCoord2f32 (s, t);
+}
+
+static void
+draw_square (Mtx v)
+{
+	Mtx m;			// model matrix.
+	Mtx mv;			// modelview matrix.
+
+	guMtxIdentity (m);
+	guMtxTransApply (m, m, 0, 0, -100);
+	guMtxConcat (v, m, mv);
+
+	GX_LoadPosMtxImm (mv, GX_PNMTX0);
+	GX_Begin (GX_QUADS, GX_VTXFMT0, 4);
+	draw_vert (0, 0, 0.0, 0.0);
+	draw_vert (1, 0, 1.0, 0.0);
+	draw_vert (2, 0, 1.0, 1.0);
+	draw_vert (3, 0, 0.0, 1.0);
+	GX_End ();
+}
+
+void
+gui_alphasetup ()
+{
+	GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+	GX_SetAlphaUpdate(GX_ENABLE);
+}
+
+/****************************************************************************
+* make BG
+*
+* Blend the last rendered emulator screen and the menu backdrop.
+* Save this as a texture to be loaded later 
+ ****************************************************************************/
+void
+gui_makebg ()
+{
+	IMGCTX ctx;
+	PNGUPROP imgProp;
+	
+	/** Load menu backdrop (either from file or buffer) **/
+	
+	ctx = PNGU_SelectImageFromDevice ("bg.png");
+	PNGU_GetImageProperties (ctx, &imgProp);
+	// can check image dimensions here
+	//texdata_bg = memalign (32, imgProp.imgWidth * imgProp.imgHeight * 4);
+	GX_InitTexObj (&texobj_BG, &texdata_bg, 640, 480, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
+	//PNGU_DecodeTo4x4RGBA8 (ctx, imgProp.imgWidth, imgProp.imgHeight, &texdata_bg, 255);
+	PNGU_DecodeToRGBA8 (ctx, 640, 480, Gui.texmem, 0, 7);
+	Make_Texture_RGBA8 (&texdata_bg, Gui.texmem, 640, 480);
+	PNGU_ReleaseImageContext (ctx);
+	DCFlushRange (&texdata_bg, imgProp.imgWidth * imgProp.imgHeight * 4);
+	
+	/*
+	texdata_bg = memalign (32, 640 * 480 * 4);
+	#ifdef HW_RVL
+	// on wii copy from memory
+	memcpy (texdata_bg, (char *) backdrop, 640 * 480 * 2);
+	#else
+	// on gc copy from aram
+	ARAMFetch (texdata_bg, (char *) AR_BACKDROP, 640 * 480 * 2);
+	#endif
+	*/
+
+	/** blend last rendered snes frame and menu backdrop **/
+	
+	// draw 640x480 quads
+	int xscale, yscale, xshift, yshift;
+	xshift = yshift = 0;
+	xscale = 320;
+	yscale = 240;
+	square[6] = square[3]  =  xscale + xshift;
+	square[0] = square[9]  = -xscale + xshift;
+	square[4] = square[1]  =  yscale + yshift;
+	square[7] = square[10] = -yscale + yshift;
+	
+	// draw 2 quads
+	
+	GX_InvalidateTexAll ();
+	
+	// behind (last snes frame)
+	square[2] = square[5] = square[8] = square[11] = 0;	// z value
+	GX_InvVtxCache ();
+	GX_LoadTexObj (&texobj, GX_TEXMAP0);	// load last rendered snes frame
+	draw_square (view);
+	
+	// in front (menu backdrop)
+	square[2] = square[5] = square[8] = square[11] = 1;	// z value
+	GX_InvVtxCache ();
+	GX_LoadTexObj (&texobj_BG, GX_TEXMAP0);
+	draw_square (view);
+
+	GX_DrawDone ();
+	
+	/* DEBUG -----------
+	// show the output
+	VIDEO_SetNextFramebuffer (xfb[whichfb]);
+	VIDEO_Flush ();
+	copynow = GX_TRUE;
+	#ifdef VIDEO_THREADING
+	// Return to caller, don't waste time waiting for vb
+	LWP_ResumeThread (vbthread);
+	#endif
+	WaitButtonAB();
+	*/
+	
+	// load blended image from efb to a texture
+	GX_InitTexObj (&texobj_BG, &texdata_bg, 640, 480, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
+	GX_SetTexCopySrc ( 0,0,640,480 );
+	GX_SetTexCopyDst ( 640, 480, GX_TF_RGBA8, 0 );
+	GX_CopyTex (&texdata_bg, 0);	// assuming that the efb is 640x480, which it should be
+	GX_PixModeSync ();	// wait until copy has completed
+	DCFlushRange (&texdata_bg, 640 * 480 * 4);
+	
+	
+	square[2] = square[5] = square[8] = square[11] = 0; 	// reset z value
+	GX_InvVtxCache ();
+}
+
+void
+gui_clearscreen ()
+{
+	whichfb ^= 1;
+	VIDEO_ClearFrameBuffer (vmode, xfb[whichfb], COLOR_BLACK);
+	memset ( Gui.texmem, 0, sizeof(Gui.texmem) );
+	Gui.fontcolour = 0;
+}
+
+void
+gui_draw ()
+{
+	gui_drawbox (0, 0, 640, 80, 255, 255, 255, 128);	// topbar
+	gui_drawbox (0, 370, 640, 480, 255, 255, 255, 128);	// bottombar
+	gui_setfontcolour (0,255,0,255);
+	// top bar text
+	setfontsize (32);	// 32/24 depending on whether selected or not
+	gui_DrawText (-1, 113, (char *)"Hello World");
+	// main text
+	setfontsize (24);	
+	gui_DrawText (-1, 113, (char *)"Hello World");
+}
+
+void
+gui_savescreen ()
+{
+	FILE* handle;
+	handle = fopen ("out.txt", "wb");
+	fwrite (Gui.texmem, 1, sizeof(Gui.texmem), handle);
+	fclose (handle);
+	
+	printf("\nsaved screen.");
+}
+
+void
+gui_showscreen ()
+{
+
+	/** Screen to Texture **/
+	
+	GX_InitTexObj (&texobj_MENU, texdata_menu, 640, 480, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
+	Make_Texture_RGBA8 (texdata_menu, Gui.texmem, 640, 480);
+	DCFlushRange (&texdata_menu, 640 * 480 * 4);
+	
+	GX_InvalidateTexAll ();
+
+	/** thats nice, but will it blend? **/
+	
+	// draw 640x480 quads
+	int xscale, yscale, xshift, yshift;
+	xshift = yshift = 0;
+	xscale = 320;
+	yscale = 240;
+	square[6] = square[3]  =  xscale + xshift;
+	square[0] = square[9]  = -xscale + xshift;
+	square[4] = square[1]  =  yscale + yshift;
+	square[7] = square[10] = -yscale + yshift;
+	
+	// draw 2 quads
+	
+	// backdrop
+	square[2] = square[5] = square[8] = square[11] = 0;	// z value
+	GX_InvVtxCache ();
+	GX_LoadTexObj (&texobj_BG, GX_TEXMAP0);
+	draw_square (view);
+	
+	// menu overlay
+	square[2] = square[5] = square[8] = square[11] = 1;	// z value
+	GX_InvVtxCache ();
+	GX_LoadTexObj (&texobj_MENU, GX_TEXMAP0);
+	draw_square (view);
+	
+	GX_DrawDone ();
+	
+	/** Display **/
+	
+	// show the output
+	VIDEO_SetNextFramebuffer (xfb[whichfb]);
+	VIDEO_Flush ();
+	copynow = GX_TRUE;
+	#ifdef VIDEO_THREADING
+	/* Return to caller, don't waste time waiting for vb */
+	LWP_ResumeThread (vbthread);
+	#endif
+	WaitButtonAB();
+
+	square[2] = square[5] = square[8] = square[11] = 0;	// z value
+	GX_InvVtxCache ();
+}
+
+/****************************************************************************
+* Make Texture RGBA8
+* 
+* input: pointer to RGBA data
+* output: formatted texture data (GX_TF_RGBA8)
+* code modified from quake wii (thanks :)
+* todo: fix last few lines (?)
+ ****************************************************************************/
+void 
+Make_Texture_RGBA8 (void * dst_tex, void * src_data, int width, int height)
+{
+	if ( (width % 4) || (height % 4) ) {
+		printf ("Error: make_texture_rgba8 width/height not multiple of 4");
+		return;
+	}
+	
+	int i, x, y;
+	u8 *pos;
+
+	pos = (u8 *)dst_tex;
+	for (y = 0; y < height; y += 4)	// process 4 lines at a time to make rows of tiles
+	{
+		u8* row1 = (u8 *) src_data;
+		u8* row2 = (u8 *) src_data;
+		u8* row3 = (u8 *) src_data;
+		u8* row4 = (u8 *) src_data;
+		row1 += width * 4 * (y + 0);	// move 640 pixels x 4 bytes * line #
+		row2 += width * 4 * (y + 1);
+		row3 += width * 4 * (y + 2);
+		row4 += width * 4 * (y + 3);
+
+		for (x = 0; x < width; x += 4)	// move across 4 pixels per tile
+		{
+			u8 AR[32];
+			u8 GB[32];
+
+			for (i = 0; i < 4; i++)	// save those 4 pixels of data in texture format
+			{
+				u8* ptr1 = &(row1[(x + i) * 4]);	// start at beginning of a row
+				u8* ptr2 = &(row2[(x + i) * 4]);	// move across (4 pixels per tile + pixel offset within tile) * 4 bytes per pixel
+				u8* ptr3 = &(row3[(x + i) * 4]);
+				u8* ptr4 = &(row4[(x + i) * 4]);
+
+				AR[(i * 2) +  0] = ptr1[3];		// fill columns of tile with rgba data
+				AR[(i * 2) +  1] = ptr1[0];
+				AR[(i * 2) +  8] = ptr2[3];
+				AR[(i * 2) +  9] = ptr2[0];
+				AR[(i * 2) + 16] = ptr3[3];
+				AR[(i * 2) + 17] = ptr3[0];
+				AR[(i * 2) + 24] = ptr4[3];
+				AR[(i * 2) + 25] = ptr4[0];
+
+				GB[(i * 2) +  0] = ptr1[1];
+				GB[(i * 2) +  1] = ptr1[2];
+				GB[(i * 2) +  8] = ptr2[1];
+				GB[(i * 2) +  9] = ptr2[2];
+				GB[(i * 2) + 16] = ptr3[1];
+				GB[(i * 2) + 17] = ptr3[2];
+				GB[(i * 2) + 24] = ptr4[1];
+				GB[(i * 2) + 25] = ptr4[2];
+			}
+
+			memcpy(pos, AR, sizeof(AR));	// copy over to resulting texture
+			pos += sizeof(AR);
+			memcpy(pos, GB, sizeof(GB));
+			pos += sizeof(GB);
+		}
+	}
+
+}
+
+void
+gui_drawbox (int x1, int y1, int width, int height, int r, int g, int b, int a)
+{
+	u32 colour = ((u8)r << 24) | ((u8)g << 16) | ((u8)b << 8) | (u8)a;
+	
+	int i, j;
+	
+	u32* memory = (u32*) Gui.texmem;
+	for (j = y1; j<height; j++) {
+		for (i = x1; i<width; i++) {
+			memory[(j*640) + i] = colour;
+		}
+	}
+}
+
+/****************************************************************************
+* DrawCharacter
+* Draws a single character on the screen
+ ****************************************************************************/
+static void
+gui_DrawCharacter (FT_Bitmap * bmp, FT_Int x, FT_Int y)
+{
+	FT_Int i, j, p, q;
+	FT_Int x_max = x + bmp->width;
+	FT_Int y_max = y + bmp->rows;
+	int c;
+
+	u32* memory = (u32*)Gui.texmem;
+	for (i = x, p = 0; i < x_max; i++, p++)
+	{
+		for (j = y, q = 0; j < y_max; j++, q++)
+		{
+			if (i < 0 || j < 0 || i >= 640 || j >= 480)
+				continue;
+
+			c = bmp->buffer[q * bmp->width + p];
+
+			/*** Cool Anti-Aliasing doesn't work too well at hires on GC ***/
+			if (c > 128)
+				memory[(j * 640) + i] = Gui.fontcolour;
+		}
+	}
+}
+
+/****************************************************************************
+ * DrawText
+ *
+ * Place the font bitmap on the screen
+ ****************************************************************************/
+void
+gui_DrawText (int x, int y, char *text)
+{
+	int px, n;
+	int i;
+	int err;
+	int value, count;
+
+	n = strlen (text);
+	if (n == 0)
+		return;
+
+	/*** x == -1, auto centre ***/
+	if (x == -1)
+	{
+		value = 0;
+		px = 0;
+	}
+	else
+	{
+		value = 1;
+		px = x;
+	}
+
+	for (count = value; count < 2; count++)
+	{
+		/*** Draw the string ***/
+		for (i = 0; i < n; i++)
+		{
+			err = FT_Load_Char (face, text[i], FT_LOAD_RENDER);
+
+			if (err)
+			{
+				printf ("Error %c %d\n", text[i], err);
+				continue;				/*** Skip unprintable characters ***/
+			}
+
+			if (count)
+				gui_DrawCharacter (&slot->bitmap, px + slot->bitmap_left, y - slot->bitmap_top);
+
+			px += slot->advance.x >> 6;
+		}
+
+		px = (640 - px) >> 1;
+
+	}
+}
+
+/****************************************************************************
+ * setfontcolour
+ *
+ * Uses RGB triple values.
+ ****************************************************************************/
+void
+gui_setfontcolour (int r, int g, int b, int a)
+{
+	Gui.fontcolour = ((u8)r << 24) | ((u8)g << 16) | ((u8)b << 8) | (u8)a;
+}
+
+/****************************************************************************
+ * DrawLine
+ *
+ * Quick'n'Dirty Bresenham line drawing routine.
+ ****************************************************************************/
+#define SIGN(x) ((x<0)?-1:((x>0)?1:0))
+
+void
+gui_DrawLine (int x1, int y1, int x2, int y2, int r, int g, int b, int a)
+{
+	u32 colour;
+	int i, dx, dy, sdx, sdy, dxabs, dyabs, x, y, px, py;
+	int sp;
+	
+	u32* memory = (u32*)Gui.texmem;
+
+	colour = ((u8)r << 24) | ((u8)g << 16) | ((u8)b << 8) | (u8)a;
+
+	dx = x2 - x1;		/*** Horizontal distance ***/
+	dy = y2 - y1;		/*** Vertical distance ***/
+
+	dxabs = abs (dx);
+	dyabs = abs (dy);
+	sdx = SIGN (dx);
+	sdy = SIGN (dy);
+	x = dyabs >> 1;
+	y = dxabs >> 1;
+	px = x1;
+	py = y1;
+
+	sp = (py * 640) + px;
+	
+	/*** Plot this pixel ***/
+	memory[sp] = colour;
+
+	if (dxabs >= dyabs)		/*** Mostly horizontal ***/
+	{
+		for (i = 0; i < dxabs; i++)
+		{
+			y += dyabs;
+			if (y >= dxabs)
+			{
+				y -= dxabs;
+				py += sdy;
+			}
+
+			px += sdx;
+			sp = (py * 640) + px;
+			memory[sp] = colour;
+		}
+	}
+	else
+	{
+		for (i = 0; i < dyabs; i++)
+		{
+			x += dxabs;
+			if (x >= dyabs)
+			{
+				x -= dyabs;
+				px += sdx;
+			}
+
+			py += sdy;
+			sp = (py * 640) + px;
+			memory[sp] = colour;
+		}
+	}
+}
+
+/* */
+
+	/**  draw menu, etc **/ 
+		// - draw topbar, bottombar
+		// - draw icons
+		// - draw bar text
+		
+		// draw main text
+	
+	/** make textures **/
+		// - load background texture
+		// - draw onto quad
+		// - make foreground texture
+		// - draw onto quad
+	
+	/** render image **/
+	
+	/** update framebuffer **/
+
+/* */
+
+// EOF
diff --git a/source/ngc/gui.h b/source/ngc/gui.h
new file mode 100644
index 0000000..41d6479
--- /dev/null
+++ b/source/ngc/gui.h
@@ -0,0 +1,36 @@
+#ifndef __GUI_H__
+#define __GUI_H__
+
+#include <gccore.h>
+
+
+struct sGui {
+	u8 texmem[640 * 480 * 4] ATTRIBUTE_ALIGN (32);	// rgba8 - working draw area
+	int currmenu;
+	int prevmenu;
+	u32 fontcolour;
+	int screenheight;
+};
+
+extern struct sGui Gui;
+
+// Prototypes
+void gui_alphasetup ();
+void gui_makebg ();
+void Make_Texture_RGBA8 (void * dst_tex, void * src_data, int width, int height);
+void gui_drawbox (int x1, int y1, int width, int height, int r, int g, int b, int a);
+void gui_DrawText (int x, int y, char *text);
+void gui_setfontcolour (int r, int g, int b, int a);
+void gui_DrawLine (int x1, int y1, int x2, int y2, int r, int g, int b, int a);
+void gui_clearscreen ();
+void gui_draw ();
+void gui_showscreen ();
+
+void gui_savescreen ();
+
+// external functions
+extern void setfontsize (int pixelsize);
+
+
+#endif
+
diff --git a/source/ngc/pngu.c b/source/ngc/pngu.c
new file mode 100644
index 0000000..c82a41a
--- /dev/null
+++ b/source/ngc/pngu.c
@@ -0,0 +1,1132 @@
+/********************************************************************************************
+
+PNGU Version : 0.2a
+
+Coder : frontier
+
+More info : http://frontier-dev.net
+
+********************************************************************************************/
+#include <stdio.h>
+#include <malloc.h>
+#include <pngu/pngu.h>
+#include <png.h>
+
+
+// Constants
+#define PNGU_SOURCE_BUFFER			1
+#define PNGU_SOURCE_DEVICE			2
+
+
+// Prototypes of helper functions
+int pngu_info (IMGCTX ctx);
+int pngu_decode (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stripAlpha);
+void pngu_free_info (IMGCTX ctx);
+void pngu_read_data_from_buffer (png_structp png_ptr, png_bytep data, png_size_t length);
+void pngu_write_data_to_buffer (png_structp png_ptr, png_bytep data, png_size_t length);
+void pngu_flush_data_to_buffer (png_structp png_ptr);
+int pngu_clamp (int value, int min, int max);
+
+
+// PNGU Image context struct
+struct _IMGCTX
+{
+	int source;
+	void *buffer;
+	char *filename;
+	PNGU_u32 cursor;
+
+	PNGU_u32 propRead;
+	PNGUPROP prop;
+
+	PNGU_u32 infoRead;
+	png_structp png_ptr;
+	png_infop info_ptr;
+	FILE *fd;
+	
+	png_bytep *row_pointers;
+	png_bytep img_data;
+};
+
+
+// PNGU Implementation //
+
+IMGCTX PNGU_SelectImageFromBuffer (const void *buffer)
+{
+	IMGCTX ctx = NULL;
+
+	if (!buffer)
+		return NULL;
+
+	ctx = malloc (sizeof (struct _IMGCTX));
+	if (!ctx)
+		return NULL;
+
+	ctx->buffer = (void *) buffer;
+	ctx->source = PNGU_SOURCE_BUFFER;
+	ctx->cursor = 0;
+	ctx->filename = NULL;
+	ctx->propRead = 0;
+	ctx->infoRead = 0;
+
+	return ctx;
+}
+
+
+IMGCTX PNGU_SelectImageFromDevice (const char *filename)
+{
+	IMGCTX ctx = NULL;
+
+	if (!filename)
+		return NULL;
+
+	ctx = malloc (sizeof (struct _IMGCTX));
+	if (!ctx)
+		return NULL;
+
+	ctx->buffer = NULL;
+	ctx->source = PNGU_SOURCE_DEVICE;
+	ctx->cursor = 0;
+
+	ctx->filename = malloc (strlen (filename) + 1);
+	if (!ctx->filename)
+	{
+		free (ctx);
+		return NULL;
+	}
+	strcpy(ctx->filename, filename);
+
+	ctx->propRead = 0;
+	ctx->infoRead = 0;
+
+	return ctx;
+}
+
+
+void PNGU_ReleaseImageContext (IMGCTX ctx)
+{
+	if (!ctx)
+		return;
+
+	if (ctx->filename)
+		free (ctx->filename);
+
+	if ((ctx->propRead) && (ctx->prop.trans))
+		free (ctx->prop.trans);
+
+	pngu_free_info (ctx);
+
+	free (ctx);
+}
+
+
+int PNGU_GetImageProperties (IMGCTX ctx, PNGUPROP *imgprop)
+{
+	int res;
+
+	if (!ctx->propRead)
+	{
+		res = pngu_info (ctx);
+		if (res != PNGU_OK)
+			return res;
+	}
+
+	*imgprop = ctx->prop;
+
+	return PNGU_OK;
+}
+
+
+int PNGU_DecodeToYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
+{
+	int result;
+	PNGU_u32 x, y, buffWidth;
+
+	// width needs to be divisible by two
+	if (width % 2)
+		return PNGU_ODD_WIDTH;
+
+	// stride needs to be divisible by two
+	if (stride % 2)
+		return PNGU_ODD_STRIDE;
+
+	result = pngu_decode (ctx, width, height, 1);
+	if (result != PNGU_OK)
+		return result;
+
+	// Copy image to the output buffer
+	buffWidth = (width + stride) / 2;
+	for (y = 0; y < height; y++)
+		for (x = 0; x < (width / 2); x++)
+			((PNGU_u32 *)buffer)[y*buffWidth+x] = PNGU_RGB8_TO_YCbYCr (*(ctx->row_pointers[y]+x*6), *(ctx->row_pointers[y]+x*6+1), *(ctx->row_pointers[y]+x*6+2),
+															*(ctx->row_pointers[y]+x*6+3), *(ctx->row_pointers[y]+x*6+4), *(ctx->row_pointers[y]+x*6+5));
+	
+	// Free resources
+	free (ctx->img_data);
+	free (ctx->row_pointers);
+
+	// Success
+	return PNGU_OK;
+}
+
+
+int PNGU_DecodeToRGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
+{
+	int result;
+	PNGU_u32 x, y, buffWidth;
+	
+	result = pngu_decode (ctx, width, height, 1);
+	if (result != PNGU_OK)
+		return result;
+
+	buffWidth = width + stride;
+
+	// Copy image to the output buffer
+	for (y = 0; y < height; y++)
+		for (x = 0; x < width; x++)
+			((PNGU_u16 *)buffer)[y*buffWidth+x] = 
+				(((PNGU_u16) (ctx->row_pointers[y][x*3] & 0xF8)) << 8) | 
+				(((PNGU_u16) (ctx->row_pointers[y][x*3+1] & 0xFC)) << 3) | 
+				(((PNGU_u16) (ctx->row_pointers[y][x*3+2] & 0xF8)) >> 3);
+	
+	// Free resources
+	free (ctx->img_data);
+	free (ctx->row_pointers);
+
+	// Success
+	return PNGU_OK;
+}
+
+
+int PNGU_DecodeToRGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride, PNGU_u8 default_alpha)
+{
+	int result;
+	PNGU_u32 x, y, buffWidth;
+	
+	result = pngu_decode (ctx, width, height, 0);
+	if (result != PNGU_OK)
+		return result;
+
+	buffWidth = width + stride;
+
+	// Check is source image has an alpha channel
+	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) )
+	{
+		// Alpha channel present, copy image to the output buffer
+		for (y = 0; y < height; y++)
+			memcpy (buffer + (y * buffWidth * 4), ctx->row_pointers[y], width * 4);
+	}
+	else
+	{
+		// No alpha channel present, copy image to the output buffer
+		for (y = 0; y < height; y++)
+			for (x = 0; x < width; x++)
+				((PNGU_u32 *)buffer)[y*buffWidth+x] = 
+					(((PNGU_u32) ctx->row_pointers[y][x*3]) << 24) | 
+					(((PNGU_u32) ctx->row_pointers[y][x*3+1]) << 16) | 
+					(((PNGU_u32) ctx->row_pointers[y][x*3+2]) << 8) | 
+					((PNGU_u32) default_alpha);
+	}
+	
+	// Free resources
+	free (ctx->img_data);
+	free (ctx->row_pointers);
+
+	// Success
+	return PNGU_OK;
+}
+
+
+int PNGU_DecodeTo4x4RGB565 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer)
+{
+	int result;
+	PNGU_u32 x, y, qwidth, qheight;
+
+	// width and height need to be divisible by four
+	if ((width % 4) || (height % 4))
+		return PNGU_INVALID_WIDTH_OR_HEIGHT;
+
+	result = pngu_decode (ctx, width, height, 1);
+	if (result != PNGU_OK)
+		return result;
+
+	// Copy image to the output buffer
+	qwidth = width / 4;
+	qheight = height / 4;
+
+	for (y = 0; y < qheight; y++)
+		for (x = 0; x < qwidth; x++)
+		{
+			int blockbase = (y * qwidth + x) * 4;
+
+			PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
+			PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
+			((PNGU_u64 *) buffer)[blockbase] = 
+				(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) | 
+				(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) | 
+				(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
+				(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
+
+			field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
+			field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
+			((PNGU_u64 *) buffer)[blockbase+1] = 
+				(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) | 
+				(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) | 
+				(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
+				(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
+
+			field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
+			field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
+			((PNGU_u64 *) buffer)[blockbase+2] = 
+				(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) | 
+				(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) | 
+				(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
+				(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
+
+			field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
+			field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
+			((PNGU_u64 *) buffer)[blockbase+3] = 
+				(((field64 & 0xF800000000000000ULL) | ((field64 & 0xFC000000000000ULL) << 3) | ((field64 & 0xF80000000000ULL) << 5)) | 
+				(((field64 & 0xF800000000ULL) << 8) | ((field64 & 0xFC000000ULL) << 11) | ((field64 & 0xF80000ULL) << 13)) | 
+				(((field64 & 0xF800ULL) << 16) | ((field64 & 0xFCULL) << 19) | ((field32 & 0xF8000000ULL) >> 11)) |
+				(((field32 & 0xF80000ULL) >> 8) | ((field32 & 0xFC00ULL) >> 5) | ((field32 & 0xF8ULL) >> 3)));
+		}
+	
+	// Free resources
+	free (ctx->img_data);
+	free (ctx->row_pointers);
+
+	// Success
+	return PNGU_OK;
+}
+
+
+int PNGU_DecodeTo4x4RGB5A3 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha)
+{
+	int result;
+	PNGU_u32 x, y, qwidth, qheight;
+	PNGU_u64 alphaMask;
+
+	// width and height need to be divisible by four
+	if ((width % 4) || (height % 4))
+		return PNGU_INVALID_WIDTH_OR_HEIGHT;
+
+	result = pngu_decode (ctx, width, height, 0);
+	if (result != PNGU_OK)
+		return result;
+
+	// Init some vars
+	qwidth = width / 4;
+	qheight = height / 4;
+
+	// Check is source image has an alpha channel
+	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) )
+	{
+		// Alpha channel present, copy image to the output buffer
+		for (y = 0; y < qheight; y++)
+			for (x = 0; x < qwidth; x++)
+			{
+				int blockbase = (y * qwidth + x) * 4;
+				PNGU_u64 tmp;
+
+				PNGU_u64 fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16));
+				PNGU_u64 fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16+8));
+				// If first pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
+				if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)			
+					tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
+				else
+					tmp = ((fieldA & 0xE000000000ULL) << 23) | ((fieldA & 0xF000000000000000ULL) >> 4) | (fieldA & 0xF0000000000000ULL) | ((fieldA & 0xF00000000000ULL) << 4);
+
+				// If second pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
+				if ((fieldA & 0xE0ULL) == 0xE0ULL)
+					tmp = tmp | 0x800000000000ULL | ((fieldA & 0xF8000000ULL) << 15) | ((fieldA & 0xF80000ULL) << 18) | ((fieldA & 0xF800ULL) << 21);
+				else
+					tmp = tmp | ((fieldA & 0xE0ULL) << 39) | ((fieldA & 0xF0000000ULL) << 12) | ((fieldA & 0xF00000ULL) << 16) | ((fieldA & 0xF000ULL) << 20);
+
+				// If third pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
+				if ((fieldB & 0xE000000000ULL) == 0xE000000000ULL)
+					tmp = tmp | 0x80000000ULL | ((fieldB & 0xF800000000000000ULL) >> 33) | ((fieldB & 0xF8000000000000ULL) >> 30) | ((fieldB & 0xF80000000000ULL) >> 27);
+				else
+					tmp = tmp | ((fieldB & 0xE000000000ULL) >> 9) | ((fieldB & 0xF000000000000000ULL) >> 36) | ((fieldB & 0xF0000000000000ULL) >> 32) | ((fieldB & 0xF00000000000ULL) >> 28);
+
+				// If fourth pixel is opaque set MSB to 1 and encode colors in RGB555, else set MSB to 0 and encode colors in ARGB3444
+				if ((fieldB & 0xE0ULL) == 0xE0ULL)
+					tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
+				else
+					tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
+				((PNGU_u64 *) buffer)[blockbase] = tmp;
+
+				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16));
+				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16+8));
+				if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = ((fieldA & 0xE000000000ULL) << 23) | ((fieldA & 0xF000000000000000ULL) >> 4) | (fieldA & 0xF0000000000000ULL) | ((fieldA & 0xF00000000000ULL) << 4);
+
+				if ((fieldA & 0xE0ULL) == 0xE0ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x800000000000ULL | ((fieldA & 0xF8000000ULL) << 15) | ((fieldA & 0xF80000ULL) << 18) | ((fieldA & 0xF800ULL) << 21);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldA & 0xE0ULL) << 39) | ((fieldA & 0xF0000000ULL) << 12) | ((fieldA & 0xF00000ULL) << 16) | ((fieldA & 0xF000ULL) << 20);
+
+				if ((fieldB & 0xE000000000ULL) == 0xE000000000ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x80000000ULL | ((fieldB & 0xF800000000000000ULL) >> 33) | ((fieldB & 0xF8000000000000ULL) >> 30) | ((fieldB & 0xF80000000000ULL) >> 27);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldB & 0xE000000000ULL) >> 9) | ((fieldB & 0xF000000000000000ULL) >> 36) | ((fieldB & 0xF0000000000000ULL) >> 32) | ((fieldB & 0xF00000000000ULL) >> 28);
+
+				if ((fieldB & 0xE0ULL) == 0xE0ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
+				((PNGU_u64 *) buffer)[blockbase+1] = tmp;
+
+				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16));
+				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16+8));
+				if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = ((fieldA & 0xE000000000ULL) << 23) | ((fieldA & 0xF000000000000000ULL) >> 4) | (fieldA & 0xF0000000000000ULL) | ((fieldA & 0xF00000000000ULL) << 4);
+
+				if ((fieldA & 0xE0ULL) == 0xE0ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x800000000000ULL | ((fieldA & 0xF8000000ULL) << 15) | ((fieldA & 0xF80000ULL) << 18) | ((fieldA & 0xF800ULL) << 21);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldA & 0xE0ULL) << 39) | ((fieldA & 0xF0000000ULL) << 12) | ((fieldA & 0xF00000ULL) << 16) | ((fieldA & 0xF000ULL) << 20);
+
+				if ((fieldB & 0xE000000000ULL) == 0xE000000000ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x80000000ULL | ((fieldB & 0xF800000000000000ULL) >> 33) | ((fieldB & 0xF8000000000000ULL) >> 30) | ((fieldB & 0xF80000000000ULL) >> 27);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldB & 0xE000000000ULL) >> 9) | ((fieldB & 0xF000000000000000ULL) >> 36) | ((fieldB & 0xF0000000000000ULL) >> 32) | ((fieldB & 0xF00000000000ULL) >> 28);
+
+				if ((fieldB & 0xE0ULL) == 0xE0ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
+				((PNGU_u64 *) buffer)[blockbase+2] = tmp;
+
+				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16));
+				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16+8));
+				if ((fieldA & 0xE000000000ULL) == 0xE000000000ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = 0x8000000000000000ULL | ((fieldA & 0xF800000000000000ULL) >> 1) | ((fieldA & 0xF8000000000000ULL) << 2) | ((fieldA & 0xF80000000000ULL) << 5);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = ((fieldA & 0xE000000000ULL) << 23) | ((fieldA & 0xF000000000000000ULL) >> 4) | (fieldA & 0xF0000000000000ULL) | ((fieldA & 0xF00000000000ULL) << 4);
+
+				if ((fieldA & 0xE0ULL) == 0xE0ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x800000000000ULL | ((fieldA & 0xF8000000ULL) << 15) | ((fieldA & 0xF80000ULL) << 18) | ((fieldA & 0xF800ULL) << 21);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldA & 0xE0ULL) << 39) | ((fieldA & 0xF0000000ULL) << 12) | ((fieldA & 0xF00000ULL) << 16) | ((fieldA & 0xF000ULL) << 20);
+
+				if ((fieldB & 0xE000000000ULL) == 0xE000000000ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x80000000ULL | ((fieldB & 0xF800000000000000ULL) >> 33) | ((fieldB & 0xF8000000000000ULL) >> 30) | ((fieldB & 0xF80000000000ULL) >> 27);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldB & 0xE000000000ULL) >> 9) | ((fieldB & 0xF000000000000000ULL) >> 36) | ((fieldB & 0xF0000000000000ULL) >> 32) | ((fieldB & 0xF00000000000ULL) >> 28);
+
+				if ((fieldB & 0xE0ULL) == 0xE0ULL)
+					// Opaque pixel, so set MSB to 1 and encode colors in RGB555
+					tmp = tmp | 0x8000ULL | ((fieldB & 0xF8000000ULL) >> 17) | ((fieldB & 0xF80000ULL) >> 14) | ((fieldB & 0xF800ULL) >> 11);
+				else
+					// Tranlucid pixel, so set MSB to 0 and encode colors in ARGB3444
+					tmp = tmp | ((fieldB & 0xE0ULL) << 7) | ((fieldB & 0xF0000000ULL) >> 20) | ((fieldB & 0xF00000ULL) >> 16) | ((fieldB & 0xF000ULL) >> 12);
+				((PNGU_u64 *) buffer)[blockbase+3] = tmp;
+			}
+	}
+	else
+	{
+		// No alpha channel present, copy image to the output buffer
+		default_alpha = (default_alpha >> 5);
+		if (default_alpha == 7)
+		{
+			// The user wants an opaque texture, so set MSB to 1 and encode colors in RGB555
+			alphaMask = 0x8000800080008000ULL;
+
+			for (y = 0; y < qheight; y++)
+				for (x = 0; x < qwidth; x++)
+				{
+					int blockbase = (y * qwidth + x) * 4;
+
+					PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
+					PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
+					((PNGU_u64 *) buffer)[blockbase] = 
+						 alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
+						((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
+						((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) | 
+						((field32 & 0xF8000000ULL) >> 11) |	((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
+
+					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
+					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
+					((PNGU_u64 *) buffer)[blockbase+1] = 
+						alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
+						((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
+						((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) | 
+						((field32 & 0xF8000000ULL) >> 11) |	((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
+
+					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
+					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
+					((PNGU_u64 *) buffer)[blockbase+2] = 
+						alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
+						((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
+						((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) | 
+						((field32 & 0xF8000000ULL) >> 11) |	((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
+
+					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
+					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
+					((PNGU_u64 *) buffer)[blockbase+3] = 
+						alphaMask | ((field64 & 0xF800000000000000ULL) >> 1) | ((field64 & 0xF8000000000000ULL) << 2) |
+						((field64 & 0xF80000000000ULL) << 5) | ((field64 & 0xF800000000ULL) << 7) | ((field64 & 0xF8000000ULL) << 10) |
+						((field64 & 0xF80000ULL) << 13) | ((field64 & 0xF800ULL) << 15) | ((field64 & 0xF8ULL) << 18) | 
+						((field32 & 0xF8000000ULL) >> 11) |	((field32 & 0xF80000ULL) >> 9) | ((field32 & 0xF800ULL) >> 6) | ((field32 & 0xF8ULL) >> 3);
+				}
+		}
+		else
+		{
+			// The user wants a translucid texture, so set MSB to 0 and encode colors in ARGB3444
+			default_alpha = (default_alpha << 4);
+			alphaMask = (((PNGU_u64) default_alpha) << 56) | (((PNGU_u64) default_alpha) << 40) |
+						(((PNGU_u64) default_alpha) << 24) | (((PNGU_u64) default_alpha) << 8);
+
+			for (y = 0; y < qheight; y++)
+				for (x = 0; x < qwidth; x++)
+				{
+					int blockbase = (y * qwidth + x) * 4;
+
+					PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
+					PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
+					((PNGU_u64 *) buffer)[blockbase] = 
+						alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) | 
+						((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) | 
+						((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |	
+						((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
+
+					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
+					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
+					((PNGU_u64 *) buffer)[blockbase+1] = 
+						alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) | 
+						((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) | 
+						((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |	
+						((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
+
+					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
+					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
+					((PNGU_u64 *) buffer)[blockbase+2] = 
+						alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) | 
+						((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) | 
+						((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |	
+						((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
+
+					field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
+					field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
+					((PNGU_u64 *) buffer)[blockbase+3] = 
+						alphaMask | ((field64 & 0xF000000000000000ULL) >> 4) | (field64 & 0xF0000000000000ULL) | ((field64 & 0xF00000000000ULL) << 4) | 
+						((field64 & 0xF000000000ULL) << 4) | ((field64 & 0xF0000000ULL) << 8) | ((field64 & 0xF00000ULL) << 12) | 
+						((field64 & 0xF000ULL) << 12) | ((field64 & 0xF0ULL) << 16) | ((field32 & 0xF0000000ULL) >> 12) |	
+						((field32 & 0xF00000ULL) >> 12) | ((field32 & 0xF000ULL) >> 8) | ((field32 & 0xF0ULL) >> 4);
+				}
+		}
+	}
+	
+	// Free resources
+	free (ctx->img_data);
+	free (ctx->row_pointers);
+
+	// Success
+	return PNGU_OK;
+}
+
+
+int PNGU_DecodeTo4x4RGBA8 (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u8 default_alpha)
+{
+	int result;
+	PNGU_u32 x, y, qwidth, qheight;
+	PNGU_u64 alphaMask;
+
+	// width and height need to be divisible by four
+	if ((width % 4) || (height % 4))
+		return PNGU_INVALID_WIDTH_OR_HEIGHT;
+
+	result = pngu_decode (ctx, width, height, 0);
+	if (result != PNGU_OK)
+		return result;
+
+	// Init some variables
+	qwidth = width / 4;
+	qheight = height / 4;
+
+	// Check is source image has an alpha channel
+	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) )
+	{
+		// Alpha channel present, copy image to the output buffer
+		for (y = 0; y < qheight; y++)
+			for (x = 0; x < qwidth; x++)
+			{
+				int blockbase = (y * qwidth + x) * 8;
+
+				PNGU_u64 fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16));
+				PNGU_u64 fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*16+8));
+				((PNGU_u64 *) buffer)[blockbase] = 
+					((fieldA & 0xFF00000000ULL) << 24) | ((fieldA & 0xFF00000000000000ULL) >> 8) | 
+					((fieldA & 0xFFULL) << 40) | ((fieldA & 0xFF000000ULL) << 8) | 
+					((fieldB & 0xFF00000000ULL) >> 8) | ((fieldB & 0xFF00000000000000ULL) >> 40) | 
+					((fieldB & 0xFFULL) << 8) | ((fieldB & 0xFF000000ULL) >> 24);
+				((PNGU_u64 *) buffer)[blockbase+4] =
+					((fieldA & 0xFFFF0000000000ULL) << 8) | ((fieldA & 0xFFFF00ULL) << 24) |
+					((fieldB & 0xFFFF0000000000ULL) >> 24) | ((fieldB & 0xFFFF00ULL) >> 8);
+
+				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16));
+				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*16+8));
+				((PNGU_u64 *) buffer)[blockbase+1] = 
+					((fieldA & 0xFF00000000ULL) << 24) | ((fieldA & 0xFF00000000000000ULL) >> 8) | 
+					((fieldA & 0xFFULL) << 40) | ((fieldA & 0xFF000000ULL) << 8) | 
+					((fieldB & 0xFF00000000ULL) >> 8) | ((fieldB & 0xFF00000000000000ULL) >> 40) | 
+					((fieldB & 0xFFULL) << 8) | ((fieldB & 0xFF000000ULL) >> 24);
+				((PNGU_u64 *) buffer)[blockbase+5] =
+					((fieldA & 0xFFFF0000000000ULL) << 8) | ((fieldA & 0xFFFF00ULL) << 24) |
+					((fieldB & 0xFFFF0000000000ULL) >> 24) | ((fieldB & 0xFFFF00ULL) >> 8);
+
+				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16));
+				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*16+8));
+				((PNGU_u64 *) buffer)[blockbase+2] = 
+					((fieldA & 0xFF00000000ULL) << 24) | ((fieldA & 0xFF00000000000000ULL) >> 8) | 
+					((fieldA & 0xFFULL) << 40) | ((fieldA & 0xFF000000ULL) << 8) | 
+					((fieldB & 0xFF00000000ULL) >> 8) | ((fieldB & 0xFF00000000000000ULL) >> 40) | 
+					((fieldB & 0xFFULL) << 8) | ((fieldB & 0xFF000000ULL) >> 24);
+				((PNGU_u64 *) buffer)[blockbase+6] =
+					((fieldA & 0xFFFF0000000000ULL) << 8) | ((fieldA & 0xFFFF00ULL) << 24) |
+					((fieldB & 0xFFFF0000000000ULL) >> 24) | ((fieldB & 0xFFFF00ULL) >> 8);
+
+				fieldA = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16));
+				fieldB = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*16+8));
+				((PNGU_u64 *) buffer)[blockbase+3] = 
+					((fieldA & 0xFF00000000ULL) << 24) | ((fieldA & 0xFF00000000000000ULL) >> 8) | 
+					((fieldA & 0xFFULL) << 40) | ((fieldA & 0xFF000000ULL) << 8) | 
+					((fieldB & 0xFF00000000ULL) >> 8) | ((fieldB & 0xFF00000000000000ULL) >> 40) | 
+					((fieldB & 0xFFULL) << 8) | ((fieldB & 0xFF000000ULL) >> 24);
+				((PNGU_u64 *) buffer)[blockbase+7] =
+					((fieldA & 0xFFFF0000000000ULL) << 8) | ((fieldA & 0xFFFF00ULL) << 24) |
+					((fieldB & 0xFFFF0000000000ULL) >> 24) | ((fieldB & 0xFFFF00ULL) >> 8);
+			}
+	}
+	else
+	{
+		// No alpha channel present, copy image to the output buffer
+		alphaMask = (((PNGU_u64)default_alpha) << 56) | (((PNGU_u64)default_alpha) << 40) |
+					(((PNGU_u64)default_alpha) << 24) | (((PNGU_u64)default_alpha) << 8);
+
+		for (y = 0; y < qheight; y++)
+			for (x = 0; x < qwidth; x++)
+			{
+				int blockbase = (y * qwidth + x) * 8;
+
+				PNGU_u64 field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4]+x*12));
+				PNGU_u64 field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4]+x*12+8));
+				((PNGU_u64 *) buffer)[blockbase] = 
+					(((field64 & 0xFF00000000000000ULL) >> 8) | (field64 & 0xFF00000000ULL) | 
+					((field64 & 0xFF00ULL) << 8) | ((field32 & 0xFF0000ULL) >> 16) | alphaMask);
+				((PNGU_u64 *) buffer)[blockbase+4] =
+					(((field64 & 0xFFFF0000000000ULL) << 8) | ((field64 & 0xFFFF0000ULL) << 16) |
+					((field64 & 0xFFULL) << 24) | ((field32 & 0xFF000000ULL) >> 8) | (field32 & 0xFFFFULL));
+
+				field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+1]+x*12));
+				field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+1]+x*12+8));
+				((PNGU_u64 *) buffer)[blockbase+1] = 
+					(((field64 & 0xFF00000000000000ULL) >> 8) | (field64 & 0xFF00000000ULL) | 
+					((field64 & 0xFF00ULL) << 8) | ((field32 & 0xFF0000ULL) >> 16) | alphaMask);
+				((PNGU_u64 *) buffer)[blockbase+5] =
+					(((field64 & 0xFFFF0000000000ULL) << 8) | ((field64 & 0xFFFF0000ULL) << 16) |
+					((field64 & 0xFFULL) << 24) | ((field32 & 0xFF000000ULL) >> 8) | (field32 & 0xFFFFULL));
+
+				field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+2]+x*12));
+				field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+2]+x*12+8));
+				((PNGU_u64 *) buffer)[blockbase+2] = 
+					(((field64 & 0xFF00000000000000ULL) >> 8) | (field64 & 0xFF00000000ULL) | 
+					((field64 & 0xFF00ULL) << 8) | ((field32 & 0xFF0000ULL) >> 16) | alphaMask);
+				((PNGU_u64 *) buffer)[blockbase+6] =
+					(((field64 & 0xFFFF0000000000ULL) << 8) | ((field64 & 0xFFFF0000ULL) << 16) |
+					((field64 & 0xFFULL) << 24) | ((field32 & 0xFF000000ULL) >> 8) | (field32 & 0xFFFFULL));
+
+				field64 = *((PNGU_u64 *)(ctx->row_pointers[y*4+3]+x*12));
+				field32 = (PNGU_u64) *((PNGU_u32 *)(ctx->row_pointers[y*4+3]+x*12+8));
+				((PNGU_u64 *) buffer)[blockbase+3] = 
+					(((field64 & 0xFF00000000000000ULL) >> 8) | (field64 & 0xFF00000000ULL) | 
+					((field64 & 0xFF00ULL) << 8) | ((field32 & 0xFF0000ULL) >> 16) | alphaMask);
+				((PNGU_u64 *) buffer)[blockbase+7] =
+					(((field64 & 0xFFFF0000000000ULL) << 8) | ((field64 & 0xFFFF0000ULL) << 16) |
+					((field64 & 0xFFULL) << 24) | ((field32 & 0xFF000000ULL) >> 8) | (field32 & 0xFFFFULL));
+			}
+	}
+	
+	// Free resources
+	free (ctx->img_data);
+	free (ctx->row_pointers);
+
+	// Success
+	return PNGU_OK;
+}
+
+
+int PNGU_EncodeFromYCbYCr (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, void *buffer, PNGU_u32 stride)
+{
+	png_uint_32 rowbytes;
+	PNGU_u32 x, y, buffWidth;
+
+	// Erase from the context any readed info
+	pngu_free_info (ctx);
+	ctx->propRead = 0;
+
+	// Check if the user has selected a file to write the image
+	if (ctx->source == PNGU_SOURCE_BUFFER);	
+
+	else if (ctx->source == PNGU_SOURCE_DEVICE)
+	{
+		// Open file
+		if (!(ctx->fd = fopen (ctx->filename, "wb")))
+			return PNGU_CANT_OPEN_FILE;
+	}
+
+	else
+		return PNGU_NO_FILE_SELECTED;
+
+	// Allocation of libpng structs
+	ctx->png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (!(ctx->png_ptr))
+	{
+		if (ctx->source == PNGU_SOURCE_DEVICE)
+			fclose (ctx->fd);
+        return PNGU_LIB_ERROR;
+	}
+
+    ctx->info_ptr = png_create_info_struct (ctx->png_ptr);
+    if (!(ctx->info_ptr))
+    {
+		png_destroy_write_struct (&(ctx->png_ptr), (png_infopp)NULL);
+		if (ctx->source == PNGU_SOURCE_DEVICE)
+			fclose (ctx->fd);
+        return PNGU_LIB_ERROR;
+    }
+
+	if (ctx->source == PNGU_SOURCE_BUFFER)
+	{
+		// Installation of our custom data writer function
+		ctx->cursor = 0;
+		png_set_write_fn (ctx->png_ptr, ctx, pngu_write_data_to_buffer, pngu_flush_data_to_buffer);
+	}
+	else if (ctx->source == PNGU_SOURCE_DEVICE)
+	{
+		// Default data writer uses function fwrite, so it needs to use our FILE*
+		png_init_io (ctx->png_ptr, ctx->fd);
+	}
+
+	// Setup output file properties
+    png_set_IHDR (ctx->png_ptr, ctx->info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB, 
+				PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+	// Allocate memory to store the image in RGB format
+	rowbytes = width * 3;
+	if (rowbytes % 4)
+		rowbytes = ((rowbytes / 4) + 1) * 4; // Add extra padding so each row starts in a 4 byte boundary
+
+	ctx->img_data = malloc (rowbytes * height);
+	if (!ctx->img_data)
+	{
+		png_destroy_write_struct (&(ctx->png_ptr), (png_infopp)NULL);
+		if (ctx->source == PNGU_SOURCE_DEVICE)
+			fclose (ctx->fd);
+		return PNGU_LIB_ERROR;
+	}
+
+	ctx->row_pointers = malloc (sizeof (png_bytep) * height);
+	if (!ctx->row_pointers)
+	{
+		png_destroy_write_struct (&(ctx->png_ptr), (png_infopp)NULL);
+		if (ctx->source == PNGU_SOURCE_DEVICE)
+			fclose (ctx->fd);
+		return PNGU_LIB_ERROR;
+	}
+
+	// Encode YCbYCr image into RGB8 format
+	buffWidth = (width + stride) / 2;
+	for (y = 0; y < height; y++)
+	{
+		ctx->row_pointers[y] = ctx->img_data + (y * rowbytes);
+
+		for (x = 0; x < (width / 2); x++)
+			PNGU_YCbYCr_TO_RGB8 ( ((PNGU_u32 *)buffer)[y*buffWidth+x], 
+				((PNGU_u8 *) ctx->row_pointers[y]+x*6), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+1),
+				((PNGU_u8 *) ctx->row_pointers[y]+x*6+2), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+3),
+				((PNGU_u8 *) ctx->row_pointers[y]+x*6+4), ((PNGU_u8 *) ctx->row_pointers[y]+x*6+5) );
+	}
+
+	// Tell libpng where is our image data
+	png_set_rows (ctx->png_ptr, ctx->info_ptr, ctx->row_pointers);
+
+	// Write file header and image data
+	png_write_png (ctx->png_ptr, ctx->info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
+
+	// Tell libpng we have no more data to write
+	png_write_end (ctx->png_ptr, (png_infop) NULL);
+
+	// Free resources
+	free (ctx->img_data);
+	free (ctx->row_pointers);
+	png_destroy_write_struct (&(ctx->png_ptr), &(ctx->info_ptr));
+	if (ctx->source == PNGU_SOURCE_DEVICE)
+		fclose (ctx->fd);
+
+	// Success
+	return PNGU_OK;
+}
+
+
+// This function is taken from a libogc example
+PNGU_u32 PNGU_RGB8_TO_YCbYCr (PNGU_u8 r1, PNGU_u8 g1, PNGU_u8 b1, PNGU_u8 r2, PNGU_u8 g2, PNGU_u8 b2)
+{
+  int y1, cb1, cr1, y2, cb2, cr2, cb, cr;
+
+  y1 = (299 * r1 + 587 * g1 + 114 * b1) / 1000;
+  cb1 = (-16874 * r1 - 33126 * g1 + 50000 * b1 + 12800000) / 100000;
+  cr1 = (50000 * r1 - 41869 * g1 - 8131 * b1 + 12800000) / 100000;
+ 
+  y2 = (299 * r2 + 587 * g2 + 114 * b2) / 1000;
+  cb2 = (-16874 * r2 - 33126 * g2 + 50000 * b2 + 12800000) / 100000;
+  cr2 = (50000 * r2 - 41869 * g2 - 8131 * b2 + 12800000) / 100000;
+ 
+  cb = (cb1 + cb2) >> 1;
+  cr = (cr1 + cr2) >> 1;
+ 
+  return (PNGU_u32) ((y1 << 24) | (cb << 16) | (y2 << 8) | cr);
+}
+
+
+void PNGU_YCbYCr_TO_RGB8 (PNGU_u32 ycbycr, PNGU_u8 *r1, PNGU_u8 *g1, PNGU_u8 *b1, PNGU_u8 *r2, PNGU_u8 *g2, PNGU_u8 *b2)
+{
+	PNGU_u8 *val = (PNGU_u8 *) &ycbycr;
+	int r, g, b;
+
+	r = 1.371f * (val[3] - 128);
+	g = - 0.698f * (val[3] - 128) - 0.336f * (val[1] - 128);
+	b = 1.732f * (val[1] - 128);
+
+	*r1 = pngu_clamp (val[0] + r, 0, 255);
+	*g1 = pngu_clamp (val[0] + g, 0, 255);
+	*b1 = pngu_clamp (val[0] + b, 0, 255);
+
+	*r2 = pngu_clamp (val[2] + r, 0, 255);
+	*g2 = pngu_clamp (val[2] + g, 0, 255);
+	*b2 = pngu_clamp (val[2] + b, 0, 255);
+}
+
+
+int pngu_info (IMGCTX ctx)
+{
+	png_byte magic[8];
+	png_uint_32 width;
+	png_uint_32 height;
+	png_color_16p background;
+	png_bytep trans;
+	png_color_16p trans_values;
+	int scale, i;
+
+	// Check if there is a file selected and if it is a valid .png
+	if (ctx->source == PNGU_SOURCE_BUFFER)
+		memcpy (magic, ctx->buffer, 8);
+
+	else if (ctx->source == PNGU_SOURCE_DEVICE)
+	{
+		// Open file
+		if (!(ctx->fd = fopen (ctx->filename, "rb")))
+			return PNGU_CANT_OPEN_FILE;
+
+		// Load first 8 bytes into magic buffer
+        if (fread (magic, 1, 8, ctx->fd) != 8)
+		{
+			fclose (ctx->fd);
+			return PNGU_CANT_READ_FILE;
+		}
+	}
+
+	else
+		return PNGU_NO_FILE_SELECTED;;
+
+	if (png_sig_cmp(magic, 0, 8) != 0)
+	{
+		if (ctx->source == PNGU_SOURCE_DEVICE)
+			fclose (ctx->fd);
+		return PNGU_FILE_IS_NOT_PNG;
+	}
+
+	// Allocation of libpng structs
+	ctx->png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (!(ctx->png_ptr))
+	{
+		if (ctx->source == PNGU_SOURCE_DEVICE)
+			fclose (ctx->fd);
+        return PNGU_LIB_ERROR;
+	}
+
+    ctx->info_ptr = png_create_info_struct (ctx->png_ptr);
+    if (!(ctx->info_ptr))
+    {
+		if (ctx->source == PNGU_SOURCE_DEVICE)
+			fclose (ctx->fd);
+        png_destroy_read_struct (&(ctx->png_ptr), (png_infopp)NULL, (png_infopp)NULL);
+        return PNGU_LIB_ERROR;
+    }
+
+	if (ctx->source == PNGU_SOURCE_BUFFER)
+	{
+		// Installation of our custom data provider function
+		ctx->cursor = 0;
+		png_set_read_fn (ctx->png_ptr, ctx, pngu_read_data_from_buffer);
+	}
+	else if (ctx->source == PNGU_SOURCE_DEVICE)
+	{
+		// Default data provider uses function fread, so it needs to use our FILE*
+		png_init_io (ctx->png_ptr, ctx->fd);
+		png_set_sig_bytes (ctx->png_ptr, 8); // We have read 8 bytes already to check PNG authenticity
+	}
+
+	// Read png header
+	png_read_info (ctx->png_ptr, ctx->info_ptr);
+
+	// Query image properties if they have not been queried before
+	if (!ctx->propRead)
+	{
+		png_get_IHDR(ctx->png_ptr, ctx->info_ptr, &width, &height,
+					(int *) &(ctx->prop.imgBitDepth), 
+					(int *) &(ctx->prop.imgColorType),
+					NULL, NULL, NULL);
+
+		ctx->prop.imgWidth = width;
+		ctx->prop.imgHeight = height;
+		switch (ctx->prop.imgColorType)
+		{
+			case PNG_COLOR_TYPE_GRAY:
+				ctx->prop.imgColorType = PNGU_COLOR_TYPE_GRAY;
+				break;
+			case PNG_COLOR_TYPE_GRAY_ALPHA:
+				ctx->prop.imgColorType = PNGU_COLOR_TYPE_GRAY_ALPHA;
+				break;
+			case PNG_COLOR_TYPE_PALETTE:
+				ctx->prop.imgColorType = PNGU_COLOR_TYPE_PALETTE;
+				break;
+			case PNG_COLOR_TYPE_RGB:
+				ctx->prop.imgColorType = PNGU_COLOR_TYPE_RGB;
+				break;
+			case PNG_COLOR_TYPE_RGB_ALPHA:
+				ctx->prop.imgColorType = PNGU_COLOR_TYPE_RGB_ALPHA;
+				break;
+			default:
+				ctx->prop.imgColorType = PNGU_COLOR_TYPE_UNKNOWN;
+				break;
+		}
+
+		// Constant used to scale 16 bit values to 8 bit values
+		scale = 1;
+		if (ctx->prop.imgBitDepth == 16)
+			scale = 256;
+
+		// Query background color, if any.
+		ctx->prop.validBckgrnd = 0;
+		if (((ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA)) &&
+			(png_get_bKGD (ctx->png_ptr, ctx->info_ptr, &background)))
+		{
+			ctx->prop.validBckgrnd = 1;
+			ctx->prop.bckgrnd.r = background->red / scale;
+			ctx->prop.bckgrnd.g = background->green / scale;
+			ctx->prop.bckgrnd.b = background->blue / scale;
+		}
+		else if (((ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA)) &&
+			(png_get_bKGD (ctx->png_ptr, ctx->info_ptr, &background)))
+		{
+			ctx->prop.validBckgrnd = 1;
+			ctx->prop.bckgrnd.r = ctx->prop.bckgrnd.g = ctx->prop.bckgrnd.b = background->gray / scale;
+		}
+
+		// Query list of transparent colors, if any.
+		ctx->prop.numTrans = 0;
+		ctx->prop.trans = NULL;
+		if (((ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA)) &&
+			(png_get_tRNS (ctx->png_ptr, ctx->info_ptr, &trans, (int *) &(ctx->prop.numTrans), &trans_values)))
+		{
+			if (ctx->prop.numTrans)
+			{
+				ctx->prop.trans = malloc (sizeof (PNGUCOLOR) * ctx->prop.numTrans);
+				if (ctx->prop.trans)
+					for (i = 0; i < ctx->prop.numTrans; i++)
+					{
+						ctx->prop.trans[i].r = trans_values[i].red / scale;
+						ctx->prop.trans[i].g = trans_values[i].green / scale;
+						ctx->prop.trans[i].b = trans_values[i].blue / scale;
+					}
+				else
+					ctx->prop.numTrans = 0;
+			}
+		}
+		else if (((ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA)) &&
+			(png_get_tRNS (ctx->png_ptr, ctx->info_ptr, &trans, (int *) &(ctx->prop.numTrans), &trans_values)))
+		{
+			if (ctx->prop.numTrans)
+			{
+				ctx->prop.trans = malloc (sizeof (PNGUCOLOR) * ctx->prop.numTrans);
+				if (ctx->prop.trans)
+					for (i = 0; i < ctx->prop.numTrans; i++)
+						ctx->prop.trans[i].r = ctx->prop.trans[i].g = ctx->prop.trans[i].b = 
+						trans_values[i].gray / scale;
+				else
+					ctx->prop.numTrans = 0;
+			}
+		}
+
+		ctx->propRead = 1;
+	}
+
+	// Success
+	ctx->infoRead = 1;
+
+	return PNGU_OK;
+}
+
+
+int pngu_decode (IMGCTX ctx, PNGU_u32 width, PNGU_u32 height, PNGU_u32 stripAlpha)
+{
+	png_uint_32 rowbytes;
+	int i;
+
+	// Read info if it hasn't been read before
+	if (!ctx->infoRead)
+	{
+		i = pngu_info (ctx);
+		if (i != PNGU_OK)
+			return i;
+	}
+
+	// Check if the user has specified the real width and height of the image
+	if ( (ctx->prop.imgWidth != width) || (ctx->prop.imgHeight != height) )
+		return PNGU_INVALID_WIDTH_OR_HEIGHT;
+
+	// Check if color type is supported by PNGU
+	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_PALETTE) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_UNKNOWN) )
+		return PNGU_UNSUPPORTED_COLOR_TYPE;
+
+	// Scale 16 bit samples to 8 bit
+	if (ctx->prop.imgBitDepth == 16)
+        png_set_strip_16 (ctx->png_ptr);
+
+	// Remove alpha channel if we don't need it
+	if (stripAlpha && ((ctx->prop.imgColorType == PNGU_COLOR_TYPE_RGB_ALPHA) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA)))
+        png_set_strip_alpha (ctx->png_ptr);
+
+	// Expand 1, 2 and 4 bit samples to 8 bit
+	if (ctx->prop.imgBitDepth < 8)
+        png_set_packing (ctx->png_ptr);
+
+	// Transform grayscale images to RGB
+	if ( (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY) || (ctx->prop.imgColorType == PNGU_COLOR_TYPE_GRAY_ALPHA) )
+		png_set_gray_to_rgb (ctx->png_ptr);
+
+	// Flush transformations
+	png_read_update_info (ctx->png_ptr, ctx->info_ptr);
+
+	// Allocate memory to store the image
+	rowbytes = png_get_rowbytes (ctx->png_ptr, ctx->info_ptr);
+	if (rowbytes % 4)
+		rowbytes = ((rowbytes / 4) + 1) * 4; // Add extra padding so each row starts in a 4 byte boundary
+
+	ctx->img_data = malloc (rowbytes * ctx->prop.imgHeight);
+	if (!ctx->img_data)
+	{
+		pngu_free_info (ctx);
+		return PNGU_LIB_ERROR;
+	}
+
+	ctx->row_pointers = malloc (sizeof (png_bytep) * ctx->prop.imgHeight);
+	if (!ctx->row_pointers)
+	{
+		free (ctx->img_data);
+		pngu_free_info (ctx);
+		return PNGU_LIB_ERROR;
+	}
+
+	for (i = 0; i < ctx->prop.imgHeight; i++)
+		ctx->row_pointers[i] = ctx->img_data + (i * rowbytes);
+
+	// Transform the image and copy it to our allocated memory
+	png_read_image (ctx->png_ptr, ctx->row_pointers);
+
+	// Free resources
+	pngu_free_info (ctx);
+
+	// Success
+	return PNGU_OK;
+}
+
+
+void pngu_free_info (IMGCTX ctx)
+{
+	if (ctx->infoRead)
+	{
+		if (ctx->source == PNGU_SOURCE_DEVICE)
+			fclose (ctx->fd);
+
+		png_destroy_read_struct (&(ctx->png_ptr), &(ctx->info_ptr), (png_infopp)NULL);
+
+		ctx->infoRead = 0;
+	}
+}
+
+
+// Custom data provider function used for reading from memory buffers.
+void pngu_read_data_from_buffer (png_structp png_ptr, png_bytep data, png_size_t length)
+{
+	IMGCTX ctx = (IMGCTX) png_get_io_ptr (png_ptr);
+	memcpy (data, ctx->buffer + ctx->cursor, length);
+	ctx->cursor += length;
+}
+
+
+// Custom data writer function used for writing to memory buffers.
+void pngu_write_data_to_buffer (png_structp png_ptr, png_bytep data, png_size_t length)
+{
+	IMGCTX ctx = (IMGCTX) png_get_io_ptr (png_ptr);
+	memcpy (ctx->buffer + ctx->cursor, data, length);
+	ctx->cursor += length;
+}
+
+
+// Custom data flusher function used for writing to memory buffers.
+void pngu_flush_data_to_buffer (png_structp png_ptr)
+{
+	// Nothing to do here
+}
+
+
+// Function used in YCbYCr to RGB decoding
+int pngu_clamp (int value, int min, int max)
+{
+	if (value < min)
+		value = min;
+	else if (value > max)
+		value = max;
+
+	return value;
+}
+
diff --git a/source/ngc/snes9xGX.cpp b/source/ngc/snes9xGX.cpp
index 1222664..21cd8f9 100644
--- a/source/ngc/snes9xGX.cpp
+++ b/source/ngc/snes9xGX.cpp
@@ -202,6 +202,8 @@ extern "C" {
 #include "fileop.h"
 #include "input.h"
 
+#include "gui.h"
+
 unsigned long ARAM_ROMSIZE = 0;
 int ConfigRequested = 0;
 extern int FrameTimer;
@@ -288,6 +290,13 @@ emulate ()
 					NGCFreezeGame ( GCSettings.SaveMethod, SILENT );
 				}
 			}
+			
+			// GUI Stuff
+			gui_makebg ();
+			gui_clearscreen();
+			gui_draw ();
+			gui_showscreen ();
+			//gui_savescreen ();
 
 			mainmenu (3); // go to game menu
 
diff --git a/source/ngc/video.cpp b/source/ngc/video.cpp
index bae7c07..4b1dc8a 100644
--- a/source/ngc/video.cpp
+++ b/source/ngc/video.cpp
@@ -21,6 +21,8 @@
 #include "aram.h"
 #include "snes9xGX.h"
 
+#include "gui.h"
+
 /*** Snes9x GFX Buffer ***/
 static unsigned char snes9xgfx[1024 * 512 * 2];
 
@@ -43,7 +45,7 @@ unsigned int copynow = GX_FALSE;
 static unsigned char gp_fifo[DEFAULT_FIFO_SIZE] ATTRIBUTE_ALIGN (32);
 static unsigned char texturemem[TEX_WIDTH * (TEX_HEIGHT + 8)] ATTRIBUTE_ALIGN (32);
 GXTexObj texobj;
-static Mtx view;
+Mtx view;
 int vwidth, vheight, oldvwidth, oldvheight;
 
 u32 FrameTimer = 0;
@@ -170,8 +172,8 @@ GXRModeObj TV_224p =
 	256,             // fbWidth
 	224,             // efbHeight
 	224,             // xfbHeight
-	(VI_MAX_WIDTH_NTSC - 640)/2,        // viXOrigin
-	(VI_MAX_HEIGHT_NTSC - 480)/2 + 8,	// viYOrigin	// +8 if we want to maintain rendered pixel aspect ratio (not 4:3)
+	(VI_MAX_WIDTH_NTSC - 640)/2,	// viXOrigin
+	(VI_MAX_HEIGHT_NTSC - 480)/2,	// viYOrigin
 	640,             // viWidth
 	480,             // viHeight
 	VI_XFBMODE_SF,   // xFBmode
@@ -301,8 +303,6 @@ copy_to_xfb (u32 arg)
 
 	if (copynow == GX_TRUE)
 	{
-		//GX_SetZMode (GX_TRUE, GX_LEQUAL, GX_TRUE);
-		//GX_SetColorUpdate (GX_TRUE);
 		GX_CopyDisp (xfb[whichfb], GX_TRUE);
 		GX_Flush ();
 		copynow = GX_FALSE;
@@ -341,14 +341,6 @@ draw_init ()
 	memset (&view, 0, sizeof (Mtx));
 	guLookAt(view, &cam.pos, &cam.up, &cam.view);
 	GX_LoadPosMtxImm (view, GX_PNMTX0);
-
-	GX_InvalidateTexAll ();
-	GX_InitTexObj (&texobj, texturemem, vwidth, vheight, GX_TF_RGB565, GX_CLAMP, GX_CLAMP, GX_FALSE);
-	
-	/* original video mode: force filtering OFF */
-    if (!GCSettings.render)
-		GX_InitTexObjLOD(&texobj,GX_NEAR,GX_NEAR_MIP_NEAR,2.5,9.0,0.0,GX_FALSE,GX_FALSE,GX_ANISO_1);
-
 }
 
 static void
@@ -413,6 +405,8 @@ StartGX ()
 	GX_SetDispCopyGamma (GX_GM_1_0);
 	GX_SetZMode (GX_TRUE, GX_LEQUAL, GX_TRUE);
 	GX_SetColorUpdate (GX_TRUE);
+	
+	gui_alphasetup ();
 
 //	guPerspective (p, 60, 1.33F, 10.0F, 1000.0F);
 //	GX_LoadProjectionMtx (p, GX_PERSPECTIVE);
@@ -533,6 +527,12 @@ InitGCVideo ()
 			vmode_60hz = 1;
 			break;
 	}
+	
+	// check for progressive scan
+	if (vmode->viTVMode == VI_TVMODE_NTSC_PROG) {
+		TV_239p.viTVMode = TV_478i.viTVMode = TV_224p.viTVMode = TV_448i.viTVMode = VI_TVMODE_NTSC_PROG;
+		TV_239p.xfbMode = TV_478i.xfbMode = TV_224p.xfbMode = TV_448i.xfbMode = VI_XFBMODE_SF;
+	}
 
     VIDEO_Configure (vmode);
 
@@ -588,7 +588,10 @@ ResetVideo_Emu ()
 	{
 		int i;
 		for (i=0; i<4; i++) {
-			if (tvmodes[i]->efbHeight == vheight) break;
+			if (tvmodes[i]->efbHeight == vheight) {
+				tvmodes[i]->fbWidth = vwidth;	// update width - some games are 512x224 (super pang)
+				break;
+			}
 		}
 		rmode = tvmodes[i];
 	} 
@@ -620,11 +623,16 @@ ResetVideo_Emu ()
 	guOrtho(p, rmode->efbHeight/2, -(rmode->efbHeight/2), -(rmode->fbWidth/2), rmode->fbWidth/2, 10, 1000);	// matrix, t, b, l, r, n, f
 	GX_LoadProjectionMtx (p, GX_ORTHOGRAPHIC);
 	
+	// clear snes9x render screen
+	memset (snes9xgfx, 0, 1024 * 512 * 2);
+	
+	
 			// DEBUG
 		char* msg = (char*) malloc(256*sizeof(char));
 		sprintf (msg, (char*)"Interlaced: %i, vwidth: %d, vheight: %d, fb_W: %u, efb_H: %u", IPPU.Interlace, vwidth, vheight, rmode->fbWidth, rmode->efbHeight);
 		S9xMessage (0, 0, msg);
 		free(msg);
+	
 
 }
 
@@ -732,7 +740,7 @@ update_video (int width, int height)
 
 	whichfb ^= 1;
 
-	if ((oldvheight != vheight) || (oldvwidth != vwidth) 								// if rendered width/height changes
+	if ((oldvheight != vheight) || (oldvwidth != vwidth) 					// if rendered width/height changes
 		|| (CheckVideo && (IPPU.RenderedFramesCount != prevRenderedFrameCount))	// or if we get back from the menu, and have rendered at least 1 frame
 		)
 	{
@@ -765,12 +773,21 @@ update_video (int width, int height)
 		draw_init ();
 		
 		GX_InvVtxCache ();
+		GX_InvalidateTexAll ();
 		
+		GX_InitTexObj (&texobj, texturemem, vwidth, vheight, GX_TF_RGB565, GX_CLAMP, GX_CLAMP, GX_FALSE);
+		
+		/* original video mode: force filtering OFF */
+	    if (!GCSettings.render)
+			GX_InitTexObjLOD(&texobj,GX_NEAR,GX_NEAR_MIP_NEAR,2.5,9.0,0.0,GX_FALSE,GX_FALSE,GX_ANISO_1);
+		
+		/*
 					// DEBUG
 		char* msg = (char*) malloc(256*sizeof(char));
 		sprintf (msg, (char*)"xscale: %d, yscale: %d", xscale, yscale);
 		S9xMessage (0, 0, msg);
 		free(msg);
+		*/
 
 		//GX_SetViewport (0, 0, rmode->fbWidth, rmode->efbHeight, 0, 1);