// 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 <f32file.h>

#include "exifreaderwriter.h"

#include "ImageUtils.h"

#include "ExifTagHelper.h"

#include "ExifGeneralConsts.h"

#include "ifdgeneral.h"

#include "ExifTagDescriptions.h"

// used for ordering exif tags when writing them

const TInt KNumIfds = 5;

const TInt KIfdOrder[KNumIfds] = 

	{

	EZeroth, 

	EExifSub,

	EInterop,

	EGpsSub,

	EFirst

	};

HBufC8* CExifReaderWriter::CreateExifHeaderBaseL()

	{

	//write the GPS IFD tag in IFD 0 - need to write it twice to ensure correct offset

	//the second write we have the correct offset

	for (TInt i = 0; i < iIfds.Count(); i++)

		{

		if ((iIfds)[i]->Ifd() == EGpsSub)

			{

			if ((iIfds)[i]->Size())

				{

				TUint gpsIFDoffset = KIfdOffset;

				TInt result = SetIntegerParam(KTag8825[ETagValue], EZeroth, gpsIFDoffset);

				if (result != KErrNone)

					{

					User::Leave(result);

					}

				//loop through IFDs

				for (TUint j = 0; j < iIfds.Count(); j++)

	 				{

	 				//calculate the offset to the GPS IFD 

	 				TInt ifd = (iIfds)[j]->Ifd();

	 				if (ifd <= EInterop)

	 					{

		 				gpsIFDoffset += (iIfds)[j]->Size() + KSizeOfEntryCount;

	 					gpsIFDoffset += KIfdOffsetByteCount; // for size of pointer to next Ifd.

	 					}

	 				}

	 			//write the offset to IFD0 8825 GPS tag

				result = SetIntegerParam(KTag8825[ETagValue], EZeroth, gpsIFDoffset);

				if (result != KErrNone)

					{

					User::Leave(result);

					}

				}

			}

		}

	// Need to obtain the size of each IFD object in order to determine initial

	// alloc size of the total Exif data block.

	TUint allocSize = 0;

	// Account for the Exif file header data.

	allocSize = allocSize + KExifFileHeaderLength;

	// Account for the thumbnail

	if(iJpegThumbnailData)

		{

		allocSize += iJpegThumbnailData->Length();

		}

	// Account for each Ifd.

	TInt i;

	for (i = 0; i < iIfds.Count(); i++)

		{

		TUint size = iIfds[i]->Size();

		if (size > 0)

			{

			allocSize += KSizeOfEntryCount; 	// Need to allocate room for the Ifd entry count also.

			allocSize += size;

			allocSize += KIfdOffsetByteCount;	// Account for the offset to the next Ifd.

			}

		}

	// Maximum legal size of APP1 header is 64K.

	if (allocSize > KMaxApp1Size)

		{

		User::Leave(KErrTooBig);

		}

	// Allocate required buffer.

	HBufC8* buffer = HBufC8::NewL(allocSize);

	CleanupStack::PushL(buffer);

	iData = const_cast<TUint8*>(buffer->Des().Ptr());

	TUint8* tmpPtr = iData;

	WriteExifFileHeaderBaseL(allocSize - KBlockEndMarkerByteCount, tmpPtr);

	// Write each Ifd in turn.

	TUint currentOffset = KIfdOffset;

	for (TInt i = 0; i < KNumIfds; i++)

		{

		CIfdGeneral* ifd = GetIfd(KIfdOrder[i]);

		if (ifd != NULL) 

			{

			TUint16 entryCount = ifd->EntryCount();

			if (entryCount) 

				{

				TUint8* tempIfdBlock = ifd->CreateIfdBlockL(currentOffset);

				// Write Ifd entry count.		

				tmpPtr = Mem::Copy(tmpPtr, &entryCount, KSizeOfEntryCount);

				// Write the Ifd to the Exif data block.

				TInt length = ifd->Size();

				length += KIfdOffsetByteCount; // for size of pointer to next Ifd.

				tmpPtr = Mem::Copy(tmpPtr, tempIfdBlock, length);

				// Free data block created for this Ifd.

				User::Free(tempIfdBlock);

				currentOffset += length + KSizeOfEntryCount;

				}		

			}

		} // end for

	SetFirstIfdOffsetBase();

	// finally, embed the thumbnail

	if (iJpegThumbnailData)

		{

		// Now know the size of the other Ifd's, can set the offset to the 1st Ifd.

		TUint thumbnailLength = iJpegThumbnailData->Length();

		//return value the copy operation is not used, so discarded

		Mem::Copy(tmpPtr, iJpegThumbnailData->Ptr(), thumbnailLength);

		// No need to account for EOI as it is written elsewhere.

		// If the source does not have JPEGInterchangeFormatLength (tag 0x0202) then

		// ThumbnailLengthOffset will return an error. 0x0202 is mandatory with thumbs

		// so this should not happen except with corrupt sources.

		TUint thumbnailLengthOffset = 0;

		if (GetThumbnailLengthOffsetBase(thumbnailLengthOffset) == KErrNone)

			{

			Mem::Copy(iData + thumbnailLengthOffset, &thumbnailLength, sizeof(TUint));

			}

		}

	buffer->Des().SetLength(allocSize);

	CleanupStack::Pop();

	return buffer;

	}

