//========= 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 <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;
	memcpy( &bits, &(pAlphaBlock->stuff[0]), sizeof(DWORD) );

	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:
	memcpy( &bits, &(pAlphaBlock->stuff[3]), sizeof(DWORD) );

	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 0

	// 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 0
	// 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



