// Copyright (c) 1995-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 <f32file.h>

#include <s32file.h>

#include <fbs.h>

#include <bitmap.h>

#include "UTILS.H"

#include <e32hashtab.h>

GLREF_C void Panic(TFbsPanic aPanic);

void CBitwiseBitmap::DoInternalizeCompressedDataL(RReadStream& aStream,TInt aSrceSizeInBytes,TUint32* aBase,TBitmapfileCompression aCompression)

	{

	TInt destSizeInBytes = iHeader.iSizeInPixels.iHeight * iByteWidth;

	TUint8* destPtr = (TUint8*)aBase;

	// try to allocate memory for the compressed bitmap

	TUint8* decompressionBuffer = (TUint8*)User::Alloc(aSrceSizeInBytes);

	if (decompressionBuffer)

		{

		// read the compressed bitmap, then decompress

		CleanupStack::PushL(decompressionBuffer);

		aStream.ReadL(decompressionBuffer,aSrceSizeInBytes);

		switch (aCompression)

			{

		case EByteRLECompression:

			DoDecompressByteData(destPtr,destSizeInBytes,decompressionBuffer,aSrceSizeInBytes);

			break;

		case ETwelveBitRLECompression:

			DoDecompressTwelveBitData(destPtr,destSizeInBytes,decompressionBuffer,aSrceSizeInBytes);

			break;

		case ESixteenBitRLECompression:

			DoDecompressSixteenBitData(destPtr,destSizeInBytes,decompressionBuffer,aSrceSizeInBytes);

			break;

		case ETwentyFourBitRLECompression:

			DoDecompressTwentyFourBitData(destPtr,destSizeInBytes,decompressionBuffer,aSrceSizeInBytes);

			break;

		case EThirtyTwoUBitRLECompression:

			DoDecompressThirtyTwoUBitData(destPtr,destSizeInBytes,decompressionBuffer,aSrceSizeInBytes);

			break;

		case EThirtyTwoABitRLECompression:

			DoDecompressThirtyTwoABitData(destPtr,destSizeInBytes,decompressionBuffer,aSrceSizeInBytes);

			break;

		default:

			break;

			}

		CleanupStack::PopAndDestroy(); // decompressionBuffer

		return;

		}

	// not enough heap to pre-load the source bitmap

	switch (aCompression)

		{

	case EByteRLECompression:

		DoDecompressByteDataAltL(aStream,aSrceSizeInBytes,aBase);

		break;

	case ETwelveBitRLECompression:

		DoDecompressTwelveBitDataAltL(aStream,aSrceSizeInBytes,aBase);

		break;

	case ESixteenBitRLECompression:

		DoDecompressSixteenBitDataAltL(aStream,aSrceSizeInBytes,aBase);

		break;

	case ETwentyFourBitRLECompression:

		DoDecompressTwentyFourBitDataAltL(aStream,aSrceSizeInBytes,aBase);

		break;

	case EThirtyTwoUBitRLECompression:

		DoDecompressThirtyTwoUBitDataAltL(aStream,aSrceSizeInBytes,aBase);

		break;

	case EThirtyTwoABitRLECompression:

		DoDecompressThirtyTwoABitDataAltL(aStream,aSrceSizeInBytes,aBase);

		break;

	default:

		break;

		}

	}

void CBitwiseBitmap::DoDecompressByteData(TUint8* aDestBuffer,TInt aDestSize,TUint8* aSrceBuffer,TInt aSrceSize)

	{

	TUint8* srcePtr = aSrceBuffer;

	TUint8* destPtr = aDestBuffer;

	TUint8* srcePtrLimit = aSrceBuffer + aSrceSize;

	TUint8* destPtrLimit = aDestBuffer + aDestSize;

	while (srcePtr < srcePtrLimit && destPtr < destPtrLimit)

		{

		TInt8 count = *srcePtr++;

		if (count >= 0)

			{

			const TInt numBytes = Min(count + 1, destPtrLimit - destPtr);

			Mem::Fill(destPtr,numBytes,*srcePtr++);

			destPtr += numBytes;

			}

		else

			{

			const TInt numBytes = Min(-count, destPtrLimit - destPtr);

			Mem::Copy(destPtr,srcePtr,numBytes);

			srcePtr += numBytes;

			destPtr += numBytes;

			}

		}

	__ASSERT_DEBUG(srcePtr == srcePtrLimit && destPtr == destPtrLimit,Panic(EFbsBitmapDecompressionError));

	}

