// Copyright (c) 2004-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 "exiftransform.h"

#include "exiftransformdataaccessor.h"

#include "ExifEditUtility.h"

#include "ExifThumbnailGenerator.h"

#include "ExifGeneralConsts.h"

#include "JpegConsts.h"

#include "ImageUtils.h"

#include <f32file.h>

const TUint8 KJpegMarkerByte = 0xff;

const TUint8 KDhtMarkerByte = 0xc4;

const TUint8 KDqtMarkerByte = 0xdb;

const TUint8 KSosMarkerByte = 0xda;

const TUint KTableTypeSize = 1;		// in DHT and DQT the table type is one byte long

const TUint KEntriesInQTable = 64;	// number of entries in a specific quantization table

const TUint KDCTableSize = 28;		// see Exif 2.2 specification

const TUint KACTableSize = 178;		// see Exif 2.2 specification

const TUint KDQTTypicalSize = (KTableTypeSize + KEntriesInQTable) * 3;

const TUint KDHTTypicalSize = (KTableTypeSize + KDCTableSize) * 2 + (KTableTypeSize + KACTableSize) * 2;

const TInt KJpegBlockTypeUndefined = -1;

_LIT(KDhtBlockHeader, "\xff\xc4\x00\x00");	// jpeg DHT block id followed by placeholder for block size

_LIT(KDqtBlockHeader, "\xff\xdb\x00\x00");	// jpeg DQT block id followed by placeholder for block size

CExifEditUtility* CExifEditUtility::NewL(MExifSource* aSource, MExifDest* aDest, TBool aIgnoreExifMetadataProcessing)

	{

	CExifEditUtility * self= new (ELeave) CExifEditUtility(aIgnoreExifMetadataProcessing);

	CleanupStack::PushL(self);

	self->ConstructL(aSource, aDest);

	CleanupStack::Pop(self);

	return self;

	}

CExifEditUtility::~CExifEditUtility()

	{

	Cancel();

	delete iScaledJpegGenerator;

	delete iExifData;

	iDHTTables.Close();

	iDQTTables.Close();	

	iTempCopyBuffer.Close();

	}

CExifEditUtility::CExifEditUtility(TBool aIgnoreExifMetadataProcessing)

	: CActive(EPriorityStandard)

	, iState(EEmpty)

	, iIgnoreExifMetadataProcessing(aIgnoreExifMetadataProcessing)

	{

	iLookupSlackBuff.SetLength( 0 );

	}

void CExifEditUtility::ConstructL(MExifSource* aSource, MExifDest* aDest)

	{

	ASSERT(aSource != NULL);

	ASSERT(aDest != NULL);

	iSource = aSource;

	iDest = aDest;

	CActiveScheduler::Add(this);

	}

MExifMetadata* CExifEditUtility::ExifMetadata()

	{

	return iExifData;

	}

//

//

//

//

//		interface methods

//	

void CExifEditUtility::ReadSourceL()

	{

	if(iState!=EEmpty)

		{

		User::Leave(KErrInUse);

		}

	InitReadL();

	if(!iIgnoreExifMetadataProcessing)

		{

		delete iExifData;

		iExifData = NULL;

		TRAPD(err, iExifData = iSource->ReadAndConvertExifDataL(iHeaderBlockSize + 

			(sizeof(KJpgSOISignature)+sizeof(KJpgMarker)) /*size of the app1 marker*/, 

			iExifBlockSize));

		if(err != KErrNone)

			{

			if(err == KErrNoMemory)

				{

				User::Leave(KErrNoMemory);					

				}

			iIgnoreExifMetadataProcessing = ETrue;

			iExifBlockSize = 0;

			iConvertToJfif = ETrue;				

			}

		}

	iState=EReadComplete;

	}

void CExifEditUtility::WriteDestL(TBool aEncodeThumbnail, const TSize& aSize, TBool aPreserveImage, TBool aMaintainAspectRatio, TRequestStatus* aNotifier)

	{

	iNotifier=aNotifier;

	iEncodeThumbnail=aEncodeThumbnail;

	iSize= aSize;

	iPreserveImage= aPreserveImage;

	iMaintainAspectRatio = aMaintainAspectRatio;

	if(iState !=EReadComplete)

		{

		RunError(KErrInUse);

		return;

		}

	TInt err=iDest->Init();

	if(err!=KErrNone)

		{

		RunError(err);

		return;

		}

	iState=EStartWrite;

	ProcessCommandL();

	*iNotifier=KRequestPending;

	}

//

//		interface methods

//	

//

//

//

//

//

//

//

//		methods from CActive

//

