CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plGImage/plMipmap.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
///////////////////////////////////////////////////////////////////////////////
//																			 //
//	plMipmap Class Functions												 //
//	Derived bitmap class representing a single mipmap.						 //
//	Cyan, Inc.																 //
//																			 //
//// Version History //////////////////////////////////////////////////////////
//																			 //
//	6.7.2001 mcn - Created.													 //
//																			 //
///////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "plMipmap.h"
#include "hsStream.h"
#include "hsExceptions.h"
#include "hsUtils.h"
#include "hsColorRGBA.h"
#include "../plPipeline/hsGDeviceRef.h"
#include "plProfile.h"
#include "../plJPEG/plJPEG.h"

plProfile_CreateMemCounter("Mipmaps", "Memory", MemMipmaps);

//// Constructor & Destructor /////////////////////////////////////////////////

plMipmap::plMipmap() : fImage( nil ), fLevelSizes( nil ), fCurrLevelPtr( nil ), fCurrLevel( 0 ), fTotalSize( 0 )
{
	SetConfig( kARGB32Config );
	fCompressionType = kUncompressed;
	fUncompressedInfo.fType = UncompressedInfo::kRGB8888;

#ifdef MEMORY_LEAK_TRACER
	fNumMipmaps++;
#endif
}

plMipmap::~plMipmap()
{
	Reset();

#ifdef MEMORY_LEAK_TRACER
	fNumMipmaps--;
	if( fNumMipmaps == 0 )
		IReportLeaks();
#endif
}

plMipmap::plMipmap( UInt32 width, UInt32 height, unsigned config, UInt8 numLevels, UInt8 compType, UInt8 format )
{
	Create( width, height, config, numLevels, compType, format );

#ifdef MEMORY_LEAK_TRACER
	fNumMipmaps++;
#endif
}

//// Create ///////////////////////////////////////////////////////////////////

void	plMipmap::Create( UInt32 width, UInt32 height, unsigned config, UInt8 numLevels, UInt8 compType, UInt8 format )
{
	int		i;


	SetConfig( config );

	fWidth = width;
	fHeight = height;
	fRowBytes = fWidth * fPixelSize >> 3;
	if( numLevels > 0 )
		fNumLevels = numLevels;
	else
	{
		for( fNumLevels = 1; width > 1 || height > 1; fNumLevels++ )
		{
			if( width > 1 )
				width >>= 1;
			if( height > 1 )
				height >>= 1;
		}
	}
	
	fCompressionType = compType;
	if( compType == kUncompressed )
	{
		fUncompressedInfo.fType = format;
	}
	else if( compType == kJPEGCompression )
	{
		fUncompressedInfo.fType = format;
	}
	else
	{
		fDirectXInfo.fBlockSize = ( format == DirectXInfo::kDXT1 ) ? 8 : 16;
		fDirectXInfo.fCompressionType = format;

		if( format == DirectXInfo::kDXT1 )
		{
			// Has an alpha bit, but no channel
			fFlags |= kAlphaBitFlag;
			fFlags &= ~kAlphaChannelFlag;
		}
		else // All other formats have an actual alpha channel
		{
			fFlags &= ~kAlphaBitFlag;
			fFlags |= kAlphaChannelFlag;
		}
	}

	fLevelSizes = nil;
	IBuildLevelSizes();

	fTotalSize = 0;
	for( i = 0; i < fNumLevels; i++ )
		fTotalSize += fLevelSizes[ i ];

	fImage = (void *)TRACKED_NEW UInt8[ fTotalSize ];
	memset(fImage, 0, fTotalSize);

	SetCurrLevel( 0 );
	plProfile_NewMem(MemMipmaps, fTotalSize);

#ifdef MEMORY_LEAK_TRACER
	IAddToMemRecord( this, plRecord::kViaCreate );
#endif

}

//// Reset ////////////////////////////////////////////////////////////////////

void	plMipmap::Reset()
{
	delete [] fLevelSizes;
	fLevelSizes = nil;
	if( !( fFlags & kUserOwnsBitmap ) )
	{
#ifdef MEMORY_LEAK_TRACER
		if( fImage != nil )
			IRemoveFromMemRecord( (UInt8 *)fImage );
#endif

		delete [] fImage;
		plProfile_DelMem(MemMipmaps, fTotalSize);
	}
	fImage = nil;
}


///////////////////////////////////////////////////////////////////////////////
//// Virtual Functions ////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

//// GetTotalSize /////////////////////////////////////////////////////////////
//	Get the total size in bytes

UInt32	plMipmap::GetTotalSize() const
{
	return fTotalSize;
}

//// Read /////////////////////////////////////////////////////////////////////

UInt32  plMipmap::Read( hsStream *s )
{
	UInt32 totalRead = plBitmap::Read( s );

	// Decide to clamp if we were told to
	int	clampBy = fGlobalNumLevelsToChop;
	const kMaxSkipLevels = 1;
	if( clampBy > kMaxSkipLevels )
		clampBy = kMaxSkipLevels;
	if( fFlags & kNoMaxSize )
		clampBy = 0;
	else if( ( fFlags & kHalfSize ) && clampBy > 1 )
		clampBy = 1;
	UInt32	amtToSkip = 0;

	fWidth = s->ReadSwap32();
	fHeight = s->ReadSwap32();
	fRowBytes = s->ReadSwap32();
	fTotalSize = s->ReadSwap32();
	fNumLevels = s->ReadByte();

	totalRead += 4 * 4 + 1;
	
	if( fTotalSize == 0 )
		fImage = nil; 
	else
	{
		IBuildLevelSizes();

		if (fCompressionType != kJPEGCompression) // JPEGs don't play nicely with quality settings the way they are written, so we ignore them
		{
			if( clampBy > 0 )
			{
				int	i;
				for( i = 0; i < clampBy && fNumLevels > 1 && fWidth > 4 && fHeight > 4; i++ )
				{
					amtToSkip += fLevelSizes[ i ];
					fWidth >>= 1;
					fHeight >>= 1;
					fRowBytes >>= 1;
					fNumLevels--;
				}
				fTotalSize -= amtToSkip;
				IBuildLevelSizes();
			}
		}

		fImage = (void *)TRACKED_NEW UInt8[ fTotalSize ];
#ifdef MEMORY_LEAK_TRACER
		IAddToMemRecord( this, plRecord::kViaRead );
#endif
		plProfile_NewMem(MemMipmaps, fTotalSize);
		
		switch( fCompressionType )
		{
			case kDirectXCompression:
				s->Skip( amtToSkip );
				s->Read( fTotalSize, fImage );
				break;
				
			case kUncompressed:
				s->Skip( amtToSkip );
				IReadRawImage( s );
				break;
				
			case kJPEGCompression:
				IReadJPEGImage( s );
				break;
				
			default:
				hsAssert( false, "Unknown compression type in plMipmap::Read()" );
				return totalRead;
		}
		totalRead += fTotalSize;
	}
	return totalRead;
}

//// Write ////////////////////////////////////////////////////////////////////

UInt32 	plMipmap::Write( hsStream *s )
{
	UInt32 totalWritten = plBitmap::Write( s );

	s->WriteSwap32( fWidth );
	s->WriteSwap32( fHeight );
	s->WriteSwap32( fRowBytes );
	s->WriteSwap32( fTotalSize );
	s->WriteByte( fNumLevels );

	totalWritten += 4 * 4 + 1;

	if( fTotalSize > 0 )
	{
		switch( fCompressionType )
		{
			case kDirectXCompression:
				s->Write( fTotalSize, fImage );
				break;

			case kUncompressed:
				IWriteRawImage( s );
				break;

			case kJPEGCompression:
				IWriteJPEGImage( s );
				break;

			default:
				hsAssert( false, "Unknown compression type in plMipmap::Read()" );
				return totalWritten;
		}
		totalWritten += fTotalSize;
	}

	return totalWritten;
}


///////////////////////////////////////////////////////////////////////////////
//// Utility Functions ////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

//// IReadRawImage ////////////////////////////////////////////////////////////

void	plMipmap::IReadRawImage( hsStream *stream )
{
	UInt32		i;
	UInt8		*data = (UInt8 *)fImage;


	switch( fPixelSize )
	{
		case 32:
			for( i = 0; i < fNumLevels; i++ )
			{	
				stream->ReadSwap32( fLevelSizes[ i ] >> 2, (UInt32 *)data );
				data += fLevelSizes[ i ];
			}
			break;

		case 16:
			for( i = 0; i < fNumLevels; i++ )
			{
				stream->ReadSwap16( fLevelSizes[ i ] >> 1, (UInt16 *)data );
				data += fLevelSizes[ i ];
			}
			break;

		default:
			hsThrow( hsBadParamException() );
	}
}

//// IWriteRawImage ///////////////////////////////////////////////////////////

