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

// CJpgReadCodec::GetHuffmanCodeL() is based heavily on HUFFMAN_DECODE() from jdhuff.h
// in the IJG code, Copyright (C) 1991-1997, Thomas G. Lane.
/**
   @file
   @internalComponent
*/

#include <fbs.h>
#include "ImageUtils.h"
#include "icl/ImageCodec.h"
#include "JpegTypes.h"
#include "rawcolorprocessor.h"
#include "jpgimageframeprocessor.h"
#include "JPEGCodec.h"
#include "ImageProcessorPriv.h"
#include "fwextconstants.h"
#include <imageprocessor/imageprocessor.h>

#ifdef JPEG_DEBUG_OUTPUT
// This can be turned off in the MMP.
#pragma message("Building Debug version of JPEG codec!")
#endif

const TInt KMaxMCUPerDraw = 100; 	// Maximum MCUs to draw per run
// new value should be 48
const TInt KMarkerLookAhead=32;		// number of bytes which are checked ahead for presense of 0xFF
const TInt KMCUDataLeftThreshhold=192; // approximate value for MCU size, used to avoid re-decoding MCUs when it span data blocks
const TInt KMCUMaxTotalDataUnits=1024; // Maximum of data units to use on this process' heap; if we need more, we'll create a local chunk to store them.


const TInt KUShiftIdx=0;	// index of U shift factor for MCU de-sampling
const TInt KVShiftIdx=1;	// index of V shift factor for MCU de-sampling

#if defined(__ARMCC__)
#pragma push
#pragma thumb
#endif

// CJpgReadCodec
CJpgReadCodec::CJpgReadCodec(const TJpgFrameInfo& aFrameInfo,const TJpgScanInfo& aScanInfo)
 :	iFrameInfo(aFrameInfo),
	iScanInfo(aScanInfo),
	iOperation(EDecodeNormal)
	{
	}


CJpgReadCodec::~CJpgReadCodec()
	{
	for (TInt i = 0; i < KJpgNumberOfComponents; i++)
		{
		delete[] iComponent[i];
		}

	delete iImageFrameCodecPtr;
	delete iRawColorProcessor;
	User::Free(iRgbBuffer);
	iRgbBuffer = NULL;
	}

TFrameState CJpgReadCodec::ProcessFrameL(TBufPtr8& aSrc)
	{
	iDataPtr = CONST_CAST(TUint8*,aSrc.Ptr());
	iDataPtrLimit = iDataPtr + aSrc.Length();
	iPreviousDataLeft = iDataPtrLimit - iDataPtr;

	TFrameState frameState = EFrameComplete;
	TRAPD(err, frameState = DoProcessL());
	if (err != KErrNone)
		{
		if (err == KErrCompletion)
			{
			RestoreState();
			frameState = EFrameIncomplete;
			}
		else if (err == KErrEof)
			{
			frameState = EFrameComplete;
			}
		else
			{
			JPEG_LEAVE(err, "ProcessFrameL");
			}
		}

	aSrc.Shift(iDataPtr - aSrc.Ptr()); // Shift out used data

	return frameState;
	}
	
/**
  used to configure U,V DCT for high-speed scaling mode
*/
void CJpgReadCodec::ConfigureUVComponentDCT(TInt aCompIdx)
	{
	switch (iScalingFactor)
		{
		case -2:
			if (iHorzSampleFactor[aCompIdx]==iMaxHorzSampleFactor &&
				iVertSampleFactor[aCompIdx]==iMaxVertSampleFactor)
				{
				iCompConf[aCompIdx].iDCT 			= &iFastHalfDCT;
				iCompConf[aCompIdx].iDequantFunc	= &TQTable::FastHalfDeQuantize;
				}
			break;

		case -3:
			if (iHorzSampleFactor[aCompIdx]==iMaxHorzSampleFactor &&
				iVertSampleFactor[aCompIdx]==iMaxVertSampleFactor)
				{
				iCompConf[aCompIdx].iDCT 			= &iFastQuarterDCT;
				iCompConf[aCompIdx].iDequantFunc	= &TQTable::FastQuarterDeQuantize;
				}
			else if (iHorzSampleFactor[aCompIdx]*2 == iMaxHorzSampleFactor &&
						iVertSampleFactor[aCompIdx]*2 == iMaxVertSampleFactor)
				{
				iCompConf[aCompIdx].iDCT 			= &iFastHalfDCT;
				iCompConf[aCompIdx].iDequantFunc	= &TQTable::FastHalfDeQuantize;
				}
			break;
		default:
			{
			ASSERT(EFalse);
			}
		}
	}
//
//
//
void CJpgReadCodec::InitComponentsL()
	{
	JPEG_ASSERT(iMaxHorzSampleFactor > 0);
	JPEG_ASSERT(iMaxVertSampleFactor > 0);
	
	for (TInt i = 0; i < iFrameInfo.iNumberOfComponents; i++)
		{
		iHorzSampleFactor[i] = iFrameInfo.iComponent[i].iHorzSampleFactor;
		iVertSampleFactor[i] = iFrameInfo.iComponent[i].iVertSampleFactor;
		iHorzSampleRatio[i] = iMaxHorzSampleFactor / iHorzSampleFactor[i];
		iVertSampleRatio[i] = iMaxVertSampleFactor / iVertSampleFactor[i];
		
		TInt dataUnits = iHorzSampleFactor[i] * iVertSampleFactor[i];
		iMCUDataUnitCount[i] = dataUnits;
		if ((i == 0) || !iMonochrome)
			{
			JPEG_ASSERT(dataUnits > 0);
			delete[] iComponent[i];
			iComponent[i] = NULL;
			iComponent[i] = new(ELeave) TDataUnit[dataUnits];
			}
		}
	}

//
//
//
void CJpgReadCodec::InitFrameL(TFrameInfo& /*aFrameInfo*/, CFrameImageData& /*aFrameImageData*/, TBool aDisableErrorDiffusion, CFbsBitmap& aFrame, CFbsBitmap* /*aFrameMask*/)
	{
	JPEG_DEBUG1("InitFrameL(TFrameInfo)");
	JPEG_DEBUG3(" - iFrameInfo dimensions: %d x %d",
			iFrameInfo.iSizeInPixels.iWidth,
			iFrameInfo.iSizeInPixels.iHeight);

	JPEG_DEBUG3(" - aFrame dimensions: %d x %d",
			aFrame.SizeInPixels().iWidth,
			aFrame.SizeInPixels().iHeight);

	PreInitFrameL();

	iMonochrome |= (aFrame.DisplayMode() <= EGray256);

	if ((iMaxHorzSampleFactor != iFrameInfo.iComponent[KYComp].iHorzSampleFactor) ||
		(iMaxVertSampleFactor != iFrameInfo.iComponent[KYComp].iVertSampleFactor))
		{
		// Current implementation doesn't support images with Y sampling frequency
		// lower than U or V components
		JPEG_LEAVE(KErrNotSupported, "Unsupported sampling frequency");
		}

	InitComponentsL();
	for (TInt i = 0; i < iFrameInfo.iNumberOfComponents; i++)
		{
		if ((iFrameInfo.iComponent[i].iVertSampleFactor == 3) ||
			(iFrameInfo.iComponent[i].iHorzSampleFactor == 3))
			{
			JPEG_LEAVE(KErrCorrupt, "Bad sample factor");
			}
		
		if ((i == 1) || (i == 2))
			{
			iHorzSampleRatioSh[i - 1] = iHorzSampleRatio[i] / 2;
			iVertSampleRatioSh[i - 1] = iVertSampleRatio[i] / 2;
			}
		}

	TSize requiredSize = iFrameInfo.iSizeInPixels;
	TInt err = iExtensionManager->GetDestinationSize(requiredSize);
	JPEG_LEAVE_IF_ERROR(err, "GetDestinationSize failed");
	
	if (iExtensionManager->ScalerExtensionRequested())
		{
		// Explicit scaling
		// Mandatory check that the destination size matches the calculated size
		if (requiredSize != aFrame.SizeInPixels())
			{
			JPEG_LEAVE(KErrArgument, "Destination bitmap size != GetDestinationSize");
			}
		
		TSize sizeToScale = iExtensionManager->ClippingRectExtensionRequested() ?
							iExtensionManager->ClippingRect().Size() : iFrameInfo.iSizeInPixels;
		
		if (iExtensionManager->DimensionsSwapped())
			{
			sizeToScale.SetSize(sizeToScale.iHeight, sizeToScale.iWidth);
			}
		
		err = iExtensionManager->GetScalingCoefficient(iScalingFactor, &sizeToScale);
		JPEG_LEAVE_IF_ERROR(err, "GetScalingCoefficient failed");
			
		if (iScalingFactor != -4)
			{
			if (!iHighSpeedMode || (iHighSpeedMode && iMonochrome))
				{
				// Needs to be the original image/cropped size in correct orientation
				// and NOT the GetDestinationSize() value
				requiredSize = sizeToScale;	
				}
			}
		}
	else
		{
		// Implicit scaling for compatibility
		// requiredSize now equals full, cropped or scaled in correct orientation
		iScalingFactor = ScalingCoefficient(requiredSize, aFrame.SizeInPixels());
		if ((iHighSpeedMode && !iMonochrome) || iScalingFactor == -4)
			{
			err = GetReducedSize(requiredSize, iScalingFactor, requiredSize);
			JPEG_LEAVE_IF_ERROR(err, "GetReducedSize failed");
			}
		}
	
	if (iScalingFactor == 1)
		{
		// For convenience
		iScalingFactor = -iScalingFactor;
		}
	
	JPEG_DEBUG2(" - iMonochrome = %d", iMonochrome);
	JPEG_DEBUG2(" - iProgressive = %d", iProgressive);
	JPEG_DEBUG2(" - iHighSpeedMode = %d", iHighSpeedMode);
	JPEG_DEBUG2(" - iScalingFactor = %d", iScalingFactor);

	// "raw" processor is used when we can directly write data in output format rather than TRgb
	// that provides with saving on "to/from" TRgb conversion and memory bandwidth
	TBool useRawProc = (!iMonochrome && !iProgressive &&
										(aFrame.DisplayMode() == EColor16M ||
										(aFrame.DisplayMode() == EColor64K &&
										 CPluginExtensionManager::ConvertScalingCoeffToReductionFactor(iScalingFactor) == 3))
						);

	// defaults which are equal to legacy behaviour
	iMcuWriteFunc = (iMonochrome ? &CJpgReadCodec::WriteMonoMCU : &CJpgReadCodec::WriteUnScaledMCU);

	iCompConf[KYComp].iDequantFunc = &TQTable::DeQuantize;
	iCompConf[KUComp].iDequantFunc = &TQTable::DeQuantize;
	iCompConf[KVComp].iDequantFunc = &TQTable::DeQuantize;

	TInt reductionFactor = 0;
	switch (iScalingFactor)
		{
		case -1:
			reductionFactor = 0;
			iCompConf[KYComp].iDCT = &iFullDCT;
			iCompConf[KUComp].iDCT = &iFullDCT;
			iCompConf[KVComp].iDCT = &iFullDCT;

			if (iMonochrome)
				{
				iMcuWriteFunc = &CJpgReadCodec::WriteMonoMCU;
				JPEG_DEBUG1(" - Using Mono function");
				}
			else
				{
				if (useRawProc)
					{
					iMcuWriteFunc = &CJpgReadCodec::WriteUnScaledMCU16M;
					}
				else
					{
					iMcuWriteFunc = &CJpgReadCodec::WriteUnScaledMCU;
					}
				JPEG_DEBUG1(" - Using Unscaled functions");
				}
			break;

		case -2:
			reductionFactor = 1;
			iCompConf[KYComp].iDCT = &iHalfDCT;
			iCompConf[KUComp].iDCT = &iHalfDCT;
			iCompConf[KVComp].iDCT = &iHalfDCT;
			if (!iMonochrome && iHighSpeedMode) // we do not support fast scaling for monochrome
				{
				reductionFactor = 0;
				if (useRawProc)
					{
					iMcuWriteFunc = &CJpgReadCodec::WriteDiv2ScaledMCU16M;
					}
				else
					{
					iMcuWriteFunc = &CJpgReadCodec::WriteDiv2ScaledMCU;
					}
				JPEG_DEBUG1(" - Using Div2 functions");

				iCompConf[KYComp].iDCT 			= &iFastHalfDCT;
				iCompConf[KYComp].iDequantFunc	= &TQTable::FastHalfDeQuantize;
				ConfigureUVComponentDCT(KUComp);
				ConfigureUVComponentDCT(KVComp);
				}
			else
				{
				iScalingFactor = -1;
				useRawProc = EFalse;
				}
			break;

		case -3:
			reductionFactor = 2;
			iCompConf[KYComp].iDCT = &iQuarterDCT;
			iCompConf[KUComp].iDCT = &iQuarterDCT;
			iCompConf[KVComp].iDCT = &iQuarterDCT;
			if (!iMonochrome && iHighSpeedMode) // we do not support fast scaling for monochrome
				{
				reductionFactor = 0;
				if (useRawProc)
					{
					iMcuWriteFunc = &CJpgReadCodec::WriteDiv4ScaledMCU16M;
					}
				else
					{
					iMcuWriteFunc = &CJpgReadCodec::WriteDiv4ScaledMCU;
					}
				JPEG_DEBUG1(" - Using Div4 functions");

				iCompConf[KYComp].iDCT = &iFastQuarterDCT;
				iCompConf[KYComp].iDequantFunc = &TQTable::FastQuarterDeQuantize;
				ConfigureUVComponentDCT(KUComp);
				ConfigureUVComponentDCT(KVComp);
				}
			else
				{
				iScalingFactor = -1;
				useRawProc = EFalse;
				}
			break;

		case -4:
			iCompConf[KYComp].iDCT = &iEighthDCT;
			iCompConf[KUComp].iDCT = &iEighthDCT;
			iCompConf[KVComp].iDCT = &iEighthDCT;
			iCompConf[KYComp].iDequantFunc = &TQTable::Fast18DeQuantize;
			iCompConf[KUComp].iDequantFunc = &TQTable::Fast18DeQuantize;
			iCompConf[KVComp].iDequantFunc = &TQTable::Fast18DeQuantize;
			reductionFactor = 0;
			if (!iMonochrome) // 1/8 Mono has got its own fast 1/8 inside the function
				{
				iMcuWriteFunc = useRawProc? (aFrame.DisplayMode()==EColor16M ? &CJpgReadCodec::WriteDiv8ScaledMCU16M : &CJpgReadCodec::WriteDiv8ScaledMCU64K)
											: &CJpgReadCodec::WriteDiv8ScaledMCU;
				JPEG_DEBUG1(" - Using Div8 functions");
				}
			break;

		default:
			JPEG_LEAVE(KErrArgument, "Bad scaling factor");
			break;
		}

	iCompConf[KYComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);
	iCompConf[KUComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);
	iCompConf[KVComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);

	if (!iMonochrome)
		{
		CalculateRgbIndeces();
		}

	if (iProgressive)
		{
		iFrameInfo.iMCUBlocksPerLine = 1;
		}
	else
		{
		TInt mcuWidth = iFrameInfo.MCUWidthInPixels();
		iFrameInfo.iMCUBlocksPerLine = (iFrameInfo.iSizeInPixels.iWidth + mcuWidth - 1) / mcuWidth;
		}

	// Allocate the intermediate buffer.
	iPixelSize = useRawProc ? TDisplayModeUtils::NumDisplayModeBitsPerPixel(aFrame.DisplayMode()) / 8 : sizeof(TRgb);

	TInt scaleDivisor = CJpgReadCodec::ScaleFactorToDivisorL(iScalingFactor);
	ConfigureAndAllocateBufferL(scaleDivisor);

	CImageProcessorExtension* imageProc = NULL;
	if (useRawProc)
		{
		JPEG_DEBUG1(" - Using raw processor");
		imageProc = CRawColorProcessor::NewL();
		}
	else
		{
		JPEG_DEBUG2(" - Using stock processor, reductionFactor=%d", reductionFactor);
		imageProc = ImageProcessorUtility::NewImageProcessorExtensionL(
						aFrame,
						reductionFactor,
						iMonochrome ? EGray256 : ERgb,
						aDisableErrorDiffusion || iHighSpeedMode);
		}
	
	ConfigureImageProcessorL(imageProc, aFrame, scaleDivisor, requiredSize);	
	CalculateRenderingParams(scaleDivisor);
	PostInitFrameL();
	}

