// 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 "ifdgeneral.h"

#include "ifdgeneralentry.h"

#include "ExifTagDescriptions.h"

#include "exifreaderwriter.h"

#include "ExifTagHelper.h"

#include <bafl/sysutil.h>

// Number of consecutive invalid IFD entries that may appear before the whole IFD is considered corrupt

// This value is set in the ExifLibStatic.mmp file, the default is 7.

const TUint KMaxNumberOfConsecInvalidEntries = SYMBIAN_ICL_EXIF_CONSEC_INVALID_TAGS;

CIfdGeneral::CIfdGeneral(const TInt aIfdNumber, const TUint aOffsetToIfd, const TUint8* aBase, const TBool aIntel, const TUint aExifDataLength)

	: iIfdNumber(aIfdNumber)

	, iIntel(aIntel)

	, iOffsetToIfd(aOffsetToIfd)

	, iBase(aBase)

	, iExifDataLength(aExifDataLength)

	{	

	}

CIfdGeneral::~CIfdGeneral()

	{

	iIfdEntries.ResetAndDestroy();

	}

void CIfdGeneral::ConstructL()

	{

	if(iBase)

		{

		// read the entries from the data block

		AddAllIfdEntriesL();

		}

	else

		{

		// create default entries

		SetupDirectoryEntriesL();

		}

	}

// Alters a directory in a given IFD - used when the directory is known to exist 

// (i.e. for mandatory entries) which are set/created upon initialisation.

TInt CIfdGeneral::SetParam8(const TUint aTag, HBufC8* aParam)

	{	

	ASSERT(aParam!=NULL);

	// find the entry with the required tag.

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

		{

		if(aTag == iIfdEntries[i]->Tag())

			{

			// Found the tag.

			// May be undefined type or ascii type.

			if(iIfdEntries[i]->IsStringFormat())

				{

				//pass in ifd number as the same ascii tag may be in more than one ifd

				return iIfdEntries[i]->UpdateString(aParam);				

				}

			else if(iIfdEntries[i]->IsUndefinedFormat())

				{

				return iIfdEntries[i]->UpdateData(aParam->Length(), aParam->Des().Ptr());	

				}

			else if (iIfdEntries[i]->Format()==EByte)

				{

				//we need to support byte entries too as they are Param8

				return iIfdEntries[i]->UpdateData(aParam->Length(), aParam->Des().Ptr());

				}			

			}

		}

	return KErrNotSupported;

	}

TInt CIfdGeneral::SetParam16(const TUint aTag, HBufC16* aParam)

	{	

	ASSERT(aParam!=NULL);

	// find the entry with the required tag.

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

		{

		if(aTag == iIfdEntries[i]->Tag())

			{

			// Found the tag.			

			HBufC8* extendedData=NULL;

			TRAPD(err, extendedData=TExifTagHelper::CreateUnicodePrefixedBufferL(*aParam));

			if(err!=KErrNone)

				{

				return KErrNoMemory;

				} 

			TInt componentCount=extendedData->Length();

			TInt updateErr = iIfdEntries[i]->UpdateData(componentCount, extendedData->Des().Ptr()); 

			delete extendedData;		

			return updateErr;

			}

		}

	return KErrNotSupported;

	}

TInt CIfdGeneral::SetIntegerParam(const TUint aTag, const TInt aParam)

	{

	// find the entry with the required tag.

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

		{

		if(aTag == iIfdEntries[i]->Tag())

			{

			// Found the tag.

			return iIfdEntries[i]->UpdateInteger(aParam);

			}

		}

	return KErrNotSupported;

	}

TInt CIfdGeneral::SetShortParam(const TUint aTag, const TUint16 aParam)

	{

	// find the entry with the required tag.

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

		{

		if(aTag == iIfdEntries[i]->Tag())

			{

			// Found the tag.

			return iIfdEntries[i]->UpdateShort(aParam);

			}

		}

	return KErrNotSupported;

	}

TInt CIfdGeneral::SetRationalParam(const TUint aTag, const TInt aNumerator, const TInt aDenominator)

	{

	// find the entry with the required tag.

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

		{

		if(aTag == iIfdEntries[i]->Tag())

			{

			// Found the tag.

			return iIfdEntries[i]->UpdateRational(aNumerator, aDenominator);

			}

		}

	return KErrNotSupported;

	}

/* 

Add a directory in a given IFD - used for the optional directories, since these are not

set/created upon initialisation.  Must check for existence of the tag along with validity

of adding the tag to this particular IFD.

*/

