// 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 <fbs.h>

#include <bitmap.h>

#include <graphicsaccelerator.h>

#include <graphics/lookuptable.h>

#include <graphics/blendingalgorithms.h>

#include <graphics/bitmapuid.h>

#include "UTILS.H"

#include <s32mem.h>

#include "ShiftedFileStore.h"

#include "CompileAssert.h"

#include "CompressionBookmark.h"

#include "BitmapCompr.h"

#include "palette.h"

#include "fbsrasterizer.h"

#include "bitmap.inl"

#include "BitwiseBitmap.inl"

#include "bitmapconst.h"

#ifdef __ARMCC__

#pragma arm

#pragma O3

#pragma Otime

#endif

const TInt KMaxPixelSize = KMaxTInt / 4; // Maximum pixel size to avoid some overflow problems

const TUint KMaxByteSize = TUint(KMaxTInt / 2); // Maximum byte size to avoid other overflow problems

enum

    {

    EFirstTime = 65536

    };

GLREF_C void Panic(TFbsPanic aPanic);

#define COLOR_VALUE(ScanLinePtr, XPos) (*((ScanLinePtr) + ((XPos) >> 5)) & ( 1 << ((XPos) & 0x1F)))

EXPORT_C void CBitwiseBitmap::operator delete(TAny *aThis)

	{

	if (((CBitwiseBitmap*)aThis)->iHeap)

		((CBitwiseBitmap*)aThis)->iHeap->Free(aThis);

	}

EXPORT_C CBitwiseBitmap::CBitwiseBitmap(RHeap* aHeap,CChunkPile* aPile):

	iUid(KCBitwiseBitmapUid),

	iSettings(ENone),

	iHeap(aHeap),

	iPile(aPile),

	iByteWidth(0),

	iDataOffset(0),

	iIsCompressedInRAM(EFalse)

	{

	//CBitwiseBitmap size can't be changed! If the bitmap is ROM based,

	//then CBitwiseBitmap object is not created, but CBitwiseBitmap pointer is

	//used to access ROM based bitmap data.

	//The following line is a part of CFbsBitmap::DoLoad(...) source code:

	//iRomPointer=(CBitwiseBitmap*)(((TUint8*)rompointer)+offset);

	//We have to preserve data compatibility with already existing ROM bitmaps.

	enum

		{

		KCBitwiseBitmapSize = 72

		};

	COMPILE_TIME_ASSERT(sizeof(CBitwiseBitmap) == KCBitwiseBitmapSize);

#ifdef SYMBIAN_DEBUG_FBS_LOCKHEAP

	Extra()->iLockCount = 0;

	Extra()->iThreadId = TThreadId(KNullThreadId);

#endif

	Extra()->iTouchCount = 0;

	Extra()->iSerialNumber = 0;

	}

EXPORT_C CBitwiseBitmap::~CBitwiseBitmap()

	{

	Reset();

	}

EXPORT_C void CBitwiseBitmap::Reset()

	{

	if (iDataOffset)

		{

		if(iUid.iUid==KCBitwiseBitmapHardwareUid.iUid)

			{

			RHardwareBitmap hwb(iDataOffset);	// iDataOffset = handle for hardware bitmap

			hwb.Destroy();

			}

		else

			if (iPile) iPile->Free(DataAddress());

		}

	iUid.iUid = KCBitwiseBitmapUid.iUid;

	iDataOffset=0;

	iSettings.SetDisplayModes(ENone);

	iByteWidth=0;

	iHeader=SEpocBitmapHeader();

	iIsCompressedInRAM=EFalse;

	}

EXPORT_C TUid CBitwiseBitmap::Uid() const

	{

	return(iUid);

	}