void CExifEditUtility::DoCancel()

	{

	iState=ECancelled;

	if(iScaledJpegGenerator)

		{

		iScaledJpegGenerator->Cancel();

		}

	//Now reset everything to how it was before the transform.

	iState = EReadComplete;	

	iSource->Cancel();

	iDest->Cancel();

	//We need to cancel both the internal state machine request status

	//and the client request status	

	if (iStatus == KRequestPending)

		{

		TRequestStatus* status=&iStatus;

		User::RequestComplete(status, KErrCancel);

		}

	if (iNotifier)//but we do need to check iNotifier TRequestStatus

		{

		if (*iNotifier == KRequestPending)

			{

			User::RequestComplete(iNotifier,KErrCancel);

			}

		}

	}

void CExifEditUtility::RunL()

	{

	if(iStatus.Int()==KErrNone)

		{

		ProcessCommandL();

		}

	else

		{

		RunError(iStatus.Int());

		}

	}

TInt CExifEditUtility::RunError(TInt aError)

	{					

	if(iState<EReadComplete)

		{

		delete iExifData;

		iExifData = NULL;

		iState=EEmpty;

		iSource->CleanupAfterEarlyError();

		iDest->CleanupAfterEarlyError();

		}

	else 

		{

		iState=EReadComplete;

		iSource->CleanupAfterLateError();

		iDest->CleanupAfterLateError();

		}

	User::RequestComplete(iNotifier, aError);

	return KErrNone;

	}

//

//		interface methods

//	

//

//

//

void CExifEditUtility::ProcessCommandL()

	{

	TBool doContinue=EFalse;

	switch(iState)

		{

		// writer commands

		case EStartWrite:

			doContinue=DoCopyBlockL(0, iHeaderBlockSize, EWriteWriteHeader);

			iState=ECopying;

			break;

		case EWriteWriteHeader:

			if(!iIgnoreExifMetadataProcessing)

				{

				doContinue=DoWriteReadThumbnailL();

				}

			else

				{

				//skip to next step.

				iStatus=KRequestPending;

				TRequestStatus* reqStat=&iStatus;

				User::RequestComplete(reqStat, KErrNone);

				doContinue = ETrue; 

				}

			iState = EReadThumbnail;

			break;

		case EReadThumbnail:

			doContinue=DoReadThumbnailL();		

			if (iPreserveImage)

				{

				iState=EWriteReadThumbnail;

				}

			else

				{

				iState=EWriteWriteExif;

				}

			break;		

		case EWriteReadThumbnail:

			doContinue=DoWriteConvertExifL();

			iState=EWriteConvertExif;

			break;

		case EWriteConvertExif:

			if(iIgnoreExifMetadataProcessing && (iExifBlockSize >0))

				{

				HBufC8* destBuffer = iIOBufferPtr.AllocL();

				iDest->SetDestBuffer(destBuffer); // Give iDest ownership of buffer

				}

			doContinue=DoWriteDestBufferL();

			if(iPreserveImage)

				{

				iState=EWriteWriteExif;

				}

			else

				{

				iState=EWriteReadMainImage;

				}

			break;

		case EWriteWriteExif:

			if(iPreserveImage)

				{

				doContinue=DoCopyBlockL(iTrailerOffset, iTrailerBlockSize, EWriteTrailer, iDestIsExif);

				iState=ECopying;

				}

			else

				{

				doContinue=DoCreateMainImageL();

				iCurrentWriteBufferIndex = 0;

				iState=EWriteReadThumbnail;

				}

			break;

		case EWriteTrailer:

			DoWriteComplete();

			iState=EReadComplete;

			break;

		case EWriteReadMainImage:

			doContinue=DoWriteScaledImageL();

			break;

		case ECancelled:

			return;

		case ECopying:

			iState=DoCopyNextBlockL();

			doContinue=ETrue;

			break;

		default:

			break;

		}

	if(doContinue)

		{

		SetActive();

		}

	}

//

//

//

//

//		Readers and writers

//	each performs one step of the process

//

//			Readers

//

void CExifEditUtility::InitReadL()

	{

	iSource->InitL();

	TBool exifFound=EFalse;

	TUint16 jpegMarker=0;

	TUint position=0;

	TUint16 blockSize=0;

	// we want to preserve the image data.

	// so we parse the source file, and isolate the exif metadata

	for(;;)

		{		

		position+=blockSize;

		jpegMarker=KJpgSOISignature;

		User::LeaveIfError(iSource->SetReadPosition(position));

		do

			{

			jpegMarker=iSource->ReadUint16L();	

			position+=sizeof(TUint16);

			}while(jpegMarker==KJpgSOISignature);

		if(jpegMarker==KJpgApp0Signature || jpegMarker==KJpgApp1Signature)

			{

			blockSize=iSource->ReadUint16L();

			position+=sizeof(TUint16);

			if (jpegMarker==KJpgApp1Signature)

				{

				exifFound=ETrue;

				break;					

				}

			}

		else

			{

			break;

			}

		}

	User::LeaveIfError(iSource->Size(iTrailerBlockSize));

	iTrailerOffset=sizeof(KJpgSOISignature);

	if(exifFound)

		{

		// Set our reading parameters

		TUint sizeOfApp1Marker = sizeof(KJpgSOISignature)+sizeof(KJpgMarker);

		if(position <= sizeOfApp1Marker) User::Leave(KErrCorrupt);//source file is corrupted.

		iHeaderBlockSize=position - sizeOfApp1Marker;	

		iExifBlockSize=blockSize;

		iTrailerOffset+=iHeaderBlockSize+blockSize;

		}

	else

		{

		iHeaderBlockSize=sizeof(KJpgSOISignature); 		

		iExifBlockSize=0;

		}

	iTrailerBlockSize-= iTrailerOffset;

	}