//
// Configures the image processor that has been created.
// This function does not take ownership of the image processor.
//
void CJpgReadCodec::ConfigureImageProcessorL(CImageProcessorExtension* aImageProc, CFbsBitmap& aFrame, const TInt aScaleDivisor, const TSize& aPrepareLSize)
	{
	JPEG_DEBUG2("ConfigureImageProcessorL(aScaleDivisor=%d)", aScaleDivisor);
	JPEG_ASSERT(aImageProc);
	JPEG_ASSERT(iExtensionManager);
	JPEG_ASSERT(aScaleDivisor > 0);
	JPEG_ASSERT(aPrepareLSize.iWidth > 0);
	JPEG_ASSERT(aPrepareLSize.iHeight > 0);
	

#ifdef JPEG_DEBUG_OUTPUT
	TRAPD(err, iExtensionManager->TransferExtensionDataL(aImageProc));
	JPEG_LEAVE_IF_ERROR(err, "TransferExtensionDataL");
#else
	iExtensionManager->TransferExtensionDataL(aImageProc);
#endif

	SetImageProcessor(aImageProc);

	// Set the padding variables.
	TRect clip = iExtensionManager->ClippingRect();
	TInt left = (clip.iTl.iX - iMCUClipRect.iTl.iX) / aScaleDivisor;
	TInt top = (clip.iTl.iY - iMCUClipRect.iTl.iY) / aScaleDivisor;
	TInt bottom = (iMCUClipRect.iBr.iY - clip.iBr.iY) / aScaleDivisor;
	TInt right = (iMCUClipRect.iBr.iX - clip.iBr.iX) / aScaleDivisor;

	JPEG_DEBUG1(" - clipping rect offsets (scaled):");
	JPEG_DEBUG2(" -   top: %d", top);
	JPEG_DEBUG2(" -   left: %d", left);
	JPEG_DEBUG2(" -   bottom: %d", bottom);
	JPEG_DEBUG2(" -   right: %d", right);	
	JPEG_DEBUG3(" - Output size: %d x %d", aPrepareLSize.iWidth, aPrepareLSize.iHeight);
	
	//TBool bottomUp = ETrue;
	TInt initialPadding = 0;
	TInt padding = 0;

	// iRubbish is only valid for non-clipped images.
	switch (iOperation)
		{
		case EDecodeNormal:
		case EDecodeHorizontalFlip:
			initialPadding = (iUseClipRect ? top : 0);
			padding = (iUseClipRect ? left : 0);
			break;

		case EDecodeVerticalFlip:
		case EDecodeRotate180:
			initialPadding = (iUseClipRect ? top : 0);
			padding = (iUseClipRect ? right : iRubbish.iWidth);
			break;

		case EDecodeRotate90:
		case EDecodeVerticalFlipRotate90:
			initialPadding = (iUseClipRect ? left : 0);
			padding = (iUseClipRect ? bottom : iRubbish.iHeight);
			break;

		case EDecodeHorizontalFlipRotate90:
		case EDecodeRotate270:
			initialPadding = (iUseClipRect ? left : 0);
			padding = (iUseClipRect ? top : 0);
			break;

		default:
			ASSERT(EFalse);
		}

	JPEG_DEBUG2(" - initialPadding = %d", initialPadding);
	JPEG_DEBUG2(" - padding = %d", padding);

	JPEG_ASSERT(aImageProc);

	aImageProc->SetInitialScanlineSkipPadding(initialPadding);
	aImageProc->SetPixelPadding(padding);
	aImageProc->PrepareL(aFrame, aPrepareLSize, iBufSize);
	}

//
//
//
TInt CJpgReadCodec::ScaleFactorToDivisorL(TInt aScalingFactor)
	{
	switch (aScalingFactor)
		{
		case 1:
		case -1:
			return 1;

		case -2:
			return 2;

		case -3:
			return 4;

		case -4:
			return 8;

		default:
			break;
		}

	// Keep the compiler happy.
	JPEG_LEAVE(KErrArgument, "Bad scaling factor");
	return 0;
	}

//
// Calculates the necessary intermediate buffer size and allocates it.
// It also sets how many MCUs are contained in the buffer (iMCUsPerBuffer).
//
void CJpgReadCodec::ConfigureAndAllocateBufferL(const TInt aScale)
	{
	JPEG_DEBUG2("ConfigureAndAllocateBufferL(aScale=%d)", aScale);
	JPEG_ASSERT(aScale > 0);

	TInt horizMCUs = 0;
	TInt vertMCUs = 0;

	if (iUseClipRect)
		{
		// We need to translate the clipping rect from pixels to MCU space.
		// Clipping is done before any rotation.
		JPEG_ASSERT(!iProgressive);

		CalculateMCUBoundingRectL(iFrameInfo.iMCUBlocksPerLine);
		horizMCUs = iMCUClipRect.Width() / iFrameInfo.MCUWidthInPixels();
		vertMCUs = iMCUClipRect.Height() / iFrameInfo.MCUHeightInPixels();
		}
	else
		{
		if (iProgressive)
			{
			JPEG_ASSERT(aScale == 1);
			JPEG_ASSERT(iOperation == EDecodeNormal);

			horizMCUs = 1;
			vertMCUs = 1;
			}
		else
			{
			horizMCUs = iFrameInfo.iMCUBlocksPerLine;
			vertMCUs = iFrameInfo.iMCUBlocksPerColumn;

			iRubbish.iWidth = ((horizMCUs * iFrameInfo.MCUWidthInPixels()) - iFrameInfo.iSizeInPixels.iWidth) / aScale;
			iRubbish.iHeight = ((vertMCUs * iFrameInfo.MCUHeightInPixels()) - iFrameInfo.iSizeInPixels.iHeight) / aScale;

			JPEG_DEBUG3(" - iRubbish: %d x %d (scaled)", iRubbish.iWidth, iRubbish.iHeight);
			JPEG_ASSERT(iRubbish.iWidth >= 0);
			JPEG_ASSERT(iRubbish.iHeight >= 0);
			}
		}

	// We may need to swap dimensions for some rotates.
	switch (iOperation)
		{
		case EDecodeRotate90:
		case EDecodeRotate270:
		case EDecodeHorizontalFlipRotate90:
		case EDecodeVerticalFlipRotate90:
			iMCUsPerBuffer = vertMCUs;
			iBufSize.iWidth = vertMCUs * iFrameInfo.MCUHeightInPixels();
			iBufSize.iHeight = iFrameInfo.MCUWidthInPixels();
			break;

		default:
			iMCUsPerBuffer = horizMCUs;
			iBufSize.iWidth = horizMCUs * iFrameInfo.MCUWidthInPixels();
			iBufSize.iHeight = iFrameInfo.MCUHeightInPixels();
		}

	iBufSize.iWidth /= aScale;
	iBufSize.iHeight /= aScale;

	// Because JPEG doesn't round up with scaling it is possible to have a scaled image that 0x0 in size.
	// Things are ok for now because a 1x1 image is actually an 8x8 image and the maximum reduction factor
	// supported is -4 (divide by 8). It is possible that larger reduction factors will be supported in
	// the future as cameras take larger pictures. In this case an 8x8 image will scale to 0x0.
	JPEG_DEBUG3(" - scaled buffer dimensions: %d x %d", iBufSize.iWidth, iBufSize.iHeight);
	JPEG_ASSERT(iBufSize.iWidth > 0);
	JPEG_ASSERT(iBufSize.iHeight > 0);
	JPEG_ASSERT(iPixelSize > 0);

	TInt bufSize = iBufSize.iWidth * iBufSize.iHeight * iPixelSize;

	User::Free(iRgbBuffer);
	iRgbBuffer = NULL;
	iRgbBuffer = reinterpret_cast<TRgb*>(User::AllocL(bufSize));
	}


//
// Sets up the fields that control where the pixels are
// drawn into the intermediate buffer.
//
void CJpgReadCodec::CalculateRenderingParams(const TInt aScale)
	{
	JPEG_DEBUG1("CalculateRenderingParams()");

	JPEG_ASSERT(aScale > 0);

	TInt mcuPixelWidth = iFrameInfo.MCUWidthInPixels() / aScale;
	TInt mcuPixelHeight = iFrameInfo.MCUHeightInPixels() / aScale;

	switch (iOperation)
		{
		case EDecodeNormal:
		case EDecodeHorizontalFlip:
			// These are the same except FlipHorizontal will draw from bottom up.
			iFirstPixelOffset = 0;
			iPixelIncrement = 1;
			iRgbBufNextLineOffs = iBufSize.iWidth - mcuPixelWidth;
			iFillBufferBackwards = EFalse;
			iMCUHorizExtent = mcuPixelWidth;
			break;

		case EDecodeVerticalFlip:
		case EDecodeRotate180:
			iFirstPixelOffset = mcuPixelWidth - 1;
			iPixelIncrement = -1;
			iRgbBufNextLineOffs = iBufSize.iWidth + mcuPixelWidth;
			iFillBufferBackwards = ETrue;
			iMCUHorizExtent = mcuPixelWidth;
			break;

		case EDecodeRotate90:
		case EDecodeVerticalFlipRotate90:
			// These differ only in the direction the buffer is copied to the bitmap.
			iFirstPixelOffset = mcuPixelHeight - 1;
			iPixelIncrement = iBufSize.iWidth;
			iRgbBufNextLineOffs = -((iBufSize.iWidth * mcuPixelWidth) + 1);
			iFillBufferBackwards = ETrue;
			iMCUHorizExtent = mcuPixelHeight;
			break;

		case EDecodeRotate270:
		case EDecodeHorizontalFlipRotate90:
			// These differ only in the direction the buffer is copied to the bitmap.
			iFirstPixelOffset = 0;
			iPixelIncrement = iBufSize.iWidth;
			iRgbBufNextLineOffs = -(iBufSize.iWidth * mcuPixelWidth) + 1;
			iFillBufferBackwards = EFalse;
			iMCUHorizExtent = mcuPixelHeight;
			break;

		default:
			// Bad operation.
			ASSERT(EFalse);
		}

	JPEG_DEBUG2(" - iFirstPixelOffset = %d", iFirstPixelOffset);
	JPEG_DEBUG2(" - iPixelIncrement = %d", iPixelIncrement);
	JPEG_DEBUG2(" - iRgbBufNextLineOffs = %d", iRgbBufNextLineOffs);
	JPEG_DEBUG2(" - iFillBufferBackwards = %d", iFillBufferBackwards);
	JPEG_DEBUG2(" - iMCUHorizExtent = %d", iMCUHorizExtent);
	}

//
// This is called when a clipping rectangle has been set.
// Subclasses that support clipping must provide a way of
// mapping the clip rect pixel coordinates to MCUs.
//
void CJpgReadCodec::CalculateMCUBoundingRectL(TInt /*aMCUsPerLine*/)
	{
	JPEG_LEAVE(KErrNotSupported, "CalculateMCUBoundingRectL");
	}

/**
   we would go across the whole block top-to-bottom left-to-right
*/
void CJpgReadCodec::CalculateRgbIndeces()
	{
	TUVidxElemType* pixIdxPtr=iUVIndeces;

	TUint offsMask=iMaxVertSampleFactor*iMaxHorzSampleFactor*KJpgDCTBlockSize -1;
	TInt vertStep=1;

	switch (iScalingFactor)
		{
		case -4:
			offsMask &= ~TUint(KJpgDCTBlockSize - 1);
			break;

		case -3:
			vertStep = 4;
			break;

		case -2:
			vertStep = 2;
			break;

		default:
			ASSERT((iScalingFactor == 1) || (iScalingFactor == -1));
		}

	for (TInt j = 0; j < iMaxVertSampleFactor*KJpgDCTBlockWidth; j+=vertStep)
		{

		for (TInt i = 0; i < iMaxHorzSampleFactor; i++)
			{
			for (TInt k=0; k<2; ++k)
				{
				const TInt shiftIdx=k;
				const TInt comp=k+1;
				TInt hOffs		=((i*KJpgDCTBlockWidth)>>iHorzSampleRatioSh[shiftIdx])&7;
				TInt hBlkOffs	=(i>>iHorzSampleRatioSh[shiftIdx]) *KJpgDCTBlockSize;

				TInt vOffs		=((j>>iVertSampleRatioSh[shiftIdx]&7))*KJpgDCTBlockWidth;

				TInt vBlkOffs	=((j/KJpgDCTBlockWidth) >>iVertSampleRatioSh[shiftIdx]) *KJpgDCTBlockSize*iHorzSampleFactor[comp];

				*pixIdxPtr++ =  offsMask & (hOffs+  hBlkOffs + vOffs + vBlkOffs);
				}

			if (iScalingFactor == -3)
				{
				// for this factor we have 1 more entry per horizontal line
				// which is offset against previous pixel i.e. (4>>iHorzSampleRatioSh[Comp])
				*pixIdxPtr++ = vertStep>>iHorzSampleRatioSh[KUShiftIdx];
				*pixIdxPtr++ = vertStep>>iHorzSampleRatioSh[KVShiftIdx];
				}
			}
		}
	ASSERT(pixIdxPtr-iUVIndeces <= sizeof(iUVIndeces)/sizeof(iUVIndeces[0]) );
	}

void CJpgReadCodec::InitFrameL(CImageFrame& aDest)
	{
	JPEG_DEBUG1("CJpgReadCodec::InitFrameL(CImageFrame)");

	PreInitFrameL();

	// This JPEG codec does not support scaling when using destination of type CImageFrame
	// It leaves if scaling has been requested.
	//TInt reductionFactor = 0;
	
	if (iOperation != EDecodeNormal)
		{
		JPEG_LEAVE(KErrNotSupported, "No operations on CImageFrame");
		}
	
	if (iExtensionManager->ScalerExtensionRequested())
		{
		JPEG_LEAVE(KErrNotSupported, "No scaling on CImageFrame");
		}

	if (iUseClipRect)
		{
		JPEG_LEAVE(KErrNotSupported, "No clipping on CImageFrame");
		}
	
	// Check for implicit scaling.
	TInt reductionFactor = 0;
	if (!iUseClipRect)
		{
		reductionFactor = ReductionFactor(iFrameInfo.iSizeInPixels, aDest.FrameSizeInPixels());
		}
	
	if (reductionFactor != 0)
		{
		JPEG_DEBUG2(" - reductionFactor = %d", reductionFactor);
		JPEG_LEAVE(KErrNotSupported, "Bad reductionFactor");
		}

	InitComponentsL();

	iCompConf[KYComp].iDequantFunc = &TQTable::DeQuantize;
	iCompConf[KUComp].iDequantFunc = &TQTable::DeQuantize;
	iCompConf[KVComp].iDequantFunc = &TQTable::DeQuantize;

	iCompConf[KYComp].iDCT = &iFullDCT;
	iCompConf[KUComp].iDCT = &iFullDCT;
	iCompConf[KVComp].iDCT = &iFullDCT;

	iCompConf[KYComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);
	iCompConf[KUComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);
	iCompConf[KVComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);

	// Create JPEG read codec extension and the appropriate image processor
	ASSERT(iImageFrameCodecPtr == NULL);
	delete iImageFrameCodecPtr;
	iImageFrameCodecPtr = NULL;
	iImageFrameCodecPtr = CJpgImageFrameReadCodec::NewL(&aDest);
	iImageFrameCodecPtr->CreateImageProcessorL(iFrameInfo);

	PostInitFrameL();
	}

//initialization for streaming
void CJpgReadCodec::InitFrameL(TUid aFormat, TDecodeStreamCaps::TNavigation aNavigation)
	{
	JPEG_DEBUG1("InitFrameL(TUid)");

	//validate format with frameinfo
	PreInitFrameL();

	ValidateFormatL(iFrameInfo, aFormat);

	iIsBlockStreaming = ETrue;

	iStreamFormat = aFormat;
	iNavigation = aNavigation;

	InitComponentsL();

	iCompConf[KYComp].iDequantFunc = &TQTable::DeQuantize;
	iCompConf[KUComp].iDequantFunc = &TQTable::DeQuantize;
	iCompConf[KVComp].iDequantFunc = &TQTable::DeQuantize;

	iCompConf[KYComp].iDCT = &iFullDCT;
	iCompConf[KUComp].iDCT = &iFullDCT;
	iCompConf[KVComp].iDCT = &iFullDCT;

	iCompConf[KYComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);
	iCompConf[KUComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);
	iCompConf[KVComp].iDCT->SetPrecision(iFrameInfo.iSamplePrecision);

	// Create JPEG read codec extension and the appropriate image processor
	delete iImageFrameCodecPtr;
	iImageFrameCodecPtr = NULL;
	iImageFrameCodecPtr = CJpgImageFrameReadCodec::NewL(NULL);

	PostInitFrameL();
	}

#if defined(__ARMCC__)
#pragma pop
#endif

//get blocks for streaming
void CJpgReadCodec::GetBlocksL(CImageFrame* aFrame, TInt aSeqPosition, TInt aNumBlocksToGet, TInt* aNumBlocksRead)
	{
	ASSERT(aNumBlocksRead);

	if(aFrame == NULL || !(iNavigation == TDecodeStreamCaps::ENavigationRandomForward || iNavigation == TDecodeStreamCaps::ENavigationRandomBackwards))
		{
		JPEG_LEAVE(KErrArgument, "GetBlocks - bad params");
		}

	ValidateImageFrameBlockL(aFrame);

	iImageFrameCodecPtr->SetImageFrameBlocksL(aFrame, iFrameInfo);

	*aNumBlocksRead = 0;
	iStreamDecodeConfig.iSeqPosition = aSeqPosition;
	iStreamDecodeConfig.iNumBlocksToGet = aNumBlocksToGet;
	iStreamDecodeConfig.iNumBlocksRead = aNumBlocksRead;
	}

//get blocks for streaming
void CSequentialJpgReadCodec::GetBlocksL(CImageFrame* aFrame, TInt aSeqPosition, TInt aNumBlocksToGet, TInt* aNumBlocksRead)
	{
	if (aSeqPosition < 0)
		{
		JPEG_LEAVE(KErrArgument, "GetBlocksL - bad aSeqPosition");
		}

	iNeededMCU = aSeqPosition;

	CJpgReadCodec::GetBlocksL(aFrame, aSeqPosition, aNumBlocksToGet, aNumBlocksRead);
	}

//get blocks for streaming
void CJpgReadCodec::GetNextBlocksL(CImageFrame* aFrame, TInt aNumBlocksToGet, TInt* aNumBlocksRead, TBool* aHaveMoreBlocks)
	{
	ASSERT(aNumBlocksRead);
	ASSERT(aHaveMoreBlocks);

	if (aFrame == NULL || iNavigation != TDecodeStreamCaps::ENavigationSequentialForward)
		{
		JPEG_LEAVE(KErrArgument, "GetNextBlocksL - bad params");
		}

	ValidateImageFrameBlockL(aFrame);

	iImageFrameCodecPtr->SetImageFrameBlocksL(aFrame, iFrameInfo);

	*aNumBlocksRead = 0;
	*aHaveMoreBlocks = ETrue;
	iStreamDecodeConfig.iNumBlocksToGet = aNumBlocksToGet;
	iStreamDecodeConfig.iNumBlocksRead = aNumBlocksRead;
	iStreamDecodeConfig.iHaveMoreBlocks = aHaveMoreBlocks;
	}