EXPORT_C TInt CBitwiseBitmap::Construct(const TSize& aSize,TDisplayMode aDispMode,TUid aCreatorUid)

	{

	if (iHeap == NULL || iPile == NULL)

		return KErrNoMemory;

	if (aSize.iWidth > KMaxPixelSize || aSize.iHeight > KMaxPixelSize)

		return KErrTooBig;

	TUint8* data = NULL;

	Reset();

	iSettings.SetDisplayModes(aDispMode);

	iByteWidth = ByteWidth(aSize.iWidth,aDispMode);

	TInt64 hugeDataSize = TInt64(aSize.iHeight) * TInt64(iByteWidth);

	if (I64HIGH(hugeDataSize) != 0 || I64LOW(hugeDataSize) > KMaxByteSize)

		return KErrTooBig;

	TInt dataSize = I64LOW(hugeDataSize);

	iHeader.iBitmapSize = sizeof(SEpocBitmapHeader) + dataSize;

	iHeader.iStructSize = sizeof(SEpocBitmapHeader);

	iHeader.iSizeInPixels = aSize;

	iHeader.iSizeInTwips = TSize(0,0);

	iHeader.iBitsPerPixel = Bpp(aDispMode);

	iHeader.iColor = IsColor(aDispMode);

	iHeader.iPaletteEntries = 0;

	iHeader.iCompression = ENoBitmapCompression;

	if (aSize.iHeight && aSize.iWidth)

		{

		if(aCreatorUid!=KUidCFbsBitmapCreation)

			{

			RHardwareBitmap hwb;

			TAcceleratedBitmapInfo info;

			TInt ret = hwb.Create(aDispMode,aSize,aCreatorUid);

			if(ret==KErrNone)

				ret = hwb.GetInfo(info);

			if(ret!=KErrNone)

				{

				Reset();

				return ret;

				}

			iSettings.SetVolatileBitmap();

			data = info.iAddress;

			dataSize = info.iLinePitch*info.iSize.iHeight;

			__ASSERT_DEBUG(info.iLinePitch >= iByteWidth, ::Panic(EFbsHardwareBitmapError));

			iByteWidth = info.iLinePitch;

			iDataOffset = hwb.iHandle;	// iDataOffset = handle for hardware bitmap

			iUid.iUid = KCBitwiseBitmapHardwareUid.iUid;

#ifdef SYMBIAN_DISABLE_HARDWARE_BITMAP_WHITEFILL

			return KErrNone;

#endif

			}

		else

			{

			data = iPile->Alloc(dataSize);

			iDataOffset = data - iPile->ChunkBase();

			}

		if (!data)

			{

			iDataOffset=0;

			Reset();

			return(KErrNoMemory);	// no memory exit point

			}

		}

	if (dataSize < KMaxLargeBitmapAlloc || aDispMode == EColor4K || iUid.iUid == KCBitwiseBitmapHardwareUid.iUid)

		{

		WhiteFill(data,dataSize,aDispMode);

		}

	return KErrNone;	// success exit point

	}

EXPORT_C TInt CBitwiseBitmap::ConstructExtended(const TSize& aSize, TDisplayMode aDispMode, TUid aType, TInt aDataSize)

	{

	if (iHeap == NULL || iPile == NULL)

		return KErrNoMemory;

	if (aSize.iWidth > KMaxPixelSize || aSize.iHeight > KMaxPixelSize)

		return KErrTooBig;

	if (aType.iUid == KCBitwiseBitmapUid.iUid || aType.iUid == KCBitwiseBitmapHardwareUid.iUid)

		return KErrArgument; // make sure the extended bitmap type is not one of the standard types

	if (aDataSize > KMaxByteSize)

		return KErrTooBig;

	Reset();

	iUid = aType;

	iSettings.SetDisplayModes(aDispMode);

	iByteWidth = ByteWidth(aSize.iWidth, aDispMode);

	iHeader.iBitmapSize = sizeof(SEpocBitmapHeader) + aDataSize;

	iHeader.iStructSize = sizeof(SEpocBitmapHeader);

	iHeader.iSizeInPixels = aSize;

	iHeader.iSizeInTwips = TSize(0,0);

	iHeader.iBitsPerPixel = Bpp(aDispMode);

	iHeader.iColor = IsColor(aDispMode);

	iHeader.iPaletteEntries = 0;

	iHeader.iCompression = EProprietaryCompression;

	TUint8* data = iPile->Alloc(aDataSize);

	if (!data)

		{

		Reset();

		return KErrNoMemory;

		}

	iDataOffset = data - iPile->ChunkBase();

	return KErrNone;

	}

