// Copyright (c) 1999-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 <fbs.h>

#include "ImageClientMain.h"

#include "ImageUtils.h"

#include "PNGCodec.h"

// Constants.

const TInt KTwipsPerMeter = 56693;

// Helper classes.

// TPngImageInformation

TPngImageInformation::TPngImageInformation()

	{

	iSize.SetSize(0,0);

	iBitDepth = 0;

	iColorType = EGrayscale;

	iCompressionMethod = EDeflateInflate32K;

	iFilterMethod = EAdaptiveFiltering;

	iInterlaceMethod = ENoInterlace;

	iPalettePresent = EFalse;

#if defined(_DEBUG)

	ASSERT(sizeof(TRgb)==sizeof(TUint32)); // ie no new fields

	ASSERT(KPngMaxPLTESize%4==0);

#endif  // defined(_DEBUG)

	TRgb* palette=iPalette;

	TInt i=KPngMaxPLTESize>>2;

	do 

		{

		*palette++ = KRgbBlack;

		*palette++ = KRgbBlack;

		*palette++ = KRgbBlack;

		*palette++ = KRgbBlack;

		} while (--i);

	iBackgroundPresent = EFalse;

	iBackgroundColor = KRgbWhite;

	iPhysicalPresent = EFalse;

	iPhysicalUnits = EUnknownUnits;

	iPhysicalSize.SetSize(0,0);

	iTransparencyPresent = EFalse;

	Mem::Fill(iTransparencyValue,KPngMaxPLTESize,0xff);

	}

// CMdaPngReadCodec

CPngReadCodec::~CPngReadCodec()

	{

	delete iDecoder;

	delete iDecompressor;

	if (iOwnsImageProcessor)

		{

		delete iImageProc;

		}

	if (iOwnsMaskProcessor)

		{

		delete iMaskProc;

		}

	if (iOwnsFastProcessor)

		{

		delete iFastProc;

		}		

	}

CPngReadCodec* CPngReadCodec::NewL(MPngDecoder& aDecoderIFace)

	{

	CPngReadCodec* self = new(ELeave) CPngReadCodec(aDecoderIFace);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self); 

	return self;

	}

CPngReadCodec::CPngReadCodec(MPngDecoder& aDecoderIFace):	

	iDecoderIFace(aDecoderIFace), iNewPosition(0), iReadMore(EFalse)

	{

	}

void CPngReadCodec::ConstructL()

	{

	CImageMaskProcessorReadCodec::ConstructL();

	}

void CPngReadCodec::InitFrameL(TFrameInfo& /*aFrameInfo*/, CFrameImageData& /*aFrameImageData*/, TBool aDisableErrorDiffusion, CFbsBitmap& aDestination, CFbsBitmap* aDestinationMask)

	{

	CFbsBitmap& newFrame = aDestination;

	iChunkBytesRemaining = 0;

	iChunkId = KNullDesC8;

	iPreviousChunkReadFailed = EFalse;

	const TSize destinationSize(newFrame.SizeInPixels());

	TInt reductionFactor = ReductionFactor(iImageInfo.iSize, destinationSize);

	TBool fastProcessorMode = EFalse;

	CImageProcessor* imageProc = NULL;

	SetImageProcessor(NULL);

	CImageProcessor* maskProc = NULL;

	SetMaskProcessor(NULL);

	CFastProcessor* fastProc = NULL;

	SetFastProcessor(NULL);

	if (!SkipImageProcessor(aDestination))

		{

		imageProc = ImageProcessorUtility::NewImageProcessorL(newFrame, reductionFactor, ERgb, aDisableErrorDiffusion);

		SetImageProcessor(imageProc);

		imageProc->PrepareL(newFrame,iImageInfo.iSize);

		if ((iImageInfo.iTransparencyPresent || (iImageInfo.iColorType & TPngImageInformation::EAlphaChannelUsed))

			&& aDestinationMask)

			{

			maskProc = ImageProcessorUtility::NewImageProcessorL(*aDestinationMask, iImageInfo.iSize, ERgb, aDisableErrorDiffusion);

			SetMaskProcessor(maskProc);

			maskProc->PrepareL(*aDestinationMask,iImageInfo.iSize);

			// set mask to black so that unknown parts on streamed image are not drawn

			ClearBitmapL(*aDestinationMask, KRgbBlack);

			}

		}

	else

		{

		fastProc = CFastProcessor::NewL(iImageInfo, &aDestination, aDestinationMask, EFalse);

		SetFastProcessor(fastProc);

		fastProcessorMode = ETrue;

		}

	delete iDecoder;

	iDecoder = NULL;

	iDecoder = CPngReadSubCodec::NewL(imageProc,maskProc,iImageInfo, fastProc, fastProcessorMode);

	if (!iDecompressor)

		{

		iDecompressor = CEZDecompressor::NewL(*this);

		}

	else

		{

		iDecompressor->ResetL(*this);

		}

	if (!aDestinationMask)

		{

		// if no mask, clear destination for sensible behaviour on streamed partial images

		TRgb background = iImageInfo.iBackgroundPresent ? iImageInfo.iBackgroundColor : KRgbWhite;

		ClearBitmapL(aDestination, background);

		if (aDestination.DisplayMode() == EColor16MA && iFrameInfo->iFlags & TFrameInfo::ETransparencyPossible)

			{

			iDecoder->SetAlphaMode(ETrue);

			}

		}

	}