//validates the blocks passed.
void CJpgReadCodec::ValidateImageFrameBlockL(CImageFrame* aFrame)
	{
	ASSERT(aFrame);

	TSize aBlockSizeInPixels = aFrame->FrameSizeInPixels();
	TSize aRefSizeInPixels = TSize(iFrameInfo.MCUWidthInPixels(), iFrameInfo.MCUHeightInPixels());

	const TFrameFormat& format = static_cast<const TFrameFormat&>(aFrame->FrameFormat());
	TUid imageFrameFormatCode = format.FormatCode();

	TInt oddPixelsWidth = aBlockSizeInPixels.iWidth % aRefSizeInPixels.iWidth;
	TInt oddPixelsHeight = aBlockSizeInPixels.iHeight % aRefSizeInPixels.iHeight;

	if (oddPixelsWidth != 0 || oddPixelsHeight != 0 || aBlockSizeInPixels.iHeight != aRefSizeInPixels.iHeight)
		{
		User::Leave(KErrNotSupported);
		}

	if(iIsBlockStreaming == EFalse)
		{
		User::Leave(KErrNotReady);
		}

	if(imageFrameFormatCode != KNullUid)
		{
		if(imageFrameFormatCode != iStreamFormat)
			{
			User::Leave(KErrArgument);
			}
		}
	}

//get buffer and blockSizeInPix for streaming
TInt CJpgReadCodec::GetStreamBufferSizeL(TUid aFormatCode, TSize& aBlockSizeInPixels, TInt aNumBlocks)
	{
	return CJpgImageFrameProcessorUtility::RecommendedStreamBufferSizeL(iFrameInfo, aFormatCode, aBlockSizeInPixels, aNumBlocks);
	}

//validate format
void CJpgReadCodec::ValidateFormatL(const TJpgFrameInfo& aFrameInfo, TUid aFormatCode)
	{
	TInt dataUnitCount=0;

	if (aFrameInfo.iNumberOfComponents == 1)
		{
		dataUnitCount = 1;
		}
	else
		{
		dataUnitCount = 0;
		for (TInt index = 0; index < aFrameInfo.iNumberOfComponents; index++)
			{
			dataUnitCount += aFrameInfo.iComponent[index].iHorzSampleFactor *
							 aFrameInfo.iComponent[index].iVertSampleFactor;
			}
		}

	switch (dataUnitCount)
		{

		case 1: // Monochrome
			{
			if (aFormatCode != KUidFormatYUVMonochrome)
				{
				// error transcoding not supported
				User::Leave(KErrNotSupported);
				}
			break;
			}

		case 4: // 4:2:2
			{
			if (aFormatCode != KUidFormatYUV422Interleaved)
				{
				// error transcoding not supported
				User::Leave(KErrNotSupported);
				}
			break;
			}

		case 6: // 4:2:0
			{
			if (!(aFormatCode == KUidFormatYUV420Planar || aFormatCode == KUidFormatYUV420PlanarReversed))
				{
				// error transcoding not supported
				User::Leave(KErrNotSupported);
				}
			break;
			}

		default:
			{
			User::Leave(KErrNotSupported);
			break;
			}
		}
	}

//
// This function should be called at beginning of the
// various InitFrameL versions. It performs initialisation
// that's common to all forms of image.
//
void CJpgReadCodec::PreInitFrameL()
	{
	JPEG_DEBUG1("PreInitFrameL()");
	JPEG_DEBUG2(" - MCU pixel width: %d", iFrameInfo.MCUWidthInPixels());
	JPEG_DEBUG2(" - MCU pixel height: %d", iFrameInfo.MCUHeightInPixels());

	iHorzMCUBlkCount = 0;
	iScalingFactor = 1;
	iMCUsPerBuffer = (iFrameInfo.iProgressive ? 1 : iFrameInfo.iMCUBlocksPerLine);
	ASSERT(iMCUsPerBuffer > 0);
	
	iMonochrome = (iFrameInfo.iNumberOfComponents == 1);
	
	TInt interval = iFrameInfo.iRestartInterval;
	iRestartMCUCount = (interval > 0 ? interval : KErrNotFound);
	JPEG_DEBUG2(" - iRestartMCUCount = %d", iRestartMCUCount);
	
	iMaxHorzSampleFactor = iFrameInfo.iMaxHorzSampleFactor;
	iMaxVertSampleFactor = iFrameInfo.iMaxVertSampleFactor;
	JPEG_DEBUG2(" - iMaxHorzSampleFactor = %d", iMaxHorzSampleFactor);
	JPEG_DEBUG2(" - iMaxVertSampleFactor = %d", iMaxVertSampleFactor);
	
	// Get info from the extension manager. The InitFrameL function can
	// decide whether or not the operation is supported.
	ASSERT(iExtensionManager);

	if (iAutoRotateFlag > 1 && iAutoRotateFlag < 9) 
		{
		// To ensure operation extension is created
		iExtensionManager->CreateExtensionForAutoRotateL();
		iOperation = iExtensionManager->OperationL(iAutoRotateFlag);
		}
	else 
		{
		iOperation = iExtensionManager->Operation();
		}
	
	// check out if we need to clip.
	iUseClipRect = EFalse;
	if (iExtensionManager->ClippingRectExtensionRequested())
		{
		iUseClipRect = ETrue;
		}
	
	ResetState();
	}

//
//
//
void CJpgReadCodec::PostInitFrameL()
	{
	// Default implementation does nothing.
	}

//
//
//
void CJpgReadCodec::StoreState()
	{
	iInitialDataPtr = iDataPtr;
	iInitialDataValue = iDataValue;
	iInitialBitsLeft = iBitsLeft;
	iBitBufferPtrLimit = NULL;

	for (TInt i = 0; i < KJpgNumberOfComponents; i++)
		{
		iInitialDCPredictor[i] = iDCPredictor[i];
		}
	}

//
//
//
void CJpgReadCodec::RestoreState()
	{
	iDataPtr = iInitialDataPtr;
	iBitBufferPtrLimit = NULL;
	iDataValue = iInitialDataValue;
	iBitsLeft = iInitialBitsLeft;

	for (TInt i = 0; i < KJpgNumberOfComponents; i++)
		{
		iDCPredictor[i] = iInitialDCPredictor[i];
		}
	}

//
//
//
void CJpgReadCodec::ResetState()
	{
	for (TInt i = 0; i < KJpgNumberOfComponents; i++)
		{
		iDCPredictor[i] = 0;
		}

	iBitsLeft = 0;
	iBitBufferPtrLimit = NULL;
	}

//
// Returns the number of bytes that had to be skipped before the restart marker was found.
//
TInt CJpgReadCodec::RestartStateL()
	{
	const TUint8* startPtr = iDataPtr;
	const TUint8* readLimit = iDataPtrLimit - 2;

	// skip the data until the marker is found
	while (*iDataPtr != 0xff && iDataPtr < readLimit)
		{
		iDataPtr++;
		}

	if (*iDataPtr != 0xff)
		{
		User::Leave(KErrCompletion);
		}

	iDataPtr++;

	TInt marker = *iDataPtr++;

	if (marker == (KJpgEOISignature & 0x00ff))
		{
		User::Leave(KErrEof);
		}
	else if ((marker & 0xf0) != 0xd0)
		{
#if !defined(RELAX_JPEG_STRICTNESS)
		User::Leave(KErrCorrupt);
#endif
		}

	// if iRestartInterval is 0, iRestartMCUCount is set to a negative value (KErrNotFound) to skip the 0 trigger points that would call RestartStateL
	// This is done to solve the problem that on some images the iRestartInterval marker is 0 on every frame
	iRestartMCUCount = iFrameInfo.iRestartInterval > 0 ? iFrameInfo.iRestartInterval : KErrNotFound;
	ResetState();
	StoreState();
	
	return iDataPtr - startPtr;
	}

CJpgImageFrameReadCodec* CJpgReadCodec::ImageFrameCodec()
	{
	return iImageFrameCodecPtr;
	}

TInt CJpgReadCodec::ReducedSize(const TSize& aOriginalSize, TInt aReductionFactor, TSize& aReducedSize) const
	{
	aReducedSize = aOriginalSize;
	if (aReductionFactor < 0 || aReductionFactor > 3)
		{
		return KErrArgument;
		}
	else
		{
		return CImageReadCodec::ReducedSize(aOriginalSize, aReductionFactor, aReducedSize);	
		}
	}

#if defined(__ARMCC__)
// use ARM instruction for performance-critical code
#pragma push
#pragma arm 
#pragma O3 
#pragma Otime
#endif

TInt CJpgReadCodec::FillBitBufferL(TInt aBLeft)
	{
	const TInt KBytesToFetch= 4;
	const TUint8* dataPtr   = iDataPtr;
	
	const TUint8* bitBufLim = iBitBufferPtrLimit;
	if (dataPtr + KBytesToFetch >=  bitBufLim)
		{
		bitBufLim = JpegFillBuffer(dataPtr);
		}
		
	register TUint dataValue = iDataValue;
	
	if (dataPtr + KBytesToFetch < bitBufLim )
		{
		if (aBLeft == 0)
		    {
		    aBLeft = 8;
		    dataValue = (*dataPtr++);
		    }
		dataValue = (dataValue<<8) | (*dataPtr++);
		dataValue = (dataValue<<8) | (*dataPtr++);
		dataValue = (dataValue<<8) | (*dataPtr++);

		iBitsLeft = aBLeft + (KBytesToFetch-1) * 8;    

		iDataValue= dataValue;
		iDataPtr  = dataPtr;

		return iBitsLeft;
		}
		
	if (dataPtr == iDataPtrLimit) // no more data available
		{
		if (aBLeft) // there are some bits left so make use of them
			{
			return (iBitsLeft = aBLeft);
			}
		// no more data in buffer - signal that
		User::Leave(KErrCompletion); 
		}
		
	iDataValue = (dataValue<<8) | (*iDataPtr++);
	iBitsLeft  = aBLeft + 8;

	if ((iDataValue & 0xFF) == 0xFF)
		{
		if (iDataPtr == iDataPtrLimit)
			{
			// ----+ +-------
			//  |FF| |??|??|
			// ----+ +-------
			--iDataPtr;
			User::Leave(KErrCompletion);
			}

		// When the byte sequence 0xFF occurs in encoded image data it must be followed
		// by 0x00 or the decoder will consider it a marker. The 0x00 is ignored
		// by the decoder.
		
		// --------...
		//  |FF|??|
		// --------...
		TInt marker = *iDataPtr++;
		if (marker)//Since (FF,00) stream is valid we send it.For a Non-Zero marker we need to do something
			{
			// It's a proper marker
			if (iBitsLeft > 8) // there are stiil some bits to decode
				{
			// Before: iDataValue = [xxxxxxxx][xxxxxxxx][xxxxxxxx][ffffffff]
				iBitsLeft-=8;
				iDataValue >>=8;
				iDataPtr-=2;
			// After: iDataValue = [00000000][xxxxxxxx][xxxxxxxxx][xxxxxxxx]
				return iBitsLeft;
				}
			// End of encoded image data stream?
			if (marker == (KJpgEOISignature&0xFF)) //Allow 0xFF as a valid marker only report KErrEof in case of EOI marker
				{
				User::Leave(KErrEof);	// we've reached the end of the file
				}
			else
				{
				//If marker is a special marker like 0xFF we need to give a valid iDataValue..
				if(marker == KJpgMarkerByte)
					{
					while(iDataPtr<iDataPtrLimit && *iDataPtr == KJpgMarkerByte)
						{
						iDataPtr++;
						}
					
					if (iDataPtr==iDataPtrLimit)
						{
						--iDataPtr;
						User::Leave(KErrCompletion);
						}
					else
						{
						//Check for 0x00 marker since (0xFF,0x00) is a valid stream
						if(*iDataPtr==0x00)	
							{
							iDataPtr+=1;
							return iBitsLeft;
							}
						}
					}
				iDataPtr-=1; // we'd accept some malformed files, otherwise User::Leave(KErr)
				}
			}
		}
	return iBitsLeft;
	}

//
// Examine the buffer given by ProcessL for 0xFF sequences.
// This allows for less checking in the FillBitBufferL function.
//
inline const TUint8* CJpgReadCodec::JpegFillBuffer(const TUint8* aDataPtr)
	{
	register const TUint8* limit = Min(iDataPtrLimit - 1, aDataPtr + KMarkerLookAhead + 1);

	// Try to ignore markers that are at the start of the buffer, except for EOI.
	while ((aDataPtr < limit) && (*aDataPtr != 0xFF))
		{
		++aDataPtr;
		}

	return (iBitBufferPtrLimit = (aDataPtr - 1));
	}

FORCEDINLINE TBool CJpgReadCodec::NextBitL()
	{
	if (iBitsLeft == 0)
		{
		FillBitBufferL(0);
		}
	return (iDataValue & (1 << --iBitsLeft));
	}

void CJpgReadCodec::SetAutoRotateFlag(TUint16 aAutoRotateFlag)
	{
	iAutoRotateFlag = aAutoRotateFlag;
	}

void CJpgReadCodec::GetComponentBlockL(TDataUnit& aDestination,TInt& aNumValues,TInt& aDCPrediction,const TDecHuffmanTable& aDCTable,const TDecHuffmanTable& aACTable)
	{
	TInt size = GetHuffmanCodeL(aDCTable);
	TInt amplitude = (size > 0) ? GetBinaryNumberL( size & 0x1F ) : 0;
	aDCPrediction += amplitude;

	if (aDCPrediction > KMaxTInt16 || aDCPrediction < KMinTInt16)
		{
		JPEG_LEAVE(KErrCorrupt, "Bad component block");
		}
	
	if (iScalingFactor != -4) 
	    {
		FillCompZ(aDestination, KJpgDCTBlockSize);
		TInt16* valuePtr = aDestination.iCoeff;
		TInt16* valuePtrLimit = valuePtr + KJpgDCTBlockSize;

		*valuePtr++ = TInt16(aDCPrediction);

		while (valuePtr < valuePtrLimit)
			{
			TInt s = GetHuffmanCodeL(aACTable);
			if (s == 0) // End of block
				{
				break;
				}
			else
				{
				TInt r = s >> 4;
				s &= 0x0f;
				if (s > 0)
					{
					valuePtr += r;

					if (valuePtr < valuePtrLimit)
						{
    				    *valuePtr++ = GetBinaryNumberL(s);
						}
					}
				else if (r == 15) // Zero run length
					{
					valuePtr += 16;
					}
				}
			}

		if (valuePtr > valuePtrLimit)
    	    {
			valuePtr = valuePtrLimit;
    	    }

		aNumValues = valuePtr - aDestination.iCoeff;
	    }
	else    // for 1/8 scaling we need only DC value, so perform fast block skipping
	    {
	    aNumValues      = 1;
    	
    	aDestination.iCoeff[0] = TInt16(aDCPrediction);
    	TInt numValuesRead = 1; //we've already got DC value
    	do 
    		{
    		TInt s = GetHuffmanCodeL(aACTable);
    		if (s == 0) // End of block
    		    {
    		    break;
    		    }
    		else
    			{
    			TInt r = s >> 4;
    			s &= 0x0f;
    			if (s > 0)
    				{
    				numValuesRead += r;

    				if (numValuesRead < KJpgDCTBlockSize)
    				    {
    				    numValuesRead++;
    				    SkipBitsQuickL(s);
    				    }
    				}
    			else if (r == 15) // Zero run length
    				{
    				numValuesRead += 16;
    				}
    			}
    		} while (numValuesRead < KJpgDCTBlockSize);
	    }
	}

TInt CJpgReadCodec::GetHuffmanCodeL(const TDecHuffmanTable& aTable)
	{
	TInt bLeft = iBitsLeft;
	if (bLeft < KJpgHuffmanLookAhead)
		{
		bLeft = FillBitBufferL(bLeft);
		}

	TUint dv = iDataValue;

	TInt nb=1;
	//
	if (bLeft >= KJpgHuffmanLookAhead)
		{
		
		TUint32 fastLook = (dv >> (bLeft - KJpgHuffmanLookAhead)) & KJpgHuffmanLookAheadMask;
		register TUint32 lookupEntry = aTable.GetLookupEntry(fastLook);
		if (aTable.Found(lookupEntry))
			{
			iBitsLeft = (bLeft - aTable.GetSize(lookupEntry));
			return aTable.GetCode(lookupEntry);
			}
		else
			{
			nb = (KJpgHuffmanLookAhead+1 > bLeft)? bLeft : KJpgHuffmanLookAhead+1;
			}
		}

	register TUint index   = 0;
	TInt bitCount = 0;

	ASSERT(nb>0);
	register TUint32 look = dv << (32 - bLeft);
	iBitsLeft -= nb;
	do
		{
		index = (index << 1) + 1;
		index +=((look & ((TUint32)1<<31)) != 0);
		look<<=1;
		} while (++bitCount < nb);

	const TUint8* codeIdxHash = aTable.GetCodeIdxHash();
	
	for (; bitCount <= 16; bitCount++)
		{
      	TInt first    = codeIdxHash[bitCount];
      	TInt last    = codeIdxHash[bitCount+1];
		while (last >= first)
         	{
         	register TInt notFoundPosition = (first + last) >> 1;
         	TInt codeIndex = aTable.GetIndex(notFoundPosition);

			if (index < codeIndex)
				{
				last = notFoundPosition - 1;
				}
			else if (index > codeIndex)
				{
				first = notFoundPosition + 1;
				}
			else
				{
            	return aTable.GetIndexedCode(notFoundPosition);
            	}
         	}

		index = (index << 1) + 1;
		index += (NextBitL()!=0);
		}

#if !defined(RELAX_JPEG_STRICTNESS)
	User::Leave(KErrCorrupt);
#endif

	return aTable.GetIndexedCode(0);
	}