EXPORT_C void CBitwiseBitmap::ConstructL(RFs& aFs,const TDesC& aFilename,TInt32 aId,TUint aFileOffset)

	{

	//If aFileOffset != 0 then aFilename is a file with an embedded MBM file section at the end.

	//The implementation uses the fact that mbm files are implemented as

	//filestores and stream ID is actually the offset from the beginning of the filestore.

	//If stream ID changes its meaning in the future -

	//the method implementation has to be reviewed and changed too.

	User::LeaveIfNull(iHeap);

	User::LeaveIfNull(iPile);

	TUint fileMode = EFileRead;

	if(aFileOffset != 0) //This is a file with an embedded MBM file section at the end.

		fileMode |= EFileShareReadersOnly;

	CShiftedFileStore* filestore = CShiftedFileStore::OpenLC(aFs,aFilename,fileMode,aFileOffset);

	TStreamId streamid = filestore->Root();

	//TStreamId is the offset from the beggining of the file.

	//Obviously, if the bitmap file section is at the middle of the physical file,

	//we should add aFileOffset value to TStreamId value and use it.

	TStreamId streamid2(streamid.Value() + aFileOffset);

	RStoreReadStream readstream;

	readstream.OpenLC(*filestore,streamid2);

	TInt numbitmaps = readstream.ReadInt32L();

	if (aId < 0 || aId >= numbitmaps)

		User::Leave(KErrEof);

	TStreamId bmpstreamid;

	bmpstreamid.InternalizeL(readstream);

	TStreamId bmpstreamid2(bmpstreamid.Value() + aFileOffset);

	for (TInt count = 0; count < aId; count++)

		{

		bmpstreamid2.InternalizeL(readstream);

		bmpstreamid2 = TStreamId(bmpstreamid2.Value() + aFileOffset);

		}

	CleanupStack::PopAndDestroy();

	RStoreReadStream bmpstream;

	bmpstream.OpenLC(*filestore,bmpstreamid2);

	InternalizeL(bmpstream);

	CleanupStack::PopAndDestroy(2);

	}

EXPORT_C void CBitwiseBitmap::ConstructL(RFile& aFile,TInt32 aId,TUint aFileOffset)

	{

	//If aFileOffset != 0 then aFilename is a file with an embedded MBM file section at the end.

	//The implementation uses the fact that mbm files are implemented as

	//filestores and stream ID is actually the offset from the beginning of the filestore.

	//If stream ID changes its meaning in the future -

	//the method implementation has to be reviewed and changed too.

	User::LeaveIfNull(iHeap);

	User::LeaveIfNull(iPile);

	CShiftedFileStore* filestore = CShiftedFileStore::FromL(aFile,aFileOffset);

	CleanupStack::PushL(filestore);

	TStreamId streamid = filestore->Root();

	//TStreamId is the offset from the beggining of the file.

	//Obviously, if the bitmap file section is at the middle of the physical file,

	//we should add aFileOffset value to TStreamId value and use it.

	TStreamId streamid2(streamid.Value() + aFileOffset);

	RStoreReadStream readstream;

	readstream.OpenLC(*filestore,streamid2);

	TInt numbitmaps = readstream.ReadInt32L();

	if (aId < 0 || aId >= numbitmaps)

		User::Leave(KErrEof);

	//Retrieving the streamid of the bitmap of that id from the file

	TStreamId bmpstreamid;

	bmpstreamid.InternalizeL(readstream);

	TStreamId bmpstreamid2(bmpstreamid.Value() + aFileOffset);

	for (TInt count = 0; count < aId; count++)

		{

		bmpstreamid2.InternalizeL(readstream);

		bmpstreamid2 = TStreamId(bmpstreamid2.Value() + aFileOffset);

		}

	//Use the streamid found to initialize the bitmap raw data in the memory

	CleanupStack::PopAndDestroy(&readstream);

	RStoreReadStream bmpstream;

	bmpstream.OpenLC(*filestore,bmpstreamid2);

	InternalizeL(bmpstream);

	CleanupStack::PopAndDestroy(2,filestore);

	}

