// 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:

//

#ifndef __PNGCODEC_H__

#define __PNGCODEC_H__

#include <bitdev.h>

#include <ezcompressor.h>

#include <ezdecompressor.h>

#include <icl/imageprocessor.h>

#include <icl/imagecodec.h>

#include "PNGConvert.h"

/** @file

	@internalComponent */

// Constants.

const TInt KPngFileSignatureLength = 8;

const TUint8 KPngSignature[KPngFileSignatureLength] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };

const TInt KPngChunkIdSize = 4;

const TInt KPngMaxPLTESize = 256;

const TInt KPngNumInterlacedPasses = 8; // 7 passes plus a safety entry

const TInt KPngChunkLengthSize = 4;

const TInt KPngChunkCRCSize = 4;

const TInt KPngIHDRChunkSize = 13;

const TInt KPngIENDChunkSize = 0;

const TInt KPngcHRMChunkSize = 32;

const TInt KPnggAMAChunkSize = 4;

const TInt KPngpHYsChunkSize = 9;

const TInt KPngtIMEChunkSize = 7;

// KPngMaxImageSize is the maximum size for width and height, as defined in the PNG Specification v1.0 page 14

const TUint KPngMaxImageSize = ((TUint)2 << 30) - 1;

const TInt KPngCrcTableLength = 256;

const TUint KPngCrcMask = 0xffffffff;

_LIT8(KPngIHDRChunkId,"IHDR");

_LIT8(KPngPLTEChunkId,"PLTE");

_LIT8(KPngIDATChunkId,"IDAT");

_LIT8(KPngIENDChunkId,"IEND");

_LIT8(KPngbKGDChunkId,"bKGD");

_LIT8(KPngpHYsChunkId,"pHYs");

_LIT8(KPngtRNSChunkId,"tRNS");

_LIT8(KPngZTXTChunkId,"zTXt");

_LIT8(KPngITXTChunkId,"iTXt");

_LIT8(KPngTEXTChunkId,"tEXt");

// Helper classes.

// TPngImageInformation

class TPngImageInformation : public TFrameInfo

	{

public:

	TPngImageInformation();

public:

	enum TColorElements

		{

		EMonochrome = 0x0,

		EPaletteUsed = 0x1,

		EColorUsed = 0x2,

		EAlphaChannelUsed = 0x4

		};

	enum TColorType

		{

		EGrayscale = EMonochrome, // 0

		EDirectColor = EColorUsed, // 2

		EIndexedColor = EColorUsed | EPaletteUsed, // 3

		EAlphaGrayscale = EMonochrome | EAlphaChannelUsed, // 4

		EAlphaDirectColor = EColorUsed | EAlphaChannelUsed // 6

		};

	enum TCompressionMethod

		{

		EDeflateInflate32K = 0

		};

	enum TFilterMethod

		{

		EAdaptiveFiltering = 0

		};

	enum TInterlaceMethod

		{

		ENoInterlace = 0,

		EAdam7Interlace = 1

		};

	enum TPhysicalUnits

		{

		EUnknownUnits = 0,

		EMeters = 1

		};

public:

	// IHDR chunk

	TSize iSize; // iWidth/iHeight = 1 ... (2^31)-1

	TInt iBitDepth; // 1,2,4,8,16 subject to color type restrictions

	TColorType iColorType; // 0,2,3,4,6

	TCompressionMethod iCompressionMethod; // 0

	TFilterMethod iFilterMethod; // 0

	TInterlaceMethod iInterlaceMethod; // 0 or 1

	// PLTE chunk

	TBool iPalettePresent;

	TRgb iPalette[KPngMaxPLTESize];

	// bKGD chunk

	TBool iBackgroundPresent;

//	TRgb iBackgroundColor; // declared in TFrameInfo

	// pHYs chunk

	TBool iPhysicalPresent;

	TPhysicalUnits iPhysicalUnits;

	TSize iPhysicalSize;

	// tRNS chunk

	TBool iTransparencyPresent;

	TUint16 iTransparentGray;

	TUint16 iTransparentRed;

	TUint16 iTransparentGreen;

	TUint16 iTransparentBlue;

	TUint8 iTransparencyValue[KPngMaxPLTESize];

	};

/**

The Base class for different conversion types.

It is used when Image Processor is ignored for decoding 24 (or 32) bpp non-interlaced PNG images into 24 (or 32 bpp).

All subclasses should provide implementations of SetPixels().

*/

class CFastProcessor : public CBase

	{

public:

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

    virtual ~CFastProcessor();

    void End();

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

    void Begin();

private:    

	void ConstructL();

protected:

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

    CFbsBitmap* iBitmap;

    CFbsBitmap* iMask;

    TUint8* iBitmapBuffer;

    TUint8* iMaskBuffer;

    TSize iBitmapSize;

    TPoint iPos;

    TBool iRgbaMode;

	};

// Read codec