void CBitwiseBitmap::DoDecompressByteDataAltL(RReadStream& aStream,TInt aSrceSizeInBytes,TUint32* aBase)

	{

	TInt destSizeInBytes = iHeader.iSizeInPixels.iHeight * iByteWidth;

	TUint8* destPtr = (TUint8*)aBase;

	TUint8* destPtrLimit = destPtr + destSizeInBytes;

	while(aSrceSizeInBytes > 0 && destPtr < destPtrLimit)

		{

		TInt8 count = aStream.ReadInt8L();

		aSrceSizeInBytes--;

		if (count >= 0)

			{

			const TInt numBytes = Min(count + 1, destPtrLimit - destPtr);

			TUint8 value = aStream.ReadUint8L();

			aSrceSizeInBytes--;

			Mem::Fill(destPtr,numBytes,value);

			destPtr += numBytes;

			}

		else

			{

			const TInt numBytes = Min(-count, destPtrLimit - destPtr);

			aStream.ReadL(destPtr,numBytes);

			aSrceSizeInBytes -= numBytes;

			destPtr += numBytes;

			}

		}

	__ASSERT_DEBUG(aSrceSizeInBytes == 0 && destPtr == destPtrLimit,Panic(EFbsBitmapDecompressionError));

	}

/** Fills the 32bit pixels into the destination pointer

This method uses the concept of Duff's Device 

@param aDestPtr32 pointer to 32bit destination buffer.

@param aCount Number of 32bit pixels to be copied.

@param aValue32 32bit pixel data. */

void CBitwiseBitmap::BitmapFill32(TUint32* aDestPtr32, TInt aCount, TUint32 aValue32)

	{

	__ASSERT_DEBUG(aCount > 0, Panic(EFbsBitmapDecompressionError));

	if (aCount > 0)

		{ // for performance loop is unrolled, using "Duff's Device" pattern

		TInt blocksOf16 = aCount / 16;	// number of blocks of 16 full words to write

		// the first iteration writes 1 to 15 words

		switch (aCount & 0x0f)

			{ // note that case statements intentionally cascade

		case 0:

write16dblPixels:	// second and subsequent iterations always write 16 words

			--blocksOf16;

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 15:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 14:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 13:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 12:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 11:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 10:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 9:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 8:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 7:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 6:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 5:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 4:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 3:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 2:

			*aDestPtr32++ = aValue32;

			//coverity [fallthrough]

		case 1:

			*aDestPtr32++ = aValue32;

			}

		if (blocksOf16 > 0)

			{

			goto write16dblPixels;

			}

		}

	}

/** Fills the 16bit pixels into the destination pointer

This method uses the concept of Duff's Device 

@param aDestPtr16 pointer to 16bit destination buffer.

@param aCount Number of 16bit pixels to be copied.

@param aValue16 16bit pixel data. */

inline void CBitwiseBitmap::BitmapFill16(TUint16* aDestPtr16, TInt aCount, TUint16 aValue16)

	{

	// Call the 32-bit fill method if there at least 8 pixels to fill

	if (aCount >= 8)

		{

		// first pixel is on half word address?

		if (reinterpret_cast<TUint32>(aDestPtr16) & 2) 

			{

			*aDestPtr16++ = aValue16; 

			--aCount; 

			} 

		// destPtr16 is now full Word aligned

		const TInt countDoublePixels = aCount / 2;

		TUint32* destPtr32 = (TUint32*) aDestPtr16;

		BitmapFill32(destPtr32, countDoublePixels, (aValue16 << 16) | aValue16);

		aCount -= countDoublePixels * 2;

		if (aCount == 1)

			{ // last pixel is on a half-word

			aDestPtr16 += countDoublePixels * 2;

			*aDestPtr16++ = aValue16; 

			}

		}

	else

		{ // less than 8 pixels to fill

		switch (aCount)

			{ // note that case statements intentionally cascade

		case 7:

			*aDestPtr16++ = aValue16; 

		case 6:

			*aDestPtr16++ = aValue16; 

		case 5:

			*aDestPtr16++ = aValue16; 

		case 4:

			*aDestPtr16++ = aValue16; 

		case 3:

			*aDestPtr16++ = aValue16; 

		case 2:

			*aDestPtr16++ = aValue16; 

		case 1:

			*aDestPtr16++ = aValue16; 

		case 0: // nothing to do

			;

			}

		}

	}

