1 /*

     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Exif-utilities for harvester

    15 *

    16 */

    17 

    18 #include "harvesterexifutil.h"

    19 

    20 #include "mdsutils.h"

    21 #include "mdeobjectdef.h"

    22 #include "mdeconstants.h"

    23 #include "mdeproperty.h"

    24 #include "tz.h"

    25 #include <ExifModify.h>

    26 

    27 

    28 

    29 using namespace MdeConstants;

    30 

    31 const TUint16 KIdColorSpace = 0xA001;

    32 const TUint16 KIdResolutionUnit = 0x0128;

    33 const TUint16 KIdYbCrPositioning = 0x0213;

    34 const TUint16 KIdImageDescription = 0x010E;

    35 const TUint16 KIdCopyright = 0x8298;

    36 const TUint16 KIdUserComment = 0x9286;

    37 const TUint16 KIdDateTime = 0x0132;

    38 const TUint16 KIdDateTimeOriginal = 0x9003;

    39 const TUint16 KIdDateTimeDigitized = 0x9004;

    40 const TUint16 KIdDateTimeModified = 0x132;

    41 const TUint16 KIdFNumber = 0x829D;

    42 const TUint16 KIdMake = 0x010F;

    43 const TUint16 KIdModel = 0x0110;

    44 const TUint16 KIdFocalLength = 0x920A;

    45 const TUint16 KIdFocalLengthIn35mm = 0xA405;

    46 const TUint16 KIdSamplesPerPixel = 0x0115;

    47 const TUint16 KIdISOSpeedRatings = 0x8827;

    48 const TUint16 KIdComponentsConfig = 0x9101;

    49 const TUint16 KIdArtist = 0x013B;

    50 const TUint16 KIdPixelXDimension = 0xA002;

    51 const TUint16 KIdPixelYDimension = 0xA003;

    52 const TUint16 KIdRelatedSoundFile = 0xA004;

    53 const TUint16 KIdFocalPlaneResolutionUnit = 0xA210;

    54 const TUint16 KIdFocalPlaneXResolution = 0xA20E;

    55 const TUint16 KIdFocalPlaneYResolution = 0xA20F;

    56 

    57 const TUint16 KIdExposureTime = 0x829A;

    58 const TUint16 KIdApertureValue = 0x9202;

    59 const TUint16 KIdExposureBias = 0x9204;

    60 const TUint16 KIdMeteringMode = 0x9207;

    61 const TUint16 KIdShutterSpeed = 0x9201;

    62 const TUint16 KIdXResolution = 0x011A;

    63 const TUint16 KIdYResolution = 0x011B;

    64 const TUint16 KIdWhiteBalance = 0xA403;

    65 const TUint16 KIdExposureProgram = 0x8822;

    66 const TUint16 KIdFlash = 0x9209;

    67 const TUint16 KIdOrientation = 0x112;

    68 

    69 const TUint16 KIdGpsLatitudeRef = 0x1;

    70 const TUint16 KIdGpsLatitude = 0x2;

    71 const TUint16 KIdGpsLongitudeRef = 0x3;

    72 const TUint16 KIdGpsLongitude = 0x4;

    73 const TUint16 KIdGpsAltitudeRef = 0x5;

    74 const TUint16 KIdGpsAltitude = 0x6;

    75 const TUint16 KIdGpsMeasureMode = 0xA;

    76 const TUint16 KIdGpsDop = 0xB;

    77 const TUint16 KIdGpsMapDatum = 0x12;

    78 

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

    80 const TInt KDateBufferSize = 20;

    81 const TInt KCoordinateBufferSize = 24;

    82 

    83 // This is needed for exif description field

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

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

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

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

    88 

    89 _LIT8( KNorth, "N\0" );

    90 _LIT8( KSouth, "S\0" );

    91 _LIT8( KEast, "E\0" );

    92 _LIT8( KWest, "W\0" );

    93 _LIT8( KMeasureMode2, "2\0" );

    94 _LIT8( KMeasureMode3, "3\0" );

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

    96 

    97 CHarvesterExifUtil::CHarvesterExifUtil() :

    98     iSession( NULL ), iDefaultNamespace( NULL )

    99 {

   100 }

   101 

   102 

   103 CHarvesterExifUtil::~CHarvesterExifUtil()

   104 {

   105 }

   106 

   107 EXPORT_C CHarvesterExifUtil* CHarvesterExifUtil::NewLC()

   108 {

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

   110 	CleanupStack::PushL(self);

   111 	self->ConstructL();

   112 	return self;

   113 }

   114 

   115 EXPORT_C CHarvesterExifUtil* CHarvesterExifUtil::NewL()

   116 {

   117 	CHarvesterExifUtil* self=CHarvesterExifUtil::NewLC();

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

   119 	return self;

   120 }

   121 

   122 void CHarvesterExifUtil::ConstructL()

   123 {

   124 

   125 }

   126 

   127 EXPORT_C void CHarvesterExifUtil::SetSession( CMdESession* aSession )

   128 	{

   129 	iSession = aSession;

   130 	if ( !iDefaultNamespace && aSession )

   131 		{

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

   133 		}

   134 	}

   135 

   136 

   137 EXPORT_C TBool CHarvesterExifUtil::IsValidExifData(TPtr8 aPtr)

   138 	{

   139 	WRITELOG( "CHarvesterExifUtil::IsValidExifData start" );

   140 	

   141 	CExifRead* reader = NULL;

   142 	

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

   144 	if (err != KErrNone || !reader )

   145 		{

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

   147 	

   148 		return EFalse;

   149 		}

   150 	

   151 	delete reader;

   152 	

   153 	WRITELOG( "CHarvesterExifUtil::IsValidExifData end" );	

   154 	

   155 	return ETrue;

   156 	}

   157 

   158 void CHarvesterExifUtil::StripNulls( HBufC& aString )

   159 	{

   160 	_LIT( KNull, "\0" );

   161 	_LIT( KSpace, " " );

   162 	

   163 	TInt pos( 0 );

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

   165     	{

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

   167     	}

   168     aString.Des().TrimAll();

   169 	}

   170 

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

   172 	{

   173 	HBufC16* destination = NULL;

   174     if( aReader.TagExists( aTagID, aIFD ) )

   175     	{

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

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

   178     	StripNulls( *destination );    	

   179     	}	

   180     return destination;

   181 	}

   182 

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

   184     {

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

   186 

   187     CExifRead* reader = CExifRead::NewL(

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

   189     CleanupStack::PushL(reader);

   190     

   191     // Getting description

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

   193 

   194     // Getting UserComment

   195     ReadUserCommentL( aHd, reader ); 

   196           

   197     // Getting copyright

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

   199     

   200     // Artist

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

   202     

   203     // Getting whitebalance

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

   205  

   206     // Getting aHd.iFlash    

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

   208     

   209     // Getting exposure

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

   211                 

   212     // Getting width

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

   214         {

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

   216         reader->GetPixelXDimension(aHd.iImageWidthExif);

   217         }

   218     

   219     // Getting height

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

   221         {

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

   223         reader->GetPixelYDimension(aHd.iImageHeightExif);

   224         }

   225     

   226     // Getting aFileData.iModified date

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

   228         {

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

   230         aHd.iDateModified8 = reader->GetDateTimeL();

   231         }

   232     

   233     // Getting original date

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

   235         {

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

   237         aHd.iDateOriginal8 = reader->GetDateTimeOriginalL();

   238         }

   239         

   240     // Getting date & time digitized

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

   242         {

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

   244         aHd.iDateDigitized8 = reader->GetDateTimeDigitizedL();

   245         }            

   246     

   247     //Getting camera maker

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

   249     

   250     //Getting camera aHd.iModel

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

   252     

   253     //Getting aHd.iOrientation

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

   255     

   256     //Getting X Resolution

   257     ReadXResolutionL( aHd, reader ); 

   258     

   259     //Getting Y Resolution

   260     ReadXResolutionL( aHd, reader ); 

   261     

   262     //Getting resolution unit (mandatory tag)

   263     reader->GetResolutionUnit( aHd.iResolutionUnit );

   264     

   265     //Getting YCbCr Positioning

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

   267         

   268     //Getting exposure bias value

   269     ReadExposureBiasL( aHd, reader ); 

   270     

   271     //Getting exposure time

   272     ReadExposureTimeL( aHd, reader ); 

   273         

   274     //Getting FNumber

   275     ReadFNumberL( aHd, reader );

   276     

   277     //Getting Exif version

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

   279         

   280     //Getting FlashPix version

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

   282     

   283     // Shutter speed

   284     ReadShutterSpeedL( aHd, reader );

   285         

   286     //Getting aHd.iAperture

   287     ReadApertureValueL( aHd, reader );

   288     

   289     //Getting focal length

   290     ReadFocalLengthL( aHd, reader );

   291     

   292     // Getting focal length in 35 mm

   293     ReadFocalLength35mmL( aHd, reader );

   294         

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

   296     

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

   298     

   299 	TUint32 numerator = 0;

   300     TUint32 denominator = 0;

   301 	

   302     //Getting thumbnail X resolution    

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

   304     if ( error == KErrNone )

   305         {

   306         aHd.iStoreThumbXResolution = ETrue;

   307         aHd.iThumbXResolution = 0.0f;

   308         if ( denominator > 0)

   309             {

   310             aHd.iThumbXResolution = numerator / denominator;

   311             }

   312         }

   313     

   314     //Getting thumbnail Y resolution

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

   316     if ( error == KErrNone )

   317         {

   318         aHd.iStoreThumbYResolution = ETrue;

   319         aHd.iThumbYResolution = 0.0f;

   320         if ( denominator > 0 )

   321             {

   322             aHd.iThumbYResolution = numerator / denominator;

   323             }

   324         }

   325         

   326     aHd.iStoreThumbResolutionUnit =

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

   328        

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

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

   331         {

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

   333         TPtrC8 tagData = tag->Data();

   334         

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

   336         aHd.iStoreSamplesPerPixel = ETrue;

   337         

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

   339         }

   340     

   341     //Getting ISO speed rating.

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

   343         {

   344         HBufC8* iso8 = reader->GetIsoSpeedRatingsL();

   345         

   346         if ( iso8 )

   347             {

   348             aHd.iStoreIsoSpeedRating = ETrue;

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

   350             delete iso8;

   351             iso8 = NULL;

   352             }    

   353         }

   354     

   355     //Getting components configuration

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

   357         {

   358         const CExifTag* tag = reader->GetTagL(

   359         		EIfdExif, KIdComponentsConfig );

   360         TPtrC8 tagData = tag->Data();

   361         

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

   363         aHd.iStoreComponentsConfig = ETrue;

   364         }

   365     

   366     // Getting thumbnail compression

   367     aHd.iStoreThumbCompression =

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

   369         

   370     // Getting metering mode

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

   372     

   373     // Getting related soundfile

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

   375         

   376     // Getting focal plane resolution unit

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

   378         {

   379         const CExifTag* tag = reader->GetTagL(

   380         		EIfdExif, KIdFocalPlaneResolutionUnit );

   381         TPtrC8 tagData = tag->Data();

   382         

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

   384         aHd.iStoreFocalPlaneResolutionUnit = ETrue;

   385         }

   386     

   387     // Getting focal plane X resolution

   388     ReadFocalXPlaneResolutionL( aHd, reader );

   389 

   390         

   391     // Getting focal plane Y resolution

   392     ReadFocalYPlaneResolutionL( aHd, reader );

   393 

   394     // Get GPS tags

   395     TBool latitudeExists = EFalse;

   396     

   397     // latitude

   398     ReadGPSLatitudeL( aHd, reader, latitudeExists );

   399 

   400     // longitude

   401     ReadGPSLongitudeL( aHd, reader, latitudeExists );

   402     

   403     // altitude

   404     ReadGPSAltitudeL( aHd, reader );

   405         

   406     CleanupStack::PopAndDestroy( reader );

   407     return KErrNone;

   408     }

   409 

   410 // ---------------------------------------------------------------------------

   411 // Time converting

   412 // ---------------------------------------------------------------------------

   413 //

   414 EXPORT_C TTime CHarvesterExifUtil::ConvertExifDateTimeToSymbianTimeL(

   415 		const TDesC8& aDateTime )

   416     {

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

   418     

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

   420     TBuf<4> text;

   421     

   422     // Year

   423     TPtrC8 textPart = aDateTime.Left(4);

   424     TLex8 lex( textPart );

   425     TInt number = 0;

   426     TInt error = lex.Val( number );

   427     if ( error != KErrNone )

   428         {

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

   430         User::Leave( error );

   431         }

   432     datetime.SetYear( number );

   433     

   434     // Month

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

   436     lex.Assign( textPart2 );

   437     error = lex.Val( number );

   438     if ( error != KErrNone )

   439         {

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

   441         User::Leave( error );

   442         }        

   443     number--;

   444     TMonth month = (TMonth) number;

   445     datetime.SetMonth( month );

   446     

   447     // Day

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

   449     lex.Assign( textPart3 );

   450     error = lex.Val( number );

   451     if ( error != KErrNone )

   452         {

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

   454         User::Leave( error );

   455         }

   456     datetime.SetDay( number - 1 );

   457     

   458     // Hours

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

   460     lex.Assign( textPart4 );

   461     error = lex.Val( number );

   462     if ( error != KErrNone )

   463         {

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

   465         User::Leave( error );

   466         }    

   467     datetime.SetHour( number );

   468     

   469     // Minutes

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

   471     lex.Assign( textPart5 );

   472     error = lex.Val( number );

   473     if ( error != KErrNone )

   474         {

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

   476         User::Leave( error );

   477         }

   478     datetime.SetMinute( number );

   479     

   480     // Seconds

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

   482     lex.Assign( textPart6 );

   483     error = lex.Val( number );

   484     if ( error != KErrNone )

   485         {

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

   487         User::Leave( error );

   488         }

   489     datetime.SetSecond( number );

   490     

   491     TTime time( datetime );

   492 

   493     return time;

   494     }

   495 

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

   497 		const TDesC& aProperty, TUint16 aValue )

   498 	{

   499 	CMdEPropertyDef& propDef = aObjectDef.GetPropertyDefL( aProperty );    

   500 	CMdEProperty* mdeProp = NULL;

   501 	

   502 	aMdeObject.Property( propDef, mdeProp, 0 );

   503     if ( !mdeProp )

   504         {

   505         aMdeObject.AddUint16PropertyL( propDef, aValue );

   506         }	

   507 	}

   508 

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

   510 		   const TDesC& aProperty, TUint32 aValue )

   511 {

   512 	CMdEPropertyDef& propDef = aObjectDef.GetPropertyDefL( aProperty );    

   513 	CMdEProperty* mdeProp = NULL;

   514 	

   515 	aMdeObject.Property( propDef, mdeProp, 0 );

   516 	if ( !mdeProp )

   517 		{

   518 		aMdeObject.AddUint32PropertyL( propDef, aValue );

   519 		}	

   520 }

   521 

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

   523 	{

   524     const TUint32 KPixPerResolution = 72;

   525     const TUint32 KPixPerResDenm = 1;

   526     const TUint16 KResUnitInch = 2;

   527     const TUint16 KYCbCrPositioning = 1;

   528     const TUint8  KCompConf1st = 1;

   529     const TUint8  KCompConf2nd = 2;

   530     const TUint8  KCompConf3rd = 3;

   531     const TUint8  KCompConf4rd = 0;

   532     const TUint16 KColorSpaceRGB = 1;

   533 

   534     CMdEObjectDef& imageDef = iDefaultNamespace->GetObjectDefL( Image::KImageObject );

   535     

   536     aExifModify.SetXResolutionL( KPixPerResolution, KPixPerResDenm );

   537     aExifModify.SetYResolutionL( KPixPerResolution, KPixPerResDenm );

   538 

   539     AddPropertyL( imageDef, aMdeObject, MediaObject::KResolutionUnitProperty,

   540     		      KResUnitInch );

   541     aExifModify.SetResolutionUnitL( KResUnitInch );

   542 

   543     AddPropertyL( imageDef, aMdeObject, Image::KYCbCrPositioningProperty,

   544     		      KYCbCrPositioning );

   545     aExifModify.SetYCbCrPositioningL( KYCbCrPositioning );

   546 

   547     TUint32 compUint32( 0 );

   548     TUint8* components = (TUint8*) &compUint32;

   549     *(components + 3) = KCompConf4rd;

   550     *(components + 2) = KCompConf3rd;

   551     *(components + 1) = KCompConf2nd;

   552           *components = KCompConf1st;

   553     

   554     AddPropertyL( imageDef, aMdeObject, Image::KComponentsConfigurationProperty,

   555     		      compUint32 );

   556     aExifModify.SetComponentsConfigurationL( KCompConf1st, KCompConf2nd,

   557     										 KCompConf3rd, KCompConf4rd );

   558 

   559     AddPropertyL( imageDef, aMdeObject, Image::KColourSpaceProperty, KColorSpaceRGB );

   560     aExifModify.SetColorSpaceL( KColorSpaceRGB );

   561 	}

   562 

   563 HBufC8* CHarvesterExifUtil::GetPropertyValueLC( const CMdEPropertyDef& aPropDef,

   564 		const CMdEProperty& aProperty )

   565 	{

   566 	switch( aPropDef.PropertyType() )

   567 		{

   568 		case EPropertyReal32:

   569 			{

   570 			TUint32 denominator = 1; 

   571 			if( aPropDef.Name().CompareF( Image::KExposureTimeProperty ) == 0 )

   572 				{

   573 				denominator = 1000000;

   574 				}

   575 			else if( aPropDef.Name().CompareF( Image::KApertureValueProperty ) == 0 )

   576 				{

   577 				denominator = 100;

   578 				}

   579 			else if( aPropDef.Name().CompareF( Image::KExposureBiasValueProperty ) == 0 )

   580 				{

   581 				denominator = 100;

   582 				}

   583 			else if( aPropDef.Name().CompareF( Image::KShutterSpeedValueProperty ) == 0 )

   584 				{

   585 				denominator = 1000;

   586 				}

   587 			else if( aPropDef.Name().CompareF( Image::KFNumberProperty ) == 0 )

   588 				{

   589 				denominator = 10;

   590 				}			

   591 			TUint32 value = TUint32( aProperty.Real32ValueL() * (TReal32)denominator );

   592 

   593 			HBufC8* buf8 = HBufC8::NewLC( 2 * sizeof(TUint32) );

   594 			TPtr8 ptr = buf8->Des();

   595 			ptr.Append( (TUint8*)&value, sizeof(TUint32) );

   596 			ptr.Append( (TUint8*)&denominator, sizeof(TUint32) );

   597 			

   598 			return buf8;

   599 			}

   600 		case EPropertyTime:

   601 			{

   602 	        TTime time = aProperty.TimeValueL();

   603 	        if( aPropDef.Name().CompareF( Image::KDateTimeProperty ) == 0 )

   604 	        	{

   605 	        	RTz timezone;

   606 	        	CleanupClosePushL( timezone );

   607 	        	User::LeaveIfError( timezone.Connect() );

   608 	        	timezone.ConvertToLocalTime( time );

   609 	        	CleanupStack::PopAndDestroy( &timezone );

   610 	        	}

   611 	        HBufC* buf = HBufC::NewLC( KDateBufferSize );

   612 	        TPtr ptr = buf->Des();

   613 	        time.FormatL( ptr, KExifDateTimeFormat );

   614 	        HBufC8* buf8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( ptr );

   615 	        CleanupStack::PopAndDestroy( buf );

   616 	        CleanupStack::PushL( buf8 );

   617 	        return buf8;

   618 			}

   619 		case EPropertyText:

   620 			{

   621 			TPtrC text = aProperty.TextValueL();

   622 			if( aPropDef.Name().CompareF( MediaObject::KCommentProperty ) == 0 )

   623 				{

   624 		        const TUint16 bufLength = KUnicodeCodeDesignation.iTypeLength + text.Size();

   625 		        HBufC8* commentBuf = HBufC8::NewLC( bufLength );

   626 		        TPtr8 commentPtr = commentBuf->Des();

   627 		        commentPtr.Append( KUnicodeCodeDesignation );

   628 		        commentPtr.Append( (TUint8*)text.Ptr(), text.Size() );

   629 		        return commentBuf;

   630 				}

   631 			HBufC8* buf = CnvUtfConverter::ConvertFromUnicodeToUtf8L( text );

   632 			CleanupStack::PushL( buf );

   633 	        return buf;

   634 			}

   635 		case EPropertyUint16:

   636 			{

   637         	TUint16 value = aProperty.Uint16ValueL();

   638         	HBufC8* buf = HBufC8::NewLC( sizeof(value) );

   639         	TPtr8 ptr = buf->Des();

   640         	ptr.Copy( (TUint8*)(&value), sizeof(value) );

   641 			return buf;

   642 			}

   643 		default:

   644 			User::Leave( KErrGeneral );

   645 		}

   646 	    return NULL;

   647 	}

   648 

   649 CExifTag::TExifTagDataType CHarvesterExifUtil::ExifTagDataType( TUint16 aTagID, const CMdEPropertyDef& aPropDef )

   650 	{

   651 	if( aTagID == KIdUserComment )

   652 		{

   653 		return CExifTag::ETagUndefined;   		

   654 		}

   655 	if( aTagID == KIdShutterSpeed || aTagID == KIdExposureBias )

   656 		{

   657 		return CExifTag::ETagSrational;

   658 		}

   659 	switch( aPropDef.PropertyType() )

   660 		{

   661 		case EPropertyBool:

   662 		case EPropertyInt8:

   663 		case EPropertyUint8:

   664 			return CExifTag::ETagByte;

   665 		case EPropertyInt16:

   666 		case EPropertyUint16:

   667 			return CExifTag::ETagShort;

   668 		case EPropertyUint32:

   669 			return CExifTag::ETagLong;

   670 		case EPropertyInt32:

   671 			return CExifTag::ETagSlong;

   672 		case EPropertyReal32:

   673 			return CExifTag::ETagRational;

   674 		case EPropertyTime:

   675 			return CExifTag::ETagAscii;

   676 		case EPropertyText:

   677 			return CExifTag::ETagAscii;

   678 		default:

   679 			return CExifTag::ETagUndefined;

   680 		}

   681 	}

   682 

   683 TBool CHarvesterExifUtil::CompareTag( TPtrC8 aMdeData, const CExifTag* aTag )

   684 	{

   685 	if( aTag->TagInfo().iDataType == CExifTag::ETagRational )

   686 		{

   687 		TUint32 denominator;

   688 		TUint32 value;

   689         TPtrC8 ptr( aTag->Data() );

   690         memcpy( &value, ptr.Ptr(), sizeof(value) );

   691         memcpy( &denominator, ptr.Ptr()+sizeof(value), sizeof(denominator) );

   692 

   693     	TReal32 tagValue = 0.0f;

   694     	if ( denominator != 0 )

   695     		{

   696     		tagValue = (TReal32)value / (TReal32)denominator;

   697     		}

   698         ptr.Set( aMdeData );

   699         memcpy( &value, ptr.Ptr(), sizeof(value) );

   700         memcpy( &denominator, ptr.Ptr()+sizeof(value), sizeof(denominator) );

   701 

   702     	TReal32 mdeValue = 0.0f;

   703     	if ( denominator != 0 )

   704     		{

   705     		mdeValue = (TReal32)value / (TReal32)denominator;

   706     		}

   707     	return Abs( tagValue - mdeValue ) > 0.01f;

   708 		}

   709 	else

   710 		{

   711 		return aMdeData.CompareF( aTag->Data() ) != 0; 

   712 		}

   713 	}

   714 

   715 TBool CHarvesterExifUtil::ModifyExifTagL( CMdEObject& aMdeObject, CExifModify& aExifModify,

   716 		const TDesC& aProperty, TExifIfdType aIFD, TUint16 aTagID, TBool aRemove )

   717 	{

   718 	CMdEObjectDef& imageDef = iDefaultNamespace->GetObjectDefL( Image::KImageObject );

   719 	CMdEPropertyDef& propDef = imageDef.GetPropertyDefL( aProperty );    

   720 	CMdEProperty* mdeProp = NULL;

   721 	TBool exifChanged = EFalse;

   722 	

   723 	aMdeObject.Property( propDef, mdeProp, 0 );

   724 	TBool tagExists = EFalse;

   725 	if( aRemove )

   726 		{

   727 		tagExists = aExifModify.Reader()->TagExists( aTagID, aIFD );

   728 		}

   729 	if ( mdeProp )

   730         {

   731         HBufC8* mdedata = GetPropertyValueLC( propDef, *mdeProp );

   732         TPtrC8 ptr = mdedata->Des();

   733         TBool change = EFalse;

   734         const CExifTag* tag = NULL;

   735         TRAP_IGNORE( tag = aExifModify.Reader()->GetTagL( aIFD, aTagID ) );

   736         if( !tag ) //create new exif tag

   737         	{

   738         	change = ETrue;

   739         	}

   740         else if( CompareTag( ptr, tag ) )

   741             {

   742             change = ETrue;

   743             }

   744         if( change )

   745         	{

   746         	CExifTag::TExifTagDataType type = ExifTagDataType( aTagID, propDef );

   747         	TInt len = 1;

   748         	if( type == CExifTag::ETagUndefined || type == CExifTag::ETagAscii  )

   749         		{

   750         		len = ptr.Length();

   751         		}

   752         	TExifTagInfo info( aTagID, type, len  );

   753             aExifModify.SetTagL( aIFD, info, ptr );

   754             exifChanged = ETrue;        	

   755         	}

   756         CleanupStack::PopAndDestroy( mdedata );

   757         }

   758 	else if( tagExists ) // remove from exif

   759         {

   760         aExifModify.DeleteTag( aIFD, aTagID );

   761         exifChanged = ETrue;

   762         }

   763     return exifChanged;

   764 	}

   765 

   766 // ---------------------------------------------------------------------------

   767 // ComposeExifData

   768 // ---------------------------------------------------------------------------

   769 //

   770 EXPORT_C TInt CHarvesterExifUtil::ComposeExifDataL( CMdEObject& aMdeObject, TPtr8 aImagePtr, HBufC8*& aModified )

   771 	{

   772 

   773 	if ( !iSession )

   774 		{

   775 		User::Leave( KErrSessionClosed );

   776 		}

   777 	

   778     WRITELOG1( "CHarvesterExifUtil::ComposeExifData() - Compose Start Object ID: %d", aMdeObject.Id() );

   779     TBool exifChanged = EFalse;

   780 

   781     // 2. try to init EXIF data from image file's data

   782     CExifModify* modifyExif = NULL;

   783     TInt exifError = KErrNone;

   784     TRAP( exifError, modifyExif = CExifModify::NewL( aImagePtr, 

   785     		CExifModify::EModify, CExifModify::ENoJpegParsing ) );

   786 

   787     // 3. Is this image format supported?

   788     if ( exifError == KErrNotSupported )

   789         {

   790         WRITELOG( "CHarvesterExifUtil::ComposeExifData() - Image format not supported (!jpeg)" );

   791         User::Leave( exifError );

   792         }

   793 

   794     // 4. if image does not contain EXIF data try to create it

   795     if ( exifError != KErrNone )

   796         {

   797         WRITELOG( "CHarvesterExifUtil::ComposeExifData() - Image doesn't contain EXIF data" );

   798         modifyExif = CExifModify::NewL( aImagePtr, 

   799         		CExifModify::ECreate, CExifModify::ENoJpegParsing );

   800         SetExifDefaultsL( aMdeObject, *modifyExif );

   801         exifChanged = ETrue;

   802         }

   803     CleanupStack::PushL( modifyExif );

   804     const CExifRead* readExif = modifyExif->Reader();

   805     CMdEObjectDef& imageDef = iDefaultNamespace->GetObjectDefL( Image::KImageObject );

   806     

   807     // Set pixel X dimension tag (mandatory)

   808     TBool changed = ModifyExifTagL( aMdeObject, *modifyExif,

   809     		MediaObject::KWidthProperty, EIfdExif, KIdPixelXDimension);

   810     exifChanged = (exifChanged | changed);

   811 

   812     // Set pixel Y dimension tag (mandatory)

   813     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   814     		MediaObject::KHeightProperty, EIfdExif, KIdPixelYDimension);

   815     exifChanged = (exifChanged | changed);

   816 

   817     // Set white balance tag (recommended)

   818     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   819     		Image::KWhiteBalanceProperty, EIfdExif, KIdWhiteBalance, ETrue );

   820     exifChanged = (exifChanged | changed);

   821     

   822     // Set flash tag (recommended)

   823     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   824     		Image::KFlashProperty, EIfdExif, KIdFlash, ETrue );

   825     exifChanged = (exifChanged | changed);

   826     

   827     // Set exposure program tag (optional)

   828     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   829     		Image::KExposureProgramProperty, EIfdExif, KIdExposureProgram, ETrue );

   830     exifChanged = (exifChanged | changed);

   831 

   832     // Set description tag (recommended)

   833     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   834     		MediaObject::KDescriptionProperty, EIfd0, KIdImageDescription, ETrue );

   835     exifChanged = (exifChanged | changed);

   836     

   837     // Set user comment tag (optional)

   838     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   839     		MediaObject::KCommentProperty, EIfdExif, KIdUserComment, ETrue );

   840     exifChanged = (exifChanged | changed);

   841     

   842     // Set copyright tag (optional)

   843     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   844     		MediaObject::KCopyrightProperty, EIfd0, KIdCopyright, ETrue );

   845     exifChanged = (exifChanged | changed);

   846 

   847     // Set DateTimeOriginal tag (optional)

   848     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   849     		Image::KDateTimeOriginalProperty, EIfdExif, KIdDateTimeOriginal, ETrue );

   850     exifChanged = (exifChanged | changed);

   851     

   852     // Set DateTimeDigitized tag (optional)

   853     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   854     		Image::KDateTimeDigitizedProperty, EIfdExif, KIdDateTimeDigitized, ETrue );

   855     exifChanged = (exifChanged | changed);

   856     

   857     // Set DateTime (_image_ modified) tag (recommended)

   858     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   859     		Image::KDateTimeProperty, EIfd0, KIdDateTimeModified, ETrue );

   860     exifChanged = (exifChanged | changed);

   861     

   862     // Set maker tag (optional)

   863     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   864     		Image::KMakeProperty, EIfd1, KIdMake, ETrue );

   865     exifChanged = (exifChanged | changed);

   866     

   867     // Set model tag (optional)

   868     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   869     		Image::KModelProperty, EIfd1, KIdModel, ETrue );

   870     exifChanged = (exifChanged | changed);

   871     

   872     // Set orientation tag (recommended)

   873     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   874     		Image::KOrientationProperty, EIfd0, KIdOrientation , ETrue );

   875     exifChanged = (exifChanged | changed);

   876 

   877     // Set YCbCrPositioning tag (mandatory)

   878     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   879     		Image::KYCbCrPositioningProperty, EIfd1, KIdYbCrPositioning, EFalse );

   880     exifChanged = (exifChanged | changed);

   881     

   882     // Set resolution unit tag (mandatory)

   883     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   884     		MediaObject::KResolutionUnitProperty, EIfd1, KIdResolutionUnit, EFalse );

   885     exifChanged = (exifChanged | changed);

   886     

   887     // Set ISO speed tag (optional)

   888     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   889     		Image::KISOSpeedRatingsProperty, EIfdExif, KIdISOSpeedRatings, ETrue );

   890     exifChanged = (exifChanged | changed);

   891 

   892     // Set related soundfile tag (optional)

   893     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   894     		Image::KRelatedSoundFileProperty, EIfdExif, KIdRelatedSoundFile, ETrue );

   895     exifChanged = (exifChanged | changed);    

   896     

   897     // Set exposure time tag (recommended)

   898     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   899     		Image::KExposureTimeProperty, EIfdExif, KIdExposureTime, ETrue );

   900     exifChanged = (exifChanged | changed);   

   901         

   902     // Set aperture value tag (optional)

   903     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   904     		Image::KApertureValueProperty, EIfdExif, KIdApertureValue, ETrue );

   905     exifChanged = (exifChanged | changed);  

   906     

   907     // Set colour space tag (mandatory)

   908     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   909 		Image::KColourSpaceProperty, EIfdExif, KIdColorSpace , EFalse );

   910     exifChanged = (exifChanged | changed);

   911         

   912     // Set exposure bias tag (optional)

   913     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   914     		Image::KExposureBiasValueProperty, EIfdExif, KIdExposureBias, ETrue );

   915     exifChanged = (exifChanged | changed);

   916     

   917     // Set metering mode tag (optional)

   918     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   919     		Image::KMeteringModeProperty, EIfdExif, KIdMeteringMode, ETrue );

   920     exifChanged = (exifChanged | changed);

   921 

   922     // Set shutter speed tag (optional)

   923     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   924     		Image::KShutterSpeedValueProperty, EIfdExif, KIdShutterSpeed, ETrue );

   925     exifChanged = (exifChanged | changed);

   926 

   927     // Set X resolution tag (mandatory)

   928     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   929     		Image::KXResolutionProperty, EIfd0, KIdXResolution, EFalse );

   930     exifChanged = (exifChanged | changed); 

   931 

   932     // Set Y resolution tag (mandatory)

   933     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   934     		Image::KYResolutionProperty, EIfd0, KIdYResolution, EFalse );

   935     exifChanged = (exifChanged | changed); 

   936     

   937     // Set F number tag (optional)

   938     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   939     		Image::KFNumberProperty, EIfdExif, KIdFNumber, ETrue );

   940     exifChanged = (exifChanged | changed);     

   941     

   942     // Set focal length tag (optional)

   943     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   944     		Image::KFocalLengthProperty, EIfdExif, KIdFocalLength, ETrue );

   945     exifChanged = (exifChanged | changed);  

   946     

   947     // Set focal length in 35 mm film tag (optional)

   948     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   949     		Image::KFocalLengthIn35mmFilmProperty, EIfdExif, KIdFocalLengthIn35mm, ETrue );

   950     exifChanged = (exifChanged | changed);   

   951 

   952     // Set focal plane resolution unit (optional)

   953     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   954     		Image::KFocalPlaneResolutionUnitProperty, EIfdExif, KIdFocalPlaneResolutionUnit, ETrue );

   955     exifChanged = (exifChanged | changed);   

   956 

   957     // Set focal plane X resolution (optional)

   958     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   959     		Image::KFocalPlaneXResolutionProperty, EIfdExif, KIdFocalPlaneXResolution, ETrue );

   960     exifChanged = (exifChanged | changed);

   961     

   962     // Set focal plane Y resolution (optional)

   963     changed = ModifyExifTagL( aMdeObject, *modifyExif,

   964     		Image::KFocalPlaneYResolutionProperty, EIfdExif, KIdFocalPlaneYResolution, ETrue );

   965     exifChanged = (exifChanged | changed);

   966     

   967     TUint16 uint16Value( 0 );

   968     TUint32 uint32Value( 0 );

   969     

   970     // Set components configuration tag (mandatory)

   971     const CMdEPropertyDef& componentsDef = imageDef.GetPropertyDefL(

   972      		Image::KComponentsConfigurationProperty );

   973         {

   974         CMdEProperty* componentsProp = NULL;

   975         aMdeObject.Property( componentsDef, componentsProp, 0 );

   976 

   977         if ( componentsProp )

   978             {

   979             TUint32 componentsValue = componentsProp->Uint32ValueL();

   980             TUint8* components = (TUint8*) &componentsValue;

   981             const TUint8 KComponent4th = *(components + 3);

   982             const TUint8 KComponent3rd = *(components + 2);

   983             const TUint8 KComponent2nd = *(components + 1);

   984             const TUint8 KComponent1st = *components;

   985             

   986             TUint8 exifComponent4th( 0 );

   987             TUint8 exifComponent3rd( 0 );

   988             TUint8 exifComponent2nd( 0 );

   989             TUint8 exifComponent1st( 0 );

   990             

   991             exifError = readExif->GetComponentsConfiguration(

   992               	exifComponent1st, exifComponent2nd, exifComponent3rd, exifComponent4th );

   993             if ( exifError != KErrNone || 

   994                  exifComponent1st != KComponent1st || exifComponent2nd != KComponent2nd ||

   995                  exifComponent3rd != KComponent3rd || exifComponent4th != KComponent4th )

   996                 {

   997                 modifyExif->SetComponentsConfigurationL(

   998                 		KComponent1st, KComponent2nd, KComponent3rd, KComponent4th );

   999                 exifChanged = ETrue;

  1000                 }

  1001             }

  1002         }        

  1003         

  1004 	// Set thumbnail X resolution tag (mandatory)

  1005     const CMdEPropertyDef& thumbXDef = imageDef.GetPropertyDefL(

  1006         Image::KThumbXResolutionProperty );

  1007         {

  1008         CMdEProperty* thumbXProp = NULL;

  1009         aMdeObject.Property( thumbXDef, thumbXProp, 0 );

  1010 

  1011         if ( thumbXProp )

  1012             {

  1013             const TUint32 thumbX = thumbXProp->Uint32ValueL();

  1014 

  1015             TUint32 exifDenominator = 0;

  1016             exifError = readExif->GetThumbnailXResolution( uint32Value, exifDenominator );

  1017             TUint32 exifThumbXResol = 0;

  1018             if ( exifDenominator > 0 )

  1019                 {

  1020                 exifThumbXResol = uint32Value / exifDenominator;

  1021                 }

  1022 

  1023             if ( exifError != KErrNone || exifThumbXResol != thumbX )

  1024                 {

  1025                 const TUint32 KDenominator = 1;

  1026                 modifyExif->SetThumbnailXResolutionL( thumbX, KDenominator );

  1027                 exifChanged = ETrue;

  1028                 }

  1029             }

  1030         }

  1031 

  1032 	// Set thumbnail Y resolution tag (mandatory)

  1033     const CMdEPropertyDef& thumbYDef = imageDef.GetPropertyDefL(

  1034       		Image::KThumbYResolutionProperty );

  1035         {

  1036         CMdEProperty* thumbYProp = NULL;

  1037         aMdeObject.Property( thumbYDef, thumbYProp, 0 );

  1038 

  1039         if ( thumbYProp )

  1040             {

  1041             TUint32 thumbY = TUint32( thumbYProp->Uint32ValueL() );

  1042             TUint32 exifDenominator = 0;

  1043             exifError = readExif->GetThumbnailYResolution( uint32Value, exifDenominator );

  1044             TUint32 exifThumbYResol = 0;

  1045             if ( exifDenominator > 0 )

  1046                 {

  1047                 exifThumbYResol = uint32Value / exifDenominator;

  1048                 }

  1049             

  1050             if ( exifError != KErrNone || exifThumbYResol != thumbY )

  1051                 {

  1052                 const TUint32 KDenominator = 1;

  1053                 modifyExif->SetThumbnailYResolutionL( thumbY, KDenominator );

  1054                 exifChanged = ETrue;

  1055                 }

  1056             }

  1057         }

  1058 

  1059 	// Set thumbnail resolution unit tag (mandatory)

  1060     const CMdEPropertyDef& thumbResolutionUnitDef = imageDef.GetPropertyDefL(

  1061         	Image::KThumbResolutionUnitProperty );

  1062         {

  1063         CMdEProperty* thumbResolutionUnitProp = NULL;            

  1064         aMdeObject.Property( thumbResolutionUnitDef, thumbResolutionUnitProp, 0 );

  1065 

  1066         if ( thumbResolutionUnitProp )

  1067             {

  1068             exifError = readExif->GetThumbnailResolutionUnit( uint16Value );

  1069             const TUint16 thumbnailResolutionUnitValue =

  1070              	thumbResolutionUnitProp->Uint16ValueL();

  1071             if ( exifError != KErrNone || uint16Value != thumbnailResolutionUnitValue )

  1072                 {

  1073                 modifyExif->SetThumbnailResolutionUnitL( thumbnailResolutionUnitValue );

  1074                 exifChanged = ETrue;

  1075                 }

  1076             }

  1077         }

  1078         

  1079     if ( exifChanged )

  1080         {

  1081         WRITELOG( "CHarvesterExifUtil::ComposeExifData() - write exif to buffer" );

  1082         aModified = modifyExif->WriteDataL( aImagePtr );

  1083         }

  1084     CleanupStack::PopAndDestroy( modifyExif );

  1085 

  1086     WRITELOG1( "CHarvesterExifUtil::ComposeExifData() - Compose End Object ID: %d", aMdeObject.Id() );

  1087 

  1088 	return KErrNone;

  1089 	}

  1090 

  1091 // ---------------------------------------------------------------------------

  1092 // ComposeLocation

  1093 // ---------------------------------------------------------------------------

  1094 //

  1095 EXPORT_C void CHarvesterExifUtil::ComposeLocationL( CMdEObject* aLocation, TPtr8 aImagePtr, HBufC8*& aModified )

  1096     {

  1097     CMdEProperty* latitudeProperty = NULL;

  1098     CMdEProperty* longitudeProperty = NULL;

  1099     CMdEProperty* altitudeProperty = NULL;

  1100     CMdEProperty* qualityProperty = NULL;

  1101     

  1102     CMdEObjectDef& locationDef = iDefaultNamespace->GetObjectDefL( Location::KLocationObject );

  1103 

  1104     aLocation->Property( locationDef.GetPropertyDefL(

  1105     		Location::KLatitudeProperty ), latitudeProperty, 0 );

  1106     aLocation->Property( locationDef.GetPropertyDefL(

  1107     		Location::KLongitudeProperty ), longitudeProperty, 0 );

  1108     aLocation->Property( locationDef.GetPropertyDefL(

  1109     		Location::KAltitudeProperty ), altitudeProperty, 0 );

  1110     aLocation->Property( locationDef.GetPropertyDefL(

  1111     		Location::KQualityProperty ), qualityProperty, 0 );

  1112 

  1113     CExifModify* exifWriter = CExifModify::NewL( aImagePtr, 

  1114     		CExifModify::EModify, CExifModify::ENoJpegParsing );

  1115     CleanupStack::PushL( exifWriter );

  1116     const CExifRead* exifReader = exifWriter->Reader();

  1117 

  1118     TBool exifChanged = EFalse;

  1119     TBool changed = EFalse;

  1120     const TReal KAngleSecond = 1.0 / 3600.0;

  1121     TInt exifError( 0 );

  1122     // location data (all fields are optional)

  1123     // latitude

  1124     const CExifTag* exifLatitudeRefTag = NULL;

  1125     TRAP( exifError, exifLatitudeRefTag = exifReader->GetTagL( EIfdGps, KIdGpsLatitudeRef ) );

  1126     if ( latitudeProperty )

  1127         {

  1128         TBuf8<2> south( KSouth );

  1129         TBuf8<2> north( KNorth );

  1130         TReal64 latitude = latitudeProperty->Real64ValueL();

  1131 

  1132         TReal64 exifLatitude( 0.0 );

  1133         TBuf8<2> exifLatitudeRef;

  1134         if ( exifError == KErrNone )