// 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:
// Licensed under US Patent No 4,558,302 and foreign counterparts
// 
//

#ifndef GIFCODEC_H
#define GIFCODEC_H

#include <icl/imageprocessor.h>
#include <icl/imagecodec.h>
#include <icl/imagecodecdata.h>

#include "GIFConvert.h"
#include "GIFFormat.h"

// Constants.
const TInt KGifMaxBits = 12;
const TInt KGifConversionTableSize = 1<<KGifMaxBits; // 4096
const TInt KGifHashTableSize = KGifConversionTableSize + 907; // a bit extra for 80% occupancy

const TUint8 KGifExtensionId = 0x21;
const TUint8 KGifImageDescriptorId = 0x2c;
const TUint8 KGifPlainTextExtensionId = 0x01;
const TUint8 KGifGraphicControlExtensionId = 0xf9;
const TUint8 KGifCommentExtensionId = 0xfe;
const TUint8 KGifApplicationExtensionId = 0xff;
const TInt KGifInitialCodeLengthSize = 1;
const TUint8 KGifFrameTerminatorId = 0x00;
const TUint8 KGifTerminatorId = 0x3b;
const TInt KGifCentiSecondsToMicroSeconds = 10000;

const TInt KMinGifGraphicControlBlkLen = 4;
const TInt KGifExtBlkHeaderSize = 3;
const TInt KPixelBufMaxSize = 2048;//to get proper optimization must not be less then 1024 
// (basically each additional 1024 pixels for the buffer adds about 5% to decoding speed 
// untill buffer size increases up to quarter a CPU cash size 

_LIT8(KAppIdNetscape, "NETSCAPE");
_LIT8(KAppAuthenticCode2_0, "2.0");

const TInt KAppIdBlockLength = 11;
const TInt KAppIdLength = 8;
const TInt KAppAuthenticCodeLength = 3;
const TInt KLoopIterationsOffset = 14;


// Read codec
class CGifReadCodec : public CImageMaskProcessorReadCodec
	{
public:
	virtual ~CGifReadCodec();

	static CGifReadCodec* NewL(TRgb* aGlobalPalette,TInt aBackgroundColorIndex, TSize aScreenSize, TBool aFastDecode);

	// From CImageReadCodec
	virtual void InitFrameHeader(TFrameInfo& aFrameSettings, CFrameImageData& aFrameImageData);
	virtual void InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, TBool aDisableErrorDiffusion, CFbsBitmap& aDestination, CFbsBitmap* aDestinationMask);
	virtual TFrameState ProcessFrameHeaderL(TBufPtr8& aData);
	virtual TFrameState ProcessFrameL(TBufPtr8& aSrc);
	void SetUseFrameSizeInPixels(TBool aUseFrameSizeInPixels);
private:
    typedef TUint32 TBitBuffer;
	typedef TUint16 T64KPixel;
	    
	void ConstructL();
	CGifReadCodec(TRgb* aGlobalPalette,TInt aBackgroundColorIndex, TSize aScreenSize, TBool aFastDecode);

	void DoProcessInfoL(const TUint8*& aDataPtr,const TUint8* aDataPtrLimit);
	void DoProcessExtensionL(const TUint8*& aDataPtr,const TUint8* aDataPtrLimit);
	void DoProcessImageDescriptorL(const TUint8*& aDataPtr,const TUint8* aDataPtrLimit);
	void DoProcessDataL();
	void DoSaveCommentsL();
	inline TInt ResetTableL();
	inline TInt NextCode(TBitBuffer& aBitBuffer, TInt& aBitBufSize, TInt aCurCodeLen);
	void WriteCodeL(TInt aCode);
	void WriteStringWithoutTransparency(TUint8* aOutputString, TInt aPixSize, TInt aNumOfPixels);
	void WriteStringWithTransparency(TUint8* aOutputString, TInt aPixSize, TUint32* aMaskString, TInt aNumOfPixels);
	
	inline void SetCurrentCodeLengthL(TInt aCodeLength);
	inline void UpdateYPos();
	void UpdateYPosInterlaced();
	void FlushPixBuffer(TInt aPixSize);
	
    template <class TPalType, TInt aPtrDelta> 
    inline TUint8* WriteGifBuffer(TUint8* aOutputStringPtr, TUint8* aOutputStringLimit);
    