void CPngReadCodec::InitFrameHeader(TFrameInfo& aFrameSettings, CFrameImageData& /* aFrameImageData */)

	{

	ASSERT(aFrameSettings.CurrentFrameState() == TFrameInfo::EFrameInfoUninitialised);

	iFrameInfo = &aFrameSettings;

	iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrameHeader);

	}

TFrameState CPngReadCodec::ProcessFrameHeaderL(TBufPtr8& aData)

	{

	const TUint8* startDataPtr = aData.Ptr();

	const TUint8* dataPtr = startDataPtr;

	const TUint8* dataPtrLimit = startDataPtr + aData.Length();

	if (iFrameInfo->CurrentFrameState() == TFrameInfo::EFrameInfoProcessingFrameHeader)

		{

		if (dataPtr + KPngChunkLengthSize + KPngChunkIdSize + KPngIHDRChunkSize + KPngChunkCRCSize > dataPtrLimit)

			User::Leave(KErrUnderflow);

		TInt chunkLength = PtrReadUtil::ReadBigEndianUint32Inc(dataPtr);

		TPtrC8 chunkId(dataPtr,KPngChunkIdSize);

		if (chunkLength != KPngIHDRChunkSize || chunkId != KPngIHDRChunkId)

			User::Leave(KErrNotFound);

		dataPtr += KPngChunkIdSize;

		DoProcessIHDRL(dataPtr,chunkLength);

		dataPtr += KPngIHDRChunkSize + KPngChunkCRCSize;

		}

	//When there is not enough buffer to read the chunk length and chunk id,

	//the input buffer is not increased, the decoder will not be able to read more data,

	//the test will stuck in infinite loop.

	//To break the infinite loop, here it checkes whether it's reading the same data as last time,

	//if so, leaves.	

	if ((iPreviousDataPos == iNewPosition) && (iPreviousDataLength == aData.Length()))

		{

		User::Leave(KErrUnderflow);

		}

	TRAPD(err, DoProcessInfoL(dataPtr, dataPtrLimit));

	iPreviousDataPos = iNewPosition;

	iPreviousDataLength = aData.Length();

	if (err != KErrNone)

		{

		if (err == KErrNotFound)

			return EFrameComplete;

		User::Leave(err); // A real error occured

		}

	if(iReadMore)

		{

		iReadMore = EFalse;

		iNewPosition += dataPtr - startDataPtr;

		return EFrameIncompleteRepositionRequest;

		}

	aData.Shift(dataPtr - startDataPtr);

	iFrameInfo->iFrameCoordsInPixels.SetRect(TPoint(0,0),iImageInfo.iSize);

	iFrameInfo->iOverallSizeInPixels = iImageInfo.iSize;

	if (iImageInfo.iPhysicalPresent && iImageInfo.iPhysicalUnits == TPngImageInformation::EMeters)

		iFrameInfo->iFrameSizeInTwips = iImageInfo.iPhysicalSize;

	else

		iFrameInfo->iFrameSizeInTwips.SetSize(0,0);

	iFrameInfo->iBitsPerPixel = iImageInfo.iBitDepth;

	if (iImageInfo.iColorType & TPngImageInformation::EColorUsed 

		 && iImageInfo.iColorType != TPngImageInformation::EIndexedColor)

		iFrameInfo->iBitsPerPixel *= 3;

	iFrameInfo->iDelay = 0;

	iFrameInfo->iFlags = TFrameInfo::ECanDither;

	if (iImageInfo.iColorType & (TPngImageInformation::EPaletteUsed | TPngImageInformation::EColorUsed))

		iFrameInfo->iFlags |= TFrameInfo::EColor;

	if (iImageInfo.iColorType & TPngImageInformation::EAlphaChannelUsed)

		{

		iFrameInfo->iFlags |= TFrameInfo::ETransparencyPossible;

		iFrameInfo->iFlags |= TFrameInfo::EAlphaChannel;

		}

	else if (iImageInfo.iTransparencyPresent)

		iFrameInfo->iFlags |= TFrameInfo::ETransparencyPossible;

	const TInt bitsPerPixel = iFrameInfo->iBitsPerPixel;

	// the best mode for colour-indexed images is 16m

	if (iImageInfo.iColorType == TPngImageInformation::EIndexedColor)

		iFrameInfo->iFrameDisplayMode = EColor16M;

	else if(bitsPerPixel == 1)

		iFrameInfo->iFrameDisplayMode = EGray2;

	else if(bitsPerPixel == 2)

		iFrameInfo->iFrameDisplayMode = EGray4;

	else if((bitsPerPixel > 2)&&(bitsPerPixel <= 4))

		iFrameInfo->iFrameDisplayMode = EGray16;

	else if((bitsPerPixel > 4)&&(bitsPerPixel <= 8))

		iFrameInfo->iFrameDisplayMode = EGray256;

	else if((bitsPerPixel > 8)&&(bitsPerPixel <= 12))

		iFrameInfo->iFrameDisplayMode = EColor4K;

	else if((bitsPerPixel > 8) && (!(iFrameInfo->iFlags & TFrameInfo::EColor)))

		iFrameInfo->iFrameDisplayMode = EGray256;

	else if((bitsPerPixel > 12)&&(bitsPerPixel <= 16))

		iFrameInfo->iFrameDisplayMode = EColor64K;

	else if((bitsPerPixel > 16)&&(bitsPerPixel <= 48))

		iFrameInfo->iFrameDisplayMode = EColor16M;

	else

		User::Leave(KErrCorrupt);

	if (iImageInfo.iBackgroundPresent)

		iFrameInfo->iBackgroundColor = iImageInfo.iBackgroundColor;

	iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingComplete);

	return EFrameComplete;

	}