FORCEDINLINE void CJpgReadCodec::SkipBitsQuickL(TInt aNumOfBits)
    {
    TInt bLeft = iBitsLeft;
        
    FOREVER
        {
        bLeft   -=  aNumOfBits;
        if (bLeft >= 0)
            {
            iBitsLeft = bLeft;
            return;
            }
        aNumOfBits = -bLeft;
        iBitsLeft = 0;
        bLeft = FillBitBufferL(0);
        }
    }

FORCEDINLINE TInt CJpgReadCodec::GetBinaryNumberQuickL(TInt aLength)
	{
	register TInt bLeft  = iBitsLeft;
	register TUint number = 0;
	register TBitBuffer bitBuf;

	FOREVER
		{
		bitBuf = iDataValue;
		
		bLeft -= aLength;
		if (bLeft >= 0)
		    {
		    break;
		    }
		bLeft  += aLength;
		aLength -= bLeft;
	    number |= ((bitBuf & ((1<<bLeft)-1)) << aLength);
    
	    bLeft = FillBitBufferL(0);
		}
		
	iBitsLeft = bLeft;
	
	number |= ((bitBuf>>bLeft) & ((1<<aLength)-1));
	return number;	
	}

FORCEDINLINE TInt16 CJpgReadCodec::GetPositiveBinaryNumberL(TInt aLength)
	{
    return TInt16( GetBinaryNumberQuickL(aLength) );
	}

FORCEDINLINE TInt16 CJpgReadCodec::GetBinaryNumberL(TInt aLength)
    {
	TInt mask  = (-1) << (aLength - 1);
	TInt number = GetBinaryNumberQuickL(aLength);
	return TInt16( (number & mask)? number : number + ( mask<<1 ) + 1);
    }

/**
 	This class is to provide with "write pixel" functionality
 	for writting pixels into TRgb-type buffer
*/
class TRgbWriter
	{
public:
	inline
	static void WritePixel(TRgb* aPtr, TInt aY, TInt aU, TInt aV)
		{
		*aPtr = TYCbCr::YCbCrtoRGB(aY, aU, aV);
		}
	inline
	static TRgb* ShiftPtr(TRgb* aPtr, TInt aUnitsOffs)
		{
		return  aPtr + aUnitsOffs;
		}
	};

/**
 	This class is to provide with "write pixel" functionality
 	for writting pixels into EColor16M-type buffer i.e. 3 bytes per pixel
*/
class TRawWriter
	{
public:
	inline
	static void WritePixel(TRgb* aPtr, TInt aY, TInt aU, TInt aV)
		{
		TYCbCr::YCbCrtoRawRGB(aY, aU, aV, aPtr);
		}
	inline
	static TRgb* ShiftPtr(TRgb* aPtr, TInt aUnitsOffs)
		{
		return  reinterpret_cast<TRgb*>(reinterpret_cast<TUint8*>(aPtr) + (aUnitsOffs<<1) + aUnitsOffs);
		}
	};

/**
 	This class is to provide with "write pixel" functionality
 	for writting pixels into EColor16M-type buffer i.e. 3 bytes per pixel
 	It is similar to the TRawWriter but uses inline version of YUV->RGB
 	conversion function
*/
class TRawInlineWriter
	{
public:
	inline
	static void WritePixel(TRgb* aPtr, TInt aY, TInt aU, TInt aV)
		{
		TYCbCr::YCbCrtoRawRGBInl(aY, aU, aV, aPtr);
		}
	inline
	static TRgb* ShiftPtr(TRgb* aPtr, TInt aUnitsOffs)
		{
		return  reinterpret_cast<TRgb*>(reinterpret_cast<TUint8*>(aPtr) + (aUnitsOffs<<1) + aUnitsOffs);
		}
	};

/**
 	This class is to provide with "write pixel" functionality
 	for writting pixels into EColor64K-type buffer i.e. 2 bytes per pixel
*/
class TRaw64KColorWriter
	{
public:
	inline
	static void WritePixel(TRgb* aPtr, TInt aY, TInt aU, TInt aV)
		{
		TYCbCr::YCbCrtoRaw64K(aY, aU, aV, aPtr);
		}
	inline
	static TRgb* ShiftPtr(TRgb* aPtr, TInt aUnitsOffs)
		{
		return  reinterpret_cast<TRgb*>(reinterpret_cast<TUint8*>(aPtr) + (aUnitsOffs<<1) );
		}
	};

inline void CJpgReadCodec::WriteMCU()
	{
	JPEG_ASSERT(iMcuWriteFunc);
	(this->*iMcuWriteFunc)();
	}

//
// Calculate where in the intermediate buffer this MCU should be drawn.
//
TInt CJpgReadCodec::GetMCURenderOffset()
	{
	TInt mcuPos;

	JPEG_ASSERT(iMCUHorizExtent > 0);

	if (iFillBufferBackwards)
		{
		JPEG_ASSERT(!iProgressive);
		mcuPos = iMCUsPerBuffer - iHorzMCUBlkCount - 1;
		}
	else
		{
		// Fill from left to right.
		mcuPos = iHorzMCUBlkCount;
		}

	JPEG_ASSERT(mcuPos >= 0);

	// iMCUHorizExtent has already been scaled by CalculateRenderingParams().
	return (mcuPos * iMCUHorizExtent);

	}

//
// Writes a monochrome MCU.
//
void CJpgReadCodec::WriteMonoMCU()
	{
	const TInt16* yComp = iComponent[KYComp]->iCoeff;

	if (iScalingFactor == -4)
		{
		TInt pixelsToSkip = GetMCURenderOffset() + iFirstPixelOffset;
		TRgb* writeAddress = iRgbBuffer + pixelsToSkip;
		/* Coverity may flag as overrun of array yComp by indexing, which is false positive. There is more than one TDataUnit object pointed to by 
		iComponent[KYComp], which Coverity may fail to take into account */
		for (TInt j = 0; j < iMaxVertSampleFactor; j++)
			{
			for (TInt i = 0; i < iMaxHorzSampleFactor; i++)
				{
				*writeAddress = TRgb::Gray256(ColorCcomponent::ClampColorComponent(yComp[0]));
				writeAddress += iPixelIncrement;
				yComp += KJpgDCTBlockSize;
				}
			writeAddress += iRgbBufNextLineOffs;
			}
		}
	else
		{
		const TInt KYBlockOffset	= KJpgDCTBlockWidth-(iMaxHorzSampleFactor * KJpgDCTBlockSize);

		TInt pixelsToSkip = GetMCURenderOffset() + iFirstPixelOffset;
		TRgb* writeAddress = iRgbBuffer + pixelsToSkip;

		for (TInt sf = iMaxVertSampleFactor * KJpgDCTBlockWidth; sf;)
			{
			TInt hsf = iMaxHorzSampleFactor;
			do
				{
				TInt i = KJpgDCTBlockWidth / 2;
				do
					{
					*writeAddress = TRgb::Gray256(ColorCcomponent::ClampColorComponent(*yComp++));
					writeAddress += iPixelIncrement;
					*writeAddress = TRgb::Gray256(ColorCcomponent::ClampColorComponent(*yComp++));
					writeAddress += iPixelIncrement;
					}
				while (--i);

				yComp += (KJpgDCTBlockSize - KJpgDCTBlockWidth);
				}
			while (--hsf);

			--sf;
			yComp 		+= (sf & (KJpgDCTBlockWidth-1))? KYBlockOffset: -(KJpgDCTBlockSize-KJpgDCTBlockWidth);
			writeAddress += iRgbBufNextLineOffs;
			}
		}
	}

void CJpgReadCodec::WriteDiv8ScaledMCU16M()
	{
	WriteDiv8MCUImpl<TRawWriter>();
	}

void CJpgReadCodec::WriteDiv8ScaledMCU()
	{
	WriteDiv8MCUImpl<TRgbWriter>();
	}

void CJpgReadCodec::WriteDiv8ScaledMCU64K()
	{
	WriteDiv8MCUImpl<TRaw64KColorWriter>();
	}

template <class T>
inline void CJpgReadCodec::WriteDiv8MCUImpl()
	{
	ASSERT(iScalingFactor == -4);

	TInt16* yComp = iComponent[0]->iCoeff;

	TUVidxElemType* uVIndeces = iUVIndeces;

	TInt pixelsToSkip = GetMCURenderOffset() + iFirstPixelOffset;
	TRgb* writeAddress = T::ShiftPtr(iRgbBuffer, pixelsToSkip);

	const TInt16* uComp = iComponent[KUComp]->iCoeff;
	const TInt16* vComp = iComponent[KVComp]->iCoeff;

	TInt hsf = iMaxHorzSampleFactor;
	TInt vsf = iMaxVertSampleFactor;
	/* Coverity may flag as overrun of array on indexing yComp. This is false positive. Coverity doesn't take into account that 
	iComponent[0] can point to more than one TDataUnit.
	*/
	do
		{
		do
			{
			const TInt16 uValue = uComp[*uVIndeces];
			uVIndeces++;
			const TInt16 vValue = vComp[*uVIndeces];
			uVIndeces++;
			T::WritePixel(writeAddress, *yComp, uValue, vValue);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);

			yComp += KJpgDCTBlockSize;
			}
		while (--hsf);

		hsf = iMaxHorzSampleFactor;
		uVIndeces += (hsf << 4); // 2 * hsf * KJpgBlockWidth
		writeAddress = T::ShiftPtr(writeAddress, iRgbBufNextLineOffs);
		}
	while (--vsf);
	}

void CJpgReadCodec::WriteUnScaledMCU16M()
	{
	WriteUnScaledMCUImpl<TRawWriter>();
	}

void CJpgReadCodec::WriteUnScaledMCU()
	{
	WriteUnScaledMCUImpl<TRgbWriter>();
	}

