// Copyright (c) 2001-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 JPEGCODEC_H

#define JPEGCODEC_H

#include "JPEGConvert.h"

#include "pluginextensionmanager.h"

#include "fwextconstants.h"

#ifdef JPEG_DEBUG_OUTPUT

#define JPEG_DEBUG_LEAVES

#define JPEG_ASSERT(a)													\

	do																	\

		{																\

		if (!(a))														\

			{															\

			RDebug::Printf("*** Assertion failed: " #a);				\

			RDebug::Printf("*** " __FILE__ " at line %d", __LINE__);	\

			ASSERT(EFalse);												\

			}															\

		}																\

	while (EFalse)

// Parameter 'a' should be a C-style string.

#define JPEG_DEBUG1(a)			RDebug::Printf("JPEG: " a)

#define JPEG_DEBUG2(a, b)		RDebug::Printf("JPEG: " a, b)

#define JPEG_DEBUG3(a, b, c)	RDebug::Printf("JPEG: " a, b, c)

#define JPEG_DEBUG4(a, b, c, d)	RDebug::Printf("JPEG: " a, b, c, d)

#define JPEG_DEBUG5(a, b, c, d, e)	RDebug::Printf("JPEG: " a, b, c, d, e)

#define JPEG_DEBUG6(a, b, c, d, e, f) RDebug::Printf("JPEG: " a, b, c, d, e, f)

#define JPEG_DEBUG7(a, b, c, d, e, f, g) RDebug::Printf("JPEG: " a, b, c, d, e, f, g)

#define JPEG_DEBUG8(a, b, c, d, e, f, g, h) RDebug::Printf("JPEG: " a, b, c, d, e, f, g, h)

#else

#define JPEG_ASSERT(a)

#define JPEG_DEBUG1(a)

#define JPEG_DEBUG2(a, b)

#define JPEG_DEBUG3(a, b, c)

#define JPEG_DEBUG4(a, b, c, d)

#define JPEG_DEBUG5(a, b, c, d, e)

#define JPEG_DEBUG6(a, b, c, d, e, f)

#define JPEG_DEBUG7(a, b, c, d, e, f, g)

#define JPEG_DEBUG8(a, b, c, d, e, f, g, h)

#endif

#ifdef JPEG_DEBUG_LEAVES

// A more debugging friendly way of leaving.

// The temporary variable is absolutely necessary and will break code if removed.

#define JPEG_LEAVE_IF_ERROR(err, reason)									\

	do																		\

		{																	\

		TInt temp = err;													\

		if (temp != KErrNone)												\

			{																\

			RDebug::Printf("JPEG: *** Leave(%d): %d \"" reason "\"", __LINE__, temp);	\

			User::Leave(temp);												\

			}																\

		}																	\

	while (EFalse)

// A more debugging friendly way of leaving.

#define JPEG_LEAVE(err, reason) 										\

	do																	\

		{																\

		TInt temp = err;												\

		RDebug::Printf("JPEG: *** Leave(%d): %d \"" reason "\"", __LINE__, temp);	\

		User::Leave(temp);												\

		}																\

	while (EFalse)

#else

#define JPEG_LEAVE_IF_ERROR(err, reason)	User::LeaveIfError(err)

#define JPEG_LEAVE(err, reason)			User::Leave(err)

#endif

class CImageFrame;

class CRawColorProcessor;

class CJpgImageFrameProcessor;

class TJpgFrameInfo;

class TDataUnit;

class TJpgScanInfo;

class CJpegDecoder;

// CJpgImageFrameReadCodec

class CJpgImageFrameReadCodec : public CBase

	{

public:

	static CJpgImageFrameReadCodec* NewL(CImageFrame* aFrame);

	~CJpgImageFrameReadCodec();

	void CreateImageProcessorL(const TJpgFrameInfo& aFrameInfo);		

	void ProcessL(const RArray<const TDataUnit*>& compPtr);

	CImageFrame* Destination();

	void SetImageFrameBlocksL(CImageFrame* aFrame, const TJpgFrameInfo& aFrameInfo);

private:

	CJpgImageFrameReadCodec(CImageFrame* aFrame);

private:

	CImageFrame* iDestination;

	CJpgImageFrameProcessor* iImageFrameProcessorPtr;

	};

//

// CJpgReadCodec

// The base class for all JPEG decoding.

//

class CJpgReadCodec : public CImageProcessorReadCodecExtension

	{

public:

	friend class CSequentialJpgReadCodec;

	friend class CMultiScanSequentialJpgReadCodec;

	//

	// Values and explanations are based on the book

	// "JPEG Still Image Data Compression Standard" by W.B.Pennebaker and J.L.Mitchell.

	//

	enum

		{

		EMarkerEscape = 0xFF00,	// Not really a marker but used to escape valid 0xFF bitstream sequences.

		EMarkerTEM = 0xFF01,	// For temporary use in arithmetic coding.

		EMarkerRES0 = 0xFF02,	// Reserved.

		EMarkerRESn = 0xFFBF,	// ...

		EMarkerSOF0 = 0xFFC0,	// Baseline DCT.

		EMarkerSOF1 = 0xFFC1,	// Extended sequential DCT.

		EMarkerSOF2 = 0xFFC2,	// Progressive DCT.

		EMarkerSOF3 = 0xFFC3,	// Lossless (sequential).

		EMarkerDHT = 0xFFC4,	// Define Huffman table(s).

		EMarkerSOF5 = 0xFFC5,	// Differential sequential DCT.

		EMarkerSOF6 = 0xFFC6,	// Differential progressive DCT.

		EMarkerSOF7 = 0xFFC7,	// Differential lossless.

		EMarkerJPG = 0xFFC8,	// Reserved.

		EMarkerSOF9 = 0xFFC9,	// Extended sequential DCT.

		EMarkerSOF10 = 0xFFCA,	// Progressive DCT.

		EMarkerSOF11 = 0xFFCB,	// Lossless (sequential).

		EMarkerDAC = 0xFFCC,	// Define arithmetic conditioning table(s).

		EMarkerSOF13 = 0xFFCD,	// Differential sequential DCT.

		EMarkerSOF14 = 0xFFCE,	// Differential progressive DCT.

		EMarkerSOF15 = 0xFFCF,	// Differential lossless.

		EMarkerRST0 = 0xFFD0,	// First restart marker.

		EMarkerRST1 = 0xFFD1,	// ...

		EMarkerRST2 = 0xFFD2,	// ...

		EMarkerRST3 = 0xFFD3,	// ...

		EMarkerRST4 = 0xFFD4,	// ...

		EMarkerRST5 = 0xFFD5,	// ...

		EMarkerRST6 = 0xFFD6,	// ...

		EMarkerRST7 = 0xFFD7,	// Last restart marker.

		EMarkerSOI = 0xFFD8,	// Start of image.

		EMarkerEOI = 0xFFD9,	// End of image.

		EMarkerSOS = 0xFFDA,	// Start of scan.

		EMarkerDQT = 0xFFDB,	// Define quantization table(s).

		EMarkerDNL = 0xFFDC,	// Define number of lines.

		EMarkerDRI = 0xFFDD,	// Define restart interval.

		EMarkerDHP = 0xFFDE,	// Define hierarchical progression.

		EMarkerEXP = 0xFFDF,	// Expand reference image(s).

		EMarkerAPP0 = 0xFFE0,	// Reserved for application use.

		EMarkerAPP1 = 0xFFE1,	// ...

		EMarkerAPP2 = 0xFFE2,	// ...

		EMarkerAPP3 = 0xFFE3,	// ...

		EMarkerAPP4 = 0xFFE4,	// ...

		EMarkerAPP5 = 0xFFE5,	// ...

		EMarkerAPP6 = 0xFFE6,	// ...

		EMarkerAPP7 = 0xFFE7,	// ...

		EMarkerAPP8 = 0xFFE8,	// ...

		EMarkerAPP9 = 0xFFE9,	// ...

		EMarkerAPP10 = 0xFFEA,	// ...

		EMarkerAPP11 = 0xFFEB,	// ...

		EMarkerAPP12 = 0xFFEC,	// ...

		EMarkerAPP13 = 0xFFED,	// ...

		EMarkerAPP14 = 0xFFEE,	// ...

		EMarkerAPP15 = 0xFFEF,	// ...

		EMarkerJPG0 = 0xFFF0,	// Reserved for JPEG extensions.

		EMarkerJPG1 = 0xFFF1,	// ...

		EMarkerJPG2 = 0xFFF2,	// ...

		EMarkerJPG3 = 0xFFF3,	// ...

		EMarkerJPG4 = 0xFFF4,	// ...

		EMarkerJPG5 = 0xFFF5,	// ...

		EMarkerJPG6 = 0xFFF6,	// ...

		EMarkerJPG7 = 0xFFF7,	// ...

		EMarkerJPG8 = 0xFFF8,	// ...

		EMarkerJPG9 = 0xFFF9,	// ...

		EMarkerJPG10 = 0xFFFA,	// ...

		EMarkerJPG11 = 0xFFFB,	// ...

		EMarkerJPG12 = 0xFFFC,	// ...

		EMarkerJPG13 = 0xFFFD,	// ...

		EMarkerCOM = 0xFFFE,	// Comment.

		}

	TMarker;

	void SetYuvDecode(TBool aYuvDecode);

	void SetHighSpeedMode(TBool aHighSpeedMode);

	TInt RecommendBufferSizeL(TUid aFormatCode);

	TInt GetStreamBufferSizeL(TUid aFormatCode, TSize& aBlockSizeInPixels, TInt aNumBlocks);

	virtual void InitDrawFrame();

	virtual TBool DrawFrameL();

	//From CImageReadCodec

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

	CJpgReadCodec(const TJpgFrameInfo& aFrameInfo,const TJpgScanInfo& aScanInfo);

	~CJpgReadCodec();

	virtual void InitFrameHeader(TFrameInfo& aFrameInfo, CFrameImageData& aFrameData);

	//Jpg codec support for CImageFrame

	virtual void InitFrameL(CImageFrame& aFrame);

	virtual void PreInitFrameL();

	virtual void PostInitFrameL();

	//JPEG codec support for streaming

	virtual void InitFrameL(TUid aFormat, TDecodeStreamCaps::TNavigation aNavigation);

	virtual void GetBlocksL(CImageFrame* aFrame, TInt aSeqPosition, TInt aNumBlocksToGet, TInt* aNumBlocksRead);

	virtual void GetNextBlocksL(CImageFrame* aFrame, TInt aNumBlocksToGet, TInt* aNumBlocksRead, TBool* aHaveMoreBlocks);

	void ValidateImageFrameBlockL(CImageFrame* aFrame);

	void ValidateFormatL(const TJpgFrameInfo& aFrameInfo, TUid aFormatCode);

	// INC037134 - free buffers used in codec

	virtual void CleanupBuffers();

	CJpgImageFrameReadCodec* ImageFrameCodec();

	virtual TInt ReducedSize(const TSize& aOriginalSize, TInt aReductionFactor, TSize& aReducedSize) const;

	void SetExtensionManager(CPluginExtensionManager* aExtensionManager);

	static TInt ScaleFactorToDivisorL(TInt aScalingFactor);

	void SetAutoRotateFlag(TUint16 aAutoRotateFlag);

protected:

	void InitComponentsL();

	TFrameState ProcessFrameL(TBufPtr8& aSrc);

	virtual TFrameState DoProcessL() = 0;

	void StoreState();

	void RestoreState();

	void ResetState();

	TInt RestartStateL();

	void GetComponentBlockL(TDataUnit& aDestination,TInt& aNumValues,TInt& aDCPrediction,const TDecHuffmanTable& aDCTable,const TDecHuffmanTable& aACTable);

	TInt GetHuffmanCodeL(const TDecHuffmanTable& aTable);

	inline void SkipBitsQuickL(TInt aNumOfBits);

	inline TInt GetBinaryNumberQuickL(TInt aLength);

	inline TInt16 GetBinaryNumberL(TInt aLength);

	inline TInt16 GetPositiveBinaryNumberL(TInt aLength);

	void CalculateRgbIndeces();					// prepares UV indeces for de-sampling process

	void ConfigureUVComponentDCT(TInt aCompIdx);// cofigures UV iDCT parameters according to the scaling factor

	void WriteMCU();

	void WriteMonoMCU();

	void CalculateRenderingParams(const TInt aScale);

	virtual void CalculateMCUBoundingRectL(TInt aMCUsPerLine);

	TInt GetMCURenderOffset();

	template<class T>

	inline void WriteDiv8MCUImpl(); //templatized implementation for writting MCU with 1/8 scaling factor

	template<class T>

	void WriteDiv4ScaledMCUImpl(); //templatized implementation for writting MCU with 1/4 scaling factor

	template<class T>

	void WriteDiv2ScaledMCUImpl(); //templatized implementation for writting MCU with 1/2 scaling factor

	template<class T>

	inline void WriteUnScaledMCUImpl(); //templatized implementation for writting MCU with 1/1 scaling factor

	void WriteUnScaledMCU();		// implementation for writing MCU with 1/1 scaling factor to TRgb output buffer

	void WriteDiv2ScaledMCU();		// implementation for writing MCU with 1/2 scaling factor to TRgb output buffer

	void WriteDiv4ScaledMCU();		// implementation for writing MCU with 1/4 scaling factor to TRgb output buffer

	void WriteDiv8ScaledMCU();		// implementation for writing MCU with 1/8 scaling factor to TRgb output buffer

	void WriteUnScaledMCU16M();		// implementation for writing MCU with 1/1 scaling factor to 24bpp output buffer

	void WriteDiv2ScaledMCU16M(); 	// implementation for writing MCU with 1/2 scaling factor to 24bpp output buffer

	void WriteDiv4ScaledMCU16M(); 	// implementation for writing MCU with 1/4 scaling factor to 24bpp output buffer

	void WriteDiv8ScaledMCU16M(); 	// implementation for writing MCU with 1/8 scaling factor to 24bpp output buffer

	void WriteDiv8ScaledMCU64K(); 	// implementation for writing MCU with 1/8 scaling factor to 16bpp output buffer

	TInt ComponentIndexL(TInt aComponentId) const;

	inline TBool NextBitL();					// returns value of next bit off the bit buffers

	inline TInt FillBitBufferL(TInt aBLeft);					// fetches up to 4 bytes into bit-buffer

	inline const TUint8* JpegFillBuffer(const TUint8* aDataPtr);				// detects safe number of bytes which can be read from input buffer

	virtual TInt MCUBlockPerRgbBuffer() const; 	// returns number of MCU block which make full horizontal line

	TInt GetHorzMCUCount();

	TInt GetVertMCUCount();

	void ConfigureAndAllocateBufferL(const TInt aScale);

	void ConfigureImageProcessorL(CImageProcessorExtension* aImageProc, CFbsBitmap& aFrame, const TInt aScaleDivisor, const TSize& aPrepareLSize);

protected:

	class TCompConf // configuration parameters for color component

		{

	public:

		TDCT* 					iDCT;			// (i)DCT implementation pointer

		TQTable::TDequantFunc	iDequantFunc;   // DeQuantization function pointer

		};

	TJpgFrameInfo iFrameInfo;

	TJpgScanInfo iScanInfo;

	const TUint8* iDataPtr;

	const TUint8* iDataPtrLimit;

// NOTE: there are multiple sections, which are created to achieve best CPU cache effectiveness

private://		

    typedef TUint TBitBuffer;

	const TUint8* iBitBufferPtrLimit;	// upper value for data buffer pointer which can be safely read without dealing with 0xFF

	TUint iDataValue;

	TUint iBitsLeft;

protected:		

	TInt iDCPredictor[KJpgNumberOfComponents];

	TCompConf iCompConf[KJpgNumberOfComponents];	// color component decoding implementation parameters

	TInt iMCUDataUnitCount[KJpgNumberOfComponents];

	TDataUnit* iComponent[KJpgNumberOfComponents];

	TBool iProcessing;

	TInt iScalingFactor;

	TInt iRestartMCUCount;

	TInt iHorzMCUBlkCount;	// current MCU number within the horizontal line

	TInt iHorzSampleFactor[KJpgNumberOfComponents];

	TInt iVertSampleFactor[KJpgNumberOfComponents];

	TInt iHorzSampleRatio[KJpgNumberOfComponents];

	TInt iVertSampleRatio[KJpgNumberOfComponents];

	TInt iMaxHorzSampleFactor;

	TInt iMaxVertSampleFactor;

	TInt iHorzSampleRatioSh[2];	// "shift" factor for calculating U/V horizontal pixel corrdinate during de-sampling

	TInt iVertSampleRatioSh[2];	// "shift" factor for calculating U/V vertical pixel corrdinate during de-sampling

private:	

	const TUint8* iInitialDataPtr;

	TBitBuffer iInitialDataValue;

	TUint iInitialBitsLeft;

	TInt iInitialDCPredictor[KJpgNumberOfComponents];

	typedef TUint8 TUVidxElemType;

	TInt iRgbBufNextLineOffs; // pre-calculated data offset that can be used to step to next MCU address within the iRgbBuffer

	TUVidxElemType iUVIndeces[2* KJpgMaxSampleFactor * KJpgMaxSampleFactor * KJpgDCTBlockWidth];

		// iUVIndeces are used to speed up MCU de-sampling

protected:

	TRgb* iRgbBuffer;						// RGB output buffer

	TBool iMonochrome;

	TBool iYuvDecode;

	TInt iP1;

	TInt iM1;

	TInt iPreviousDataLeft;					// used to detect if the last available data block is being processed

	CRawColorProcessor* iRawColorProcessor;	// Fast and simple Color Processor, not owned

	// Jpg codec support for Image Frame

	CJpgImageFrameReadCodec* iImageFrameCodecPtr;	

	TBool iProgressive;				// TRUE if we're dealing with progressively-encoded image

	TInt iBlocksPerLine;			// number of MCU blocks per image horizontal line

private:	

	TBool iHighSpeedMode;			// flag of "fast possbile decoding mode"

	TDCT iFullDCT;					// implemetation for the (Inverse) Discrete Cosine Transformer

	THalfDCT iHalfDCT;				// implemetation for the 1/2-sized (Inverse) Discrete Cosine Transformer

	TFastHalfDCT iFastHalfDCT;		// implemetation for the "fast" 1/2-sized (Inverse) Discrete Cosine Transformer

	TQuarterDCT iQuarterDCT; 		// implemetation for the 1/4-sized (Inverse) Discrete Cosine Transformer

	TFastQuarterDCT iFastQuarterDCT;// implemetation for the "fast" 1/4-sized (Inverse) Discrete Cosine Transformer

	TEighthDCT iEighthDCT;			// implemetation for the 1/8-sized (Inverse) Discrete Cosine Transformer

	typedef void (CJpgReadCodec::*TMCUWriteFunc)();

	TMCUWriteFunc iMcuWriteFunc;	// function pointer for the MCU to Bitmap writer implementation

protected:

	TSize iBufSize;		// The size, in pixels, of the intermediate buffer.

	TInt iPixelSize;

	TInt iCurrentMCUBitOffset;

	TBool iUseClipRect;	// Set if SetClippingRectL has been called.

	TRect iMCUClipRect;	// The clipping rect represented in MCU indeces.

	TInt iPixelIncrement;

	TInt iFirstPixelOffset;

	CPluginExtensionManager* iExtensionManager; // not owned

	TTransformOptions iOperation;

	TBool iFillBufferBackwards;	// How to fill iRgbBuffer.

	TInt iMCUHorizExtent;	// Flipping-aware pixel width of an MCU.

	//streaming information 

    class TStreamConfig

        {

    public:

    	TInt iSeqPosition;	//sequence postion of MCU

		TInt iNumBlocksToGet;	//number of blocks to decode

		TInt* iNumBlocksRead;	//number of blocks decoded

		TBool* iHaveMoreBlocks;	//are more blocks available to decode

        };

	TStreamConfig iStreamDecodeConfig;

	TBool iIsBlockStreaming;

	TDecodeStreamCaps::TNavigation iNavigation;

	TUid iStreamFormat;

	// These are members of this class as it greatly helps

	// debugging if you know what MCUs you're dealing with.

	TInt iNeededMCU;	// The MCU number that's next needed for rendering.

	TInt iStreamMCU;	// The MCU that the bit stream is currently representing.

	TBool iSeekDone;	// Is DoProcessL being called after a reposition request.

	TBool iEscapeAtEnd;	// Set if the 0xFF00 sequence occurs at the buffer boundary.

	TInt iMCUsPerBuffer;

	TSize iRubbish;		// The amount of 'pixels' of an MCU that aren't part of the final image.

	TUint16 iAutoRotateFlag;

	};

//

// Utility class for finding out what

// MCUs are needed to render a clipping rect.

//

class CMCUStore : public CBase

	{

public:

	static CMCUStore* NewL(TJpgFrameInfo& aFrameInfo);

	~CMCUStore();

	void SetClippingRect(const TInt aFirstMCU, const TInt aTotalMCUs);

	void SetOperation(const TTransformOptions aOperation);

	void SetMCUsPerBuffer(const TInt aMCUsPerBuffer);

	TInt GetNextMCU();

	void NextLine();

	void Reset();

private:

	CMCUStore(TJpgFrameInfo& aFrameInfo);

	void Prepare();

	TBool iClipped;

	TJpgFrameInfo& iFrameInfo;

	TInt iCurrentMCU;

	TTransformOptions iOperation;

	TInt iNextRowOffset;

	TInt iMCUIncrement;

	TInt iLastMCU;

	TInt iReads;

	TInt iMaxReads;

	TInt iMCUsPerBuffer;

	TBool iPrepared;

	};

//

// CSequentialJpgReadCodec

//

class CSequentialJpgReadCodec : public CJpgReadCodec

	{

	//

	// This is the structure of a lookup-table entry.

	// 

	typedef struct

		{

		TUint32 iPosition;			// The bit position of the MCU.

		TInt16 iDCPredictor[3];		// The DC predictors (needed for correct rendering).

		TInt16 iRestartMCUCount;	// Images with restart intervals will require this.

		}

	TMCUEntry;

public:

	static CSequentialJpgReadCodec* NewL(

			const TJpgFrameInfo& aFrameInfo,

			const TJpgScanInfo& aScanInfo,

			TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],

			TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],

			const TQTable aQTable[KJpgMaxNumberOfTables]

			);

	~CSequentialJpgReadCodec();

	virtual void PreInitFrameL();

	virtual void PostInitFrameL();

	virtual void GetBlocksL(CImageFrame* aFrame, TInt aSeqPosition, TInt aNumBlocksToGet, TInt* aNumBlocksRead);