void CIfdGeneral::AddParam8L(const TUint aTag, const TUint aFormat, const TUint aComponentCount, HBufC8* aParam)

	{

	ASSERT(aParam!=NULL);

	TInt err = KErrNotSupported;

	// Check that aTag belongs in this IFD.

	TInt index = GetTagIndex(aTag);

	if(index != KErrNotFound)

		{

		//The length is checked, but really it should be done in the IfdEntry

		TUint paramLength=aParam->Length();

		const TUint* tag = GetTagInformation(index);

		TUint requiredComponentCount=tag[EComponentCountValue];

		TBool legal=EFalse;

		if((requiredComponentCount==0) || (aFormat!=EAscii))

			{

			//Either this tag can be of any length (so no further length checks needed)

			//or it is not ASCII, which means it simply has to be at least as long

			//as the required length

			legal=(paramLength >= requiredComponentCount * KDataFormatSize[aFormat]);	

			}

		else

			{

			//We have a fixed length ASCII string.  For such strings we must

			//consider NULL termination.  Considering that we add the NULL if the 

			//user forgets to add it for other tags, we should do it here as well 

			//to be consistent.

			if (paramLength==requiredComponentCount)

				{

				//The string is already of the max length so it is only legal if it is NULL

				//terminated

				legal=((*aParam)[paramLength-1] == KNullCharacter);	

				}

			else if (paramLength==requiredComponentCount-1)

				{

				//The string is one less than the required length.  If it is NULL terminated already,

				//then the string is too short (illegal).  If it is not NULL terminated, we let it

				//pass anyway and CEncoderIfdEntry software will add the NULL.  

				legal=((*aParam)[paramLength-1] != KNullCharacter);						

				}

			else

				{

				//Strings that pass the first two checks are only legal if exactly the

				//required length.

				legal=(paramLength == requiredComponentCount);	

				}

			}

		if (legal)				

			{

			// Entry is legal, so add entry.

			const TUint8* valueOffset = aParam->Des().Ptr();			

			CIfdGeneralEntry* entry = CIfdGeneralEntry::NewLC(aTag, aFormat, aComponentCount, valueOffset, this);

			iIfdEntries.AppendL(entry);

			CleanupStack::Pop(entry);

			err = KErrNone;

			}

		else

			{

			err = KErrNotSupported;

			}

		}

	User::LeaveIfError(err);

	}

void CIfdGeneral::AddParam16L(const TUint aTag, const TUint aFormat, const TUint /*aComponentCount*/, HBufC16* aParam)

	{

	ASSERT(aParam!=NULL);

	TInt err = KErrNotSupported;

	// Check that aTag belongs in this IFD.

	TInt index = GetTagIndex(aTag);

	if(index != KErrNotFound)

		{	

		TUint paramLength=aParam->Length();

		const TUint* tag = GetTagInformation(index);

		if( (paramLength >= tag[EComponentCountValue] * KDataFormatSize[aFormat]))

			{				

			// Entry is legal, so add entry.

			// Must add UNICODE\0 to start of data.				

			TInt size = aParam->Length()*2 + KUnicode().Length();

			TUint8* data = static_cast<TUint8*>(User::AllocL(size));								

			CleanupStack::PushL(data);

			Mem::Copy(data, KUnicode().Ptr(), KUnicode().Length());

			Mem::Copy(data+KUnicode().Length(), aParam->Des().Ptr(), aParam->Length()*2);												

			CIfdGeneralEntry* entry = CIfdGeneralEntry::NewLC(aTag, aFormat, size, data, this);

			iIfdEntries.AppendL(entry);

			CleanupStack::Pop(entry);

			CleanupStack::PopAndDestroy(data);

			err = KErrNone;		

			}

		} 

	User::LeaveIfError(err);

	}

void CIfdGeneral::AddIntegerParamL(const TUint aTag, const TUint aFormat, const TUint aComponentCount, TInt aParam)

	{

	TInt err = KErrNotSupported;

	// Check that aTag belongs in this IFD.

	if(FindTag(aTag))

		{

		// Entry is legal, so add entry.

		CIfdGeneralEntry* entry = CIfdGeneralEntry::NewLC(aTag, aFormat, aComponentCount, reinterpret_cast<const TUint8*>(&aParam), this);

		iIfdEntries.AppendL(entry);

		CleanupStack::Pop(entry);

		err = KErrNone;		

		} 

	User::LeaveIfError(err);

	}

void CIfdGeneral::AddShortParamL(const TUint aTag, const TUint aFormat, const TUint aComponentCount, TUint16 aParam)

	{

	TInt err = KErrNotSupported;

	// Check that aTag belongs in this IFD.

	if(FindTag(aTag))

		{

		// Entry is legal, so add entry.

		CIfdGeneralEntry* entry = CIfdGeneralEntry::NewLC(aTag, aFormat, aComponentCount, reinterpret_cast<const TUint8*>(&aParam),this);

		iIfdEntries.AppendL(entry);

		CleanupStack::Pop(entry);

		err = KErrNone;		

		} 

	User::LeaveIfError(err);

	}