void CBitwiseBitmap::DoDecompressTwelveBitData(TUint8* aDestBuffer,TInt aDestSize,TUint8* aSrceBuffer,TInt aSrceSize)

	{

	TUint16* srcePtr = (TUint16*)aSrceBuffer;

	TUint16* destPtr = (TUint16*)aDestBuffer;

	TUint16* srcePtrLimit = srcePtr + (aSrceSize / 2);

	TUint16* destPtrLimit = destPtr + (aDestSize / 2);

	while (srcePtr < srcePtrLimit && destPtr < destPtrLimit)

		{

		TUint16 value = *srcePtr++;

		TInt count = Min(value >> 12, destPtrLimit - destPtr);

		value &= 0x0fff;

		while (count >= 0)

			{

			*destPtr++ = value;

			count--;

			}

		}

	__ASSERT_DEBUG(srcePtr == srcePtrLimit && destPtr == destPtrLimit,Panic(EFbsBitmapDecompressionError));

	}

void CBitwiseBitmap::DoDecompressTwelveBitDataAltL(RReadStream& aStream,TInt aSrceSizeInBytes,TUint32* aBase)

	{

	TInt destSizeInBytes = iHeader.iSizeInPixels.iHeight * iByteWidth;

	TUint16* destPtr = (TUint16*)aBase;

	TUint16* destPtrLimit = destPtr + (destSizeInBytes / 2);

	while(aSrceSizeInBytes > 0 && destPtr < destPtrLimit)

		{

		TUint16 value = aStream.ReadUint16L();

		TInt count = Min(value >> 12, destPtrLimit - destPtr);

		value &= 0x0fff;

		aSrceSizeInBytes -= 2;

		while (count >= 0)

			{

			*destPtr++ = value;

			count--;

			}

		}

	__ASSERT_DEBUG(aSrceSizeInBytes == 0 && destPtr == destPtrLimit,Panic(EFbsBitmapDecompressionError));

	}

/** The function decodes 24-bit compressed buffer to the 16-bit stream with unused top bytes by using RLE compression algorithm*/

void CBitwiseBitmap::DoDecompressSixteenBitData(TUint8* aDestBuffer,TInt aDestSize,TUint8* aSrceBuffer,TInt aSrceSize)

	{

	__ASSERT_DEBUG((reinterpret_cast<TUint32>(aDestBuffer) & 0x2)==0,Panic(EFbsBitmapDecompressionError)); // make sure the start address is half-word aligned

	__ASSERT_DEBUG((aDestSize & 0x2)==0,Panic(EFbsBitmapDecompressionError)); // make sure the start address is half-word aligned

	TUint8* srcePtr8 = aSrceBuffer; // pointer to compressed source Byte(8-bit) stream 

	TUint16* destPtr16 = reinterpret_cast<TUint16*>(aDestBuffer); //pointer to uncompressed destination HalfWord(16-bit) pixel stream

	TUint8* srcePtrLimit8 = aSrceBuffer + aSrceSize; //maximum number of compressed source bytes

	TUint16* destPtrLimit16 = reinterpret_cast<TUint16*>(aDestBuffer + aDestSize); //maximum number of uncompressed destination pixel stream

	const TInt KPixelSize = 2; //number of bytes of the source stream that is to be considered as one Pixel

	while (srcePtr8 < srcePtrLimit8 && destPtr16 < destPtrLimit16)

		{

		TInt8 count = *srcePtr8++; //number of pixels to be retrieved from the source stream

		if (count >= 0) //repeating number of pixels

			{

			const TInt numPixels = 1 + Min(count, (destPtrLimit16 - destPtr16));

			const TUint8 lowByte = *srcePtr8++;

			const TUint8 highByte = *srcePtr8++;

			const TUint16 pixel = highByte<<8 | lowByte; //Pixel buffer which needs to be stored in destPtr16

			BitmapFill16(destPtr16, numPixels, pixel);

			destPtr16 += numPixels;

			}

		else

			{

			const TInt numPixels = Min(-count, destPtrLimit16 - destPtr16); //number of pixels to be copied

			const TInt numBytes = numPixels * KPixelSize; //number of bytes needs to be retrieved from the srcePtr

			Mem::Copy(destPtr16, srcePtr8, numBytes); // copy bytes

			srcePtr8 += numBytes; //incrementing the srcePtr by number of bytes

			destPtr16 += numPixels; //incrementing the destPtr16 by number of pixels

			}

		}

	__ASSERT_DEBUG(srcePtr8 == srcePtrLimit8 && destPtr16 == destPtrLimit16, Panic(EFbsBitmapDecompressionError));

	}

