--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmplugins/imagingplugins/codecs/JPEGCodec/JPEGCodec.h	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,650 @@
+// 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
+	{
+public:
+	static CMultiScanSequentialJpgReadCodec* NewL(
+			const TJpgFrameInfo& aFrameInfo,
+			const TJpgScanInfo& aScanInfo,
+			TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],
+			TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],
+			const TQTable aQTable[KJpgMaxNumberOfTables]);
+	virtual void PreInitFrameL();
+	virtual void InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, TBool aDisableErrorDiffusion, CFbsBitmap& aFrame, CFbsBitmap* aFrameMask);
+	~CMultiScanSequentialJpgReadCodec();
+	
+private:
+	virtual TFrameState DoProcessL();
+	TFrameState ProcessFrameL(TBufPtr8& aSrc);
+	TBool SearchTableOrSosMarker(TBufPtr8& aSourceData, TInt& aPos, TUint16& aMarker);
+	TBool SwitchScanL(const TUint8*& aScan, const TUint8* aDataLimit);		
+	void RenderMCUsL();
+	CMultiScanSequentialJpgReadCodec(
+			const TJpgFrameInfo& aFrameInfo,
+			const TJpgScanInfo& aScanInfo,
+			TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],
+			TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],
+			const TQTable aQTable[KJpgMaxNumberOfTables]);
+	void CopyMCUs(TInt aCompIdx);
+	void FillEmptyMCUs();
+	void FillEmptyDU(TDataUnit* pDU);
+	void ResetOnNewScan();
+	TBool ProcessHuffmanTableL(const TUint8*& aData, const TUint8* aDataLimit);
+	void PrepareToRenderMCU(TInt aMCUIndex);
+
+private:
+	TInt iTotalMCUBlocks;
+	TDataUnit* iCompBuf[KJpgNumberOfComponents];
+	TInt iCurrentMcuIdx;
+	TBool iNewTableOrScan;
+	RChunk iMCUChunk;
+	TUint8* iMCUMemoryOffset;
+	//available components
+	TBool iCompAvailable[KJpgNumberOfComponents];
+	//count of MCUs decoded
+	TInt iCompMcuCount[KJpgNumberOfComponents];
+	//copy of pointer held by iComponents; this value is overwritten in rendering.
+	TDataUnit* iComponentCpy[KJpgNumberOfComponents];
+	
+	TJpgScanInfo iFirstScan;
+	};
+
+
+//
+// CProgressiveJpgReadCodec
+// =========================
+//
+class CProgressiveJpgReadCodec : public CJpgReadCodec
+	{
+public:
+	static CProgressiveJpgReadCodec* NewL(const TJpgFrameInfo& aFrameInfo,const TJpgScanInfo& aScanInfo,const TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],const TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],const TQTable aQTable[KJpgMaxNumberOfTables]);
+	
+	virtual void PreInitFrameL();
+	virtual void InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, TBool aDisableErrorDiffusion, CFbsBitmap& aFrame, CFbsBitmap* aFrameMask);
+	virtual ~CProgressiveJpgReadCodec();
+
+	//From CJpgReadCodec
+	void InitDrawFrame();
+	TBool DrawFrameL();
+	void InitFrameL(CImageFrame& aFrame);
+
+	// INC037134 - free buffers used in codec
+	virtual void CleanupBuffers();
+
+private:
+	CProgressiveJpgReadCodec(const TJpgFrameInfo& aFrameInfo,const TJpgScanInfo& aScanInfo,const TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],const TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],const TQTable aQTable[KJpgMaxNumberOfTables]);
+	virtual TFrameState DoProcessL();
+	void ProcessFrameL();
+	void InitDCL();
+	void RefineDCL();
+	void InitACL();
+	void RefineACL();
+	void GetDCValueL(TDataUnit& aDataUnit,const TDecHuffmanTable& aHuffmanTable,TInt& aDCPredictor);
+	void SkipDCValueL(const TDecHuffmanTable& aHuffmanTable);
+	TInt GetACValuesL(TDataUnit& aDataUnit,const TDecHuffmanTable& aHuffmanTable);
+	void RefineACValuesL(TDataUnit& aDataUnit,const TDecHuffmanTable& aHuffmanTable);
+	void LoadHuffmanTableL();
+	void LoadSOSL();
+	void LoadRestartIntervalL();
+	void DoInitFrameL();
+private:
+	const TJpgFrameInfo iOriginalFrameInfo;
+	const TJpgScanInfo iOriginalScanInfo;
+
+	TDecHuffmanTable iDCHuffmanTable[KJpgMaxNumberOfTables];
+	TDecHuffmanTable iACHuffmanTable[KJpgMaxNumberOfTables];
+	TQTable iQTable[KJpgMaxNumberOfTables];
+
+	TInt iHorzMCUCount;
+	TInt iVertMCUCount;
+	TInt iTotalMCUCount;
+	TInt iCurrentMCUCount;
+	TInt iCurrentMCUHorzCount;
+	TInt iCurrentMCUVertCount;
+	TInt iSkipCount;
+
+	TInt16 iRefinedDCValue;
+	TInt iEobRun;
+
+	TDataUnit* iMCUBuffer[KJpgNumberOfComponents];
+	TDataUnit* iMCUBufferPtr[KJpgNumberOfComponents];
+	TDataUnit* iMCUBufferPtrLimit[KJpgNumberOfComponents];
+	
+	TUint8* iMCUMemoryBuffer;
+	RChunk iMCUChunk;
+	TBool iMCUChunkAllocated;
+
+	TInt iIndividualHorzMCUCount[KJpgNumberOfComponents];
+	TInt iIndividualVertMCUCount[KJpgNumberOfComponents];
+
+	//used only by InitDrawFrame()/DrawFrame()
+	TInt iCurrentDrawMCU;
+	TDataUnit* iDrawMCUPtr[KJpgNumberOfComponents];
+	};
+
+#endif // JPEGCODEC_H
+