TFrameState CPngReadCodec::ProcessFrameL(TBufPtr8& aSrc)

	{

	CImageProcessor*const imageProc = ImageProcessor();

	CImageProcessor*const maskProc = MaskProcessor();

	TUint8* startDataPtr = CONST_CAST(TUint8*,aSrc.Ptr());

	TUint8* dataPtr = startDataPtr;

	const TUint8* dataPtrLimit = dataPtr + aSrc.Length();

	TBool chunkReadFailed = EFalse;

	while (dataPtr < dataPtrLimit)

		{

		if (iChunkBytesRemaining == 0)

			{

			if (iChunkId != KNullDesC8)

				{

				// this is not the first chunk - need to skip the previous chunk's CRC

				// as well as reading this chunk's length and id

				if (dataPtr + KPngChunkCRCSize + KPngChunkLengthSize + KPngChunkIdSize > dataPtrLimit)

					{

					// not enough data

					chunkReadFailed = ETrue;

					break;

					}

				dataPtr += KPngChunkCRCSize;

				}

			else

				{				

				if (dataPtr + KPngChunkLengthSize + KPngChunkIdSize > dataPtrLimit)

					{

					// not enough data

					break;

					}

				}

			// read the current chunk's length and id

			iChunkBytesRemaining = PtrReadUtil::ReadBigEndianUint32Inc(const_cast<const TUint8*&>(dataPtr));

			if(iChunkBytesRemaining < 0 )

			    {

			    User::Leave(KErrCorrupt);

			    }

			iChunkId = TPtr8(dataPtr,KPngChunkIdSize,KPngChunkIdSize);

			dataPtr += KPngChunkIdSize;

			}

		if (iChunkId == KPngIDATChunkId)

			{

			if(SetupProcessData(aSrc, dataPtr, const_cast<const TUint8*&>(dataPtr), dataPtrLimit))

				iDecoderIFace.GoToProcessDataState();

			break;

			}

		else if (iChunkId == KPngIENDChunkId)

			{

			iDecompressor->InflateL();

			if (imageProc)

				{

				imageProc->FlushPixels();	

				}

			if (maskProc)

				{

				maskProc->FlushPixels();	

				}

			return EFrameComplete;

			}

		else // Skip other chunks

			{

			TInt bytesLeft = dataPtrLimit - dataPtr;

			if (bytesLeft >= iChunkBytesRemaining)

				{

				dataPtr += iChunkBytesRemaining;

				iChunkBytesRemaining = 0;

				}

			else

				{

				dataPtr += bytesLeft;

				iChunkBytesRemaining -= bytesLeft;

				}

			}

		}

	// allow decode of png files with missing IEND chunks

	if (!iMissingiENDChunkFail && chunkReadFailed && iPreviousChunkReadFailed)

		{

		// we're completely out of data but have finished a whole chunk

		// try to decode the image

		TBool moreDataNeeded = EFalse;

		TRAPD(err, moreDataNeeded = iDecompressor->InflateL());

		if ((err == KErrNone) && !moreDataNeeded)

			{

			if(imageProc)

				{

			 	imageProc->FlushPixels();

				}			

			if (maskProc)

				{

				maskProc->FlushPixels();

				}

			return EFrameComplete;

			}

		}

	iPreviousChunkReadFailed = chunkReadFailed;

	aSrc.Shift(dataPtr - startDataPtr);

	return EFrameIncomplete;

	}