void	plMipmap::IWriteRawImage( hsStream *stream )
{
	UInt32		i;
	UInt8		*data = (UInt8 *)fImage;


	switch( fPixelSize )
	{
		case 32:
			for( i = 0; i < fNumLevels; i++ )
			{	
				stream->WriteSwap32( fLevelSizes[ i ] >> 2, (UInt32 *)data );
				data += fLevelSizes[ i ];
			}
			break;

		case 16:
			for( i = 0; i < fNumLevels; i++ )
			{
				stream->WriteSwap16( fLevelSizes[ i ] >> 1, (UInt16 *)data );
				data += fLevelSizes[ i ];
			}
			break;

		default:
			hsThrow( hsBadParamException() );
	}
}

plMipmap *plMipmap::ISplitAlpha()
{
	plMipmap *retVal = TRACKED_NEW plMipmap();
	retVal->CopyFrom(this);
	memset( retVal->fImage, 0, fTotalSize );

	UInt8 *curLoc = (UInt8 *)fImage;
	UInt8 *destLoc = (UInt8 *)retVal->fImage;
	UInt32 numBytes = fTotalSize;
	UInt32 curByte = 0;

	switch( fUncompressedInfo.fType )
	{
	case fUncompressedInfo.kRGB8888:
		// first byte is the alpha channel, we will drop this byte into the red channel for compression
		while (curByte < numBytes)
		{
			curLoc += 3;
			destLoc += 2; // make the destination pointer point at the red channel
			*destLoc = *curLoc; // copy the information
			destLoc += 2; // make the destination pointer point at the beginning of the next pixel
			curLoc ++; // same here for source pointer
			curByte += 4;
		}
		break;
	default:
		break; // not going to mess with other formats for now
	}
	return retVal;
}

// alphaChannel must be in the format generated from ISplitAlpha, or strange things will happen
void plMipmap::IRecombineAlpha( plMipmap *alphaChannel )
{
	UInt8 *curLoc = (UInt8 *)alphaChannel->fImage;
	UInt8 *destLoc = (UInt8 *)fImage;
	UInt32 numBytes = fTotalSize;
	UInt32 curByte = 0;

	switch( fUncompressedInfo.fType )
	{
	case fUncompressedInfo.kRGB8888:
		// first byte is the alpha channel, we will grab this byte from the red channel for reconstitution
		while (curByte < numBytes)
		{
			curLoc += 2; // pointer points at the red channel (where the alpha is stored)
			destLoc += 3;
			*destLoc = *curLoc; // copy the data
			destLoc++; // move the pointer to the next pixel
			curLoc += 2;
			curByte += 4;
		}
		break;
	default:
		break; // not going to mess with other formats for now
	}
	fFlags |= plBitmap::kAlphaChannelFlag;
}

plMipmap *plMipmap::IReadRLEImage( hsStream *stream )
{
	UInt32 count,color;
	bool done = false;

	plMipmap *retVal = TRACKED_NEW plMipmap(fWidth,fHeight,plMipmap::kARGB32Config,1);

	UInt32 *curPos = (UInt32*)retVal->fImage;
	UInt32 curLoc = 0;

	while (!done)
	{
		count = stream->ReadSwap32();
		color = stream->ReadSwap32();
		if (count == 0)
			done = true;
		else
		{
			for (UInt32 i=0; i<count; i++)
			{
				*curPos = color;
				curPos++;
				curLoc++;
			}
		}
	}
	// We really don't want to suddenly start calling this uncompressed now that it's read in.
	// Case in point, on export we load in all previously exported textures (like this JPEG one)
	// share those, add any textures that aren't already there, then write the whole thing back
	// out. Viola, we just converted our nice small compressed 1024x1024 JPEG (~128k) to a 
	// monster uncompressed 4Mb which it will remain for ever more.
//	retVal->fCompressionType = kUncompressed;
	return retVal;
}

void plMipmap::IWriteRLEImage( hsStream *stream, plMipmap *mipmap )
{
	UInt32 count=0,color=0,curColor=0;
	UInt32 curPos = 0;
	UInt32 totalSize = mipmap->fLevelSizes[0]/4; // we only save the first mipmap level

	UInt32 *src = (UInt32*)mipmap->fImage;
	curColor = *src;
	curColor &= 0x00FFFFFF; // strip the alpha (if there is any)
	while (curPos < totalSize)
	{
		color = *src;
		color &= 0x00FFFFFF; // strip the alpha (if there is any)
		if (color != curColor)
		{
			stream->WriteSwap32(count);
			stream->WriteSwap32(curColor);
			count = 0;
			curColor = color;
		}
		count++;
		src++;
		curPos++;
	}
	stream->WriteSwap32(count);
	stream->WriteSwap32(color);
	stream->WriteSwap32(0); // terminate with zero count
	stream->WriteSwap32(0);
}

void plMipmap::IReadJPEGImage( hsStream *stream )
{
	UInt8 flags = 0;
	flags = stream->ReadByte();

	plMipmap *temp = nil;
	plMipmap *alpha = nil;

	if (flags & kColorDataRLE)
		temp = IReadRLEImage(stream);
	else
		temp = plJPEG::Instance().ReadFromStream(stream);
	
	if (temp)
	{
		// copy the data
		CopyFrom(temp);
		
		if (flags & kAlphaDataRLE)
			alpha = IReadRLEImage(stream);
		else
			alpha = plJPEG::Instance().ReadFromStream(stream);

		if (alpha)
		{
			IRecombineAlpha(alpha);
			delete alpha;
		}
		delete temp;
	}
}

void plMipmap::IWriteJPEGImage( hsStream *stream )
{
	plMipmap *alpha = ISplitAlpha();
	UInt8 flags = 0;

	hsNullStream *nullStream = TRACKED_NEW hsNullStream();
	IWriteRLEImage(nullStream,this);
	if (nullStream->GetBytesWritten() < 5120) // we use RLE if it can get the image size under 5k, otherwise we use JPEG
		flags |= kColorDataRLE;
	delete nullStream;
	nullStream = TRACKED_NEW hsNullStream();
	IWriteRLEImage(nullStream,alpha);
	if (nullStream->GetBytesWritten() < 5120)
		flags |= kAlphaDataRLE;
	delete nullStream;
	stream->WriteByte(flags);

	if (flags & kColorDataRLE)
		IWriteRLEImage(stream,this);
	else
	{
		plJPEG::Instance().SetWriteQuality(70);
		plJPEG::Instance().WriteToStream(stream, this);
	}
	if (flags & kAlphaDataRLE)
		IWriteRLEImage(stream,alpha);
	else
	{
		plJPEG::Instance().SetWriteQuality(100);
		plJPEG::Instance().WriteToStream(stream, alpha);
	}
	delete alpha;
}

//// GetLevelSize /////////////////////////////////////////////////////////////
//	Get the size of a single mipmap level (0 is the largest)

UInt32	plMipmap::GetLevelSize( UInt8 level )
{
	if( fLevelSizes == nil )
		IBuildLevelSizes();

	return fLevelSizes[ level ];
}

//// IBuildLevelSizes /////////////////////////////////////////////////////////
//	Creates the table of level sizes, for quick reference

void	plMipmap::IBuildLevelSizes()
{
	UInt8		level;
	UInt32		width, height, rowBytes;


	delete [] fLevelSizes;
	fLevelSizes = TRACKED_NEW UInt32[ fNumLevels ];
	memset( fLevelSizes, 0, sizeof( UInt32 ) * fNumLevels );

	for( level = 0, width = fWidth, height = fHeight, rowBytes = fRowBytes; level < fNumLevels; level++ )
	{
		switch( fCompressionType )
		{
			case kDirectXCompression:
				if( ( width | height ) & 0x03 )
					fLevelSizes[ level ] = height * rowBytes;
				else
					fLevelSizes[ level ] = ( height * width * (UInt32)fDirectXInfo.fBlockSize ) >> 4;
				break;

			case kUncompressed:
			case kJPEGCompression:
				fLevelSizes[ level ] = height * rowBytes;
				break;

			default:
				hsAssert( false, "Bad compression type." );
				return;
		}

		// Scale down and go!
		if( width > 1 )
		{
			width >>= 1;
			rowBytes >>= 1;
		}
		if( height > 1 )
			height >>= 1;
	}
}

//// GetLevelPtr //////////////////////////////////////////////////////////////

UInt8	*plMipmap::GetLevelPtr( UInt8 level, UInt32 *width, UInt32 *height, UInt32 *rowBytes )
{
	UInt8	*data, i;
	UInt32	w, h, r;


	if( fLevelSizes == nil )
		IBuildLevelSizes();

	for( i = 0, data = (UInt8 *)fImage, w = fWidth, h = fHeight, r = fRowBytes; i < level; i++ )
	{
		data += fLevelSizes[ i ];
		if( w > 1 )
		{
			w >>= 1;
			r >>= 1;
		}
		if( h > 1 )
			h >>= 1;
	}

	if( width != nil )
		*width = w;
	if( height != nil )
		*height = h;
	if( rowBytes != nil )
		*rowBytes = r;

	return data;
}

//// SetCurrLevel /////////////////////////////////////////////////////////////
//	Sets the current level pointer for use with GetAddr*

void	plMipmap::SetCurrLevel( UInt8 level )
{
	fCurrLevel = level;
	fCurrLevelPtr = GetLevelPtr( level, &fCurrLevelWidth, &fCurrLevelHeight, &fCurrLevelRowBytes );
}

