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

#include <bitmap.h>

#include <graphicsaccelerator.h>

#include <fbs.h>

#include <graphics/bitmapuid.h>

#include "fbsdefs.h"

#include "UTILS.H"

#include "fbshelper.h"

#include "fbsrasterizer.h"

#include "BitwiseBitmap.inl"

#include "fbsmessage.h"

#include "bitmapconst.h"

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

const TInt KMaxBitmapHandleBufferSize = KNumBytesPerBitmapHandle * 2000; 	// Maximum size of buffer to store all bitmap handles.

GLREF_C void Panic(TFbsPanic aPanic);

//If we have to handle RAM located file with an embedded ROM mbm file section - 

//KRomMBMInRamRSC should be ETrue.

//If it is not allowed to do that - KRomMBMInRamRSC should be EFalse.

//The same constant is defined into TDefect test app. It should be changed too.

#pragma warning(disable : 4127)   //conditional expression is constant

LOCAL_D const TBool KRomMBMInRamRSC = EFalse;

//Cleanup function used by CFbsBitmap::LoadShiftedRomBmpL(...)

LOCAL_D void FreeMem(TAny* aMem)

	{

	delete[] static_cast<TUint8*>(aMem);

	}

// Fbs style bitmap client class for font bitmap server

/** @publishedAll */

EXPORT_C CFbsBitmap::CFbsBitmap():

	CBase(),

	iFbs(RFbsSession::GetSession()),

	iAddressPointer(NULL),

	iFlags(0),

	iUseCount(0),

	iHandle(0),

	iServerHandle(0)

	{

	}

/** Destructor. Calls Reset().

@see Reset()

@publishedAll 

@released

*/

EXPORT_C CFbsBitmap::~CFbsBitmap()

	{

	Reset();

	}

/** Gets the physical length in bytes of a scanline in memory. 

This is aligned to a 4 byte (DWORD) boundary for performance reasons.

@param aLength The length of a scanline in pixels. 

@param aDispMode The display mode of the bitmap. 

@return Number of bytes in the scanline in memory. 

@publishedAll 

@released

*/

EXPORT_C TInt CFbsBitmap::ScanLineLength(TInt aLength,TDisplayMode aDispMode)

	{

	if (aDispMode == ERgb)

		return aLength * 4;

	else if (aDispMode == ENone)

		return 0;

	return CBitwiseBitmap::ByteWidth(aLength,aDispMode);

	}

/** Releases the bitmap's handle from the font and bitmap server and decrements 

its access count.

The server-side bitmap is only deleted when the access count for the bitmap 

decrements to zero. 

@publishedAll

@released

*/

EXPORT_C void CFbsBitmap::Reset()

	{

	if (iHandle && !(iFlags & EIsRomBitmap))

		{

		iFbs->SendCommand(EFbsMessClose, iHandle, Handle());

		iFbs->iHelper->RemoveBitmap(*this);

		}

	if (KRomMBMInRamRSC && (iFlags & EIsRomBitmap))

		{

		// If it is a ROM bitmap, we have to check, is it a ROM bitmap located

		// in RAM? If yes, then we have to deallocate the bitmap memory.

		TBool isInRom = EFalse;

		TInt ret = User::IsRomAddress(isInRom, iAddressPointer);

		if (ret == KErrNone && !isInRom)

			delete[] reinterpret_cast<TUint8*>(iAddressPointer);

		}

	iAddressPointer = NULL;

	iFlags = 0;

	iUseCount = 0;

	iHandle = 0;

	iServerHandle = 0;

	}

/** Tests whether or not the bitmap is read-only.

@return ETrue if the bitmap is read-only, EFalse otherwise.

@publishedAll

@released

*/

EXPORT_C TBool CFbsBitmap::IsRomBitmap() const

	{

	return (iFlags & EIsReadOnlyBitmapMask) > 0;

	}