CExifReaderWriter::CExifReaderWriter() 

	{

	}

// Set 8-bit data.

TInt CExifReaderWriter::SetParam8(TUint aTag, TUint aIfd,  HBufC8* aParam)

	{

	TInt err = DoSetParam8(aTag, aIfd, aParam);

	if(err == KErrNone)

		{

		iExifDataModified = ETrue;

		}

	return err;

	}

// Set 16-bit data.  Only used for Unicode 'User Comment' tag.

TInt CExifReaderWriter::SetParam16(TUint aTag, TUint aIfd,  HBufC16* aParam)

	{

	TInt err = DoSetParam16(aTag, aIfd, aParam);

	if(err == KErrNone)

		{

		iExifDataModified = ETrue;

		}

	return err;

	}

TInt CExifReaderWriter::SetIntegerParam(TUint aTag, TUint aIfd,  TInt aParam)

	{

	TInt err = DoSetIntegerParam(aTag, aIfd, aParam);

	if(err == KErrNone)

		{

		iExifDataModified = ETrue;

		}

	return err;

	}

TInt CExifReaderWriter::SetRationalParam(TUint aTag, TUint aIfd, TInt aNumerator, TInt aDenominator)

	{

	TInt err = DoSetRationalParam(aTag, aIfd, aNumerator, aDenominator);

	if( err == KErrNone)

		{

		iExifDataModified = ETrue;

		}

	return err;

	}

TInt CExifReaderWriter::SetShortParam(TUint aTag, TUint aIfd, TUint16 aParam)

	{

	TInt err = DoSetShortParam(aTag, aIfd, aParam);

	if( err == KErrNone )

		{

		iExifDataModified = ETrue;

		}

	return err;

	}

TInt CExifReaderWriter::SetIntegerArrayParam(TUint aTag, TUint aIfd, CArrayFix<TInt>& aParam)

	{

	TInt err = DoSetIntegerArrayParam(aTag, aIfd, aParam);

	if(err == KErrNone)

		{

		iExifDataModified = ETrue;

		}

	return err;

	}

TInt CExifReaderWriter::SetRationalArrayParam(TUint aTag, TUint aIfd, CArrayFix<TRational>& aParam)

	{

	TInt err = DoSetRationalArrayParam(aTag, aIfd, aParam);

	if(err == KErrNone)

		{

		iExifDataModified = ETrue;

		}

	return err;

	}

TInt CExifReaderWriter::SetShortArrayParam(TUint aTag, TUint aIfd, CArrayFix<TUint16>& aParam)

	{

	TInt err = DoSetShortArrayParam(aTag, aIfd, aParam);

	if(err == KErrNone)

		{

		iExifDataModified = ETrue;

		}

	return err;

	}

// Set 8-bit data.