class CPngReadSubCodec : public CBase

	{

public:

	static CPngReadSubCodec* NewL(CImageProcessor* aImageProc,CImageProcessor* aMaskProc,const TPngImageInformation& aInfo, CFastProcessor* aFastProc, TBool aFastProcessorMode);

	virtual ~CPngReadSubCodec();

	TDes8& FirstBuffer();

	TDes8& DecodeL();

	void ResetL();

	void SetRgbaMode(TBool aMode);

	void Start();

	void Complete();

	void SetAlphaMode(TBool aMode);

protected:

	CPngReadSubCodec();

	void WritePixel(TRgb aPixelColor);

	void WritePixel(TRgb aPixelColor,TUint8 aAlphaValue);

private:

	void ConstructL(CImageProcessor* aImageProc,CImageProcessor* aMaskProc,const TPngImageInformation& aInfo,CFastProcessor* aFastProc, TBool aFastProcessorMode);

	void FilterScanlineDataL(TUint8* aDataPtr,const TUint8* aDataPtrLimit);

	TInt PaethPredictor(TInt aLeft,TInt aAbove,TInt aAboveLeft);

	virtual void DoConstructL() = 0;

	virtual TInt ScanlineBufferSize(TInt aPixelLength) = 0;

	virtual void DoDecode(TUint8* aDataPtr,const TUint8* aDataPtrLimit) = 0;

	void UpdatePos();

	TInt ClampValue(TInt aValue, TInt aMinValue, TInt aMaxValue) const;

	void SetFastProcessorMode(TBool aMode); //Sets iFastProcessorMode to True or False

protected:

	CImageProcessor* iImageProc;

	CImageProcessor* iMaskProc;

	TPngImageInformation iInfo;

	TInt iScanlineBufferSize;

	TInt iBytesPerPixel;

	HBufC8* iScanlineBuffer1;

	HBufC8* iScanlineBuffer2;

	TPtr8 iScanlineDes1;

	TPtr8 iScanlineDes2;

	TInt iCurrentScanlineBuffer;

	TInt iInterlacedScanlineBufferSize[KPngNumInterlacedPasses];

	TInt iPass;

	TPoint iPos;

	TBool iRgbaMode;

	TRgb* iLineCache;

	TBool iFastProcessorMode; //Sets the current mode

	CFastProcessor* iFastProc;

	TBool iAlphaMode; // Are we decoding to a bitmap that contains an alpha channel?

	};

class MPngDecoder;

class CPngReadCodec : public CImageMaskProcessorReadCodec, public MEZBufferManager

	{

public:

	~CPngReadCodec();

	static CPngReadCodec* NewL(MPngDecoder& aDecoderIFace);

	void SetImageProcessor(CImageProcessor* aImageProc, TBool aOwnsProcessor=ETrue);

	void SetMaskProcessor(CImageProcessor* aMaskProc, TBool aOwnsProcessor=ETrue);

	void SetFastProcessor(CFastProcessor* aFastProc, TBool aOwnsProcessor=ETrue);

	CImageProcessor* MaskProcessor() const;

	CImageProcessor* ImageProcessor() const;

	CFastProcessor* FastProcessor() const;

		// From CImageReadCodec

	virtual void InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, TBool aDisableErrorDiffusion, CFbsBitmap& aDestination, CFbsBitmap* aDestinationMask);

	virtual void InitFrameHeader(TFrameInfo& aFrameSettings, CFrameImageData& /* aFrameImageData */);

	TFrameState ProcessFrameHeaderL(TBufPtr8& aData);

	TFrameState ProcessFrameL(TBufPtr8& aSrc);

	TBool DoProcessDataL();

	void GetNewDataPosition(TInt& aPosition, TInt&  /*aLength*/ );

	TBool SkipImageProcessor(CFbsBitmap& aDestination); //Checks if Image processor is to be used or skipped. If returns ETrue then skip ImageProcessor 

	void Complete();

	void SetMissingiENDChunkFail(TBool aValue);

protected:

	CPngReadCodec(MPngDecoder& aDecoderIFace);

	void ConstructL();

protected:

	virtual void DoProcessPLTEL(const TUint8* aDataPtr,TInt aChunkLength);

	virtual void DoProcesstRNSL(const TUint8* aDataPtr,TInt aChunkLength);

	virtual void DoProcessbKGDL(const TUint8* aDataPtr,TInt aChunkLength);

	virtual void DoProcesspHYsL(const TUint8* aDataPtr,TInt aChunkLength);

private:

	void DoProcessInfoL(const TUint8*& aDataPtr,const TUint8* aDataPtrLimit);

	void DoProcessIHDRL(const TUint8* aDataPtr,TInt aChunkLength);

	TBool SetupProcessData(TBufPtr8& aSrc,

						   TUint8* aStartDataPtr,

						   const TUint8*& aDataPtr,

						   const TUint8* aDataPtrLimit);

	// From MEZBufferManager

	virtual void InitializeL(CEZZStream &aZStream);

	virtual void NeedInputL(CEZZStream &aZStream);

	virtual void NeedOutputL(CEZZStream &aZStream);

	virtual void FinalizeL(CEZZStream &aZStream);