/**  Sets the bitmap to use a bitmap image stored in ROM.

@param aRomBitmapPointer Pointer to a bitmap stored in ROM.

@param aBitmapSizeInBytes On return, indicates the size of 

the bitmap in bytes. 

@leave KErrUnknown aRomBitmapPointer is not in ROM, or has an invalid UID.

@publishedAll

@released

*/	

EXPORT_C void CFbsBitmap::SetRomBitmapL(CBitwiseBitmap* aRomBitmapPointer,TInt& aBitmapSizeInBytes)

    {

	TBool isInRom = EFalse;

	TInt ret = User::IsRomAddress(isInRom,(TAny*)aRomBitmapPointer);

	if (ret != KErrNone || !isInRom || aRomBitmapPointer->Uid() != KCBitwiseBitmapUid)

		User::Leave(KErrUnknown);

	Reset();

	iAddressPointer = aRomBitmapPointer;

	iFlags = EIsRomBitmap;

	iHandle = 1;

	User::LeaveIfError(iFbs->AllocScanLineBuffer(aRomBitmapPointer->iByteWidth + 4));

	aBitmapSizeInBytes = Align4(aRomBitmapPointer->iHeader.iBitmapSize + 28);

	}

CBitwiseBitmap* CFbsBitmap::Address() const

	{

	if (!iHandle)

		return NULL;

	return iAddressPointer;

	}

EXPORT_C CBitwiseBitmap* CFbsBitmap::CleanAddress() const

	{

	if (!iHandle)

		return NULL;

	// Don't try to clean a dirty bitmap between calls to BeginDataAccess() and EndDataAccess(), i.e. iUseCount > 0

	// ROM bitmaps can never be dirty

	if (!(iFlags & EIsReadOnlyBitmapMask) && iUseCount == 0 && iAddressPointer->iSettings.IsDirtyBitmap())

		{

		TPckgBuf<TBmpHandles> handlebuf;

		TIpcArgs args(iHandle, &handlebuf);

		if (iFbs->SendCommand(EFbsMessBitmapClean, args) == KErrNone)

			{

			const_cast<CFbsBitmap*>(this)->iHandle = handlebuf().iHandle;

			const_cast<CFbsBitmap*>(this)->iServerHandle = handlebuf().iServerHandle;

			const_cast<CFbsBitmap*>(this)->iAddressPointer = (CBitwiseBitmap*)(iFbs->HeapBase() + handlebuf().iAddressOffset);

			}

		}

	return iAddressPointer;

	}

inline CBitwiseBitmap* CFbsBitmap::BeginDataAccessAndGetCleanAddress(TUint32*& aDataAddress) const

	{

	BeginDataAccess();

	CBitwiseBitmap* bmp = Address();

	// aDataAddress should be consistent with bmp since after the call to BeginDataAccess()

	// the call to DataAddress() will not clean the bitmap again

	aDataAddress = DataAddress();

	return bmp;

	}

/** Gets the address of the first pixel in the bitmap. 

The first pixel is at the top-left. Access to the pixel data of a bitmap

should be surrounded by calls to BeginDataAccess() and EndDataAccess(),

otherwise performance may be degraded on certain platforms.

Note: Performing a Resize() or Compress() operation changes the value returned by this function.

@return The address of the first pixel of the bitmap.

@publishedAll

@released

@see CFbsBitmap::BeginDataAccess()

@see CFbsBitmap::EndDataAccess()

*/

EXPORT_C TUint32* CFbsBitmap::DataAddress() const

	{

	if(!iHandle) return(NULL);

	CBitwiseBitmap* bmp = CleanAddress();

	if (!(iFlags & EIsReadOnlyBitmapMask) && (iUseCount == 0))

		bmp->iSettings.SetVolatileBitmap();

	if(bmp->iUid.iUid==KCBitwiseBitmapHardwareUid.iUid)   // RHardwareBitmap

		{

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

		TAcceleratedBitmapInfo info;

		const TInt ret = hwb.GetInfo(info);

		return ret!=KErrNone ? NULL : (reinterpret_cast<TUint32*>(info.iAddress));

		}

	if (bmp->iHeap == NULL)

		return(reinterpret_cast<TUint32*>((TUint8*)bmp+bmp->iDataOffset));

	return(reinterpret_cast<TUint32*>(iFbs->iLargeBitmapChunk.Base()+bmp->iDataOffset));

	}

