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

//

#include <barsc.h>

#include <barsread.h>

#include <bautils.h>

#include <imageconversion.h>

#include "icl/ImageCodec.h"

#include "ImageClientMain.h"

#include <101F45D6_extra.rsg>

#include "JpegTypes.h"

#include "jpegwritecodec.h"

#include "JpegYuvDecoder.h"

#include "icl/ICL_UIDS.hrh"

#include <bitmaptransforms.h>

#include "exifdecoder.h"

#include "ExifEncoder.h"

#include "exiftransform.h"

#include "ImageUtils.h"

#include "JPEGCodec.h"

#include "JPEGConvert.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <icl/icl_uids_const.hrh>

#include <icl/icl_uids_def.hrh>

#include <icl/imagecodecdef.h>

#endif

_LIT(KJPEGPanicCategory, "JPEGConvertPlugin");

const TInt KBlockSignatureSearchSize = 256;

const TInt KSizeOfBlockSignaturePlusBlockLength = sizeof(KJpgMarker) + sizeof(TUint16);

//

// this file doesn't contain much of performance-critical code so use thumb

// instruction set to save on some ROM footprint

//

#if defined(__ARMCC__)

#pragma thumb

#endif

// Global panic function

GLDEF_C void Panic(TIclPanic aError)

	{

	User::Panic(KJPEGPanicCategory, aError);

	}

// Jpeg decoder.

CJpegDecoder* CJpegDecoder::NewL()

	{

	return new(ELeave)CJpegDecoder();

	}

CJpegDecoder::CJpegDecoder()

 :	iImageType(CImageDecoder::EImageTypeMain)

	{

	}

CJpegDecoder::~CJpegDecoder()

	{

	delete iExtensionManager;

	delete iStreamedDecodeExt;

	delete iExifDecoder;

	iComment.ResetAndDestroy();

	Cleanup();

	}

void CJpegDecoder::ImageType(TInt aFrameNumber, TUid& aImageType, TUid& aImageSubType) const

	{

	__ASSERT_ALWAYS(aFrameNumber == 0, Panic(EFrameNumberOutOfRange));

	aImageType = KImageTypeJPGUid;

	aImageSubType = KNullUid;

	}

TInt CJpegDecoder::NumberOfFrameComments(TInt aFrameNumber) const

	{

	__ASSERT_ALWAYS(IsImageHeaderProcessingComplete(), Panic(EHeaderProcessingNotComplete));

	__ASSERT_ALWAYS((aFrameNumber >= 0) && (aFrameNumber < NumberOfFrames()), Panic(EFrameNumberOutOfRange));

	const CFrameImageData& frameImageData = FrameData(aFrameNumber);

	TInt frameCommentCount = 0;

	// Because this is a single frame format, the comments are stored

	// in the global rather than local comment block

	TInt imageDataCount = frameImageData.ImageDataCount();

	for (TInt count = 0; count < imageDataCount; count++)

		{

		const TImageDataBlock* imageData = frameImageData.GetImageData(count);

		if (imageData->DataType() == KJPGCommentUid)

			frameCommentCount++;

		}

	return frameCommentCount;

	}

HBufC* CJpegDecoder::FrameCommentL(TInt aFrameNumber, TInt aCommentNumber) const

	{

	__ASSERT_ALWAYS(IsImageHeaderProcessingComplete(), Panic(EHeaderProcessingNotComplete));

	__ASSERT_ALWAYS((aFrameNumber >= 0) && (aFrameNumber < NumberOfFrames()), Panic(EFrameNumberOutOfRange));

	__ASSERT_ALWAYS((aCommentNumber >= 0) && (aCommentNumber < NumberOfFrameComments(aFrameNumber)), Panic(ECommentNumberOutOfRange));

	const CFrameImageData& frameImageData = FrameData(aFrameNumber);

	TInt commentCount = 0;

	// Because this is a single frame format, the comments are stored

	// in the global rather than local comment block

	TInt imageDataCount = frameImageData.ImageDataCount();

	const TImageDataBlock* imageData = NULL;

	for (TInt count = 0; count < imageDataCount; count++)

		{

		imageData = frameImageData.GetImageData(count);

		if (imageData->DataType() == KJPGCommentUid)

			{

			if (commentCount == aCommentNumber)

				{

				break;

				}

			commentCount++;

			}

		}

	const TJpegComment* jpegComment = static_cast<const TJpegComment*>(imageData);

	HBufC* comment = NULL;

	if (jpegComment)

		{

		comment = HBufC::NewL(jpegComment->iComment->Length());

		comment->Des().Copy(*(jpegComment->iComment)); // Create a 16 bit copy of the 8 bit original	

		}

	return comment;

	}

