// Copyright (c) 1997-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 "BITPANIC.H"

#include <fntstore.h>

#include <bitmap.h>

#include <bitstd.h>

#include <bitdev.h>

#include <bitdraw.h>

#include <bitdrawscaling.h>

#include <bitdrawinterfaceid.h>

#include <bmalphablend.h>

#include <graphics/fbsrasterizer.h>

#include <graphics/bitmap.inl>

#include <graphics/gdi/gdiinline.inl>

GLREF_C void XorBuffers(TUint32* aDestBuffer,const TUint32* aSrceBuffer,TInt aNumBytes);

GLREF_C void AndBuffers(TUint32* aDestBuffer,const TUint32* aSrceBuffer,TInt aNumBytes);

GLREF_C void InvertBuffer(TUint32* aDestBuffer,TInt aNumBytes);

GLREF_C void InvertBuffer(TUint8* aDestBuffer,TInt aNumBytes);

LOCAL_C void TileScanLine(TPtr8& aScanLine,

						  TInt aLengthInPixels,

						  const TPoint& aSrcPt,

						  const CBitwiseBitmap* aMaskBitmap,

						  TLineScanningPosition& aScanLinePos,

						  TUint32* aMaskBase,

						  TDisplayMode aDisplayMode

						  );

/** Draws from another CFbsBitGc.

@param aPoint The position to draw the top left corner of the piece of bitmap

@param aGc The source bitmap graphics context */

EXPORT_C void CFbsBitGc::BitBlt(const TPoint& aDest,const CFbsBitGc& aGc)

	{

	TRect deviceRect;

	aGc.iDevice->iDrawDevice->GetDrawRect(deviceRect);

	BitBlt(aDest,aGc,deviceRect);

	}

/** Draws a particular rectangle from another CFbsBitGc.

@param aPoint The position to draw the top left corner of the piece of bitmap.

@param aGc The source bitmap graphics context.

@param aSrceRect A rectangle defining the piece of the source to be drawn. */

EXPORT_C void CFbsBitGc::BitBlt(const TPoint& aDest,

								const CFbsBitGc& aGc,

								const TRect& aSrceRect)

	{

	if (CheckDevice(aSrceRect))

		return;

	aGc.CheckDevice();

	CFbsDevice* srceDevice = aGc.iDevice;

	if (!srceDevice)

		return;

	TRect srceRect(aSrceRect);

	TRect deviceRect;

	srceDevice->GetDrawRect(deviceRect);

	if (!srceRect.Intersects(deviceRect))

		return;

	srceRect.Intersection(deviceRect);

	const TPoint destPoint(aDest + iOrigin + srceRect.iTl - aSrceRect.iTl);

	const TRect destRect(destPoint,srceRect.Size());

	const TPoint offset(srceRect.iTl - destPoint);

	TRect clippedDestRect(destRect);

	AddRect(clippedDestRect);

	if (UserClipRect(clippedDestRect))

		return;

	SetupDevice();

	aGc.iDevice->DrawingBegin();

	iDevice->DrawingBegin();

	const TInt limit = iDefaultRegionPtr->Count();

	TBool opaqueSource = (!IsAlphaChannel(srceDevice->DisplayMode())) && (iDrawMode == EDrawModePEN);

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

		{

		iClipRect=(*iDefaultRegionPtr)[count];

		if(!iClipRect.Intersects(clippedDestRect))

			continue;

		iClipRect.Intersection(clippedDestRect);

		TRect clippedSrceRect(iClipRect);

		clippedSrceRect.Move(offset);

		if (opaqueSource)

			iDrawMode = EDrawModeWriteAlpha;// ie write rather then blend

		DoBitBlt(iClipRect.iTl,srceDevice,clippedSrceRect);

		if (opaqueSource)

			iDrawMode = EDrawModePEN;// set it back how it was

		iDevice->iDrawDevice->UpdateRegion(iClipRect);

		}

	aGc.iDevice->DrawingEnd();

	iDevice->DrawingEnd();

	}

/** Draws the whole of a CFbsBitmap.

@param aDest   The position to draw the top left corner of the bitmap.

@param aBitmap The source bitmap. */