//// SetConfig ////////////////////////////////////////////////////////////////

void	plMipmap::SetConfig( unsigned config )
{
	switch( config )
	{
		case kRGB32Config:
			fPixelSize	= 32;
			fSpace	= kDirectSpace;
			fFlags	= kNoFlag;
			break;
		case kARGB32Config:
			fPixelSize	= 32;
			fSpace	= kDirectSpace;
			fFlags	= kAlphaChannelFlag;
			break;
		case kRGB16Config:
			fPixelSize	= 16;
			fSpace	= kDirectSpace;
			fFlags	= kAlphaBitFlag;
			break;
		case kColor8Config:
			fPixelSize	= 8;
			fSpace	= kIndexSpace;
			fFlags	= kNoFlag;
			break;
		case kGray8Config:
			fPixelSize	= 8;
			fSpace	= kDirectSpace;
			fFlags	= kNoFlag;
			break;
		case kGray44Config:
			fPixelSize	= 8;
			fSpace	= kGraySpace;
			fFlags	= kAlphaChannelFlag;
			break;
		case kGray4Config:
			fPixelSize	= 4;
			fSpace	= kGraySpace;
			fFlags	= kNoFlag;
			break;
		default:
			hsDebugMessage( "unknown config", config );
			break;
	}
}

//// ClipToMaxSize ////////////////////////////////////////////////////////////
//	Looks for mipmap levels above the given dimension and "clips" them out, 
//	i.e. deletes them. So if you have a 512x1024 mipmap and call this with
//	a size of 256, when this function returns the mipmap will be 256x128 in
//	size.

void	plMipmap::ClipToMaxSize( UInt32 maxDimension )
{
	UInt8		*srcData, *destData, i;
	UInt32		newSize;


	for( i = 0, newSize = fTotalSize, srcData = (UInt8 *)fImage; fWidth > maxDimension || fHeight > maxDimension; i++ )
	{
		srcData += fLevelSizes[ i ];
		newSize -= fLevelSizes[ i ];
		if( fWidth > 1 )
		{
			fWidth >>= 1;
			fRowBytes >>= 1;
		}
		if( fHeight > 1 )
			fHeight >>= 1;
	}

	if( i == 0 )
		// No change
		return;

	/// Create a new image pointer
	destData = TRACKED_NEW UInt8[ newSize ];
	hsAssert( destData != nil, "Out of memory in ClipToMaxSize()" );
	memcpy( destData, srcData, newSize );

#ifdef MEMORY_LEAK_TRACER
	IRemoveFromMemRecord( (UInt8 *)fImage );
#endif
	delete [] fImage;
	plProfile_DelMem(MemMipmaps, fTotalSize);

	fImage = destData;
	fTotalSize = newSize;
	fNumLevels -= i;
	IBuildLevelSizes();
	plProfile_NewMem(MemMipmaps, fTotalSize);

#ifdef MEMORY_LEAK_TRACER
	IAddToMemRecord( this, plRecord::kViaClipToMaxSize );
#endif
}

//// RemoveMipping ////////////////////////////////////////////////////////////
//	Basically removes mipmap levels so that there is only one level remaining;
//	i.e. a plain bitmap instead of a mipmap.

void	plMipmap::RemoveMipping()
{
	UInt8		*destData;


	/// Create a new image pointer
	destData = TRACKED_NEW UInt8[ fLevelSizes[ 0 ] ];
	hsAssert( destData != nil, "Out of memory in ClipToMaxSize()" );
	memcpy( destData, fImage, fLevelSizes[ 0 ] );

#ifdef MEMORY_LEAK_TRACER
	IRemoveFromMemRecord( (UInt8 *)fImage );
#endif
	delete [] fImage;
	plProfile_DelMem(MemMipmaps, fTotalSize);

	fImage = destData;
	fTotalSize = fLevelSizes[ 0 ];
	fNumLevels = 1;
	fFlags |= kForceOneMipLevel;
	IBuildLevelSizes();
	plProfile_NewMem(MemMipmaps, fTotalSize);

#ifdef MEMORY_LEAK_TRACER
	IAddToMemRecord( this, plRecord::kViaClipToMaxSize );
#endif
}


///////////////////////////////////////////////////////////////////////////////



#include "hsCodecManager.h"


namespace {
	const UInt32 kVersion			= 1;
	const hsScalar kDefaultSigma	= 1.f;
	const UInt32 kDefaultDetailBias = 5;

	// Color masks (out of 0-2)
	const UInt8 fColorMasks[ 10 ][ 3 ] = { { 2, 0, 0 }, { 0, 2, 2 }, { 2, 0, 2 }, { 0, 2, 0 },			
				{ 0, 0, 2 }, { 2, 2, 0 }, { 2, 2, 2 }, { 2, 0, 1 }, { 0, 2, 1 }, { 1, 0, 2 } };
											
}

///////////////////////////////////////////////////////////////////////////////
//// plFilterMask Helper Class ////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

// This filter mask class actually introduces a half pixel per level shift
// artifact. It's done that since I wrote it a couple of years ago, and nobody's
// noticed but me, so it's probably okay. But fixing it would be easy. The
// mask needs to extend -n down and n+1 up. To see why, notice that the current
// upper level pixel (i,j) maps to four lower pixels (i<<1,j<<1) .. (i<<1+1,j<<1+1).
// So the mask value on pixel (i<<1,j<<1) should give equal weight to those other
// 3 pixels.
// The mask here is symmetric about the src pixel, which is right if you are
// just filtering the src bitmap. But we're filtering and resampling, so the
// mask needs to be symmetric about the dst pixel, which is off by a half
// dst pixel, or on whole src pixel.
class plFilterMask
{
	protected:
		int				fExt;
		hsScalar		**fMask;

	public:

		plFilterMask( hsScalar sig );
		virtual ~plFilterMask();

		int		Begin() const { return -fExt; }
		int		End() const { return fExt; }

		hsScalar	Mask( int i, int j ) const { return fMask[ i ][ j ]; }
};

plFilterMask::plFilterMask( hsScalar sig )
{
	fExt = (int)( sig * 2.f );
	if( fExt < 1 )
		fExt = 1;

	hsScalar **m = TRACKED_NEW hsScalar *[ ( fExt << 1 ) + 1 ];
	m += fExt;
	int i, j;
	hsScalar ooSigSq = 1.f / ( sig * sig );

	for( i = -fExt; i <= fExt; i++ )
	{
		m[ i ] = ( TRACKED_NEW hsScalar[ ( fExt << 1 ) + 1] ) + fExt;
		for( j = -fExt; j <= fExt; j++ )
		{
			m[ i ][ j ] = expf( -( i*i + j*j ) * ooSigSq );
		}
	}
	fMask = m;
}

plFilterMask::~plFilterMask()
{
	int i;
	for( i = -fExt; i <= fExt; i++ )
		delete [] ( fMask[ i ] - fExt );
	delete [] ( fMask - fExt );
}


///////////////////////////////////////////////////////////////////////////////
//// Some More Functions //////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