template <class T>
inline void CJpgReadCodec::WriteUnScaledMCUImpl()
	{
	ASSERT((iScalingFactor == 1) || (iScalingFactor == -1));

	TInt pixelsToSkip = GetMCURenderOffset() + iFirstPixelOffset;
	TRgb* writeAddress = T::ShiftPtr(iRgbBuffer, pixelsToSkip);

	const TInt KYBlockOffset = KJpgDCTBlockWidth - (iFrameInfo.MCUWidthInPixels() * 8);

	register const TInt ush = iHorzSampleRatioSh[KUShiftIdx];
	register const TInt vsh = iHorzSampleRatioSh[KVShiftIdx];
	const TInt16* yComp = iComponent[KYComp]->iCoeff;
	const TUVidxElemType* pixIdx = iUVIndeces;

	TInt sf = iFrameInfo.MCUHeightInPixels();
	do
		{
		TInt hsf = iMaxHorzSampleFactor;
		do
			{
			const TInt16* const u_base = iComponent[KUComp]->iCoeff + *pixIdx++;
			const TInt16* const v_base = iComponent[KVComp]->iCoeff + *pixIdx++;

#if defined(JPEG_OPTIMIZE_FOR_PERFORMCE)

			T::WritePixel(writeAddress, *yComp++, u_base[0], v_base[0]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);

			register TInt p=1;

			T::WritePixel(writeAddress, *yComp++, u_base [(p>>ush)], v_base [(p>>vsh)]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			++p;
			T::WritePixel(writeAddress, *yComp++, u_base [(p>>ush)], v_base [(p>>vsh)]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			++p;
			T::WritePixel(writeAddress, *yComp++, u_base [(p>>ush)], v_base [(p>>vsh)]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			++p;

			T::WritePixel(writeAddress, *yComp++, u_base [(p>>ush)], v_base [(p>>vsh)]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			++p;
			T::WritePixel(writeAddress, *yComp++, u_base [(p>>ush)], v_base [(p>>vsh)]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			++p;
			T::WritePixel(writeAddress, *yComp++, u_base [(p>>ush)], v_base [(p>>vsh)]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			++p;
			T::WritePixel(writeAddress, *yComp++, u_base [(p>>ush)], v_base [(p>>vsh)]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
#else

			register TInt p = 0;
			do
				{
				TInt y = *yComp++;
				TInt u = u_base[(p >> ush)];
				TInt v = v_base[(p >> vsh)];

				T::WritePixel(writeAddress, y, u, v);
				writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
				}
			while (++p < 8);
#endif
			yComp += (KJpgDCTBlockSize - KJpgDCTBlockWidth);
			}
		while (--hsf);

		--sf;
		yComp += (sf & (KJpgDCTBlockWidth - 1)) ? KYBlockOffset : -(KJpgDCTBlockSize - KJpgDCTBlockWidth);
		writeAddress = T::ShiftPtr(writeAddress, iRgbBufNextLineOffs);
		}
	while (sf);
	}

void CJpgReadCodec::WriteDiv2ScaledMCU()
	{
	WriteDiv2ScaledMCUImpl<TRgbWriter>();
	}

void CJpgReadCodec::WriteDiv2ScaledMCU16M()
	{
	WriteDiv2ScaledMCUImpl<TRawWriter>();
	}

template <class T>
inline void CJpgReadCodec::WriteDiv2ScaledMCUImpl()
	{
	ASSERT(iScalingFactor == -2);

	const TInt KScalingFactor = 2;
	const TInt KYBlockOffset = KJpgDCTBlockWidth -
		(iMaxHorzSampleFactor * KJpgDCTBlockSize) +
		(KScalingFactor - 1) * KJpgDCTBlockWidth;

	TInt pixelsToSkip = GetMCURenderOffset() + iFirstPixelOffset;
	TRgb* writeAddress = T::ShiftPtr(iRgbBuffer, pixelsToSkip);

	const TInt16* yComp = iComponent[KYComp]->iCoeff;
	const TUVidxElemType* pixIdx = iUVIndeces;
	register const TInt ush = iHorzSampleRatioSh[KUShiftIdx];
	register const TInt vsh = iHorzSampleRatioSh[KVShiftIdx];

	TInt sf = iMaxVertSampleFactor * KJpgDCTBlockWidth;
	/* Coverity may flag as overrun of array by accessing yComp. This is false positive. Coverity doesn't take into account that 
	iComponent[KYComp] can point to more than one TDataUnit.
	*/
	do
		{
		TInt hsf = iMaxHorzSampleFactor;
		do
			{
			const TInt16* const u_base = iComponent[KUComp]->iCoeff + *pixIdx++;
			const TInt16* const v_base = iComponent[KVComp]->iCoeff + *pixIdx++;

			T::WritePixel(writeAddress, *yComp, u_base[0], v_base[0]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			yComp += KScalingFactor;

			T::WritePixel(writeAddress, *yComp, u_base[KScalingFactor >> ush], v_base[KScalingFactor >> vsh]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			yComp += KScalingFactor;

			T::WritePixel(writeAddress, *yComp, u_base[2 * KScalingFactor >> ush], v_base[2 * KScalingFactor >> vsh]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			yComp += KScalingFactor;

			T::WritePixel(writeAddress, *yComp, u_base[3 * KScalingFactor >> ush], v_base[3 * KScalingFactor >> vsh]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			yComp += KScalingFactor + (KJpgDCTBlockSize - KJpgDCTBlockWidth);
			}
		while (--hsf);

		sf -= KScalingFactor;
		yComp += (sf & (KJpgDCTBlockWidth-1))? KYBlockOffset: KScalingFactor*KJpgDCTBlockWidth-KJpgDCTBlockSize;
		writeAddress = T::ShiftPtr(writeAddress, iRgbBufNextLineOffs);
		}
	while (sf);
	}

void CJpgReadCodec::WriteDiv4ScaledMCU()
	{
	WriteDiv4ScaledMCUImpl<TRgbWriter>();
	}

void CJpgReadCodec::WriteDiv4ScaledMCU16M()
	{
	WriteDiv4ScaledMCUImpl<TRawInlineWriter>();
	}

template <class T>
inline void CJpgReadCodec::WriteDiv4ScaledMCUImpl()
	{
	ASSERT(iScalingFactor == -3);

	const TInt KScalingFactor = 4;
	const TInt KYBlockOffset = KJpgDCTBlockWidth -
		(iMaxHorzSampleFactor * KJpgDCTBlockSize) +
		(KScalingFactor - 1) * KJpgDCTBlockWidth;

	TInt pixelsToSkip = GetMCURenderOffset() + iFirstPixelOffset;
	TRgb* writeAddress = T::ShiftPtr(iRgbBuffer, pixelsToSkip);

	const TInt16* yComp = iComponent[KYComp]->iCoeff;
	const TUVidxElemType* pixIdx=iUVIndeces;

	TInt sf = iMaxVertSampleFactor * KJpgDCTBlockWidth;
	/* Coverity may flag as overrun of array on accessing yComp. This is false positive. Coverity doesn't take into account that 
	iComponent[KYComp] can point to more than one TDataUnit.
	*/
	do
		{
		TInt hsf = iMaxHorzSampleFactor;
		do
			{
			const TInt16* const u_base1 = iComponent[KUComp]->iCoeff + *pixIdx;
			pixIdx++;
			const TInt16* const v_base1 = iComponent[KVComp]->iCoeff + *pixIdx;
			pixIdx++;

			T::WritePixel(writeAddress, *yComp, u_base1[0], v_base1[0]);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			yComp += KScalingFactor;

			const TInt16 u_base2 = u_base1[*pixIdx];
			pixIdx++;
			const TInt16 v_base2 = v_base1[*pixIdx];
			pixIdx++;

			T::WritePixel(writeAddress, *yComp, u_base2, v_base2);
			writeAddress = T::ShiftPtr(writeAddress, iPixelIncrement);
			yComp += KScalingFactor + (KJpgDCTBlockSize - KJpgDCTBlockWidth);
			}
		while (--hsf);

		sf -= KScalingFactor;
		yComp += (sf & (KJpgDCTBlockWidth-1))? KYBlockOffset: KScalingFactor*KJpgDCTBlockWidth-KJpgDCTBlockSize;
		writeAddress = T::ShiftPtr(writeAddress, iRgbBufNextLineOffs);
		}
	while (sf);
	}


TInt CJpgReadCodec::ComponentIndexL(TInt aComponentId) const
	{
	for (TInt count = 0; count < iFrameInfo.iNumberOfComponents; count++)
		{
		if (iFrameInfo.iComponent[count].iId == aComponentId)
			return count;
		}

	User::Leave(KErrCorrupt);
	return 0;
	}

void CJpgReadCodec::SetYuvDecode(TBool aYuvDecode)
	{
	iYuvDecode = aYuvDecode;
	}

void CJpgReadCodec::SetHighSpeedMode(TBool aHighSpeedMode)
	{
	iHighSpeedMode = aHighSpeedMode;
	}

TInt CJpgReadCodec::RecommendBufferSizeL(TUid aFormatCode)
	{
	return CJpgImageFrameProcessorUtility::RecommendedBufferSizeL(iFrameInfo, aFormatCode);
	}

void CJpgReadCodec::InitDrawFrame()
	{//default implementation do nothing
	}

TBool CJpgReadCodec::DrawFrameL()
	{//default implementation do nothing
	return ETrue;
	}

void CJpgReadCodec::CleanupBuffers()
	{//default implementation do nothing
	}

void CJpgReadCodec::InitFrameHeader(TFrameInfo& aFrameInfo, CFrameImageData& /*aFrameData*/)
	{
	aFrameInfo.SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingComplete);
	}


TInt CJpgReadCodec::MCUBlockPerRgbBuffer() const
	{
	return iMCUsPerBuffer;
	}

TInt CJpgReadCodec::GetHorzMCUCount()
	{
	TInt maxMCUWidth = KJpgDCTBlockWidth * iMaxHorzSampleFactor;
	return (iFrameInfo.iSizeInPixels.iWidth + maxMCUWidth - 1) / maxMCUWidth;
	}

TInt CJpgReadCodec::GetVertMCUCount()
	{
	TInt maxMCUHeight = KJpgDCTBlockWidth * iMaxVertSampleFactor;
	return (iFrameInfo.iSizeInPixels.iHeight + maxMCUHeight - 1) / maxMCUHeight;
	}

//
// aExtensionManager is not owned.
//
void CJpgReadCodec::SetExtensionManager(CPluginExtensionManager* aExtensionManager)
	{
	iExtensionManager = aExtensionManager;
	}

#if defined(__ARMCC__)
#pragma pop
#endif

#if defined(__ARMCC__)
#pragma push
#pragma thumb
#endif
//
// CSequentialJpgReadCodec
CSequentialJpgReadCodec::CSequentialJpgReadCodec(
	const TJpgFrameInfo& aFrameInfo,
	const TJpgScanInfo& aScanInfo,
	TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],
	TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],
	const TQTable aQTable[KJpgMaxNumberOfTables])
 :	CJpgReadCodec(aFrameInfo, aScanInfo),
	iDCHuffmanTable(aDCHuffmanTable),
	iACHuffmanTable(aACHuffmanTable),
	iQTable(aQTable)
	{
	iProgressive = EFalse;
	}

//
//
//
CSequentialJpgReadCodec::~CSequentialJpgReadCodec()
	{
	delete iMCUStore;
	iMCUStore = NULL;

	User::Free(iMCULookup);
	iMCULookup = NULL;
	}

//
//
//
CSequentialJpgReadCodec* CSequentialJpgReadCodec::NewL(
	const TJpgFrameInfo& aFrameInfo,
	const TJpgScanInfo& aScanInfo,
	TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],
	TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],
	const TQTable aQTable[KJpgMaxNumberOfTables])
	{
	CSequentialJpgReadCodec* self = new(ELeave) CSequentialJpgReadCodec(
			aFrameInfo,
			aScanInfo,
			aDCHuffmanTable,
			aACHuffmanTable,
			aQTable);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

//
//
//
void CSequentialJpgReadCodec::ConstructL(TBool aUseCache)
	{
	CJpgReadCodec::ConstructL();

	ASSERT(iMCULookup == NULL);

	iTotalMCUCount = iFrameInfo.TotalMCUCount();

	// Make sure iFrameInfo has had its members set.
	JPEG_ASSERT(iTotalMCUCount >= 1);

	iMCUStore = CMCUStore::NewL(iFrameInfo);

	// If the allocation of the lookup table fails, continue
	// to decode the image as it's not needed for some decodes
	// and others should be able to continue without it (with a
	// performance hit).
	if (aUseCache)
		{
		JPEG_DEBUG2(" - Cache for %d elements", iTotalMCUCount);
		TInt allocSize = iTotalMCUCount * sizeof(TMCUEntry);
		iMCULookup = reinterpret_cast<TMCUEntry*>(User::AllocZ(allocSize));
		}
	}

//
// Nothing is guaranteed to be known about the image structure at this point.
//
void CSequentialJpgReadCodec::PreInitFrameL()
	{
	CJpgReadCodec::PreInitFrameL();
	iMCUStore->Reset();
	}


//
// This function is called after the various variants of
// InitFrameL have been called. At this stage enough should
// be known about the image to set several properties.
//
void CSequentialJpgReadCodec::PostInitFrameL()
	{
	iHorzMCUBlkCount = 0;
	iStreamMCU = 0;
	iMCUStore->SetMCUsPerBuffer(iMCUsPerBuffer);
	iMCUStore->SetOperation(iOperation);
	iNeededMCU = iMCUStore->GetNextMCU();

	// Make sure iScanInfo isn't used before its members have been set.
	JPEG_ASSERT(iScanInfo.iImageOffset > 0);

	iCurrentMCUBitOffset = (iScanInfo.iImageOffset * 8);
	
	CJpgReadCodec::PostInitFrameL();
	}

//
// This is called by the framework whenever DoProcessL returns EFrameIncompleteRepositionRequest.
// After this function returns the framework should call DoProcessL again.
//
void CSequentialJpgReadCodec::GetNewDataPosition(TInt& aPosition, TInt& /*aLength*/)
	{
	if (!iMCULookup)
		{
		// Seek to the start of the image data.
		aPosition = iScanInfo.iImageOffset;
		iSeekDone = ETrue;
		return;
		}

	if ((iNeededMCU >= 0) && (iNeededMCU < iTotalMCUCount))
		{
		TMCUEntry& entry = iMCULookup[iNeededMCU];

		aPosition = (entry.iPosition >> 3);
		iSeekDone = ETrue;
		return;
		}

	// The seek shouldn't have been made if iNeededMCU is outside
	// the bounds of the lookup table.
	ASSERT(EFalse);
	}

#if defined(__ARMCC__)
#pragma pop
#endif

#if defined(__ARMCC__)
// use ARM instruction for performance-critical code
#pragma push
#pragma arm 
#pragma O3 
#pragma Otime
#endif
//
// This will be called by CJpgReadCodec once enough
// data is available to do correct calculations.
//
void CSequentialJpgReadCodec::CalculateMCUBoundingRectL(TInt aMCUsPerLine)
	{
	JPEG_DEBUG1("CalculateMCUBoundingRectL()");

	ASSERT(iExtensionManager);

	JPEG_ASSERT(!iIsBlockStreaming);
	JPEG_ASSERT(!iProgressive);
	JPEG_ASSERT(aMCUsPerLine > 0);

	TRect clipRect;
	clipRect = iExtensionManager->ClippingRect();

	// This function shouldn't be called by InitFrameL
	// if no clipping rect has been set.
	JPEG_ASSERT(!clipRect.IsEmpty());

	TInt mcuWidthInPixels = iFrameInfo.MCUWidthInPixels();
	TInt mcuHeightInPixels = iFrameInfo.MCUHeightInPixels();
	JPEG_DEBUG2(" - MCU pixel width: %d", mcuWidthInPixels);
	JPEG_DEBUG2(" - MCU pixel height: %d", mcuHeightInPixels);

	// The clipping rect is specified in pixels. We need to
	// find out which MCUs contain these pixels.
	TInt left = clipRect.iTl.iX / mcuWidthInPixels;
	TInt top = clipRect.iTl.iY / mcuHeightInPixels;
	TInt right = (clipRect.iBr.iX - 1) / mcuWidthInPixels;
	TInt bottom = (clipRect.iBr.iY - 1) / mcuHeightInPixels;

	TInt firstMCU = (top * aMCUsPerLine) + left;

	iMCUClipRect.SetRect(left, top, right + 1, bottom + 1);

	iMCUStore->SetClippingRect(firstMCU, iMCUClipRect.Width() * iMCUClipRect.Height());

	// Convert back to pixels.
	left *= mcuWidthInPixels;
	top *= mcuHeightInPixels;
	right = (right * mcuWidthInPixels) + mcuWidthInPixels;
	bottom = (bottom * mcuHeightInPixels) + mcuHeightInPixels;

	iMCUClipRect.SetRect(left, top, right, bottom);
	JPEG_DEBUG5("iMCUClipRect: (%d, %d) - (%d x %d)",
			iMCUClipRect.iTl.iX,
			iMCUClipRect.iTl.iY,
			iMCUClipRect.Width(),
			iMCUClipRect.Height());
	}

//
//
//
void CSequentialJpgReadCodec::CacheMCULocation()
	{
	JPEG_ASSERT(iStreamMCU >= 0);
	JPEG_ASSERT(!iFrameInfo.iMultiScan);

	if (!iMCULookup || (iStreamMCU >= iTotalMCUCount))
		{
		return;
		}

	TMCUEntry& entry = iMCULookup[iStreamMCU];

	if (entry.iPosition != 0)
		{
		for (TInt i = 0; i < 3; i++)
			{
			JPEG_ASSERT(entry.iDCPredictor[i] == iDCPredictor[i]);
			}
		}
	else
		{
		entry.iPosition = iCurrentMCUBitOffset;
		if (iEscapeAtEnd)
			{
			entry.iPosition -= 8;	// Go back a byte.
			}

		entry.iDCPredictor[0] = iDCPredictor[0];
		entry.iDCPredictor[1] = iDCPredictor[1];
		entry.iDCPredictor[2] = iDCPredictor[2];
		entry.iRestartMCUCount = iRestartMCUCount;
		}
	}

//
//
//
#ifdef JPEG_DEBUG_OUTPUT
void CSequentialJpgReadCodec::DumpCache()
	{
	JPEG_DEBUG1("CACHE DUMP");
	
	for (TInt i = 0; i < iTotalMCUCount; i++)
		{
		TMCUEntry& entry = iMCULookup[i];
		if (entry.iPosition == 0)
			{
			return;
			}
		
		JPEG_DEBUG7("Entry[%6d] location=%8d; predictors[%4d, %4d, %4d] restart=%d",
				i,
				entry.iPosition,
				entry.iDCPredictor[0],
				entry.iDCPredictor[1],
				entry.iDCPredictor[2],
				entry.iRestartMCUCount);
		}
	}
#endif

//
// This is called after a seek has been performed.
// It sets everything up so that we're decoding from
// the correct position in the bitstream and does
// some other housekeeping.
//
void CSequentialJpgReadCodec::RestoreAfterSeekL()
	{
	// Reset the bitstream.
	TInt bitOffset = 0;
	iBitsLeft = 0;
	iBitBufferPtrLimit = 0;
	iDataValue = 0;

	if (iMCULookup)
		{
		TMCUEntry& entry = iMCULookup[iNeededMCU];

		// Divide entry.iPosition into byte and bit offsets.
		bitOffset = (entry.iPosition & 0x07);

		// Make sure re-caching will work.
		iCurrentMCUBitOffset = entry.iPosition;
		iDCPredictor[0] = entry.iDCPredictor[0];
		iDCPredictor[1] = entry.iDCPredictor[1];
		iDCPredictor[2] = entry.iDCPredictor[2];
		iRestartMCUCount = entry.iRestartMCUCount;

		iStreamMCU = iNeededMCU;
		}
	else
		{
		// The seek was to the start of the image.
		iRestartMCUCount = iFrameInfo.iRestartInterval;
		iDCPredictor[0] = 0;
		iDCPredictor[1] = 0;
		iDCPredictor[2] = 0;
		iStreamMCU = 0;
		iCurrentMCUBitOffset = iScanInfo.iImageOffset * 8;
		}

	//FetchNext3BytesL();
	FillBitBufferL(iBitsLeft);
	iBitsLeft -= bitOffset;
	iSeekDone = EFalse;
	}


//
// Check's if the location of iNeededMCU is known in advance.
//
TBool CSequentialJpgReadCodec::QueryCache()
	{
	// Prevent an infinite seeking loop.
	if (iNeededMCU == iStreamMCU)
		{
		return EFalse;
		}

	if (!iMCULookup)
		{
		if (iNeededMCU < iStreamMCU)
			{
			// We can seek to the start of the image and start
			// decoding again from there.
			iDataPtr++;
			return ETrue;
			}

		return EFalse;
		}

	if ((iNeededMCU < 0) || (iNeededMCU >= iTotalMCUCount))
		{
		// Out of bounds.
		return EFalse;
		}

	TMCUEntry& entry = iMCULookup[iNeededMCU];
	if (entry.iPosition != 0)
		{
		// This is in order to get the framework to do the seek.
		iDataPtr++;
		return ETrue;
		}

	return EFalse;
	}


#if defined(__ARMCC__)
#pragma pop 
#endif

//
//
//
TFrameState CSequentialJpgReadCodec::DoProcessL()
	{
	if (iSeekDone)
		{
		RestoreAfterSeekL();
		}

	while (iDataPtr < iDataPtrLimit)
		{
		if (iNeededMCU > iTotalMCUCount)
			{
			JPEG_LEAVE(KErrOverflow, "iNeededMCU is out of bounds");
			}

		// See if we're done.
		if (iNeededMCU == KErrCompletion)
			{
			return EFrameComplete;
			}
		else if (QueryCache())
			{
			return EFrameIncompleteRepositionRequest;
			}

		StoreState();
		if (iRestartMCUCount == 0)
			{
			TInt skipped = RestartStateL();
			iCurrentMCUBitOffset += (skipped * 8);
			}

		CacheMCULocation();

		TInt error = KErrNone;
		TInt mcuBitSize = 0;
		// we do that "if" in order to bypass exception handling which can
		// affect performance of the decoder
		if (iPreviousDataLeft < KMCUDataLeftThreshhold)
			{
			const TUint8* const latestDataPtr = iDataPtr;
			TRAP(error, mcuBitSize = ProcessMCUL());

			// leave if it wasn't a partial MCU
			if ((error != KErrNone) &&
				(error != KErrEof ||
				latestDataPtr == iDataPtr ||
				(latestDataPtr + sizeof(TUint16) <= iDataPtrLimit &&
				PtrReadUtil::ReadBigEndianUint16(latestDataPtr) == KJpgEOISignature)))
				{
				User::Leave(error);
				}
			}
		else
			{
			mcuBitSize = ProcessMCUL();
			}

		iCurrentMCUBitOffset += mcuBitSize;

		// we would try to render the partially decoded MCU
		// in case if there is a partial MCU/incompelete image
		// and do leave with original error code later
		if (iStreamMCU == iNeededMCU)
			{
			if (iIsBlockStreaming &&
					(iNavigation == TDecodeStreamCaps::ENavigationRandomForward ||
					iNavigation == TDecodeStreamCaps::ENavigationRandomBackwards) &&
					iStreamMCU < iStreamDecodeConfig.iSeqPosition)
				{
				iNeededMCU = iMCUStore->GetNextMCU();
				}
			else
				{
				PostProcessMCUL(error != KErrNone);

				User::LeaveIfError(error);

				if (iIsBlockStreaming)
					{
					iNeededMCU++;
					if (EBlockComplete == ProcessStreaming())
						{
						iStreamMCU++;
						iRestartMCUCount--;
						return EBlockComplete;
						}
					}
				else
					{
					iNeededMCU = iMCUStore->GetNextMCU();
					}
				}
			}

		iStreamMCU++;
		iRestartMCUCount--;

		TInt dataLeft = iDataPtrLimit - iDataPtr;
		if (dataLeft < KMCUDataLeftThreshhold)
			{
			TBool needLeave = (iPreviousDataLeft > dataLeft);
			iPreviousDataLeft = dataLeft;
			if (needLeave)
				{
				StoreState();
				User::Leave(KErrCompletion);
				}
			}
		}

	return EFrameIncomplete;
	}

TFrameState CSequentialJpgReadCodec::ProcessStreaming()
	{
	if(iNavigation == TDecodeStreamCaps::ENavigationSequentialForward)
		{
		if(iTotalMCUCount > iNeededMCU)
			{
			*(iStreamDecodeConfig.iHaveMoreBlocks) = ETrue;
			}
		else
			{
			*(iStreamDecodeConfig.iHaveMoreBlocks) = EFalse;
			}
		}

	*(iStreamDecodeConfig.iNumBlocksRead) += 1;

	if(*(iStreamDecodeConfig.iNumBlocksRead) >= iStreamDecodeConfig.iNumBlocksToGet)
		{
		return EBlockComplete;
		}
	else
		{
		return EFrameIncomplete;
		}
	}

//
// This functions turns the MCU data into pixel data.
// The pixel data is written into an intermediate buffer,
// iRgbBuffer, by WriteMCU() and then if this intermediate
// buffer is full this is copied to the output bitmap by
// SetPixelBlock().
//
void CSequentialJpgReadCodec::PostProcessMCUL(TBool aForceBufferFlush)
	{
	if (!iImageFrameCodecPtr)
		{
		TBool copyIt = aForceBufferFlush;

		WriteMCU();
		iHorzMCUBlkCount++;

		// Only copy the buffer if we have rendered a row of MCUs or are forced to.
		copyIt |= (iHorzMCUBlkCount == iMCUsPerBuffer);
		if (copyIt)
			{
			CImageProcessor* proc = ImageProcessor();
			ASSERT(proc != NULL);
			proc->SetPixelBlock(iRgbBuffer);
			iMCUStore->NextLine();
			iHorzMCUBlkCount = 0;
			}
		}
	else
		{
		RArray<const TDataUnit*> dataUnits;
		CleanupClosePushL(dataUnits);
		for(TInt i = 0; i < iFrameInfo.iNumberOfComponents; i++)
			{
			TDataUnit* compPtr = iComponent[i];
			TInt numSamples = iMCUDataUnitCount[i];
			while (numSamples > 0)
				{
				numSamples--;
				User::LeaveIfError(dataUnits.Append(compPtr++));
				}
			}
		iImageFrameCodecPtr->ProcessL(dataUnits);
		CleanupStack::PopAndDestroy(1, &dataUnits);
		}
	}


TInt CSequentialJpgReadCodec::ProcessMCUL()
	{
	TDataUnit temp;
	TInt numValues;
	TInt bitsBefore = iBitsLeft;
	const TUint8* startPtr = iDataPtr;
	
	iEscapeAtEnd = EFalse;
	for (TInt i = 0; i < iScanInfo.iNumberOfComponents; i++)
		{
		TJpgScanInfo::TScanComponentInfo& scanInfo = iScanInfo.iComponent[i];
		TInt compIndex = ComponentIndexL(scanInfo.iId);
		TJpgFrameInfo::TComponentInfo& compInfo = iFrameInfo.iComponent[compIndex];
		const TDecHuffmanTable& dcTable = iDCHuffmanTable[scanInfo.iDCCodingTable];
		const TDecHuffmanTable& acTable = iACHuffmanTable[scanInfo.iACCodingTable];
		const TQTable& qTable = iQTable[compInfo.iQTable];
		TDataUnit* compPtr = iComponent[compIndex];
		if (compPtr==NULL)
			{
			compPtr = &temp; // we'd throw it away in case of Mono mode
			}
		TInt numSamples = iMCUDataUnitCount[compIndex];

		while (numSamples > 0)
			{
			GetComponentBlockL(*compPtr, numValues, iDCPredictor[compIndex], dcTable, acTable);
			if (compIndex == 0 || !iMonochrome)
				{
				(qTable.*iCompConf[compIndex].iDequantFunc)(temp, *compPtr, numValues);
				iCompConf[compIndex].iDCT->InverseTransform(*compPtr, temp);
				compPtr++;
				}
			numSamples--;
			}
		}
	
	if (iRestartMCUCount == 1)
		{
		iBitsLeft = 0;
		}
	else
		{
		iEscapeAtEnd = ((iDataValue & 0xFF) == 0xFF);
		}

	TInt bytesRead = iDataPtr - startPtr;
	return bitsBefore + (bytesRead * 8) - iBitsLeft;
	}


#if defined(__ARMCC__)
// use ARM instruction for performance-critical code
#pragma push
#pragma thumb 
#endif

// CProgressiveJpgReadCodec
CProgressiveJpgReadCodec::CProgressiveJpgReadCodec(const TJpgFrameInfo& aFrameInfo,const TJpgScanInfo& aScanInfo,const TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],const TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],const TQTable aQTable[KJpgMaxNumberOfTables])
:	CJpgReadCodec(aFrameInfo,aScanInfo),
	iOriginalFrameInfo(aFrameInfo),
	iOriginalScanInfo(aScanInfo)
	{
	iProgressive = ETrue;
	Mem::Copy(iDCHuffmanTable,aDCHuffmanTable,sizeof(TDecHuffmanTable) * KJpgMaxNumberOfTables);
	Mem::Copy(iACHuffmanTable,aACHuffmanTable,sizeof(TDecHuffmanTable) * KJpgMaxNumberOfTables);
	Mem::Copy(iQTable,aQTable,sizeof(TQTable) * KJpgMaxNumberOfTables);
	}

CProgressiveJpgReadCodec* CProgressiveJpgReadCodec::NewL(const TJpgFrameInfo& aFrameInfo,const TJpgScanInfo& aScanInfo,const TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],const TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],const TQTable aQTable[KJpgMaxNumberOfTables])
	{
	CProgressiveJpgReadCodec* self = new(ELeave) CProgressiveJpgReadCodec(aFrameInfo, aScanInfo, aDCHuffmanTable, aACHuffmanTable, aQTable);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CProgressiveJpgReadCodec::~CProgressiveJpgReadCodec()
	{
	CleanupBuffers();
	}

void CProgressiveJpgReadCodec::DoInitFrameL()
	{
	iFrameInfo = iOriginalFrameInfo;
	iScanInfo = iOriginalScanInfo;

	TInt maxMCUWidth = KJpgDCTBlockWidth * iMaxHorzSampleFactor;
	TInt maxMCUHeight = KJpgDCTBlockWidth * iMaxVertSampleFactor;
	iHorzMCUCount = (iFrameInfo.iSizeInPixels.iWidth + maxMCUWidth - 1) / maxMCUWidth;
	iVertMCUCount = (iFrameInfo.iSizeInPixels.iHeight + maxMCUHeight - 1) / maxMCUHeight;
	iTotalMCUCount = iHorzMCUCount * iVertMCUCount;
	iCurrentMCUCount = 0;
	iCurrentMCUHorzCount = 0;
	iCurrentMCUVertCount = 0;
	iMCUChunkAllocated = EFalse;

	// We calculate how many data units we'll need in total
	TInt totalDataUnitCount = 0;
	for (TInt compIndex = 0; compIndex < iFrameInfo.iNumberOfComponents; compIndex++)
		{
		totalDataUnitCount += iMCUDataUnitCount[compIndex] * iTotalMCUCount;
		}

	TUint8* offset = NULL;
	if(totalDataUnitCount > KMCUMaxTotalDataUnits)
		{
 		iMCUChunk.Close();
		User::LeaveIfError(iMCUChunk.CreateLocal(totalDataUnitCount * sizeof(TDataUnit), totalDataUnitCount * sizeof(TDataUnit)));
		offset = iMCUChunk.Base();
		iMCUChunkAllocated = ETrue;
		}
    else
        {
        delete iMCUMemoryBuffer;
        iMCUMemoryBuffer = NULL;
        iMCUMemoryBuffer = new (ELeave) TUint8 [ totalDataUnitCount * sizeof(TDataUnit) ];
        offset = iMCUMemoryBuffer;
        }


	for (TInt compIndex = 0; compIndex < iFrameInfo.iNumberOfComponents; compIndex++)
		{
		TInt dataUnitCount = iMCUDataUnitCount[compIndex] * iTotalMCUCount;

		iMCUBuffer[compIndex] = new(offset) TDataUnit[dataUnitCount];
		offset += dataUnitCount * sizeof(TDataUnit);

		Mem::FillZ(iMCUBuffer[compIndex],dataUnitCount * sizeof(TDataUnit));
		iMCUBufferPtr[compIndex] = iMCUBuffer[compIndex];
		iMCUBufferPtrLimit[compIndex] = iMCUBuffer[compIndex] + dataUnitCount;

		iIndividualHorzMCUCount[compIndex] = ((iFrameInfo.iSizeInPixels.iWidth*iHorzSampleFactor[compIndex]) + maxMCUWidth - 1) / maxMCUWidth;
		iIndividualVertMCUCount[compIndex] = ((iFrameInfo.iSizeInPixels.iHeight*iVertSampleFactor[compIndex]) + maxMCUHeight - 1) / maxMCUHeight;
		}

	iProcessing = ETrue;
	iRefinedDCValue = 0;
	}

//
// Progressive supports scaling and normal decode only.
//
void CProgressiveJpgReadCodec::PreInitFrameL()
	{
	CJpgReadCodec::PreInitFrameL();
	
	if (iOperation != EDecodeNormal)
		{
		JPEG_LEAVE(KErrNotSupported, "No operations on Progressive");
		}
	
	if (iUseClipRect)
		{
		JPEG_LEAVE(KErrNotSupported, "No clipping on Progressive");
		}
	}

void CProgressiveJpgReadCodec::InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, TBool aDisableErrorDiffusion, CFbsBitmap& aFrame, CFbsBitmap* aFrameMask)
	{
	CJpgReadCodec::InitFrameL(aFrameInfo, aFrameImageData, aDisableErrorDiffusion, aFrame, aFrameMask);

	ClearBitmapL(aFrame, KRgbWhite); // clear bitmap so sensibly draw partial decodes

	DoInitFrameL();
	}

void CProgressiveJpgReadCodec::InitFrameL(CImageFrame& aFrame)
	{
	CJpgReadCodec::InitFrameL(aFrame);

	DoInitFrameL();
	}

#if defined(__ARMCC__)
#pragma pop 
#endif

TFrameState CProgressiveJpgReadCodec::DoProcessL()
	{
	FOREVER
		{
		if (iProcessing)
			ProcessFrameL();
		else
			{
			StoreState();
			TInt dataRemaining = iDataPtrLimit - iDataPtr;
			if (dataRemaining < 2)
				return EFrameIncomplete;

			TInt sig = (iDataPtr[0] << 8) | iDataPtr[1];
			switch (sig)
				{
			case KJpgDHTSignature:
				LoadHuffmanTableL();
				break;
			case KJpgDQTSignature:
				break;
			case KJpgSOSSignature:
				LoadSOSL();
				iProcessing = ETrue;
				break;
			case KJpgRestartIntervalSignature:
				LoadRestartIntervalL();
				break;
			case KJpgEOISignature:
				iDataPtr += 2;
				return EFrameComplete;
			default:
#if defined(RELAX_JPEG_STRICTNESS)
				iDataPtr += 1;
				dataRemaining = iDataPtrLimit - iDataPtr;
				if (dataRemaining < 2)
					{
					return EFrameIncomplete;
					}
#else
				User::Leave(KErrCorrupt);
#endif
				break;
				}
			}
		}
	}

void CProgressiveJpgReadCodec::ProcessFrameL()
	{
	if (iScanInfo.iEndSpectralSelection == 0)
		{
		if (iScanInfo.iSuccessiveApproximationBitsHigh == 0)
			InitDCL();
		else
			RefineDCL();
		}
	else
		{
		if (iScanInfo.iSuccessiveApproximationBitsHigh == 0)
			InitACL();
		else
			RefineACL();
		}
	}

void CProgressiveJpgReadCodec::InitDCL()
	{
	if(iScanInfo.iNumberOfComponents == 1)
		{ //Non interleaved scan
		for (TInt scanInfoIndex = 0; scanInfoIndex < iScanInfo.iNumberOfComponents; scanInfoIndex++)
			{
			TJpgScanInfo::TScanComponentInfo& scanInfo = iScanInfo.iComponent[scanInfoIndex];
			TInt compIndex = ComponentIndexL(scanInfo.iId);
			const TDecHuffmanTable& dcTable = iDCHuffmanTable[scanInfo.iDCCodingTable];
			TInt& dcPredictor = iDCPredictor[compIndex];
			TInt dataUnitCount = iMCUDataUnitCount[compIndex];

			TInt horzSamples = iHorzSampleFactor[compIndex];
			TInt vertSamples = iVertSampleFactor[compIndex];
			TDataUnit* dataUnit = iMCUBuffer[compIndex];
			for (; iCurrentMCUVertCount < iIndividualVertMCUCount[compIndex]; iCurrentMCUVertCount++)
				{
				TInt blockBase = (iCurrentMCUVertCount / vertSamples) * iHorzMCUCount;
				TInt unitBase = (iCurrentMCUVertCount % vertSamples) * horzSamples;
				for (; iCurrentMCUHorzCount < iIndividualHorzMCUCount[compIndex]; iCurrentMCUHorzCount++)
					{
					StoreState();
					if (iRestartMCUCount == 0)
						RestartStateL();

					TInt blockOffset = blockBase + (iCurrentMCUHorzCount / horzSamples);
					TInt unitOffset = unitBase + (iCurrentMCUHorzCount % horzSamples);

					GetDCValueL(dataUnit[(blockOffset * dataUnitCount) + unitOffset],dcTable,dcPredictor);

					iRestartMCUCount--;
					}

				iCurrentMCUHorzCount = 0;
				}
			iCurrentMCUVertCount = 0;
			}
		}
	else
		{ // Interleaved scan
		for(; iCurrentMCUCount < iTotalMCUCount; iCurrentMCUCount++)
			{
			StoreState();
			if (iRestartMCUCount == 0)
				RestartStateL();

			for (TInt scanInfoIndex = 0; scanInfoIndex < iScanInfo.iNumberOfComponents; scanInfoIndex++)
				{
				TJpgScanInfo::TScanComponentInfo& scanInfo = iScanInfo.iComponent[scanInfoIndex];
				TInt compIndex = ComponentIndexL(scanInfo.iId);
				const TDecHuffmanTable& dcTable = iDCHuffmanTable[scanInfo.iDCCodingTable];
				TInt& dcPredictor = iDCPredictor[compIndex];
				TDataUnit* tempMCUBufferPtr = iMCUBufferPtr[compIndex];

				for (TInt count = iMCUDataUnitCount[compIndex]; count > 0; count--)
					{
					GetDCValueL(*tempMCUBufferPtr,dcTable,dcPredictor);
					tempMCUBufferPtr++;
					}
				}

			for (TInt count = 0; count < iFrameInfo.iNumberOfComponents; count++)
				iMCUBufferPtr[count] += iMCUDataUnitCount[count];

			iRestartMCUCount--;
			}
		}

	for (TInt count = 0; count < iFrameInfo.iNumberOfComponents; count++)
		iMCUBufferPtr[count] = iMCUBuffer[count];

	ResetState();
	iCurrentMCUCount = 0;
	iProcessing = EFalse;
	}

void CProgressiveJpgReadCodec::RefineDCL()
	{
	for(; iCurrentMCUCount < iTotalMCUCount; iCurrentMCUCount++)
		{
		StoreState();
		if (iRestartMCUCount == 0)
			RestartStateL();

		for (TInt scanInfoIndex = 0; scanInfoIndex < iScanInfo.iNumberOfComponents; scanInfoIndex++)
			{
			TJpgScanInfo::TScanComponentInfo& scanInfo = iScanInfo.iComponent[scanInfoIndex];
			TInt compIndex = ComponentIndexL(scanInfo.iId);
			TDataUnit* tempMCUBufferPtr = iMCUBufferPtr[compIndex];

			for (TInt count = iMCUDataUnitCount[compIndex]; count > 0; count--)
				{
				if (NextBitL())
					tempMCUBufferPtr->iCoeff[0] |= iRefinedDCValue;
				tempMCUBufferPtr++;
				}
			}

		for (TInt count = 0; count < iFrameInfo.iNumberOfComponents; count++)
			iMCUBufferPtr[count] += iMCUDataUnitCount[count];

		iRestartMCUCount--;
		}

	for (TInt count = 0; count < iFrameInfo.iNumberOfComponents; count++)
		iMCUBufferPtr[count] = iMCUBuffer[count];

	ResetState();
	iCurrentMCUCount = 0;
	iProcessing = EFalse;
	}

void CProgressiveJpgReadCodec::InitACL()
	{
	if (iScanInfo.iNumberOfComponents > 1)
		User::Leave(KErrCorrupt);

	TInt compIndex = ComponentIndexL(iScanInfo.iComponent[0].iId);
	const TDecHuffmanTable& acTable = iACHuffmanTable[iScanInfo.iComponent[0].iACCodingTable];
	TInt dataUnitCount = iMCUDataUnitCount[compIndex];

	if (dataUnitCount == 1)
		{
		for(; iCurrentMCUCount < iTotalMCUCount; iCurrentMCUCount++)
			{
			StoreState();
			if (iRestartMCUCount == 0)
				RestartStateL();

			if (iSkipCount == 0)
				iSkipCount = GetACValuesL(*iMCUBufferPtr[compIndex],acTable);
			else
				iSkipCount--;

			iMCUBufferPtr[compIndex]++;
			iRestartMCUCount--;
			}

		iCurrentMCUCount = 0;
		}
	else
		{
		TInt horzSamples = iHorzSampleFactor[compIndex];
		TInt vertSamples = iVertSampleFactor[compIndex];
		TDataUnit* dataUnit = iMCUBuffer[compIndex];
		for (; iCurrentMCUVertCount < iIndividualVertMCUCount[compIndex]; iCurrentMCUVertCount++)
			{
			TInt blockBase = (iCurrentMCUVertCount / vertSamples) * iHorzMCUCount;
			TInt unitBase = (iCurrentMCUVertCount % vertSamples) * horzSamples;
			for (; iCurrentMCUHorzCount < iIndividualHorzMCUCount[compIndex]; iCurrentMCUHorzCount++)
				{
				StoreState();
				if (iRestartMCUCount == 0)
					RestartStateL();

				if (iSkipCount == 0)
					{
					TInt blockOffset = blockBase + (iCurrentMCUHorzCount / horzSamples);
					TInt unitOffset = unitBase + (iCurrentMCUHorzCount % horzSamples);
					iSkipCount = GetACValuesL(dataUnit[(blockOffset * dataUnitCount) + unitOffset],acTable);
					}
				else
					iSkipCount--;

				iRestartMCUCount--;
				}

			iCurrentMCUHorzCount = 0;
			}
		iCurrentMCUVertCount = 0;
		}

	for (TInt count = 0; count < iFrameInfo.iNumberOfComponents; count++)
		iMCUBufferPtr[count] = iMCUBuffer[count];

	iSkipCount = 0;
	ResetState();
	iProcessing = EFalse;
	}

void CProgressiveJpgReadCodec::RefineACL()
	{
	if (iScanInfo.iNumberOfComponents > 1)
		User::Leave(KErrCorrupt);

	TInt compIndex = ComponentIndexL(iScanInfo.iComponent[0].iId);
	const TDecHuffmanTable& acTable = iACHuffmanTable[iScanInfo.iComponent[0].iACCodingTable];
	TInt dataUnitCount = iMCUDataUnitCount[compIndex];
	if (dataUnitCount == 1)
		{
		for(; iCurrentMCUCount < iTotalMCUCount; iCurrentMCUCount++)
			{
			StoreState();
			if (iRestartMCUCount == 0)
				RestartStateL();

			RefineACValuesL(*iMCUBufferPtr[compIndex],acTable);
			iMCUBufferPtr[compIndex]++;

			iRestartMCUCount--;
			}

		iCurrentMCUCount = 0;
		}
	else
		{
		TInt horzSamples = iHorzSampleFactor[compIndex];
		TInt vertSamples = iVertSampleFactor[compIndex];
		TDataUnit* dataUnit = iMCUBuffer[compIndex];
		for (; iCurrentMCUVertCount < iIndividualVertMCUCount[compIndex]; iCurrentMCUVertCount++)
			{
			TInt blockBase = (iCurrentMCUVertCount / vertSamples) * iHorzMCUCount;
			TInt unitBase = (iCurrentMCUVertCount % vertSamples) * horzSamples;
			for (; iCurrentMCUHorzCount < iIndividualHorzMCUCount[compIndex]; iCurrentMCUHorzCount++)
				{
				StoreState();
				if (iRestartMCUCount == 0)
					RestartStateL();

				TInt blockOffset = blockBase + (iCurrentMCUHorzCount / horzSamples);
				TInt unitOffset = unitBase + (iCurrentMCUHorzCount % horzSamples);
				RefineACValuesL(dataUnit[(blockOffset * dataUnitCount) + unitOffset],acTable);

				iRestartMCUCount--;
				}

			iCurrentMCUHorzCount = 0;
			}
		iCurrentMCUVertCount = 0;
		}

	for (TInt count = 0; count < iFrameInfo.iNumberOfComponents; count++)
		iMCUBufferPtr[count] = iMCUBuffer[count];

	ResetState();
	iProcessing = EFalse;
	}

void CProgressiveJpgReadCodec::InitDrawFrame()
	{
	iCurrentDrawMCU = 0;
	TInt numberOfComponents = iMonochrome ? 1 : iFrameInfo.iNumberOfComponents;
	for (TInt count = 0; count < numberOfComponents; count++)
		{
		iDrawMCUPtr[count] = iMCUBuffer[count];
		}

	if (!iImageFrameCodecPtr)
		{
		CImageProcessor* const imageProc = ImageProcessor();
		imageProc->SetPos(TPoint(0,0));
		}
	}

TBool CProgressiveJpgReadCodec::DrawFrameL()
	{
	TInt numberOfComponents = iMonochrome ? 1 : iFrameInfo.iNumberOfComponents;

	TDataUnit dataUnit;
	CImageProcessor* const imageProc = ImageProcessor();

	const TInt drawMCULimit = Min(iCurrentDrawMCU + KMaxMCUPerDraw, iTotalMCUCount);

	while (iCurrentDrawMCU < drawMCULimit)
		{
		for (TInt compIndex = 0; compIndex < numberOfComponents; compIndex++)
			{
			TQTable& qTable = iQTable[iFrameInfo.iComponent[compIndex].iQTable];
			TDataUnit* compPtr = iComponent[compIndex];
			for (TInt dataUnitCount = iMCUDataUnitCount[compIndex]; dataUnitCount > 0; dataUnitCount--)
				{
				qTable.DeQuantize(dataUnit, *iDrawMCUPtr[compIndex], KJpgDCTBlockSize);
				iCompConf[compIndex].iDCT->InverseTransform(*compPtr, dataUnit);
				iDrawMCUPtr[compIndex]++;
				compPtr++;
				}
			}

		if (imageProc)
			{
			WriteMCU();
			imageProc->SetPixelBlock(iRgbBuffer);
			}
		else
			{
			RArray<const TDataUnit*> dataUnits;
			CleanupClosePushL(dataUnits);
			for (TInt compIndex = 0; compIndex < iFrameInfo.iNumberOfComponents; compIndex++)
				{
				TDataUnit* compPtr = iComponent[compIndex];
				TInt numSamples = iMCUDataUnitCount[compIndex];
				while (numSamples > 0)
					{
					numSamples--;
					User::LeaveIfError(dataUnits.Append(compPtr++));
					}
				}
			iImageFrameCodecPtr->ProcessL(dataUnits);
			CleanupStack::PopAndDestroy(1, &dataUnits);
			}

		iCurrentDrawMCU++;
		}

	if (iCurrentDrawMCU < iTotalMCUCount)
		{
		return EFalse;
		}

	return ETrue;
	}

void CProgressiveJpgReadCodec::GetDCValueL(TDataUnit& aDataUnit,const TDecHuffmanTable& aHuffmanTable,TInt& aDCPredictor)
	{
	TInt size = GetHuffmanCodeL(aHuffmanTable);
	TInt amplitude = (size > 0) ? GetBinaryNumberL(size) : 0;
	aDCPredictor += amplitude;
	ASSERT(aDCPredictor <= KMaxTInt16 && aDCPredictor >= KMinTInt16);
	aDataUnit.iCoeff[0] = TInt16(aDCPredictor << iScanInfo.iSuccessiveApproximationBitsLow);
	}

TInt CProgressiveJpgReadCodec::GetACValuesL(TDataUnit& aDataUnit,const TDecHuffmanTable& aHuffmanTable)
	{
	TInt16* valuePtr = &aDataUnit.iCoeff[iScanInfo.iStartSpectralSelection];
	TInt16* valuePtrLimit = &aDataUnit.iCoeff[iScanInfo.iEndSpectralSelection + 1];

	while (valuePtr < valuePtrLimit)
		{
		TInt s = GetHuffmanCodeL(aHuffmanTable);
		const TInt r = s >> 4;
		s &= 0x0f;
		if (s > 0)
			{
			valuePtr += r;

			if (valuePtr < valuePtrLimit)
				*valuePtr++ |= TInt16(GetBinaryNumberL(s) << iScanInfo.iSuccessiveApproximationBitsLow);
			}
		else
			{
			if (r == 15) // Zero run length
				valuePtr += 16;
			else
				{
				TInt eobRun = 1 << r;
				if (r > 0)
					eobRun += GetPositiveBinaryNumberL(r);
				return eobRun - 1;
				}
			}
		}
	return 0;
	}

void CProgressiveJpgReadCodec::RefineACValuesL(TDataUnit& aDataUnit,const TDecHuffmanTable& aHuffmanTable)
	{
	TInt s = 0;
	TInt r;
	TInt16* valuePtr = &aDataUnit.iCoeff[iScanInfo.iStartSpectralSelection];
	TInt16* valuePtrLimit = &aDataUnit.iCoeff[iScanInfo.iEndSpectralSelection];

	TInt err;
	TInt numNewNonZero = 0;
	TInt16* newNonZeroPosition[KJpgDCTBlockSize];
	TInt oldEobRun = iEobRun;
	if (iEobRun == 0)
		{
		for (; valuePtr <= valuePtrLimit; valuePtr++)
			{
			TRAP(err,s = GetHuffmanCodeL(aHuffmanTable));
			if (err == KErrCompletion)
				goto OutOfData;
			User::LeaveIfError(err);
			r = s >> 4;
			s &= 0x0f;
			if (s > 0)
				{
				TBool nextBit = EFalse;
				TRAP(err,nextBit = NextBitL());
				if (err == KErrCompletion)
					goto OutOfData;
				User::LeaveIfError(err);
				if (nextBit)
					s = iP1;
				else
					s = iM1;
				}
			else
				{
				if (r != 15)
					{
					iEobRun = 1 << r;
					if (r > 0)
						{
						TRAP(err,iEobRun += GetPositiveBinaryNumberL(r));
						if (err == KErrCompletion)
							goto OutOfData;
						User::LeaveIfError(err);
						}
					break;
					}
				}

			do
				{
				TInt16* coef = valuePtr;
				if (*coef != 0)
					{
					TBool nextBit = EFalse;
					TRAP(err,nextBit = NextBitL());
					if (err == KErrCompletion)
						goto OutOfData;
					User::LeaveIfError(err);
					if (nextBit)
						{
						if ((*coef & iP1) == 0)
							{
							if (*coef >= 0)
								*coef = TInt16(*coef + iP1);
							else
								*coef = TInt16(*coef + iM1);
							}
						}
					}
				else
					{
					if (--r < 0)
						break;
					}
				valuePtr++;
				}
			while (valuePtr <= valuePtrLimit);

			if (s != 0)
				{
				*valuePtr = TInt16(s);
				newNonZeroPosition[numNewNonZero++] = valuePtr;
				}
			}
		}

	if (iEobRun > 0)
		{
		for (; valuePtr <= valuePtrLimit; valuePtr++)
			{
			TInt16* coef = valuePtr;
			if (*coef != 0)
				{
				TBool nextBit = EFalse;
				TRAP(err,nextBit = NextBitL());
				if (err == KErrCompletion)
					goto OutOfData;
				User::LeaveIfError(err);
				if (nextBit)
					{
					if ((*coef & iP1) == 0)
						{
						if (*coef >= 0)
							*coef = TInt16(*coef + iP1);
						else
							*coef = TInt16(*coef + iM1);
						}
					}
				}
			}
		iEobRun--;
		}
	return;

OutOfData:
	while (numNewNonZero > 0)
		*(newNonZeroPosition[--numNewNonZero]) = 0;
	iEobRun = oldEobRun;

	User::Leave(KErrCompletion);
	}

#if defined(__ARMCC__)
#pragma push
#pragma thumb 
#endif
	
void CProgressiveJpgReadCodec::LoadHuffmanTableL()
	{
	if (iDataPtr + 4 > iDataPtrLimit)
	    {
	    User::Leave(KErrCompletion);
	    }
		
	TInt length = (iDataPtr[2] << 8) | iDataPtr[3];

	const TUint8* dataPtrLimit = iDataPtr + length + 2;
	if (dataPtrLimit > iDataPtrLimit)
		User::Leave(KErrCompletion);

	iDataPtr += 4;
	while (iDataPtr < dataPtrLimit)
		{
		TInt index = *iDataPtr++;
		TBool dcTable = !(index & 0x10);
		index &= 0x0f;
		if (index >= KJpgMaxNumberOfTables)
			User::Leave(KErrCorrupt);
		TDecHuffmanTable& table = dcTable ? iDCHuffmanTable[index] : iACHuffmanTable[index];
		iDataPtr += table.SetL(iDataPtr,dataPtrLimit);
		}
	}

void CProgressiveJpgReadCodec::LoadSOSL()
	{
	if (iDataPtr + 4 > iDataPtrLimit)
		User::Leave(KErrCompletion);
	TInt length = (iDataPtr[2] << 8) | iDataPtr[3];

	if (iDataPtr + length + 2 > iDataPtrLimit)
		User::Leave(KErrCompletion);

	iDataPtr += 4;
	iScanInfo.iNumberOfComponents = *iDataPtr++;

	// We ony support up to 3 components, even though spec supports up to 4.
	// Additionaly, number must not be greater than in original frame SOS header
	if (iScanInfo.iNumberOfComponents < KJpgMinNumberOfComponents ||
		iScanInfo.iNumberOfComponents > iOriginalFrameInfo.iNumberOfComponents)
		User::Leave(KErrCorrupt);

	for (TInt count = 0; count < iScanInfo.iNumberOfComponents; count++)
		{
		iScanInfo.iComponent[count].iId = *iDataPtr++;

		TUint8 table = *iDataPtr++;
		TUint8 DCTable = static_cast<TUint8>(table >> 4);
		TUint8 ACTable = static_cast<TUint8>(table & 0x0f);

		if(DCTable >= KJpgMaxNumberOfTables || ACTable >= KJpgMaxNumberOfTables)
			User::Leave(KErrCorrupt);

		iScanInfo.iComponent[count].iDCCodingTable = DCTable;
		iScanInfo.iComponent[count].iACCodingTable = ACTable;

		iDCHuffmanTable[DCTable].MakeDerivedTableL();
		iACHuffmanTable[ACTable].MakeDerivedTableL();
		}

	iScanInfo.iStartSpectralSelection = *iDataPtr++;
	iScanInfo.iEndSpectralSelection = *iDataPtr++;
	TUint8 successiveApproximation = *iDataPtr++;
	iScanInfo.iSuccessiveApproximationBitsHigh = successiveApproximation >> 4;
	iScanInfo.iSuccessiveApproximationBitsLow = successiveApproximation & 0x0f;
	iP1 = 1 << iScanInfo.iSuccessiveApproximationBitsLow;
	iM1 = (-1) << iScanInfo.iSuccessiveApproximationBitsLow;

	iRefinedDCValue = TInt16(1 << iScanInfo.iSuccessiveApproximationBitsLow);

	// if iRestartInterval is 0, iRestartMCUCount is set to a negative value (KErrNotFound) to skip the 0 trigger points that would call RestartStateL
	// This is done to solve the problem that on some images the iRestartInterval marker is 0 on every frame
	iRestartMCUCount = iFrameInfo.iRestartInterval > 0 ? iFrameInfo.iRestartInterval : KErrNotFound;
	}

void CProgressiveJpgReadCodec::LoadRestartIntervalL()
	{
	if (iDataPtr + 6 > iDataPtrLimit)
		{
		User::Leave(KErrCompletion);
		}

	iFrameInfo.iRestartInterval = iDataPtr[5] | (iDataPtr[4] << 8);
	iDataPtr += 6;

	// if iRestartInterval is 0, iRestartMCUCount is set to a negative value (KErrNotFound) to skip the 0 trigger points that would call RestartStateL
	// This is done to solve the problem that on some images the iRestartInterval marker is 0 on every frame
	iRestartMCUCount = iFrameInfo.iRestartInterval > 0 ? iFrameInfo.iRestartInterval : KErrNotFound;
	}

// 03/12/03 - function added as a result of INC037134
// needed a way to cleanup buffers when decoding complete
void CProgressiveJpgReadCodec::CleanupBuffers()
	{
	if(!iMCUChunkAllocated)
		{
        delete iMCUMemoryBuffer;
        iMCUMemoryBuffer = NULL;
		}
	else
		{
		iMCUChunk.Close();
		}
    for (TInt count = 0; count < KJpgNumberOfComponents; count++)
		{
		iMCUBuffer[count] = NULL;
		}
	iMCUChunkAllocated = EFalse;
	}

// CJpgImageFrameReadCodec
CJpgImageFrameReadCodec::CJpgImageFrameReadCodec(CImageFrame* aFrame)
	{
	iDestination = aFrame;
	}

CJpgImageFrameReadCodec::~CJpgImageFrameReadCodec()
	{
	delete iImageFrameProcessorPtr;
	}

CJpgImageFrameReadCodec* CJpgImageFrameReadCodec::NewL(CImageFrame* aFrame)
	{
	CJpgImageFrameReadCodec* self = new(ELeave) CJpgImageFrameReadCodec(aFrame);
	return self;
	}

void CJpgImageFrameReadCodec::CreateImageProcessorL(const TJpgFrameInfo& aFrameInfo)
	{
	ASSERT(iImageFrameProcessorPtr==NULL);

	iDestination->SetFrameSizeInPixels(aFrameInfo.iSizeInPixels);
	CJpgImageFrameProcessorUtility::PrepareImageFrameL(aFrameInfo,*iDestination);
	iImageFrameProcessorPtr = CJpgImageFrameProcessorUtility::NewL(*iDestination);
	}

void CJpgImageFrameReadCodec::ProcessL(const RArray<const TDataUnit*>& aDataUnits)
	{
	iImageFrameProcessorPtr->WriteBlockL(aDataUnits);
	}

CImageFrame* CJpgImageFrameReadCodec::Destination()
	{
	return iDestination;
	}

void CJpgImageFrameReadCodec::SetImageFrameBlocksL(CImageFrame* aFrame, const TJpgFrameInfo& aFrameInfo)
	{
	iDestination = aFrame;

	if(iImageFrameProcessorPtr)
		{
		delete iImageFrameProcessorPtr;
		iImageFrameProcessorPtr = NULL;
		}

	CJpgImageFrameProcessorUtility::PrepareImageFrameL(aFrameInfo, *iDestination);
	iImageFrameProcessorPtr = CJpgImageFrameProcessorUtility::NewL(*iDestination);
	}

//
// Multiscan sequential read codec.
//
CMultiScanSequentialJpgReadCodec* CMultiScanSequentialJpgReadCodec::NewL(
	const TJpgFrameInfo& aFrameInfo,
	const TJpgScanInfo& aScanInfo,
	TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],
	TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],
	const TQTable aQTable[KJpgMaxNumberOfTables])
	{
	CMultiScanSequentialJpgReadCodec* self = new(ELeave) CMultiScanSequentialJpgReadCodec(
			aFrameInfo,
			aScanInfo,
			aDCHuffmanTable,
			aACHuffmanTable,
			aQTable);
	CleanupStack::PushL(self);
	self->ConstructL(EFalse);	// No cache needed
	CleanupStack::Pop(self);
	return self;
	}


//
//
//
CMultiScanSequentialJpgReadCodec::CMultiScanSequentialJpgReadCodec(
		const TJpgFrameInfo& aFrameInfo,
		const TJpgScanInfo& aScanInfo,
		TDecHuffmanTable aDCHuffmanTable[KJpgMaxNumberOfTables],
		TDecHuffmanTable aACHuffmanTable[KJpgMaxNumberOfTables],
		const TQTable aQTable[KJpgMaxNumberOfTables])
 :	CSequentialJpgReadCodec(aFrameInfo,
		 aScanInfo,
		 aDCHuffmanTable,
		 aACHuffmanTable,
		 aQTable)
	{
	Mem::Copy(&iFirstScan, &iScanInfo, sizeof(TJpgScanInfo));
	}


//
//
//
CMultiScanSequentialJpgReadCodec::~CMultiScanSequentialJpgReadCodec()
	{
	iMCUChunk.Close();
	}


//
//
//
void CMultiScanSequentialJpgReadCodec::PreInitFrameL()
	{
	CSequentialJpgReadCodec::PreInitFrameL();
	
	// Restore the first scan.
	Mem::Copy(&iScanInfo, &iFirstScan, sizeof(TJpgScanInfo));

	for (TInt i = 0; i < KJpgNumberOfComponents; i++)
		{
		iCompAvailable[i] = EFalse;
		}
	
	iMCUChunk.Close();
	iMCUMemoryOffset = NULL;
	}


//
//
//
void CMultiScanSequentialJpgReadCodec::InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, TBool aDisableErrorDiffusion, CFbsBitmap& aFrame, CFbsBitmap* aFrameMask)
	{
	CJpgReadCodec::InitFrameL(aFrameInfo, aFrameImageData, aDisableErrorDiffusion, aFrame, aFrameMask);
	
	iTotalMCUBlocks = GetHorzMCUCount() * GetVertMCUCount();
	
	// Prepare RChunk memory for all components
	TInt mcuMemory = 0;
	for (TInt i = 0; i < iFrameInfo.iNumberOfComponents; i++)
		{
		mcuMemory += iTotalMCUBlocks * iMCUDataUnitCount[i] * sizeof(TDataUnit);
		}
	
	TInt err = iMCUChunk.CreateLocal(mcuMemory, mcuMemory);
	JPEG_LEAVE_IF_ERROR(err, "Chunk creation");
	
	iMCUMemoryOffset = iMCUChunk.Base();
	
	// Allocate memory for individual components in scan.
	for (TInt scanInfoIndex = 0; scanInfoIndex < iScanInfo.iNumberOfComponents; scanInfoIndex++)
		{
		TJpgScanInfo::TScanComponentInfo& scanInfo = iScanInfo.iComponent[scanInfoIndex];
		TInt compIndex = ComponentIndexL(scanInfo.iId);
		TInt unitCount = iTotalMCUBlocks * iMCUDataUnitCount[compIndex];
		
		iCompBuf[compIndex] = reinterpret_cast<TDataUnit*>(iMCUMemoryOffset);
		iCompAvailable[compIndex] = ETrue;
		
		iMCUMemoryOffset += unitCount * sizeof(TDataUnit);
		}
	
	iCurrentMcuIdx = 0;
	}