EXPORT_C void CBitwiseBitmap::ConstructL(CShiftedFileStore* aFileStore,TStreamId aStreamId)

	{

	User::LeaveIfNull(iHeap);

	User::LeaveIfNull(iPile);

	RStoreReadStream bmpstream;

	bmpstream.OpenLC(*aFileStore,aStreamId);

	InternalizeL(bmpstream);

	CleanupStack::PopAndDestroy();

	}

EXPORT_C TInt CBitwiseBitmap::CopyData(const CBitwiseBitmap& aSourceBitmap)

	{

	__ASSERT_DEBUG(iHeap && iPile, ::Panic(EFbsPanicBitmapDataCopy));

	__ASSERT_DEBUG(!iIsCompressedInRAM, ::Panic(EFbsPanicBitmapDataCopy));

	__ASSERT_DEBUG(iUid.iUid == KCBitwiseBitmapUid.iUid, ::Panic(EFbsPanicBitmapDataCopy));

	if (aSourceBitmap.iUid.iUid != KCBitwiseBitmapUid.iUid)

		return KErrNotSupported;

	const TDisplayMode displayMode = aSourceBitmap.iSettings.CurrentDisplayMode();

	__ASSERT_DEBUG(iSettings.CurrentDisplayMode() == displayMode, ::Panic(EFbsPanicBitmapDataCopy));

	if (aSourceBitmap.iHeader.iSizeInPixels.iWidth > 0)

		iHeader.iSizeInTwips.iWidth = (aSourceBitmap.iHeader.iSizeInTwips.iWidth * iHeader.iSizeInPixels.iWidth)

			/ aSourceBitmap.iHeader.iSizeInPixels.iWidth;

	if (aSourceBitmap.iHeader.iSizeInPixels.iHeight > 0)

		iHeader.iSizeInTwips.iHeight = (aSourceBitmap.iHeader.iSizeInTwips.iHeight * iHeader.iSizeInPixels.iHeight)

			/ aSourceBitmap.iHeader.iSizeInPixels.iHeight;

	TUint32* destBase = DataAddress();

	TUint32* srcBase = aSourceBitmap.DataAddress();

	if (!destBase || !srcBase)

		return KErrNone;

	TInt minPixelHeight = Min(iHeader.iSizeInPixels.iHeight, aSourceBitmap.iHeader.iSizeInPixels.iHeight);

	if (aSourceBitmap.iIsCompressedInRAM)

		{

		TUint8* dest = (TUint8*)destBase;

		TInt minPixelWidth = Min(iHeader.iSizeInPixels.iWidth, aSourceBitmap.iHeader.iSizeInPixels.iWidth);

		TPtr8 pDest(dest, iByteWidth, iByteWidth);

		TPoint pt(0, 0);

		TPoint ditherOffset(0, 0);

		TLineScanningPosition scanPos(srcBase);

		scanPos.iScanLineBuffer = HBufC8::New(aSourceBitmap.iByteWidth + 4);

		if (!scanPos.iScanLineBuffer)

			return KErrNoMemory;

		for (TInt row = 0; row < minPixelHeight; ++row)

			{

			pDest.Set(dest, iByteWidth, iByteWidth);

			pt.iY = row;

			aSourceBitmap.GetScanLine(pDest, pt, minPixelWidth, EFalse, ditherOffset, displayMode, srcBase, scanPos);

			dest += iByteWidth;

			}

		delete scanPos.iScanLineBuffer;

		}

	else

		{

		TUint8* dest = (TUint8*)destBase;

		TUint8* src = (TUint8*)srcBase;

		TInt minByteWidth = Min(iByteWidth, aSourceBitmap.iByteWidth);

		for(TInt row = 0; row < minPixelHeight; ++row)

			{

			Mem::Copy(dest, src, minByteWidth);

			dest += iByteWidth;

			src += aSourceBitmap.iByteWidth;

			}

		}

	if (iHeader.iSizeInPixels.iWidth > aSourceBitmap.iHeader.iSizeInPixels.iWidth)

		{

		TInt extraBits = (aSourceBitmap.iHeader.iSizeInPixels.iWidth * aSourceBitmap.iHeader.iBitsPerPixel) & 31;

		if (extraBits > 0)

			{

			TUint32 mask = KMaxTUint32;

			mask <<= extraBits;

			TInt destWordWidth = iByteWidth >> 2;

			TInt srcWordWidth = aSourceBitmap.iByteWidth >> 2;

			TUint32* maskAddress = destBase + srcWordWidth - 1;

			for (TInt row = 0; row < minPixelHeight; ++row)

				{

				*maskAddress |= mask;

				maskAddress += destWordWidth;

				}

			}

		}

	return KErrNone;

	}