plMipmap::plMipmap( plMipmap *bm, hsScalar sig, UInt32 createFlags, 
        hsScalar detailDropoffStart, hsScalar detailDropoffStop, 
        hsScalar detailMax, hsScalar detailMin)
{
	int		i;


	hsAssert(bm->GetHeight() && bm->GetWidth(), "Degenerate Bitmap into Mipmap");

	if( sig <= 0 )
		sig = kDefaultSigma;

	fHeight = bm->GetHeight();
	fWidth = bm->GetWidth();
	fRowBytes = bm->GetRowBytes();
	fPixelSize = bm->GetPixelSize();
	fImage = nil;
	fFlags = bm->GetFlags();

	UInt32 minDim = fHeight < fWidth ? fHeight : fWidth;
	for( fNumLevels = 0; (minDim >> fNumLevels); fNumLevels++ ) /* empty */;

	fLevelSizes = nil;
	fCompressionType = kUncompressed;
	fUncompressedInfo.fType = bm->fUncompressedInfo.fType;
	IBuildLevelSizes();

	fTotalSize = 0;
	for( i = 0; i < fNumLevels; i++ )
		fTotalSize += fLevelSizes[ i ];
	fCurrLevel = 0;

	fImage = (void *)TRACKED_NEW UInt8[ fTotalSize ];
	memset(fImage, 0, fTotalSize);
	memcpy( fImage, bm->fImage, bm->GetLevelSize( 0 ) );
#ifdef MEMORY_LEAK_TRACER
	IAddToMemRecord( this, plRecord::kViaDetailMapConstructor );
#endif
	plProfile_NewMem(MemMipmaps, fTotalSize);

	/// Filter levels!
	plFilterMask mask(sig);

	/// First, fill in all the mipmap levels sans detail levels
	for( i = 1; i < fNumLevels; i++ )
		ICreateLevelNoDetail(i, mask);

    if (createFlags & kCreateDetailMask) 
	{
		// Fill in the detail levels afterwards, so we can just grab the current level's texture
		// alpha (old way did it at the same time, which accumulated the detail alpha each level down)
        detailDropoffStart *= fNumLevels;
        detailDropoffStop *= fNumLevels;

		switch( createFlags & kCreateDetailMask )
		{
			case kCreateDetailAlpha:
	            fFlags |= kAlphaChannelFlag;
				for( i = 0; i < fNumLevels; i++ )
					IBlendLevelDetailAlpha(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
				break;

			case kCreateDetailAdd:
				for( i = 0; i < fNumLevels; i++ )
					IBlendLevelDetailAdd( i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
				break;

			case kCreateDetailMult:
				for( i = 0; i < fNumLevels; i++ )
					IBlendLevelDetailMult(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
				break;
		}
    }
	if( createFlags & kCreateCarryAlpha )
	{
		for( i = 1; i < fNumLevels; i++ )
			ICarryZeroAlpha(i);
	}
	if( createFlags & (kCreateCarryWhite | kCreateCarryBlack) )
	{
		UInt32 col = createFlags & kCreateCarryWhite ? 0x00ffffff : 0x00000000;
		for( i = 1; i < fNumLevels; i++ )
			ICarryColor(i, col);
	}


#ifdef MEMORY_LEAK_TRACER
	fNumMipmaps++;
#endif
}

//// IGetDetailLevelAlpha /////////////////////////////////////////////////////
//	Given the detail range and the current level, returns the detail's alpha
//	value at that level.

hsScalar plMipmap::IGetDetailLevelAlpha( UInt8 level, hsScalar dropStart, hsScalar dropStop, hsScalar min, hsScalar max )
{
	hsScalar detailAlpha;


	detailAlpha = ( level - dropStart ) * ( min - max ) / ( dropStop - dropStart ) + max;

	if( min < max )
		detailAlpha = hsMinimum( max, hsMaximum( min, detailAlpha ) );
	else
		detailAlpha = hsMinimum( min, hsMaximum( max, detailAlpha ) );

	return detailAlpha;
}

void plMipmap::SetBitmapAsLevel(UInt8 iDst, plMipmap *bm, hsScalar sig, UInt32 createFlags, 
                                      hsScalar detailDropoffStart, hsScalar detailDropoffStop, 
                                      hsScalar detailMax, hsScalar detailMin)
{
    SetCurrLevel( iDst );

    hsAssert((bm->fHeight == fCurrLevelHeight) && (bm->fWidth == fCurrLevelWidth), "Wrong size bitmap for Mipmap level.");

    memcpy( fCurrLevelPtr, bm->fImage, bm->GetLevelSize( 0 ) );
	plFilterMask mask(sig);
	int i;

	// Fill in levels w/o detail first
	for( i = iDst+1; i < fNumLevels; i++ )
		ICreateLevelNoDetail(i, mask);

	// Now fill in the detail alphas, if we have any
	switch( createFlags & kCreateDetailMask )
	{
		case 0:
			break;

		case kCreateDetailAlpha:
			for( i = iDst; i < fNumLevels; i++ )
				IBlendLevelDetailAlpha(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
			break;

		case kCreateDetailAdd:
			for( i = iDst; i < fNumLevels; i++ )
				IBlendLevelDetailAdd(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
			break;

		case kCreateDetailMult:
			for( i = iDst; i < fNumLevels; i++ )
				IBlendLevelDetailMult(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
			break;
	}
	if( createFlags & kCreateCarryAlpha )
	{
		for( i = iDst+1; i < fNumLevels; i++ )
			ICarryZeroAlpha(i);
	}
	if( createFlags & (kCreateCarryWhite | kCreateCarryBlack) )
	{
		UInt32 col = createFlags & kCreateCarryWhite ? 0x00ffffff : 0x00000000;
		for( i = iDst+1; i < fNumLevels; i++ )
			ICarryColor(i, col);
	}

	SetCurrLevel(0);
}

//// ICreateLevelNoDetail /////////////////////////////////////////////////////
//	Creates one level of a mipmap based on a filter on the previous layer.
//	This version assumes no detail map fading.

void	plMipmap::ICreateLevelNoDetail( UInt8 iDst, const plFilterMask& mask )
{
    hsAssert(fPixelSize == 32, "Only 32 bit implemented");
	ASSERT_UNCOMPRESSED();

	int i, j, ii, jj;

	if( 32 == fPixelSize )
	{
		SetCurrLevel(iDst);

		UInt8 *src = (UInt8 *)GetLevelPtr( iDst-1 );
		UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);

		UInt32 srcRowBytes = fCurrLevelRowBytes << 1;
		UInt32 srcHeight = fCurrLevelHeight << 1;
		UInt32 srcWidth = fCurrLevelWidth << 1;

		for( i = 0; i < fCurrLevelHeight; i++ )
		{
			for( j = 0; j < fCurrLevelWidth; j++ )
			{
				UInt8 *center = src + (i << 1) * srcRowBytes + (j << 3);

				UInt32 chan;
				for( chan = 0; chan < 4; chan++ )
				{
					hsScalar w = 0;
					hsScalar a = 0;

					for( ii = mask.Begin(); ii <= mask.End(); ii++ )
					{
						for( jj = mask.Begin(); jj <= mask.End(); jj++ )
						{
							if( (ii + (i << 1) >= 0)&&(ii + (i << 1) < srcHeight)
							  &&(jj + (j << 1) >= 0)&&(jj + (j << 1) < srcWidth) )
							{
								w += mask.Mask(ii, jj);
								a += (hsScalar(center[ii*srcRowBytes + (jj<<2) + chan]) + 0.5f) * mask.Mask(ii, jj);
							}
						}
					}
					a /= w;

					dst[i * fCurrLevelRowBytes + (j << 2) + chan] = (UInt8)a;
				}
			}
		}
	}
}

void plMipmap::ICarryZeroAlpha(UInt8 iDst)
{
    hsAssert(fPixelSize == 32, "Only 32 bit implemented");
	ASSERT_UNCOMPRESSED();

	int i, j;

	if( 32 == fPixelSize )
	{
		SetCurrLevel(iDst);

		UInt8 *src = (UInt8 *)GetLevelPtr( iDst-1 );
		UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);

		UInt32 srcRowBytes = fCurrLevelRowBytes << 1;
		UInt32 srcHeight = fCurrLevelHeight << 1;
		UInt32 srcWidth = fCurrLevelWidth << 1;

		const UInt8 alphaOff = 3;
		for( i = 0; i < fCurrLevelHeight; i++ )
		{
			for( j = 0; j < fCurrLevelWidth; j++ )
			{
				UInt8 *center = src + (i << 1) * srcRowBytes + (j << 3) + alphaOff;

				if( !center[0]
					|| !center[4]
					|| !center[srcRowBytes + 0]
					|| !center[srcRowBytes + 4] )
				{
					dst[i * fCurrLevelRowBytes + (j << 2) + alphaOff] = 0;
				}
			}
		}
	}
}

void plMipmap::ICarryColor(UInt8 iDst, UInt32 col)
{
    hsAssert(fPixelSize == 32, "Only 32 bit implemented");
	ASSERT_UNCOMPRESSED();

	int i, j;

	if( 32 == fPixelSize )
	{
		SetCurrLevel(iDst);

		UInt32* src = (UInt32*)GetLevelPtr( iDst-1 );
		UInt32* dst = (UInt32*)GetLevelPtr(iDst);

		UInt32 srcHeight = fCurrLevelHeight << 1;
		UInt32 srcWidth = fCurrLevelWidth << 1;

		const UInt8 alphaOff = 3;
		for( i = 0; i < fCurrLevelHeight; i++ )
		{
			for( j = 0; j < fCurrLevelWidth; j++ )
			{
				UInt32* center = src + (i << 1) * srcWidth + (j << 1);

				if( ((center[0] & 0x00ffffff) == col)
					||((center[1] & 0x00ffffff) == col)
					||((center[srcHeight] & 0x00ffffff) == col)
					||((center[srcHeight+1] & 0x00ffffff) == col) )
				{
					dst[i * fCurrLevelWidth + j] &= 0xff000000;
					dst[i * fCurrLevelWidth + j] |= col;
				}
			}
		}
	}
}

//// IBlendLevelDetailAlpha ///////////////////////////////////////////////////
//	Blends in the detail alpha for a given level. This version assumes 
//	standard detail map blending.

void	plMipmap::IBlendLevelDetailAlpha( UInt8 iDst, const plFilterMask& mask, 
										  hsScalar detailDropoffStart, hsScalar detailDropoffStop, 
										  hsScalar detailMax, hsScalar detailMin )
{
    hsAssert(fPixelSize == 32, "Only 32 bit implemented");
	ASSERT_UNCOMPRESSED();

	int		i, j;
	UInt32	offset;


	SetCurrLevel(iDst);

	UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);

	hsScalar detailAlpha = IGetDetailLevelAlpha( iDst, detailDropoffStart, detailDropoffStop, detailMin, detailMax );

	for( i = 0; i < fCurrLevelHeight; i++ )
	{
		for( j = 0; j < fCurrLevelWidth; j++ )
		{
			UInt32 chan = 3;	// Alpha channel only
			offset = i * fCurrLevelRowBytes + (j << 2) + chan;

			float a = (float)dst[ offset ] * detailAlpha;
			dst[ offset ] = (UInt8)a;
		}
	}
}

//// IBlendLevelDetailAdd /////////////////////////////////////////////////////
//	Blends in the detail alpha for a given level. This version assumes additive 
//	detail map blending. (Shesh, gotta hate C sometimes....)

void	plMipmap::IBlendLevelDetailAdd( UInt8 iDst, const plFilterMask& mask, 
										  hsScalar detailDropoffStart, hsScalar detailDropoffStop, 
										  hsScalar detailMax, hsScalar detailMin )
{
    hsAssert(fPixelSize == 32, "Only 32 bit implemented");
	ASSERT_UNCOMPRESSED();

	int		i, j;
	UInt32	offset;


	SetCurrLevel(iDst);

	UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);

	hsScalar detailAlpha = IGetDetailLevelAlpha( iDst, detailDropoffStart, detailDropoffStop, detailMin, detailMax );

	for( i = 0; i < fCurrLevelHeight; i++ )
	{
		for( j = 0; j < fCurrLevelWidth; j++ )
		{
			UInt32 chan;

			/// Blend all but the alpha channel, since we're doing additive blending
			for( chan = 0; chan < 3; chan++ )
			{
				offset = i * fCurrLevelRowBytes + (j << 2) + chan;

				float a = (float)dst[ offset ] * detailAlpha;
				dst[ offset ] = (UInt8)a;
			}
		}
	}
}

//// IBlendLevelDetailMult ////////////////////////////////////////////////////
//	Blends in the detail alpha for a given level. This version assumes 
//	multiplicitive detail map blending. (Shesh, gotta hate C sometimes....)

void	plMipmap::IBlendLevelDetailMult( UInt8 iDst, const plFilterMask& mask, 
										  hsScalar detailDropoffStart, hsScalar detailDropoffStop, 
										  hsScalar detailMax, hsScalar detailMin )
{
	hsAssert(fPixelSize == 32, "Only 32 bit implemented");
	ASSERT_UNCOMPRESSED();

	int		i, j;
	UInt32	offset;


	SetCurrLevel(iDst);

	UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);

	hsScalar	detailAlpha = IGetDetailLevelAlpha( iDst, detailDropoffStart, detailDropoffStop, detailMin, detailMax );
	hsScalar	invDetailAlpha = ( 1.f - detailAlpha ) * 255.f;

	for( i = 0; i < fCurrLevelHeight; i++ )
	{
		for( j = 0; j < fCurrLevelWidth; j++ )
		{
			UInt32 chan;

			for( chan = 0; chan < 4; chan++ )
			{
				offset = i * fCurrLevelRowBytes + (j << 2) + chan;

				float a = (float)dst[ offset ];

				// Mult should fade to white, not black like with additive blending
				a = invDetailAlpha + a * detailAlpha;

				dst[ offset ] = (UInt8)a;
			}
		}
	}
}

//// EnsureKonstantBorder /////////////////////////////////////////////////////
//	Checks a mipmap's levels and makes sure that if the top level has constant
//	border color/alpha, the rest of the levels get that border, too, regardless
//	of filtering. (This is us guessing that that border was apparently what
//	was intented, thus removing ugly stretching problems on clamped textures).

void	plMipmap::EnsureKonstantBorder( hsBool clampU, hsBool clampV )
{
	if( fPixelSize != 32 )
	{
		hsAssert( false, "Only 32 bit color supported in EnsureKonstantBorder()" );
		return;
	}

	if( !clampU && !clampV )
		return;		// Um, exactly what are we supposed to do, again?

	UInt32	uColor, vColor;
	int		i;


	if( clampU && !IGrabBorderColor( false, &uColor ) )
		return;
	if( clampV && !IGrabBorderColor( true, &vColor ) )
		return;

	if( clampU && clampV && ( uColor != vColor ) )
		return;

	for( i = 1; i < fNumLevels; i++ )
	{
		SetCurrLevel( i );
		if( clampU )
			ISetCurrLevelUBorder( uColor );
		if( clampV )
			ISetCurrLevelVBorder( vColor );
	}

	SetCurrLevel( 0 );
}

//// IGrabBorderColor /////////////////////////////////////////////////////////
//	Grabs the top level's border color, or returns false if not all pixels
//	on the border are the same color/alpha.

hsBool	plMipmap::IGrabBorderColor( hsBool grabVNotU, UInt32 *color )
{
	int			i;
	UInt32		*src1 = (UInt32 *)fImage, *src2, testColor;


	if( !grabVNotU )
	{
		src2 = (UInt32 *)( (UInt8 *)fImage + fRowBytes * ( fHeight - 1 ) );

		testColor = *src1;
		for( i = 0; i < fWidth; i++ )
		{
			if( src1[ i ] != testColor || src2[ i ] != testColor )
				return false;
		}

		*color = testColor;
		return true;
	}
	else
	{
		src2 = src1 + ( fWidth - 1 );

		testColor = *src1;
		for( i = 0; i < fHeight; i++ )
		{
			if( *src1 != testColor || *src2 != testColor )
				return false;
			src1 += fWidth;
			src2 += fWidth;
		}

		*color = testColor;
		return true;
	}
}

//// ISetCurrLevelUBorder /////////////////////////////////////////////////////

void	plMipmap::ISetCurrLevelUBorder( UInt32 color )
{
	int		i;
	UInt32	*src1 = (UInt32 *)fCurrLevelPtr, *src2;


	src2 = (UInt32 *)( (UInt8 *)fCurrLevelPtr + fCurrLevelRowBytes * ( fCurrLevelHeight - 1 ) );

	for( i = 0; i < fCurrLevelWidth; i++ )
	{
		src1[ i ] = color;
		src2[ i ] = color;
	}
}

//// ISetCurrLevelVBorder /////////////////////////////////////////////////////

void	plMipmap::ISetCurrLevelVBorder( UInt32 color )
{
	int		i;
	UInt32	*src1 = (UInt32 *)fCurrLevelPtr, *src2;


	src2 = src1 + ( fCurrLevelWidth - 1 );

	for( i = 0; i < fCurrLevelHeight; i++ )
	{
		*src1 = color;
		*src2 = color;
		src1 += fCurrLevelWidth;
		src2 += fCurrLevelWidth;
	}
}

void plMipmap::Filter(hsScalar sig)
{
    hsAssert(fPixelSize == 32, "Only 32 bit implemented");
	ASSERT_UNCOMPRESSED();

	int i, j, ii, jj;

	if( 32 == fPixelSize )
	{
		UInt8 *dst = (UInt8 *)(fImage);

		UInt8* src = (UInt8*)HSMemory::New(fRowBytes * fHeight);
		HSMemory::BlockMove(dst, src, fRowBytes * fHeight);

		if( sig <= 0 )
			sig = kDefaultSigma;

		plFilterMask mask(sig);

		UInt32 srcRowBytes = fRowBytes;
		UInt32 srcHeight = fHeight;
		UInt32 srcWidth = fWidth;

		for( i = 0; i < fHeight; i++ )
		{
			for( j = 0; j < fWidth; j++ )
			{
				UInt8 *center = src + i * srcRowBytes + (j << 2);

				UInt32 chan;
				for( chan = 0; chan < 4; chan++ )
				{
					hsScalar w = 0;
					hsScalar a = 0;

					for( ii = mask.Begin(); ii <= mask.End(); ii++ )
					{
						for( jj = mask.Begin(); jj <= mask.End(); jj++ )
						{
							if( (ii + i >= 0)&&(ii + i < srcHeight)
							  &&(jj + j >= 0)&&(jj + j < srcWidth) )
							{
								w += mask.Mask(ii, jj);
								a += (hsScalar(center[ii*srcRowBytes + (jj<<2) + chan]) + 0.5f) * mask.Mask(ii, jj);
							}
						}
					}
					a /= w;

					dst[i * fRowBytes + (j << 2) + chan] = (UInt8)(a);
				}
			}
		}

		HSMemory::Delete(src);
	}
}

static void CopyPixels(UInt32 srcWidth, UInt32 srcHeight,void *srcPixels,
					UInt32 skipX, UInt32 skipY, UInt32 dstFormat,
					void * &destPixels, UInt32 copyOptions)
{
	int y;
	int xInc = skipX + 1;
	int yInc = skipY + 1;
	int i = 0; 
	int firstX = 0;

	int rowSkip = yInc * srcWidth; // Number of pixels to skip for each line

	const hsRGBAColor32 *p =(const hsRGBAColor32 *)srcPixels;
	UInt16 *pixels16 = (UInt16*)destPixels;
	UInt8 *pixels8 = (UInt8*)destPixels;

	for(y = 0; y < srcHeight; y += yInc, firstX += rowSkip)
	{
		const hsRGBAColor32 *srcPix = &(p[firstX]);
		int x;
		switch (dstFormat)
		{
			case plMipmap::kPixelAI88:
					for(x =0; x < srcWidth; x += xInc)
						pixels16[i++]= ((srcPix[x].a & 0xff) << 8) | (srcPix[x].r & 0xff);
			break;
			case plMipmap::kPixelI8:
				for(x =0; x < srcWidth; x += xInc)
					pixels8[i++]= srcPix[x].r;
			break;
			case plMipmap::kPixelARGB4444:
				for(x = 0; x < srcWidth; x += xInc)
					pixels16[i++]= (((srcPix[x].r>>4) & 0xf) << 8) 
						| (((srcPix[x].g >> 4) & 0xf) << 4) 
						| (((srcPix[x].b >> 4) & 0xf) )
						| (((srcPix[x].a >> 4) & 0xf) << 12);
			break;
			case plMipmap::kPixelARGB1555:
				for(x = 0; x < srcWidth; x += xInc)
					pixels16[i++]= (((srcPix[x].r>>3) & 0x1f) << 10) | 
						(((srcPix[x].g >> 3) & 0x1f) << 5) |
						((srcPix[x].b >> 3) & 0x1f) | ((srcPix[x].a == 0) ? 0 : 0x8000);
			break;
		}
	}
	destPixels = (char *)destPixels + (i * ((dstFormat == plMipmap::kPixelI8 ) ? 1 : 2));
}


UInt32 plMipmap::CopyOutPixels(UInt32 destXSize, UInt32 destYSize, 
					UInt32 dstFormat, void *destPixels, UInt32 copyOptions)
{

	hsAssert(fPixelSize == 32, "Only 32 bit implemented");
	ASSERT_UNCOMPRESSED();

	int i;

	int skipX = fWidth/destXSize - 1;
	int skipY = fHeight/destYSize - 1;

	hsAssert(!fCurrLevel,"Mip Map not at level 0");

	for(i = 0 ; i < (fNumLevels - fCurrLevel); i++)
	{
		CopyPixels(fWidth >> i , fHeight >> i, GetLevelPtr( i ), skipX, skipY,
						dstFormat, destPixels, copyOptions);
	}

	return 0;
}

//// CopyFrom /////////////////////////////////////////////////////////////////

void	plMipmap::CopyFrom( const plMipmap *source )
{
	hsAssert( source != nil, "nil source in plMipmap::CopyFrom()" );

	plProfile_DelMem(MemMipmaps, fTotalSize);
#ifdef MEMORY_LEAK_TRACER
	IRemoveFromMemRecord( (UInt8 *)fImage );
#endif
	delete [] fImage;

	fWidth = source->fWidth;
	fHeight = source->fHeight;
	fRowBytes = source->fRowBytes;
	fPixelSize = source->fPixelSize;
	fFlags = source->fFlags;
	fSpace = source->fSpace;
	fCompressionType = source->fCompressionType;
	fTotalSize = source->fTotalSize;

	fImage = (void *)TRACKED_NEW UInt8[ fTotalSize ];
	memcpy( fImage, source->fImage, fTotalSize );
#ifdef MEMORY_LEAK_TRACER
	IAddToMemRecord( this, plRecord::kViaCopyFrom );
#endif
	plProfile_NewMem(MemMipmaps, fTotalSize);
	
	fNumLevels = source->fNumLevels;

	switch( fCompressionType )
	{
		case kDirectXCompression:
			{
				fDirectXInfo.fBlockSize = source->fDirectXInfo.fBlockSize;
				fDirectXInfo.fCompressionType = source->fDirectXInfo.fCompressionType;
			}
			break;
		case kUncompressed:
		case kJPEGCompression:
			fUncompressedInfo.fType = source->fUncompressedInfo.fType;
			break;
		default:
			hsAssert(false, "Reading unknown compression format.");
			break;
	}

	// Gotta do this AFTER we set our block size, etc.
	IBuildLevelSizes();
	
	// We just changed our texture, so if we have a texture ref, we better dirty it
	if( GetDeviceRef() != nil )
		GetDeviceRef()->SetDirty( true );
}

//// Clone ////////////////////////////////////////////////////////////////////

plMipmap	*plMipmap::Clone() const
{
	plMipmap *newMap = TRACKED_NEW plMipmap;

	newMap->CopyFrom( this );

	return newMap;
}

//// Composite ////////////////////////////////////////////////////////////////
//	Compositing function. Take a (smaller) mipmap and composite it onto this one 
//	at the given location

void	plMipmap::Composite( plMipmap *source, UInt16 x, UInt16 y, plMipmap::CompositeOptions *options )
{
	UInt8	level, numLevels, srcNumLevels, srcLevelOffset, levelsToSkip;
	UInt16	pX, pY;
	UInt32	*srcLevelPtr, *dstLevelPtr, *srcPtr, *dstPtr;
	UInt32	srcRowBytes, dstRowBytes, srcRowBytesToCopy, r, g, b, dR, dG, dB, srcWidth, srcHeight;
	UInt32	srcAlpha, oneMinusAlpha, destAlpha;
	UInt16	srcClipX, srcClipY;


	// Currently we only support 32 bit uncompressed mipmaps
	if( fPixelSize != 32 || fCompressionType == kDirectXCompression )
	{
		hsAssert( false, "Destination mipmap on composite has unsupported format" );
		return;
	}
	if( source->fPixelSize != 32 || source->fCompressionType == kDirectXCompression )
	{
		hsAssert( false, "Source mipmap on composite has unsupported format" );
		return;
	}

	// Grab the correct options pointer
	if( options == nil )
	{
		static CompositeOptions		defaultOptions;
		options = &defaultOptions;
	}

	// Src level skipping
	srcWidth = source->fWidth;
	srcHeight = source->fHeight;
	srcLevelPtr = (UInt32 *)source->fImage;
	srcRowBytes = source->fRowBytes;
	srcNumLevels = source->fNumLevels;
	for( srcLevelOffset = 0, levelsToSkip = options->fSrcLevelsToSkip; levelsToSkip > 0; levelsToSkip--, srcLevelOffset++ )
	{
		srcWidth >>= 1;
		srcHeight >>= 1;
		srcLevelPtr += source->fLevelSizes[ srcLevelOffset ] >> 2;
		srcRowBytes >>= 1;
		srcNumLevels--;
	}

	// Src clipping setup
	srcClipX = srcClipY = 0;
	srcRowBytesToCopy = srcRowBytes;
	if( options->fSrcClipY > 0 )
	{
		srcHeight -= options->fSrcClipY;
		srcClipY = options->fSrcClipY;
	}
	if( options->fSrcClipHeight > 0 )
	{
		srcHeight = options->fSrcClipHeight;
	}
	if( options->fSrcClipX > 0 )
	{
		srcWidth -= options->fSrcClipX;
		srcClipX = options->fSrcClipX;
		srcRowBytesToCopy -= options->fSrcClipX * ( source->fPixelSize >> 3 );
	}
	if( options->fSrcClipWidth > 0 )
	{
		srcWidth = options->fSrcClipWidth;
		srcRowBytesToCopy = srcWidth * ( source->fPixelSize >> 3 );
	}

	// Position checks
	if( x + srcWidth > fWidth || y + srcHeight > fHeight )
	{
		hsAssert( false, "Illegal position on mipmap composite" );
		return;
	}

	// Do the composite on each level
	numLevels = fNumLevels;
	if( numLevels > srcNumLevels )
		numLevels = srcNumLevels;

	dstLevelPtr = (UInt32 *)fImage;
	dstRowBytes = fRowBytes;

	if( options->fFlags & kForceOpaque )
	{
		for( level = 0; level < numLevels; level++, y >>= 1, x >>= 1 )
		{
			srcPtr = srcLevelPtr;
			dstPtr = dstLevelPtr + ( y * dstRowBytes >> 2 ) + x;

			// Clipping
			srcPtr += srcClipY * ( srcRowBytes >> 2 ) + srcClipX;

			for( pY = (UInt16)srcHeight; pY > 0; pY-- )
			{
				memcpy( dstPtr, srcPtr, srcRowBytesToCopy );
				for( pX = 0; pX < srcWidth; pX++ )
				{
					// Force the alpha opaque
					dstPtr[ pX ] |= 0xff000000;
				}
				dstPtr += dstRowBytes >> 2;
				srcPtr += srcRowBytes >> 2;
			}
		
			srcLevelPtr += source->fLevelSizes[ level + srcLevelOffset ] >> 2;
			dstLevelPtr += fLevelSizes[ level ] >> 2;
			srcRowBytes >>= 1;
			dstRowBytes >>= 1;
			srcRowBytesToCopy >>= 1;
			if( srcHeight > 1 )
				srcHeight >>= 1;
			srcClipX >>= 1;
			srcClipY >>= 1;
		}	
	}
	else if( options->fFlags & kCopySrcAlpha )
	{
		for( level = 0; level < numLevels; level++, y >>= 1, x >>= 1 )
		{
			srcPtr = srcLevelPtr;
			dstPtr = dstLevelPtr + ( y * dstRowBytes >> 2 ) + x;

			// Clipping
			srcPtr += srcClipY * ( srcRowBytes >> 2 ) + srcClipX;

			for( pY = (UInt16)srcHeight; pY > 0; pY-- )
			{
				memcpy( dstPtr, srcPtr, srcRowBytesToCopy );
				dstPtr += dstRowBytes >> 2;
				srcPtr += srcRowBytes >> 2;
			}
		
			srcLevelPtr += source->fLevelSizes[ level + srcLevelOffset ] >> 2;
			dstLevelPtr += fLevelSizes[ level ] >> 2;
			srcRowBytes >>= 1;
			dstRowBytes >>= 1;
			srcRowBytesToCopy >>= 1;
			if( srcHeight > 1 )
				srcHeight >>= 1;
			srcClipX >>= 1;
			srcClipY >>= 1;
		}	
	}
	else if( options->fFlags & kMaskSrcAlpha )
	{
		for( level = 0; level < numLevels; level++, y >>= 1, x >>= 1 )
		{
			srcPtr = srcLevelPtr;
			dstPtr = dstLevelPtr + ( y * dstRowBytes >> 2 ) + x;

			// Clipping
			srcPtr += srcClipY * ( srcRowBytes >> 2 ) + srcClipX;

			for( pY = (UInt16)srcHeight; pY > 0; pY-- )
			{
				for( pX = 0; pX < srcWidth; pX++ )
				{
					srcAlpha = options->fOpacity * ( ( srcPtr[ pX ] >> 16 ) & 0x0000ff00 ) / 255 / 256;
					if( srcAlpha != 0 )
						dstPtr[ pX ] = ( srcPtr[ pX ] & 0x00ffffff ) | ( srcAlpha << 24 );
				}
				dstPtr += dstRowBytes >> 2;
				srcPtr += srcRowBytes >> 2;
			}
		
			srcLevelPtr += source->fLevelSizes[ level + srcLevelOffset ] >> 2;
			dstLevelPtr += fLevelSizes[ level ] >> 2;
			srcRowBytes >>= 1;
			dstRowBytes >>= 1;
			srcRowBytesToCopy >>= 1;
			if( srcHeight > 1 )
				srcHeight >>= 1;
			srcClipX >>= 1;
			srcClipY >>= 1;
		}	
	}
	else
	{
		for( level = 0; level < numLevels; level++, y >>= 1, x >>= 1 )
		{
			srcPtr = srcLevelPtr;
			dstPtr = dstLevelPtr + ( y * dstRowBytes >> 2 ) + x;

			// Clipping
			srcPtr += srcClipY * ( srcRowBytes >> 2 ) + srcClipX;

			for( pY = (UInt16)srcHeight; pY > 0; pY-- )			
			{
				// Reverse the loop so we can count downwards--slightly faster
				pX = (UInt16)srcWidth;
				do
				{
					pX--;

					// Wacko trick here. Alphas are 0-255, which means scaling by alpha would
					// be a v' = v * alpha / 255 operation sequence. However, since we hate
					// dividing by 255 all the time, we actually scale the alpha just ever so
					// slightly so it's 0-256, which makes the divide a simple shift. Note
					// that this will result in some tiny bit of aliasing, but it shouldn't be
					// enough to notice
					
					if (!(srcPtr[pX] >> 24)) // Zero alpha. Skip this pixel
						continue;

					srcAlpha = options->fOpacity * ( ( srcPtr[ pX ] >> 16 ) & 0x0000ff00 ) / 255 / 256;
					oneMinusAlpha = 256 - srcAlpha;
					destAlpha = dstPtr[ pX ] & 0xff000000;

					r = (UInt32)((( srcPtr[ pX ] >> 16 ) & 0x000000ff) * options->fRedTint);
					g = (UInt32)((( srcPtr[ pX ] >> 8  ) & 0x000000ff) * options->fGreenTint);
					b = (UInt32)((( srcPtr[ pX ]       ) & 0x000000ff) * options->fBlueTint);
					dR = ( dstPtr[ pX ] >> 16 ) & 0x000000ff;
					dG = ( dstPtr[ pX ] >> 8  ) & 0x000000ff;
					dB = ( dstPtr[ pX ]       ) & 0x000000ff;
					r = ( r * srcAlpha ) >> 8;
					g = ( g * srcAlpha ) >> 8;
					b = ( b * srcAlpha ) >> 8;
					dR = ( dR * oneMinusAlpha ) >> 8;
					dG = ( dG * oneMinusAlpha ) >> 8;
					dB = ( dB * oneMinusAlpha ) >> 8;

					// Dest alpha for now is just our original dest alpha
					dstPtr[ pX ] = ( ( r + dR ) << 16 ) | ( ( g + dG ) << 8 ) | ( b + dB ) | destAlpha;

					if( !( options->fFlags & kBlendWriteAlpha ) )
						continue;

					// Unless our blend option is set of course
					dstPtr[ pX ] = ( dstPtr[ pX ] & 0x00ffffff ) | ( srcAlpha << 24 );

				} while( pX > 0 );

				dstPtr += dstRowBytes >> 2;
				srcPtr += srcRowBytes >> 2;
			}
		
			srcLevelPtr += source->fLevelSizes[ level + srcLevelOffset ] >> 2;
			dstLevelPtr += fLevelSizes[ level ] >> 2;
			srcRowBytes >>= 1;
			dstRowBytes >>= 1;
			if( srcWidth > 1 )
				srcWidth >>= 1;
			if( srcHeight > 1 )
				srcHeight >>= 1;
			srcClipX >>= 1;
			srcClipY >>= 1;
		}	
	}

	// All done!
	if( GetDeviceRef() != nil )
		GetDeviceRef()->SetDirty( true );
}

//// Colorize /////////////////////////////////////////////////////////////////
//	Colorizes a mipmap so that each level is color-coded. Assume max 10 levels
//	(coloring wraps after 10).

void	plMipmap::Colorize()
{
	UInt32		currColor, width, height;
	UInt8		currLevel;


	if( fPixelSize != 32 && fCompressionType != kDirectXCompression )
	{
		/// Most likely this is a luminance or luminance/alpha map,
		/// so we ignore it (it's up to the device to make sure we
		/// only get 32-bit or compressed mipmaps)
		return;
	}

	if( fFlags & kForceOneMipLevel )
	{
		// Don't colorize if it's not mipmapped...
		return;
	}

	/// First handle compressed levels, if any
	currLevel = 0;
	currColor = 0;
	width = fWidth;
	height = fHeight;
	if( fCompressionType == kDirectXCompression )
	{
		for( ; currLevel < fNumLevels; currLevel++ )
		{
			/// Are we over the threshold?
			SetCurrLevel( currLevel );
			if( ( fCurrLevelWidth | fCurrLevelHeight ) & 0x03 )
				break;

			/// Since this level is compressed, we have to use the codec...
			hsCodecManager::Instance().ColorizeCompMipmap( this, fColorMasks[ currColor ] );

			/// Increment the color
			currColor = ( currColor >=9 ) ? 0 : currColor + 1;
		}
	}

	/// Now loop through the uncompressed levels
	for( ; currLevel < fNumLevels; currLevel++ )
	{
		/// Do this one
		IColorLevel( currLevel, fColorMasks[ currColor ] );

		/// Increment the color
		currColor = ( currColor >=9 ) ? 0 : currColor + 1;
	}

	SetCurrLevel( 0 );
}

//// IColorLevel //////////////////////////////////////////////////////////////
//	Colorizes the current level of a mipmap according to the color mask given
//	(percentages of r, g & b in the range of 0-2).

void	plMipmap::IColorLevel( UInt8 level, const UInt8 *colorMask )
{	
	UInt32		index, max, color, gray, grayDiv2, *data, width, height;
	UInt8		compMasks[ 3 ][ 2 ] = { { 0, 0 }, { 0, 0xff }, { 0xff, 0 } };
	

	data = (UInt32 *)GetLevelPtr( level, &width, &height );
	max = fLevelSizes[ level ] >> 2;

	for( index = 0; index < max; index++ )
	{
		/// Get color and calculate gray (average of r, g & b)
		color = data[ index ];
		gray = ( ( color >> 16 ) & 0xff ) + ( ( color >> 8 ) & 0xff ) + ( color & 0xff );
		gray /= 3;
		gray = 0xff - ( ( 0xff - gray ) >> 1 );		// Lighten it 50%
		grayDiv2 = gray >> 1;

		/// Preserve alpha
		color &= 0xff000000;

		/// Now rewrite the components based on the color mask
		color |= ( ( gray & compMasks[ colorMask[ 0 ] ][ 0 ] ) |
			   ( grayDiv2 & compMasks[ colorMask[ 0 ] ][ 1 ] ) ) << 16;
		color |= ( ( gray & compMasks[ colorMask[ 1 ] ][ 0 ] ) |
			   ( grayDiv2 & compMasks[ colorMask[ 1 ] ][ 1 ] ) ) << 8;
		color |= ( ( gray & compMasks[ colorMask[ 2 ] ][ 0 ] ) |
			   ( grayDiv2 & compMasks[ colorMask[ 2 ] ][ 1 ] ) );

		data[ index ] = color;
	}
}

///////////////////////////////////////////////////////////////////////////////
//// Scaling //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

//// ScaleNicely //////////////////////////////////////////////////////////////
//	Does a nice (smoothed) scaling of a 1-level mipmap onto another 1-level 
//	mipmap. Works only for 32-bit mipmaps.

void	plMipmap::ScaleNicely( UInt32 *destPtr, UInt16 destWidth, UInt16 destHeight,
								UInt16 destStride, plMipmap::ScaleFilter filter ) const
{
	UInt16		destX, destY, srcX, srcY;
	Int16		srcStartX, srcEndX, srcStartY, srcEndY;
	float		srcPosX, srcPosY, destToSrcXScale, destToSrcYScale, filterWidth, filterHeight, weight;
	float		totalWeight;
	hsColorRGBA	color, accumColor;
	float		whyWaits[ 16 ], whyWait, xWeights[ 16 ];
	UInt32		*srcPtr;


	// Init
	destToSrcXScale = (float)fWidth / (float)destWidth;
	destToSrcYScale = (float)fHeight / (float)destHeight;

	// Filter size is the radius of the area (or rather, half the box size) around the source position 
	// that we sample from. We calculate it so that a 1:1 scale would result in a filter size of 1 (thus 
	// making a box filter at 1:1 result in a straight copy of the original)
	filterWidth = 1.f * destToSrcXScale;
	filterHeight = 1.f * destToSrcYScale;

	// If we are upsampling, we still want a filter at least a pixel half-width/height, which will just do
	// a bilerp up. That doesn't make this function correctly resample, or excuse the incredibly complicated
	// code to do something incredibly simple, but at least it doesn't fail so obviously.
	if( filterWidth < 1.f )
		filterWidth = 1.f;
	if( filterHeight < 1.f )
		filterHeight = 1.f;

	// Process
	for( destY = 0; destY < destHeight; destY++ )
	{
		// Calculate the span across this row
		srcPosY = destY * destToSrcYScale;

		srcStartY = (Int16)( srcPosY - filterHeight );
		if( srcStartY < 0 ) 
			srcStartY = 0;

		srcEndY = (Int16)( srcPosY + filterHeight );
		if( srcEndY >= fHeight ) 
			srcEndY = (Int16)(fHeight - 1);

		// Precalc the y weights
		for( srcY = srcStartY; srcY <= srcEndY && ( srcY - srcStartY ) < 16; srcY++ )
			whyWaits[ srcY - srcStartY ] = 1.f - ( fabs( (float)srcY - srcPosY ) / filterHeight );

		for( destX = 0; destX < destWidth; destX++ )
		{
			// For this pixel in the destination, figure out where in the source image we virtually are
			srcPosX = destX * destToSrcXScale;

			// Range of pixels that the filter covers
			srcStartX = (Int16)( srcPosX - filterWidth );
			if( srcStartX < 0 ) 
				srcStartX = 0;
			
			srcEndX = (Int16)( srcPosX + filterWidth );
			if( srcEndX >= fWidth ) 
				srcEndX = (Int16)(fWidth - 1);

			// Precalc the x weights
			for( srcX = srcStartX; srcX <= srcEndX && ( srcX - srcStartX ) < 16; srcX++ )
				xWeights[ srcX - srcStartX ] = 1.f - ( fabs( (float)srcX - srcPosX ) / filterWidth );

			// Sum up all the weighted colors in the filter area
			accumColor.Set( 0.f, 0.f, 0.f, 0.f );
			totalWeight = 0.f;
			for( srcY = srcStartY; srcY <= srcEndY; srcY++ )
			{
				if( srcY - srcStartY < 16 )
					whyWait = whyWaits[ srcY - srcStartY ];
				else
					whyWait = 1.f - ( fabs( (float)srcY - srcPosY ) / filterHeight );

				if( whyWait <= 0.f )
					continue;

				srcPtr = GetAddr32( srcStartX, srcY );
				for( srcX = srcStartX; srcX <= srcEndX; srcX++, srcPtr++ )
				{
					// Our weight...
					weight = ( srcX - srcStartX < 16 ) ? xWeights[ srcX - srcStartX ] : 
								( 1.f - ( fabs( (float)srcX - srcPosX ) / filterWidth ) );
					weight *= whyWait;

					if( weight > 0.f )
					{
						// Grab pixel values from us...
						color.FromARGB32( *srcPtr );
						color *= weight;
						accumColor += color;
						totalWeight += weight;
					}
				}
			}
			accumColor *= 1.f / totalWeight;

			// Set the final value
			*destPtr = accumColor.ToARGB32();
			destPtr++;
		}
		destPtr += destStride - destWidth;
	}
}

//// ResizeNicely /////////////////////////////////////////////////////////////
//	Resizes us using the ScaleNicely function. Only works for 1-level, 32bpp
//	uncompressed mipmaps.

hsBool	plMipmap::ResizeNicely( UInt16 newWidth, UInt16 newHeight, plMipmap::ScaleFilter filter )
{
	// Make a temp buffer
	UInt32	*newData = TRACKED_NEW UInt32[ newWidth * newHeight ];
	if( newData == nil )
		return false;

	// Scale to it
	ScaleNicely( newData, newWidth, newHeight, newWidth, filter );

	// Reset us to that
	Reset();
	fWidth = newWidth;
	fHeight = newHeight;
	fRowBytes = fWidth * fPixelSize >> 3;
	fTotalSize = fRowBytes * fWidth;
	fNumLevels = 1;
	IBuildLevelSizes();
	fImage = newData;
	SetCurrLevel( 0 );
	plProfile_NewMem(MemMipmaps, fTotalSize);

#ifdef MEMORY_LEAK_TRACER
	IAddToMemRecord( this, plRecord::kViaResize );
#endif

	// All done!
	return true;
}

#ifdef MEMORY_LEAK_TRACER
//// Debug Mipmap Memory Leak Tracker /////////////////////////////////////////

plMipmap::plRecord	*plMipmap::fRecords = nil;
UInt32				plMipmap::fNumMipmaps = 0;

void	plMipmap::IAddToMemRecord( plMipmap *mip, plRecord::Method method )
{
	plRecord	*newRecord = TRACKED_NEW plRecord;


	newRecord->fCompressionType = mip->fCompressionType;
	newRecord->fCreationMethod = method;
	newRecord->fHeight = mip->fHeight;
	newRecord->fWidth = mip->fWidth;
	newRecord->fImage = mip->fImage;
	newRecord->fNumLevels = mip->fNumLevels;
	newRecord->fRowBytes = mip->fRowBytes;
	if( mip->GetKey() )
		strcpy( newRecord->fKeyName, mip->GetKeyName() );
	else
		strcpy( newRecord->fKeyName, "<noKey>" );
	if( mip->fCompressionType != kDirectXCompression )
		newRecord->fUncompressedInfo.fType = mip->fUncompressedInfo.fType;
	else
	{
		newRecord->fDirectXInfo.fBlockSize = mip->fDirectXInfo.fBlockSize;
		newRecord->fDirectXInfo.fCompressionType = mip->fDirectXInfo.fCompressionType;
	}

	newRecord->Link( &fRecords );
}

void	plMipmap::IRemoveFromMemRecord( UInt8 *image )
{
	plRecord	*record;


	for( record = fRecords; record != nil; record = record->fNext )
	{
		if( record->fImage == image )
		{
			record->Unlink();
			delete record;
			return;
		}
	}
}

void	plMipmap::IReportLeaks()
{
	plRecord	*record, *next;
	static char	msg[ 512 ], m2[ 128 ];
	UInt32		size;


	hsStatusMessage( "--- plMipmap Leaks ---\n" );
	for( record = fRecords; record != nil;  )
	{
		size = record->fHeight * record->fRowBytes;
		if( size >= 1024 )
			sprintf( msg, "%s, %4.1f kB: \t%dx%d, %d levels, %d bpr", record->fKeyName, size / 1024.f, record->fWidth, record->fHeight, record->fNumLevels, record->fRowBytes );
		else
			sprintf( msg, "%s, %u bytes: \t%dx%d, %d levels, %d bpr", record->fKeyName, size, record->fWidth, record->fHeight, record->fNumLevels, record->fRowBytes );

		if( record->fCompressionType != kDirectXCompression )
			sprintf( m2, " UType: %d", record->fUncompressedInfo.fType );
		else
			sprintf( m2, " DXT%d BSz: %d", record->fDirectXInfo.fCompressionType, record->fDirectXInfo.fBlockSize );
		strcat( msg, m2 );

		switch( record->fCreationMethod )
		{
			case plRecord::kViaCreate: strcat( msg, " via Create\n" ); break;
			case plRecord::kViaRead: strcat( msg, " via Read\n" ); break;
			case plRecord::kViaClipToMaxSize: strcat( msg, " via ClipToMaxSize\n" ); break;
			case plRecord::kViaDetailMapConstructor: strcat( msg, " via DetailMapConstructor\n" ); break;
			case plRecord::kViaCopyFrom: strcat( msg, " via CopyFrom\n" ); break;
			case plRecord::kViaResize: strcat( msg, " via Resize\n" ); break;
		}

		hsStatusMessage( msg );

		next = record->fNext;
		record->Unlink();
		delete record;
		record = next;
	}
	hsStatusMessage( "--- End of plMipmap Leaks ---\n" );
}

#endif