#if defined(__ARMCC__)
#pragma pop 
#endif

//
//
//
TFrameState CMultiScanSequentialJpgReadCodec::DoProcessL()
	{
	while (iDataPtr < iDataPtrLimit)
		{
		StoreState();
		if (iRestartMCUCount == 0)
			{
			RestartStateL();
			}

		const TUint8* const latestDataPtr = iDataPtr;
		TInt error = KErrNone;
		// we do that "if" in order to bypass exception handling which can
		// affect performance of the decoder
		if (iPreviousDataLeft < KMCUDataLeftThreshhold)
			{
			TRAP(error, ProcessMCUL());
			// leave if it wasn't a partial MCU
			if (error != KErrNone && 	(error != KErrEof || latestDataPtr == iDataPtr ||
											(latestDataPtr + sizeof(TUint16) <= iDataPtrLimit
											  && PtrReadUtil::ReadBigEndianUint16(latestDataPtr)==KJpgEOISignature
											)
										)
				)
				{
				JPEG_LEAVE(error, "From ProcessMCUL_1");
				}
			}
		else
			{
			ProcessMCUL();
			}

		JPEG_LEAVE_IF_ERROR(error, "From slow ProcessMCUL");
		
		//in case of corrupt image, if MCUs exceed total MCUs then leave
		if (iCurrentMcuIdx >= iTotalMCUBlocks)
			{
			JPEG_LEAVE(KErrEof, "Too many MCUs in image");
			}
		
		for (TInt scanInfoIndex = 0; scanInfoIndex < iScanInfo.iNumberOfComponents; scanInfoIndex++)
			{
			TJpgScanInfo::TScanComponentInfo& scanInfo = iScanInfo.iComponent[scanInfoIndex];
			TInt compIndex = ComponentIndexL(scanInfo.iId);
			CopyMCUs(compIndex);
			}
		
		iCurrentMcuIdx++;
		iRestartMCUCount--;

		if (iDataPtrLimit - iDataPtr < KMCUDataLeftThreshhold)
			{
			TBool needLeave = (iPreviousDataLeft > iDataPtrLimit - iDataPtr);
			iPreviousDataLeft = iDataPtrLimit - iDataPtr;
			if (needLeave && !iNewTableOrScan)
				{
				StoreState();
				User::Leave(KErrCompletion);
				}
			}
		}
	return EFrameIncomplete;
	}