EXPORT_C void CFbsBitGc::BitBlt(const TPoint& aDest,const CFbsBitmap* aBitmap)

    {

    if (aBitmap == NULL || !aBitmap->Handle())

    	return;

	aBitmap->BeginDataAccess();

    BitBlt(aDest,aBitmap,TRect(aBitmap->SizeInPixels()));

	aBitmap->EndDataAccess(ETrue);

	}

/** Draws a particular rectangle from a CFbsBitmap.

@param aDest The position to draw the top left corner of the bitmap.

@param aBitmap The source bitmap.

@param aSrceRect A rectangle defining the piece of the source to be drawn. */

EXPORT_C void CFbsBitGc::BitBlt(const TPoint& aDest,

								const CFbsBitmap* aBitmap,

								const TRect& aSrceRect)

    {

	if (aBitmap == NULL || !aBitmap->Handle()|| CheckDevice(aSrceRect))

		return;

	aBitmap->BeginDataAccess();

	TRect srceRect(aSrceRect);

	const TRect area(aBitmap->SizeInPixels());

	if (!srceRect.Intersects(area))

		{

		aBitmap->EndDataAccess(ETrue);

		return;

		}

	srceRect.Intersection(area);

	const TPoint destPoint(aDest + iOrigin + srceRect.iTl - aSrceRect.iTl);

	const TPoint offset(srceRect.iTl - destPoint);

	TRect targetRect(destPoint,srceRect.Size());

	AddRect(targetRect);

	if (UserClipRect(targetRect))

		{

		aBitmap->EndDataAccess(ETrue);

		return;

		}

	SetupDevice();

	iDevice->DrawingBegin();

	CBitwiseBitmap* srce = ((CFbsBitGcBitmap*)aBitmap)->Address();

	BG_ASSERT_DEBUG(srce,EBitgdiPanicInvalidBitmap);

	CFbsRasterizer* rasterizer = PrepareRasterizerForExtendedBitmap(*aBitmap, targetRect, offset);

	TInt count;

	const TInt limit = iDefaultRegionPtr->Count();

	CGraphicsAccelerator* ga = GraphicsAccelerator();

	TBool opaqueSource = (!IsAlphaChannel(aBitmap->DisplayMode())) && (iDrawMode == EDrawModePEN);

	if(ga && (iShadowMode == CFbsDrawDevice::ENoShadow))

		{

	    TInt gaOperationResult = KErrUnknown;

		TAcceleratedBitmapSpec bitmapSpec(const_cast<CFbsBitmap*>(aBitmap));

        iDevice->DrawingEnd();

		for(count=0;count<limit;count++)

			{

			iClipRect=(*iDefaultRegionPtr)[count];

			if(!iClipRect.Intersects(targetRect))

				continue;

			iClipRect.Intersection(targetRect);

			TRect clippedSrceRect(iClipRect);

			clippedSrceRect.Move(offset);

			gaOperationResult = ga->Operation(TGopBitBlt(iClipRect.iTl,bitmapSpec,clippedSrceRect));

			if(gaOperationResult != KErrNone)

				break;

			iDevice->iDrawDevice->UpdateRegion(iClipRect);

			}

		if(gaOperationResult == KErrNone)

			goto finish;

		iDevice->DrawingBegin();

		}

	for(count=0;count<limit;count++)

		{

		iClipRect=(*iDefaultRegionPtr)[count];

		if(!iClipRect.Intersects(targetRect))

			continue;

		iClipRect.Intersection(targetRect);

		TRect clippedSrceRect(iClipRect);

		clippedSrceRect.Move(offset);

		if (opaqueSource)

			iDrawMode = EDrawModeWriteAlpha;// ie write rather then blend

		DoBitBlt(iClipRect.iTl,srce,aBitmap->DataAddress(),aBitmap->DataStride(),clippedSrceRect);

		if (opaqueSource)

			iDrawMode = EDrawModePEN;// set it back how it was

		iDevice->iDrawDevice->UpdateRegion(iClipRect);

		}

	iDevice->DrawingEnd();

finish:

	if (rasterizer)

		{

		rasterizer->EndBitmap(aBitmap->SerialNumber());

		}

	aBitmap->EndDataAccess(ETrue);

	}