protected:

	MPngDecoder& iDecoderIFace;

	TFrameInfo* iFrameInfo;

	TPngImageInformation iImageInfo;

	TBuf8<KPngChunkIdSize> iChunkId;

	TInt iChunkBytesRemaining;

	CPngReadSubCodec* iDecoder;

	CEZDecompressor* iDecompressor;

	TPtrC8 iDataDes;

	// used for async decode...

	const TUint8* iDataPtr;

	TBufPtr8* iSavedSrc;

	TUint8* iStartDataPtr;

	CImageProcessor* iImageProc;

	TBool iOwnsImageProcessor;

	CImageProcessor* iMaskProc;

	TBool	iOwnsMaskProcessor;

	CFastProcessor* iFastProc;

	TBool	iOwnsFastProcessor;

private:	

	TInt iNewPosition;

	TBool iReadMore;

	TBool iPreviousChunkReadFailed;

	TBool iMissingiENDChunkFail;

	TInt iPreviousDataPos;

	TInt iPreviousDataLength;

	};

// Write sub-codec

class CPngWriteSubCodec : public CBase

	{

public:

	static CPngWriteSubCodec* NewL(const TPngImageInformation& aInfo, const CFbsBitmap* aSource);

	virtual ~CPngWriteSubCodec();

protected:

	CPngWriteSubCodec();

private:

	void ConstructL(const TPngImageInformation& aInfo, const CFbsBitmap* aSource);

public:

	TDes8& Buffer();

	inline TInt BufferSize() const;

	TDes8& EncodeL(const TInt aScanline);

	inline CPalette* Palette() const;

protected:

	TUint8 ReverseBits(const TUint8 aValue) const;

	void EncodePalettedScanline(TUint8* aDataPtr, const CFbsBitmap* aSource, const TInt aScanline,

								const TInt aPixelsPerByte, const TInt aShiftValue);

private:

	virtual void DoConstructL();

	virtual TInt ScanlineBufferSize(TInt aPixelLength) = 0;

	virtual void DoEncode(const CFbsBitmap* aSource, const TInt aScanline,

					TUint8* aDataPtr, const TUint8* aDataPtrLimit) = 0;

protected:

	TPngImageInformation iInfo;

	const CFbsBitmap* iSource;

	TInt iScanlineBufferSize;

	HBufC8* iScanlineBuffer;

	TPtr8 iScanlineDes;

	CPalette* iPalette;

	friend class RPngWriteSubCodecTest;

	};

// Write codec

class CPngWriteCodec : public CImageWriteCodec, public MEZBufferManager

	{

private:

	enum TPngEncoderState

		{

		EPngInit,		// Initialize compressor

		EPngDeflate,	// Deflate encoded image data

		EPngWritePLTE,	// Write PLTE chunk

		EPngWriteIDAT,	// Write IDAT chunk

		EPngEndChunk	// Write end chunk

		};

public:

	static CPngWriteCodec* NewL(CPngEncoder& aPlugin, TInt aBpp, TBool aColor, TBool aPaletted, TInt aCompressionLevel);

	virtual ~CPngWriteCodec();

public:

	void GetCrc(TUint32& aCrc, const TUint8* aPtr, const TInt aLength);

	TBool DeflateEncodedDataL();

private:

	CPngWriteCodec(CPngEncoder& aPlugin, TInt aBpp, TBool aColor, TBool aPaletted, TInt aCompressionLevel);

	void WritePngChunk(TUint8*& aDestPtr, const TDesC8& aChunkId, const TDesC8& aData, TInt& aLength);

	void InitializeCompressorL(TBufPtr8& aDst);

	void SetCompressorOutputL(TBufPtr8& aDst);

	void WritePLTEChunk(TBufPtr8& aDst);

	void WriteIDATChunk(TBufPtr8& aDst);

	void WriteEndChunk(TBufPtr8& aDst);

	TInt WriteHeaderChunk(TBufPtr8& aDst);

	void GetImageDataL(TInt& aBytesToProcess);

	void GetPngScanLine(TDes8& aBuf, const TPoint& aPixel, TInt& aLength);

	void CalcCrcTable();

	// from CImageWriteCodec

public:

	virtual void InitFrameL(TBufPtr8& aDst, const CFbsBitmap& aSource);

	virtual TFrameState ProcessFrameL(TBufPtr8& aDst);

	// from MEZBufferManager

private:

	virtual void InitializeL(CEZZStream &aZStream);

	virtual void NeedInputL(CEZZStream &aZStream);

	virtual void NeedOutputL(CEZZStream &aZStream);

	virtual void FinalizeL(CEZZStream &aZStream);

private:

	TUint32 iCrcTable[KPngCrcTableLength];

	TBool iCrcTableCalculated;

	CPngWriteSubCodec* iEncoder;

	TPngEncoderState iEncoderState;

	TInt iCompressionLevel;

	CEZCompressor* iCompressor;

	TInt iScanline;

	TUint8* iDestStartPtr;

	TUint8* iDestPtr;

	TUint8* iDestPtrLimit;

	TPngImageInformation iImageInfo;

	TPtr8 iCompressorPtr;	// data area for compressor to write to

	TBool iCallAgain;

	CPngEncoder& iPlugin;

	friend class RPngWriteCodecTest;

	};

#include "PngCodec.inl"

#endif // __PNGCODEC_H__