TInt CJpegDecoder::FrameHeaderBlockSize(TInt /*aFrameNumber*/) const

	{

	return KJfifHeaderBlockSizeInBytes;

	}

TInt CJpegDecoder::FrameBlockSize(TInt /*aFrameNumber*/) const

	{

	return KJfifDataBlockSizeInBytes;

	}

//

//

//

TInt CJpegDecoder::GetDestinationSize(TSize& aSize, TInt aFrameNumber)

	{

	ASSERT(iExtensionManager);

	const TFrameInfo frameInfo = FrameInfo(aFrameNumber);

	TSize originalSize = frameInfo.iOverallSizeInPixels;

	TInt err = iExtensionManager->GetDestinationSize(originalSize);

	if(err == KErrNone)

		{

		aSize = originalSize;

		}

	return err;

	}

void CJpegDecoder::InitConvertL()

	{

	iState = EStateStart; //  when starting convert, always start from the top

	CImageDecoderPlugin::InitConvertL();

	}

void CJpegDecoder::DoConvert()

	{

	switch(iState)

		{

		case EStateStart:

			{

			TRAPD(errCode, PrepareForProcessFrameL());

			if (errCode!=KErrNone)

				{

				RequestComplete(errCode);

				return;

				}

			iCodecState = EFrameIncomplete;

			TBufPtr8& sourceData = SourceData();

			TInt sourceLength = sourceData.Length();

			if (sourceLength!=0)

				{

				TRAP(errCode, iCodecState = ImageReadCodec()->ProcessFrameL(sourceData));

				}

			if (errCode == KErrNone && (sourceData.Length() == sourceLength || iCodecState == EFrameComplete || iCodecState == EBlockComplete))

				{

				CJpgReadCodec* readCodec = static_cast<CJpgReadCodec*>(ImageReadCodec());

				JPEG_ASSERT(readCodec);

				readCodec->InitDrawFrame();

				iState=EStateDrawFrame;

				SelfComplete(KErrNone);

				}

			else

				{

				ASSERT(iState==EStateStart);

				HandleProcessFrameResult(errCode,iCodecState);

				}

			}

			break;

		case EStateDrawFrame:

			{

			CJpgReadCodec* readCodec = static_cast<CJpgReadCodec*>(ImageReadCodec());

			JPEG_ASSERT(readCodec);

			TBool result = EFalse;

			TRAPD(errCode, result = readCodec->DrawFrameL());

			if (errCode != KErrNone)

				{

				HandleProcessFrameResult(errCode, iCodecState);

				}

			else if (result)

				{

				HandleProcessFrameResult(KErrNone, iCodecState);

				iState = EStateStart;

				}

			else

				{

				ASSERT(iState==EStateDrawFrame);

				SelfComplete(KErrNone);

				}

			}

			break;

		default:

			ASSERT(EFalse);

		}

	}

MExifMetadata* CJpegDecoder::ExifMetadata()

	{

	return iExifDecoder;

	}

// Scan header.

// Validate that format is correct.

// Create codec.

// Fill in image info. (All frames)