void CIfdGeneral::AddRationalParamL(const TUint aTag, const TUint aFormat, const TUint aComponentCount, const TInt aNumerator, const TInt aDenominator)

	{

	TInt err = KErrNotSupported;

	// Check that aTag belongs in this IFD.

	if(FindTag(aTag))

		{

		TUint8* valueOffset = static_cast<TUint8*>(User::AllocL(KSizeOfRational));

		CleanupStack::PushL(valueOffset);

		// Entry is legal, so add entry.

		CIfdGeneralEntry* entry = CIfdGeneralEntry::NewLC(aTag, aFormat, aComponentCount, valueOffset, this);

		User::LeaveIfError(entry->UpdateRational(aNumerator, aDenominator));

		iIfdEntries.AppendL(entry);

		CleanupStack::Pop(entry);

		CleanupStack::PopAndDestroy(valueOffset);

		err = KErrNone;			

		} 

	if(err != KErrNone)

		{

		User::LeaveIfError(err);			

		}

	return;

	}

void CIfdGeneral::SetIntegerArrayParamL(const TUint aTag, const CArrayFix<TInt>& aParam)

	{

	TInt err = KErrNotSupported;

	// find the entry with the required tag.

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

		{

		if(aTag == iIfdEntries[i]->Tag())

			{

			// Found the tag.

			HBufC8* ptr = HBufC8::NewL(aParam.Count()*K32BitIntegerByteCount/K8BitIntegerByteCount);

			CleanupStack::PushL(ptr);

			const TUint8* bytePtr = ptr->Des().Ptr();

			TInt* dataPtr = const_cast<TInt*>(reinterpret_cast<const TInt*>(bytePtr));								

			for(TInt j = 0; j < aParam.Count(); j++)

				{

				TInt value = aParam.At(j);

				dataPtr[j] = value;

				}

			User::LeaveIfError(iIfdEntries[i]->UpdateData(aParam.Count(), bytePtr));

			CleanupStack::PopAndDestroy(ptr);

			err = KErrNone;

			}

		}

	User::LeaveIfError(err);

	}

void CIfdGeneral::AddIntegerArrayParamL(const TUint aTag, const TUint aFormat, const CArrayFix<TInt>& aParam)

	{

	TInt err = KErrNotSupported;

	// Check that aTag belongs in this IFD.

	if(FindTag(aTag))

		{

		// Entry is legal, so add entry.

		HBufC8* ptr = HBufC8::NewL(aParam.Count()*K32BitIntegerByteCount/K8BitIntegerByteCount);

		CleanupStack::PushL(ptr);

		const TUint8* bytePtr = ptr->Des().Ptr();

		TInt* dataPtr = const_cast<TInt*>(reinterpret_cast<const TInt*>(bytePtr));								

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

			{

			TInt value = aParam.At(i);

			dataPtr[i] = value;

			}

		CIfdGeneralEntry* entry = CIfdGeneralEntry::NewLC(aTag, aFormat, aParam.Count(), bytePtr, this);								

		iIfdEntries.AppendL(entry);

		CleanupStack::Pop(entry);

		CleanupStack::PopAndDestroy(ptr);

		err = KErrNone;					

		}

	User::LeaveIfError(err);

	}

void CIfdGeneral::AddRationalArrayParamL(const TUint aTag, const TUint aFormat, const CArrayFix<TRational>& aParam)

	{

	TInt err = KErrNotSupported;

	// Check that aTag belongs in this IFD.

	if(FindTag(aTag))

		{

		// Entry is legal, so add entry.

		HBufC8* ptr = HBufC8::NewL((aParam.Count()*2) * K32BitIntegerByteCount);

		CleanupStack::PushL(ptr);

		const TUint8* bytePtr = ptr->Des().Ptr();

		TInt* dataPtr = const_cast<TInt*>(reinterpret_cast<const TInt*>(bytePtr));

		TInt ptrInc = 0;

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

			{

			TInt numer = (aParam.At(i)).iNumerator;

			TInt denom = (aParam.At(i)).iDenominator;

			dataPtr[ptrInc++] = numer;

			dataPtr[ptrInc++] = denom;

			}

		CIfdGeneralEntry* entry = CIfdGeneralEntry::NewLC(aTag, aFormat, aParam.Count(), bytePtr, this);								

		iIfdEntries.AppendL(entry);

		CleanupStack::Pop(entry);

		CleanupStack::PopAndDestroy(ptr);

		err = KErrNone;						

		} 

	User::LeaveIfError(err);

	}

