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