//			Readers

//

//

//

//			Writers

//

TBool CExifEditUtility::DoWriteConvertExifL()

	{

	if(iIgnoreExifMetadataProcessing)

		{

		if(iExifBlockSize)

			{

			//copy the EXIF metadata en-block, without parsing it first.

			iSource->ReadL(iHeaderBlockSize, iIOBufferPtr, iExifBlockSize + KBlockSizeLength, iStatus);

			iDestIsExif = ETrue;

			}

		else

			{ // JUMP to next step... no EXIF metadata information, so nothing to ignore.

			if (iConvertToJfif)

				{

				//Create a buffer to hold a default JFIF header

				HBufC8* buffer=HBufC8::NewMaxL(KJfifApp0DataSize+sizeof(KJpgApp0Signature));

				TPtr8 buf(buffer->Des());

				TJpegUtilities::CreateJfifHeader(buf);

				iDest->SetDestBuffer(buffer);// Give iDest ownership of buffer				

				}

			iStatus=KRequestPending;	

			TRequestStatus* reqStat=&iStatus;

			User::RequestComplete(reqStat, KErrNone);

			iDestIsExif = EFalse;

			}

		}

	else

		{	

		TInt err = KErrNone;

		if(iExifBlockSize > 0 || iExifData->IsExifDataModified())

			{

			HBufC8* buffer = NULL;

			UpdateImageSizeTagsL();

			iExifData->CheckUpdateMandatoryTagsL();

			err= iExifData->CreateExifChunk(buffer); // buffer not owned by iExifData

			if (err == KErrNone)

				{

				iDest->SetDestBuffer(buffer); // Give iDest ownership of buffer

				}	

			iExifData->ResetExifDataModified();

			iDestIsExif = ETrue;	

			}

		else

			{

			iDestIsExif = EFalse;

			}

		iStatus=KRequestPending;	

		TRequestStatus* reqStat=&iStatus;

		User::RequestComplete(reqStat, err);	

		}

	return ETrue;	//we continue to the next step

	}

TBool CExifEditUtility::DoWriteReadThumbnailL()

	{

	if(iEncodeThumbnail)

		{

		HBufC8* buffer = iExifData->GetJpegThumbnailData(); // Does not transfer ownership of buffer

		if(buffer==NULL)

			{

			delete iScaledJpegGenerator;

			iScaledJpegGenerator=NULL;

			// we have to generate the thumbnail

			iScaledJpegGenerator=CScaledJpegGenerator::NewL(&iStatus, iSource);

			iScaledJpegGenerator->StartL(TSize(KThumbnailWidth, KThumbnailHeight), CScaledJpegGenerator::EThumbnail);

			}

		else

			{

			iStatus=KRequestPending;

			TRequestStatus* reqStat=&iStatus;

			User::RequestComplete(reqStat, KErrNone);

			}

		}

	else

		{

		iExifData->SetThumbnailData(NULL);

		iStatus=KRequestPending;

		TRequestStatus* reqStat=&iStatus;

		User::RequestComplete(reqStat, KErrNone);

		}

	return ETrue;

	}

TBool CExifEditUtility::DoReadThumbnailL()

	{

	if(iEncodeThumbnail && iScaledJpegGenerator)

		{

		HBufC8* thumb=iScaledJpegGenerator->GetJpegDataL(); // thumb not owned by iScaledJpegGenerator

		delete iScaledJpegGenerator;

		iScaledJpegGenerator=NULL;

		iExifData->SetThumbnailData(thumb); // Give iExifData ownership of thumb

		}

	iStatus=KRequestPending;	

	TRequestStatus* reqStat=&iStatus;

	User::RequestComplete(reqStat, KErrNone);

	return ETrue;

	}

TBool CExifEditUtility::DoCreateMainImageL()

	{

	if(!iScaledJpegGenerator)

		{

		iScaledJpegGenerator=CScaledJpegGenerator::NewL(&iStatus, iSource, iMaintainAspectRatio, 

			CImageDecoder::EOptionIgnoreExifMetaData);

		}

	iScaledJpegGenerator->StartL(iSize, CScaledJpegGenerator::EMainImage);

	return ETrue;

	}