1HEADmaster

1 files changed, 2373 insertions, 0 deletions

diff --git a/bitmap/colorconversion.cpp b/bitmap/colorconversion.cpp
new file mode 100644
index 0000000..ac033fd
--- /dev/null
+++ b/bitmap/colorconversion.cpp
@@ -0,0 +1,2373 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifdef IS_WINDOWS_PC
+#include <windows.h>
+#endif
+#include "bitmap/imageformat.h"
+#include "basetypes.h"
+#include "tier0/dbg.h"
+#include <malloc.h>
+#include <memory.h>
+#include "mathlib/mathlib.h"
+#include "mathlib/vector.h"
+#include "tier1/utlmemory.h"
+#include "tier1/strtools.h"
+#include "mathlib/compressed_vector.h"
+#include "nvtc.h"
+
+#ifdef POSIX
+typedef int32 *DWORD_PTR;
+#endif
+
+#include "ATI_Compress.h"
+#include "bitmap/float_bm.h"
+
+#define STB_DXT_IMPLEMENTATION
+#include "stb_dxt.h"
+
+// Should be last include
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Various important function types for each color format
+//-----------------------------------------------------------------------------
+
+typedef void (*UserFormatToRGBA8888Func_t )( const uint8 *src, uint8 *dst, int numPixels );
+typedef void (*RGBA8888ToUserFormatFunc_t )( const uint8 *src, uint8 *dst, int numPixels );
+
+
+namespace ImageLoader
+{
+
+// Color Conversion functions
+static void RGBA8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToABGR8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToRGB888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToBGR888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToRGB565( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToI8( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToIA88( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToP8( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToA8( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToRGB888_BLUESCREEN( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToBGR888_BLUESCREEN( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToARGB8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToBGRA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToBGRX8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToBGR565( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToBGRX5551( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToBGRA5551( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToBGRA4444( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToUV88( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToUVWQ8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA8888ToUVLX8888( const uint8 *src, uint8 *dst, int numPixels );
+//static void RGBA8888ToRGBA16161616F( const uint8 *src, uint8 *dst, int numPixels );
+
+static void ABGR8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGB888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void BGR888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGB565ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void I8ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void IA88ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void P8ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void A8ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGB888_BLUESCREENToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void BGR888_BLUESCREENToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void ARGB8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void BGRA8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void BGRX8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void BGR565ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void BGRX5551ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void BGRA5551ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void BGRA4444ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void UV88ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void UVWQ8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void UVLX8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+static void RGBA16161616ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+//static void RGBA16161616FToRGBA8888( const uint8 *src, uint8 *dst, int numPixels );
+
+
+static UserFormatToRGBA8888Func_t GetUserFormatToRGBA8888Func_t( ImageFormat srcImageFormat )
+{
+	switch( srcImageFormat )
+	{
+	case IMAGE_FORMAT_RGBA8888:
+		return RGBA8888ToRGBA8888;
+	case IMAGE_FORMAT_ABGR8888:
+		return ABGR8888ToRGBA8888;
+	case IMAGE_FORMAT_RGB888:
+		return RGB888ToRGBA8888;
+	case IMAGE_FORMAT_BGR888:
+		return BGR888ToRGBA8888;
+	case IMAGE_FORMAT_RGB565:
+		return NULL;
+	case IMAGE_FORMAT_I8:
+		return I8ToRGBA8888;
+	case IMAGE_FORMAT_IA88:
+		return IA88ToRGBA8888;
+	case IMAGE_FORMAT_A8:
+		return A8ToRGBA8888;
+	case IMAGE_FORMAT_RGB888_BLUESCREEN:
+		return RGB888_BLUESCREENToRGBA8888;
+	case IMAGE_FORMAT_BGR888_BLUESCREEN:
+		return BGR888_BLUESCREENToRGBA8888;
+	case IMAGE_FORMAT_ARGB8888:
+		return ARGB8888ToRGBA8888;
+	case IMAGE_FORMAT_BGRA8888:
+		return BGRA8888ToRGBA8888;
+	case IMAGE_FORMAT_BGRX8888:
+		return BGRX8888ToRGBA8888;
+	case IMAGE_FORMAT_BGR565:
+		return BGR565ToRGBA8888;
+	case IMAGE_FORMAT_BGRX5551:
+		return BGRX5551ToRGBA8888;
+	case IMAGE_FORMAT_BGRA5551:
+		return BGRA5551ToRGBA8888;
+	case IMAGE_FORMAT_BGRA4444:
+		return BGRA4444ToRGBA8888;
+	case IMAGE_FORMAT_UV88:
+		return UV88ToRGBA8888;
+	case IMAGE_FORMAT_UVWQ8888:
+		return UVWQ8888ToRGBA8888;
+	case IMAGE_FORMAT_UVLX8888:
+		return UVLX8888ToRGBA8888;
+	case IMAGE_FORMAT_RGBA16161616:
+		return RGBA16161616ToRGBA8888;
+	case IMAGE_FORMAT_RGBA16161616F:
+		return NULL;
+
+#if defined( _X360 )
+	case IMAGE_FORMAT_LINEAR_RGBA8888:
+		return RGBA8888ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_ABGR8888:
+		return ABGR8888ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_RGB888:
+		return RGB888ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_BGR888:
+		return BGR888ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_I8:
+		return I8ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_ARGB8888:
+		return ARGB8888ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_BGRA8888:
+		return BGRA8888ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_BGRX8888:
+		return BGRX8888ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_BGRX5551:
+		return BGRX5551ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_RGBA16161616:
+		return RGBA16161616ToRGBA8888;
+#endif
+
+	default:
+		return NULL;
+	}
+}
+
+static RGBA8888ToUserFormatFunc_t GetRGBA8888ToUserFormatFunc_t( ImageFormat dstImageFormat )
+{
+	switch( dstImageFormat )
+	{
+	case IMAGE_FORMAT_RGBA8888:
+		return RGBA8888ToRGBA8888;
+	case IMAGE_FORMAT_ABGR8888:
+		return RGBA8888ToABGR8888;
+	case IMAGE_FORMAT_RGB888:
+		return RGBA8888ToRGB888;
+	case IMAGE_FORMAT_BGR888:
+		return RGBA8888ToBGR888;
+	case IMAGE_FORMAT_RGB565:
+		return NULL;
+	case IMAGE_FORMAT_I8:
+		return RGBA8888ToI8;
+	case IMAGE_FORMAT_IA88:
+		return RGBA8888ToIA88;
+	case IMAGE_FORMAT_A8:
+		return RGBA8888ToA8;
+	case IMAGE_FORMAT_RGB888_BLUESCREEN:
+		return RGBA8888ToRGB888_BLUESCREEN;
+	case IMAGE_FORMAT_BGR888_BLUESCREEN:
+		return RGBA8888ToBGR888_BLUESCREEN;
+	case IMAGE_FORMAT_ARGB8888:
+		return RGBA8888ToARGB8888;
+	case IMAGE_FORMAT_BGRA8888:
+		return RGBA8888ToBGRA8888;
+	case IMAGE_FORMAT_BGRX8888:
+		return RGBA8888ToBGRX8888;
+	case IMAGE_FORMAT_BGR565:
+		return RGBA8888ToBGR565;
+	case IMAGE_FORMAT_BGRX5551:
+		return RGBA8888ToBGRX5551;
+	case IMAGE_FORMAT_BGRA5551:
+		return RGBA8888ToBGRA5551;
+	case IMAGE_FORMAT_BGRA4444:
+		return RGBA8888ToBGRA4444;
+	case IMAGE_FORMAT_UV88:
+		return RGBA8888ToUV88;
+	case IMAGE_FORMAT_UVWQ8888:
+		return RGBA8888ToUVWQ8888;
+	case IMAGE_FORMAT_UVLX8888:
+		return RGBA8888ToUVLX8888;
+	case IMAGE_FORMAT_RGBA16161616F:
+		return NULL;
+
+#if defined( _X360 )
+	case IMAGE_FORMAT_LINEAR_RGBA8888:
+		return RGBA8888ToRGBA8888;
+	case IMAGE_FORMAT_LINEAR_ABGR8888:
+		return RGBA8888ToABGR8888;
+	case IMAGE_FORMAT_LINEAR_RGB888:
+		return RGBA8888ToRGB888;
+	case IMAGE_FORMAT_LINEAR_BGR888:
+		return RGBA8888ToBGR888;
+	case IMAGE_FORMAT_LINEAR_I8:
+		return RGBA8888ToI8;
+	case IMAGE_FORMAT_LINEAR_ARGB8888:
+		return RGBA8888ToARGB8888;
+	case IMAGE_FORMAT_LINEAR_BGRA8888:
+		return RGBA8888ToBGRA8888;
+	case IMAGE_FORMAT_LINEAR_BGRX8888:
+		return RGBA8888ToBGRX8888;
+	case IMAGE_FORMAT_LINEAR_BGRX5551:
+		return RGBA8888ToBGRX5551;
+#endif
+
+	default:
+		return NULL;
+	}
+}
+
+
+
+#pragma pack(1)
+
+struct DXTColBlock
+{
+	WORD col0;
+	WORD col1;
+
+	// no bit fields - use bytes
+	BYTE row[4];
+};
+
+struct DXTAlphaBlock3BitLinear
+{
+	BYTE alpha0;
+	BYTE alpha1;
+
+	BYTE stuff[6];
+};
+
+#pragma pack()
+
+static inline void GetColorBlockColorsBGRA8888( DXTColBlock *pBlock, BGRA8888_t *col_0, 
+											    BGRA8888_t *col_1, BGRA8888_t *col_2, 
+												BGRA8888_t *col_3, WORD & wrd  )
+{
+	// input data is assumed to be x86 order
+	// swap to target platform for proper dxt decoding
+	WORD color0 = LittleShort( pBlock->col0 );
+	WORD color1 = LittleShort( pBlock->col1 );
+
+	// convert to full precision correctly.
+	// If this was a perf problem, we could optimize it. But this isn't used in any hotpaths 
+	// (now) so let's just do the correct but slow fp math.
+	col_0->a = 0xff;
+	col_0->r = ( uint8 ) round( ( ( BGR565_t* ) &color0 )->r * 255.0f / 31.0f );
+	col_0->g = ( uint8 ) round( ( ( BGR565_t* ) &color0 )->g * 255.0f / 63.0f );
+	col_0->b = ( uint8 ) round( ( ( BGR565_t* ) &color0 )->b * 255.0f / 31.0f );
+
+	col_1->a = 0xff;
+	col_1->r = ( uint8 ) round( ( ( BGR565_t* ) &color1 )->r * 255.0f / 31.0f );
+	col_1->g = ( uint8 ) round( ( ( BGR565_t* ) &color1 )->g * 255.0f / 63.0f );
+	col_1->b = ( uint8 ) round( ( ( BGR565_t* ) &color1 )->b * 255.0f / 31.0f );
+
+	if ( color0 > color1 )
+	{
+		// Four-color block: derive the other two colors.    
+		// 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
+		// These two bit codes correspond to the 2-bit fields 
+		// stored in the 64-bit block.
+
+		wrd = ((WORD)col_0->r * 2 + (WORD)col_1->r )/3;
+											// no +1 for rounding
+											// as bits have been shifted to 888
+		col_2->r = (BYTE)wrd;
+
+		wrd = ((WORD)col_0->g * 2 + (WORD)col_1->g )/3;
+		col_2->g = (BYTE)wrd;
+
+		wrd = ((WORD)col_0->b * 2 + (WORD)col_1->b )/3;
+		col_2->b = (BYTE)wrd;
+		col_2->a = 0xff;
+
+		wrd = ((WORD)col_0->r + (WORD)col_1->r *2 )/3;
+		col_3->r = (BYTE)wrd;
+
+		wrd = ((WORD)col_0->g + (WORD)col_1->g *2 )/3;
+		col_3->g = (BYTE)wrd;
+
+		wrd = ((WORD)col_0->b + (WORD)col_1->b *2 )/3;
+		col_3->b = (BYTE)wrd;
+		col_3->a = 0xff;
+	}
+	else
+	{
+		// Three-color block: derive the other color.
+		// 00 = color_0,  01 = color_1,  10 = color_2,  
+		// 11 = transparent.
+		// These two bit codes correspond to the 2-bit fields 
+		// stored in the 64-bit block. 
+
+		// explicit for each component, unlike some refrasts...????
+		
+		wrd = ((WORD)col_0->r + (WORD)col_1->r )/2;
+		col_2->r = (BYTE)wrd;
+		wrd = ((WORD)col_0->g + (WORD)col_1->g )/2;
+		col_2->g = (BYTE)wrd;
+		wrd = ((WORD)col_0->b + (WORD)col_1->b )/2;
+		col_2->b = (BYTE)wrd;
+		col_2->a = 0xff;
+
+		col_3->r = 0x00;		// random color to indicate alpha
+		col_3->g = 0xff;
+		col_3->b = 0xff;
+		col_3->a = 0x00;
+	}
+}			
+
+template <class CDestPixel> 
+static inline void DecodeColorBlock( CDestPixel *pOutputImage, DXTColBlock *pColorBlock, int width,
+					                 BGRA8888_t *col_0, BGRA8888_t *col_1, 
+					                 BGRA8888_t *col_2, BGRA8888_t *col_3 )
+{
+	// width is width of image in pixels
+	DWORD bits;
+	int r,n;
+
+	// bit masks = 00000011, 00001100, 00110000, 11000000
+	const DWORD masks[] = { 3 << 0, 3 << 2, 3 << 4, 3 << 6 };
+	const int   shift[] = { 0, 2, 4, 6 };
+
+	// r steps through lines in y
+	for ( r=0; r < 4; r++, pOutputImage += width-4 )	// no width*4 as DWORD ptr inc will *4
+	{
+		// width * 4 bytes per pixel per line
+		// each j dxtc row is 4 lines of pixels
+
+		// n steps through pixels
+		for ( n=0; n < 4; n++ )
+		{
+			bits = pColorBlock->row[r] & masks[n];
+			bits >>= shift[n];
+
+			switch( bits )
+			{
+			case 0:
+				*pOutputImage = *col_0;
+				pOutputImage++;		// increment to next output pixel
+				break;
+			case 1:
+				*pOutputImage = *col_1;
+				pOutputImage++;
+				break;
+			case 2:
+				*pOutputImage = *col_2;
+				pOutputImage++;
+				break;
+			case 3:
+				*pOutputImage = *col_3;
+				pOutputImage++;
+				break;
+			default:
+				Assert( 0 );
+				pOutputImage++;
+				break;
+			}
+		}
+	}
+}
+
+template <class CDestPixel> 
+static inline void DecodeAlpha3BitLinear( CDestPixel *pImPos, DXTAlphaBlock3BitLinear *pAlphaBlock, int width, int nChannelSelect = 3 )
+{
+	static BYTE		gBits[4][4];
+	static WORD		gAlphas[8];
+	static BGRA8888_t	gACol[4][4];
+
+	gAlphas[0] = pAlphaBlock->alpha0;
+	gAlphas[1] = pAlphaBlock->alpha1;
+
+	// 8-alpha or 6-alpha block?    
+
+	if( gAlphas[0] > gAlphas[1] )
+	{
+		// 8-alpha block:  derive the other 6 alphas.    
+		// 000 = alpha_0, 001 = alpha_1, others are interpolated
+
+		gAlphas[2] = ( 6 * gAlphas[0] +     gAlphas[1]) / 7;	// bit code 010
+		gAlphas[3] = ( 5 * gAlphas[0] + 2 * gAlphas[1]) / 7;	// Bit code 011    
+		gAlphas[4] = ( 4 * gAlphas[0] + 3 * gAlphas[1]) / 7;	// Bit code 100    
+		gAlphas[5] = ( 3 * gAlphas[0] + 4 * gAlphas[1]) / 7;	// Bit code 101
+		gAlphas[6] = ( 2 * gAlphas[0] + 5 * gAlphas[1]) / 7;	// Bit code 110    
+		gAlphas[7] = (     gAlphas[0] + 6 * gAlphas[1]) / 7;	// Bit code 111
+	}    
+	else
+	{
+		// 6-alpha block:  derive the other alphas.    
+		// 000 = alpha_0, 001 = alpha_1, others are interpolated
+
+		gAlphas[2] = (4 * gAlphas[0] +     gAlphas[1]) / 5;	// Bit code 010
+		gAlphas[3] = (3 * gAlphas[0] + 2 * gAlphas[1]) / 5;	// Bit code 011    
+		gAlphas[4] = (2 * gAlphas[0] + 3 * gAlphas[1]) / 5;	// Bit code 100    
+		gAlphas[5] = (    gAlphas[0] + 4 * gAlphas[1]) / 5;	// Bit code 101
+		gAlphas[6] = 0;										// Bit code 110
+		gAlphas[7] = 255;									// Bit code 111
+	}
+
+	// Decode 3-bit fields into array of 16 BYTES with same value
+
+	// first two rows of 4 pixels each:
+	// pRows = (Alpha3BitRows*) & ( pAlphaBlock->stuff[0] );
+	const DWORD mask = 0x00000007;		// bits = 00 00 01 11
+
+	DWORD bits = *( (DWORD*) & ( pAlphaBlock->stuff[0] ));
+
+	gBits[0][0] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[0][1] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[0][2] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[0][3] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[1][0] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[1][1] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[1][2] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[1][3] = (BYTE)( bits & mask );
+
+	// now for last two rows:
+	bits = *( (DWORD*) & ( pAlphaBlock->stuff[3] ));		// last 3 bytes
+
+	gBits[2][0] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[2][1] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[2][2] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[2][3] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[3][0] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[3][1] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[3][2] = (BYTE)( bits & mask );
+	bits >>= 3;
+	gBits[3][3] = (BYTE)( bits & mask );
+
+	// decode the codes into alpha values
+	int row, pix;
+	for ( row = 0; row < 4; row++ )
+	{
+		for ( pix=0; pix < 4; pix++ )
+		{
+			gACol[row][pix].a = (BYTE) gAlphas[ gBits[row][pix] ];
+
+			Assert( gACol[row][pix].r == 0 );
+			Assert( gACol[row][pix].g == 0 );
+			Assert( gACol[row][pix].b == 0 );
+		}
+	}
+
+	// Write out alpha values to the image bits
+	for ( row=0; row < 4; row++, pImPos += width-4 )
+	{
+		for ( pix = 0; pix < 4; pix++ )
+		{
+			// zero the alpha bits of image pixel
+			switch ( nChannelSelect )
+			{
+				case 0:
+					pImPos->r = ( *(( BGRA8888_t *) &(gACol[row][pix])) ).a;
+					pImPos->g = 0;	// Danger...stepping on the other color channels
+					pImPos->b = 0;
+					pImPos->a = 0;
+					break;
+				case 1:
+					pImPos->g = ( *(( BGRA8888_t *) &(gACol[row][pix])) ).a;
+					break;
+				case 2:
+					pImPos->b = ( *(( BGRA8888_t *) &(gACol[row][pix])) ).a;
+					break;
+				default:
+				case 3:
+					pImPos->a = ( *(( BGRA8888_t *) &(gACol[row][pix])) ).a;
+					break;
+			}
+
+			pImPos++;
+		}
+	}
+}
+
+template <class CDestPixel> 
+static void ConvertFromDXT1( const uint8 *src, CDestPixel *dst, int width, int height )
+{
+	Assert( sizeof( BGRA8888_t ) == 4 );
+	Assert( sizeof( RGBA8888_t ) == 4 );
+	Assert( sizeof( RGB888_t ) == 3 );
+	Assert( sizeof( BGR888_t ) == 3 );
+	Assert( sizeof( BGR565_t ) == 2 );
+	Assert( sizeof( BGRA5551_t ) == 2 );
+	Assert( sizeof( BGRA4444_t ) == 2 );
+
+	int realWidth = 0;
+	int realHeight = 0;
+	CDestPixel *realDst = NULL;
+
+	// Deal with the case where we have a dimension smaller than 4.
+	if ( width < 4 || height < 4 )
+	{
+		realWidth = width;
+		realHeight = height;
+		// round up to the nearest four
+		width = ( width + 3 ) & ~3;
+		height = ( height + 3 ) & ~3;
+		realDst = dst;
+		dst = ( CDestPixel * )_alloca( width * height * sizeof( CDestPixel ) );
+		Assert( dst );
+	}
+	Assert( !( width % 4 ) );
+	Assert( !( height % 4 ) );
+
+	int xblocks, yblocks;
+	xblocks = width >> 2;
+	yblocks = height >> 2;
+	CDestPixel *pDstScan = dst;
+	DWORD *pSrcScan = ( DWORD * )src;
+
+	DXTColBlock *pBlock;
+	BGRA8888_t col_0, col_1, col_2, col_3;
+	WORD wrdDummy;
+
+	int i, j;
+	for ( j = 0; j < yblocks; j++ )
+	{
+		// 8 bytes per block
+		pBlock = ( DXTColBlock * )( ( uint8 * )pSrcScan + j * xblocks * 8 );
+		for ( i=0; i < xblocks; i++, pBlock++ )
+		{
+			GetColorBlockColorsBGRA8888( pBlock, &col_0, &col_1, &col_2, &col_3, wrdDummy );
+
+			// now decode the color block into the bitmap bits
+			// inline func:
+			pDstScan = dst + i*4 + j*4*width;
+			DecodeColorBlock<CDestPixel>( pDstScan, pBlock, width, &col_0, &col_1, &col_2, &col_3 );
+		}
+	}
+
+	// Deal with the case where we have a dimension smaller than 4.
+	if ( realDst )
+	{
+		int x, y;
+		for ( y = 0; y < realHeight; y++ )
+		{
+			for ( x = 0; x < realWidth; x++ )
+			{
+				realDst[x+(y*realWidth)] = dst[x+(y*width)];
+			}
+		}
+	}
+}
+
+template <class CDestPixel> 
+static void ConvertFromDXT5( const uint8 *src, CDestPixel *dst, int width, int height )
+{
+	int realWidth = 0;
+	int realHeight = 0;
+	CDestPixel *realDst = NULL;
+
+	// Deal with the case where we have a dimension smaller than 4.
+	if ( width < 4 || height < 4 )
+	{
+		realWidth = width;
+		realHeight = height;
+		// round up to the nearest four
+		width = ( width + 3 ) & ~3;
+		height = ( height + 3 ) & ~3;
+		realDst = dst;
+		dst = ( CDestPixel * )_alloca( width * height * sizeof( CDestPixel ) );
+		Assert( dst );
+	}
+	Assert( !( width % 4 ) );
+	Assert( !( height % 4 ) );
+
+	int xblocks, yblocks;
+	xblocks = width >> 2;
+	yblocks = height >> 2;
+	
+	CDestPixel *pDstScan = dst;
+	DWORD *pSrcScan = ( DWORD * )src;
+
+	DXTColBlock				*pBlock;
+	DXTAlphaBlock3BitLinear *pAlphaBlock;
+
+	BGRA8888_t col_0, col_1, col_2, col_3;
+	WORD wrd;
+
+	int i,j;
+	for ( j=0; j < yblocks; j++ )
+	{
+		// 8 bytes per block
+		// 1 block for alpha, 1 block for color
+		pBlock = (DXTColBlock*) ( (uint8 *)pSrcScan + j * xblocks * 16 );
+
+		for ( i=0; i < xblocks; i++, pBlock ++ )
+		{
+			// inline
+			// Get alpha block
+			pAlphaBlock = (DXTAlphaBlock3BitLinear*) pBlock;
+
+			// inline func:
+			// Get color block & colors
+			pBlock++;
+
+			GetColorBlockColorsBGRA8888( pBlock, &col_0, &col_1, &col_2, &col_3, wrd );
+
+			pDstScan = dst + i*4 + j*4*width;
+
+			// Decode the color block into the bitmap bits
+			// inline func:
+			DecodeColorBlock<CDestPixel>( pDstScan, pBlock, width, &col_0, &col_1, &col_2, &col_3 );
+
+			// Overwrite the previous alpha bits with the alpha block
+			//  info
+			DecodeAlpha3BitLinear( pDstScan, pAlphaBlock, width );
+		}
+	}
+
+	// Deal with the case where we have a dimension smaller than 4.
+	if ( realDst )
+	{
+		int x, y;
+		for( y = 0; y < realHeight; y++ )
+		{
+			for( x = 0; x < realWidth; x++ )
+			{
+				realDst[x+(y*realWidth)] = dst[x+(y*width)];
+			}
+		}
+	}
+}
+
+template <class CDestPixel> 
+static void ConvertFromDXT5IgnoreAlpha( const uint8 *src, CDestPixel *dst, int width, int height )
+{
+	int realWidth = 0;
+	int realHeight = 0;
+	CDestPixel *realDst = NULL;
+
+	// Deal with the case where we have a dimension smaller than 4.
+	if ( width < 4 || height < 4 )
+	{
+		realWidth = width;
+		realHeight = height;
+		// round up to the nearest four
+		width = ( width + 3 ) & ~3;
+		height = ( height + 3 ) & ~3;
+		realDst = dst;
+		dst = ( CDestPixel * )_alloca( width * height * sizeof( CDestPixel ) );
+		Assert( dst );
+	}
+	Assert( !( width % 4 ) );
+	Assert( !( height % 4 ) );
+
+	int xblocks, yblocks;
+	xblocks = width >> 2;
+	yblocks = height >> 2;
+	
+	CDestPixel *pDstScan = dst;
+	DWORD *pSrcScan = ( DWORD * )src;
+
+	DXTColBlock *pBlock;
+
+	BGRA8888_t col_0, col_1, col_2, col_3;
+	WORD wrd;
+
+	int i,j;
+	for ( j=0; j < yblocks; j++ )
+	{
+		// 8 bytes per block
+		// 1 block for alpha, 1 block for color
+		pBlock = (DXTColBlock*) ( (uint8 *)pSrcScan + j * xblocks * 16 );
+
+		for( i=0; i < xblocks; i++, pBlock ++ )
+		{
+			// inline func:
+			// Get color block & colors
+			pBlock++;
+
+			GetColorBlockColorsBGRA8888( pBlock, &col_0, &col_1, &col_2, &col_3, wrd );
+
+			pDstScan = dst + i*4 + j*4*width;
+
+			// Decode the color block into the bitmap bits
+			// inline func:
+			DecodeColorBlock<CDestPixel>( pDstScan, pBlock, width, &col_0, &col_1, &col_2, &col_3 );
+		}
+	}
+
+	// Deal with the case where we have a dimension smaller than 4.
+	if( realDst )
+	{
+		int x, y;
+		for( y = 0; y < realHeight; y++ )
+		{
+			for( x = 0; x < realWidth; x++ )
+			{
+				realDst[x+(y*realWidth)] = dst[x+(y*width)];
+			}
+		}
+	}
+}
+
+
+template <class CDestPixel> 
+static void ConvertFromATIxN( const uint8 *src, CDestPixel *dst, int width, int height, bool bATI2N )
+{
+	int realWidth = 0;
+	int realHeight = 0;
+	CDestPixel *realDst = NULL;
+
+	// Deal with the case where we have a dimension smaller than 4.
+	if ( width < 4 || height < 4 )
+	{
+		realWidth = width;
+		realHeight = height;
+		// round up to the nearest four
+		width = ( width + 3 ) & ~3;
+		height = ( height + 3 ) & ~3;
+		realDst = dst;
+		dst = ( CDestPixel * )_alloca( width * height * sizeof( CDestPixel ) );
+		Assert( dst );
+	}
+	Assert( !( width % 4 ) );
+	Assert( !( height % 4 ) );
+
+	int xblocks, yblocks;
+	xblocks = width >> 2;
+	yblocks = height >> 2;
+
+	CDestPixel *pDstScan = dst;
+	DWORD *pSrcScan = ( DWORD * )src;
+
+	DXTAlphaBlock3BitLinear	*pBlock;
+
+	int nBytesPerBlock = bATI2N ? 16 : 8;
+
+	int i,j;
+	for ( j=0; j < yblocks; j++ )
+	{
+		// 8 bytes per block
+		// 1 block for x, 1 block for y
+		pBlock = (DXTAlphaBlock3BitLinear*) ( (uint8 *)pSrcScan + j * xblocks * nBytesPerBlock );
+
+		for ( i=0; i < xblocks; i++, pBlock++ )
+		{
+			pDstScan = dst + i*4 + j*4*width;
+			DecodeAlpha3BitLinear( pDstScan, pBlock, width, 0 );
+
+			if ( bATI2N )
+			{
+				pBlock++;
+				DecodeAlpha3BitLinear( pDstScan, pBlock, width, 1 );
+			}
+		}
+	}
+
+	// Deal with the case where we have a dimension smaller than 4.
+	if ( realDst )
+	{
+		int x, y;
+		for( y = 0; y < realHeight; y++ )
+		{
+			for( x = 0; x < realWidth; x++ )
+			{
+				realDst[x+(y*realWidth)] = dst[x+(y*width)];
+			}
+		}
+	}
+}
+
+static DWORD GetDXTCEncodeType( ImageFormat imageFormat )
+{
+	switch ( imageFormat )
+	{
+	case IMAGE_FORMAT_DXT1:
+		return S3TC_ENCODE_RGB_FULL;
+	case IMAGE_FORMAT_DXT1_ONEBITALPHA:
+		return S3TC_ENCODE_RGB_FULL | S3TC_ENCODE_RGB_ALPHA_COMPARE;
+	case IMAGE_FORMAT_DXT3:
+		return S3TC_ENCODE_RGB_FULL | S3TC_ENCODE_ALPHA_EXPLICIT;
+	case IMAGE_FORMAT_DXT5:
+		return S3TC_ENCODE_RGB_FULL | S3TC_ENCODE_ALPHA_INTERPOLATED;
+	default:
+		return 0;
+	}
+}
+
+// Convert RGBA input to ATI1N or ATI2N format
+bool ConvertToATIxN(  const uint8 *src, ImageFormat srcImageFormat,
+					  uint8 *dst, ImageFormat dstImageFormat,
+					  int width, int height, int srcStride, int dstStride )
+{
+#if !defined( _X360 ) && !defined( POSIX )
+
+	// from rgb(a) to ATIxN
+	if( srcStride != 0 || dstStride != 0 )
+		return false;
+
+	// If we're not the right format for the ATI compressor, we bail
+	if ( srcImageFormat != IMAGE_FORMAT_ARGB8888 )
+		return false;
+
+	// Define source image parameters and copy the bits into buffer
+	ATI_TC_Texture srcTexture;
+	srcTexture.dwSize = sizeof( srcTexture );
+	srcTexture.dwWidth = width;
+	srcTexture.dwHeight = height;
+	srcTexture.dwPitch = srcStride;
+	srcTexture.format = ATI_TC_FORMAT_ARGB_8888;
+	srcTexture.dwDataSize = ATI_TC_CalculateBufferSize( &srcTexture );
+	srcTexture.pData = (ATI_TC_BYTE*) malloc( srcTexture.dwDataSize );
+	memcpy( srcTexture.pData, src, srcTexture.dwDataSize );
+
+	ATI_TC_Texture destTexture;
+	destTexture.dwSize = sizeof( destTexture );
+	destTexture.dwWidth = width;
+	destTexture.dwHeight = height;
+	destTexture.dwPitch = 0;
+	destTexture.format = dstImageFormat == IMAGE_FORMAT_ATI2N ? ATI_TC_FORMAT_ATI2N : ATI_TC_FORMAT_ATI1N;	// Assume it can only be one of these two...
+	destTexture.dwDataSize = ATI_TC_CalculateBufferSize( &destTexture );
+	destTexture.pData = (ATI_TC_BYTE*) dst;
+
+	ATI_TC_ERROR errATI = ATI_TC_ConvertTexture( &srcTexture, &destTexture, NULL, NULL, NULL, NULL );		// Convert it!
+	
+	free( srcTexture.pData );																				// Free temporary buffers
+
+	if ( errATI != ATI_TC_OK )
+		return false;
+
+	return true;
+#else
+	Assert( 0 );
+	return false;
+#endif
+}
+
+
+bool ConvertToDXTLegacy(  const uint8 *src, ImageFormat srcImageFormat,
+ 						  uint8 *dst, ImageFormat dstImageFormat, 
+					      int width, int height, int srcStride, int dstStride )
+{
+#if !defined( _X360 ) && !defined( POSIX )
+	// from rgb(a) to dxtN
+	if( srcStride != 0 || dstStride != 0 )
+		return false;
+
+	DDSURFACEDESC descIn;
+	DDSURFACEDESC descOut;
+	memset( &descIn, 0, sizeof(descIn) );
+	memset( &descOut, 0, sizeof(descOut) );
+	float weight[3] = {0.3086f, 0.6094f, 0.0820f};
+	DWORD dwEncodeType = GetDXTCEncodeType( dstImageFormat );
+	
+	// Setup descIn
+	descIn.dwSize = sizeof(descIn);
+	descIn.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_LPSURFACE | 
+		/*DDSD_PITCH | */ DDSD_PIXELFORMAT;
+	descIn.dwWidth = width;
+	descIn.dwHeight = height;
+	descIn.lPitch = width * ImageLoader::SizeInBytes( srcImageFormat );
+	descIn.lpSurface = ( LPVOID *) src;
+	descIn.ddpfPixelFormat.dwSize = sizeof( DDPIXELFORMAT );
+	switch ( srcImageFormat )
+	{
+	case IMAGE_FORMAT_RGBA8888:
+		descIn.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
+		descIn.ddpfPixelFormat.dwRGBBitCount = 32;
+		descIn.ddpfPixelFormat.dwRBitMask = 0x0000ff;
+		descIn.ddpfPixelFormat.dwGBitMask = 0x00ff00;
+		descIn.ddpfPixelFormat.dwBBitMask = 0xff0000;
+		// must set this anyway or S3TC will lock up!!!
+		descIn.ddpfPixelFormat.dwRGBAlphaBitMask = 0xff000000;
+		break;
+	case IMAGE_FORMAT_BGRA8888:
+		descIn.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
+		descIn.ddpfPixelFormat.dwRGBBitCount = 32;
+		descIn.ddpfPixelFormat.dwRBitMask = 0xFF0000;
+		descIn.ddpfPixelFormat.dwGBitMask = 0x00ff00;
+		descIn.ddpfPixelFormat.dwBBitMask = 0x0000FF;
+		// must set this anyway or S3TC will lock up!!!
+		descIn.ddpfPixelFormat.dwRGBAlphaBitMask = 0xff000000;
+		break;
+	case IMAGE_FORMAT_BGRX8888:
+		descIn.ddpfPixelFormat.dwFlags = DDPF_RGB;
+		descIn.ddpfPixelFormat.dwRGBBitCount = 32;
+		descIn.ddpfPixelFormat.dwRBitMask = 0xFF0000;
+		descIn.ddpfPixelFormat.dwGBitMask = 0x00ff00;
+		descIn.ddpfPixelFormat.dwBBitMask = 0x0000FF;
+		// must set this anyway or S3TC will lock up!!!
+		descIn.ddpfPixelFormat.dwRGBAlphaBitMask = 0xff000000;
+		break;
+	case IMAGE_FORMAT_RGB888:
+		descIn.ddpfPixelFormat.dwFlags = DDPF_RGB;
+		descIn.ddpfPixelFormat.dwRGBBitCount = 24;
+		descIn.ddpfPixelFormat.dwRBitMask = 0x0000ff;
+		descIn.ddpfPixelFormat.dwGBitMask = 0x00ff00;
+		descIn.ddpfPixelFormat.dwBBitMask = 0xff0000;
+		descIn.ddpfPixelFormat.dwRGBAlphaBitMask = 0xff000000;
+		break;
+	default:
+		return false;
+	}
+	
+	// Setup descOut
+	descOut.dwSize = sizeof( descOut );
+	
+	// Encode the texture
+	S3TCencode( &descIn, NULL, &descOut, dst, dwEncodeType, weight );
+	return true;
+#else
+	Assert( 0 );
+	return false;
+#endif
+}
+
+template < typename SrcPixel_t >
+void CompressSTB( uint8 *pDstBytes, ImageFormat dstFmt, const uint8 *pSrcBytes, int nWidth, int nHeight )
+{
+	const bool cbWriteAlpha = ( dstFmt == IMAGE_FORMAT_DXT5 );
+	const uint32 cDstStride = ( dstFmt == IMAGE_FORMAT_DXT1 ) ? 8 : 16;
+
+	const uint32 cPixX = (uint32) nWidth;
+	const uint32 cPixY = (uint32) nHeight;
+	const uint32 cSrcPitch = cPixX * sizeof( SrcPixel_t );
+	const uint32 cLastX = cPixX - 1;
+	const uint32 cLastY = cPixY - 1;
+
+	// STB always takes blocks as 4x4 of RGBA8888_t
+	RGBA8888_t srcBlock[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+	SrcPixel_t* pSrcs[4] = { 0, 0, 0, 0 };
+
+	for ( uint32 y = 0; y < cPixY; y += 4 ) 
+	{
+		// This handles clamping for cPixY % 4 != 0
+		pSrcs[ 0 ] = ( SrcPixel_t* ) ( pSrcBytes + cSrcPitch * Min( y + 0, cLastY ) );
+		pSrcs[ 1 ] = ( SrcPixel_t* ) ( pSrcBytes + cSrcPitch * Min( y + 1, cLastY ) );
+		pSrcs[ 2 ] = ( SrcPixel_t* ) ( pSrcBytes + cSrcPitch * Min( y + 2, cLastY ) );
+		pSrcs[ 3 ] = ( SrcPixel_t* ) ( pSrcBytes + cSrcPitch * Min( y + 3, cLastY ) );
+
+		for ( uint x = 0; x < cPixX; x += 4 ) 
+		{
+			for ( uint i = 0; i < 4; ++i )
+			{
+				uint32 offsetX = Min( x + i, cLastX );
+				srcBlock[ 0 + i ] =  pSrcs[ 0 ][ offsetX ];
+				srcBlock[ 4 + i ] =  pSrcs[ 1 ][ offsetX ];
+				srcBlock[ 8 + i ] =  pSrcs[ 2 ][ offsetX ];
+				srcBlock[ 12 + i ] = pSrcs[ 3 ][ offsetX ];
+			}
+
+			stb_compress_dxt_block( pDstBytes, ( const uint8* ) srcBlock, cbWriteAlpha, STB_DXT_NORMAL );
+			pDstBytes += cDstStride;
+		}
+	}
+}
+
+inline ImageFormat GetTrueImageFormat( ImageFormat fmt )
+{
+	switch ( fmt )
+	{
+	case IMAGE_FORMAT_DXT1_RUNTIME:
+		return IMAGE_FORMAT_DXT1;
+	case IMAGE_FORMAT_DXT5_RUNTIME:
+		return IMAGE_FORMAT_DXT5;
+	default: /* expected */
+		break;
+	}
+
+	return fmt;
+}
+
+bool ConvertToDXTRuntime( const uint8 *src, ImageFormat srcImageFormat,
+						  uint8 *dst, ImageFormat dstImageFormat,
+						  int width, int height, int srcStride, int dstStride )
+{
+	if ( srcStride != 0 || dstStride != 0 )
+		return false;
+
+	dstImageFormat = GetTrueImageFormat( dstImageFormat );
+
+	switch ( srcImageFormat )
+	{
+		case IMAGE_FORMAT_RGBA8888: CompressSTB<RGBA8888_t>( dst, dstImageFormat, src, width, height ); return true;
+		case IMAGE_FORMAT_RGB888:   CompressSTB<RGB888_t>  ( dst, dstImageFormat, src, width, height ); return true;
+		case IMAGE_FORMAT_BGRA8888: CompressSTB<BGRA8888_t>( dst, dstImageFormat, src, width, height ); return true;
+		case IMAGE_FORMAT_BGRX8888: CompressSTB<BGRX8888_t>( dst, dstImageFormat, src, width, height ); return true;
+		default:
+			Assert( !"Unexpected format here, wtf." );
+			break;
+	};
+
+	return false;
+}
+
+bool ConvertToDXT( const uint8 *src, ImageFormat srcImageFormat,
+ 				   uint8 *dst, ImageFormat dstImageFormat, 
+				   int width, int height, int srcStride, int dstStride )
+{
+	// The STB compressor (the new compressor) is faster and higher quality in most cases, and has less error overall
+	// than the S3TC compressor. So use it by default, unless we're working with a format that STB doesn't support.
+	bool bUseNewCompressor = dstImageFormat != IMAGE_FORMAT_DXT1_ONEBITALPHA 
+		                  && dstImageFormat != IMAGE_FORMAT_DXT3;
+
+//	bool bUseNewCompressor = dstImageFormat == IMAGE_FORMAT_DXT1_RUNTIME 
+//		                  || dstImageFormat == IMAGE_FORMAT_DXT5_RUNTIME;
+
+	if ( bUseNewCompressor )
+		return ConvertToDXTRuntime( src, srcImageFormat, dst, dstImageFormat, width, height, srcStride, dstStride );
+
+	return ConvertToDXTLegacy( src, srcImageFormat, dst, dstImageFormat, width, height, srcStride, dstStride );
+}
+
+// HDRFIXME: This assumes that the 16-bit integer values are 4.12 fixed-point.
+void ConvertImageFormat_RGBA16161616_To_RGB323232F( unsigned short *pSrcImage, float *pDstImage, int width, int height )
+{
+	int srcSize = width * height * 4;
+	unsigned short *pSrcEnd = pSrcImage + srcSize;
+	unsigned short *pSrcScan = pSrcImage;
+	float *pDstScan = pDstImage;
+	for ( ; pSrcScan < pSrcEnd; pSrcScan += 4, pDstScan += 3 )
+	{
+		pDstScan[0] = ( ( float )pSrcScan[0] ) * ( 1.0f / ( ( float )( 1 << 12 ) ) );
+		pDstScan[1] = ( ( float )pSrcScan[1] ) * ( 1.0f / ( ( float )( 1 << 12 ) ) );
+		pDstScan[2] = ( ( float )pSrcScan[2] ) * ( 1.0f / ( ( float )( 1 << 12 ) ) );
+	}
+}
+
+// HDRFIXME: This assumes that the 16-bit integer values are 4.12 fixed-point.
+void ConvertImageFormat_RGB323232F_To_RGBA16161616( float *pSrcImage, unsigned short *pDstImage, int width, int height )
+{
+	int srcSize = width * height * 3;
+	float *pSrcEnd = pSrcImage + srcSize;
+	float *pSrcScan = pSrcImage;
+	unsigned short *pDstScan = pDstImage;
+	for ( ; pSrcScan < pSrcEnd; pSrcScan += 3, pDstScan += 4 )
+	{
+
+		pDstScan[0] = ( unsigned short )min( 65535.0f, ( pSrcScan[0] * ( ( ( float )( 1 << 12 ) ) ) ) );
+		pDstScan[1] = ( unsigned short )min( 65535.0f, ( pSrcScan[1] * ( ( ( float )( 1 << 12 ) ) ) ) );
+		pDstScan[2] = ( unsigned short )min( 65535.0f, ( pSrcScan[2] * ( ( ( float )( 1 << 12 ) ) ) ) );
+		pDstScan[3] = 65535;
+	}
+}
+
+void ConvertImageFormat_RGBA16161616F_To_RGB323232F( float16 *pSrcImage, float *pDstImage, int width, int height )
+{
+	int srcSize = width * height * 4;
+	float16 *pSrcEnd = pSrcImage + srcSize;
+	float16 *pSrcScan = pSrcImage;
+	float *pDstScan = pDstImage;
+	for( ; pSrcScan < pSrcEnd; pSrcScan += 4, pDstScan += 3 )
+	{
+		pDstScan[0] = pSrcScan[0].GetFloat();
+		pDstScan[1] = pSrcScan[1].GetFloat();
+		pDstScan[2] = pSrcScan[2].GetFloat();
+	}
+}
+
+void ConvertImageFormat_RGBA16161616F_To_RGBA323232F( float16 *pSrcImage, float *pDstImage, int width, int height , size_t src_stride)
+{
+	size_t s_stride=src_stride/2;
+	for(int y=0; y<height; y++)
+	{
+		float16 const *pSrcScan=pSrcImage;
+		float *pDstScan = pDstImage;
+		for(int x=0; x<width; x++)
+		{
+			pDstScan[0] = pSrcScan[0].GetFloat();
+			pDstScan[1] = pSrcScan[1].GetFloat();
+			pDstScan[2] = pSrcScan[2].GetFloat();
+			pDstScan[3] = pSrcScan[3].GetFloat();
+			pDstScan+=4;
+			pSrcScan+=4;
+		}
+		pSrcImage += s_stride;
+		pDstImage+=4*width;
+	}
+}
+
+
+void ConvertImageFormat_RGB323232F_To_RGBA16161616F( float *pSrcImage, float16 *pDstImage, int width, int height )
+{
+	int srcSize = width * height * 3;
+	float *pSrcEnd = pSrcImage + srcSize;
+	float *pSrcScan = pSrcImage;
+	float16 *pDstScan = pDstImage;
+	for( ; pSrcScan < pSrcEnd; pSrcScan += 3, pDstScan += 4 )
+	{
+		pDstScan[0].SetFloat( pSrcScan[0] );
+		pDstScan[1].SetFloat( pSrcScan[1] );
+		pDstScan[2].SetFloat( pSrcScan[2] );
+	}
+}
+
+void ConvertImageFormat_RGB323232F_To_RGBA8888( float *pSrcImage, uint8 *dst, int width, int height )
+{
+	FloatBitMap_t flbm;
+	flbm.AllocateRGB( width, height );
+
+	// Set the pixels
+	for ( int y = 0; y < height; ++ y )
+	{
+		for ( int x = 0; x < width; ++ x )
+		{
+			float *pf = &pSrcImage[ 3 * ( x + width * y ) ];
+			PixRGBAF fpix;
+			fpix.Red = pf[0];
+			fpix.Green = pf[1];
+			fpix.Blue = pf[2];
+			fpix.Alpha = 0.f;
+			
+			flbm.WritePixelRGBAF( x, y, fpix );
+		}
+	}
+	// memcpy( flbm.RGBAData, pSrcImage, width * height * 4 );
+	
+	flbm.CompressTo8Bits( 8.0 );
+
+	// Now, get the pixels
+	for ( int y = 0; y < height; ++ y )
+	{
+		for ( int x = 0; x < width; ++ x )
+		{
+			PixRGBAF fpix = flbm.PixelRGBAF( x, y );
+			PixRGBA8 pix8 = PixRGBAF_to_8( fpix );
+
+			uint8 *pch = &dst[ 4 * ( x + width * y ) ];
+
+			pch[0] = pix8.Red;
+			pch[1] = pix8.Green;
+			pch[2] = pix8.Blue;
+			pch[3] = pix8.Alpha;
+		}
+	}
+}
+
+void ConvertImageFormat_RGB323232F_To_BGRA8888( float *pSrcImage, uint8 *dst, int width, int height )
+{
+	FloatBitMap_t flbm;
+	flbm.AllocateRGB( width, height );
+
+	// Set the pixels
+	for ( int y = 0; y < height; ++ y )
+	{
+		for ( int x = 0; x < width; ++ x )
+		{
+			float *pf = &pSrcImage[ 3 * ( x + width * y ) ];
+			PixRGBAF fpix;
+			fpix.Red = pf[0];
+			fpix.Green = pf[1];
+			fpix.Blue = pf[2];
+			fpix.Alpha = 0.f;
+
+			flbm.WritePixelRGBAF( x, y, fpix );
+		}
+	}
+	// memcpy( flbm.RGBAData, pSrcImage, width * height * 4 );
+
+	flbm.CompressTo8Bits( 8.0 );
+
+	// Now, get the pixels
+	for ( int y = 0; y < height; ++ y )
+	{
+		for ( int x = 0; x < width; ++ x )
+		{
+			PixRGBAF fpix = flbm.PixelRGBAF( x, y );
+			PixRGBA8 pix8 = PixRGBAF_to_8( fpix );
+
+			uint8 *pch = &dst[ 4 * ( x + width * y ) ];
+
+			pch[0] = pix8.Blue;
+			pch[1] = pix8.Green;
+			pch[2] = pix8.Red;
+			pch[3] = pix8.Alpha;
+		}
+	}
+}
+
+// HDRFIXME: This assumes that the 16-bit integer values are 4.12 fixed-point.
+void ConvertImageFormat_RGBA16161616_To_RGBA16161616F( unsigned short *pSrcImage, float *pDstImage, int width, int height )
+{
+	int srcSize = width * height * 4;
+	unsigned short *pSrcEnd = pSrcImage + srcSize;
+	unsigned short *pSrcScan = pSrcImage;
+	float16 *pDstScan = ( float16 * )pDstImage;
+	for( ; pSrcScan < pSrcEnd; pSrcScan += 4, pDstScan += 4 )
+	{
+		pDstScan[0].SetFloat( pSrcScan[0] * ( 1.0f / ( float )( 1 << 16 ) ) );
+		pDstScan[1].SetFloat( pSrcScan[1] * ( 1.0f / ( float )( 1 << 16 ) ) );
+		pDstScan[2].SetFloat( pSrcScan[2] * ( 1.0f / ( float )( 1 << 16 ) ) );
+		pDstScan[3].SetFloat( pSrcScan[3] * ( 1.0f / ( float )( 1 << 16 ) ) );
+	}
+}
+
+void ConvertImageFormat_RGBA16161616F_To_RGBA16161616( float16 *pSrcImage, unsigned short *pDstImage, int width, int height )
+{
+	int srcSize = width * height * 4;
+	float16 *pSrcEnd = pSrcImage + srcSize;
+	float16 *pSrcScan = pSrcImage;
+	unsigned short *pDstScan = pDstImage;
+	for( ; pSrcScan < pSrcEnd; pSrcScan += 4, pDstScan += 4 )
+	{
+		int i;
+		for( i = 0; i < 4; i++ )
+		{
+			float val;
+			val = pSrcScan[i].GetFloat();
+			val *= ( float )( 1 << 12 );
+			val = max( val, 0.f );
+			val = min( val, 65535.0f );
+			pDstScan[i] = ( unsigned short )val;
+		}
+	}
+}
+
+bool ConvertImageFormat( const uint8 *src, ImageFormat srcImageFormat,
+ 					     uint8 *dst, ImageFormat dstImageFormat, 
+						 int width, int height, int srcStride, int dstStride )
+{
+	// HDRFIXME: WE NEED A BIGGER INTERMEDIATE FORMAT!!!!!
+	if ( srcImageFormat == IMAGE_FORMAT_RGBA16161616 )
+	{
+		if ( dstImageFormat == IMAGE_FORMAT_RGB323232F )
+		{
+			Assert( srcStride == 0 && dstStride == 0 );
+			ConvertImageFormat_RGBA16161616_To_RGB323232F( ( unsigned short * )src, ( float * )dst, width, height );
+			return true;
+		}
+		if ( dstImageFormat == IMAGE_FORMAT_RGBA16161616F )
+		{
+			Assert( srcStride == 0 && dstStride == 0 );
+			ConvertImageFormat_RGBA16161616_To_RGBA16161616F( ( unsigned short * )src, ( float * )dst, width, height );
+			return true;
+		}
+	}
+	else if ( srcImageFormat == IMAGE_FORMAT_RGBA16161616F )
+	{	
+		if ( dstImageFormat == IMAGE_FORMAT_RGB323232F )
+		{
+			Assert( srcStride == 0 && dstStride == 0 );
+			ConvertImageFormat_RGBA16161616F_To_RGB323232F( ( float16 * )src, ( float * )dst, width, height );
+			return true;
+		}
+		if ( dstImageFormat == IMAGE_FORMAT_RGBA32323232F )
+		{
+			Assert( dstStride == 0 );
+			ConvertImageFormat_RGBA16161616F_To_RGBA323232F( ( float16 * )src, ( float * )dst, width, height, srcStride );
+			return true;
+		}
+		if ( dstImageFormat == IMAGE_FORMAT_RGBA16161616 )
+		{
+			Assert( srcStride == 0 && dstStride == 0 );
+			ConvertImageFormat_RGBA16161616F_To_RGBA16161616( ( float16 * )src, ( unsigned short * )dst, width, height );
+			return true;
+		}
+	}
+	else if ( srcImageFormat == IMAGE_FORMAT_RGB323232F )
+	{
+		if ( dstImageFormat == IMAGE_FORMAT_RGBA16161616 )
+		{
+			Assert( srcStride == 0 && dstStride == 0 );
+			ConvertImageFormat_RGB323232F_To_RGBA16161616( ( float * )src, ( unsigned short * )dst, width, height );
+			return true;
+		}
+		if ( dstImageFormat == IMAGE_FORMAT_RGBA16161616F )
+		{
+			Assert( srcStride == 0 && dstStride == 0 );
+			ConvertImageFormat_RGB323232F_To_RGBA16161616F( ( float * )src, ( float16 * )dst, width, height );
+			return true;
+		}
+		if ( dstImageFormat == IMAGE_FORMAT_RGBA8888 )
+		{
+			Assert( srcStride == 0 );
+			ConvertImageFormat_RGB323232F_To_RGBA8888( ( float * )src, dst, width, height );
+			return true;
+		}
+		if ( dstImageFormat == IMAGE_FORMAT_BGRA8888 )
+		{
+			Assert( srcStride == 0 );
+			ConvertImageFormat_RGB323232F_To_BGRA8888( ( float * )src, dst, width, height );
+			return true;
+		}
+	}
+	
+	// Fast path for just copying a compressed texture
+	if ( ( ( dstImageFormat == IMAGE_FORMAT_DXT1 || dstImageFormat == IMAGE_FORMAT_DXT1_RUNTIME ||
+		     dstImageFormat == IMAGE_FORMAT_DXT3 ||
+		     dstImageFormat == IMAGE_FORMAT_DXT5 || dstImageFormat == IMAGE_FORMAT_DXT5_RUNTIME ||
+		     dstImageFormat == IMAGE_FORMAT_ATI1N ||
+		     dstImageFormat == IMAGE_FORMAT_ATI2N ) && ( srcImageFormat == dstImageFormat ) ) ||
+		 ( dstImageFormat == IMAGE_FORMAT_DXT5 && srcImageFormat == IMAGE_FORMAT_DXT5_RUNTIME ) ||
+		 ( dstImageFormat == IMAGE_FORMAT_DXT1 && srcImageFormat == IMAGE_FORMAT_DXT1_RUNTIME ) ||
+		 ( dstImageFormat == IMAGE_FORMAT_DXT5_RUNTIME && srcImageFormat == IMAGE_FORMAT_DXT5 ) ||
+		 ( dstImageFormat == IMAGE_FORMAT_DXT1_RUNTIME && srcImageFormat == IMAGE_FORMAT_DXT1 ) )
+	{
+		// Fast path for compressed textures . . stride doesn't make as much sense.
+//		Assert( srcStride == 0 && dstStride == 0 );
+
+		int memRequired;
+		memRequired = GetMemRequired( width, height, 1, srcImageFormat, false );
+		memcpy( dst, src, memRequired );
+		return true;
+	}
+	else if ( ( srcImageFormat == IMAGE_FORMAT_RGBA8888 ||		
+			   srcImageFormat == IMAGE_FORMAT_RGB888    ||														// RGBA source
+			   srcImageFormat == IMAGE_FORMAT_BGRA8888  ||														//
+			   srcImageFormat == IMAGE_FORMAT_BGRX8888 ) &&	   													// and
+			 ( dstImageFormat == IMAGE_FORMAT_DXT1  ||															//
+			   dstImageFormat == IMAGE_FORMAT_DXT3  ||	   														// DXT compressed dest
+			   dstImageFormat == IMAGE_FORMAT_DXT5  ||
+			   dstImageFormat == IMAGE_FORMAT_DXT1_RUNTIME ||
+			   dstImageFormat == IMAGE_FORMAT_DXT5_RUNTIME ) )
+	{
+		return ConvertToDXT( src, srcImageFormat, dst, dstImageFormat, width, height, srcStride, dstStride );
+	}
+	else if ( ( srcImageFormat == IMAGE_FORMAT_ARGB8888 ) &&									 				// RGBA source and
+			  ( dstImageFormat == IMAGE_FORMAT_ATI1N    || dstImageFormat == IMAGE_FORMAT_ATI2N ) )				// ATI compressed dest
+	{
+		return ConvertToATIxN( src, srcImageFormat, dst, dstImageFormat, width, height, srcStride, dstStride );
+	}
+	else if ( ( dstImageFormat == IMAGE_FORMAT_RGBA8888 ||
+			   dstImageFormat == IMAGE_FORMAT_BGRX8888 ||
+			   dstImageFormat == IMAGE_FORMAT_BGRA8888 ||
+			   dstImageFormat == IMAGE_FORMAT_BGRA4444 ||
+			   dstImageFormat == IMAGE_FORMAT_BGRA5551 ||
+			   dstImageFormat == IMAGE_FORMAT_BGRX5551 ||
+			   dstImageFormat == IMAGE_FORMAT_BGR565 ||
+			   dstImageFormat == IMAGE_FORMAT_BGR888 ||
+			   dstImageFormat == IMAGE_FORMAT_RGB888 ) &&
+			 ( srcImageFormat == IMAGE_FORMAT_DXT1  ||
+			   srcImageFormat == IMAGE_FORMAT_DXT3  ||
+			   srcImageFormat == IMAGE_FORMAT_DXT5  ||
+			   srcImageFormat == IMAGE_FORMAT_ATI1N ||
+			   srcImageFormat == IMAGE_FORMAT_ATI2N ) )
+	{
+		// from dxtN to rgb(a)
+		if ( srcStride != 0 || dstStride != 0 )
+		{
+			return false;
+		}
+		if ( srcImageFormat == IMAGE_FORMAT_DXT1 )
+		{
+			if ( dstImageFormat == IMAGE_FORMAT_RGBA8888 )
+			{
+				ConvertFromDXT1( src, ( RGBA8888_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGRA8888 ||
+			    dstImageFormat == IMAGE_FORMAT_BGRX8888 )
+			{
+				ConvertFromDXT1( src, ( BGRA8888_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_RGB888 )
+			{
+				ConvertFromDXT1( src, ( RGB888_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGR888 )
+			{
+				ConvertFromDXT1( src, ( BGR888_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGR565 )
+			{
+				ConvertFromDXT1( src, ( BGR565_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGRA5551 ||
+				dstImageFormat == IMAGE_FORMAT_BGRX5551 )
+			{
+				ConvertFromDXT1( src, ( BGRA5551_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGRA4444 )
+			{
+				ConvertFromDXT1( src, ( BGRA4444_t * )dst, width, height );
+				return true;
+			}
+		}
+		else if ( srcImageFormat == IMAGE_FORMAT_ATI2N )
+		{
+			if ( dstImageFormat == IMAGE_FORMAT_BGRA8888 )
+			{
+				ConvertFromATIxN( src, ( BGRA8888_t * )dst, width, height, true );
+				return true;
+			}
+		}
+		else if ( srcImageFormat == IMAGE_FORMAT_ATI1N )
+		{
+			if ( dstImageFormat == IMAGE_FORMAT_BGRA8888 )
+			{
+				ConvertFromATIxN( src, ( BGRA8888_t * )dst, width, height, false );
+				return true;
+			}
+		}
+		else if ( srcImageFormat == IMAGE_FORMAT_DXT5 )
+		{
+			if ( dstImageFormat == IMAGE_FORMAT_RGBA8888 )
+			{
+				ConvertFromDXT5( src, ( RGBA8888_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGRA8888 ||
+			    dstImageFormat == IMAGE_FORMAT_BGRX8888 )
+			{
+				ConvertFromDXT5( src, ( BGRA8888_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_RGB888 )
+			{
+				ConvertFromDXT5IgnoreAlpha( src, ( RGB888_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGR888 )
+			{
+				ConvertFromDXT5IgnoreAlpha( src, ( BGR888_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGR565 )
+			{
+				ConvertFromDXT5IgnoreAlpha( src, ( BGR565_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGRA5551 ||
+				dstImageFormat == IMAGE_FORMAT_BGRX5551 )
+			{
+				ConvertFromDXT5( src, ( BGRA5551_t * )dst, width, height );
+				return true;
+			}
+			if ( dstImageFormat == IMAGE_FORMAT_BGRA4444 )
+			{
+				ConvertFromDXT5( src, ( BGRA4444_t * )dst, width, height );
+				return true;
+			}
+		}
+		return false;
+	}
+	else if ( dstImageFormat == IMAGE_FORMAT_DXT1  ||
+			  dstImageFormat == IMAGE_FORMAT_DXT3  ||
+			  dstImageFormat == IMAGE_FORMAT_DXT5  ||
+			  dstImageFormat == IMAGE_FORMAT_ATI1N ||
+			  dstImageFormat == IMAGE_FORMAT_ATI2N ||
+			  srcImageFormat == IMAGE_FORMAT_DXT1  ||
+			  srcImageFormat == IMAGE_FORMAT_DXT3  ||
+			  srcImageFormat == IMAGE_FORMAT_DXT5  ||
+			  srcImageFormat == IMAGE_FORMAT_ATI1N ||
+			  srcImageFormat == IMAGE_FORMAT_ATI2N )
+	{
+		// DxtN to DxtN
+		Assert( IsPC() );
+		return false;
+	}
+	else
+	{
+		// uncompressed textures
+		int line;
+		int srcPixelSize = SizeInBytes(srcImageFormat);
+		int dstPixelSize = SizeInBytes(dstImageFormat);
+		
+		if ( srcStride == 0 )
+		{
+			srcStride = srcPixelSize * width;
+		}
+		if ( dstStride == 0 )
+		{
+			dstStride = dstPixelSize * width;
+		}
+		
+		// Fast path...
+		if( ( srcImageFormat == dstImageFormat ) || 
+			((srcImageFormat == IMAGE_FORMAT_BGRA8888) && (dstImageFormat == IMAGE_FORMAT_BGRX8888)) )
+		{
+			if ( IsX360() && ( srcStride == dstStride ) && ( width*srcPixelSize == srcStride ) )
+			{
+				// fastest path
+				memcpy( dst, src, height*srcStride ); 
+				return true;
+			}
+
+			for ( line = 0; line < height; ++line )
+			{
+				memcpy( dst, src, width*srcPixelSize ); 
+				dst += dstStride;
+				src += srcStride;
+			}
+			return true;
+		}
+		
+		// format conversion
+		uint8 *lineBufRGBA8888 = (uint8 *)_alloca(width*4);
+		
+		UserFormatToRGBA8888Func_t userFormatToRGBA8888Func;
+		RGBA8888ToUserFormatFunc_t RGBA8888ToUserFormatFunc;
+		
+		userFormatToRGBA8888Func = GetUserFormatToRGBA8888Func_t( srcImageFormat );
+		RGBA8888ToUserFormatFunc = GetRGBA8888ToUserFormatFunc_t( dstImageFormat );
+		
+		if ( !userFormatToRGBA8888Func || !RGBA8888ToUserFormatFunc )
+		{
+			return false;
+		}
+
+		for ( line = 0; line < height; line++ )
+		{
+			userFormatToRGBA8888Func( src + line * srcStride, lineBufRGBA8888, width );
+			RGBA8888ToUserFormatFunc( lineBufRGBA8888, dst + line * dstStride, width );
+		}
+		return true;
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Color conversion routines
+//-----------------------------------------------------------------------------
+void ConvertIA88ImageToNormalMapRGBA8888( const uint8 *src, int width, 
+										  int height, uint8 *dst,
+										  float bumpScale )
+{
+	float heightScale = ( 1.0f / 255.0f ) * bumpScale;
+	float c, cx, cy;
+	float maxDim = ( width > height ) ? width : height;
+	float ooMaxDim = 1.0f / maxDim;
+
+	int s, t;
+	for( t = 0; t < height; t++ )
+	{
+		uint8 *dstPixel = &dst[t * width * 4];
+		for( s = 0; s < width; s++ )
+		{
+			c = src[( t * width + s ) * 2];
+			cx = src[( t * width + ((s+1)%width) ) * 2];
+			cy = src[( ((t+1)%height) * width + s ) * 2];
+
+			/*
+			// \Z (out of screen)
+			//  \
+			//   \
+			//    \
+			//     \-----------  X
+			//     |
+			//     |
+			//     |
+			//     |
+			//     |
+			//     Y
+			*/
+			
+			Vector xVect, yVect, normal;
+			xVect[0] = ooMaxDim;
+			xVect[1] = 0.0f;
+			xVect[2] = (cx - c) * heightScale;
+
+			yVect[0] = 0.0f;
+			yVect[1] = ooMaxDim;
+			yVect[2] = (cy - c) * heightScale;
+
+			CrossProduct( xVect, yVect, normal );
+			VectorNormalize( normal );
+
+			/* Repack the normalized vector into an RGB unsigned byte
+			vector in the normal map image. */
+			dstPixel[0] = ( uint8 )( 128 + 127*normal[0] );
+			dstPixel[1] = ( uint8 )( 128 + 127*normal[1] );
+			dstPixel[2] = ( uint8 )( 128 + 127*normal[2] );
+			dstPixel[3] = src[( ( t * width + s ) * 2 ) + 1];
+			dstPixel += 4;
+		}
+	}
+}
+
+void ConvertNormalMapRGBA8888ToDUDVMapUVWQ8888( const uint8 *src, int width, int height,
+										                     uint8 *dst_ )
+{
+	unsigned const char *lastPixel = src + width * height * 4;
+	char *dst = ( char * )dst_; // NOTE: this is signed!!!!
+
+	for( ; src < lastPixel; src += 4, dst += 4 )
+	{
+		dst[0] = ( char )( ( ( int )src[0] ) - 127 );
+		dst[1] = ( char )( ( ( int )src[1] ) - 127 );
+		dst[2] = ( char )( ( ( int )src[2] ) - 127 );
+		dst[3] = ( char )( ( ( int )src[3] ) - 127 );
+	}
+}
+
+void ConvertNormalMapRGBA8888ToDUDVMapUVLX8888( const uint8 *src, int width, int height,
+										                     uint8 *dst_ )
+{
+	unsigned const char *lastPixel = src + width * height * 4;
+	char *dst = ( char * )dst_; // NOTE: this is signed!!!!
+
+	for( ; src < lastPixel; src += 4, dst += 4 )
+	{
+		dst[0] = ( char )( ( ( int )src[0] ) - 127 );
+		dst[1] = ( char )( ( ( int )src[1] ) - 127 );
+
+		uint8 *pUDst = (uint8 *)dst;
+		pUDst[2] = src[3];
+		pUDst[3] = 0xFF;
+	}
+}
+
+void ConvertNormalMapRGBA8888ToDUDVMapUV88( const uint8 *src, int width, int height,
+										                     uint8 *dst_ )
+{
+	unsigned const char *lastPixel = src + width * height * 4;
+	char *dst = ( char * )dst_; // NOTE: this is signed!!!!
+
+	for( ; src < lastPixel; src += 4, dst += 2 )
+	{
+		dst[0] = ( char )( ( ( int )src[0] ) - 127 );
+		dst[1] = ( char )( ( ( int )src[1] ) - 127 );
+	}
+}
+
+void NormalizeNormalMapRGBA8888( uint8 *src, int numTexels )
+{
+	uint8 *lastPixel = src + numTexels * 4;
+
+	for( uint8 *pixel = src; pixel < lastPixel; pixel += 4 )
+	{
+		Vector tmpVect;
+		tmpVect[0] = ( ( float )pixel[0] - 128.0f ) * ( 1.0f / 127.0f );
+		tmpVect[1] = ( ( float )pixel[1] - 128.0f ) * ( 1.0f / 127.0f );
+		tmpVect[2] = ( ( float )pixel[2] - 128.0f ) * ( 1.0f / 127.0f );
+
+		VectorNormalize( tmpVect );
+
+		pixel[0] = ( uint8 )( 128 + 127 * tmpVect[0] );
+		pixel[1] = ( uint8 )( 128 + 127 * tmpVect[1] );
+		pixel[2] = ( uint8 )( 128 + 127 * tmpVect[2] );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Image rotation
+//-----------------------------------------------------------------------------
+bool RotateImageLeft( const uint8 *src, uint8 *dst, 
+					  int widthHeight, ImageFormat imageFormat )
+{
+#define SRC(x,y) src[((x)+(y)*widthHeight)*sizeInBytes]
+#define DST(x,y) dst[((x)+(y)*widthHeight)*sizeInBytes]
+	if( IsCompressed( imageFormat ) )
+	{
+		return false;
+	}
+
+	int x, y;
+
+	uint8 tmp[4][16];
+	int halfWidthHeight = widthHeight >> 1;
+	int sizeInBytes = SizeInBytes( imageFormat );
+	Assert( sizeInBytes <= 16 && sizeInBytes > 0 );
+
+	for( y = 0; y < halfWidthHeight; y++ )
+	{
+		for( x = 0; x < halfWidthHeight; x++ )
+		{
+			memcpy( tmp[0], &SRC( x, y ), sizeInBytes );
+			memcpy( tmp[1], &SRC( y, widthHeight-x-1 ), sizeInBytes );
+			memcpy( tmp[2], &SRC( widthHeight-x-1, widthHeight-y-1 ), sizeInBytes );
+			memcpy( tmp[3], &SRC( widthHeight-y-1, x ), sizeInBytes );
+			memcpy( &DST( x, y ),                             tmp[3], sizeInBytes );
+			memcpy( &DST( y, widthHeight-x-1 ),               tmp[0], sizeInBytes );
+			memcpy( &DST( widthHeight-x-1, widthHeight-y-1 ), tmp[1], sizeInBytes );
+			memcpy( &DST( widthHeight-y-1, x ),               tmp[2], sizeInBytes );
+		}
+	}
+#undef SRC
+#undef DST
+	return true;
+}
+
+bool RotateImage180( const uint8 *src, uint8 *dst, 
+					  int widthHeight, ImageFormat imageFormat )
+{
+	// OPTIMIZE: do this transformation directly.
+	if( RotateImageLeft( src, dst, widthHeight, imageFormat ) )
+	{
+		return RotateImageLeft( dst, dst, widthHeight, imageFormat );
+	}
+	return false;
+}
+
+bool FlipImageVertically( void *pSrc, void *pDst, int nWidth, int nHeight, ImageFormat imageFormat, int nDstStride )
+{
+	if( IsCompressed( imageFormat ) )
+		return false;
+
+	int nSizeInBytes = SizeInBytes( imageFormat );
+	int nRowBytes = nSizeInBytes * nWidth;
+	int nSrcStride = nRowBytes;
+	if ( nDstStride == 0 )
+	{
+		nDstStride = nRowBytes;
+	}
+
+	uint8 *pSrcRow = (uint8*)pSrc;
+	uint8 *pDstRow = (uint8*)pDst + ((nHeight-1) * nDstStride);
+	if ( pSrc == pDst )
+	{
+		uint8* pTemp = (uint8*)_alloca( nRowBytes );
+		int nHalfHeight = nHeight >> 1;
+		for ( int i = 0; i < nHalfHeight; i++ )
+		{
+			memcpy( pTemp, pSrcRow, nRowBytes );
+			memcpy( pSrcRow, pDstRow, nRowBytes );
+			memcpy( pDstRow, pTemp, nRowBytes );
+
+			pSrcRow += nSrcStride;
+			pDstRow -= nDstStride;
+		}
+	}
+	else
+	{
+		for ( int i = 0; i < nHeight; i++ )
+		{
+			memcpy( pDstRow, pSrcRow, nRowBytes );
+			pSrcRow += nSrcStride;
+			pDstRow -= nDstStride;
+		}
+	}
+
+	return true;
+}
+
+bool FlipImageHorizontally( void *pSrc, void *pDst, int nWidth, int nHeight, ImageFormat imageFormat, int nDstStride )
+{
+	if( IsCompressed( imageFormat ) )
+		return false;
+
+	uint8 tmp[16];
+	int nSizeInBytes = SizeInBytes( imageFormat );
+	int nRowBytes = nSizeInBytes * nWidth;
+	Assert( nSizeInBytes <= 16 && nSizeInBytes > 0 );
+	int nSrcStride = nRowBytes;
+	if ( nDstStride == 0 )
+	{
+		nDstStride = nRowBytes;
+	}
+
+	int x, y;
+	uint8 *pSrcRow = (uint8*)pSrc;
+	uint8 *pDstRow = (uint8*)pDst;
+	if ( pSrc == pDst )
+	{
+		int nHalfWidth = nWidth >> 1;
+		for( y = 0; y < nHeight; y++ )
+		{
+			uint8 *pSrcPixel = pSrcRow;
+			uint8 *pDstPixel = pDstRow + nRowBytes - nSizeInBytes;
+			for( x = 0; x < nHalfWidth; x++ )
+			{
+				memcpy( tmp, pSrcPixel, nSizeInBytes );
+				memcpy( pSrcPixel, pDstPixel, nSizeInBytes );
+				memcpy( pDstPixel, tmp, nSizeInBytes );
+
+				pSrcPixel += nSizeInBytes;
+				pDstPixel -= nSizeInBytes;
+			}
+
+			pSrcRow += nSrcStride;
+			pDstRow += nDstStride;
+		}
+	}
+	else
+	{
+		for( y = 0; y < nHeight; y++ )
+		{
+			uint8 *pSrcPixel = pSrcRow;
+			uint8 *pDstPixel = pDstRow + nRowBytes - nSizeInBytes;
+			for( x = 0; x < nWidth; x++ )
+			{
+				memcpy( pDstPixel, pSrcPixel, nSizeInBytes );
+				pSrcPixel += nSizeInBytes;
+				pDstPixel -= nSizeInBytes;
+			}
+
+			pSrcRow += nSrcStride;
+			pDstRow += nDstStride;
+		}
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Image rotation
+//-----------------------------------------------------------------------------
+bool SwapAxes( uint8 *src, int widthHeight, ImageFormat imageFormat )
+{
+#define SRC(x,y) src[((x)+(y)*widthHeight)*sizeInBytes]
+	if( IsCompressed( imageFormat ) )
+	{
+		return false;
+	}
+
+	int x, y;
+
+	uint8 tmp[4];
+	int sizeInBytes = SizeInBytes( imageFormat );
+	Assert( sizeInBytes <= 4 && sizeInBytes > 0 );
+
+	for( y = 0; y < widthHeight; y++ )
+	{
+		for( x = 0; x < y; x++ )
+		{
+			memcpy( tmp, &SRC( x, y ), sizeInBytes );
+			memcpy( &SRC( x, y ), &SRC( y, x ), sizeInBytes );
+			memcpy( &SRC( y, x ), tmp, sizeInBytes );
+		}
+	}
+#undef SRC
+	return true;
+}
+
+void RGBA8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	memcpy( dst, src, 4 * numPixels );
+}
+
+void RGBA8888ToABGR8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 4 )
+	{
+		dst[0] = src[3];
+		dst[1] = src[2];
+		dst[2] = src[1];
+		dst[3] = src[0];
+	}
+}
+
+void RGBA8888ToRGB888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 3 )
+	{
+		dst[0] = src[0];
+		dst[1] = src[1];
+		dst[2] = src[2];
+	}
+}
+
+void RGBA8888ToBGR888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 3 )
+	{
+		dst[0] = src[2];
+		dst[1] = src[1];
+		dst[2] = src[0];
+	}
+}
+
+void RGBA8888ToRGB565( const uint8 *src, uint8 *dst, int numPixels )
+{
+	Assert( 0 );
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 2 )
+	{
+	}
+}
+
+void RGBA8888ToI8( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 1 )
+	{
+		dst[0] = ( uint8 )( 0.299f * src[0] + 0.587f * src[1] + 0.114f * src[2] );
+	}
+}
+
+void RGBA8888ToIA88( const uint8 *src, uint8 *dst, int numPixels )
+{
+	// fixme: need to find the proper rgb weighting
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 2 )
+	{
+		dst[0] = ( uint8 )( 0.299f * src[0] + 0.587f * src[1] + 0.114f * src[2] );
+		dst[1] = src[3];
+	}
+}
+
+void RGBA8888ToP8( const uint8 *src, uint8 *dst, int numPixels )
+{
+	Assert( 0 );
+}
+
+void RGBA8888ToA8( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 1 )
+	{
+		dst[0] = src[3];
+	}
+}
+
+void RGBA8888ToRGB888_BLUESCREEN( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 3 )
+	{
+		if( src[3] == 0 )
+		{
+			dst[0] = 0;
+			dst[1] = 0;
+			dst[2] = 255;
+		}
+		else
+		{
+			dst[0] = src[0];
+			dst[1] = src[1];
+			dst[2] = src[2];
+		}
+	}
+}
+
+void RGBA8888ToBGR888_BLUESCREEN( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 3 )
+	{
+		if( src[3] == 0 )
+		{
+			dst[2] = 0;
+			dst[1] = 0;
+			dst[0] = 255;
+		}
+		else
+		{
+			dst[2] = src[0];
+			dst[1] = src[1];
+			dst[0] = src[2];
+		}
+	}
+}
+
+void RGBA8888ToARGB8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 4 )
+	{
+		dst[0] = src[3];
+		dst[1] = src[0];
+		dst[2] = src[1];
+		dst[3] = src[2];
+	}
+}
+
+void RGBA8888ToBGRA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 4 )
+	{
+		dst[0] = src[2];
+		dst[1] = src[1];
+		dst[2] = src[0];
+		dst[3] = src[3];
+	}
+}
+
+void RGBA8888ToBGRX8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 4 )
+	{
+		dst[0] = src[2];
+		dst[1] = src[1];
+		dst[2] = src[0];
+	}
+}
+
+void RGBA8888ToBGR565( const uint8 *src, uint8 *dst, int numPixels )
+{
+	unsigned short* pDstShort = (unsigned short*)dst;
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, pDstShort ++ )
+	{
+		*pDstShort = ((src[0] >> 3) << 11) |
+					 ((src[1] >> 2) << 5) |
+					  (src[2] >> 3);
+	}
+}
+
+void RGBA8888ToBGRX5551( const uint8 *src, uint8 *dst, int numPixels )
+{
+	unsigned short* pDstShort = (unsigned short*)dst;
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, pDstShort ++ )
+	{
+		*pDstShort = ((src[0] >> 3) << 10) |
+					 ((src[1] >> 3) << 5) |
+					  (src[2] >> 3);
+	}
+}
+
+void RGBA8888ToBGRA5551( const uint8 *src, uint8 *dst, int numPixels )
+{
+	unsigned short* pDstShort = (unsigned short*)dst;
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, pDstShort ++ )
+	{
+		*pDstShort = ((src[0] >> 3) << 10) |
+					 ((src[1] >> 3) << 5) |
+					  (src[2] >> 3) |
+					  (src[3] >> 7) << 15;
+	}
+}
+
+void RGBA8888ToBGRA4444( const uint8 *src, uint8 *dst, int numPixels )
+{
+	unsigned short* pDstShort = (unsigned short*)dst;
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, pDstShort ++ )
+	{
+		*pDstShort = ((src[0] >> 4) << 8) |
+					 ((src[1] >> 4) << 4) |
+					  (src[2] >> 4) |
+					 ((src[3] >> 4) << 12);
+	}
+}
+
+void RGBA8888ToUV88( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 2 )
+	{
+		dst[0] = src[0];
+		dst[1] = src[1];
+	}
+}
+
+void RGBA8888ToUVWQ8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	RGBA8888ToRGBA8888( src, dst, numPixels );
+}
+
+void RGBA8888ToUVLX8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	RGBA8888ToRGBA8888( src, dst, numPixels );
+}
+
+void ABGR8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 4 )
+	{
+		dst[0] = src[3];
+		dst[1] = src[2];
+		dst[2] = src[1];
+		dst[3] = src[0];
+	}
+}
+
+void RGB888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 3;
+	for ( ; src < endSrc; src += 3, dst += 4 )
+	{
+		dst[0] = src[0];
+		dst[1] = src[1];
+		dst[2] = src[2];
+		dst[3] = 255;
+	}
+}
+
+void BGR888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 3;
+	for ( ; src < endSrc; src += 3, dst += 4 )
+	{
+		dst[0] = src[2];
+		dst[1] = src[1];
+		dst[2] = src[0];
+		dst[3] = 255;
+	}
+}
+
+void RGB565ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	Assert( 0 );
+	const uint8 *endSrc = src + numPixels * 2;
+	for ( ; src < endSrc; src += 2, dst += 4 )
+	{
+	}
+}
+
+void I8ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels;
+	for ( ; src < endSrc; src += 1, dst += 4 )
+	{
+		dst[0] = src[0];
+		dst[1] = src[0];
+		dst[2] = src[0];
+		dst[3] = 255;
+	}
+}
+
+void IA88ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 2;
+	for ( ; src < endSrc; src += 2, dst += 4 )
+	{
+		dst[0] = src[0];
+		dst[1] = src[0];
+		dst[2] = src[0];
+		dst[3] = src[1];
+	}
+}
+
+void P8ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	Assert( 0 );
+}
+
+void A8ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels;
+	for ( ; src < endSrc; src += 1, dst += 4 )
+	{
+		dst[0] = src[0];
+		dst[1] = src[0];
+		dst[2] = src[0];
+		dst[3] = src[0];
+	}
+}
+
+void RGB888_BLUESCREENToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 3;
+	for ( ; src < endSrc; src += 3, dst += 4 )
+	{
+		if( src[0] == 0 && src[1] == 0 && src[2] == 255 )
+		{
+			dst[0] = 0;
+			dst[1] = 0;
+			dst[2] = 0;
+			dst[3] = 0;
+		}
+		else
+		{
+			dst[0] = src[0];
+			dst[1] = src[1];
+			dst[2] = src[2];
+			dst[3] = 255;
+		}
+	}
+}
+
+void BGR888_BLUESCREENToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 3;
+	for ( ; src < endSrc; src += 3, dst += 4 )
+	{
+		if( src[2] == 0 && src[1] == 0 && src[0] == 255 )
+		{
+			dst[0] = 0;
+			dst[1] = 0;
+			dst[2] = 0;
+			dst[3] = 0;
+		}
+		else
+		{
+			dst[2] = src[0];
+			dst[1] = src[1];
+			dst[0] = src[2];
+			dst[3] = 255;
+		}
+	}
+}
+
+void ARGB8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 4 )
+	{
+		dst[0] = src[1];
+		dst[1] = src[2];
+		dst[2] = src[3];
+		dst[3] = src[0];
+	}
+}
+
+void BGRA8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 4 )
+	{
+		dst[0] = src[2];
+		dst[1] = src[1];
+		dst[2] = src[0];
+		dst[3] = src[3];
+	}
+}
+
+void BGRX8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8 *endSrc = src + numPixels * 4;
+	for ( ; src < endSrc; src += 4, dst += 4 )
+	{
+		dst[0] = src[2];
+		dst[1] = src[1];
+		dst[2] = src[0];
+		dst[3] = 255;
+	}
+}
+
+void BGR565ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	unsigned short* pSrcShort = (unsigned short*)src;
+	unsigned short* pEndSrc = pSrcShort + numPixels;
+	for ( ; pSrcShort < pEndSrc; pSrcShort++, dst += 4 )
+	{
+		int blue = (*pSrcShort & 0x1F);
+		int green = (*pSrcShort >> 5) & 0x3F;
+		int red = (*pSrcShort >> 11) & 0x1F;
+
+		// Expand to 8 bits
+		dst[0] = (red << 3) | (red >> 2);
+		dst[1] = (green << 2) | (green >> 4);
+		dst[2] = (blue << 3) | (blue >> 2);
+		dst[3] = 255;
+	}
+}
+
+void BGRX5551ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	unsigned short* pSrcShort = (unsigned short*)src;
+	unsigned short* pEndSrc = pSrcShort + numPixels;
+	for ( ; pSrcShort < pEndSrc; pSrcShort++, dst += 4 )
+	{
+		int blue = (*pSrcShort & 0x1F);
+		int green = (*pSrcShort >> 5) & 0x1F;
+		int red = (*pSrcShort >> 10) & 0x1F;
+
+		// Expand to 8 bits
+		dst[0] = (red << 3) | (red >> 2);
+		dst[1] = (green << 3) | (green >> 2);
+		dst[2] = (blue << 3) | (blue >> 2);
+		dst[3] = 255;
+	}
+}
+
+void BGRA5551ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	unsigned short* pSrcShort = (unsigned short*)src;
+	unsigned short* pEndSrc = pSrcShort + numPixels;
+	for ( ; pSrcShort < pEndSrc; pSrcShort++, dst += 4 )
+	{
+		int blue = (*pSrcShort & 0x1F);
+		int green = (*pSrcShort >> 5) & 0x1F;
+		int red = (*pSrcShort >> 10) & 0x1F;
+		int alpha = *pSrcShort & ( 1 << 15 );
+
+		// Expand to 8 bits
+		dst[0] = (red << 3) | (red >> 2);
+		dst[1] = (green << 3) | (green >> 2);
+		dst[2] = (blue << 3) | (blue >> 2);
+		// garymcthack
+		if( alpha )
+		{
+			dst[3] = 255;
+		}
+		else
+		{
+			dst[3] = 0;
+		}
+	}
+}
+
+void BGRA4444ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	unsigned short* pSrcShort = (unsigned short*)src;
+	unsigned short* pEndSrc = pSrcShort + numPixels;
+	for ( ; pSrcShort < pEndSrc; pSrcShort++, dst += 4 )
+	{
+		int blue = (*pSrcShort & 0xF);
+		int green = (*pSrcShort >> 4) & 0xF;
+		int red = (*pSrcShort >> 8) & 0xF;
+		int alpha = (*pSrcShort >> 12) & 0xF;
+
+		// Expand to 8 bits
+		// FIXME: shouldn't this be (red << 4) | red?
+		dst[0] = (red << 4) | (red >> 4);
+		dst[1] = (green << 4) | (green >> 4);
+		dst[2] = (blue << 4) | (blue >> 4);
+		dst[3] = (alpha << 4) | (alpha >> 4);
+	}
+}
+
+void UV88ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	const uint8* pEndSrc = src + numPixels * 2;
+	for ( ; src < pEndSrc; src += 2, dst += 4 )
+	{
+		dst[0] = src[0];
+		dst[1] = src[1];
+		dst[2] = 0;
+		dst[3] = 0;
+	}
+}
+
+void UVWQ8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	RGBA8888ToRGBA8888( src, dst, numPixels );
+}
+
+void UVLX8888ToRGBA8888( const uint8 *src, uint8 *dst, int numPixels )
+{
+	RGBA8888ToRGBA8888( src, dst, numPixels );
+}
+
+// HDRFIXME: This assumes that the 16-bit integer values are 4.12 fixed-point.
+void RGBA16161616ToRGBA8888( const uint8 *src_, uint8 *dst, int numPixels )
+{
+	unsigned short *src = ( unsigned short * )src_;
+	unsigned short *pEndSrc = src + numPixels * 4;
+	for ( ; src < pEndSrc; src += 4, dst += 4 )
+	{
+		dst[0] = min( 255, src[0] >> 4 );
+		dst[1] = min( 255, src[1] >> 4 );
+		dst[2] = min( 255, src[2] >> 4 );
+		dst[3] = min( 255, src[3] >> 8 );
+	}
+}
+
+} // ImageLoader namespace ends
+
+
+