void CPngReadCodec::DoProcessInfoL(const TUint8*& aDataPtr,const TUint8* aDataPtrLimit)

	{

	FOREVER

		{

		if (aDataPtr + KPngChunkLengthSize + KPngChunkIdSize > aDataPtrLimit) // Check there is enough data to read the chunk length

			{

			iNewPosition = 0 ;

			iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrame);

			iReadMore = ETrue;

			return;

			}

		TInt chunkLength = PtrReadUtil::ReadBigEndianUint32Inc(aDataPtr);

		TPtrC8 chunkId (&aDataPtr[0],KPngChunkIdSize);

		if (chunkId == KPngIDATChunkId)

			{

			aDataPtr -= KPngChunkLengthSize; // Rewind to start of chunkLength

			break;

			}

		if (aDataPtr + KPngChunkIdSize + chunkLength + KPngChunkCRCSize > aDataPtrLimit

			 || chunkLength < 0) // Check there is enough data to read the whole chunk

			{

			if (	chunkId == KPngPLTEChunkId || chunkId == KPngbKGDChunkId ||

					chunkId == KPngpHYsChunkId || chunkId == KPngtRNSChunkId )

				{

				aDataPtr -= KPngChunkLengthSize; // Rewind to start of chunkLength

				User::Leave(chunkLength < 0 ? KErrCorrupt : KErrUnderflow);

				}

			iNewPosition = KPngChunkIdSize + chunkLength + KPngChunkCRCSize;

			iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrame);

			iReadMore = ETrue;

			return;

			}

		aDataPtr += KPngChunkIdSize;

		if (chunkId == KPngPLTEChunkId)

			DoProcessPLTEL(aDataPtr,chunkLength);

		else if (chunkId == KPngbKGDChunkId)

			DoProcessbKGDL(aDataPtr,chunkLength);

		else if (chunkId == KPngpHYsChunkId)

			DoProcesspHYsL(aDataPtr,chunkLength);

		else if (chunkId == KPngtRNSChunkId)

			DoProcesstRNSL(aDataPtr,chunkLength);

		else if (chunkId == KPngIHDRChunkId || chunkId == KPngIENDChunkId)

			User::Leave(KErrCorrupt);

		aDataPtr += chunkLength;

		PtrReadUtil::ReadBigEndianUint32Inc(aDataPtr); // Skip crc value

		}

	}

