--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfxconversion/bmconv_s60/group/bld.inf	Tue Feb 02 01:11:11 2010 +0200
@@ -0,0 +1,29 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+PRJ_PLATFORMS
+#ifdef SBSV2
+  TOOLS2
+#else
+  TOOLS
+#endif
+
+
+PRJ_MMPFILES
+#if defined (TOOLS) || defined(TOOLS2)
+  bmconv.mmp
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfxconversion/bmconv_s60/group/bmconv.mmp	Tue Feb 02 01:11:11 2010 +0200
@@ -0,0 +1,33 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <platform_paths.hrh>
+
+
+TARGET           bmconv.exe
+TARGETTYPE       exe
+
+
+SOURCEPATH       ../src
+SOURCE           MAINFUNC.CPP 
+SOURCE           BMTOPBM.CPP
+SOURCE           PBMCOMP.CPP
+SOURCE           PBMTOBM.CPP
+SOURCE           RGB.CPP
+SOURCE           UTILS.CPP
+
+MW_LAYER_SYSTEMINCLUDE

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfxconversion/bmconv_s60/src/BMCONV.H	Tue Feb 02 01:11:11 2010 +0200
@@ -0,0 +1,460 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#ifndef __BMCONV_H__
+#define __BMCONV_H__
+
+#include <string.h>
+#ifdef WIN32
+    #include <io.h>
+#else
+    #include <sys/io.h>
+#endif
+
+#if defined (__MSVCDOTNET__) || defined(__TOOLS2__) || defined(__CW32__)
+#include <fstream>
+#include <iostream>
+using namespace std;
+#else //!(__MSVCDOTNET__||__TOOLS2__||__CW32__)
+#include <fstream.h>
+#include <iostream.h>
+#endif //!(__MSVCDOTNET__||__TOOLS2__||__CW32__)
+
+#include <stdlib.h>
+
+#ifdef __linux__
+    #define GNUPACK __attribute__((packed)) 
+    #define OPTCHAR '-'
+    /* on Linux the '/' optchar cannot be supported as filenames can start with '/'. */
+    #define ALTERNATE_OPTCHAR '-'
+#else
+    #define GNUPACK
+    #define OPTCHAR '-' 
+    #define ALTERNATE_OPTCHAR '/'
+#endif
+
+
+/**
+@internalComponent
+*/
+const long int KWriteOnceFileStoreUid=268435511;
+const long int KCBitwiseBitmapUid=268435520;
+const long int KMultiBitmapRomImageUid=268435521;
+const long int KMultiBitmapFileImageUid=268435522;
+const long int KMultiBitmapFileImageChecksum=1194943545;
+/**
+@internalComponent
+*/
+enum TBitmapColor
+	{
+	EMonochromeBitmap,
+	EColorBitmap,
+	EColorBitmapAlpha,	
+	EColorBitmapUndefined	
+	};
+
+/** 
+Defines the types of file compression. 
+@internalComponent
+*/
+enum TBitmapfileCompression
+	{
+	/** Bitmap file is not compressed. */
+	ENoBitmapCompression=0,
+	/** File is compressed using run-length encoding compression. */
+	EByteRLECompression,
+	/** File is compressed using twelve bit run-length encoding compression. */
+	ETwelveBitRLECompression,
+	/** File is compressed using sixteen bit run-length encoding compression. */
+	ESixteenBitRLECompression,
+	/** File is compressed using twenty four bit run-length encoding compression. */
+	ETwentyFourBitRLECompression,
+	/** File is compressed using unsigned thirty two bit run-length encoding compression. */
+	EThirtyTwoUBitRLECompression,
+	/** File is compressed using unsigned thirty two bit run-length encoding compression and includes an alpha channel. */
+	EThirtyTwoABitRLECompression,
+	/** Insert new compression types here */
+	ERLECompressionLast = 255
+	};
+/**
+@internalComponent
+*/
+enum TStoreType
+	{
+	ENoStore,
+	EFileStore,
+	ERomStore,
+	ECompressedRomStore
+	};
+/**
+@internalComponent
+*/
+enum Errors
+	{
+	NoCompression=-1,
+	NoError=0,
+	NoMemory,
+	Arg,
+	Files,
+	SourceFile,
+	DestFile,
+	CommandFile,
+	OutOfRange,
+	TooManyArgs,
+	UnknownCompression,
+	CompressionError,
+	DecompressionError,
+	Bpp,
+	PaletteFile,
+	PaletteSupportNotImplemented,
+	AlphaFiles,
+	AlphaDimensions,
+	AlphaBpp
+	};
+/**
+@internalComponent
+*/
+struct SEpocBitmapHeader
+/** Contains information about the bitmap when streaming bitmaps to stores. */
+	{
+	/** The size of the bitmap data, in bytes. */
+	long iBitmapSize;
+	/** The size of the structure in which the bitmap data is stored. */
+	long iStructSize;
+	long iWidthInPixels;
+	long iHeightInPixels;
+	long iWidthInTwips;
+	long iHeightInTwips;
+	/** The bitmaps number of bits per pixel */
+	long iBitsPerPixel;
+	/** Whether or not the bitmap is colour. A true value means that the bitmap 
+	is colour. */
+	TBitmapColor iColor;
+	/** The number of entries in the bitmap's palette. */
+	long iPaletteEntries;	// always 0 in current implementations
+	/** The type of compression used to store the bitmap. */
+	TBitmapfileCompression iCompression;
+	};
+
+#ifndef __linux__ 
+#include <pshpack2.h>
+#endif 
+/**
+@internalComponent
+*/
+struct TRgb24bit
+	{
+	unsigned char iBlue;
+	unsigned char iGreen;
+	unsigned char iRed;
+	} GNUPACK;
+#ifndef __linux__ 
+#include <poppack.h>
+#endif 
+
+#ifndef __linux__ 
+#include <pshpack2.h>
+#endif 
+/**
+@internalComponent
+*/
+struct TBitmapFileHeader
+	{
+	unsigned short bfType;
+	unsigned long bfSize;
+	unsigned short bfReserved1;
+	unsigned short bfReserved2;
+	unsigned long bfOffBits;
+	} GNUPACK;
+#ifndef __linux__ 
+#include <poppack.h>
+#endif 
+/**
+@internalComponent
+*/
+struct TBitmapInfoHeader
+	{
+	unsigned long biSize;
+	long biWidth;
+	long biHeight;
+	unsigned short biPlanes;
+	unsigned short biBitCount;
+	unsigned long biCompression;
+	unsigned long biSizeImage;
+	long biXPelsPerMeter;
+	long biYPelsPerMeter;
+	unsigned long biClrUsed;
+	unsigned long biClrImportant;
+	};
+
+#ifndef __linux__ 
+#include <pshpack2.h>
+#endif 
+/**
+@internalComponent
+*/
+struct TRgbTriple
+	{
+	unsigned char rgbtBlue;
+	unsigned char rgbtGreen;
+	unsigned char rgbtRed;
+	} GNUPACK;
+#ifndef __linux__ 
+#include <poppack.h>
+#endif 
+/**
+@internalComponent
+*/
+struct TRgbQuad
+	{
+	unsigned char iBlue;
+	unsigned char iGreen;
+	unsigned char iRed;
+	unsigned char iReserved;
+	};
+
+class TRgb
+/** 
+24-bit RGB colour value with 8 bits each for red, green and blue.
+
+All Graphics drawing functions are specified in terms of a 32-bit TRgb colour 
+containing the three colour values plus 8 unused bits. For hardware which 
+does not support 24-bit colour, a mapping from TRgb to display colours is 
+performed. 
+
+The supported display modes are enumerated in the TDisplayMode type. In each 
+display mode a unique index can represent each physical colours supported, 
+and which can be mapped onto a full RGB value. The mappings are as follows: 
+
+16-colour displays use the EGA colour set: black, white, and then both light 
+and dark versions of grey, red, green, blue, cyan, magenta and yellow
+
+256-colour displays support 216 colours made up of 6x6x6 RGB values, each 
+containing all possible multiples of 51 for R,G,B values. Additionally, all 
+remaining 10 shades of pure red, green, blue and grey are represented, by 
+adding all remaining multiples of 17. This use of 256 colours is sometimes 
+known as the Netscape colour cube.
+
+4096-colour displays effectively support RGB values with 4 bits per primary 
+colour
+
+64k-colour displays effectively support RGB values with 5 bits allocated to 
+red, 6 to green and 5 to blue
+
+16 million-colour displays support true colour with 8 bits allocated to each 
+primary colour
+
+@see TDisplayMode
+@see DynamicPalette 
+@internalComponent
+*/
+	{
+public:
+	TRgb();
+	TRgb(long unsigned int val);
+	TRgb(int aRed,int aGreen,int aBlue);
+	TRgb &operator=(const TRgb& aColor);
+	int operator==(const TRgb& aColor);
+	int Difference(const TRgb& col) const;
+	int Gray2() const;
+	int Gray4() const;
+	int Gray16() const;
+	int Gray256() const;
+	int Color16() const;
+	int Color256() const;
+	int Color4K() const;
+	int Color64K() const;
+	long int Color16M() const;
+	static TRgb Gray2(int aGray2);
+	static TRgb Gray4(int aGray4);
+	static TRgb Gray16(int aGray16);
+	static TRgb Gray256(int aGray256);
+	static TRgb Color16(int aColor16);
+	static TRgb Color256(int aColor256);
+	static TRgb Color4K(int aColor64K);
+	static TRgb Color64K(int aColor64K);
+	static TRgb Color16M(long int aColor16M);
+public:
+	unsigned char iRed;
+	unsigned char iGreen;
+	unsigned char iBlue;
+	unsigned char iSpare;
+	};
+
+class Bitmap
+/**
+@internalComponent
+*/
+	{
+public:
+	int iUid;
+	int iDispMode;
+	void* iHeap;
+	void* iPile;
+	int iByteWidth;
+	SEpocBitmapHeader iHeader;
+	int iChunk;
+	int iDataOffset; // offset from "this"
+	};
+
+class TSourceFile
+	{
+public:
+	enum TCompileInfo
+		{
+		EFormatNotImportant,
+		ENokiaBitmap,
+		EThirdPartyBitmap
+		};
+public:
+	TSourceFile();
+	char*& FileName();
+	void SetCompileInfo(TCompileInfo aInfo);
+	void WriteCompileInfo(ostream& aOut);
+private:
+	char* iFileName;
+	TCompileInfo iInfo;
+	};
+
+class BitmapCompiler
+/**
+Historical note - Pbm is an abbreviation for "Symbian Bitmap"
+@internalComponent
+*/
+	{
+public:
+	BitmapCompiler(TSourceFile* aSourcefilenames,int aNumSources);
+	~BitmapCompiler();
+	int Compile(TStoreType aSt,int aCompress,char* aDestfilename,char* aHeaderFilename,char* aPaletteFilename);
+private:
+	int AllocatePbmSourcesArray();
+	int LoadSourcefiles();
+	int LoadPbmFile(char* aPbmFilename);
+	int RomImage(bool aCompress);
+	int FileImage(int aCompress);
+	int WriteRomheader();
+	int WriteRombitmap(SEpocBitmapHeader* aPbm);
+	int WriteFileheader();
+	int WriteFilebitmap(SEpocBitmapHeader* aPbm);
+	int WriteHeadStream();
+	int CreateHeader(char* aHeaderFilename);
+	char* UnadornedName(char* aName);	// returns pointer to static buffer
+	int LoadPalette(char* aPaletteFilename);
+	void CalculateInversePalette();
+	void WritePalette();
+	int CompressBitmap(SEpocBitmapHeader*& aPbm);
+	int CompressByteData(char*& aDest,char* aSrce,int aSize);
+	int WriteCompressedByteData(char*& aDest,char* aData,int aLength, const char* aDestEnd);
+	int WriteCompressedByteValues(char*& aDest,char aValue,int aLength, const char* aDestEnd);
+	int CompressTwelveBitData(char*& aDest,char* aSrce,int aSizeInBytes);
+	int WriteCompressedTwelveBitData(unsigned short*& aDest,unsigned short aData,int aLength);
+	int CompressSixteenBitData(char*& aDest,char* aSrce,int aSize);
+	int WriteCompressedSixteenBitData(char*& aDest,unsigned short* aData,int aLength, const char* aDestEnd);
+	int WriteCompressedSixteenBitValues(char*& aDest,unsigned short aValue,int aLength, const char* aDestEnd);
+	int CompressTwentyFourBitData(char*& aDest,char* aSrce,int aSizeInBytes);
+	int WriteCompressedTwentyFourBitData(char*& aDest,char* aData,int aLength, const char* aDestEnd);
+	int WriteCompressedTwentyFourBitValues(char*& aDest,char aComponent1,char aComponent2,char aComponent3,int aLength, const char* aDestEnd);
+	int CompressThirtyTwoUBitData(char*& aDest,char* aSrce,int aSizeInBytes);
+	int WriteCompressedThirtyTwoUBitData(char*& aDest,char* aData, int aLength, const char* aDestEnd);
+	int WriteCompressedThirtyTwoUBitValues(char*& aDest,char aComponent1, char aComponent2,char aComponent3, int aLength, const char* aDestEnd);
+	int TrueColorPointerCompare(char* aColorPointer,char aComponent1,char aComponent2,char aComponent3);
+	int CompressThirtyTwoABitData(char*& aDest,char* aSrce,int aSizeInBytes);
+	int WriteCompressedThirtyTwoABitData(char*& aDest,char* aData,int aLength,const char* aDestEnd);
+	int WriteCompressedThirtyTwoABitValues(char*& aDest,char aComponent1,char aComponent2,char aComponent3,char aComponent4,int aLength,const char* aDestEnd);
+	int ColorAlphaPointerCompare(char* aColorPointer,char aComponent1,char aComponent2,char aComponent3,char aComponent4);
+	int ReadHexString(char aHexBuf[10],char*& aDataPtr,char* aDataPtrLimit);
+	int HexToInt(char aHighNibble,char aLowNibble);
+	int HexToInt(char aNibble);
+	static void CopyTail(void* aDst, void* aSrc, int aFullSize, int aSkipped);
+private:
+	fstream iDestFile;
+	TSourceFile* iSourcefilenames;
+	SEpocBitmapHeader** iPbmSources;
+	int iNumSources;
+	int iDefaultPalette;
+	TRgb iPalette[256];
+	char iInversePalette[4096];
+	};
+
+class BitmapLoader
+/**
+@internalComponent
+*/
+	{
+public:
+	BitmapLoader();
+	~BitmapLoader();
+	int LoadBitmap(TSourceFile& aFileName,int aBpp,TBitmapColor aColor,SEpocBitmapHeader*& aPbm);
+private:
+	int DoLoad(char* aFileName);
+	int DoLoadAlpha(char* aAlphaFileName);
+	int DoConvert(int aBpp,TBitmapColor aColor,SEpocBitmapHeader*& aPbm);
+	TRgb GetBmpPixel(long aXCoord,long aYCoord);
+	unsigned char GetAlphaPixel(long aXCoord,long aYCoord);
+private:
+	TSourceFile* iSourceFile;
+	TBitmapInfoHeader iBmpHeader;
+	int iNumBmpColors;
+	TRgbQuad* iBmpColors;
+	char* iBmpBits;
+	char* iAlphaBits;
+	};
+
+class EpocLoader
+/**
+@internalComponent
+*/
+	{
+public:
+	EpocLoader();
+	~EpocLoader();
+	int EpocBitmapCount(char* aFilename,int& aCount,int& isRomFormat);
+	int LoadEpocBitmap(char* aFilename,int aIndex);
+	int SaveBitmap(char* aFilename);
+	int SaveAlpha(char* aFilename);
+	int DupBitmap(SEpocBitmapHeader*& aPbm);
+	SEpocBitmapHeader Header() const { return iOriginalPbmHeader;}
+private:
+	int LoadFile(char* aFilename,int aIndex);
+	int LoadRom(char* aFilename,int aIndex);
+	TRgb GetPixel(int aXCoord,int aYCoord);
+	unsigned char GetAlpha(int aXCoord,int aYCoord);
+	int DoLoadFile(fstream& aFile);
+	int DoLoadRom(fstream& aFile);
+	int ExpandByteRLEData(char* aDest,int aDestSize,char* aSrce,int aSrceSize);
+	int ExpandTwelveBitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes);
+	int ExpandSixteenBitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes);
+	int ExpandTwentyFourBitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes);
+	int ExpandThirtyTwoUBitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes);
+	int ExpandThirtyTwoABitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes);
+	int Decompress(int aSize);
+private:
+	SEpocBitmapHeader iOriginalPbmHeader;
+	SEpocBitmapHeader iPbmHeader;
+	char* iPbmBits;
+	};
+
+class BitmapUtils
+/**
+@internalComponent
+*/
+	{
+public:
+	static int ByteWidth(int aPixelWidth,int aBitsPerPixel);
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfxconversion/bmconv_s60/src/BMTOPBM.CPP	Tue Feb 02 01:11:11 2010 +0200
@@ -0,0 +1,499 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include "BMCONV.H"
+
+const TRgbQuad KNokiaBrandBlue = {0xcc,0x33,0,0};
+const TRgbQuad KNokiaBrandGreen = {0x33,0x99,0,0};
+const int KNokiaBrandBlueIndex = 254;
+const int KNokiaBrandGreenIndex = 253;
+
+const unsigned char ColorRemapTable[256] = 
+	{
+	0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0x00, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xd7
+	};
+
+BitmapLoader::BitmapLoader():
+	iNumBmpColors(0),
+	iBmpColors(NULL),
+	iBmpBits(NULL),
+	iAlphaBits(NULL)
+	{}
+
+BitmapLoader::~BitmapLoader()
+	{
+	delete [] iBmpColors;
+	delete [] iBmpBits;
+	delete [] iAlphaBits;
+	}
+
+int BitmapLoader::LoadBitmap(TSourceFile& aFileName,int aBpp,TBitmapColor aColor,SEpocBitmapHeader*& aPbm)
+	{
+	iSourceFile = &aFileName;
+	char sig[2];
+#if defined(__MSVCDOTNET__) || defined(__LINUX__) || defined(__TOOLS2__) || defined(__CW32__)
+	fstream file(aFileName.FileName(), ios::in | ios::binary);
+#else	
+	fstream file(aFileName.FileName(), ios::in | ios::binary | ios::nocreate);	
+#endif		
+
+	if (file.is_open()==0)
+		return Files;
+	file.read(sig,2);
+	file.close();
+	if (file.gcount()!=2)
+		return SourceFile ;
+	if (sig[0]!='B'||sig[1]!='M')
+		return SourceFile;
+
+	int ret = DoLoad(aFileName.FileName());
+
+    // Iff we have >8bit color BMP file and c8, change to c16
+    if( (aColor==EColorBitmap) && (aBpp==8) && 
+        (iBmpHeader.biBitCount>8) )
+        {
+        // cout << "Note: " << aFileName.FileName() << " changed c8 -> c16" << "\n";
+        aBpp = 16;
+        }
+	if (!ret && aColor==EColorBitmapAlpha)
+		{
+		int fileNameLen = strlen(aFileName.FileName());
+		char* alphaFileName = new char[fileNameLen + 7];// -alpha suffix is 6 chars, plus NUL termination
+		if (alphaFileName == NULL)
+			return NoMemory;
+		int dotPos = -1;
+		for (int i = 0; i < fileNameLen; ++i)
+			if (aFileName.FileName()[i]=='.')
+				dotPos=i;
+		int prefixLen = (dotPos>=0?dotPos:fileNameLen);
+		memcpy(alphaFileName,aFileName.FileName(),prefixLen);
+		const char* suffix = "-alpha";
+		memcpy(alphaFileName+prefixLen,suffix,6);
+		if (dotPos>=0)
+			memcpy(alphaFileName+prefixLen+6,aFileName.FileName()+dotPos,fileNameLen-dotPos);
+		*(alphaFileName + fileNameLen + 6) = '\0';
+		ret = DoLoadAlpha(alphaFileName); // overlay alpha data from separate file
+		delete [] alphaFileName;
+		}
+	if (!ret)
+		ret = DoConvert(aBpp,aColor,aPbm);
+	return ret;
+	}
+
+int BitmapLoader::DoLoad(char* aFileName)
+	{
+#if defined (__MSVCDOTNET__)  || defined(__TOOLS2__) || defined(__CW32__)    	
+	fstream file(aFileName, ios::in | ios::binary);
+#else //!__MSVCDOTNET__
+	fstream file(aFileName, ios::in | ios::binary | ios::nocreate);
+#endif //__MSVCDOTNET__
+	if (file.is_open()==0)
+		return Files;
+	TBitmapFileHeader bmpfile;
+	long size=sizeof(TBitmapFileHeader);
+	file.read((char *)&bmpfile,size);
+	if (file.gcount()!=size)
+		return SourceFile;
+	size=sizeof(TBitmapInfoHeader);
+	file.read((char *)&iBmpHeader,size);
+	if (file.gcount()!=size)
+		return SourceFile;
+	if (iBmpHeader.biCompression != 0)
+		return UnknownCompression;
+	size=bmpfile.bfSize-sizeof(TBitmapInfoHeader)-sizeof(TBitmapFileHeader);
+	long bitcount=iBmpHeader.biBitCount;
+	long colors=iBmpHeader.biClrUsed;
+	if (colors==0)
+		{
+		if (bitcount==24)
+			iNumBmpColors=0;
+		else if (bitcount==32)
+			iNumBmpColors=0;//See MSDN - BITMAPFILEHEADER and BITMAPINFOHEADER structures.
+                            //If biCompression is 0 - we don't have TRgbQuad array! 
+		else
+			iNumBmpColors=1<<bitcount;
+		}
+	else
+		iNumBmpColors=colors;
+	if (iNumBmpColors > 256)
+		return SourceFile;
+	if (iNumBmpColors>0)
+		{
+		iBmpColors = new TRgbQuad[iNumBmpColors];
+		if (iBmpColors == NULL)
+			return NoMemory;
+		memset(iBmpColors,0,iNumBmpColors*sizeof(TRgbQuad));
+		}
+	size-=iNumBmpColors*sizeof(TRgbQuad);
+	iBmpBits = new char[size];
+	if (iBmpBits == NULL)
+		return NoMemory;
+	memset(iBmpBits,0xff,size);
+
+	if(iBmpColors != NULL)
+	    {
+		file.read((char *)iBmpColors,iNumBmpColors*sizeof(TRgbQuad));
+		if (file.gcount()!=(int)(iNumBmpColors*sizeof(TRgbQuad)))
+			return SourceFile;
+	    }
+	file.read(iBmpBits,size);
+	file.close();
+	if (file.gcount()!=size)
+		return SourceFile;
+	return NoError;
+	}
+
+int BitmapLoader::DoLoadAlpha(char* aAlphaFileName)
+	{
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
+	fstream file(aAlphaFileName, ios::in | ios::binary);
+#else //!__MSVCDOTNET__
+	fstream file(aAlphaFileName, ios::in | ios::binary | ios::nocreate);
+#endif //__MSVCDOTNET__
+	if (file.is_open()==0)
+		return AlphaFiles;
+	TBitmapFileHeader alphaBmpfile;
+	long size=sizeof(TBitmapFileHeader);
+	file.read((char *)&alphaBmpfile,size);
+	if (file.gcount()!=size)
+		return SourceFile;
+	size=sizeof(TBitmapInfoHeader);
+	TBitmapInfoHeader alphaBmpInfo;
+	file.read((char *)&alphaBmpInfo,size);
+	if (file.gcount()!=size)
+		return SourceFile;
+	if (alphaBmpInfo.biCompression != 0)
+		return UnknownCompression;
+	if (alphaBmpInfo.biWidth != iBmpHeader.biWidth || alphaBmpInfo.biHeight != iBmpHeader.biHeight)
+		return AlphaDimensions;
+	if (alphaBmpInfo.biBitCount != 8)
+		return AlphaBpp;
+	size=alphaBmpfile.bfSize-sizeof(TBitmapInfoHeader)-sizeof(TBitmapFileHeader);
+	long numBmpColors=alphaBmpInfo.biClrUsed;
+	if (numBmpColors == 0)
+		numBmpColors = 256;
+	if (numBmpColors != 256)
+		return SourceFile;
+	size-=numBmpColors*sizeof(TRgbQuad);
+	iAlphaBits = new char[size];
+	if (iAlphaBits == NULL)
+		{
+		return NoMemory;
+		}
+	memset(iAlphaBits,0xff,size);
+	char* bmpColors = new char[numBmpColors*sizeof(TRgbQuad)];
+	file.read((char *)bmpColors,numBmpColors*sizeof(TRgbQuad));
+	delete [] bmpColors; // we aren't interested in the palette data for the 8bpp grayscale alpha bmp
+	if (file.gcount()!=(int)(numBmpColors*sizeof(TRgbQuad)))
+		return SourceFile;
+	file.read(iAlphaBits,size);
+	file.close();
+	if (file.gcount()!=size)
+		return SourceFile;
+	return NoError;
+	}
+
+TRgb BitmapLoader::GetBmpPixel(long aXCoord,long aYCoord)
+	{
+	TRgb darkgray(128,128,128);
+	TRgb darkgrayex(127,127,127);
+	TRgb lightgray(192,192,192);
+	TRgb lightgrayex(187,187,187);
+	unsigned char col;
+	TRgb color;
+
+	switch(iBmpHeader.biBitCount)
+		{
+		case 1:
+			col=iBmpBits[(iBmpHeader.biHeight-aYCoord-1)*(((iBmpHeader.biWidth+31)>>5)<<2)+(aXCoord>>3)];
+			col&=(0x80>>(aXCoord%8));
+			if (iBmpColors)
+				{
+				TRgbQuad rgbq;
+				if (col)
+					rgbq = iBmpColors[1];
+				else
+					rgbq = iBmpColors[0];
+				color = TRgb(rgbq.iRed,rgbq.iGreen,rgbq.iBlue);
+				}
+			else
+				{
+				if (col)
+					color = TRgb(0x00ffffff);
+				else
+					color = TRgb(0);
+				}
+			break;
+		case 4:
+			col=iBmpBits[(iBmpHeader.biHeight-aYCoord-1)*(((iBmpHeader.biWidth+7)>>3)<<2)+(aXCoord>>1)];
+			if (aXCoord%2==0)
+				col=(unsigned char)(col>>4);
+			col&=0x0f;
+			if (iBmpColors)
+				{
+				TRgbQuad rgbq = iBmpColors[col];
+				color = TRgb(rgbq.iRed,rgbq.iGreen,rgbq.iBlue);
+				}
+			else
+				{
+				col *= 17;
+				color = TRgb(col,col,col);
+				}
+			break;
+		case 8:
+			col=iBmpBits[(iBmpHeader.biHeight-aYCoord-1)*((iBmpHeader.biWidth+3)&~3)+aXCoord];
+			if (iBmpColors)
+				{
+				TRgbQuad rgbq = iBmpColors[col];
+				color = TRgb(rgbq.iRed,rgbq.iGreen,rgbq.iBlue);
+				}
+			else
+				color = TRgb(col,col,col);
+			break;
+		case 16:
+			{
+			unsigned short int* wordptr = (unsigned short int*)&iBmpBits[(iBmpHeader.biHeight-aYCoord-1)*(((iBmpHeader.biWidth+1)&~1)<<1)+(aXCoord<<1)];
+			color = TRgb((*wordptr&0x7c)>>10,(*wordptr&0x3e)>>5,(*wordptr&0x1f));
+			}
+			break;
+		case 24:
+			{
+			TRgbTriple rgbcol = *((TRgbTriple *)&(iBmpBits[(iBmpHeader.biHeight-aYCoord-1)*((3*iBmpHeader.biWidth+3)&~3)+aXCoord+(aXCoord<<1)]));
+			color = TRgb(rgbcol.rgbtRed,rgbcol.rgbtGreen,rgbcol.rgbtBlue);
+			}
+			break;
+		case 32:
+			{
+			unsigned long int* dwordptr = (unsigned long int*)&iBmpBits[(iBmpHeader.biHeight-aYCoord-1)*((iBmpHeader.biWidth)<<2)+(aXCoord<<2)];
+			color = TRgb((*dwordptr&0xff0000)>>16,(*dwordptr&0xff00)>>8,*dwordptr&0xff);
+			}
+			break;
+		default:
+			break;
+		}
+	if (color == darkgray)
+		color = darkgrayex;
+	else if (color == lightgray)
+		color = lightgrayex;
+	return color;
+	}
+
+unsigned char BitmapLoader::GetAlphaPixel(long aXCoord,long aYCoord)
+	{
+	return iAlphaBits[(iBmpHeader.biHeight-aYCoord-1)*((iBmpHeader.biWidth+3)&~3)+aXCoord];
+	}
+
+int BitmapLoader::DoConvert(int aBpp,TBitmapColor aColor,SEpocBitmapHeader*& aPbm)
+	{
+	bool useAlpha = (aColor==EColorBitmapAlpha);
+	long desttwipswidth = 0;
+	long desttwipsheight = 0;
+
+	long bytewidth = BitmapUtils::ByteWidth(iBmpHeader.biWidth,aBpp);
+	long destlength = iBmpHeader.biHeight * bytewidth;
+
+	if (iBmpHeader.biXPelsPerMeter>0)
+		desttwipswidth = iBmpHeader.biWidth*1440000/254/iBmpHeader.biXPelsPerMeter;
+	if (iBmpHeader.biYPelsPerMeter>0)
+		desttwipsheight = iBmpHeader.biHeight*1440000/254/iBmpHeader.biYPelsPerMeter;
+
+	aPbm = (SEpocBitmapHeader*)new char[sizeof(SEpocBitmapHeader) + destlength];
+	if (aPbm == NULL)
+		return NoMemory;
+	memset(aPbm,0,sizeof(SEpocBitmapHeader));
+
+	// aBitmap->iByteWidth = bytewidth;
+	// aBitmap->iDataOffset = sizeof(Bitmap);
+
+	aPbm->iBitmapSize = sizeof(SEpocBitmapHeader) + destlength;
+	aPbm->iStructSize = sizeof(SEpocBitmapHeader);
+	aPbm->iWidthInPixels = iBmpHeader.biWidth;
+	aPbm->iHeightInPixels = iBmpHeader.biHeight;
+	aPbm->iWidthInTwips = desttwipswidth;
+	aPbm->iHeightInTwips = desttwipsheight;
+	aPbm->iBitsPerPixel = aBpp;
+	aPbm->iColor = aColor;
+	aPbm->iPaletteEntries = 0;
+	aPbm->iCompression = ENoBitmapCompression;
+
+	char* pbmBits = ((char*)aPbm) + sizeof(SEpocBitmapHeader);
+	memset(pbmBits,0xff,destlength);
+
+	long col = 0;
+	char* pixadd = 0;
+	bool indicesOnly = false;
+	if (aColor == EColorBitmap && aBpp == 8)
+		{
+		indicesOnly =
+			(iNumBmpColors==256 &&
+			 iBmpColors[KNokiaBrandGreenIndex].iRed == KNokiaBrandGreen.iRed &&
+			 iBmpColors[KNokiaBrandGreenIndex].iBlue == KNokiaBrandGreen.iBlue &&
+			 iBmpColors[KNokiaBrandGreenIndex].iGreen == KNokiaBrandGreen.iGreen &&
+			 iBmpColors[KNokiaBrandBlueIndex].iRed == KNokiaBrandBlue.iRed &&
+			 iBmpColors[KNokiaBrandBlueIndex].iBlue == KNokiaBrandBlue.iBlue &&
+			 iBmpColors[KNokiaBrandBlueIndex].iGreen == KNokiaBrandBlue.iGreen);
+		}
+
+	switch(aBpp)
+		{
+	case 1:
+		{
+		for(long ycrd=0;ycrd<iBmpHeader.biHeight;ycrd++)
+			for(long xcrd=0;xcrd<iBmpHeader.biWidth;xcrd++)
+				{
+				TRgb color=GetBmpPixel(xcrd,ycrd);
+				col=color.Gray2();
+				pixadd=&(pbmBits[ycrd*bytewidth+(xcrd>>3)]);
+				(*pixadd)&=~(1<<((xcrd&7)));
+				(*pixadd)|=(unsigned char)(col<<(xcrd&7));
+				}
+		}
+		break;
+	case 2:
+		{
+		for(long ycrd=0;ycrd<iBmpHeader.biHeight;ycrd++)
+			for(long xcrd=0;xcrd<iBmpHeader.biWidth;xcrd++)
+				{
+				TRgb color=GetBmpPixel(xcrd,ycrd);
+				col=color.Gray4();
+				pixadd=&(pbmBits[ycrd*bytewidth+(xcrd>>2)]);
+				(*pixadd)&=~(0x3<<(2*(xcrd%4)));
+				(*pixadd)|=(unsigned char)(col<<(2*(xcrd%4)));
+				}
+		}
+		break;
+	case 4:
+		{
+		for(long ycrd=0;ycrd<iBmpHeader.biHeight;ycrd++)
+			for(long xcrd=0;xcrd<iBmpHeader.biWidth;xcrd++)
+				{
+				TRgb color=GetBmpPixel(xcrd,ycrd);
+				if (aColor == EMonochromeBitmap)
+					col = color.Gray16();
+				else
+					col = color.Color16();
+				pixadd=&(pbmBits[ycrd*bytewidth+(xcrd>>1)]);
+				if (xcrd%2!=0)
+					*pixadd=(unsigned char)((unsigned char)((col<<4)|(*pixadd&0x0f)));
+				else
+					*pixadd=(unsigned char)((unsigned char)(col|(*pixadd&0xf0)));
+				}
+		}
+		break;
+	case 8:
+		{
+		for(long ycrd=0;ycrd<iBmpHeader.biHeight;ycrd++)
+			for(long xcrd=0;xcrd<iBmpHeader.biWidth;xcrd++)
+				{
+				if (indicesOnly)
+					{
+					unsigned char pixel = iBmpBits[(iBmpHeader.biHeight-ycrd-1)*((iBmpHeader.biWidth+3)&~3)+xcrd];
+					col = ColorRemapTable[pixel];
+					iSourceFile->SetCompileInfo(TSourceFile::ENokiaBitmap);
+					}
+				else
+					{
+					TRgb color=GetBmpPixel(xcrd,ycrd);
+					if (aColor == EMonochromeBitmap)
+						col = color.Gray256();
+					else
+						col = color.Color256();
+					iSourceFile->SetCompileInfo(TSourceFile::EThirdPartyBitmap);
+					}
+				pixadd=&(pbmBits[ycrd*((iBmpHeader.biWidth+3)&~3)+xcrd]);
+				*pixadd=(unsigned char)col;
+				}
+		}
+		break;
+	case 12:
+		{
+		for(long ycrd=0;ycrd<iBmpHeader.biHeight;ycrd++)
+			for(long xcrd=0;xcrd<iBmpHeader.biWidth;xcrd++)
+				{
+				TRgb color=GetBmpPixel(xcrd,ycrd);
+				col=color.Color4K();
+				pixadd=&(pbmBits[ycrd*bytewidth+(xcrd<<1)]);
+				unsigned short* wordadd=(unsigned short*)pixadd;
+				*wordadd=(unsigned short)col;
+				}
+		}
+		break;
+	case 16:
+		{
+		for(long ycrd=0;ycrd<iBmpHeader.biHeight;ycrd++)
+			for(long xcrd=0;xcrd<iBmpHeader.biWidth;xcrd++)
+				{
+				TRgb color=GetBmpPixel(xcrd,ycrd);
+				col=color.Color64K();
+				pixadd=&(pbmBits[ycrd*bytewidth+(xcrd<<1)]);
+				unsigned short* wordadd=(unsigned short*)pixadd;
+				*wordadd=(unsigned short)col;
+				}
+		}
+		break;
+	case 24:
+		{
+		for(long ycrd=0;ycrd<iBmpHeader.biHeight;ycrd++)
+			{
+			unsigned char* bytePtr = (unsigned char*)&pbmBits[ycrd*bytewidth];
+			for(long xcrd=0;xcrd<iBmpHeader.biWidth;xcrd++)
+				{
+				TRgb col = GetBmpPixel(xcrd,ycrd);
+				*bytePtr++ = (unsigned char) col.iBlue;
+				*bytePtr++ = (unsigned char) col.iGreen;
+				*bytePtr++ = (unsigned char) col.iRed;
+				}
+			}
+		}
+		break;
+	case 32:
+		{
+		for(long ycrd=0;ycrd<iBmpHeader.biHeight;ycrd++)
+			{
+			unsigned char* bytePtr = (unsigned char*)&pbmBits[ycrd*bytewidth];
+			for(long xcrd=0;xcrd<iBmpHeader.biWidth;xcrd++)
+				{
+				TRgb col = GetBmpPixel(xcrd,ycrd);
+				unsigned char alpha = useAlpha?GetAlphaPixel(xcrd,ycrd):(unsigned char)0;
+				*bytePtr++ = (unsigned char) col.iBlue;
+				*bytePtr++ = (unsigned char) col.iGreen;
+				*bytePtr++ = (unsigned char) col.iRed;
+				*bytePtr++ = alpha;	
+				}
+			}
+		}
+		break;
+		};
+
+	return NoError;
+	}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfxconversion/bmconv_s60/src/MAINFUNC.CPP	Tue Feb 02 01:11:11 2010 +0200
@@ -0,0 +1,652 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__) || defined(__CW32__)
+#include <ostream>
+#include <iostream>
+using namespace std;
+#else //!__MSVCDOTNET__ && !__TOOLS2__ && !__CW32__
+#pragma warning(disable: 4100)
+#pragma warning(disable: 4511)
+#pragma warning(disable: 4512)
+#pragma warning(disable: 4530)
+#pragma warning(disable: 4663)
+#pragma warning(disable: 4710)
+#pragma warning(disable: 4786)
+#pragma warning(disable: 4800)
+#include <ostream.h>
+#endif //__MSVCDOTNET__
+
+#include "TOOLSVER.H"
+#include "BMCONV.H"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <string>
+
+const int KMaxPaletteFileLen = 256;
+
+#ifdef __linux__
+const char* DefaultPaletteFileSearchLocations[] =
+{
+    "/epoc32/include/mw/ThirdPartyBitmap.pal",
+    "/epoc32/include/middleware/ThirdPartyBitmap.pal",
+    "/epoc32/include/ThirdPartyBitmap.pal"
+};
+#else
+const char* DefaultPaletteFileSearchLocations[] =
+{
+    "\\epoc32\\include\\mw\\ThirdPartyBitmap.pal",
+    "\\epoc32\\include\\middleware\\ThirdPartyBitmap.pal",
+    "\\epoc32\\include\\ThirdPartyBitmap.pal"
+};
+#endif
+
+/**
+Returns an informative error message, the result of the program actions performed.
+@return Informative error string
+@param aErrorNumber The error returned from the actions performed
+@param aDestfile The multiple bitmap store file name
+@param aDestCreated True if the multiple bitmap store has been created/modified
+*/
+
+char* ErrorMessage(int aErrorNumber, char* aDestfile=NULL, bool aDestCreated=false)
+	{
+	// Remove the multiple bitmap store if it has been created/modified during an fstream session and there has been an error
+	if(aDestfile && (aErrorNumber != NoError) && (aDestCreated == true))
+		{
+		remove(aDestfile);
+		}
+
+	switch(aErrorNumber)
+		{
+		case NoError:
+			return "Success.";
+		case NoMemory:
+			return "Out of memory.";
+		case Arg:
+			return "Bad argument.";
+		case Files:
+			return "File does not exist";
+		case SourceFile:
+			return "Bad source file(s).";
+		case DestFile:
+			return "Bad destination file(s).";
+		case CommandFile:
+			return "Bad command file.";
+		case OutOfRange:
+			return "Number of sources/targets mismatch.";
+		case TooManyArgs:
+			return "Too many arguments.";
+		case UnknownCompression:
+			return "Unknown source compression type.";
+		case CompressionError:
+			return "Compression error.";
+		case DecompressionError:
+			return "Decompression error.";
+		case Bpp:
+			return "Invalid bitmap mode specified.";
+		case PaletteFile:
+			return "Bad palette file.";
+		case PaletteSupportNotImplemented:
+			return "Palettes not supported";
+		case AlphaFiles:
+			return "Alpha bitmap file does not exist";
+		case AlphaDimensions:
+			return "Alpha channel bitmap's dimensions don't match pixel bitmap's dimensions.";
+		case AlphaBpp:
+			return "Alpha channel bitmap must be 8bpp.";
+		default:
+			return "Unknown error!";
+		};
+	}
+
+void Header()
+	{
+	cout << "\n";
+	cout << "\n";
+	cout << "BMCONV S60 version "<< version << ".\n";
+	}
+	
+void Report(int aError)
+	{
+	Header();
+	cout << ErrorMessage(aError) << "\n";
+	}
+
+/**
+Compiliation information to print to the user at the end of the program.
+@param aQuiet Flag if the user selected quiet output mode
+@param aError The error returned from the actions performed
+@param aType The multiple bitmap store type created
+@param aDestfile The multiple bitmap store file name
+@param aBitmapFiles The array of bitmaps used
+@param aNumFiles The amount of bitmaps used
+@param aDestCreated True if the multiple bitmap store has been created/modified
+*/
+
+void CompilationReport(int aQuiet,int aError,TStoreType aType,char* aDestfile,TSourceFile* aBitmapFiles,int aNumFiles, bool aDestCreated)
+	{	
+	if(!aQuiet || aError)
+		{
+		Header();
+		cout << "Compiling...\n";
+		if(aType!=ENoStore)
+			cout << "Multiple bitmap store type: ";
+		if(aType==EFileStore)
+			cout << "File store" << "\n";
+		else if(aType==ERomStore)
+			cout << "ROM image store" << "\n";
+		else if(aType==ECompressedRomStore)
+			cout << "Compressed ROM image store" << "\n";
+		if(aDestfile!=NULL)
+			cout << "Epoc file: " << aDestfile << "\n\n";
+		for(int count=0;count<aNumFiles;count++)
+			{
+			cout << "Bitmap file " << count+1 << "	: ";
+			aBitmapFiles[count].WriteCompileInfo(cout);
+			cout << endl;
+			}
+		cout << ErrorMessage(aError, aDestfile, aDestCreated) << "\n";
+		}
+	}
+	
+void DecompilationReport(int aError,char* aDestfile,char** aBitmapFiles,int aNumFiles)
+	{	
+	Header();
+	cout << "Decompiling...\n";
+	if(aDestfile!=NULL)
+		cout << "Epoc file: " << aDestfile << "\n\n";
+	for(int count=0;count<aNumFiles;count++)
+		{
+		cout << "Bitmap file " << count+1 << "	: ";
+		cout << aBitmapFiles[count] << "\n";
+		}
+	cout << ErrorMessage(aError) << "\n";
+	}
+	
+void Usage()
+    {
+	cout << "\n";
+	cout << "BMCONV S60 version "<< version << ".\n";
+	cout << "Symbian OS multiple bitmap file/rom store conversion program.\n";
+	cout << "Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.";
+	cout << "\n";
+	cout << "\n";
+	cout << "Usage:\n";
+	cout << "BMCONV [-r|-s|-n] [-hfilename] [-q] [-pfilename] epocfile [OPT]bmp_1 ... [OPT]bmp_n\n";
+	cout << "BMCONV [-r|-s|-n] [-q] [-pfilename] epocfile -mepocfile2\n";
+	cout << "BMCONV -u epocfile bmp_1 [... bmp_n]\n";
+	cout << "BMCONV -v epocfile\n";
+	cout << "BMCONV commandfile\n";
+	cout << "\n";
+	cout << " -r specifies a ROM image destination file,\n";
+	cout << " -s specifies a compressed ROM image file,\n";
+	cout << " -n disables bitmap File Store compression,\n";
+	cout << " the default is a compressed File Store file.\n\n";
+	cout << " -q specifies quiet mode - only errors are reported.\n\n";
+	cout << " -hfilename specifies the filename for the automatic\n";
+	cout << " generation of a header file for inclusion into code.\n\n";
+	cout << " -pfilename gives the filename of a palette file containing 256 hex\n";
+	cout << " numbers (0x00BBGGRR) specifying the palette for 8bpp colour bitmaps.\n";
+	cout << " (Omission results in the use of a default palette.)\n\n";
+	cout << " OPT may be one of -1, -2, -4, -8, -c4, -c8, -c12, -c16, -c24 -c32 -c32a\n";
+	cout << " specifying bits per pixel and grey-scale-colour, or -mepocfile2\n";
+	cout << " to specify an existing multiple bitmap file. default is -2.\n\n";
+	cout << " To avoid ambiguity when specifying -c32 with a bitmap file whose name\n";
+	cout << " begins with an 'a', use a relative or direct directory reference\n";
+	cout << " e.g. -c32.\\abitmap.bmp or -c32c:\\abitmap.bmp\n";
+	cout << " Directory names must not include spaces.\n\n";
+	cout << " -c32a specifies use of an alpha channel in a 32bpp bitmap. Alpha data\n";
+	cout << " is supplied in a separate 8bpp bmp file with identical dimensions to\n";
+	cout << " the pixel data. This file must be named as bmp_n with the suffix '-alpha'\n";
+	cout << " e.g. if bmp_1 is 'my.bmp' then the file 'my-alpha.bmp' is required in the\n";
+	cout << " same directory.  The alpha file does not need to be specified.\n\n";
+	cout << " epocfile specifies the epoc multi-bitmap file name.\n";
+	cout << " bmp_n specifies the nth bitmap file name.\n\n";
+	cout << " -u decompiles epocfile to bmp_1,...,bmp_n.\n";
+	cout << " If an alpha channel is present then a further, 8bpp file is output for \n";
+	cout << " the alpha data, named with an '-alpha' suffix as described above.\n\n";
+	cout << " -v displays a summary of the bitmaps in epocfile\n";
+	cout << " otherwise bmp_1,...,bmp_n are compiled to epocfile\n\n";
+	cout << " commandfile specifies a file containing the commandline\n";
+	cout << " with commands separated by spaces or newlines.\n\n";
+	cout << " When bmconv is used on Windows, options may start with '/' or '-'\n";
+	}
+
+int IsWhiteSpace(char aCharacter)
+	{
+	return(aCharacter==' ' || aCharacter=='\n' || aCharacter=='\r' || aCharacter==0x1a);
+	}
+
+int ProcessCommandFile(char* aCommandFileName,char** aArgPtrs,int& aNumArgs)
+    {
+	struct stat fileinfo;
+	if (stat(aCommandFileName,&fileinfo)==-1)
+		return CommandFile;
+
+	int filesize=fileinfo.st_size;
+	if (filesize==0)
+		return NoError;
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__) || defined(__CW32__)
+	fstream commandfile(aCommandFileName, ios::in | ios::binary);
+#else //!__MSVCDOTNET__
+	fstream commandfile(aCommandFileName, ios::in | ios::binary | ios::nocreate);
+#endif //__MSVCDOTNET__
+	if(!commandfile.is_open())
+		return CommandFile;
+
+	char* commandData=new char[filesize+1];
+	if(commandData==NULL)
+		return NoMemory;
+
+	memset(commandData,0,filesize+1);
+	commandfile.read(commandData,filesize);
+	commandData[filesize]='\0';
+
+	char* commandptr = (char*)commandData;
+	char* commandptrLimit = (char*)(commandData + filesize);
+	while (commandptr < commandptrLimit)
+		{
+		if(*commandptr=='/' && *(commandptr+1)=='/')
+			while(*commandptr!='\n' && *commandptr!='\r' && commandptr < commandptrLimit)
+				*commandptr++=' ';
+		else if (*commandptr==0x1a)
+			*commandptr++=' ';
+		commandptr++;
+		}
+
+	commandptr = (char*)commandData;
+	while (commandptr < commandptrLimit)
+		{
+		while(IsWhiteSpace(*commandptr) && commandptr < commandptrLimit)
+			*commandptr++='\0';
+		if (commandptr == commandptrLimit)
+			break;
+		aArgPtrs[aNumArgs]=commandptr;
+        if ( (*commandptr == '/') && (*(commandptr+1) == 'p'||*(commandptr+1) == 'P') && (*(commandptr+2) == '"') )
+            {
+            commandptr+=3;
+            while(*commandptr != '"')
+                commandptr++;
+            *commandptr=' ';
+            
+            }
+		while(!IsWhiteSpace(*commandptr) && commandptr < commandptrLimit)
+			commandptr++;
+		if (commandptr == commandptrLimit)
+			break;
+		aNumArgs++;
+		}
+
+	commandfile.close();
+	return NoError;
+    }
+
+int Decompile(int aArgc,int aNumArgs,char** aArgPtrs)
+	{
+	int ret=OutOfRange;
+	char* destfilename=aArgPtrs[1];
+
+	if(aArgc>=4 || aArgc==2)
+		{
+		for(int count=2;count<aNumArgs;count++)
+			{
+			EpocLoader pl;
+			ret=pl.LoadEpocBitmap(destfilename,count-2);
+			if(!ret) ret=pl.SaveBitmap(aArgPtrs[count]);
+			if(ret) break;
+			}
+		DecompilationReport(ret,destfilename,&aArgPtrs[2],aNumArgs-2);
+		}
+	else
+		DecompilationReport(ret,NULL,NULL,0);
+
+	return ret;
+	}
+
+const char* AddEpocRootTo(std::string& aBuf, const std::string& aName)
+	{ 
+	int nameLen = aName.length();
+	int rootLen = 0;
+	aBuf = ""; // Clear old contents
+	char* epocroot = getenv("EPOCROOT");
+	if (epocroot)
+		{
+		rootLen = strlen(epocroot);
+		if (nameLen+rootLen < KMaxPaletteFileLen)
+			{
+			if( rootLen > 0 && epocroot[rootLen-1] == '\\')
+			    {
+			    aBuf = std::string(epocroot, rootLen-1);
+			    }
+			else if( rootLen > 0 )
+			    {
+			    aBuf = std::string(epocroot);
+			    }
+			}
+		}
+	aBuf += aName;
+	return aBuf.c_str();
+	}
+
+bool FileExists( const char* aFileName )
+{
+  struct stat fileInfo;   
+  int retVal = 0; 
+
+  // Try to get file attributes to see if the file exists or not:
+  retVal = stat( aFileName, &fileInfo); 
+  return retVal == 0;
+}
+
+const char* DefaultPaletteFileName(std::string& aBuf)
+    {
+    const char* palettefilename = NULL;    
+    int numOfSearchLocations = sizeof(DefaultPaletteFileSearchLocations)/sizeof(char*);
+    
+    for( int i = 0; i < numOfSearchLocations; ++i )
+        {
+        palettefilename = AddEpocRootTo(aBuf, DefaultPaletteFileSearchLocations[i]);
+        if( FileExists( palettefilename))
+            {
+            return palettefilename;
+            }
+        }
+    
+    return NULL;
+    }
+
+int Compile(int aNumArgs,int aArgArraySize, char** aArgPtrs)
+	{
+	TStoreType storeType = EFileStore;
+	int compression = 1;
+	int quiet = 0;
+	char* headerfilename = NULL;
+	char paletteBuf[KMaxPaletteFileLen];
+	memset(paletteBuf, 0, KMaxPaletteFileLen);
+	std::string paletteStr;	
+	const char* defaultPalettefile = DefaultPaletteFileName(paletteStr);
+	char* palettefilename = NULL;
+	char* destfilename = NULL;
+	int ret = OutOfRange;
+	bool aDestCreated = false;
+
+	for(int argnum=0;argnum<aNumArgs;argnum++)
+		{
+		if(aArgPtrs[argnum] && (aArgPtrs[argnum][0] == OPTCHAR || aArgPtrs[argnum][0]==ALTERNATE_OPTCHAR))
+			{
+			if(aArgPtrs[argnum][1]=='r' || aArgPtrs[argnum][1]=='R')
+				{
+				if(storeType==ECompressedRomStore)
+					{
+					ret=TooManyArgs;
+					CompilationReport(quiet,ret,storeType,NULL,NULL,0,aDestCreated);
+					return ret;
+					}
+				storeType=ERomStore;
+				aArgPtrs[argnum] = NULL;
+				}
+			else if(aArgPtrs[argnum][1]=='s' || aArgPtrs[argnum][1]=='S')
+				{
+				if(storeType==ERomStore)
+					{
+					ret=TooManyArgs;
+					CompilationReport(quiet,ret,storeType,NULL,NULL,0,aDestCreated);
+					return ret;
+					}
+				storeType=ECompressedRomStore;
+				aArgPtrs[argnum] = NULL;
+				}
+			else if(aArgPtrs[argnum][1]=='n' || aArgPtrs[argnum][1]=='N')
+				{
+				compression=0;
+				aArgPtrs[argnum] = NULL;
+				}
+			else if(aArgPtrs[argnum][1]=='h' || aArgPtrs[argnum][1]=='H')
+				{
+				headerfilename = &aArgPtrs[argnum][2];
+				aArgPtrs[argnum] = NULL;
+				}
+			else if(aArgPtrs[argnum][1]=='q' || aArgPtrs[argnum][1]=='Q')
+				{
+				if (getenv("BMCONV_NOT_QUIET") == 0)
+					quiet=1;
+				aArgPtrs[argnum] = NULL;
+				}
+			else if(aArgPtrs[argnum][1]=='p' || aArgPtrs[argnum][1]=='P')
+				{
+				palettefilename = &aArgPtrs[argnum][2];
+                if (*palettefilename=='"')
+                    {
+                    palettefilename+=1;
+                    }
+				aArgPtrs[argnum] = NULL;
+				}
+			}
+		else
+			break;		// the RNHQP arguments must precede the output filename
+		}
+
+	if( palettefilename == NULL )
+	    {
+	    // Palette file not given in arguments. If the default palette file
+	    // was found, use it, otherwise return error.
+	    if( defaultPalettefile != NULL )
+	        {
+	        memcpy(paletteBuf, defaultPalettefile, strlen(defaultPalettefile));
+	        palettefilename = paletteBuf;
+	        }
+	    else
+	        {
+	        // Palettefile not given in arguments nor found from default locations:
+	        ret = PaletteFile;
+	        CompilationReport(quiet,ret,storeType,NULL,NULL,0,aDestCreated);
+	        return ret;
+	        }
+	    }
+	int firstsource=0;
+	while(firstsource<aArgArraySize && aArgPtrs[firstsource]==NULL)
+		firstsource++;
+	if(firstsource==aArgArraySize) firstsource=0;
+	destfilename=aArgPtrs[firstsource];
+	firstsource++;
+	int numsources=firstsource;
+	while(numsources<aArgArraySize && aArgPtrs[numsources]!=NULL)
+		numsources++;
+	if(numsources==aArgArraySize) numsources=0;
+	numsources-=firstsource;
+
+	TSourceFile* sources = 0;
+
+	if (numsources > 0)
+		{
+		sources = new TSourceFile[numsources];
+		for (int ii=0; ii<numsources; ii++)
+			sources[ii].FileName() = aArgPtrs[firstsource + ii];
+		BitmapCompiler mp(sources,numsources);
+		ret = mp.Compile(storeType,compression,destfilename,headerfilename,palettefilename);
+		aDestCreated = true;		// The multiple bitmap store has been created/modified
+		}
+
+	CompilationReport(quiet,ret,storeType,destfilename,sources,aNumArgs-firstsource,aDestCreated);
+	delete [] sources;
+
+	return ret;
+	}
+
+void GetInfo(char* aSourceFile)
+	{
+	Header();
+
+	EpocLoader pl;
+	int numSources=-1;
+	int romFormat=0;
+	int ret = pl.EpocBitmapCount(aSourceFile, numSources, romFormat);
+	if (ret)
+		{
+		cout << "Problem reading number of bitmaps \n";
+		cout << ErrorMessage(ret) << "\n";
+		return;
+		}
+
+	cout << aSourceFile << " is a " << (romFormat? "ROM image":"File store") 
+		<< " containing " << numSources << ((numSources==1)? " bitmap\n":" bitmaps\n");
+
+	for (int count = 0;count<numSources;count++)
+		{
+		ret = pl.LoadEpocBitmap(aSourceFile,count);
+		if (ret == OutOfRange)
+			break;
+		cout << "\n";
+		if (ret)
+			{
+			cout << "Problem loading bitmap number " << count << "\n";
+			cout << ErrorMessage(ret) << "\n";
+			break;
+			}
+		else
+			{
+			SEpocBitmapHeader h = pl.Header();
+			cout << "Bitmap " << count + 1 << " information:\n";
+			cout << "Pixel size " << h.iWidthInPixels << " x " << h.iHeightInPixels << "\n";
+			cout << "Twips size " << h.iWidthInTwips << " x " << h.iHeightInTwips << "\n";
+			cout << h.iBitsPerPixel << " Bpp ";
+			if (h.iColor == EColorBitmap)
+				cout << "Colour";
+			else if (h.iColor == EColorBitmapAlpha)
+				cout << "Colour with alpha channel";
+			else if(h.iColor == EMonochromeBitmap)
+				cout << "Monochrome";
+			else
+				cout << "Unknown colour format";
+			cout << "\n";
+			if (h.iPaletteEntries > 0)
+				cout << "Palette entries " << h.iPaletteEntries;
+
+			int byteSize = BitmapUtils::ByteWidth(h.iWidthInPixels,h.iBitsPerPixel) * h.iHeightInPixels;
+			int compressionRatio = 0;
+			if (byteSize > 0)
+				compressionRatio = (h.iBitmapSize - sizeof(SEpocBitmapHeader)) * 100 / byteSize;
+
+			switch (h.iCompression)
+				{
+			case ENoBitmapCompression:
+				cout << "No compression\n";
+				break;
+			case EByteRLECompression:
+				cout << "Bytewise RLE compression " << compressionRatio << "%\n";
+				break;
+			case ETwelveBitRLECompression:
+				cout << "12 bit RLE compression " << compressionRatio << "%\n";
+				break;
+			case ESixteenBitRLECompression:
+				cout << "16 bit RLE compression " << compressionRatio << "%\n";
+				break;
+			case ETwentyFourBitRLECompression:
+				cout << "24 bit RLE compression " << compressionRatio << "%\n";
+				break;
+			case EThirtyTwoUBitRLECompression:
+				cout << "unsigned 32 bit RLE compression (no alpha channel) " << compressionRatio << "%\n";
+				break;
+			case EThirtyTwoABitRLECompression:
+				cout << "unsigned 32 bit RLE compression (with alpha channel) " << compressionRatio << "%\n";
+				break;
+		//	case ERLECompressionLast: // Added to supress unhandled switch warning
+			default:
+				break;
+				}
+			}
+		}
+
+	cout << "\n";
+	}
+
+class TAutoPtr
+	{
+public:
+	TAutoPtr(char** aPtr) :
+		iPtr(aPtr)
+		{
+		}
+	~TAutoPtr()
+		{
+		delete iPtr;
+		}
+private:
+	char** iPtr;
+	};
+
+int main(int argc,char* argv[],char* [])
+    {
+	if (argc <= 1)
+		{
+		Usage();
+		return 0;
+		}
+
+	int optMaxCnt = argc;
+
+	if(argc==2) // The single argument must be a command file name
+		{
+		struct stat fileinfo;
+		if (stat(argv[1],&fileinfo)==-1)
+			{
+			Report(CommandFile);
+			return 0;
+			}
+		optMaxCnt = fileinfo.st_size;
+		}
+
+	char** argptrs = new char*[optMaxCnt];
+	if(!argptrs)
+		{
+		Report(NoMemory);
+		return 0;
+		}
+	TAutoPtr autoPtr(argptrs);
+	memset(argptrs, 0, optMaxCnt * sizeof(char*));
+
+	int numargs = 0;
+	if(argc>2) // Explicit arguments are present
+		{
+		for(int count=0;count<argc-1;count++)
+			argptrs[count]=argv[count+1];
+		numargs = argc-1;
+		}
+	else // The single argument must be a command file name
+		{
+		int ret = ProcessCommandFile(argv[1],argptrs,numargs);
+		if (ret)
+			{
+			Report(ret);
+			return 0;
+			}
+		}
+
+	if ((argptrs[0]!=NULL && (argptrs[0][0]==OPTCHAR || argptrs[0][0]==ALTERNATE_OPTCHAR)) && (argptrs[0][1]=='u' || argptrs[0][1]=='U')) {
+		return Decompile(argc,numargs,argptrs); }
+
+	if ((argptrs[0]!=NULL && (argptrs[0][0]==OPTCHAR || argptrs[0][0]==ALTERNATE_OPTCHAR)) && (argptrs[0][1]=='v' || argptrs[0][1]=='V'))
+		{
+		GetInfo(argptrs[1]);
+		return 0;
+		}
+
+	return Compile(numargs,optMaxCnt,argptrs);
+    }
+

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

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfxconversion/bmconv_s60/src/PBMTOBM.CPP	Tue Feb 02 01:11:11 2010 +0200
@@ -0,0 +1,730 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <assert.h>
+#include "BMCONV.H"
+
+EpocLoader::EpocLoader():
+	iPbmBits(NULL)
+	{}
+
+EpocLoader::~EpocLoader()
+	{
+	delete iPbmBits;
+	}
+
+int EpocLoader::EpocBitmapCount(char* aFileName, int& aCount, int& isRomFormat)
+    {
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__) || defined(__CW32__)
+	fstream file(aFileName, ios::in | ios::binary);
+#else //!__MSVCDOTNET__
+	fstream file(aFileName, ios::in | ios::binary | ios::nocreate);
+#endif //__MSVCDOTNET__
+
+	if (file.is_open()==0)
+		return Files;
+
+	long int wordbuffer;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+	if (wordbuffer==KMultiBitmapRomImageUid)
+		{
+		// ROM format file - next 4 bytes are the number of bitmaps
+		isRomFormat=1;
+		}
+	else
+		{
+		if (wordbuffer!=KWriteOnceFileStoreUid)
+			return SourceFile;
+		isRomFormat=0;
+		file.read((char *)&wordbuffer,4);
+		if (file.gcount()!=4 || wordbuffer!=KMultiBitmapFileImageUid)
+			return SourceFile;
+		file.read((char *)&wordbuffer,4);
+		if (file.gcount()!=4 || wordbuffer!=0)
+			return SourceFile;
+		file.read((char *)&wordbuffer,4);
+		if (file.gcount()!=4 || wordbuffer!=KMultiBitmapFileImageChecksum)
+			return SourceFile;
+		file.read((char *)&wordbuffer,4);
+		if (file.gcount()!=4)
+			return SourceFile;
+		file.seekg(wordbuffer,ios::beg);
+		}
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+	aCount=wordbuffer;
+	return NoError;
+    }
+
+int EpocLoader::LoadEpocBitmap(char* aFileName,int aIndex)
+	{
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__) || defined(__CW32__)
+	fstream file(aFileName, ios::in | ios::binary);
+#else //!__MSVCDOTNET__
+	fstream file(aFileName, ios::in | ios::binary | ios::nocreate);
+#endif //__MSVCDOTNET__
+
+	if (file.is_open()==0)
+		return Files;
+
+	long int wordbuffer;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+	file.close();
+
+	if (wordbuffer==KMultiBitmapRomImageUid)
+		return LoadRom(aFileName,aIndex);
+
+	return LoadFile(aFileName,aIndex);
+	}
+
+int EpocLoader::LoadFile(char* aFileName,int aIndex)
+	{
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__) || defined(__CW32__)
+	fstream file(aFileName, ios::in | ios::binary);
+#else //!__MSVCDOTNET__
+	fstream file(aFileName, ios::in | ios::binary | ios::nocreate);
+#endif //__MSVCDOTNET__
+
+	if (file.is_open()==0)
+		return Files;
+
+	long int wordbuffer;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4 || wordbuffer!=KWriteOnceFileStoreUid)
+		return SourceFile;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4 || wordbuffer!=KMultiBitmapFileImageUid)
+		return SourceFile;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4 || wordbuffer!=0)
+		return SourceFile;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4 || wordbuffer!=KMultiBitmapFileImageChecksum)
+		return SourceFile;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+	file.seekg(wordbuffer,ios::beg);
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+
+	int numsources=wordbuffer;
+	if (aIndex >= numsources)
+		return OutOfRange;
+	file.seekg(aIndex*4,ios::cur);
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+	file.seekg(wordbuffer,ios::beg);
+	int ret = DoLoadFile(file);
+	file.close();
+	return ret;
+	}
+
+int EpocLoader::LoadRom(char* aFileName,int aIndex)
+	{
+#if defined(__MSVCDOTNET__) || defined(__TOOLS2__) || defined(__CW32__)
+	fstream file(aFileName, ios::in | ios::binary);
+#else //!__MSVCDOTNET__
+	fstream file(aFileName, ios::in | ios::binary | ios::nocreate);
+#endif //__MSVCDOTNET__
+
+	if (file.is_open()==0)
+		return Files;
+
+	long int wordbuffer;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+	if (wordbuffer!=KMultiBitmapRomImageUid)
+		return SourceFile;
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+	if (aIndex>=wordbuffer)
+		return OutOfRange;
+	file.seekg(aIndex*4,ios::cur);
+	file.read((char *)&wordbuffer,4);
+	if (file.gcount()!=4)
+		return SourceFile;
+	file.seekg(wordbuffer,ios::beg);
+	int ret=DoLoadRom(file);
+	file.close();
+	return ret;
+	}
+
+int EpocLoader::DoLoadFile(fstream& aFile)
+	{
+	long size = sizeof(SEpocBitmapHeader);
+	aFile.read((char *)&iPbmHeader,size);
+	if (aFile.gcount()!=size)
+		return SourceFile;
+	iOriginalPbmHeader = iPbmHeader;
+	size=iPbmHeader.iBitmapSize-iPbmHeader.iStructSize;
+
+	iPbmBits=new char[size];
+	if (iPbmBits==NULL)
+		return NoMemory;
+	memset(iPbmBits,0xff,size);
+	aFile.read(iPbmBits,size);
+	aFile.close();
+	if (aFile.gcount() != size)
+		return SourceFile;
+
+	if (iPbmHeader.iCompression != ENoBitmapCompression)
+		{
+		return Decompress(size);
+		}
+
+	return NoError;
+	}
+
+int EpocLoader::DoLoadRom(fstream& aFile)
+	{
+	Bitmap bmp;
+	long size=sizeof(Bitmap);
+	aFile.read((char*)&bmp,size);
+	if (aFile.gcount() != size)
+		return SourceFile;
+
+	size = bmp.iHeader.iBitmapSize - sizeof(SEpocBitmapHeader);
+	iPbmBits = new char[size];
+	if (iPbmBits == NULL)
+		return NoMemory;
+	memset(iPbmBits,0xff,size);
+
+	aFile.read(iPbmBits,size);
+	if (aFile.gcount() != size)
+		return SourceFile;
+	iPbmHeader = bmp.iHeader;
+	iOriginalPbmHeader = iPbmHeader;
+
+	if (iPbmHeader.iCompression != ENoBitmapCompression)
+		{
+		return Decompress(size);
+		}
+
+	return NoError;
+	}
+
+int EpocLoader::Decompress(int aSize)
+	{
+	int byteWidth = BitmapUtils::ByteWidth(iPbmHeader.iWidthInPixels,iPbmHeader.iBitsPerPixel);
+	int expandedsize = byteWidth * iPbmHeader.iHeightInPixels;
+	char* newbits = new char[expandedsize];
+	if (newbits == NULL)
+		return NoMemory;
+	memset(newbits,0xff,expandedsize);
+	int ret = NoError;
+	switch (iPbmHeader.iCompression)
+		{
+	case EByteRLECompression:
+		ret = ExpandByteRLEData(newbits,expandedsize,iPbmBits,aSize);
+		break;
+	case ETwelveBitRLECompression:
+		ret = ExpandTwelveBitRLEData(newbits,expandedsize,iPbmBits,aSize);
+		break;
+	case ESixteenBitRLECompression:
+		ret = ExpandSixteenBitRLEData(newbits,expandedsize,iPbmBits,aSize);
+		break;
+	case ETwentyFourBitRLECompression:
+		ret = ExpandTwentyFourBitRLEData(newbits,expandedsize,iPbmBits,aSize);
+		break;
+	case EThirtyTwoUBitRLECompression:
+		ret = ExpandThirtyTwoUBitRLEData(newbits,expandedsize,iPbmBits,aSize);
+		break;
+	case EThirtyTwoABitRLECompression:
+		ret = ExpandThirtyTwoABitRLEData(newbits,expandedsize,iPbmBits,aSize);
+		break;
+	default:
+		ret = UnknownCompression;
+		break;
+		}
+	delete iPbmBits;
+	iPbmBits = newbits;
+	iPbmHeader.iCompression = ENoBitmapCompression;
+	iPbmHeader.iBitmapSize += expandedsize-aSize;
+	return ret;
+	}
+
+int EpocLoader::ExpandByteRLEData(char* aDest,int aDestSize,char* aSrce,int aSrceSize)
+	{
+	char* srcelimit=aSrce+aSrceSize;
+	char* destlimit=aDest+aDestSize;
+	while(aSrce<srcelimit && aDest<destlimit)
+		{
+		char count=*aSrce++;
+		if (count<0)
+			{
+			int runLength=-count;
+			memcpy(aDest,aSrce,runLength);
+			aSrce+=runLength;
+			aDest+=runLength;
+			}
+		else
+			{
+			char value=*aSrce++;
+			while(count>=0)
+				{
+				*aDest++=value;
+				count--;
+				}
+			}
+		}
+	if (aSrce!=srcelimit || aDest!=destlimit)
+		return DecompressionError;
+	return NoError;
+	}
+
+int EpocLoader::ExpandTwelveBitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes)
+	{
+	unsigned short* srcePtr = (unsigned short*)aSrce;
+	unsigned short* destPtr = (unsigned short*)aDest;
+	unsigned short* srcePtrLimit = srcePtr + (aSrceSizeInBytes / 2);
+	unsigned short* destPtrLimit = destPtr + (aDestSizeInBytes / 2);
+
+	while (srcePtr < srcePtrLimit && destPtr < destPtrLimit)
+		{
+		unsigned short value = *srcePtr++;
+		int runLength = (value >> 12) + 1;
+		value &= 0x0fff;
+
+		for (;runLength > 0;runLength--)
+			*destPtr++ = value;
+		}
+
+	if (srcePtr != srcePtrLimit || destPtr != destPtrLimit)
+		return DecompressionError;
+
+	return NoError;
+	}
+
+int EpocLoader::ExpandSixteenBitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes)
+	{
+	char* srcePtrLimit = aSrce + aSrceSizeInBytes;
+	unsigned short* destPtr = (unsigned short*)aDest;
+	unsigned short* destPtrLimit = destPtr + (aDestSizeInBytes / 2);
+
+	while (aSrce < srcePtrLimit && destPtr < destPtrLimit)
+		{
+		int runLength = *aSrce++;
+
+		if (runLength >= 0)
+			{
+			unsigned short value = *((unsigned short*)(aSrce));
+			aSrce += 2;
+			for (runLength++; runLength > 0; runLength--)
+				*destPtr++ = value;
+			}
+		else
+			{
+			runLength = -runLength;
+			int byteLength = runLength * 2;
+			memcpy(destPtr,aSrce,byteLength);
+			aSrce += byteLength;
+			destPtr += runLength;
+			}
+		}
+
+	if (aSrce != srcePtrLimit || destPtr != destPtrLimit)
+		return DecompressionError;
+
+	return NoError;
+	}
+
+int EpocLoader::ExpandTwentyFourBitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes)
+	{
+	char* srcePtrLimit = aSrce + aSrceSizeInBytes;
+	char* destPtrLimit = aDest + aDestSizeInBytes;
+
+	while (aSrce < srcePtrLimit && aDest < destPtrLimit)
+		{
+		int runLength = *aSrce++;
+
+		if (runLength >= 0)
+			{
+			char component1 = *aSrce++;
+			char component2 = *aSrce++;
+			char component3 = *aSrce++;
+			for (runLength++; runLength > 0; runLength--)
+				{
+				*aDest++ = component1;
+				*aDest++ = component2;
+				*aDest++ = component3;
+				}
+			}
+		else
+			{
+			runLength = -runLength;
+			int byteLength = runLength * 3;
+			memcpy(aDest,aSrce,byteLength);
+			aSrce += byteLength;
+			aDest += byteLength;
+			}
+		}
+
+	if (aSrce != srcePtrLimit || aDest != destPtrLimit)
+		return DecompressionError;
+
+	return NoError;
+	}
+
+/** The function decodes 24-bit compressed pixel buffer into the 32-bit buffer, where top bytes are unused*/
+int EpocLoader::ExpandThirtyTwoUBitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes)
+	{
+	char* srcePtrLimit = aSrce + aSrceSizeInBytes;
+	char* destPtrLimit = aDest + aDestSizeInBytes;
+
+	while (aSrce < srcePtrLimit && aDest < destPtrLimit)
+		{
+		int runLength = *aSrce++;
+
+		if (runLength >= 0)
+			{
+			char component1 = *aSrce++;
+			char component2 = *aSrce++;
+			char component3 = *aSrce++;
+			for (runLength++; runLength > 0; runLength--)
+				{
+				*aDest++ = component1;
+				*aDest++ = component2;
+				*aDest++ = component3;
+				aDest++;
+				}
+			}
+		else 
+			{
+			runLength = -runLength;
+			for(int ii = 0; ii < runLength; ii++)
+				{
+				memcpy(aDest,aSrce,3);
+				aSrce += 3;
+				aDest += 4;
+				}
+			}
+		}
+
+	if (aSrce != srcePtrLimit || aDest != destPtrLimit)
+		return DecompressionError;
+
+	return NoError;
+	}
+
+/** The function decodes 32-bit compressed pixel buffer into the 32-bit buffer, where top bytes are alpha channel*/
+int EpocLoader::ExpandThirtyTwoABitRLEData(char* aDest,int aDestSizeInBytes,char* aSrce,int aSrceSizeInBytes)
+	{
+	char* srcePtrLimit = aSrce + aSrceSizeInBytes;
+	char* destPtrLimit = aDest + aDestSizeInBytes;
+
+	while (aSrce < srcePtrLimit && aDest < destPtrLimit)
+		{
+		int runLength = *aSrce++;
+
+		if (runLength >= 0)
+			{
+			char component1 = *aSrce++;
+			char component2 = *aSrce++;
+			char component3 = *aSrce++;
+			char component4 = *aSrce++;
+			for (runLength++; runLength > 0; runLength--)
+				{
+				*aDest++ = component1;
+				*aDest++ = component2;
+				*aDest++ = component3;
+				*aDest++ = component4;
+				}
+			}
+		else 
+			{
+			runLength = -runLength;
+			memcpy(aDest,aSrce,4*runLength);
+			aSrce += 4*runLength;
+			aDest += 4*runLength;
+			}
+		}
+
+	if (aSrce != srcePtrLimit || aDest != destPtrLimit)
+		return DecompressionError;
+
+	return NoError;
+	}
+
+TRgb EpocLoader::GetPixel(int aXCoord,int aYCoord)
+	{
+	unsigned char col;
+	aXCoord%=iPbmHeader.iWidthInPixels;
+	aYCoord%=iPbmHeader.iHeightInPixels;
+	int byteWidth = BitmapUtils::ByteWidth(iPbmHeader.iWidthInPixels,iPbmHeader.iBitsPerPixel);
+	int yOffset = aYCoord * byteWidth;
+
+	switch(iPbmHeader.iBitsPerPixel)
+		{
+		case 1:
+			col = iPbmBits[yOffset + (aXCoord / 8)];
+			col >>= (aXCoord&7);
+			return TRgb::Gray2(col & 1);
+		case 2:
+			col = iPbmBits[yOffset + (aXCoord / 4)];
+			col = (unsigned char)(col>>(2*(aXCoord%4)));
+			return TRgb::Gray4(col & 3);
+		case 4:
+			col = iPbmBits[yOffset + (aXCoord / 2)];
+			if (aXCoord & 1)
+				col >>= 4;
+			col &= 0xf;
+			if (iPbmHeader.iColor==EColorBitmap)
+				return TRgb::Color16(col);
+			else
+				return TRgb::Gray16(col);
+		case 8:
+			col=iPbmBits[yOffset + aXCoord];
+			if (iPbmHeader.iColor==EColorBitmap)
+				return TRgb::Color256(col);
+			else
+				return TRgb::Gray256(col);
+		case 12:
+		case 16:
+			{
+			unsigned short* shortPtr = (unsigned short*)&iPbmBits[yOffset + (aXCoord * 2)];
+			if (iPbmHeader.iBitsPerPixel == 12)
+				return TRgb::Color4K(*shortPtr);
+			else
+				return TRgb::Color64K(*shortPtr);
+			}
+		case 24:
+			{
+			char* pixelPtr = iPbmBits + yOffset + (aXCoord * 3);
+			TRgb pixelColor;
+			pixelColor.iBlue = *pixelPtr++;
+			pixelColor.iGreen = *pixelPtr++;
+			pixelColor.iRed = *pixelPtr;
+			return pixelColor;
+			}
+		case 32:
+			{
+			char* pixelPtr = iPbmBits + yOffset + (aXCoord * 4);
+			TRgb pixelColor;
+			pixelColor.iBlue = *pixelPtr++;
+			pixelColor.iGreen = *pixelPtr++;
+			pixelColor.iRed = *pixelPtr++;
+			pixelColor.iSpare = *pixelPtr;
+			return pixelColor;
+			}
+		default:
+			return TRgb(0);
+		}
+	}
+
+unsigned char EpocLoader::GetAlpha(int aXCoord,int aYCoord)
+	{
+	aXCoord%=iPbmHeader.iWidthInPixels;
+	aYCoord%=iPbmHeader.iHeightInPixels;
+	int byteWidth = BitmapUtils::ByteWidth(iPbmHeader.iWidthInPixels,iPbmHeader.iBitsPerPixel);
+	int yOffset = aYCoord * byteWidth;
+
+	assert(iPbmHeader.iBitsPerPixel == 32); // this method must only be called for 32bpp bitmaps!
+
+	char* pixelPtr = iPbmBits + yOffset + (aXCoord * 4);
+	pixelPtr += 3; // skip over RGB
+	unsigned char col = *pixelPtr;
+	return col;	
+	}
+
+int EpocLoader::SaveBitmap(char* aFileName)
+	{
+	TBitmapFileHeader fileheader;
+	TBitmapInfoHeader bmpHeader;
+	char* bmpBits;
+
+	bmpHeader.biSize = sizeof(TBitmapInfoHeader);
+	bmpHeader.biWidth = iPbmHeader.iWidthInPixels;
+	bmpHeader.biHeight = iPbmHeader.iHeightInPixels;
+	bmpHeader.biPlanes = 1;
+	bmpHeader.biBitCount = 24;
+	bmpHeader.biCompression = 0;
+	bmpHeader.biSizeImage = 0;
+	bmpHeader.biXPelsPerMeter = 0;
+	bmpHeader.biYPelsPerMeter = 0;
+	bmpHeader.biClrUsed = 0;
+	bmpHeader.biClrImportant = 0;
+
+	long byteWidth = ((bmpHeader.biWidth * 3) + 3) & ~3;
+	long destlength = bmpHeader.biHeight * byteWidth;
+
+	fileheader.bfType = 'B'+('M'<<8);
+	fileheader.bfSize = sizeof(TBitmapFileHeader)+sizeof(TBitmapInfoHeader)+destlength;
+	fileheader.bfReserved1 = 0;
+	fileheader.bfReserved2 = 0;
+	fileheader.bfOffBits = sizeof(TBitmapFileHeader)+sizeof(TBitmapInfoHeader);
+
+	bmpBits = new char[destlength];
+	if (bmpBits == NULL)
+		return NoMemory;
+	memset(bmpBits,0xff,destlength);
+
+	for(long y=0;y<bmpHeader.biHeight;y++)
+		{
+		char* dest=&bmpBits[(bmpHeader.biHeight-y-1)*byteWidth];
+		for(long x=0;x<bmpHeader.biWidth;x++)
+			{
+			TRgb pixel=GetPixel(x,y);
+			*dest++=pixel.iBlue;
+			*dest++=pixel.iGreen;
+			*dest++=pixel.iRed;
+			}
+		}
+
+	fstream file(aFileName, ios::out | ios::binary);
+
+	if (file.is_open()==0)
+		{
+		delete bmpBits;
+		return DestFile;
+		}
+
+	file.write((char *)&fileheader,sizeof(TBitmapFileHeader));
+	file.write((char *)&bmpHeader,sizeof(TBitmapInfoHeader));
+	file.write((char *)bmpBits,destlength);
+	file.close();
+
+	delete bmpBits;
+
+	if (iPbmHeader.iColor == EColorBitmapAlpha)
+		SaveAlpha(aFileName);
+	return NoError;
+	}
+
+
+int EpocLoader::SaveAlpha(char* aFileName)
+	{
+	TBitmapFileHeader fileheader;
+	TBitmapInfoHeader alphaHeader;
+
+	alphaHeader.biSize = sizeof(TBitmapInfoHeader);
+	alphaHeader.biWidth = iPbmHeader.iWidthInPixels;
+	alphaHeader.biHeight = iPbmHeader.iHeightInPixels;
+	alphaHeader.biPlanes = 1;
+	alphaHeader.biBitCount = 8;
+	alphaHeader.biCompression = 0;
+	alphaHeader.biSizeImage = 0;
+	alphaHeader.biXPelsPerMeter = 0;
+	alphaHeader.biYPelsPerMeter = 0;
+	alphaHeader.biClrUsed = 256;
+	alphaHeader.biClrImportant = 0;
+
+	const long paletteSize = 1024;
+
+	// ensure bytes-per-scanline is a large enough multiple of 4
+	long byteWidth = (alphaHeader.biWidth + 3) & ~3; 
+	long destlength = alphaHeader.biHeight * byteWidth;
+	alphaHeader.biSizeImage = destlength;
+
+	fileheader.bfType = 'B'+('M'<<8);
+	fileheader.bfSize = sizeof(TBitmapFileHeader)+sizeof(TBitmapInfoHeader)+paletteSize+destlength;
+	fileheader.bfReserved1 = 0;
+	fileheader.bfReserved2 = 0;
+	fileheader.bfOffBits = sizeof(TBitmapFileHeader)+sizeof(TBitmapInfoHeader)+paletteSize;
+
+	// we need to output the grayscale palette before the actual alpha data as this is an 8bpp BMP
+	char* palette = new char[paletteSize]; // 256 colors x 4bytes/color (r,g,b,unused)
+	if (palette == NULL)
+		return NoMemory;
+	memset(palette,0,paletteSize);
+	char* pEnt = palette;
+	for (long p=0;p<256;++p)
+		{
+		unsigned char col = (unsigned char)p;
+		*pEnt++=col;
+		*pEnt++=col;
+		*pEnt++=col;
+		pEnt++;
+		}
+
+	char* alphaBits = new char[destlength];
+	if (alphaBits == NULL)
+		{
+		delete [] palette;
+		return NoMemory;
+		}
+	memset(alphaBits,0,destlength);
+
+	for(long y=0;y<alphaHeader.biHeight;y++)
+		{
+		char* dest=&alphaBits[(alphaHeader.biHeight-y-1)*byteWidth];
+		for(long x=0;x<alphaHeader.biWidth;x++)
+			{
+			unsigned char alphaVal=GetAlpha(x,y);
+			*dest++=alphaVal;
+			}
+		}
+
+	int fileNameLen = strlen(aFileName);
+	char* alphaFileName = new char[fileNameLen + 7];// -alpha suffix is 6 chars, plus NUL termination
+	if (alphaFileName == NULL)
+		{
+		delete [] palette;
+		delete [] alphaBits;
+		return NoMemory;
+		}
+	int dotPos = -1;
+	for (int i = 0; i < fileNameLen; ++i)
+		if (aFileName[i]=='.')
+			dotPos=i;
+	int prefixLen = (dotPos>=0?dotPos:fileNameLen);
+	memcpy(alphaFileName,aFileName,prefixLen);
+	const char* suffix = "-alpha";
+	memcpy(alphaFileName+prefixLen,suffix,6);
+	if (dotPos>=0)
+		memcpy(alphaFileName+prefixLen+6,aFileName+dotPos,fileNameLen-dotPos);
+	*(alphaFileName + fileNameLen + 6) = '\0';
+	fstream file(alphaFileName, ios::out | ios::binary);
+	if (file.is_open()==0)
+		{
+		delete [] alphaFileName;
+		delete [] alphaBits;
+		delete [] palette;
+		return DestFile;
+		}
+
+	file.write((char *)&fileheader,sizeof(TBitmapFileHeader));
+	file.write((char *)&alphaHeader,sizeof(TBitmapInfoHeader));
+	file.write((char *)palette,paletteSize);
+	file.write((char *)alphaBits,destlength);
+	file.close();
+
+	delete [] alphaFileName;
+	delete [] alphaBits;
+	delete [] palette;
+	return NoError;
+	}
+
+int EpocLoader::DupBitmap(SEpocBitmapHeader*& aPbm)
+	{
+	char* newPbm = new char[iPbmHeader.iBitmapSize];
+	if (newPbm == NULL)
+		return NoMemory;
+	memcpy(newPbm, &iPbmHeader, sizeof(SEpocBitmapHeader));
+	memcpy(newPbm+sizeof(SEpocBitmapHeader), iPbmBits, iPbmHeader.iBitmapSize - sizeof(SEpocBitmapHeader));
+	aPbm = (SEpocBitmapHeader*)newPbm;
+	return NoError;
+	}