void CJpegDecoder::ScanDataL()

	{

	ReadFormatL();

	ASSERT(ImageReadCodec() == NULL);

	CJpgReadCodec* imageReadCodec = NULL;

	if (iJpgFrameInfo.iProgressive)

		{

		imageReadCodec = CProgressiveJpgReadCodec::NewL(

				iJpgFrameInfo,

				iScanInfo,

				iDCHuffmanTable,

				iACHuffmanTable,

				iQTable);

		}

	else if (iJpgFrameInfo.iNumberOfComponents == iScanInfo.iNumberOfComponents)

		{

		imageReadCodec = CSequentialJpgReadCodec::NewL(

				iJpgFrameInfo,

				iScanInfo,

				iDCHuffmanTable,

				iACHuffmanTable,

				iQTable);

		}

	else

		{

		iJpgFrameInfo.iMultiScan = ETrue;

		imageReadCodec = CMultiScanSequentialJpgReadCodec::NewL(

				iJpgFrameInfo,

				iScanInfo,

				iDCHuffmanTable,

				iACHuffmanTable,

				iQTable);

		}

	CleanupStack::PushL(imageReadCodec);

	if (!iExtensionManager)

		{

		// Manager settings persist over all frames.

		iExtensionManager = CPluginExtensionManager::NewL(imageReadCodec);

		}

	else

		{

		// Maintain manager settings, but reset the codec that it points to.

		iExtensionManager->ResetCodecExtension(imageReadCodec);

		}

	CleanupStack::Pop(); // imageReadCodec

	imageReadCodec->SetExtensionManager(iExtensionManager);

	imageReadCodec->SetHighSpeedMode( (DecoderOptions() & CImageDecoder::EPreferFastDecode) == CImageDecoder::EPreferFastDecode );

	// If this is the main image - pull the thumbnail out and give it to the

	// framework

	if (iImageType == CImageDecoder::EImageTypeMain)

		{

		if (iExifDecoder != NULL)

			{

			TInt err = 0;

			TInt thumbDataOffset = 0;

			HBufC8* thumbnailData = NULL;

			// Hold the thumbnail data (extracted from the Exif object).

			// Get both the offset of the thumbnail data and its length.

			err = iExifDecoder->GetIntegerParam(KJPEGInterchangeFormat, 1, thumbDataOffset);

			if(err == KErrNone)

				{

				TInt thumbDataLength = 0;

				err = iExifDecoder->GetIntegerParam(KJPEGInterchangeFormatLength, 1, thumbDataLength);

				if(err == KErrNone)

					{

					//get the thumbnail data.

					thumbnailData = iExifDecoder->GetJpegThumbnailData();

					// Pass the thumbnailData back to the framework (ownership remains here).

					SetThumbnailData(thumbnailData);

					}

				}

			}

		}

	imageReadCodec->SetAutoRotateFlag(iAutoRotateFlag);

	SetImageReadCodec(imageReadCodec);

	ReadFrameHeadersL();

	}

void CJpegDecoder::NotifyImageTypeChangeL(TInt aImageType)

	{

	TInt prevImageType = iImageType;

	iImageType = aImageType;

	TRAPD(err, ScanDataL());

	if (err != KErrNone)

		{

		iImageType = prevImageType;

		JPEG_LEAVE(err, "ScanDataL");

		}

	}