//
// Searches Start of Scan marker(0xffda) or Huffman table marker(0xffc4) and gives the position in aPos.
//
TBool CMultiScanSequentialJpgReadCodec::SearchTableOrSosMarker(TBufPtr8& aSourceData, TInt& aPos, TUint16& aMarker)
	{
	const TUint8* ptr = aSourceData.Ptr();
	const TUint8* limit = ptr + aSourceData.Length() - 1;
	
	aPos = 0;
	while ((ptr + 1) <= limit)
		{
		// Mem::Copy must be used to avoid KERN:EXEC 3 access alignment panics on hardware.
		TUint16 data = 0;
		Mem::Copy(&data, ptr++, sizeof(TUint16));
		
		switch (data)
			{
			case 0xDAFF:	// Big-endian version of KJpgSOSSignature.
				aMarker = KJpgSOSSignature;
				return ETrue;
				
			case 0xC4FF:	// Big-endian version of KJpgDHTSignature.
				aMarker = KJpgDHTSignature;
				return ETrue;
				
			default:
				aPos++;
			}
		}
	
	return EFalse;
	}


//
// Processes frame data. Renders only on decoding all MCUs.
//
TFrameState CMultiScanSequentialJpgReadCodec::ProcessFrameL(TBufPtr8& aSrc)
	{
	TUint16 marker = 0;
	TInt markerPos = -1;
	iDataPtr = const_cast<TUint8*>(aSrc.Ptr());
	TInt dataLen = aSrc.Length();
	const TUint8* newMarkerAddr = NULL;
	const TUint8* bufferLimit = iDataPtr + dataLen;
	TBool switched = EFalse;
	
	// Exclude table or next scan.
	iNewTableOrScan = SearchTableOrSosMarker(aSrc, markerPos, marker);
	if (iNewTableOrScan)
		{
		newMarkerAddr = iDataPtr + markerPos;
		iDataPtrLimit = const_cast<TUint8*>(newMarkerAddr);
		}
	else
		{
		// If marker 0xff is in the last byte, exclude it.
		iDataPtrLimit = iDataPtr + dataLen;
		if (*(iDataPtrLimit - 1) == 0xFF)
			{
			iDataPtrLimit--;
			}
		}
	
	iPreviousDataLeft = iDataPtrLimit - iDataPtr;

	TFrameState frameState = EFrameComplete;
	TRAPD(err, frameState = DoProcessL());
	// If there is new scan or table, switch to it.
	if (iNewTableOrScan)
		{
		if (marker == KJpgDHTSignature)
			{
			switched = ProcessHuffmanTableL(newMarkerAddr, bufferLimit);
			}
		else if (marker == KJpgSOSSignature)
			{
			switched = SwitchScanL(newMarkerAddr, bufferLimit);
			}
		}
	
	if (err != KErrNone)
		{
		if (err == KErrCompletion)
			{
			RestoreState();
			frameState = EFrameIncomplete;
			}
		else if (err == KErrEof)
			{
			frameState = EFrameComplete;
			// Render all MCUs.
			RenderMCUsL();
			}
		else
			{
			JPEG_LEAVE(err, "From DoProcessL");
			}
		}
	
	if (switched)
		{
		iDataPtr = const_cast<TUint8*>(newMarkerAddr);
		if (marker == KJpgSOSSignature)
			{
			ResetOnNewScan();
			}
		}
	
	aSrc.Shift(iDataPtr - aSrc.Ptr()); // Shift out used data.

	return frameState;
	}