private:
	
	T64KPixel* i64KPalette;
	const TRgb* iPalette;
	
	TInt iBackgroundColorIndex;
	TUint32 iOpaqueMask;
	TUint16 iTranspColIdx;
	TUint16 iBufMode;
	TInt16* iPrefixIndex;
	TUint8* iSuffixCode;
	TUint8* iOutputString;
		
	TUint32* iPixelBuffer;
	TInt     iPixBufCount;
	TInt     iPixRead;
	TInt     iPixBufferSize;
	
	TUint32* iMaskBuffer;

// do not change data members layout without a reason
// it is to have more efficient CPU caching	
	TInt iNextFree;
	TInt iBitBuffSize;
	TInt iCurrentCodeLength;
	TBitBuffer iBitBuffer;	
	
	const TUint8* iDataPtr;
	const TUint8* iDataPtrLimit;
	
	CImageProcessor* iImgProc;  // not owned
	CImageProcessor* iMaskProc; // not owned
	TUint8  iFirstChar;
	TUint8  iLatestPixSize;
	TInt iPreviousCode;
	TInt iClearCode;
	TInt iEoiCode;
    TPoint* iPPos;
    
	TBool iComplete;
	TInt iPass;
	TInt iYPosIncrement;

	TPoint iPositionOffset;
	TInt iReductionFactor;
	const TSize iScreenSize;

	TBool iTableReset;
	TInt iBlockId;
	TBool iReadingExtensionBlock;
	TBool iReadingCommentExtensionBlock;
	TBool iReadingOtherExtensionBlock;
	TBool iReadingLoopIterationExtensionBlock;

// Local frame settings.	
	TFrameInfo *iFrameInfo;
	CFrameImageData *iFrameData;	
	TRgb* iGlobalPalette;
	TUint8* iStartDataPtr;	//startDataPtr;

	RPointerArray<HBufC8> iComment;
	TInt iCommentIndex;

	// Temporary ImageData pointers. (Not owned by the codec)
	// These ones are used by convert only.
	TGifImageControl *iGifImageControl;
	TGifImageDescriptor *iGifImageDesc;
	TGifColorTable *iGifColorTable;
	TGifLZWInfo *iGifLZWInfo;

	// These ones are used by header processing only.
	TGifImageControl *iFrameImageControl;
	TGifImageDescriptor *iFrameImageDesc;
	TGifLZWInfo *iFrameLZWInfo;

	TSize iFirstFrameSize;
	TRect iFirstFrameCoords;

	TSize iFrameSize;
	TRect iFrameCoords;
	TPoint iFrameOffset;
	TBool iUseFrameSizeInPixels;
	TBool iFast64kMode;
	const TBool iFastDecode;
	TBool iFastAccessMode;
	};


// Write codec.
const TInt KGifBlockSize = 255;
const TInt KGifBufferSize = KGifBlockSize + 9;
class CGifEncoder;
class CGifWriteCodec : public CImageWriteCodec
	{
public:
	static CGifWriteCodec* NewL(const CGifEncoder& aEncoder);

	//From CImageWriteCodec
	virtual TFrameState ProcessFrameL(TBufPtr8& aDst);
protected:
	CGifWriteCodec(const CGifEncoder& aEncoder);

private:
	void InitFrameL(TBufPtr8& aDst, const CFbsBitmap& aSource);
	void AddToTableL(TInt aIndex, TUint32 aHashValue);
	TBool TableEntry(TInt16 aWaitingCode, TUint8 aNewCode, TInt& aIndex, TUint32& aHashValue);
	void ResetTable();
	void WriteData(TInt aIndex);
	void FillBufferL(const CFbsBitmap& aFrame);
	TBool WriteBuffer();
	TBool WriteTerminator();
private:
	TRect iSourceRect;
	TPoint iPos;
	TInt16 iWaitingCode;
	TInt16 iHashCode[KGifHashTableSize];   // must hold -1..(KGifConversionTableSize-1)
	TUint32 iHashValue[KGifHashTableSize]; // must hold  0..(KGifConversionTableSize-1)<<8|TUint8
	TUint8 iBuffer[KGifBufferSize];
	TUint8* iBufferPtr;
	TInt iBufferSize;
	TBool iBufferFull;
	TBool iImageComplete;
	TInt iCodeLength;
	TInt iNextLimit;
	TInt iClearCode;
	TInt iNextFree;
	TInt iBitsPerPixel;
	TInt iBitOffset;
	TUint8* iDestStartPtr;
	TUint8* iDestPtr;
	TUint8* iDestPtrLimit;
	const CGifEncoder& iEncoder;
	};

#endif // GIFCODEC_H