EXPORT_C void CBitwiseBitmap::ExternalizeL(RWriteStream& aStream,const CFbsBitmap& aHandleBitmap) const

	{

	ExternalizeRectangleL(aStream,iHeader.iSizeInPixels,aHandleBitmap);

	}

EXPORT_C void CBitwiseBitmap::ExternalizeRectangleL(RWriteStream& aStream,const TRect& aRect,const CFbsBitmap& aHandleBitmap) const

	{

	if (aRect.IsEmpty())

		User::Leave(KErrArgument);

	// the bitmap must have been already prepared for data access

	if (aHandleBitmap.iUseCount == 0)

		User::Leave(KErrArgument);

	// If the bitmap is palette-compressed in RAM externalisation is currently not supported

	// Externalisation of extended bitmaps is currently not supported either

	if (iHeader.iCompression == EGenericPaletteCompression || iHeader.iCompression == EProprietaryCompression)

		User::Leave(KErrNotSupported);

	const TRect bitmapRect(iHeader.iSizeInPixels);

	TRect sourceRect(aRect);

	if (!sourceRect.Intersects(bitmapRect))

		User::Leave(KErrTooBig);

	sourceRect.Intersection(bitmapRect);

	TDisplayMode displayMode = iSettings.CurrentDisplayMode();

	const TInt scanLineByteLength = CBitwiseBitmap::ByteWidth(sourceRect.Width(),displayMode);

	const TInt rectByteSize = sourceRect.Height() * scanLineByteLength;

	TUint8* buffer = (TUint8*)User::AllocLC(scanLineByteLength);

	TPtr8 scanline(buffer,scanLineByteLength,scanLineByteLength);

	scanline.Fill(0xff);

	const TPoint zeroPoint;

	TInt compressedSize = 0;

	TInt row;

	for (row = sourceRect.iTl.iY; row < sourceRect.iBr.iY; row++)

		{

		GetScanLine(scanline,TPoint(sourceRect.iTl.iX,row),sourceRect.Width(),EFalse,zeroPoint,displayMode,aHandleBitmap.DataAddress());

		compressedSize += SizeOfDataCompressed(buffer,scanLineByteLength);

		}

	TBool compress = EFalse;

	if(compressedSize > 0)

		{

		compress = (displayMode == EColor4K) || (compressedSize < (rectByteSize >> 1) + (rectByteSize >> 2));

		}

	aStream.WriteInt32L(sizeof(SEpocBitmapHeader) + ((compress) ? compressedSize : rectByteSize));

	aStream.WriteInt32L(iHeader.iStructSize);

	aStream.WriteInt32L(sourceRect.Width());

	aStream.WriteInt32L(sourceRect.Height());

	aStream.WriteInt32L(HorizontalPixelsToTwips(sourceRect.Width()));

	aStream.WriteInt32L(VerticalPixelsToTwips(sourceRect.Height()));

	aStream.WriteInt32L(iHeader.iBitsPerPixel);

	aStream.WriteUint32L(iHeader.iColor);

	aStream.WriteInt32L(0);

	aStream.WriteUint32L(compress ? CompressionType(iHeader.iBitsPerPixel, iHeader.iColor) : ENoBitmapCompression);

	for (row = sourceRect.iTl.iY; row < sourceRect.iBr.iY; row++)

		{

		GetScanLine(scanline,TPoint(sourceRect.iTl.iX,row),sourceRect.Width(),EFalse,zeroPoint,displayMode,aHandleBitmap.DataAddress());

		if (!compress)

			aStream.WriteL(buffer,scanLineByteLength);

		else

			DoExternalizeDataCompressedL(aStream,buffer,scanLineByteLength);

		}

	CleanupStack::PopAndDestroy(); // buffer

	}