void CPngReadCodec::DoProcessIHDRL(const TUint8* aDataPtr,TInt aChunkLength)

	{

	if (aChunkLength != KPngIHDRChunkSize)

		User::Leave(KErrCorrupt);

	iImageInfo.iSize.iWidth = PtrReadUtil::ReadBigEndianUint32Inc(aDataPtr);

	iImageInfo.iSize.iHeight = PtrReadUtil::ReadBigEndianUint32Inc(aDataPtr);

	iImageInfo.iBitDepth = aDataPtr[0];

	iImageInfo.iColorType = TPngImageInformation::TColorType(aDataPtr[1]);

	iImageInfo.iCompressionMethod = TPngImageInformation::TCompressionMethod(aDataPtr[2]);

	iImageInfo.iFilterMethod = TPngImageInformation::TFilterMethod(aDataPtr[3]);

	iImageInfo.iInterlaceMethod = TPngImageInformation::TInterlaceMethod(aDataPtr[4]);

	// Check is one of the PNG formats we support

	if (iImageInfo.iSize.iWidth < 1 || iImageInfo.iSize.iHeight < 1

		|| iImageInfo.iCompressionMethod != TPngImageInformation::EDeflateInflate32K

		|| iImageInfo.iFilterMethod != TPngImageInformation::EAdaptiveFiltering

		|| (iImageInfo.iInterlaceMethod != TPngImageInformation::ENoInterlace &&

		iImageInfo.iInterlaceMethod != TPngImageInformation::EAdam7Interlace))

		User::Leave(KErrCorrupt);

	/*

		Check if color type and bit depths are valid. 

		PNG image type		Color type		Allowed bit depths

		--------------      -----------     ------------------

		Greyscale				0				1, 2, 4, 8, 16

		Truecolour				2				8, 16

		Indexed-colour			3				1, 2, 4, 8

		Greyscale with alpha	4				8, 16

		Truecolour with alpha	6				8, 16

		  (See http://www.w3.org/TR/PNG/#11IHDR)

	*/

	switch(iImageInfo.iColorType)

		{

		case TPngImageInformation::EGrayscale: // 0

			{

				if (! (iImageInfo.iBitDepth == 1 

					|| iImageInfo.iBitDepth == 2 

					|| iImageInfo.iBitDepth == 4

					|| iImageInfo.iBitDepth == 8 

					|| iImageInfo.iBitDepth == 16))

				{

					User::Leave(KErrCorrupt); // Invalid bit depth for color type 0

				}

			}

			break;

		case TPngImageInformation::EDirectColor: // 2

		case TPngImageInformation::EAlphaGrayscale: // 4

		case TPngImageInformation::EAlphaDirectColor: // 6

			{

				if (! (iImageInfo.iBitDepth == 8 

					|| iImageInfo.iBitDepth == 16))

				{

					User::Leave(KErrCorrupt); // Invalid bit depth for color type 2 or 4 or 6

				}

			}

			break;

		case TPngImageInformation::EIndexedColor: //3

			{

				if (! (iImageInfo.iBitDepth == 1 

					|| iImageInfo.iBitDepth == 2 

					|| iImageInfo.iBitDepth == 4

					|| iImageInfo.iBitDepth == 8))

				{

					User::Leave(KErrCorrupt); // Invalid bit depth for color type 3

				}

			}

			break;

		default: // Invalid color depth.

			{

				User::Leave(KErrCorrupt);

			}

		}

	}