/** Gets the length in bytes between scanlines in memory.

@return The length in bytes between scanlines in memory. 

@internalAll

@released

*/

EXPORT_C TInt CFbsBitmap::DataStride() const

	{

	if (!iHandle)

		{

		return 0;

		}

	CBitwiseBitmap* bmp = CleanAddress();

	if (bmp==NULL)

		{

		return 0;

		}

	return bmp->DataStride();	

	}

/** Creates a bitmap with the specified size and display mode. The bitmap is 

created on the font and bitmap server's shared heap.

@param aSizeInPixels The size of the bitmap to be created. 

@param aDispMode The display mode of the bitmap to be created. 

@return KErrNone if successful; KErrCouldNotConnect if no connection to the 

font and bitmap server could be made; KErrArgument if either the width or height specified 

in aSizeInPixels are negative or if the requested display mode is invalid; KErrTooBig 

if the requested size is too big. 

@publishedAll

@released

*/

EXPORT_C TInt CFbsBitmap::Create(const TSize& aSizeInPixels,TDisplayMode aDispMode)

	{

	}

TInt CFbsBitmap::DoCreate(const TSize& aSizeInPixels, TDisplayMode aDispMode, TUid aUid, TInt aDataSize)

	{

	if(!iFbs) return(KErrCouldNotConnect);

	if (aDispMode <= ENone || aDispMode == ERgb || aDispMode >= EColorLast) return KErrArgument;

	if(aSizeInPixels.iWidth<0 || aSizeInPixels.iHeight<0) return(KErrArgument);

	if (aDataSize < 0) return KErrArgument;

	Reset();

	TBmpSpec bmpspec;

	bmpspec.iSizeInPixels=aSizeInPixels;

	bmpspec.iDispMode=aDispMode;

	bmpspec.iHandle = aUid.iUid;	// Use iHandle to pass UID

	bmpspec.iServerHandle = aDataSize;	// Use iServerHandle to pass data size

	TPckgBuf<TBmpSpec> b;

	b=bmpspec;

	TIpcArgs args(&b);

	TInt ret=iFbs->SendCommand(EFbsMessBitmapCreate,args);

	if(ret!=KErrNone) return(ret);

	iHandle=b().iHandle;

	iServerHandle=b().iServerHandle;

	iAddressPointer=(CBitwiseBitmap*)(iFbs->HeapBase()+b().iAddressOffset);

	if (aDataSize > 0) // explicitly specified data size means extended bitmap

		{

		iFlags = EIsExtendedBitmap;

		}

	ret = iFbs->iHelper->AddBitmap(*this);

	if (ret != KErrNone)

		return ret;

	return iFbs->AllocScanLineBuffer(CBitwiseBitmap::ByteWidth(aSizeInPixels.iWidth, aDispMode)+4);

	}

/** Creates a hardware bitmap with a size and display mode.

@param aSizeInPixels The bitmap's width and height in pixels.

@param aDispMode The bitmap's display mode.

@param aCreatorUid The UID of the application calling this function. This is 

used to allow segregation of the memory used for hardware bitmaps. For instance, 

if a device has video memory attached to display and graphics accelerator 

hardware, this UID is used to determine whether any video memory is pre-allocated 

for that application's use.

@return KErrNone if successful, otherwise one of the system wide error codes. 

These include KErrCouldNotConnect if no connection has been made to the font 

and bitmap server, KErrArgument if either the width or height specified in 

aSizeInPixels are negative or if the requested display mode is invalid, or KErrNotSupported 

if hardware bitmaps are not supported on the device. 

@publishedAll

@released

*/

EXPORT_C TInt CFbsBitmap::CreateHardwareBitmap(const TSize& aSizeInPixels,TDisplayMode aDispMode,TUid aCreatorUid)

	{

	}