void CIfdGeneral::SetRationalArrayParamL(const TUint aTag, const CArrayFix<TRational>& aParam)

	{

	TInt err = KErrNotSupported;

	// find the entry with the required tag.

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

		{

		if(aTag == iIfdEntries[i]->Tag())

			{

			// Found the tag.

			HBufC8* ptr = HBufC8::NewL((aParam.Count()*2) * K32BitIntegerByteCount);

			CleanupStack::PushL(ptr);

			const TUint8* bytePtr = ptr->Des().Ptr();

			TInt* dataPtr = const_cast<TInt*>(reinterpret_cast<const TInt*>(bytePtr));

			TInt ptrInc = 0;

			for(TInt j = 0; j < aParam.Count(); j++)

				{

				TInt numer = (aParam.At(j)).iNumerator;

				TInt denom = (aParam.At(j)).iDenominator;

				dataPtr[ptrInc++] = numer;

				dataPtr[ptrInc++] = denom;

				}

			User::LeaveIfError(iIfdEntries[i]->UpdateData(aParam.Count(), bytePtr));

			CleanupStack::PopAndDestroy(ptr);

			err = KErrNone;

			}

		}

	User::LeaveIfError(err);

	}

void CIfdGeneral::AddShortArrayParamL(const TUint aTag, const TUint aFormat, const CArrayFix<TUint16>& aParam)

	{

	TInt err = KErrNotSupported;

	// Check that aTag belongs in this IFD.

	if(FindTag(aTag))

		{

		// Entry is legal, so add entry.

		HBufC8* ptr = HBufC8::NewL(aParam.Count()*K16BitIntegerByteCount/K8BitIntegerByteCount);

		CleanupStack::PushL(ptr);

		const TUint8* bytePtr = ptr->Des().Ptr();

		TInt16* dataPtr = const_cast<TInt16*>(reinterpret_cast<const TInt16*>(bytePtr));								

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

			{

			TInt value = aParam.At(i);

			dataPtr[i] = value;

			}

		CIfdGeneralEntry* entry = CIfdGeneralEntry::NewLC(aTag, aFormat, aParam.Count(), bytePtr, this);								

		iIfdEntries.AppendL(entry);

		CleanupStack::Pop(entry);

		CleanupStack::PopAndDestroy(ptr);

		err = KErrNone;							

		} 

	User::LeaveIfError(err);

	}

void CIfdGeneral::SetShortArrayParamL(const TUint aTag, const CArrayFix<TUint16>& aParam)

	{

	TInt err = KErrNotSupported;

	// Find the entry with the required tag.

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

		{

		if(aTag == iIfdEntries[i]->Tag())

			{

			HBufC8* ptr = HBufC8::NewL(aParam.Count()*K16BitIntegerByteCount/K8BitIntegerByteCount);

			CleanupStack::PushL(ptr);

			const TUint8* bytePtr = ptr->Des().Ptr();

			TInt16* dataPtr = const_cast<TInt16*>(reinterpret_cast<const TInt16*>(bytePtr));								

			for(TInt j = 0; j < aParam.Count(); j++)

				{

				TInt value = aParam.At(j);

				dataPtr[j] = value;

				}

			User::LeaveIfError(iIfdEntries[i]->UpdateData(aParam.Count(), bytePtr));

			CleanupStack::PopAndDestroy(ptr);

			err = KErrNone;

			}		

		}

	User::LeaveIfError(err);

	}	

TInt CIfdGeneral::GetIntegerParam(const TUint aTag, TInt& aParam) const

	{

	TInt entry = LocateEntry(aTag);

	if(entry == KErrNotFound)

		{

		return KErrNotFound;

		}

	// Check that we are dealing with an Integer format.

	switch(iIfdEntries[entry]->Format())

		{		

		case (EUnsignedLong):

		case (ESignedLong):

			break;

		default:

			return KErrArgument;

		}

	// Check the size.

	TUint totalSize = iIfdEntries[entry]->ComponentCount() * KDataFormatSize[iIfdEntries[entry]->Format()];

	if(totalSize > KSizeOfValueOffsetField)

		{

		// Data is offset, so we are dealing with more than one integer, so this function cannot deal with it.

		return KErrArgument;

		}

	aParam = iIfdEntries[entry]->ValueOffset();

	return KErrNone;

	}

TInt CIfdGeneral::GetShortParam(const TUint aTag, TUint16& aParam) const

	{

	TInt entry = LocateEntry(aTag);

	if(entry == KErrNotFound)

		{

		return KErrNotFound;

		}

	// Check that we are dealing with an short format.

	if(iIfdEntries[entry]->Format() != EUnsignedShort)

		{

		return KErrArgument;