EXPORT_C void CBitwiseBitmap::InternalizeHeaderL(RReadStream& aStream,SEpocBitmapHeader& aHeader)

	{

	aHeader.iBitmapSize=aStream.ReadInt32L();

	aHeader.iStructSize=aStream.ReadInt32L();

	if (aHeader.iStructSize!=sizeof(SEpocBitmapHeader)) User::Leave(KErrCorrupt);

	aHeader.iSizeInPixels.iWidth=aStream.ReadInt32L();

	aHeader.iSizeInPixels.iHeight=aStream.ReadInt32L();

	aHeader.iSizeInTwips.iWidth=aStream.ReadInt32L();

	aHeader.iSizeInTwips.iHeight=aStream.ReadInt32L();

	aHeader.iBitsPerPixel=aStream.ReadInt32L();

	aHeader.iColor=(TInt)aStream.ReadUint32L();

	aHeader.iPaletteEntries=aStream.ReadInt32L();

	if (aHeader.iPaletteEntries != 0)

		{

		//Palettes are not supported.

		User::Leave(KErrNotSupported);

		}

	aHeader.iCompression=(TBitmapfileCompression)aStream.ReadUint32L();

	CheckHeaderIsValidL(aHeader);

	}

void CBitwiseBitmap::CheckHeaderIsValidL(const SEpocBitmapHeader& aHeader)	

	{

	//These fields are signed in the structure?

	TInt bitmapSize = aHeader.iBitmapSize;

	TInt imageHeightPix = aHeader.iSizeInPixels.iHeight;

	TInt imageWidthPix = aHeader.iSizeInPixels.iWidth;

	TInt bitsPerPixel = aHeader.iBitsPerPixel;

	TInt compression = aHeader.iCompression;

	TInt colour = aHeader.iColor;

	TBool corruptFlag = EFalse;

	//Need to copy the values from the structure

	TDisplayMode equivalentMode = CBitwiseBitmap::DisplayMode(aHeader.iBitsPerPixel,aHeader.iColor);

	if (equivalentMode == ENone)

		{

		User::Leave(KErrNotSupported);	

		}

	if(aHeader.iColor < 0)

		 {

		 corruptFlag = ETrue;

		 } 

	 	//easieast way to check if compression type is appropriate is to ask the compressor 

	if (compression && compression!= CBitwiseBitmap::CompressionType(bitsPerPixel,colour))

		{

		corruptFlag = ETrue;

		}

	//danger when using CBitwiseBitmap is they could panic for bad input...

	if (imageHeightPix <= 0 || imageWidthPix <= 0 || bitsPerPixel <= 0)

		{

		corruptFlag = ETrue;

		}

	const TInt KMeg = 1024 * 1024;

	//Test that scanline bytes calculation won't overflow.

	TInt bytesPerPack;	// pixel size in memory

	TInt bytesPerCompression;	// compressed unit data size

    User::LeaveIfError(CompressedFormatInfo(equivalentMode, bytesPerPack, bytesPerCompression));

	if (imageWidthPix > 2047 * KMeg / bytesPerPack)

		{

		corruptFlag = ETrue;

		}

	TInt uncompressedWidthBytes = CBitwiseBitmap::ByteWidth(imageWidthPix,equivalentMode);	//we know this won't overflow, now.

	//use top set bit indexes of 32 bit integer values to estimate when W*H multiply will overflow

	TInt exponentWidth = 0;

	TInt exponentHeight = 0;

	if (uncompressedWidthBytes & 0xffff0000)

		{

		exponentWidth += 16;

		}

	if (imageHeightPix & 0xffff0000)

		{