sl@0: // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "BMCONV.H"
sl@0: #include <stdlib.h>
sl@0: #include <ctype.h>
sl@0: #include <sys/stat.h>
sl@0: 
sl@0: extern TRgb* color256Palette;
sl@0: extern char* color256InversePalette;
sl@0: 
sl@0: static inline bool CanCopy16bppData(const char* aDest, const char* aDestEnd, int aDataSize)
sl@0: 	{
sl@0: 	const char* aDestNew = 	aDest + (aDataSize / 128) * (256 + 1) + //(2 * 128) bytes data + 1 leading byte
sl@0: 		                            (aDataSize % 128 ? (aDataSize % 128) * 2 + 1 : 0);
sl@0: 	return aDestNew <= aDestEnd;
sl@0: 	}
sl@0: 
sl@0: static inline bool CanWrite16bppValue(const char* aDest, const char* aDestEnd, int aDataSize)
sl@0: 	{
sl@0: 	const char* aDestNew = 	aDest + (aDataSize / 128) * (2 + 1) + //2 bytes data + 1 leading byte
sl@0: 		                            (aDataSize % 128 ? 2 + 1 : 0);
sl@0: 	return aDestNew <= aDestEnd;
sl@0: 	}
sl@0: 
sl@0: static inline bool CanCopy8bppData(const char* aDest, const char* aDestEnd, int aDataSize)
sl@0: 	{
sl@0: 	const char* aDestNew = 	aDest + (aDataSize / 128) * (128 + 1) + //128 bytes data + 1 leading byte
sl@0: 		                            (aDataSize % 128 ? (aDataSize % 128) + 1 : 0);
sl@0: 	return aDestNew <= aDestEnd;
sl@0: 	}
sl@0: 
sl@0: static inline bool CanWrite8bppValue(const char* aDest, const char* aDestEnd, int aDataSize)
sl@0: 	{
sl@0: 	const char* aDestNew = 	aDest + (aDataSize / 128) * (1 + 1) + //1 byte data + 1 leading byte
sl@0: 		                            (aDataSize % 128 ? 1 + 1 : 0);
sl@0: 	return aDestNew <= aDestEnd;
sl@0: 	}
sl@0: 
sl@0: static inline bool CanCopy24bppData(const char* aDest, const char* aDestEnd, int aDataSize)
sl@0: 	{
sl@0: 	const char* aDestNew = 	aDest + (aDataSize / 128) * (384 + 1) + //(128 * 3) bytes data + 1 leading byte
sl@0: 		                            (aDataSize % 128 ? (aDataSize % 128) * 3 + 1 : 0);
sl@0: 	return aDestNew <= aDestEnd;
sl@0: 	}
sl@0: 
sl@0: static inline bool CanWrite24bppValue(const char* aDest, const char* aDestEnd, int aDataSize)
sl@0: 	{
sl@0: 	const char* aDestNew = 	aDest + (aDataSize / 128) * (3 + 1) + //3 bytes data + 1 leading byte
sl@0: 		                            (aDataSize % 128 ? 3 + 1 : 0);
sl@0: 	return aDestNew <= aDestEnd;
sl@0: 	}
sl@0: 
sl@0: static inline bool CanCopy32bppData(const char* aDest, const char* aDestEnd, int aDataSize)
sl@0: 	{
sl@0: 	const char* aDestNew = 	aDest + (aDataSize / 128) * (512 + 1) + //(128 * 4) bytes data + 1 leading byte
sl@0: 		                            (aDataSize % 128 ? (aDataSize % 128) * 4 + 1 : 0);
sl@0: 	return aDestNew <= aDestEnd;
sl@0: 	}
sl@0: 
sl@0: static inline bool CanWrite32bppValue(const char* aDest, const char* aDestEnd, int aDataSize)
sl@0: 	{
sl@0: 	const char* aDestNew = 	aDest + (aDataSize / 128) * (4 + 1) + //4 bytes data + 1 leading byte
sl@0: 		                            (aDataSize % 128 ? 4 + 1 : 0);
sl@0: 	return aDestNew <= aDestEnd;
sl@0: 	}
sl@0: 
sl@0: BitmapCompiler::BitmapCompiler(char* aSourcefilenames[],int aNumSources):
sl@0: 	iSourcefilenames(aSourcefilenames),
sl@0: 	iPbmSources(NULL),
sl@0: 	iNumSources(aNumSources)
sl@0: 	{}
sl@0: 
sl@0: BitmapCompiler::~BitmapCompiler()
sl@0: 	{
sl@0: 	iDestFile.close();
sl@0: 	if(iPbmSources)
sl@0: 		for(int count=0;count<iNumSources;count++)
sl@0: 			delete iPbmSources[count];
sl@0: 	delete [] iPbmSources;
sl@0: 	iPbmSources = NULL;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::Compile(TStoreType aSt,int aCompress,char* aDestfilename,char* aHeaderFilename,char* aPaletteFilename)
sl@0: 	{
sl@0: 	int ret = LoadPalette(aPaletteFilename);
sl@0: 	if (ret)
sl@0: 		return ret;
sl@0: 
sl@0: 	iDestFile.open(aDestfilename, ios::out | ios::binary);
sl@0: 	if(iDestFile.is_open()==0)
sl@0: 		return DestFile;
sl@0: 	if (iNumSources < 1)
sl@0: 		return SourceFile;
sl@0: 
sl@0: 	if (iNumSources==1 && ((iSourcefilenames[0][0]==OPTCHAR || iSourcefilenames[0][0]==ALTERNATE_OPTCHAR)) && iSourcefilenames[0][1]=='m')
sl@0: 		{
sl@0: 		// Source is an existing MBM file, presumably because we want to convert
sl@0: 		// a filestore into a ROM image.
sl@0: 		if (aHeaderFilename)
sl@0: 			{
sl@0: 			cout << "Header file generation is not permitted with /m or -m\n";
sl@0: 			aHeaderFilename = NULL;
sl@0: 			}
sl@0: 		iSourcefilenames[0]+=2;
sl@0: 		EpocLoader pl;
sl@0: 		int romFormat;
sl@0: 		ret = pl.EpocBitmapCount(iSourcefilenames[0], iNumSources, romFormat);
sl@0: 		if (!ret)
sl@0: 			ret = LoadPbmFile(iSourcefilenames[0]);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// Read the usual list of [OPT]bmp_n source bitmaps.
sl@0: 		ret = LoadSourcefiles();
sl@0: 		}
sl@0: 	if (ret)
sl@0: 		return ret;
sl@0: 
sl@0: 	ret = CreateHeader(aHeaderFilename);
sl@0: 	if (ret)
sl@0: 		return ret;
sl@0: 
sl@0: 	if (aSt == ERomStore || aSt == ECompressedRomStore)
sl@0: 		ret = RomImage(aSt == ECompressedRomStore);
sl@0: 	else
sl@0: 		ret = FileImage(aCompress);
sl@0: 	return ret;
sl@0: 	};
sl@0: 
sl@0: int BitmapCompiler::AllocatePbmSourcesArray()
sl@0: 	{
sl@0: 	iPbmSources = new SEpocBitmapHeader*[iNumSources];
sl@0: 	if(iPbmSources == NULL)
sl@0: 		return NoMemory;
sl@0: 
sl@0: 	memset(iPbmSources,0xff,sizeof(SEpocBitmapHeader*)*iNumSources);
sl@0: 	int count;
sl@0: 	for(count=0;count<iNumSources;count++)
sl@0: 		iPbmSources[count]=NULL;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::LoadSourcefiles()
sl@0: 	{
sl@0: 	int ret = AllocatePbmSourcesArray();
sl@0: 	if (ret)
sl@0: 		return ret;
sl@0: 	for(int count=0;count<iNumSources;count++)
sl@0: 		{
sl@0: 		bool useAlpha = false;
sl@0: 		int bpp = 2;
sl@0: 		TBitmapColor color = EMonochromeBitmap;
sl@0: 		BitmapLoader bmpload;
sl@0: 		if(iSourcefilenames[count][0]==OPTCHAR || iSourcefilenames[count][0]==ALTERNATE_OPTCHAR)
sl@0: 			{
sl@0: 			iSourcefilenames[count]++;
sl@0: 			if(iSourcefilenames[count][0]=='c')
sl@0: 				{
sl@0: 				color = EColorBitmap;
sl@0: 				iSourcefilenames[count]++;
sl@0: 				}
sl@0: 			bpp=iSourcefilenames[count][0]-'0';
sl@0: 			iSourcefilenames[count]++;
sl@0: 			int next=iSourcefilenames[count][0]-'0';
sl@0: 			if(next==2 || next==6 || next==4)
sl@0: 				{
sl@0: 				bpp=bpp*10+next;
sl@0: 				iSourcefilenames[count]++;
sl@0: 				}
sl@0: 			if(iSourcefilenames[count][0]=='a')
sl@0: 				{
sl@0: 				useAlpha = true;
sl@0: 				iSourcefilenames[count]++;
sl@0: 				if (color!=EColorBitmap || bpp!=32)
sl@0: 					return Bpp;
sl@0: 				}
sl@0: 			if (color == EColorBitmap && bpp!=4 && bpp!=8 && bpp!=12 && bpp!=16 && bpp!=24 && bpp!=32)
sl@0: 				return Bpp;
sl@0: 			if (color == EMonochromeBitmap && bpp!=1 && bpp!=2 && bpp!=4 && bpp!=8)
sl@0: 				return Bpp;
sl@0: 			}
sl@0: 		if (color == EColorBitmap && useAlpha)
sl@0: 			color = EColorBitmapAlpha;
sl@0: 		ret = bmpload.LoadBitmap(iSourcefilenames[count],bpp,color,iPbmSources[count]);
sl@0: 		if (ret)
sl@0: 			return ret;
sl@0: 		}
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::LoadPbmFile(char* aPbmFilename)
sl@0: 	{
sl@0: 	int ret = AllocatePbmSourcesArray();
sl@0: 	if (ret)
sl@0: 		return ret;
sl@0: 	for(int count=0;count<iNumSources;count++)
sl@0: 		{
sl@0: 		EpocLoader pl;
sl@0: 		ret = pl.LoadEpocBitmap(aPbmFilename,count);
sl@0: 		if (!ret)
sl@0: 			ret = pl.DupBitmap(iPbmSources[count]);
sl@0: 		if (ret)
sl@0: 			return ret;
sl@0: 		}
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::RomImage(bool aCompress)
sl@0: 	{
sl@0: 	int count=0;
sl@0: 
sl@0: 	if (aCompress)
sl@0: 		{
sl@0: 		for(; count<iNumSources; count++)
sl@0: 			{
sl@0: 			int ret = CompressBitmap(iPbmSources[count]);
sl@0: 			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	int ret = WriteRomheader();
sl@0: 	if (ret)
sl@0: 		return ret;
sl@0: 
sl@0: 	for(count=0;count<iNumSources;count++)
sl@0: 		{
sl@0: 		ret = WriteRombitmap(iPbmSources[count]);
sl@0: 		if (ret)
sl@0: 			return ret;
sl@0: 		}
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::FileImage(int aCompress)
sl@0: 	{
sl@0: 	int count = 0;
sl@0: 	if(aCompress)
sl@0: 		{
sl@0: 		for(;count<iNumSources;count++)
sl@0: 			{
sl@0: 			int ret = CompressBitmap(iPbmSources[count]);
sl@0: 			if(ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		}
sl@0: 	int ret = WriteFileheader();
sl@0: 	if (ret)
sl@0: 		return ret;
sl@0: 	for (count=0;count<iNumSources;count++)
sl@0: 		{
sl@0: 		ret = WriteFilebitmap(iPbmSources[count]);
sl@0: 		if (ret)
sl@0: 			return ret;
sl@0: 		}
sl@0: 	ret = WriteHeadStream();
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteRomheader()
sl@0: 	{
sl@0: 	iDestFile.write((char*)&KMultiBitmapRomImageUid,4);
sl@0: 	iDestFile.write((char*)&iNumSources,4);
sl@0: 	int byteswritten=8+(iNumSources*4);
sl@0: 	for (int count=0;count<iNumSources;count++)
sl@0: 		{
sl@0: 		iDestFile.write((char*)&byteswritten,4);
sl@0: 		byteswritten+=(((iPbmSources[count]->iBitmapSize)+3)/4*4)-sizeof(SEpocBitmapHeader)+sizeof(Bitmap);
sl@0: 		}
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteRombitmap(SEpocBitmapHeader* aPbm)
sl@0: 	{
sl@0: 	if (aPbm->iPaletteEntries != 0)
sl@0: 	    return PaletteSupportNotImplemented;
sl@0: 
sl@0: 	int bitmapsize = aPbm->iBitmapSize-sizeof(SEpocBitmapHeader)+sizeof(Bitmap);
sl@0: 	bitmapsize = ((bitmapsize+3)/4)*4;
sl@0: 
sl@0: 	char* buffer = new char[bitmapsize];
sl@0: 	if (buffer == NULL)
sl@0: 		return NoMemory;
sl@0: 	memset(buffer,0xff,bitmapsize);
sl@0: 
sl@0: 	Bitmap* bmp = (Bitmap*)buffer;
sl@0: 	bmp->iUid=KCBitwiseBitmapUid;
sl@0: 	TBitmapColor color = aPbm->iColor;
sl@0: 
sl@0: 	switch(aPbm->iBitsPerPixel)
sl@0: 		{ // for corresponding enums, see TDisplayMode in <gdi.h>
sl@0: 	case 1:
sl@0: 		bmp->iDispMode=1;
sl@0: 		break;
sl@0: 	case 2:
sl@0: 		bmp->iDispMode=2;
sl@0: 		break;
sl@0: 	case 4:
sl@0: 		if (color == EMonochromeBitmap)
sl@0: 			bmp->iDispMode=3;
sl@0: 		else
sl@0: 			bmp->iDispMode=5;
sl@0: 		break;
sl@0: 	case 8:
sl@0: 		if (color == EMonochromeBitmap)
sl@0: 			bmp->iDispMode=4;
sl@0: 		else
sl@0: 			bmp->iDispMode=6;
sl@0: 		break;
sl@0: 	case 12:
sl@0: 		bmp->iDispMode=10;
sl@0: 		break;
sl@0: 	case 16:
sl@0: 		bmp->iDispMode=7;
sl@0: 		break;
sl@0: 	case 24:
sl@0: 		bmp->iDispMode=8;
sl@0: 		break;
sl@0: 	case 32:
sl@0: 		if (color == EColorBitmapAlpha)
sl@0: 			bmp->iDispMode=12; // Color16MA
sl@0: 		else
sl@0: 			bmp->iDispMode=11; // Color16MU
sl@0: 		break;
sl@0: 	default:
sl@0: 		delete [] buffer;
sl@0: 		return SourceFile;
sl@0: 		}
sl@0: 
sl@0: 	bmp->iHeap = NULL;
sl@0: 	bmp->iPile = NULL;
sl@0: 	bmp->iHeader = *aPbm;
sl@0: 	bmp->iByteWidth = BitmapUtils::ByteWidth(bmp->iHeader.iWidthInPixels,bmp->iHeader.iBitsPerPixel);
sl@0: 	bmp->iDataOffset = sizeof(Bitmap);
sl@0: 
sl@0: 	CopyTail(buffer + sizeof(Bitmap), aPbm, aPbm->iBitmapSize, sizeof(SEpocBitmapHeader));
sl@0: 	iDestFile.write(buffer,bitmapsize);
sl@0: 
sl@0: 	delete [] buffer;
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteFileheader()
sl@0: 	{
sl@0: 	int zero=0;
sl@0: 	iDestFile.write((char*)&KWriteOnceFileStoreUid,4);
sl@0: 	iDestFile.write((char*)&KMultiBitmapFileImageUid,4);
sl@0: 	iDestFile.write((char*)&zero,4);
sl@0: 	iDestFile.write((char*)&KMultiBitmapFileImageChecksum,4);
sl@0: 	int byteswritten=16;
sl@0: 	for(int count=0;count<iNumSources;count++)
sl@0: 		{
sl@0: 		byteswritten+=iPbmSources[count]->iBitmapSize;
sl@0: 		}
sl@0: 	byteswritten+=4;
sl@0: 	iDestFile.write((char*)&byteswritten,4);
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteHeadStream()
sl@0: 	{
sl@0: 	iDestFile.write((char*)&iNumSources,4);
sl@0: 	int byteswritten=20;
sl@0: 	for(int count=0;count<iNumSources;count++)
sl@0: 		{
sl@0: 		iDestFile.write((char*)&byteswritten,4);
sl@0: 		byteswritten+=iPbmSources[count]->iBitmapSize;
sl@0: 		}
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteFilebitmap(SEpocBitmapHeader* aPbm)
sl@0: 	{
sl@0: 	if (aPbm->iPaletteEntries != 0)
sl@0: 		return PaletteSupportNotImplemented;
sl@0: 
sl@0: 	int dataSize = aPbm->iBitmapSize - sizeof(SEpocBitmapHeader);
sl@0: 
sl@0: 	iDestFile.write((char*)(aPbm),sizeof(SEpocBitmapHeader));
sl@0: 	// WritePalette()
sl@0: 	iDestFile.write(((char*)(aPbm)) + sizeof(SEpocBitmapHeader),dataSize);
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: void BitmapCompiler::WritePalette()
sl@0: 	{
sl@0: 	for (int index = 0; index < 256; index++)
sl@0: 		{
sl@0: 		iDestFile.write((char*)(&iPalette[index]),3);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::LoadPalette(char* aPaletteFilename)
sl@0: 	{
sl@0: 	if (!aPaletteFilename)
sl@0: 		{
sl@0: 		iDefaultPalette = 1;
sl@0: 		return NoError;
sl@0: 		}
sl@0: 
sl@0: 	iDefaultPalette = 0;
sl@0: 	color256Palette = iPalette;
sl@0: 	color256InversePalette = iInversePalette;
sl@0: 
sl@0: 	struct stat fileinfo;
sl@0: 	if (stat(aPaletteFilename,&fileinfo)==-1)
sl@0: 		return CommandFile;
sl@0: 
sl@0: 	int filesize = fileinfo.st_size;
sl@0: 	if (filesize == 0)
sl@0: 		return PaletteFile;
sl@0: 
sl@0: #if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
sl@0: 	fstream paletteFile(aPaletteFilename, ios::in | ios::binary);
sl@0: #else
sl@0: 	fstream paletteFile(aPaletteFilename, ios::in | ios::binary | ios::nocreate);
sl@0: #endif
sl@0: 
sl@0: 	if(!paletteFile.is_open())
sl@0: 		return PaletteFile;
sl@0: 
sl@0: 	char* paletteData = new char[filesize];
sl@0: 	if (!paletteData)
sl@0: 		return NoMemory;
sl@0: 
sl@0: 	memset(paletteData,0,filesize);
sl@0: 	paletteFile.read(paletteData,filesize);
sl@0: 	paletteFile.close();
sl@0: 
sl@0: 	char* dataPtr = (char*)paletteData;
sl@0: 	char* dataPtrLimit = dataPtr + filesize;
sl@0: 
sl@0: 	for (int index = 0; index < 256; index++)
sl@0: 		{
sl@0: 		char hexBuf[10];
sl@0: 		int ret = ReadHexString(hexBuf,dataPtr,dataPtrLimit);
sl@0: 		if (ret)
sl@0: 			{
sl@0: 			delete paletteData;
sl@0: 			return ret;
sl@0: 			}
sl@0: 
sl@0: 		int red = HexToInt(hexBuf[8],hexBuf[9]);
sl@0: 		int green = HexToInt(hexBuf[6],hexBuf[7]);
sl@0: 		int blue = HexToInt(hexBuf[4],hexBuf[5]);
sl@0: 
sl@0: 		iPalette[index] = TRgb(red,green,blue);
sl@0: 		}
sl@0: 
sl@0: 	delete paletteData;
sl@0: 	CalculateInversePalette();
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: void BitmapCompiler::CalculateInversePalette()
sl@0: 	{
sl@0: 	for (int index = 0; index < 4096; index++)
sl@0: 		{
sl@0: 		TRgb color = TRgb((index & 0x00f) * 17,((index & 0x0f0) >> 4) * 17,((index & 0xf00) >> 8) * 17);
sl@0: 
sl@0: 		int nearest = 0;
sl@0: 		int distance = iPalette[0].Difference(color);
sl@0: 
sl@0: 		for (int paletteIndex = 0; paletteIndex < 256; paletteIndex++)
sl@0: 			{
sl@0: 			TRgb paletteColor = iPalette[paletteIndex];
sl@0: 
sl@0: 			if (paletteColor == color)
sl@0: 				{
sl@0: 				nearest = paletteIndex;
sl@0: 				break;
sl@0: 				}
sl@0: 
sl@0: 			int paletteDistance = paletteColor.Difference(color);
sl@0: 			if (paletteDistance < distance)
sl@0: 				{
sl@0: 				nearest = paletteIndex;
sl@0: 				distance = paletteDistance;
sl@0: 				}
sl@0: 			}
sl@0: 
sl@0: 		iInversePalette[index] = (char)nearest;
sl@0: 		TRgb palColor = iPalette[nearest];
sl@0: 		color = palColor;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::CreateHeader(char* aHeaderFilename)
sl@0: 	{
sl@0: 	if (!aHeaderFilename)
sl@0: 		return NoError;
sl@0: 
sl@0: 	fstream hf(aHeaderFilename,ios::out);
sl@0: 	if(!hf.is_open())
sl@0: 		return DestFile;
sl@0: 
sl@0: 	char* basename = strrchr(aHeaderFilename,'\\');
sl@0: 	if (basename==0)
sl@0: 		basename = aHeaderFilename;
sl@0: 	else
sl@0: 		basename++;	// skip directory separator
sl@0: 
sl@0: 	char unadornedFile[256];
sl@0: 	strcpy(unadornedFile, UnadornedName(aHeaderFilename));
sl@0: 
sl@0: 	hf << "// " << basename << "\n";
sl@0: 	hf << "// Generated by BitmapCompiler\n";
sl@0: 	hf << "// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).\n";
sl@0: 	hf << "//\n\n";
sl@0: 	hf << "enum TMbm" << unadornedFile << "\n";
sl@0: 	hf << "\t{\n";
sl@0: 
sl@0: 	for (int count=0;count<iNumSources;count++)
sl@0: 		{
sl@0: 		hf << "\tEMbm" << unadornedFile << UnadornedName(iSourcefilenames[count]);
sl@0: 		if(count<iNumSources-1)
sl@0: 			hf << ',';
sl@0: 		hf << '\n';
sl@0: 		}
sl@0: 	hf << "\t};\n";
sl@0: 	hf.close();
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: char* BitmapCompiler::UnadornedName(char* aName)
sl@0: 	{
sl@0: 	int len = strlen(aName);
sl@0: 
sl@0: 	char* foundDir = strrchr(aName,'\\');
sl@0: 	char* foundUrl = strrchr(aName,'/');
sl@0: 	char* foundExt = strrchr(aName,'.');
sl@0: 
sl@0: 	char* foundPath = (foundDir > foundUrl) ? foundDir : foundUrl;
sl@0: 	char* firstchar = (foundPath > 0) ? foundPath + 1 : aName;
sl@0: 	char* lastchar = (foundExt > firstchar) ? foundExt : aName+len;
sl@0: 
sl@0: 	static char result[256];
sl@0: 	if (lastchar-firstchar > 255)
sl@0: 		{
sl@0: 		strcpy(result,"NameTooLong");
sl@0: 		return result;
sl@0: 		}
sl@0: 	int i=0;
sl@0: 	result[0] = (char)toupper(*firstchar);
sl@0: 	firstchar+=1;
sl@0: 	for (i=1; firstchar<lastchar; i++,firstchar++)
sl@0: 		{
sl@0: 		result[i] = (char)tolower(*firstchar);
sl@0: 		}
sl@0: 	result[i] = '\0';
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::CompressBitmap(SEpocBitmapHeader*& aPbm)
sl@0: 	{
sl@0: 	int originalsize = aPbm->iBitmapSize-sizeof(SEpocBitmapHeader);
sl@0: 	char* newbits=new char[originalsize+sizeof(SEpocBitmapHeader)];
sl@0: 	if(!newbits)
sl@0: 		return NoMemory;
sl@0: 
sl@0: 	memset(newbits,0xff,sizeof(SEpocBitmapHeader)+originalsize);
sl@0: 	memcpy(newbits,aPbm,sizeof(SEpocBitmapHeader));
sl@0: 	char* newbitsptr=newbits+sizeof(SEpocBitmapHeader);
sl@0: 	char* oldbits=((char*)(aPbm))+sizeof(SEpocBitmapHeader);
sl@0: 
sl@0: 	TBitmapfileCompression compression = ENoBitmapCompression;
sl@0: 	int ret = NoCompression;
sl@0: 
sl@0: 	if (aPbm->iBitsPerPixel <= 8)
sl@0: 		{
sl@0: 		compression = EByteRLECompression;
sl@0: 		ret = CompressByteData(newbitsptr,oldbits,originalsize);
sl@0: 		}
sl@0: 	else if (aPbm->iBitsPerPixel == 12)
sl@0: 		{
sl@0: 		compression = ETwelveBitRLECompression;
sl@0: 		ret = CompressTwelveBitData(newbitsptr,oldbits,originalsize);
sl@0: 		}
sl@0: 	else if (aPbm->iBitsPerPixel == 16)
sl@0: 		{
sl@0: 		compression = ESixteenBitRLECompression;
sl@0: 		ret = CompressSixteenBitData(newbitsptr,oldbits,originalsize);
sl@0: 		}
sl@0: 	else if (aPbm->iBitsPerPixel == 24)
sl@0: 		{
sl@0: 		compression = ETwentyFourBitRLECompression;
sl@0: 		ret = CompressTwentyFourBitData(newbitsptr,oldbits,originalsize);
sl@0: 		}
sl@0: 	else if (aPbm->iBitsPerPixel == 32 && (aPbm->iColor == EColorBitmap))
sl@0: 		{
sl@0: 		compression = EThirtyTwoUBitRLECompression;
sl@0: 		ret = CompressThirtyTwoUBitData(newbitsptr,oldbits,originalsize);
sl@0: 		}
sl@0: 	else if (aPbm->iBitsPerPixel == 32 && (aPbm->iColor == EColorBitmapAlpha))
sl@0: 		{
sl@0: 		compression = EThirtyTwoABitRLECompression;
sl@0: 		ret = CompressThirtyTwoABitData(newbitsptr,oldbits,originalsize);
sl@0: 		}
sl@0: 
sl@0: 	if(ret)
sl@0: 		{
sl@0: 		delete [] newbits;
sl@0: 		if(ret>0)
sl@0: 			return ret;
sl@0: 		return NoError;
sl@0: 		}
sl@0: 
sl@0: 	delete aPbm;
sl@0: 	aPbm = (SEpocBitmapHeader*)newbits;
sl@0: 	aPbm->iBitmapSize = newbitsptr-(newbits+sizeof(SEpocBitmapHeader))+sizeof(SEpocBitmapHeader);
sl@0: 	aPbm->iCompression = compression;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::CompressByteData(char*& aDest,char* aSrce,int aSize)
sl@0: 	{
sl@0: 	const char* destEnd = aDest + aSize;
sl@0: 	char* bytepointer=aSrce;
sl@0: 	char* limitpointer=bytepointer+aSize;
sl@0: 	int margin = (aSize>>6);
sl@0: 	char* limitmargin = limitpointer - ((margin > 4) ? margin : 4);
sl@0: 	char* cutoffpointer=aDest+(aSize>>1)+(aSize>>2);
sl@0: 	int ret=NoError;
sl@0: 	char* oldbytepointer=NULL;
sl@0: 	while(bytepointer<limitmargin)
sl@0: 		{
sl@0: 		char value=*bytepointer;
sl@0: 		if(*(bytepointer+1)==value && *(bytepointer+2)==value)
sl@0: 			{
sl@0: 			oldbytepointer=bytepointer;
sl@0: 			bytepointer+=3;
sl@0: 			while ( ( bytepointer < limitmargin ) && ( *bytepointer == value ) )
sl@0: 				bytepointer++;
sl@0: 			ret = WriteCompressedByteValues(aDest,value,bytepointer-oldbytepointer, destEnd);
sl@0: 			if(ret) return ret;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			oldbytepointer=bytepointer;
sl@0: 			while((bytepointer<limitmargin) && (*(bytepointer+1)!=value || *(bytepointer+2)!=value))
sl@0: 				{
sl@0: 				bytepointer++;
sl@0: 				value=*bytepointer;
sl@0: 				}
sl@0: 			ret = WriteCompressedByteData(aDest,oldbytepointer,bytepointer-oldbytepointer, destEnd);
sl@0: 			if(ret) return ret;
sl@0: 			}
sl@0: 		if(aDest>cutoffpointer)
sl@0: 			return NoCompression;
sl@0: 		}
sl@0: 
sl@0: 	int remaining = limitpointer-bytepointer;
sl@0: 	if(remaining > 0)
sl@0: 		{
sl@0: 		if (aDest + remaining > cutoffpointer)
sl@0: 			return NoCompression;
sl@0: 		ret=WriteCompressedByteData(aDest,bytepointer,remaining, destEnd);
sl@0: 		if(ret) return ret;
sl@0: 		}
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteCompressedByteData(char*& aDest,char* aData,int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if(!CanCopy8bppData(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 	while(aLength>128)
sl@0: 		{
sl@0: 		*aDest++=-128;
sl@0: 		for(int count=0;count<128;count++)
sl@0: 			*aDest++=*aData++;
sl@0: 		aLength-=128;
sl@0: 		}
sl@0: 	if(aLength>128 || aLength<1) return CompressionError;
sl@0: 	*aDest++=char(-aLength);
sl@0: 	for(int count=0;count<aLength;count++)
sl@0: 		*aDest++=*aData++;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteCompressedByteValues(char*& aDest,char aValue,int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanWrite8bppValue(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = 127;
sl@0: 		*aDest++ = aValue;
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(aLength-1);
sl@0: 	*aDest++ = aValue;
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::CompressTwelveBitData(char*& aDest,char* aSrce,int aSizeInBytes)
sl@0: 	{
sl@0: 	unsigned short* srcePtr = (unsigned short*)aSrce;
sl@0: 	unsigned short* srceLimitPtr = srcePtr + (aSizeInBytes / 2);
sl@0: 	unsigned short* dest = (unsigned short*)aDest;
sl@0: 
sl@0: 	while (srcePtr < srceLimitPtr)
sl@0: 		{
sl@0: 		unsigned short* runStartPtr = srcePtr;
sl@0: 		unsigned short value = *srcePtr;
sl@0: 		do
sl@0: 			srcePtr++;
sl@0: 		while (srcePtr < srceLimitPtr && *srcePtr == value);
sl@0: 		WriteCompressedTwelveBitData(dest,*runStartPtr,srcePtr - runStartPtr); // Ignore error return as 12bpp compression never fails
sl@0: 		}
sl@0: 
sl@0: 	aDest = (char*)dest;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteCompressedTwelveBitData(unsigned short*& aDest,unsigned short aData,int aLength)
sl@0: 	{
sl@0: 	// The run length l is stored as l-1 in the top 4 bits of each 16-bit word (between 1 and 16)
sl@0: 	aData &= 0x0fff;
sl@0: 	unsigned short maxLengthData = (unsigned short)(aData | 0xf000);
sl@0: 
sl@0: 	while(aLength>16)
sl@0: 		{
sl@0: 		*aDest++ = maxLengthData;
sl@0: 		aLength -= 16;
sl@0: 		}
sl@0: 
sl@0: 	if (aLength > 0)
sl@0: 		*aDest++ = (unsigned short)(aData | ((aLength - 1) << 12));
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::CompressSixteenBitData(char*& aDest,char* aSrce,int aSizeInBytes)
sl@0: 	{
sl@0: 	char* destEnd = aDest + aSizeInBytes;
sl@0: 	unsigned short* srcePtr = (unsigned short*)aSrce;
sl@0: 	unsigned short* srceLimitPtr = srcePtr + (aSizeInBytes / 2);
sl@0: 	unsigned short* srceLimitPtrMinusOne = srceLimitPtr - 1;
sl@0: 	char* destCompressedLimitPtr = aDest + (aSizeInBytes * 7 / 8);
sl@0: 	int ret = NoError;
sl@0: 
sl@0: 	while (srcePtr < srceLimitPtrMinusOne)
sl@0: 		{
sl@0: 		unsigned short value = *srcePtr;
sl@0: 		unsigned short* runStartPtr = srcePtr++;
sl@0: 
sl@0: 		if(*srcePtr == value)
sl@0: 			{
sl@0: 			do
sl@0: 				srcePtr++;
sl@0: 			while ( ( srcePtr < srceLimitPtr ) && ( *srcePtr == value ) );
sl@0: 
sl@0: 			ret = WriteCompressedSixteenBitValues(aDest,value,srcePtr-runStartPtr, destEnd);
sl@0: 			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			value = *srcePtr;
sl@0: 			while (srcePtr < srceLimitPtrMinusOne && *(srcePtr + 1) != value)
sl@0: 				{
sl@0: 				srcePtr++;
sl@0: 				value = *srcePtr;
sl@0: 				}
sl@0: 
sl@0: 			ret = WriteCompressedSixteenBitData(aDest,runStartPtr,srcePtr - runStartPtr, destEnd);
sl@0: 			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		if (aDest > destCompressedLimitPtr)
sl@0: 			return NoCompression;
sl@0: 		}
sl@0: 
sl@0: 	if (srcePtr < srceLimitPtr)
sl@0: 		{
sl@0: 		ret = WriteCompressedSixteenBitData(aDest,srcePtr,srceLimitPtr - srcePtr, destEnd);
sl@0: 		if (ret)
sl@0: 			return ret;
sl@0: 		}
sl@0: 
sl@0: 	if (aDest > destCompressedLimitPtr)
sl@0: 		return NoCompression;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteCompressedSixteenBitData(char*& aDest,unsigned short* aData,
sl@0: 												  int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanCopy16bppData(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 
sl@0: 	char* srcePtr = (char*)aData;
sl@0: 
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = -128;
sl@0: 		memcpy(aDest,srcePtr,256);
sl@0: 		aDest += 256;
sl@0: 		srcePtr += 256;
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(-aLength);
sl@0: 
sl@0: 	int remainingBytes = aLength * 2;
sl@0: 	memcpy(aDest,srcePtr,remainingBytes);
sl@0: 	aDest += remainingBytes;
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteCompressedSixteenBitValues(char*& aDest,unsigned short aValue,
sl@0: 													int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanWrite16bppValue(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 
sl@0: 	char lowByte = char(aValue);
sl@0: 	char highByte = char(aValue >> 8);
sl@0: 
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = 127;
sl@0: 		*aDest++ = lowByte;
sl@0: 		*aDest++ = highByte;
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(aLength-1);
sl@0: 	*aDest++ = lowByte;
sl@0: 	*aDest++ = highByte;
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::CompressTwentyFourBitData(char*& aDest,char* aSrce,int aSizeInBytes)
sl@0: 	{
sl@0: 	const char* destEnd = aDest + aSizeInBytes; 
sl@0: 	char* srceLimitPtr = aSrce + aSizeInBytes;
sl@0: 	char* srceLimitPtrMinusThree = srceLimitPtr - 3; // three bytes == one pixel
sl@0: 	char* destCompressedLimitPtr = aDest + (aSizeInBytes * 7 / 8);
sl@0: 	int ret = NoError;
sl@0: 
sl@0: 	while (aSrce < srceLimitPtrMinusThree)
sl@0: 		{
sl@0: 		char* runStartPtr = aSrce;
sl@0: 		char component1 = *aSrce++;
sl@0: 		char component2 = *aSrce++;
sl@0: 		char component3 = *aSrce++;
sl@0: 
sl@0: 		if (TrueColorPointerCompare(aSrce,component1,component2,component3))
sl@0: 			{
sl@0: 			do
sl@0: 				aSrce += 3;
sl@0: 			while (aSrce < srceLimitPtr && TrueColorPointerCompare(aSrce,component1,component2,component3));
sl@0: 
sl@0: 			ret = WriteCompressedTwentyFourBitValues(aDest,component1,component2,component3,(aSrce - runStartPtr) / 3, destEnd);
sl@0: 			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			bool more  = true;
sl@0: 			bool eqRun = false;
sl@0: 			do
sl@0: 				{
sl@0: 				component1 = *aSrce++;
sl@0: 				component2 = *aSrce++;
sl@0: 				component3 = *aSrce++;
sl@0: 				more = (aSrce < srceLimitPtr);
sl@0: 				eqRun = more && TrueColorPointerCompare(aSrce,component1,component2,component3);
sl@0: 				}
sl@0: 			while (more && !eqRun);
sl@0: 			if (eqRun)
sl@0: 				aSrce -= 3;
sl@0: 			int pixelLength = (aSrce - runStartPtr) / 3;
sl@0: 			ret = WriteCompressedTwentyFourBitData(aDest,runStartPtr,pixelLength,destEnd);
sl@0: 			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		if (aDest > destCompressedLimitPtr)
sl@0: 			return NoCompression;
sl@0: 		}
sl@0: 
sl@0: 	if (aSrce < srceLimitPtr)
sl@0: 		{
sl@0: 		ret = WriteCompressedTwentyFourBitData(aDest,aSrce,(srceLimitPtr - aSrce) / 3, destEnd);
sl@0: 		if (ret)
sl@0: 			return ret;
sl@0: 		}
sl@0: 
sl@0: 	if (aDest > destCompressedLimitPtr)
sl@0: 		return NoCompression;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteCompressedTwentyFourBitData(char*& aDest,char* aData,
sl@0: 													 int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanCopy24bppData(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = -128;
sl@0: 		memcpy(aDest,aData,384);
sl@0: 		aDest += 384;
sl@0: 		aData += 384;
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(-aLength);
sl@0: 
sl@0: 	int remainingBytes = aLength * 3;
sl@0: 	memcpy(aDest,aData,remainingBytes);
sl@0: 	aDest += remainingBytes;
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::WriteCompressedTwentyFourBitValues(char*& aDest,char aComponent1,
sl@0: 													   char aComponent2,char aComponent3,
sl@0: 													   int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanWrite24bppValue(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = 127;
sl@0: 		*aDest++ = aComponent1;
sl@0: 		*aDest++ = aComponent2;
sl@0: 		*aDest++ = aComponent3;
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(aLength-1);
sl@0: 	*aDest++ = aComponent1;
sl@0: 	*aDest++ = aComponent2;
sl@0: 	*aDest++ = aComponent3;
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: /** The function encodes 32-bit buffer into 24-bit stream by using RLE compression algorithm*/
sl@0: int BitmapCompiler::CompressThirtyTwoUBitData(char*& aDest,char* aSrce,int aSizeInBytes)
sl@0: 	{
sl@0: 	const char* destEnd = aDest + aSizeInBytes; 
sl@0: 	char* srceLimitPtr = aSrce + aSizeInBytes;
sl@0: 	char* srceLimitPtrMinusFour = srceLimitPtr - 4; // four bytes == one pixel
sl@0: 	char* destCompressedLimitPtr = aDest + (aSizeInBytes * 7 / 8);
sl@0: 	int ret = NoError;
sl@0: 
sl@0: 	while (aSrce < srceLimitPtrMinusFour)
sl@0: 		{
sl@0: 		char* runStartPtr = aSrce;
sl@0: 		char component1 = *aSrce++;
sl@0: 		char component2 = *aSrce++;
sl@0: 		char component3 = *aSrce++;
sl@0: 		aSrce++;
sl@0: 
sl@0: 		if (TrueColorPointerCompare(aSrce,component1,component2,component3))
sl@0: 			{
sl@0: 			do
sl@0: 				aSrce += 4;
sl@0: 			while (aSrce < srceLimitPtr && TrueColorPointerCompare(aSrce,component1,component2,component3));
sl@0: 
sl@0: 			ret = WriteCompressedThirtyTwoUBitValues(aDest,component1,component2,component3,(aSrce - runStartPtr) / 4, destEnd);
sl@0: 			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		else //non repeating pixel buffer
sl@0: 			{
sl@0: 			bool more  = true;
sl@0: 			bool eqRun = false;
sl@0: 			do {
sl@0: 				component1 = *aSrce++;
sl@0: 				component2 = *aSrce++;
sl@0: 				component3 = *aSrce++;
sl@0: 				aSrce++; //last byte is unused (no alpha component)
sl@0: 				more = (aSrce < srceLimitPtr);
sl@0: 				eqRun = more && TrueColorPointerCompare(aSrce,component1,component2,component3);
sl@0: 				} while (more && !eqRun);
sl@0: 			if (eqRun)
sl@0: 				aSrce -= 4;
sl@0: 			int pixelLength = (aSrce - runStartPtr) / 4;
sl@0: 			ret = WriteCompressedThirtyTwoUBitData(aDest,runStartPtr,pixelLength,destEnd);
sl@0:  			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		if (aDest > destCompressedLimitPtr)
sl@0: 			return NoCompression;
sl@0: 		}
sl@0: 
sl@0: 	if (aSrce < srceLimitPtr)
sl@0: 		{
sl@0: 		ret = WriteCompressedThirtyTwoUBitData(aDest,aSrce,(srceLimitPtr - aSrce) / 4, destEnd);
sl@0: 		if (ret)
sl@0: 			return ret;
sl@0: 		}
sl@0: 
sl@0: 	if (aDest > destCompressedLimitPtr)
sl@0: 		return NoCompression;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: /** The function copies non repeating 32-bit buffer to 24-bit compressed buffer*/
sl@0: int BitmapCompiler::WriteCompressedThirtyTwoUBitData(char*& aDest,char* aData,
sl@0: 													 int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanCopy24bppData(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = -128;
sl@0: 		for(int ii = 0; ii < 128; ii++)
sl@0: 			{
sl@0: 			memcpy(aDest,aData, 3);
sl@0: 			aDest += 3;
sl@0: 			aData += 4;
sl@0: 			}
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(-aLength);
sl@0: 
sl@0: 	while(aLength--)
sl@0: 		{
sl@0: 		memcpy(aDest,aData, 3);
sl@0: 		aDest += 3;
sl@0: 		aData += 4;
sl@0: 		}
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: /** The function copies repeating colour to the 24-bit compressed buffer */
sl@0: int BitmapCompiler::WriteCompressedThirtyTwoUBitValues(char*& aDest,char aComponent1,
sl@0: 													   char aComponent2,char aComponent3,
sl@0: 													   int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanWrite24bppValue(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = 127;
sl@0: 		*aDest++ = aComponent1;
sl@0: 		*aDest++ = aComponent2;
sl@0: 		*aDest++ = aComponent3;
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(aLength-1);
sl@0: 	*aDest++ = aComponent1;
sl@0: 	*aDest++ = aComponent2;
sl@0: 	*aDest++ = aComponent3;
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::TrueColorPointerCompare(char* aColorPointer,char aComponent1,char aComponent2,char aComponent3)
sl@0: 	{
sl@0: 	return (*aColorPointer == aComponent1 && *(aColorPointer + 1) == aComponent2 && *(aColorPointer + 2) == aComponent3);
sl@0: 	}
sl@0: 
sl@0: /** The function encodes 32-bit buffer into 32-bit stream by using RLE compression algorithm*/
sl@0: int BitmapCompiler::CompressThirtyTwoABitData(char*& aDest,char* aSrce,int aSizeInBytes)
sl@0: 	{
sl@0: 	const char* destEnd = aDest + aSizeInBytes; 
sl@0: 	char* srceLimitPtr = aSrce + aSizeInBytes;
sl@0: 	char* srceLimitPtrMinusFour = srceLimitPtr - 4; // four bytes == one pixel
sl@0: 	char* destCompressedLimitPtr = aDest + (aSizeInBytes * 7 / 8);
sl@0: 	int ret = NoError;
sl@0: 
sl@0: 	while (aSrce < srceLimitPtrMinusFour)
sl@0: 		{
sl@0: 		char* runStartPtr = aSrce;
sl@0: 		char component1 = *aSrce++;
sl@0: 		char component2 = *aSrce++;
sl@0: 		char component3 = *aSrce++;
sl@0: 		char component4 = *aSrce++;
sl@0: 
sl@0: 		if (ColorAlphaPointerCompare(aSrce,component1,component2,component3,component4))
sl@0: 			{
sl@0: 			do
sl@0: 				aSrce += 4;
sl@0: 			while (aSrce < srceLimitPtr && ColorAlphaPointerCompare(aSrce,component1,component2,component3,component4));
sl@0: 			int eqPixelLength = (aSrce - runStartPtr) / 4;
sl@0: 			ret = WriteCompressedThirtyTwoABitValues(aDest,component1,component2,component3,component4,eqPixelLength,destEnd);
sl@0: 			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		else //non repeating pixel buffer
sl@0: 			{
sl@0: 			bool more  = true;
sl@0: 			bool eqRun = false;
sl@0: 			do {
sl@0: 				component1 = *aSrce++;
sl@0: 				component2 = *aSrce++;
sl@0: 				component3 = *aSrce++;
sl@0: 				component4 = *aSrce++;
sl@0: 				more = (aSrce < srceLimitPtr);
sl@0: 				eqRun = more && ColorAlphaPointerCompare(aSrce,component1,component2,component3,component4);
sl@0: 				} while (more && !eqRun);
sl@0: 			if (eqRun)
sl@0: 				aSrce -= 4;
sl@0: 			int nePixelLength = (aSrce - runStartPtr) / 4;
sl@0: 			ret = WriteCompressedThirtyTwoABitData(aDest,runStartPtr,nePixelLength,destEnd);
sl@0: 			if (ret)
sl@0: 				return ret;
sl@0: 			}
sl@0: 		if (aDest > destCompressedLimitPtr)
sl@0: 			return NoCompression;
sl@0: 		}
sl@0: 
sl@0: 	if (aSrce < srceLimitPtr)
sl@0: 		{
sl@0: 		ret = WriteCompressedThirtyTwoABitData(aDest,aSrce,(srceLimitPtr - aSrce) / 4, destEnd);
sl@0: 		if (ret)
sl@0: 			return ret;
sl@0: 		}
sl@0: 
sl@0: 	if (aDest > destCompressedLimitPtr)
sl@0: 		return NoCompression;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: /** The function copies non repeating 32-bit buffer to 32-bit compressed buffer*/
sl@0: int BitmapCompiler::WriteCompressedThirtyTwoABitData(char*& aDest,char* aData,
sl@0: 													 int aLength, const char* aDestEnd)
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanCopy32bppData(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = -128;
sl@0: 		memcpy(aDest,aData,512);
sl@0: 		aDest += 512;
sl@0: 		aData += 512;
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(-aLength);
sl@0: 	memcpy(aDest,aData, aLength*4);
sl@0: 	aDest += aLength*4;
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: /** The function copies repeating pixels including alpha to a 32-bit compressed buffer */
sl@0: int BitmapCompiler::WriteCompressedThirtyTwoABitValues(char*& aDest,char aComponent1,
sl@0: 													   char aComponent2,char aComponent3,
sl@0: 													   char aComponent4,int aLength,
sl@0: 													   const char* aDestEnd)
sl@0: 
sl@0: 	{
sl@0: 	if (aLength < 1)
sl@0: 		return CompressionError;
sl@0: 
sl@0: 	if(!CanWrite32bppValue(aDest, aDestEnd, aLength))
sl@0: 		return NoCompression;
sl@0: 	while (aLength > 128)
sl@0: 		{
sl@0: 		*aDest++ = 127;
sl@0: 		*aDest++ = aComponent1;
sl@0: 		*aDest++ = aComponent2;
sl@0: 		*aDest++ = aComponent3;
sl@0: 		*aDest++ = aComponent4;
sl@0: 		aLength -= 128;
sl@0: 		}
sl@0: 
sl@0: 	*aDest++ = char(aLength-1);
sl@0: 	*aDest++ = aComponent1;
sl@0: 	*aDest++ = aComponent2;
sl@0: 	*aDest++ = aComponent3;
sl@0: 	*aDest++ = aComponent4;
sl@0: 
sl@0: 	return NoError;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::ColorAlphaPointerCompare(char* aColorPointer,char aComponent1,char aComponent2,char aComponent3,char aComponent4)
sl@0: 	{
sl@0: 	return (*aColorPointer == aComponent1 && *(aColorPointer + 1) == aComponent2 && *(aColorPointer + 2) == aComponent3 && *(aColorPointer + 3) == aComponent4);
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::ReadHexString(char aHexBuf[10],char*& aDataPtr,char* aDataPtrLimit)
sl@0: 	{
sl@0: 	while (aDataPtr < aDataPtrLimit)
sl@0: 		{
sl@0: 		if (aDataPtr[0] == '0')
sl@0: 			{
sl@0: 			if (aDataPtr[1] == 'x' || aDataPtr[1] == 'X')
sl@0: 				{
sl@0: 				memcpy(aHexBuf,aDataPtr,10);
sl@0: 				aDataPtr += 10;
sl@0: 				return NoError;
sl@0: 				}
sl@0: 			}
sl@0: 		aDataPtr++;
sl@0: 		}
sl@0: 
sl@0: 	return PaletteFile;
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::HexToInt(char aHighNibble,char aLowNibble)
sl@0: 	{
sl@0: 	return (HexToInt(aHighNibble) << 4) + HexToInt(aLowNibble);
sl@0: 	}
sl@0: 
sl@0: int BitmapCompiler::HexToInt(char aNibble)
sl@0: 	{
sl@0: 	int value = 0;
sl@0: 
sl@0: 	if (aNibble >= '0' && aNibble <= '9')
sl@0: 		value = aNibble - '0';
sl@0: 	else if (aNibble >= 'a' && aNibble <= 'f')
sl@0: 		value = aNibble - 'a' + 10;
sl@0: 	else if (aNibble >= 'A' && aNibble <= 'F')
sl@0: 		value = aNibble - 'A' + 10;
sl@0: 
sl@0: 	return value;
sl@0: 	}
sl@0: 
sl@0: void BitmapCompiler::CopyTail(void* aDst, void* aSrc, int aFullSize, int aSkipped)
sl@0: 	{
sl@0: 	memcpy(aDst, ((char*)aSrc)+aSkipped, aFullSize-aSkipped);
sl@0: 	}