TInt CExifReaderWriter::DoSetParam8(TUint aTag, TUint aIfd,  HBufC8* aParam)

	{

	if(aParam == NULL)

		{

		return KErrArgument;

		}

	TInt internalIfdNumber = 0;

	CIfdGeneral* internalIfd = NULL;

	TInt err = KErrNone;

	TRAP(err, FindInternalIfdDataL(aTag, aIfd, internalIfdNumber, internalIfd));

	if(err!=KErrNone)

		{

		return err;

		}

	if(internalIfd->EntryExists(aTag))

		{

		// Set the existing entry.

		return internalIfd->SetParam8(aTag, aParam);	

		}

	else

		{

		// Get the required parameters.

		TUint format = 0;

		err = internalIfd->GetFormat(aTag, format);		

		if (err == KErrNone) 

			{

			TRAP(err, internalIfd->AddParam8L(aTag, format, aParam->Length(), aParam));

			if (internalIfdNumber == EGpsSub)

				{

				ProcessGpsIfdAddParamResult(internalIfd, err);

				}				

			}

		return err;

		}		

	}

// Set 16-bit data.  Only used for Unicode 'User Comment' tag.

TInt CExifReaderWriter::DoSetParam16(TUint aTag, TUint aIfd,  HBufC16* aParam)

	{

	if(aParam == NULL)

		{

		return KErrArgument;

		}	

	// The only tags which may contain 16-bit data are 0x9286 (UserComment),

	// 0x001B (GpsProcessingMethod) or 0x001C (GpsAreaInformation).

	if(aTag != KTag9286[ETagValue] && aTag != KTagGPS001B[ETagValue] && aTag != KTagGPS001C[ETagValue])

		{

		return KErrArgument;

		}

	TInt internalIfdNumber = 0;

	CIfdGeneral* internalIfd = NULL;

	TInt err = KErrNone;

	TRAP(err, FindInternalIfdDataL(aTag, aIfd, internalIfdNumber, internalIfd));

	if(err!=KErrNone)

		{

		return err;

		}

	if(internalIfd->EntryExists(aTag))

		{

		// Set the existing entry.

		return internalIfd->SetParam16(aTag, aParam);	

		}

	else

		{

		// Get the required parameters.

		TUint format = 0;

		err = internalIfd->GetFormat(aTag, format);

		if (err == KErrNone)

			{

			TRAP(err, internalIfd->AddParam16L(aTag, format, aParam->Length(), aParam));

			if (internalIfdNumber == EGpsSub)

				{

				err = ProcessGpsIfdAddParamResult(internalIfd, err);

				}

			}

		return err;

		}

	}

// Sets single integer data (including short, long and integer).

TInt CExifReaderWriter::DoSetIntegerParam(TUint aTag, TUint aIfd,  TInt aParam)

	{

	TInt internalIfdNumber = 0;

	CIfdGeneral* internalIfd = NULL;

	TInt err = KErrNone;

	TRAP(err, FindInternalIfdDataL(aTag, aIfd, internalIfdNumber, internalIfd));

	if(err!=KErrNone)

		{

		return err;

		}

	if(internalIfd->EntryExists(aTag))

		{

		// Set the existing entry.

		return internalIfd->SetIntegerParam(aTag, aParam);	

		}

	else

		{

		// Get the required parameters.

		TUint format = 0;

		err = internalIfd->GetFormat(aTag, format);

		if (err == KErrNone)

			{

			// Sets a single integer value.

			TRAP(err, internalIfd->AddIntegerParamL(aTag, format, 1, aParam));

			if (internalIfdNumber == EGpsSub)

				{

				err = ProcessGpsIfdAddParamResult(internalIfd, err);

				}

			}

		return err;

		}

	}

// Sets single rational data (i.e. one numerator and one denominator).

