/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

*

*/

#include "CExifParser.h"

#include <e32svr.h>		// for debug

enum TExifType

	{

	EByte = 1,

	EAscii,

	EShort,

	ELong,

	ERational,

	EUndefined = 7,

	ESLong = 9,

	ESRational

	};

const char* KTypeName[] = 

	{

	"Byte",

	"Ascii",

	"Short",

	"Long",

	"Rational",

	"Undefined",

	"SLong",

	"SRational"

	};

const char KTypeLength[] = 

	{

	0,

	1,

	1,

	2,

	4,

	8,

	0,

	1,

	0,

	4,

	8

	};

CExifParser* CExifParser::NewL()

	{

	CExifParser* self = NewLC();

	CleanupStack::Pop( self );

	return self;

	}

CExifParser* CExifParser::NewLC()

	{

	CExifParser* self = new( ELeave )CExifParser();

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

CExifParser::~CExifParser()

	{

	iEntry.ResetAndDestroy();

	iParseStack.Reset();

    delete[] iSaveBuf;

	delete[] iSaveDataBuf;

	iThumbData = NULL;    

	}

CExifParser::CExifParser()

	{

	}

void CExifParser::ConstructL()

	{

	iIntelByteOrder = true;

	}

void CExifParser::ParseL( const TPtrC8& aData )

	{

	if( aData.Length() < (8+2+12) ) return; // header + 1 tag length

	iData.Set( aData );

	iThumbData = 0;

	iThumbLen = 0;

	if( iData[ 0 ] == 0x49 && iData[ 1 ] == 0x49 )

		{

		// intel byte order

		iIntelByteOrder = ETrue;

		//RDebug::Print( _L("Intel byte order selected") );

		}

	else

		{

		//RDebug::Print( _L("Motorola byte order selected") );

		}

	iPosition = 2;

	TUint16 v = Get16();

	if( v != 0x002a )

		{

		// must be 2a 00 in EXIF

		User::Leave( KErrNotSupported );

		}

	iPosition = 4;

	iParseStack.Append( TParseStack( Get32(), EIfd0 ) );

	while( iParseStack.Count() )

		{

		iPosition = iParseStack[ 0 ].iPosition;

		TUint8 currentIfd = iParseStack[ 0 ].iIfd;

		iParseStack.Remove( 0 );

		TInt i;

		TInt c = Get16();

		for( i=0; i<c; i++ )

			{

			ParseIfdL( currentIfd );

			}

		TUint32 link = NULL;	

		if (iPosition + 3 < iData.Length())

			{

			link = Get32();

			}

		if( link )

			{

			//RDebug::Print( _L(" --Link (IFD1?) %d,%d"), link, iPosition );

			iParseStack.Append( TParseStack( link, EIfd1 ) );

			}

		else

			{

			//RDebug::Print( _L(" -- NULL Link after IFD") );

			}

		}

	iParseStack.Reset();

	//RDebug::Print( _L(" -- Parse Complete") );

	iIntelByteOrder = true;

	}

TBool CExifParser::TagExist( TInt aIfd, TUint16 aTag )

	{

	if( FindTag( aIfd, aTag ) >= 0 ) return ETrue;

	return EFalse;

	}

void CExifParser::DeleteTag( TInt aIfd, TUint16 aTag )

	{

	TInt i = FindTag( aIfd, aTag );

	if( i >= 0 )

		{

		delete iEntry[ i ];

		iEntry.Remove( i );

		}

	}

TUint32 CExifParser::TagValue( TInt aIfd, TUint16 aTag )

	{

	TInt value = 0;

	TInt n = FindTag( aIfd, aTag );

	if( n<0 ) return 0;

	TExifEntry* e = iEntry[ n ];

	TUint8* valData = e->iData;

	switch( e->iType )

		{

		case EByte:

			{

			value = Get8( valData );

			break;

			}

		case EAscii:

			{

			/*

			TBuf< 256 >str;

			str.Copy( _L("value:") );

			const TUint8* p = valData;

			while( *p != 0 )

				{

				str.Append( *p );

				p++;

				}

			*/

			// not supported

			value = 0;

			break;

			}

		case EShort:

			{

			value = Get16( valData );

			////RDebug::Print( _L("value:%d"), value );

			break;

			}

		case ELong:

			{

			value = Get32( valData );

			////RDebug::Print( _L("value:%d"), value );

			break;

			}

		case ERational:

			{

			TInt nominator = Get32( valData );

			TInt denominator = Get32( valData+4 );

			////RDebug::Print( _L("value:%d/%d"), nominator, denominator );

			if( denominator != 0 )

				{

				value = nominator / denominator;

				}

			else

				{

				value = 0;

				}

			break;

			}

		case EUndefined:

			{

			break;

			}

		case ESLong:

			{

			TUint32 val = Get32( valData );

			value = *(TInt*)(&val);

			////RDebug::Print( _L("value:%d"), svalue );

			break;

			}

		case ESRational:

			{

			TUint32 uval = Get32( valData );

			TInt nominator = *(TInt*)(&uval);

			uval = Get32( valData+4 );

			TInt denominator = *(TInt*)(&uval);

			if( denominator != 0 )

				{

				value = nominator / denominator;

				}

			else

				{

				value = 0;

				}

			////RDebug::Print( _L("value:%d/%d"), nominator, denominator );

			break;

			}

		default:

		 	{

		 	break;

		 	}

		}	

	return value;

	}

TPtrC8 CExifParser::ThumbData()

	{

	return TPtrC8( iThumbData, iThumbLen );

	}

TPtr8 CExifParser::SaveL( const TPtrC8& aThumbData )

	{

	iIntelByteOrder = true;

	//

	// Exif data cannot take more than 64KBytes

	//

	if (iSaveBuf)

	{

	    delete[] iSaveBuf;

	    iSaveBuf = NULL;

	}

	iSaveBuf = new( ELeave )TUint8[ 0x10000 ];

	iSaveBufPos = 0;

	if (iSaveDataBuf)

	{

    	delete[] iSaveDataBuf;

    	iSaveDataBuf = NULL;	    

	}

	iSaveDataBuf = new( ELeave )TUint8[ 0x10000 ];

	iSaveDataBufPos = 0;

	//

	// header

	//

	Put8( 0x49 );

	Put8( 0x49 );

	Put8( 0x2a );

	Put8( 0x00 );

	Put32( 8 );

	//

	// Remove IFD0 SubIfd tag, will be regenerated

	//

	DeleteTag( EIfd0, 0x8769 );

	//

	// Save IFD0

	//

	Put16( IfdCount( EIfd0 ) + 1 );

	TInt c = iEntry.Count();

	TInt i;

	for( i=0; i<c; i++ )

		{

		TExifEntry* e = iEntry[ i ];

		if( e->iIfd == EIfd0 )

			{

			StoreEntry( i );

			}

		}

	//

	// Save link to SubIfd ( this is a tag )

	//

	TExifEntry* tagsub = new( ELeave )TExifEntry;

	CleanupStack::PushL(tagsub);

	tagsub->iTag = 0x8769;

	tagsub->iIfd = EIfd0;

	tagsub->iType = ELong;

	tagsub->iCount = 1;

	tagsub->iData = new( ELeave )TUint8[ 4 ];

	TUint8* dat = tagsub->iData;

	TUint32 offset = iSaveBufPos + 12 + 4; // just after IFD1 link

	if( iIntelByteOrder )

		{

		dat[ 0 ] = offset & 255; offset >>= 8;

		dat[ 1 ] = offset & 255; offset >>= 8;

		dat[ 2 ] = offset & 255; offset >>= 8;

		dat[ 3 ] = offset & 255;

		}

	else

		{

		dat[ 3 ] = offset & 255; offset >>= 8;

		dat[ 2 ] = offset & 255; offset >>= 8;

		dat[ 1 ] = offset & 255; offset >>= 8;

		dat[ 0 ] = offset & 255;

		}

	iEntry.Append( tagsub );

	CleanupStack::Pop();

	StoreEntry( iEntry.Count()-1 );

	//

	// Save link to IFD1 ( not a tag, just pointer )

	//

	TInt IFD1LinkPos = iSaveBufPos;

	Put32( 0 );

	//

	// Remove Interoperability tag, will be regenerated

	//

	DeleteTag( ESubIfd, 0xa005 );

	c = iEntry.Count();

	//

	// Save SubIfd

	//

	Put16( IfdCount( ESubIfd ) );

	//RDebug::Print( _L(" SUBIFD count %x"), IfdCount( ESubIfd ) );

	for( i=0; i<c; i++ )

		{

		TExifEntry* e = iEntry[ i ];

		if( e->iIfd == ESubIfd )

			{

			//RDebug::Print( _L("  SUBIFD %x"), e->iTag );

			StoreEntry( i );

			}

		}

/*	

	TExifEntry* tagint = new( ELeave )TExifEntry;

	tagint->iTag = 0xa005;

	tagint->iIfd = ESubIfd;

	tagint->iType = ELong;

	tagint->iCount = 1;

	tagint->iData = new( ELeave )TUint8[ 4 ];

	TUint8* dat2 = tagint->iData;

	TUint32 offset2 = iSaveBufPos + 12 + 4; // just after IFD link

	if( iIntelByteOrder )

		{

		dat2[ 0 ] = offset2 & 255; offset2 >>= 8;

		dat2[ 1 ] = offset2 & 255; offset2 >>= 8;

		dat2[ 2 ] = offset2 & 255; offset2 >>= 8;

		dat2[ 3 ] = offset2 & 255;

		}

	else

		{

		dat2[ 3 ] = offset2 & 255; offset2 >>= 8;

		dat2[ 2 ] = offset2 & 255; offset2 >>= 8;

		dat2[ 1 ] = offset2 & 255; offset2 >>= 8;

		dat2[ 0 ] = offset2 & 255;

		}

	iEntry.Append( tagint );

	StoreEntry( iEntry.Count()-1 );

*/

	Put32( 0 ); // IFD link

/*	

	//

	// Save Interoperability

	//

	Put16( IfdCount( EInteroperability ) );

	c = iEntry.Count();

	for( i=0; i<c; i++ )

		{

		TExifEntry* e = iEntry[ i ];

		if( e->iIfd == EInteroperability )

			{

			StoreEntry( i );

			}

		}

	Put32( 0 ); // IFD link

*/

	//

	// Save IFD1 ( thumbnail ) if new thumbnail given

	//

	if( aThumbData.Ptr() )

		{

		TUint32 temp = iSaveBufPos;

		iSaveBufPos = IFD1LinkPos;

		Put32( temp );

		iSaveBufPos = temp;

		}

	//

	// Remove old thumbnail tags

	//

	c = iEntry.Count();

	i = 0;

	while( i < iEntry.Count() )

		{

		TExifEntry* e = iEntry[ i ];

		if( e->iIfd == EIfd1 )

			{

			delete e;

			iEntry.Remove( i );

			}

		else

			{

			i++;

			}

		}

	//

	// Add newe thumbnail tags ( if thumbnail given )

	//

	TInt thumbData = 0;

	if( aThumbData.Ptr() )

		{

		AddTagL( EIfd1, 0x0103, (TUint16)6 );			// thumbnail = jpeg

		// thumbnail X-resolution 180/1

		AddTagL( EIfd1, 0x011a, (TUint32)180, (TUint32)1 );			 

		// thumbnail Y-resolution 180/1

		AddTagL( EIfd1, 0x011b, (TUint32)180, (TUint32)1 );

		// thumbnail resolution unit = inch

		AddTagL( EIfd1, 0x0128, (TUint16)2 );

		AddTagL( EIfd1, 0x0201, (TUint32)0 );			// thumb offset

		AddTagL( EIfd1, 0x0202, (TUint32)aThumbData.Length() );	// thumb length

		Put16( IfdCount( EIfd1 ) );

		c = iEntry.Count();

		for( i=0; i<c; i++ )

			{

			TExifEntry* e = iEntry[ i ];

			if( e->iIfd == EIfd1 )

				{

				StoreEntry( i );

				}

			}

		thumbData = iSaveBufPos - 12 - 4; // tag 0x0201 data position

		Put32( 0 ); // IFD link

		}

	//