//
// Switches to new scan if sufficient header information is available.
//
TBool CMultiScanSequentialJpgReadCodec::SwitchScanL(const TUint8*& aScan, const TUint8* aDataLimit)
	{
	const TInt KSosSizeFieldLength = 2;
	if (aScan + sizeof(KJpgSOSSignature) + KSosSizeFieldLength > aDataLimit)
		{
		return EFalse;
		}
	
	// Check for SOS marker.
	TUint16 value = ReadBigEndianUint16(aScan);
	if (value != KJpgSOSSignature)
		{
		return EFalse;
		}
	
	// Read length and check if entire scan is available.
	value = ReadBigEndianUint16(aScan);
	if (aScan + value - KSosSizeFieldLength > aDataLimit)
		{
		return EFalse;
		}
	
	// Keep track of MCUs available for components.
	for (TInt i = 0; i < iScanInfo.iNumberOfComponents; i++)
		{
		TInt compIndex = ComponentIndexL(iScanInfo.iComponent[i].iId);
		iCompMcuCount[compIndex] = iCurrentMcuIdx;
		}

	iScanInfo.iNumberOfComponents = *aScan;
	// Component id, table selector bytes.
	const TInt KCompBytes = 2;
	// Scan start, scan end, successive approx bytes.
	const TInt KScanBytes = 3;
	if (aScan + (iScanInfo.iNumberOfComponents * KCompBytes) + KScanBytes > aDataLimit)
 		{
 		// Header length is wrong. Entire header is not available in the buffer.
		return EFalse;
		}
	
	TJpgScanInfoProcessor::ProcessStartOfScanL(aScan, iFrameInfo, iScanInfo, iDCHuffmanTable, iACHuffmanTable);
	
	// Move to next address after scan.
	aScan++;
	for (TInt i = 0; i < iScanInfo.iNumberOfComponents; i++)
		{
		TJpgScanInfo::TScanComponentInfo& scanInfo = iScanInfo.iComponent[i];
		TInt compIndex = ComponentIndexL(scanInfo.iId);
		if (iCompAvailable[compIndex])
			{
			// If a same component repeats, then the file is corrupt. Stop further decoding.
			JPEG_LEAVE(KErrEof, "Repeated component");
			}
		
		TInt unitCount = iTotalMCUBlocks * iMCUDataUnitCount[compIndex];
		iCompBuf[compIndex] = reinterpret_cast<TDataUnit*>(iMCUMemoryOffset);
		iCompAvailable[compIndex] = ETrue;
		
		iMCUMemoryOffset += unitCount * sizeof(TDataUnit);
		}
	
	iCurrentMcuIdx = 0;
	if (iFrameInfo.iRestartInterval > 0)
		{
		iRestartMCUCount = iFrameInfo.iRestartInterval;
		}
	else
		{
		iRestartMCUCount = KErrNotFound;
		}
	
	ResetState();
	return ETrue;
	}


//
//
//
TBool CMultiScanSequentialJpgReadCodec::ProcessHuffmanTableL(const TUint8*& aData, const TUint8* aBufferLimit)
	{
	// Length of size field for table marker.
	const TInt KTableMarkerSizeField = 2;
	if (aData + sizeof(KJpgDHTSignature) + KTableMarkerSizeField > aBufferLimit)
		{
		return EFalse;
		}
	
	// Read marker.
	TUint16 value = ReadBigEndianUint16(aData);
	if (value != KJpgDHTSignature)
		{
		return EFalse;
		}
	
	// Read length.
	value = ReadBigEndianUint16(aData);
	
	// Check if entire table data is available in buffer.
	const TUint8* dataLimit = aData + value - KTableMarkerSizeField;
	if (dataLimit > aBufferLimit)
		{
		return EFalse;
		}
	
	THuffmanTableProcessor::ProcessHuffmanTableL(aData, dataLimit, iDCHuffmanTable, iACHuffmanTable);
	
	return ETrue;
	}


//
// Copies MCUs to component buffers, where they are accumulated.
//
void CMultiScanSequentialJpgReadCodec::CopyMCUs(TInt aCompIdx)
	{
	if (iMonochrome && (aCompIdx != KYComp))
		{
		return;
		}
	
	// Assumes that iCurrentMcuIdx value start from 0.
	const TDataUnit* src = iComponent[aCompIdx];
	TDataUnit* des = iCompBuf[aCompIdx];
	
	// If Y with 4 DUs.
	if ((aCompIdx == KYComp) && (iMCUDataUnitCount[KYComp] == 4))
		{
		// Rearranges Y Data Units, so that they are rendered sequentially.
	   	TInt mcusPerLine = GetHorzMCUCount();
		TInt dusPerLine = mcusPerLine * iMCUDataUnitCount[KYComp];
		TInt line =  iCurrentMcuIdx / mcusPerLine;
		TDataUnit* lineAddr = des + (line * dusPerLine);
		TInt mcuIdxInLine = iCurrentMcuIdx - (line * mcusPerLine);
		
		// Copy offset.
		TInt offset = 0;
		if ((mcuIdxInLine + 1) <= mcusPerLine / 2)
			{
			offset = mcuIdxInLine * 8;
			}
		else
			{
			TInt idx = (mcuIdxInLine + 1) - (mcusPerLine / 2);
			offset = (idx  - 1) * 8 + 2;
			}
		
		// Copy 2 DUs at a time, giving 2 DU space.
		Mem::Copy(lineAddr + offset, src, 2 * sizeof(TDataUnit));
		Mem::Copy(lineAddr + offset + 4, src + 2, 2 * sizeof(TDataUnit));
		}
	else
		{
		des += iCurrentMcuIdx * iMCUDataUnitCount[aCompIdx];
		Mem::Copy(des, src, iMCUDataUnitCount[aCompIdx] * sizeof(TDataUnit));
		}
	}


//
// Sets up iComponent to point to the right parts of the RChunk memory.
//
void CMultiScanSequentialJpgReadCodec::PrepareToRenderMCU(TInt aMCUIndex)
	{
	JPEG_ASSERT(aMCUIndex >= 0);
	
	for (TInt i = 0; i < KJpgNumberOfComponents; i++)
		{
		if (iCompAvailable[i])
			{
			iComponent[i] = &iCompBuf[i][aMCUIndex * iMCUDataUnitCount[i]];
			}
		}
	}


//
// Sends all MCUs of components to rendering.
//
void CMultiScanSequentialJpgReadCodec::RenderMCUsL()
	{
	for (TInt i = 0; i < iScanInfo.iNumberOfComponents; i++)
		{
		// Keep track of number of MCUs available for components.
		TInt compIndex = ComponentIndexL(iScanInfo.iComponent[i].iId);
		iCompMcuCount[compIndex] = iCurrentMcuIdx;
		}
	
	FillEmptyMCUs();
	
	while (iNeededMCU != KErrCompletion)
		{
		iStreamMCU = iNeededMCU;	// Maintain behaviour of CSequentialJpgReadCodec.

		Mem::Copy(&iComponentCpy, &iComponent, sizeof(TDataUnit*) * KJpgNumberOfComponents);
		PrepareToRenderMCU(iNeededMCU);
		PostProcessMCUL(EFalse);
		Mem::Copy(&iComponent, &iComponentCpy, sizeof(TDataUnit*) * KJpgNumberOfComponents);

		
		iNeededMCU = iMCUStore->GetNextMCU();
		}
	}


//
// If the number of available MCUs for Cb and Cr is less than that of Y, those MCUs are filled with 0x7f.
//
void CMultiScanSequentialJpgReadCodec::FillEmptyMCUs()
	{
	// MCU index to start filling. This may involve overwriting existing U or V data.
	TInt startIdx = Min(iCompMcuCount[KUComp], iCompMcuCount[KVComp]);
	for (TInt i = KUComp; i <= KVComp; i++)
		{
		if (iComponent[i] == NULL)
			{
			// If monochrome or if the component is not part of image.
			continue;
			}
		
		TDataUnit* des = NULL;
		if (iCompAvailable[i])
			{
			des = iCompBuf[i];
			des += startIdx * iMCUDataUnitCount[i];
			TInt dus = (iCompMcuCount[KYComp] - startIdx) * iMCUDataUnitCount[i];
			for (TInt k = 0; k < dus; k++)
				{
				FillEmptyDU(&des[k]);
				}
			}
		else
			{
			des = iComponent[i];
			// If component is not at all available, fill iComponent[] buffer with 0x7f.
			for (TInt k = 0; k < iMCUDataUnitCount[i]; k++)
				{
				FillEmptyDU(&des[k]);
				}
			}
		}
	}


//
// Resets the data members so that new scan can be started
//
void CMultiScanSequentialJpgReadCodec::ResetOnNewScan()
	{
	iInitialDataPtr = NULL;
	iBitBufferPtrLimit = NULL;
	iDataValue = 0;
	iInitialDataValue = 0;
	iBitsLeft = 0;
	iInitialBitsLeft = 0;
	
	for (TInt i = 0; i < KJpgNumberOfComponents; i++)
		{
		iDCPredictor[i] = 0;
		iInitialDCPredictor[i] = 0;
		}
	}


//
// Fills the given Data Unit with 0x7f.
//
void CMultiScanSequentialJpgReadCodec::FillEmptyDU(TDataUnit* pDU)
	{
	JPEG_ASSERT(pDU);
	JPEG_ASSERT(pDU->iCoeff);
	
	TDataUnit::TDataUnitElemType* ptr = pDU->iCoeff;
	for(TInt i = 0; i < KJpgDCTBlockSize; i++)
		{
		*ptr++ = 0x7f;
		}
	}