void CJpegDecoder::ReadFormatL()

	{

	iJpgFrameInfo.iProgressive = EFalse; // Reset

	TPtrC8 bufferDes;

	ReadDataL(0, bufferDes, KJfifInitialHeaderSize);

	// Validate the header.

	if (bufferDes.Length() < KJfifInitialHeaderSize)

		{

		JPEG_LEAVE(KErrUnderflow, "Not enough data for JFIF header");

		}

	iPtr = &bufferDes[0];

	const TUint8* ptr = iPtr;

	TInt startPosition = 6; // Move past SOISignature + first block sig/length.

	TUint16 soiSig = ReadBigEndianUint16(ptr);

	if (soiSig != CJpgReadCodec::EMarkerSOI)

		{

		JPEG_LEAVE(KErrCorrupt, "Expected SOI marker");

		}

	iJpgFrameInfo.iRestartInterval = KErrNotFound;

	SetStartPosition(startPosition);

	//delete all comments

	iComment.ResetAndDestroy();

	for (;;)

		{

		// Read the signature and length of the next block.

		iBlockSignature = ReadBigEndianUint16(ptr);

		// Skip until next block signature is valid

		if ((iBlockSignature & KJpgMarkerMask) != KJpgMarker)

			{

			TInt blockIndex = KErrNotFound;

			TChar jpgMarker = TChar(KJpgMarker >> 8);

			for (;;)

				{

				// search in blocks of size KBlockSignatureSearchSize

				// for occurrence of a jpeg marker (0xff)

				ReadDataL(startPosition, bufferDes, KBlockSignatureSearchSize);

				if (!bufferDes.Length())

					{

					// no marker found, no data left

					JPEG_LEAVE(KErrCorrupt, "No marker, no data");

					}

				blockIndex = bufferDes.Locate(jpgMarker);

				if (blockIndex != KErrNotFound)

					{

					startPosition += blockIndex;

					break;

					}

				startPosition += bufferDes.Length();

				}

			if ((bufferDes.Length() - blockIndex) < KSizeOfBlockSignaturePlusBlockLength)

				{

				// ensure there are at least KSizeOfBlockSignaturePlusBlockLength bytes in bufferDes after the blockIndex

				ReadDataL(startPosition, bufferDes, KSizeOfBlockSignaturePlusBlockLength);

				if (bufferDes.Length() < KSizeOfBlockSignaturePlusBlockLength)

					{

					JPEG_LEAVE(KErrUnderflow, "Not enough data");	// Not enough data present

					}

				blockIndex = 0;

				}

			iPtr = &bufferDes[blockIndex];

			ptr = iPtr;

			iBlockSignature = ReadBigEndianUint16(ptr);

			startPosition += KSizeOfBlockSignaturePlusBlockLength;

			SetStartPosition(startPosition);

			}

		// Read the current block's length.

		iBlockLength = ReadBigEndianUint16(ptr);

		// Read the next block plus the signature and size of block to follow

		ReadDataL(StartPosition(),bufferDes,iBlockLength+2);

		if (bufferDes.Length() < iBlockLength+2)

			{

			JPEG_LEAVE(KErrUnderflow, "Not enough data");	// Not enough data present

			}

		iPtr = &bufferDes[0];

		switch (iBlockSignature)

			{

			case CJpgReadCodec::EMarkerAPP0:

				ProcessApp0L();

				break;

			case CJpgReadCodec::EMarkerAPP1:

				// Process the EXIF information

				// Check if the flag to ignore is set. If yes, set the data to NULL.

				if (DecoderOptions() & CImageDecoder::EOptionIgnoreExifMetaData)

					{

					delete iExifDecoder;

					iExifDecoder = NULL;

					}

				else

					{

					TRAPD(err, ProcessApp1L());

					if ((err != KErrCorrupt) && (err != KErrNotSupported))

						{

						JPEG_LEAVE_IF_ERROR(err, "ProcessApp1L");

						}

					}

				break;

			case CJpgReadCodec::EMarkerAPP14:

				ProcessAppEL();

				break;

			case CJpgReadCodec::EMarkerDHT:

				ProcessHuffmanTableL();

				break;

			case CJpgReadCodec::EMarkerDQT:

				ProcessQTableL();

				break;

			case CJpgReadCodec::EMarkerSOF2:

				iJpgFrameInfo.iProgressive = ETrue; // Fall through to ProcessStartOfFrameL()

			case CJpgReadCodec::EMarkerSOF0:

			case CJpgReadCodec::EMarkerSOF1:

				ProcessStartOfFrameL();

				break;

			case CJpgReadCodec::EMarkerSOF3:

				User::Leave(KErrNotSupported);

				break;

			case CJpgReadCodec::EMarkerSOS:

				ProcessStartOfScanL();

				FinishedProcessing();

				// Fill in image data structures and give control to the codec.

				InitialiseImageDataL();

				return;

			case CJpgReadCodec::EMarkerDRI:

				ProcessRestartInterval();

				break;

			case CJpgReadCodec::EMarkerCOM:

				CheckCommentBlockL();

				ProcessCommentL();

				break;

		default:

			// ProcessOtherBlockL();

			break;

			}

		ptr = iPtr + (iBlockLength - 2); // Advance past this block.

		startPosition += iBlockLength + 2; // Advance past this block and the signature and length of the next block

		SetStartPosition(startPosition);

		}

	}

//

// APP markers are reserved for application use. Different applications are

// free to use the same APP marker for different purposes.

// In our case, we look for the EXIF header and ignore it otherwise.

//

void CJpegDecoder::ProcessApp1L()

	{

	if (iBlockLength < KExifHeaderLength)

		{

		return;

		}

	TPtrC8 exifHeaderPtr(iPtr, KExifHeaderLength);

	if ((KExifHeader().Compare(exifHeaderPtr) == KErrNone) && (iExifDecoder == NULL))

		{

		// This is the EXIF header block, so instantiate the EXIF decoder object

		iExifDecoder = CExifDecoder::NewL(iBlockLength, iPtr);