/** The alternative decoding function which decompresses 24-bit buffer to the 16-bit stream with unused top bytes 

 	by using RLE compression algorithm. The function is used under low memory conditions. */

void CBitwiseBitmap::DoDecompressSixteenBitDataAltL(RReadStream& aStream,TInt aSrceSizeInBytes,TUint32* aBase)

	{

	__ASSERT_DEBUG((reinterpret_cast<TUint32>(aBase) & 0x2)==0,Panic(EFbsBitmapDecompressionError)); // make sure the start address is half-word aligned

	TInt destSizeInPixels = (iHeader.iSizeInPixels.iHeight * iByteWidth); //size of destination Byte pixel buffers

	destSizeInPixels >>= 1; //dividing by two, to get size of destination interms of Halfword pixel buffers

	TUint16* destPtr16 = reinterpret_cast<TUint16*>(aBase); //pointer to uncompressed destination HalfWord(16-bit) pixel stream

	TUint16* destPtrLimit16 = destPtr16 + destSizeInPixels; //maximum number of compressed source bytes

	const TInt KPixelSize = 2; //number of bytes of the source stream that is to be considered as one Pixel

	while(aSrceSizeInBytes > 0 && destPtr16 < destPtrLimit16)

		{

		TInt8 count = aStream.ReadInt8L(); //number of pixels to be retrieved from the source stream

		aSrceSizeInBytes--; //One byte from source stream read, hence reduce size by one Byte

		if (count >= 0)

			{

			const TInt numPixels = 1 + Min(count, (destPtrLimit16 - destPtr16));

			const TUint16 pixel = aStream.ReadUint16L(); //Pixel buffer which needs to be stored in destPtr16

			aSrceSizeInBytes -= KPixelSize; //Two bytes (Halfword pixel) read, reduce size by two Bytes

			BitmapFill16(destPtr16, numPixels, pixel);

			destPtr16 += numPixels;

			}

		else

			{

			const TInt numPixels = Min(-count, destPtrLimit16 - destPtr16); //number of pixels to be stored into destPtr16

			const TInt numBytes = numPixels * KPixelSize; //number of bytes needs to be retrieved from the srcePtr

			aStream.ReadL(destPtr16, numPixels); //read TUint16's

			aSrceSizeInBytes -= numBytes; //two-byte (halfword) pixel buffers read, reduce by number of bytes

			destPtr16 += numPixels; //incrementing the destPtr16 by number of pixels

			}

		}

	__ASSERT_DEBUG(aSrceSizeInBytes == 0 && destPtr16 == destPtrLimit16, Panic(EFbsBitmapDecompressionError));

	}

void CBitwiseBitmap::DoDecompressTwentyFourBitData(TUint8* aDestBuffer,TInt aDestSize,TUint8* aSrceBuffer,TInt aSrceSize)

	{

	TUint8* srcePtr = aSrceBuffer;

	TUint8* destPtr = aDestBuffer;

	TUint8* srcePtrLimit = aSrceBuffer + aSrceSize;

	TUint8* destPtrLimit = aDestBuffer + aDestSize;

	while (srcePtr < srcePtrLimit && destPtr < destPtrLimit)

		{

		TInt8 count = *srcePtr++;

		if (count >= 0)

			{

			count = Min(count, (destPtrLimit - destPtr) / 3);

			TUint8 component1 = *srcePtr++;

			TUint8 component2 = *srcePtr++;

			TUint8 component3 = *srcePtr++;

			while (count >= 0)

				{

				*destPtr++ = component1;

				*destPtr++ = component2;

				*destPtr++ = component3;

				count--;

				}

			}

		else

			{

			const TInt numBytes = Min(count * -3, destPtrLimit - destPtr);

			Mem::Copy(destPtr,srcePtr,numBytes);

			srcePtr += numBytes;

			destPtr += numBytes;

			}

		}

	__ASSERT_DEBUG(srcePtr == srcePtrLimit && destPtr == destPtrLimit,Panic(EFbsBitmapDecompressionError));

	}