protected:

#ifdef JPEG_DEBUG_OUTPUT

	void DumpCache();

#endif

	virtual TFrameState DoProcessL();

	void CalculateMCUBoundingRectL(TInt aMCUsPerLine);

	void ConstructL(TBool aUseCache = ETrue);

	TInt GetNextMCUPosition();

	void PostProcessMCUL(TBool aForceBufferFlush);

	TInt ProcessMCUL();

    TFrameState ProcessStreaming();

private:

	// Functions related to caching and seeking.

	void CacheMCULocation();

	virtual void GetNewDataPosition(TInt& aPosition, TInt& aLength);

	TBool QueryCache();

	void RestoreAfterSeekL();

protected:

	CSequentialJpgReadCodec(

			const TJpgFrameInfo& aFrameInfo,

			const TJpgScanInfo& aScanInfo,

			TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],

			TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],

			const TQTable aQTable[KJpgMaxNumberOfTables]

			);

	TDecHuffmanTable* iDCHuffmanTable;

	TDecHuffmanTable* iACHuffmanTable;

	const TQTable* iQTable;

	// A pointer to the lookup table.

	TMCUEntry* iMCULookup;

	// The number of MCUs in the source image.

	TInt iTotalMCUCount;

	// Keeps track of what MCUs are needed for rendering.

	CMCUStore* iMCUStore;

	};

//

// CMultiScanSequentialJpgReadCodec

// =================================

//

class CMultiScanSequentialJpgReadCodec : public CSequentialJpgReadCodec

	{