/** Performs a masked bitmap block transfer.

The function provides a concrete implementation of the pure virtual

function CBitmapContext::BitBltMasked(). The function

behaviour is the same as documented in that class.

There are several points to note about this implementation of

BitBltMasked():

1.For best performance the aMaskBitmap and source aBitmap should

have the same display mode as the destination device/bitmap.

2.For performance reasons this implementation does not validate

the contents of the aMaskBitmap. The caller must ensure the mask

pixels are either black or white otherwise undefined blitting causing

unpredictable discoloration will result. This is especially true

for index (where pixel is palette entry) display modes (e.g. EColor16).

It is up to the caller to decide if they wish to utilise

CFbsBitmap::IsMonochrome().

3.Alpha blending is used when the display mode of the mask bitmap aMaskBitmap

is EGray256.

@see CBitmapContext::BitBltMasked() */

EXPORT_C void CFbsBitGc::BitBltMasked(const TPoint& aDest,

									  const CFbsBitmap* aBitmap,

									  const TRect& aSourceRect,

									  const CFbsBitmap* aMaskBitmap,

									  TBool aInvertMask)

    {

	if (aBitmap == NULL || !aBitmap->Handle() ||

		aMaskBitmap == NULL || !aMaskBitmap->Handle() ||

		CheckDevice(aSourceRect))

		return;

	aBitmap->BeginDataAccess();

	aMaskBitmap->BeginDataAccess();

	TRect srceRect(aSourceRect);

	const TRect area(aBitmap->SizeInPixels());

	if (!srceRect.Intersects(area))

		{

		aBitmap->EndDataAccess(ETrue);

		aMaskBitmap->EndDataAccess(ETrue);

		return;

		}

	srceRect.Intersection(area);

	const TPoint destPoint(aDest + iOrigin + srceRect.iTl - aSourceRect.iTl);

	const TRect destRect(destPoint,srceRect.Size());

	const TPoint offset(srceRect.iTl - destPoint);

	const TPoint ditherorigin(iDitherOrigin + aDest);

	TRect clippedDestRect(destRect);

	AddRect(clippedDestRect);

	if (UserClipRect(clippedDestRect))

		{

		aBitmap->EndDataAccess(ETrue);

		aMaskBitmap->EndDataAccess(ETrue);

		return;

		}

	SetupDevice();

	iDevice->DrawingBegin();

	CBitwiseBitmap* srcebmp = ((CFbsBitGcBitmap*)aBitmap)->Address();

	CBitwiseBitmap* maskbmp = ((CFbsBitGcBitmap*)aMaskBitmap)->Address();

	BG_ASSERT_DEBUG(srcebmp,EBitgdiPanicInvalidBitmap);

	BG_ASSERT_DEBUG(maskbmp,EBitgdiPanicInvalidBitmap);

	const TDisplayMode maskMode = maskbmp->DisplayMode();

	// Do the background fill the lazy way with flicker if any of the following are true:

	// 1. There is no anti-flicker buffer

	// 2. The source and mask bitmaps are the same

	// 3. The brush style is patterned and the mask is an alpha mask

	// 4. The brush style is not null or solid or patterned

	if (!iDevice->iBitBltMaskedBuffer ||

		srcebmp == maskbmp ||

		(maskMode == EGray256 && iBrushStyle == EPatternedBrush) ||

		iBrushStyle > EPatternedBrush)

		{

		iBrushBitmap.BeginDataAccess();

		CFbsRasterizer* brushRasterizer = PrepareRasterizerForExtendedBitmap(iBrushBitmap);

		RectFill(destRect);

		if (brushRasterizer)

			{

			brushRasterizer->EndBitmap(iBrushBitmap.SerialNumber());

			}

		iBrushBitmap.EndDataAccess(ETrue);

		}

	const TInt8 shadowMode = iShadowMode;

	iShadowMode = CFbsDrawDevice::ENoShadow;

	SetupDevice();

	CFbsRasterizer* rasterizer = PrepareRasterizerForExtendedBitmap(*aBitmap, clippedDestRect, offset);

	CFbsRasterizer* maskRasterizer = NULL;

	if (srcebmp != maskbmp)

		{

		if (aMaskBitmap->SizeInPixels().iWidth >= aBitmap->SizeInPixels().iWidth

			&& aMaskBitmap->SizeInPixels().iHeight >= aBitmap->SizeInPixels().iHeight)

			{

			// Mask is not tiled. Pass same region of interest as source bitmap to rasterizer.

			maskRasterizer = PrepareRasterizerForExtendedBitmap(*aMaskBitmap, clippedDestRect, offset);

			}

		else

			{

			// Mask is tiled. Do not pass any region of interest to rasterizer.

			maskRasterizer = PrepareRasterizerForExtendedBitmap(*aMaskBitmap);

			}

		}

    TInt count;

	const TInt limit = iDefaultRegionPtr->Count();

	CGraphicsAccelerator* ga = GraphicsAccelerator();

	TBool opaqueSource = (!IsAlphaChannel(aBitmap->DisplayMode())) && (iDrawMode == EDrawModePEN);

	if(ga)

		{

		if((iBrushStyle == ENullBrush) && aInvertMask &&

		   (shadowMode == CFbsDrawDevice::ENoShadow))

			{

			TInt gaOperationResult = KErrUnknown;

			TAcceleratedBitmapSpec bitmapSpec(const_cast<CFbsBitmap*>(aBitmap));

			TAcceleratedBitmapSpec bitmapMaskSpec(const_cast<CFbsBitmap*>(aMaskBitmap));

			iDevice->DrawingEnd();

			for(count=0;count<limit;count++)

				{

				iClipRect=(*iDefaultRegionPtr)[count];

				if(!iClipRect.Intersects(clippedDestRect))

					continue;

				iClipRect.Intersection(clippedDestRect);

				TRect clippedSrceRect(iClipRect);

				clippedSrceRect.Move(offset);

				if(maskbmp->DisplayMode() == EGray256)

					gaOperationResult = ga->Operation(TGopBitBltAlphaBitmap(iClipRect.iTl,

																			bitmapSpec,

																			clippedSrceRect,

																			bitmapMaskSpec));

				else

					gaOperationResult = ga->Operation(TGopBitBltMasked(iClipRect.iTl,

																	   bitmapSpec,

																	   clippedSrceRect,

																	   bitmapMaskSpec));

				if(gaOperationResult != KErrNone)

					break;

				iDevice->iDrawDevice->UpdateRegion(iClipRect);

				}

			if(gaOperationResult == KErrNone)

				goto finish;

			iDevice->DrawingBegin();

			}

		}

	for(count=0;count<limit;count++)

		{

		iClipRect=(*iDefaultRegionPtr)[count];

		if (!iClipRect.Intersects(clippedDestRect))

			continue;

		iClipRect.Intersection(clippedDestRect);

		TRect clippedSrceRect(iClipRect);

		clippedSrceRect.Move(offset);

		if (opaqueSource)

			iDrawMode = EDrawModeWriteAlpha;// ie write rather then blend

		DoBitBltMasked(iClipRect.iTl,

					   srcebmp,

					   aBitmap->DataAddress(),

					   clippedSrceRect,

					   maskbmp,

					   aMaskBitmap->DataAddress(),

					   aInvertMask,

					   ditherorigin,

					   shadowMode);

		if (opaqueSource)

			iDrawMode = EDrawModePEN;// set it back how it was

		iDevice->iDrawDevice->UpdateRegion(iClipRect);

		}

	iDevice->DrawingEnd();

finish:

	if (rasterizer)

		{

		rasterizer->EndBitmap(aBitmap->SerialNumber());

		}

	if (maskRasterizer)

		{

		maskRasterizer->EndBitmap(aMaskBitmap->SerialNumber());

		}

	aBitmap->EndDataAccess(ETrue);

	aMaskBitmap->EndDataAccess(ETrue);

	iShadowMode = shadowMode;

	}

/**

Does BitBlt operation of source and bitmap per scanline.

*/

void CFbsBitGc::DoBitBlt(const TPoint& aDest,CFbsDevice* aSrce,const TRect& aSrceRect)

	{

	const TInt width = aSrceRect.Width();

	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;

#ifdef _DEBUG

	TRect deviceSrcRect;

	aSrce->iDrawDevice->GetDrawRect(deviceSrcRect);

	TRect deviceDestRect;

	drawDevice->GetDrawRect(deviceDestRect);

#endif

	BG_ASSERT_DEBUG(aSrceRect.iTl.iX >= deviceSrcRect.iTl.iX, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG(aSrceRect.iTl.iY >= deviceSrcRect.iTl.iY, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG(aSrceRect.iBr.iX <= deviceSrcRect.iBr.iX, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG(aSrceRect.iBr.iY <= deviceSrcRect.iBr.iY, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG(aDest.iX >= deviceDestRect.iTl.iX, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG(aDest.iY >= deviceDestRect.iTl.iY, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG((aDest.iX + aSrceRect.Width())  <= deviceDestRect.iBr.iX, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG((aDest.iY + aSrceRect.Height()) <= deviceDestRect.iBr.iY, EBitgdiPanicOutOfBounds);

	CFbsDrawDevice* srcDrawDevice = aSrce->iDrawDevice;

	TAny* interface=NULL;

	if (iDrawMode==EDrawModeWriteAlpha &&

		iShadowMode == CFbsDrawDevice::ENoShadow &&

		(aSrceRect.iTl.iX >= 0) &&  (aSrceRect.iTl.iY >= 0) &&

		(aDest.iX >= 0) && (aDest.iY >= 0) &&

	    srcDrawDevice->DisplayMode() == drawDevice->DisplayMode() &&

		drawDevice->GetInterface(KFastBlit2InterfaceID, interface) == KErrNone)

		{

		// Conditions in CFbsBitGc allow for optimised blitting.

		// The draw device supports the optimised blitting function.

		// Operation may fail regardless due to unacceptable conditions in the draw device.

		BG_ASSERT_DEBUG(interface!=NULL, EBitgdiPanicNullPointer);

		MFastBlit2* fastBlit = reinterpret_cast<MFastBlit2*>(interface);

		if (fastBlit->WriteBitmapBlock(aDest, srcDrawDevice, aSrceRect) == KErrNone)

			{

			return;

			}

		}

	MFastBlend* fastBlend=NULL;

	if (FastBlendInterface(NULL,NULL,fastBlend)==KErrNone)

		{

		if (fastBlend->FastBlendBitmap(aDest, srcDrawDevice, aSrceRect, iDrawMode, iShadowMode)==KErrNone)

			{

			return;

			}

		}

	//scanLineBuffer is destination scanline buffer.

	TUint32* scanLineBuffer = drawDevice->ScanLineBuffer();

	const TInt scanLineBytes = drawDevice->ScanLineBytes();

	TPtr8 scanLineDes((TUint8*)scanLineBuffer,scanLineBytes,scanLineBytes);

	//dispMode is destination display mode.

	const TDisplayMode dispMode = ScanLineBufferDisplayMode(drawDevice);

	TInt destY = aDest.iY;

	//Gets the scanline from the source, into the buffer scanLineDes.

	//The DoGetScanLine operation is also responsible for converting

	// the buffer pixel format to destination display format.

	for (TInt row = aSrceRect.iTl.iY; row < aSrceRect.iBr.iY; row++,destY++)

		{

		aSrce->DoGetScanLine(scanLineDes,TPoint(aSrceRect.iTl.iX,row),width,dispMode);

		drawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer,iDrawMode);

		}

	}

/**

Calculates the position into the scanline for the given x coordinate

*/

TUint CFbsBitGc::MemoryOffsetForPixelPitch(TUint aX, TDisplayMode aDisplayMode)

	{

	switch (aDisplayMode)

		{

		case EColor16MU:

		case EColor16MA:

		case EColor16MAP:

			return aX << 2;

		case EColor16M:

			return aX * 3;

		case EColor4K:

		case EColor64K:

			return aX << 1;

		case EGray256:

		case EColor256:

			return aX;

		default:

			BG_PANIC_DEBUG(EBitgdiPanicInvalidDisplayMode);

		break;

		}

	return 0;

	}