/** Resets the pixel-size of the bitmap.

If the new size is bigger than the old, the original bitmap is still situated 

at (0,0), but pixels outside the range of the old pixel-size are set to zero.

@param aSizeInPixels The new size of the bitmap. 

@return KErrNone if successful; KErrArgument if the new size is illegal; 

KErrGeneral if the bitmap has not yet been created; KErrAccessDenied if the 

bitmap is in ROM or is an extended bitmap; otherwise another of the system-wide error codes. 

@publishedAll

@released

*/

EXPORT_C TInt CFbsBitmap::Resize(const TSize& aSizeInPixels)

	{

	if(aSizeInPixels.iWidth<0 || aSizeInPixels.iHeight<0) 

		return(KErrArgument);

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

		return(KErrTooBig);	

	if(!iHandle) 

		return(KErrGeneral);

	if (iFlags & EIsReadOnlyBitmapMask)

		return(KErrAccessDenied);	

	TPckgBuf<TBmpHandles> handlebuf;

	TIpcArgs args(iHandle, aSizeInPixels.iWidth, aSizeInPixels.iHeight, &handlebuf);

	TInt err = iFbs->SendCommand(EFbsMessBitmapResize, args);

	if (err != KErrNone)

		return (err);

	iHandle = handlebuf().iHandle;

	iServerHandle = handlebuf().iServerHandle;

	iAddressPointer = (CBitwiseBitmap*)(iFbs->HeapBase() + handlebuf().iAddressOffset);

	return iFbs->AllocScanLineBuffer(CBitwiseBitmap::ByteWidth(aSizeInPixels.iWidth, DisplayMode())+4);

	}

/** Gets the display mode of the bitmap.

@return The display mode of the bitmap. 

@publishedAll

@released

*/

EXPORT_C TDisplayMode CFbsBitmap::DisplayMode() const

	{

	if(iHandle==NULL) return(ENone);

	return CleanAddress()->DisplayMode();

	}

/** Returns the display mode that was used to create the bitmap.

@return The display mode used to create the bitmap.

@publishedAll

@released

*/

EXPORT_C TDisplayMode CFbsBitmap::InitialDisplayMode() const

	{

	if(iHandle == NULL) 

		{

		return ENone;

		}

	return CleanAddress()->InitialDisplayMode();

	}

/**

Changes the display mode of the bitmap.

The requested display mode cannot be greater (in bpp value) than the initial display mode.

This method cannot leave, for instance because of an out of memory condition. No 

additional memory is allocated or leaving methods called.

The bitmap's content is preserved when converting it to the requested display mode,

but there may be some loss of quality.

@publishedAll

@released

@param aDisplayMode The requested display mode.

@return KErrArgument if the requested mode is invalid, or has a greater bpp value 

than the initial mode. KErrNotSupported if the bitmap is compressed, or is a

ROM bitmap, an extended bitmap or a hardware bitmap. KErrGeneral if the bitmap

handle is NULL. KErrNone if the method call is successful.

@see CFbsBitmap::InitialDisplayMode()

*/

EXPORT_C TInt CFbsBitmap::SetDisplayMode(TDisplayMode aDisplayMode)

	{

	if(!iHandle) 

		{

		return KErrGeneral;

		}	

	TUint32* data;

	CBitwiseBitmap* bmp = BeginDataAccessAndGetCleanAddress(data);

	TInt err = bmp->SetDisplayMode(aDisplayMode, data);

	EndDataAccess(EFalse);

	return err;

	}

/** Duplicates a bitmap.

This function does not create a copy of the bitmap. It just assigns another 

handle to the bitmap in the font and bitmap server, and sets this object's 

handle to that. If the specified bitmap is in the ROM, it just assigns a pointer 

to it.

@param aHandle The handle to an existing bitmap.

@return KErrNone if successful; KErrCouldNotConnect if no connection to the 

font and bitmap server could be made; KErrUnknown if no bitmap could be found 

with the specified handle number.

@publishedAll

@released

@see CFbsBitmap::Handle()

*/

	if(!iFbs) 

		{

		}

		{

		}