/*

* Copyright (c) 2007-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:  Exif-utilities for harvester

*

*/

#include "harvesterexifutil.h"

#include "mdsutils.h"

#include "mdeobjectdef.h"

#include "mdeconstants.h"

#include "mdeproperty.h"

#include "tz.h"

#include <ExifModify.h>

using namespace MdeConstants;

const TUint16 KIdColorSpace = 0xA001;

const TUint16 KIdResolutionUnit = 0x0128;

const TUint16 KIdYbCrPositioning = 0x0213;

const TUint16 KIdImageDescription = 0x010E;

const TUint16 KIdCopyright = 0x8298;

const TUint16 KIdUserComment = 0x9286;

const TUint16 KIdDateTime = 0x0132;

const TUint16 KIdDateTimeOriginal = 0x9003;

const TUint16 KIdDateTimeDigitized = 0x9004;

const TUint16 KIdDateTimeModified = 0x132;

const TUint16 KIdFNumber = 0x829D;

const TUint16 KIdMake = 0x010F;

const TUint16 KIdModel = 0x0110;

const TUint16 KIdFocalLength = 0x920A;

const TUint16 KIdFocalLengthIn35mm = 0xA405;

const TUint16 KIdSamplesPerPixel = 0x0115;

const TUint16 KIdISOSpeedRatings = 0x8827;

const TUint16 KIdComponentsConfig = 0x9101;

const TUint16 KIdArtist = 0x013B;

const TUint16 KIdPixelXDimension = 0xA002;

const TUint16 KIdPixelYDimension = 0xA003;

const TUint16 KIdRelatedSoundFile = 0xA004;

const TUint16 KIdFocalPlaneResolutionUnit = 0xA210;

const TUint16 KIdFocalPlaneXResolution = 0xA20E;

const TUint16 KIdFocalPlaneYResolution = 0xA20F;

const TUint16 KIdExposureTime = 0x829A;

const TUint16 KIdApertureValue = 0x9202;

const TUint16 KIdExposureBias = 0x9204;

const TUint16 KIdMeteringMode = 0x9207;

const TUint16 KIdShutterSpeed = 0x9201;

const TUint16 KIdXResolution = 0x011A;

const TUint16 KIdYResolution = 0x011B;

const TUint16 KIdWhiteBalance = 0xA403;

const TUint16 KIdExposureProgram = 0x8822;

const TUint16 KIdFlash = 0x9209;

const TUint16 KIdOrientation = 0x112;

const TUint16 KIdGpsLatitudeRef = 0x1;

const TUint16 KIdGpsLatitude = 0x2;

const TUint16 KIdGpsLongitudeRef = 0x3;

const TUint16 KIdGpsLongitude = 0x4;

const TUint16 KIdGpsAltitudeRef = 0x5;

const TUint16 KIdGpsAltitude = 0x6;

const TUint16 KIdGpsMeasureMode = 0xA;

const TUint16 KIdGpsDop = 0xB;

const TUint16 KIdGpsMapDatum = 0x12;

_LIT( KExifDateTimeFormat, "%F%Y:%M:%D %H:%T:%S\0" );

const TInt KDateBufferSize = 20;

const TInt KCoordinateBufferSize = 24;

// This is needed for exif description field

_LIT8( KAsciiCodeDesignation,     "\x41\x53\x43\x49\x49\x00\x00\x00");

_LIT8( KJisCodeDesignation,     "\x4A\x49\x53\x00\x00\x00\x00\x00");

_LIT8( KUnicodeCodeDesignation, "\x55\x4E\x49\x43\x4F\x44\x45\x00");

_LIT8( KUnknownCodeDesignation, "\x00\x00\x00\x00\x00\x00\x00\x00");

_LIT8( KNorth, "N\0" );

_LIT8( KSouth, "S\0" );

_LIT8( KEast, "E\0" );

_LIT8( KWest, "W\0" );

_LIT8( KMeasureMode2, "2\0" );

_LIT8( KMeasureMode3, "3\0" );

_LIT8( KMapDatum, "WGS-84\0");

CHarvesterExifUtil::CHarvesterExifUtil() :

    iSession( NULL ), iDefaultNamespace( NULL )

{

}

EXPORT_C CHarvesterExifUtil::~CHarvesterExifUtil()

{

}

EXPORT_C CHarvesterExifUtil* CHarvesterExifUtil::NewLC()

{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

EXPORT_C CHarvesterExifUtil* CHarvesterExifUtil::NewL()

{

	CHarvesterExifUtil* self=CHarvesterExifUtil::NewLC();

	CleanupStack::Pop( self ); // self;

	return self;

}

void CHarvesterExifUtil::ConstructL()

{

}

EXPORT_C void CHarvesterExifUtil::SetSession( CMdESession* aSession )

	{

	iSession = aSession;

	if ( !iDefaultNamespace && aSession )

		{

    	TRAP_IGNORE( iDefaultNamespace = &iSession->GetDefaultNamespaceDefL() );

		}

	}

EXPORT_C TBool CHarvesterExifUtil::IsValidExifData(TPtr8 aPtr)

	{

	WRITELOG( "CHarvesterExifUtil::IsValidExifData start" );

	CExifRead* reader = NULL;

	TRAPD(err, reader = CExifRead::NewL(aPtr, CExifRead::ENoJpeg | CExifRead::ENoTagChecking));

	if (err != KErrNone || !reader )

		{

		WRITELOG1( "CHarvesterExifUtil::IsValidExifData - error code: %d", err );

		return EFalse;

		}

	delete reader;

	WRITELOG( "CHarvesterExifUtil::IsValidExifData end" );	

	return ETrue;

	}

void CHarvesterExifUtil::StripNulls( HBufC& aString )

	{

	_LIT( KNull, "\0" );

	_LIT( KSpace, " " );

	TInt pos( 0 );

    while( (pos = aString.Find( KNull ) ) != KErrNotFound )

    	{

    	aString.Des().Replace( pos, 1, KSpace );

    	}

    aString.Des().TrimAll();

	}

HBufC16* CHarvesterExifUtil::ReadExifTagL( const CExifRead& aReader, TExifIfdType aIFD, TUint16 aTagID )

	{

	HBufC16* destination = NULL;

    if( aReader.TagExists( aTagID, aIFD ) )

    	{

        const CExifTag* tag = aReader.GetTagL( aIFD, aTagID );

    	destination = CnvUtfConverter::ConvertToUnicodeFromUtf8L( tag->Data() );

    	StripNulls( *destination );    	

    	}	

    return destination;

	}

EXPORT_C TInt CHarvesterExifUtil::ReadExifDataL( CHarvestData& aHd, CFileData& aFileData )

    {

    WRITELOG( "CHarvesterExifUtil::ReadExifDataL()" );

    CExifRead* reader = CExifRead::NewL(

    		aFileData.iImageData->Des(), CExifRead::ENoJpeg | CExifRead::ENoTagChecking);

    CleanupStack::PushL(reader);

    // Getting description

    aHd.iDescription16 = ReadExifTagL( *reader, EIfd0, KIdImageDescription );

    // Getting UserComment

    ReadUserCommentL( aHd, reader ); 

    // Getting copyright

    aHd.iCopyright16 = ReadExifTagL( *reader, EIfd0, KIdCopyright );

    // Artist

    aHd.iArtist = ReadExifTagL( *reader, EIfd0, KIdArtist );

    // Getting whitebalance

    aHd.iStoreWhiteBalance = reader->GetWhiteBalance( aHd.iWhiteBalance ) == KErrNone;

    // Getting aHd.iFlash    

    aHd.iStoreFlash = reader->GetFlash( aHd.iFlash ) == KErrNone;

    // Getting exposure

    aHd.iStoreExposureProgram = reader->GetExposureProgram( aHd.iExposureProgram ) == KErrNone;

    // Getting width

    if ( reader->TagExists( KIdPixelXDimension, EIfdExif ) )

        {

        // PixelXDimension tag should be found in EXIF according to the standard.

        reader->GetPixelXDimension(aHd.iImageWidthExif);

        }

    // Getting height

    if ( reader->TagExists( KIdPixelYDimension, EIfdExif ) )

        {

        // PixelYDimension tag should be found in EXIF according to the standard.

        reader->GetPixelYDimension(aHd.iImageHeightExif);

        }

    // Getting aFileData.iModified date

    if ( reader->TagExists(KIdDateTime, EIfd0) )

        {

        WRITELOG( "CHarvesterExifUtil::ReadExifDataL() - getting last aFileData.iModified date (exif)" );

        aHd.iDateModified8 = reader->GetDateTimeL();

        }

    // Getting original date

    if ( reader->TagExists(KIdDateTimeOriginal, EIfdExif) )

        {

        WRITELOG( "CHarvesterExifUtil::ReadExifDataL() - getting original date (exif)" );

        aHd.iDateOriginal8 = reader->GetDateTimeOriginalL();

        }

    // Getting date & time digitized

    if ( reader->TagExists(KIdDateTimeDigitized, EIfdExif) )

        {

        WRITELOG( "CHarvesterExifUtil::ReadExifDataL() - getting digitized date (exif)" );

        aHd.iDateDigitized8 = reader->GetDateTimeDigitizedL();

        }            

    //Getting camera maker

    aHd.iMake = ReadExifTagL( *reader, EIfd0, KIdMake );

    //Getting camera aHd.iModel

    aHd.iModel = ReadExifTagL( *reader, EIfd0, KIdModel );

    //Getting aHd.iOrientation

    aHd.iStoreOrientation = reader->GetOrientation( aHd.iOrientation ) == KErrNone;

    //Getting X Resolution

    ReadXResolutionL( aHd, reader ); 

    //Getting Y Resolution

    ReadXResolutionL( aHd, reader ); 

    //Getting resolution unit (mandatory tag)

    reader->GetResolutionUnit( aHd.iResolutionUnit );

    //Getting YCbCr Positioning

    aHd.iStoreYCbCrPositioning = reader->GetYCbCrPositioning( aHd.iYCbCrPositioning ) == KErrNone;

    //Getting exposure bias value

    ReadExposureBiasL( aHd, reader ); 

    //Getting exposure time

    ReadExposureTimeL( aHd, reader ); 

    //Getting FNumber

    ReadFNumberL( aHd, reader );

    //Getting Exif version

    aHd.iStoreExifVersion = reader->GetExifVersion( aHd.iExifVersion ) == KErrNone;           

    //Getting FlashPix version

    aHd.iStoreFlashPixVersion = reader->GetFlashPixVersion( aHd.iFlashPixVersion ) == KErrNone;

    // Shutter speed

    ReadShutterSpeedL( aHd, reader );

    //Getting aHd.iAperture

    ReadApertureValueL( aHd, reader );

    //Getting focal length

    ReadFocalLengthL( aHd, reader );

    // Getting focal length in 35 mm

    ReadFocalLength35mmL( aHd, reader );

    aHd.iStoreColourSpace = reader->GetColorSpace( aHd.iColourSpace ) == KErrNone;

    aHd.iStoreThumbCompression = reader->GetThumbnailCompression( aHd.iThumbCompression ) == KErrNone;

	TUint32 numerator = 0;

    TUint32 denominator = 0;

    //Getting thumbnail X resolution    

    TInt error = reader->GetThumbnailXResolution( numerator, denominator );

    if ( error == KErrNone )

        {

        aHd.iStoreThumbXResolution = ETrue;

        aHd.iThumbXResolution = 0.0f;

        if ( denominator > 0)

            {

            aHd.iThumbXResolution = numerator / denominator;

            }

        }

    //Getting thumbnail Y resolution

    error = reader->GetThumbnailYResolution( numerator, denominator );

    if ( error == KErrNone )

        {

        aHd.iStoreThumbYResolution = ETrue;

        aHd.iThumbYResolution = 0.0f;

        if ( denominator > 0 )

            {

            aHd.iThumbYResolution = numerator / denominator;

            }

        }

    aHd.iStoreThumbResolutionUnit =

    	reader->GetThumbnailResolutionUnit( aHd.iThumbResolutionUnit ) == KErrNone;

    // Bits per sample and Samples per pixel not recorded in JPEG Exif.

    if ( reader->TagExists( KIdSamplesPerPixel, EIfd0 ) )

        {

        const CExifTag* tag = reader->GetTagL( EIfd0, KIdSamplesPerPixel );

        TPtrC8 tagData = tag->Data();

        aHd.iSamplesPerPixel = MdsUtils::ToUInt16L( CONST_CAST( TUint8*, tagData.Ptr() ) );

        aHd.iStoreSamplesPerPixel = ETrue;

        WRITELOG1( "CHarvesterExifUtil::ReadExifDataL() - samples per pixel: %d", aHd.iSamplesPerPixel );

        }

    //Getting ISO speed rating.

    if ( reader->TagExists(KIdISOSpeedRatings, EIfdExif) )

        {

        HBufC8* iso8 = reader->GetIsoSpeedRatingsL();

        if ( iso8 )

            {

            aHd.iStoreIsoSpeedRating = ETrue;

            aHd.iIsoSpeedRating = iso8->Des()[0];

            delete iso8;

            iso8 = NULL;

            }    

        }

    //Getting components configuration

    if ( reader->TagExists( KIdComponentsConfig, EIfdExif ) )

        {

        const CExifTag* tag = reader->GetTagL(

        		EIfdExif, KIdComponentsConfig );

        TPtrC8 tagData = tag->Data();

        aHd.iComponentsConfiguration = MdsUtils::ToUInt32L( CONST_CAST( TUint8*, tagData.Ptr() ) );

        aHd.iStoreComponentsConfig = ETrue;

        }

    // Getting thumbnail compression

    aHd.iStoreThumbCompression =

    	reader->GetThumbnailCompression( aHd.iThumbCompression ) == KErrNone;

    // Getting metering mode

    aHd.iStoreMeteringMode = reader->GetMeteringMode( aHd.iMeteringMode ) ==KErrNone;

    // Getting related soundfile

    aHd.iRelatedSoundFile = ReadExifTagL( *reader, EIfdExif, KIdRelatedSoundFile );

    // Getting focal plane resolution unit

    if ( reader->TagExists(KIdFocalPlaneResolutionUnit, EIfdExif) )

        {

        const CExifTag* tag = reader->GetTagL(

        		EIfdExif, KIdFocalPlaneResolutionUnit );

        TPtrC8 tagData = tag->Data();

        aHd.iFocalPlaneResolutionUnit = MdsUtils::ToUInt16L( CONST_CAST( TUint8*, tagData.Ptr() ) );

        aHd.iStoreFocalPlaneResolutionUnit = ETrue;

        }

    // Getting focal plane X resolution

    ReadFocalXPlaneResolutionL( aHd, reader );

    // Getting focal plane Y resolution

    ReadFocalYPlaneResolutionL( aHd, reader );

    // Get GPS tags

    TBool latitudeExists = EFalse;

    // latitude

    ReadGPSLatitudeL( aHd, reader, latitudeExists );

    // longitude

    ReadGPSLongitudeL( aHd, reader, latitudeExists );

    // altitude

    ReadGPSAltitudeL( aHd, reader );

    CleanupStack::PopAndDestroy( reader );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// Time converting

// ---------------------------------------------------------------------------

//

EXPORT_C TTime CHarvesterExifUtil::ConvertExifDateTimeToSymbianTimeL(

		const TDesC8& aDateTime )

    {

    WRITELOG( "CHarvesterImagePluginAO::ConvertExifDateTimeToSymbianTimeL()" );

    TDateTime datetime( 0, EJanuary, 0, 0, 0, 0, 0 );

    TBuf<4> text;

    // Year

    TPtrC8 textPart = aDateTime.Left(4);

    TLex8 lex( textPart );

    TInt number = 0;

    TInt error = lex.Val( number );

    if ( error != KErrNone )

        {

        WRITELOG( "CHarvesterImagePluginAO::ConvertExifDateTimeToSymbianTimeL() - couldn't get year" );

        User::Leave( error );

        }

    datetime.SetYear( number );

    // Month

    TPtrC8 textPart2 = aDateTime.Mid( 5,2 );

    lex.Assign( textPart2 );

    error = lex.Val( number );

    if ( error != KErrNone )

        {

        WRITELOG( "CHarvesterImagePluginAO::ConvertExifDateTimeToSymbianTimeL() - couldn't get month" );

        User::Leave( error );

        }        

    number--;

    TMonth month = (TMonth) number;

    datetime.SetMonth( month );

    // Day

    TPtrC8 textPart3 = aDateTime.Mid( 8,2 );

    lex.Assign( textPart3 );

    error = lex.Val( number );

    if ( error != KErrNone )

        {

        WRITELOG( "CHarvesterImagePluginAO::ConvertExifDateTimeToSymbianTimeL() - couldn't get date" );

        User::Leave( error );

        }

    datetime.SetDay( number - 1 );

    // Hours

    TPtrC8 textPart4 = aDateTime.Mid( 11,2 );

    lex.Assign( textPart4 );

    error = lex.Val( number );

    if ( error != KErrNone )

        {

        WRITELOG( "CHarvesterImagePluginAO::ConvertExifDateTimeToSymbianTimeL() - couldn't get hours" );

        User::Leave( error );

        }    

    datetime.SetHour( number );

    // Minutes

    TPtrC8 textPart5 = aDateTime.Mid( 14,2 );

    lex.Assign( textPart5 );

    error = lex.Val( number );

    if ( error != KErrNone )

        {

        WRITELOG( "CHarvesterImagePluginAO::ConvertExifDateTimeToSymbianTimeL() - couldn't get minutes" );

        User::Leave( error );

        }

    datetime.SetMinute( number );

    // Seconds

    TPtrC8 textPart6 = aDateTime.Mid( 17,2 );

    lex.Assign( textPart6 );

    error = lex.Val( number );

    if ( error != KErrNone )

        {

        WRITELOG( "CHarvesterImagePluginAO::ConvertExifDateTimeToSymbianTimeL() - couldn't get seconds" );

        User::Leave( error );

        }

    datetime.SetSecond( number );

    TTime time( datetime );

    return time;

    }

void CHarvesterExifUtil::AddPropertyL( CMdEObjectDef& aObjectDef, CMdEObject& aMdeObject,

		const TDesC& aProperty, TUint16 aValue )

	{

	CMdEPropertyDef& propDef = aObjectDef.GetPropertyDefL( aProperty );    

	CMdEProperty* mdeProp = NULL;

	aMdeObject.Property( propDef, mdeProp, 0 );

    if ( !mdeProp )

        {

        aMdeObject.AddUint16PropertyL( propDef, aValue );

        }	

	}

void CHarvesterExifUtil::AddPropertyL( CMdEObjectDef& aObjectDef, CMdEObject& aMdeObject,

		   const TDesC& aProperty, TUint32 aValue )

{

	CMdEPropertyDef& propDef = aObjectDef.GetPropertyDefL( aProperty );    

	CMdEProperty* mdeProp = NULL;

	aMdeObject.Property( propDef, mdeProp, 0 );

	if ( !mdeProp )

		{

		aMdeObject.AddUint32PropertyL( propDef, aValue );

		}	

}

void CHarvesterExifUtil::SetExifDefaultsL( CMdEObject& aMdeObject, CExifModify& aExifModify )

	{

    const TUint32 KPixPerResolution = 72;

    const TUint32 KPixPerResDenm = 1;

    const TUint16 KResUnitInch = 2;

    const TUint16 KYCbCrPositioning = 1;

    const TUint8  KCompConf1st = 1;