TInt CExifReaderWriter::DoSetRationalParam(TUint aTag, TUint aIfd, TInt aNumerator, TInt aDenominator)

	{

	TInt internalIfdNumber = 0;

	CIfdGeneral* internalIfd = NULL;

	TInt err = KErrNone;

	TRAP(err, FindInternalIfdDataL(aTag, aIfd, internalIfdNumber, internalIfd));

	if(err!=KErrNone)

		{

		return err;

		}

	if(internalIfd->EntryExists(aTag))

		{

		// Set the existing entry.

		return internalIfd->SetRationalParam(aTag, aNumerator, aDenominator);	

		}

	else

		{

		// Get the required parameters.

		TUint format = 0;

		err = internalIfd->GetFormat(aTag, format);

		if (err == KErrNone)

			{

			TRAP(err, internalIfd->AddRationalParamL(aTag, format, 1, aNumerator, aDenominator));

			if (internalIfdNumber == EGpsSub)

				{

				err = ProcessGpsIfdAddParamResult(internalIfd, err);

				}

			}

		return err;

		}

	}

TInt CExifReaderWriter::DoSetShortParam(TUint aTag, TUint aIfd, TUint16 aParam)

	{

	TInt internalIfdNumber = 0;

	CIfdGeneral* internalIfd = NULL;

	TInt err = KErrNone;

	TRAP(err, FindInternalIfdDataL(aTag, aIfd, internalIfdNumber, internalIfd));

	if(err!=KErrNone)

		{

		return err;

		}

	if(internalIfd->EntryExists(aTag))

		{

		// Set the existing entry.

		return internalIfd->SetShortParam(aTag, aParam);	

		}

	else

		{

		// Get the required parameters.

		TUint format = 0;

		err = internalIfd->GetFormat(aTag, format);

		if (err == KErrNone)

			{

			// Sets a single integer value.

			TRAP(err, internalIfd->AddShortParamL(aTag, format, 1, aParam));

			if (internalIfdNumber == EGpsSub)

				{

				err = ProcessGpsIfdAddParamResult(internalIfd, err);

				}

			}

		return err;

		}

	}

TInt CExifReaderWriter::DoSetIntegerArrayParam(TUint aTag, TUint aIfd, CArrayFix<TInt>& aParam)

	{	

	TInt internalIfdNumber = 0;

	CIfdGeneral* internalIfd = NULL;

	TInt err = KErrNone;

	TRAP(err, FindInternalIfdDataL(aTag, aIfd, internalIfdNumber, internalIfd));

	if(err!=KErrNone)

		{

		return err;

		}

	if(internalIfd->EntryExists(aTag))

		{

		// Set the existing entry.

		TRAP(err, internalIfd->SetIntegerArrayParamL(aTag, aParam));	

		return err;

		}

	else

		{

		// Get the required parameters.

		TUint format = 0;

		err = internalIfd->GetFormat(aTag, format);

		if (err == KErrNone)

			{

			// Sets a single integer value.

			TRAP(err, internalIfd->AddIntegerArrayParamL(aTag, format, aParam));

			if (internalIfdNumber == EGpsSub)

				{

				err = ProcessGpsIfdAddParamResult(internalIfd, err);

				}

			}

		return err;

		}

	}

TInt CExifReaderWriter::DoSetRationalArrayParam(TUint aTag, TUint aIfd, CArrayFix<TRational>& aParam)

	{

	TInt internalIfdNumber = 0;

	CIfdGeneral* internalIfd = NULL;

	TInt err = KErrNone;

	TRAP(err, FindInternalIfdDataL(aTag, aIfd, internalIfdNumber, internalIfd));

	if(err!=KErrNone)

		{

		return err;

		}

	if(internalIfd->EntryExists(aTag))

		{

		// Set the existing entry.

		TRAP(err, internalIfd->SetRationalArrayParamL(aTag, aParam));	

		return err;

		}

	else

		{

		// Get the required parameters.

		TUint format = 0;

		err = internalIfd->GetFormat(aTag, format);

		if (err == KErrNone)

			{

			// Sets a single integer value.

			TRAP(err, internalIfd->AddRationalArrayParamL(aTag, format, aParam));

			if (internalIfdNumber == EGpsSub)

				{

				err = ProcessGpsIfdAddParamResult(internalIfd, err);

				}

			}

		return err;

		}

	}

TInt CExifReaderWriter::DoSetShortArrayParam(TUint aTag, TUint aIfd, CArrayFix<TUint16>& aParam)