void CBitwiseBitmap::DoDecompressTwentyFourBitDataAltL(RReadStream& aStream,TInt aSrceSizeInBytes,TUint32* aBase)

	{

	TInt destSizeInBytes = iHeader.iSizeInPixels.iHeight * iByteWidth;

	TUint8* destPtr = (TUint8*)aBase;

	TUint8* destPtrLimit = destPtr + destSizeInBytes;

	while(aSrceSizeInBytes > 0 && destPtr < destPtrLimit)

		{

		TInt8 count = aStream.ReadInt8L();

		aSrceSizeInBytes--;

		if (count >= 0)

			{

			count = Min(count, (destPtrLimit - destPtr) / 3);

			TUint8 component1 = aStream.ReadUint8L();

			TUint8 component2 = aStream.ReadUint8L();

			TUint8 component3 = aStream.ReadUint8L();

			aSrceSizeInBytes -= 3;

			while (count >= 0)

				{

				*destPtr++ = component1;

				*destPtr++ = component2;

				*destPtr++ = component3;

				count--;

				}

			}

		else

			{

			const TInt numBytes = Min(count * -3, destPtrLimit - destPtr);

			aStream.ReadL(destPtr, numBytes);

			aSrceSizeInBytes -= numBytes;

			destPtr += numBytes;

			}

		}

	__ASSERT_DEBUG(aSrceSizeInBytes == 0 && destPtr == destPtrLimit,Panic(EFbsBitmapDecompressionError));

	}

/** The function decodes 24-bit compressed buffer to the 32-bit stream with unused top bytes by using RLE compression algorithm*/

void CBitwiseBitmap::DoDecompressThirtyTwoUBitData(TUint8* aDestBuffer,TInt aDestSize,TUint8* aSrceBuffer,TInt aSrceSize)

	{

	__ASSERT_DEBUG((reinterpret_cast<TUint32>(aDestBuffer) & 0x3)==0,Panic(EFbsBitmapDecompressionError)); // make sure the start address is word aligned

	__ASSERT_DEBUG((aDestSize & 0x3)==0,Panic(EFbsBitmapDecompressionError)); // make sure the size is whole no of pixels

	TUint8* srcePtr8 = aSrceBuffer;

	TUint8* srcePtrLimit8 = aSrceBuffer + aSrceSize;

	TUint32* destPtr32 = reinterpret_cast<TUint32*>(aDestBuffer);

	TUint32* destPtrLimit32 = reinterpret_cast<TUint32*>(aDestBuffer + aDestSize);

	while (srcePtr8 < srcePtrLimit8 && destPtr32 < destPtrLimit32)

		{

		TInt8 count = *srcePtr8++; // important to read into a byte variable

		if (count >= 0) //repeating pixel buffer

			{

			count  = Min(count, (destPtrLimit32 - destPtr32));

			const TUint8 component1 = *srcePtr8++;

			const TUint8 component2 = *srcePtr8++;

			const TUint8 component3 = *srcePtr8++;

			const TUint32 pixel = 0xff000000 | (component3<<16) | (component2<<8) | component1;

			// for performance loop is unrolled, using "Duff's Device" pattern

			TInt blocksOf16 = (count >> 4);	// number of blocks of 16 full words to write

			// the first iteration writes 1 to 15 words

			switch (count & 0x0f)

				{ // note that case statements intentionally cascade

			case 15:

				do {	// second and subsequent iterations always write 16 words

				*destPtr32++ = pixel;

			case 14:

				*destPtr32++ = pixel;

			case 13:

				*destPtr32++ = pixel;

			case 12:

				*destPtr32++ = pixel;

			case 11:

				*destPtr32++ = pixel;

			case 10:

				*destPtr32++ = pixel;

			case 9:

				*destPtr32++ = pixel;

			case 8:

				*destPtr32++ = pixel;

			case 7:

				*destPtr32++ = pixel;

			case 6:

				*destPtr32++ = pixel;

			case 5:

				*destPtr32++ = pixel;

			case 4:

				*destPtr32++ = pixel;

			case 3: