// 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 "PNGCodec.h"

#include "ImageUtils.h"

const TInt KPngScanlineFilterTypeLength = 1;

const TInt KColStart[KPngNumInterlacedPasses] = { 0, 4, 0, 2, 0, 1, 0, 0 };

const TInt KRowStart[KPngNumInterlacedPasses] = { 0, 0, 4, 0, 2, 0, 1, 0 };

const TInt KColIncrement[KPngNumInterlacedPasses] = { 8, 8, 4, 4, 2, 2, 1, 0 };

const TInt KRowIncrement[KPngNumInterlacedPasses] = { 8, 8, 8, 4, 4, 2, 2, 0 };

const TInt KBlockWidth[KPngNumInterlacedPasses] = { 8, 4, 4, 2, 2, 1, 1, 0 };

const TInt KBlockHeight[KPngNumInterlacedPasses] = { 8, 8, 4, 4, 2, 2, 1, 0 };

const TInt KPngDepth1BytesPerPixel = 1;

const TInt KPngDepth3BytesPerPixel = 3;

const TInt KPngDepth4BytesPerPixel = 4;

// CFastProcessor16MAto16MA

/**This class is a specific implementation of CFastProcessor.

It provides a conversion of 24bpp + 8bpp alpha to EColor16MA display mode.

*/

class CFastProcessor16MAto16MA: public CFastProcessor

    {

public:

	CFastProcessor16MAto16MA(CFbsBitmap* aDestination, TBool aRgbaMode);

    void SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos);

    };

// CFastProcessor16MAto16MAP

/**This class is a specific implementation of CFastProcessor.

It provides a conversion of 24bpp + 8bpp alpha to EColor16MAP display mode.

*/

class CFastProcessor16MAto16MAP: public CFastProcessor

    {

public:

	CFastProcessor16MAto16MAP(CFbsBitmap* aDestination, TBool aRgbaMode);

    void SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos);

    };

// CFastProcessor16MtoM

/**This class is a specific implementation of CFastProcessor.

It provides a conversion of 24bpp to EColor16M display mode. 

*/

class CFastProcessor16Mto16M: public CFastProcessor

    {

public:

	CFastProcessor16Mto16M(CFbsBitmap* aDestination, TBool aRgbaMode);

    void SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos);

    };

// CFastProcessor16MtoMA

/**This class is a specific implementation of CFastProcessor.

It provides a conversion of 24bpp to EColor16MU, EColor16MA or EColor16MAP display mode. 

*/

class CFastProcessor16Mto16MA: public CFastProcessor

    {

public:

	CFastProcessor16Mto16MA(CFbsBitmap* aDestination, TBool aRgbaMode);

    void SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos);

    };

// CFastProcessor16MAto16MU

/**This class is a specific implementation of CFastProcessor.

It provides a conversion of a 24bpp + 8bpp alpha source to a EColor16MU (setting alpha as 0xFF).

*/

class CFastProcessor16MAto16MU: public CFastProcessor

    {

public:

	CFastProcessor16MAto16MU(CFbsBitmap* aDestination, TBool aRgbaMode);

    void SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos);

    };

// CFastProcessor32bitTo32bitAndMask

/**This class is a specific implementation of CFastProcessor.

It provides a conversion of a 24bpp + 8bpp alpha source to an opaque 32 bit destination bitmap (i.e.

setting the alpha channel to 0xFF) and EGray256 mask (which contains the alpha channel of the source).

*/

class CFastProcessor32bitTo32bitAndMask: public CFastProcessor

    {

public:

	CFastProcessor32bitTo32bitAndMask(CFbsBitmap* aDestination, CFbsBitmap* aMask, TBool aRgbaMode);

    void SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos);

    };

/**

Constructs a new FastProcessor based on the conversion type.

@param  aImageInfo

        A reference to TPngImageInformation for the FastProcessor to use.

@param  aDestination

        A reference to the destination bitmap.

@param  aRgbaMode

        This flag indicates that MNG frames are being processed.

*/

CFastProcessor* CFastProcessor::NewL(const TPngImageInformation& aImageInfo, CFbsBitmap* aDestination, CFbsBitmap* aMask, TBool aRgbaMode)

    {

	CFastProcessor* self = NULL;

	if (aRgbaMode) //if MNG

		{

		if (aImageInfo.iColorType == TPngImageInformation::EDirectColor)

			{

			self = new (ELeave) CFastProcessor16Mto16MA(aDestination, aRgbaMode);	

			}

		else if(aImageInfo.iColorType == TPngImageInformation::EAlphaDirectColor)

			{

			self = new (ELeave) CFastProcessor16MAto16MA(aDestination, aRgbaMode);	

			}

		else

			{

			User::Leave(KErrNotSupported);	

			}

		}

	else

		{

		TDisplayMode mode = aDestination->DisplayMode();

		switch (aImageInfo.iColorType)

			{

			case TPngImageInformation::EDirectColor:

				if(EColor16M == mode)

					{

					self = new (ELeave) CFastProcessor16Mto16M(aDestination, aRgbaMode);	

					}

				else if(EColor16MAP == mode || EColor16MA == mode || EColor16MU == mode)

					{

					self = new (ELeave) CFastProcessor16Mto16MA(aDestination, aRgbaMode);	

					}

				break;

			case TPngImageInformation::EAlphaDirectColor:

				if(aMask && (EColor16MA == mode || EColor16MU == mode || EColor16MAP == mode))

					{

					self = new (ELeave) CFastProcessor32bitTo32bitAndMask(aDestination, aMask, aRgbaMode);

					}

				else if(EColor16MA == mode)

					{

					self = new (ELeave) CFastProcessor16MAto16MA(aDestination, aRgbaMode);	

					}

				else if(EColor16MAP == mode)

					{

					self = new (ELeave) CFastProcessor16MAto16MAP(aDestination, aRgbaMode);	

					}

				else if(EColor16MU == mode)

					{

					self = new (ELeave) CFastProcessor16MAto16MU(aDestination, aRgbaMode);

					}

				else

					{

					User::Leave(KErrNotSupported);	

					}

				break;

			default:

				User::Leave(KErrNotSupported);

				break;				

			}		

		}

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self); 

	return self;	   

    }

/**

Destructor for this class.

Releases the lock for the current bitmap.

*/

CFastProcessor::~CFastProcessor()

    {

    }

/**

Second phase constructor.

Requests a lock for the current bitmap.

*/    

void CFastProcessor::ConstructL()

	{

	// NO-OP - reserved for changes at a later stage.

	}

/**

Default constructor 

*/

CFastProcessor::CFastProcessor(CFbsBitmap* aDestination, CFbsBitmap* aMask, TBool aRgbaMode)

    {

    iRgbaMode = aRgbaMode;

    if (!aRgbaMode)

	    {

	    iBitmap = aDestination;

	    iBitmapSize = iBitmap->SizeInPixels();	

		if (aMask)

			{

			ASSERT(aMask->SizeInPixels() == iBitmapSize);

			iMask = aMask;

			}

		}    	

	}

/**

Requests a lock for the current bitmap from the font & bitmap server and

sets the current position in the bitmap to the first pixel.

*/

void CFastProcessor::Begin()

	{

	if (!iRgbaMode)

		{

		if (iBitmapBuffer==NULL)

			{

			iBitmapBuffer = reinterpret_cast<TUint8*>( iBitmap->DataAddress() );

     		if (iMask)

     			{

     			iMaskBuffer = reinterpret_cast<TUint8*>( iMask->DataAddress() );

     			}

			}

		}

	}

/**

Releases a lock previously acquired using CFastProcessor::Begin().

*/

void CFastProcessor::End()

	{

	if (!iRgbaMode)

		{    

		if (iBitmapBuffer)

			{

			iBitmapBuffer = NULL;

			}

		if (iMaskBuffer)

			{

			iMaskBuffer = NULL;

			}

		}

	}

/**

Default constructor for this class.

*/

CFastProcessor16Mto16M::CFastProcessor16Mto16M(CFbsBitmap* aDestination, TBool aRgbaMode):

	CFastProcessor(aDestination, NULL, aRgbaMode)

    {}

/**

Sets an array of pixel values, starting at the current bitmap position using the

values supplied in aDataPtr.

@param  aDataPtr

        A pointer to the first element in the array.

@param  aDataPtrLimit

        A pointer to the last element in the array.

*/

void CFastProcessor16Mto16M::SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* /*aLineCache*/, TPoint& /*aPos*/)

    {       

    TUint8* scanLinePtr = (iBitmapBuffer + KPngDepth3BytesPerPixel * ( iPos.iX +  iPos.iY * (( (iBitmapSize.iWidth + 3)>>2)<<2))); //aligns the specified value onto a 4-byte boundary.

    iPos.iX += TUint(aDataPtrLimit - aDataPtr) / KPngDepth3BytesPerPixel;

    while (aDataPtr < aDataPtrLimit)

        {

        scanLinePtr[0] = aDataPtr[2];

        scanLinePtr[1] = aDataPtr[1];

        scanLinePtr[2] = aDataPtr[0];

 		scanLinePtr += KPngDepth3BytesPerPixel;

        aDataPtr += KPngDepth3BytesPerPixel;

        }

    while (iPos.iX >= iBitmapSize.iWidth)

        {

        iPos.iY++;

        iPos.iX -= iBitmapSize.iWidth;

        }

    }

/**

Default constructor for this class.

*/

CFastProcessor16Mto16MA::CFastProcessor16Mto16MA(CFbsBitmap* aDestination, TBool aRgbaMode):

	CFastProcessor(aDestination, NULL, aRgbaMode)

    {}

/**

Sets an array of pixel values, starting at the current bitmap position using the

values supplied in aDataPtr.

@param  aDataPtr

        A pointer to the first element in the array.

@param  aDataPtrLimit

        A pointer to the last element in the array.

//used only if RgbaMode i.e MNG processing        

@param  aLineCache

        A pointer to current scanline buffer.

@param  aPos

        Current pixel position.

*/

void CFastProcessor16Mto16MA::SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos)

    {

    TUint32* scanLinePtr;

    if (!iRgbaMode)

	    {

		scanLinePtr = (TUint32*)(iBitmapBuffer + (KPngDepth3BytesPerPixel + 1) * ( iPos.iX +  iPos.iY * iBitmapSize.iWidth));

		iPos.iX += TUint(aDataPtrLimit - aDataPtr) / KPngDepth3BytesPerPixel;

	    }

	else

		{

		scanLinePtr = reinterpret_cast<TUint32*>(aLineCache);

		aPos.iX = TUint(aDataPtrLimit - aDataPtr) / KPngDepth3BytesPerPixel;

		}

    while (aDataPtr < aDataPtrLimit)

        {

        *scanLinePtr++ = ((TUint32)0xFF << 24) | ((TUint32)aDataPtr[0] << 16) | ((TUint32)aDataPtr[1] << 8) | aDataPtr[2]; 

        aDataPtr += KPngDepth3BytesPerPixel;

        }

	if (!iRgbaMode)

		{

	    while (iPos.iX >= iBitmapSize.iWidth)

	        {

	        iPos.iY++;

	        iPos.iX -= iBitmapSize.iWidth;

	        }              

		}

    }

/**

Default constructor for this class.

*/

CFastProcessor16MAto16MA::CFastProcessor16MAto16MA(CFbsBitmap* aDestination, TBool aRgbaMode):

	CFastProcessor(aDestination, NULL, aRgbaMode)

    {}

/**

Sets an array of pixel values, starting at the current bitmap position using the

values supplied in aDataPtr.

@param  aDataPtr

        A pointer to the first element in the array.

@param  aDataPtrLimit

        A pointer to the last element in the array.

//used only if RgbaMode i.e MNG processing        

@param  aLineCache

        A pointer to current scanline buffer.

@param  aPos

        Current pixel position.

*/

void CFastProcessor16MAto16MA::SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos)

    {

    TUint32* scanLinePtr;

    if (!iRgbaMode)

	    {

    	scanLinePtr = (TUint32*)(iBitmapBuffer + KPngDepth4BytesPerPixel * ( iPos.iX + iPos.iY * iBitmapSize.iWidth));

    	iPos.iX += TUint(aDataPtrLimit - aDataPtr) / KPngDepth4BytesPerPixel;	    	

	    }

    else

	    {

		scanLinePtr = reinterpret_cast<TUint32*>(aLineCache);

		aPos.iX = TUint(aDataPtrLimit - aDataPtr) / KPngDepth4BytesPerPixel;	    	

	    }

    while (aDataPtr + sizeof(TUint32) < aDataPtrLimit)

        {       

        TUint32 pixel1 = *(TUint32*) aDataPtr;

        aDataPtr += KPngDepth4BytesPerPixel;

        TUint32 pixel2 = *(TUint32*) aDataPtr;

        aDataPtr += KPngDepth4BytesPerPixel;

        pixel1 = (pixel1 & 0xFF00FF00) | ((pixel1 & 0xFF)<<16) | ((pixel1>>16) & 0xFF);

        pixel2 = (pixel2 & 0xFF00FF00) | ((pixel2 & 0xFF)<<16) | ((pixel2>>16) & 0xFF);

        *scanLinePtr++ = pixel1;

        *scanLinePtr++ = pixel2;

        }

    if (aDataPtr + sizeof(TUint32) == aDataPtrLimit)

    	{

    	TUint32 pixel1 = *(TUint32*) aDataPtr;

    	*scanLinePtr = (pixel1 & 0xFF00FF00) | ((pixel1 & 0xFF)<<16) | ((pixel1>>16) & 0xFF);

    	}        

	if (!iRgbaMode)

		{

	    while (iPos.iX >= iBitmapSize.iWidth)

	        {

	        iPos.iY++;

	        iPos.iX -= iBitmapSize.iWidth;

	        }		

		}

    }

/**

Default constructor for this class.

*/

CFastProcessor16MAto16MAP::CFastProcessor16MAto16MAP(CFbsBitmap* aDestination, TBool aRgbaMode):

	CFastProcessor(aDestination, NULL, aRgbaMode)

    {}

/**

Sets an array of pixel values, starting at the current bitmap position using the

values supplied in aDataPtr.

@param  aDataPtr

        A pointer to the first element in the array.

@param  aDataPtrLimit

        A pointer to the last element in the array.

//used only if RgbaMode i.e MNG processing        

@param  aLineCache

        A pointer to current scanline buffer.

@param  aPos

        Current pixel position.

*/

// function to convert PNG pixel to 16MAP pixel

static TUint32 PngTo16Map(TUint32 aPngPixel)

	{

	TUint8 const alpha = TUint8( aPngPixel >> 24 );

	if (alpha == 0)

		{

		aPngPixel = 0;

		}

	else

		{

		// PNG bytes position in TUint32 are ABGR and must be coverted to ARGB in our case

		if (alpha == 0xff)

			{

			aPngPixel = (aPngPixel & 0xFF00FF00) | ((aPngPixel & 0xFF) << 16) | ((aPngPixel >> 16) & 0xFF);

			}

		else

			{   

			// Use a bias value of 128 rather than 255, but also add 1/256 of the numerator 

			// before dividing the sum by 256.

			TUint32 scaledRB = (aPngPixel & KRBMask) * alpha + KRBBias;

			scaledRB = (scaledRB + ( (scaledRB >> 8) & KRBMask) ) >> 8;

			// swap now the R & B channels

			scaledRB = (scaledRB << 16) | (scaledRB >> 16);

			TUint32 scaledG = (aPngPixel & KGMask) * alpha + KGBias;

			scaledG = (scaledG + (scaledG >> 8)) >> 8;

			// compose the new pixel swapping R with B as we premultiplied alpha on a PNG pixel 

			aPngPixel = (aPngPixel & KAMask) | (scaledRB & KRBMask) | (scaledG & KGMask); 

			}

		}

	return aPngPixel;

	}

void CFastProcessor16MAto16MAP::SetPixels(const TUint8* aDataPtr, const TUint8* aDataPtrLimit, TRgb* aLineCache, TPoint& aPos)

    {

    TUint32* scanLinePtr;

	if (!iRgbaMode)

		{

		scanLinePtr = (TUint32*)(iBitmapBuffer + KPngDepth4BytesPerPixel * ( iPos.iX +  iPos.iY * iBitmapSize.iWidth));

		iPos.iX += TUint(aDataPtrLimit - aDataPtr) / KPngDepth4BytesPerPixel;      

		}

	else

		{

		scanLinePtr = reinterpret_cast<TUint32*>(aLineCache);

		aPos.iX = TUint(aDataPtrLimit - aDataPtr) / KPngDepth4BytesPerPixel;      

		}

	// perform a direct conversion PNG -> Pixel 16MAP

    while (aDataPtr + sizeof(TUint32) < aDataPtrLimit)

		{

		TUint32 pixel1 = *(TUint32*) aDataPtr;

		aDataPtr += KPngDepth4BytesPerPixel;

		TUint32 pixel2 = *(TUint32*) aDataPtr;

		aDataPtr += KPngDepth4BytesPerPixel;

		pixel1 = PngTo16Map(pixel1);

		pixel2 = PngTo16Map(pixel2);

		*scanLinePtr++ = pixel1;

		*scanLinePtr++ = pixel2;

		}

    if (aDataPtr + sizeof(TUint32) == aDataPtrLimit)

		{

		*scanLinePtr = PngTo16Map(*(TUint32*) aDataPtr);

		}

 	if (!iRgbaMode)

  		{

		while (iPos.iX >= iBitmapSize.iWidth)

			{

			iPos.iY++;

			iPos.iX -= iBitmapSize.iWidth;

			}  

		}

    }

/**

Default constructor for this class.

*/

CFastProcessor32bitTo32bitAndMask::CFastProcessor32bitTo32bitAndMask(CFbsBitmap* aDestination, CFbsBitmap* aMask, TBool aRgbaMode)

: CFastProcessor(aDestination, aMask, aRgbaMode)

	{}

/**

Sets an array of pixel values, starting at the current bitmap position using the