1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 //#include <e32base.h>

    17 #include <iclexif.h>

    18 #include  "ExifTagDescriptions.h"

    19 

    20 #include "ExifUtility.h"

    21 

    22 /**

    23 Constructor

    24 

    25 Instantiates the exif reader utility.

    26 Note: no method on this utility should be used after the metadate has been destroyed

    27 

    28 @param aExifMetadata

    29 	the metadata class on which to read the tags

    30 */

    31 EXPORT_C TExifReaderUtility::TExifReaderUtility(MExifMetadataReader* aExifMetadata)

    32 	: iExifRead(aExifMetadata)

    33 	{

    34 	}

    35 	

    36 

    37 // Getters

    38 /**

    39 Gets the make tag value of the metadata. 

    40 

    41 @param aParam

    42 	on return, the make value

    43 	

    44 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

    45 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

    46 

    47 @return error code

    48 	KErrArgument if the requested data type does not match with the tag.

    49 	KErrNotSupported if called on an encoding module.

    50 	KErrNotFound if the tag cannot be found.

    51 */

    52 EXPORT_C TInt TExifReaderUtility::GetMake(HBufC8*& aParam) const

    53 	{

    54 	if(iExifRead==NULL)

    55 		{

    56 		return KErrOverflow;

    57 		}

    58 	TInt tag = KTag010F[ETagValue];

    59 	TInt ifd = KExifIfdZero;

    60 	return iExifRead->GetParam8(tag, ifd, aParam);

    61 	}

    62 	

    63 /**

    64 Gets the model tag value of the metadata. 

    65 

    66 @param aParam

    67 	on return, the model value

    68 	

    69 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

    70 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

    71 

    72 @return error code

    73 	KErrArgument if the requested data type does not match with the tag.

    74 	KErrNotSupported if called on an encoding module.

    75 	KErrNotFound if the tag cannot be found.

    76 */

    77 EXPORT_C TInt TExifReaderUtility::GetModel(HBufC8*& aParam) const

    78 	{

    79 	if(iExifRead==NULL)

    80 		{

    81 		return KErrOverflow;

    82 		}

    83 	TInt tag = KTag0110[ETagValue];

    84 	TInt ifd = KExifIfdZero;

    85 	return iExifRead->GetParam8(tag, ifd, aParam);

    86 	}

    87 	

    88 /**

    89 Gets the dateTime tag value of the metadata. 

    90 

    91 @param aParam

    92 	on return, the dateTime value

    93 	

    94 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

    95 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

    96 

    97 @return error code

    98 	KErrArgument if the requested data type does not match with the tag.

    99 	KErrNotSupported if called on an encoding module.

   100 	KErrNotFound if the tag cannot be found.

   101 */

   102 EXPORT_C TInt TExifReaderUtility::GetDateTime(HBufC8*& aParam) const

   103 	{

   104 	if(iExifRead==NULL)

   105 		{

   106 		return KErrOverflow;

   107 		}

   108 	TInt tag = KTag0132[ETagValue];

   109 	TInt ifd = KExifIfdZero;

   110 	return iExifRead->GetParam8(tag, ifd, aParam);

   111 	}

   112 	

   113 /**

   114 Gets the dateTimeOriginal tag value of the metadata. 

   115 

   116 @param aParam

   117 	on return, the dateTimeOriginal value

   118 	

   119 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   120 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   121 

   122 @return error code

   123 	KErrArgument if the requested data type does not match with the tag.

   124 	KErrNotSupported if called on an encoding module.

   125 	KErrNotFound if the tag cannot be found.

   126 */

   127 EXPORT_C TInt TExifReaderUtility::GetDateTimeOriginal(HBufC8*& aParam) const

   128 	{

   129 	if(iExifRead==NULL)

   130 		{

   131 		return KErrOverflow;

   132 		}

   133 	TInt tag = KTag9003[ETagValue];

   134 	TInt ifd = KExifIfdZero;

   135 	return iExifRead->GetParam8(tag, ifd, aParam);

   136 	}

   137 

   138 /**

   139 Gets the dateTimeDigitized tag value of the metadata. 

   140 

   141 @param aParam

   142 	on return, the dateTimeDigitized value

   143 	

   144 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   145 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   146 

   147 @return error code

   148 	KErrArgument if the requested data type does not match with the tag.

   149 	KErrNotSupported if called on an encoding module.

   150 	KErrNotFound if the tag cannot be found.

   151 */

   152 EXPORT_C TInt TExifReaderUtility::GetDateTimeDigitized(HBufC8*& aParam) const

   153 	{

   154 	if(iExifRead==NULL)

   155 		{

   156 		return KErrOverflow;

   157 		}

   158 	TInt tag = KTag9004[ETagValue];

   159 	TInt ifd = KExifIfdZero;

   160 	return iExifRead->GetParam8(tag, ifd, aParam);

   161 	}

   162 

   163 /**

   164 Gets the interoperabilityIndex tag value of the metadata. 

   165 

   166 @param aParam

   167 	on return, the interoperabilityIndex value

   168 	

   169 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   170 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   171 

   172 @return error code

   173 	KErrArgument if the requested data type does not match with the tag.

   174 	KErrNotSupported if called on an encoding module.

   175 	KErrNotFound if the tag cannot be found.

   176 */

   177 EXPORT_C TInt TExifReaderUtility::GetInteroperabilityIndex(HBufC8*& aParam) const

   178 	{

   179 	if(iExifRead==NULL)

   180 		{

   181 		return KErrOverflow;

   182 		}

   183 	TInt tag = KTag0001[ETagValue];

   184 	TInt ifd = KExifIfdZero;

   185 	return iExifRead->GetParam8(tag, ifd, aParam);

   186 	}

   187 

   188 /**

   189 Gets the interoperabilityVersion tag value of the metadata. 

   190 

   191 @param aParam

   192 	on return, the interoperabilityVersion value

   193 	

   194 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   195 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   196 

   197 @return error code

   198 	KErrArgument if the requested data type does not match with the tag.

   199 	KErrNotSupported if called on an encoding module.

   200 	KErrNotFound if the tag cannot be found.

   201 */

   202 EXPORT_C TInt TExifReaderUtility::GetInteroperabilityVersion(HBufC8*& aParam) const

   203 	{

   204 	if(iExifRead==NULL)

   205 		{

   206 		return KErrOverflow;

   207 		}

   208 	TInt tag = KTag0002[ETagValue];

   209 	TInt ifd = KExifIfdZero;

   210 	return iExifRead->GetParam8(tag, ifd, aParam);

   211 	}

   212 

   213 /**

   214 Gets the exifVersion tag value of the metadata. 

   215 

   216 @param aParam

   217 	on return, the exifVersion value

   218 	

   219 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   220 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   221 

   222 @return error code

   223 	KErrArgument if the requested data type does not match with the tag.

   224 	KErrNotSupported if called on an encoding module.

   225 	KErrNotFound if the tag cannot be found.

   226 */

   227 EXPORT_C TInt TExifReaderUtility::GetExifVersion(HBufC8*& aParam) const

   228 	{

   229 	if(iExifRead==NULL)

   230 		{

   231 		return KErrOverflow;

   232 		}

   233 	TInt tag = KTag9000[ETagValue];

   234 	TInt ifd = KExifIfdZero;

   235 	return iExifRead->GetParam8(tag, ifd, aParam);

   236 	}

   237 	

   238 /**

   239 Gets the componentsConfiguration tag value of the metadata. 

   240 

   241 @param aParam

   242 	on return, the ComponentConfiguration value

   243 	

   244 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   245 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   246 

   247 @return error code

   248 	KErrArgument if the requested data type does not match with the tag.

   249 	KErrNotSupported if called on an encoding module.

   250 	KErrNotFound if the tag cannot be found.

   251 */

   252 EXPORT_C TInt TExifReaderUtility::GetComponentsConfiguration(HBufC8*& aParam) const

   253 	{	

   254 	if(iExifRead==NULL)

   255 		{

   256 		return KErrOverflow;

   257 		}

   258 	TInt tag = KTag9101[ETagValue];

   259 	TInt ifd = KExifIfdZero;

   260 	return iExifRead->GetParam8(tag, ifd, aParam);

   261 	}

   262 	

   263 /**

   264 Gets the flashpixVersion tag value of the metadata. 

   265 

   266 @param aParam

   267 	on return, the flashpixVersion value

   268 	

   269 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   270 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   271 

   272 @return error code

   273 	KErrArgument if the requested data type does not match with the tag.

   274 	KErrNotSupported if called on an encoding module.

   275 	KErrNotFound if the tag cannot be found.

   276 */

   277 EXPORT_C TInt TExifReaderUtility::GetFlashPixVersion(HBufC8*& aParam) const

   278 	{

   279 	if(iExifRead==NULL)

   280 		{

   281 		return KErrOverflow;

   282 		}

   283 	TInt tag = KTagA000[ETagValue];

   284 	TInt ifd = KExifIfdZero;

   285 	return iExifRead->GetParam8(tag, ifd, aParam);

   286 	}

   287 

   288 /**

   289 Gets the main image xResolution tag value of the metadata. 

   290 

   291 @param aNumerator

   292 	on return, the main image xResolution numerator value

   293 	

   294 @param aDenominator

   295 	on return, the main image xResolution denominator value

   296 		

   297 @return error code

   298 	KErrArgument if the requested data type does not match with the tag.

   299 	KErrNotSupported if called on an encoding module.

   300 	KErrNotFound if the tag cannot be found.

   301 */

   302 EXPORT_C TInt TExifReaderUtility::GetXResolution(TInt& aNumerator, TInt& aDenominator) const

   303 	{

   304 	if(iExifRead==NULL)

   305 		{

   306 		return KErrOverflow;

   307 		}

   308 	TInt tag = KTag011A[ETagValue];

   309 	TInt ifd = KExifIfdZero;

   310 	return iExifRead->GetRationalParam(tag, ifd, aNumerator, aDenominator);

   311 	}

   312 	

   313 /**

   314 Gets the main image yResolution tag value of the metadata. 

   315 

   316 @param aNumerator

   317 	on return, the main image yResolution numerator value

   318 	

   319 @param aDenominator

   320 	on return, the main image yResolution denominator value

   321 		

   322 @return error code

   323 	KErrArgument if the requested data type does not match with the tag.

   324 	KErrNotSupported if called on an encoding module.

   325 	KErrNotFound if the tag cannot be found.

   326 */

   327 EXPORT_C TInt TExifReaderUtility::GetYResolution(TInt& aNumerator, TInt& aDenominator) const

   328 	{

   329 	if(iExifRead==NULL)

   330 		{

   331 		return KErrOverflow;

   332 		}

   333 	TInt tag = KTag011B[ETagValue];

   334 	TInt ifd = KExifIfdZero;

   335 	return iExifRead->GetRationalParam(tag, ifd, aNumerator, aDenominator);

   336 	}

   337 	

   338 /**

   339 Gets the thumbnail xResolution tag value of the metadata. 

   340 

   341 @param aNumerator

   342 	on return, the main thumbnail xResolution numerator value

   343 

   344 @param aDenominator

   345 	on return, the main thumbnail xResolution denominator value

   346 		

   347 @return error code

   348 	KErrArgument if the requested data type does not match with the tag.

   349 	KErrNotSupported if called on an encoding module.

   350 	KErrNotFound if the tag cannot be found.

   351 */

   352 EXPORT_C TInt TExifReaderUtility::GetThumbXResolution(TInt& aNumerator, TInt& aDenominator) const

   353 	{

   354 	if(iExifRead==NULL)

   355 		{

   356 		return KErrOverflow;

   357 		}

   358 	TInt tag = KThumbTag011A[ETagValue];

   359 	TInt ifd = KExifIfdOne;

   360 	return iExifRead->GetRationalParam(tag, ifd, aNumerator, aDenominator);

   361 	}

   362 	

   363 /**

   364 Gets the thumbnail yResolution tag value of the metadata. 

   365 

   366 @param aNumerator

   367 	on return, the main thumbnail yResolution numerator value

   368 

   369 @param aDenominator

   370 	on return, the main thumbnail yResolution denominator value

   371 		

   372 @return error code

   373 	KErrArgument if the requested data type does not match with the tag.

   374 	KErrNotSupported if called on an encoding module.

   375 	KErrNotFound if the tag cannot be found.

   376 */

   377 EXPORT_C TInt TExifReaderUtility::GetThumbYResolution(TInt& aNumerator, TInt& aDenominator) const

   378 	{

   379 	if(iExifRead==NULL)

   380 		{

   381 		return KErrOverflow;

   382 		}

   383 	TInt tag = KThumbTag011B[ETagValue];

   384 	TInt ifd = KExifIfdOne;

   385 	return iExifRead->GetRationalParam(tag, ifd, aNumerator, aDenominator);

   386 	}

   387 

   388 /**

   389 Gets the main image resolutionUnit tag value of the metadata. 

   390 

   391 @param aParam

   392 	on return, the main image resolutionUnit value

   393 	

   394 @return error code

   395 	KErrArgument if the requested data type does not match with the tag.

   396 	KErrNotSupported if called on an encoding module.

   397 	KErrNotFound if the tag cannot be found.

   398 */

   399 EXPORT_C TInt TExifReaderUtility::GetResolutionUnit(TUint16& aParam) const

   400 	{

   401 	if(iExifRead==NULL)

   402 		{

   403 		return KErrOverflow;

   404 		}

   405 	TInt tag = KTag0128[ETagValue];

   406 	TInt ifd = KExifIfdZero;

   407 	return iExifRead->GetShortParam(tag, ifd, aParam);

   408 	}

   409 	

   410 /**

   411 Gets the yCbCrPositioning tag value of the metadata. 

   412 

   413 @param aParam

   414 	on return, the yCbCrPositioning value

   415 	

   416 @return error code

   417 	KErrArgument if the requested data type does not match with the tag.

   418 	KErrNotSupported if called on an encoding module.

   419 	KErrNotFound if the tag cannot be found.

   420 */

   421 EXPORT_C TInt TExifReaderUtility::GetYCbCrPositioning(TUint16& aParam) const

   422 	{

   423 	if(iExifRead==NULL)

   424 		{

   425 		return KErrOverflow;

   426 		}

   427 	TInt tag = KTag0213[ETagValue];

   428 	TInt ifd = KExifIfdZero;

   429 	return iExifRead->GetShortParam(tag, ifd, aParam);

   430 	}

   431 	

   432 /**

   433 Gets the main image orientation tag value of the metadata. 

   434 

   435 @param aParam

   436 	on return, the main image orientation value

   437 	

   438 @return error code

   439 	KErrArgument if the requested data type does not match with the tag.

   440 	KErrNotSupported if called on an encoding module.

   441 	KErrNotFound if the tag cannot be found.

   442 */EXPORT_C TInt TExifReaderUtility::GetOrientation(TUint16& aParam) const

   443 	{

   444 	if(iExifRead==NULL)

   445 		{

   446 		return KErrOverflow;

   447 		}

   448 	TInt tag = KTag0112[ETagValue];

   449 	TInt ifd = KExifIfdZero;

   450 	return iExifRead->GetShortParam(tag, ifd, aParam);

   451 	}

   452 	

   453 /**

   454 Gets the colorSpace tag value of the metadata. 

   455 

   456 @param aParam

   457 	on return, the colorSpace value

   458 	

   459 @return error code

   460 	KErrArgument if the requested data type does not match with the tag.

   461 	KErrNotSupported if called on an encoding module.

   462 	KErrNotFound if the tag cannot be found.

   463 */

   464 EXPORT_C TInt TExifReaderUtility::GetColorSpace(TUint16& aParam) const

   465 	{

   466 	if(iExifRead==NULL)

   467 		{

   468 		return KErrOverflow;

   469 		}

   470 	TInt tag = KTagA001[ETagValue];

   471 	TInt ifd = KExifIfdZero;

   472 	return iExifRead->GetShortParam(tag, ifd, aParam);

   473 	}

   474 	

   475 /**

   476 Gets the pixelXDimension tag value of the metadata. 

   477 

   478 @param aParam

   479 	on return, the pixelXDimension value

   480 	

   481 @return error code

   482 	KErrArgument if the requested data type does not match with the tag.

   483 	KErrNotSupported if called on an encoding module.

   484 	KErrNotFound if the tag cannot be found.

   485 */

   486 EXPORT_C TInt TExifReaderUtility::GetPixelXDimension(TInt& aParam) const

   487 	{

   488 	if(iExifRead==NULL)

   489 		{

   490 		return KErrOverflow;

   491 		}

   492 	TInt tag = KTagA002[ETagValue];

   493 	TInt ifd = KExifIfdZero;

   494 

   495 	//This tag can be SHORT or LONG so first try to read as integer if

   496 	//that does not work then try as SHORT

   497 	TInt err = iExifRead->GetIntegerParam(tag, ifd, aParam);

   498 	

   499 	if (err == KErrArgument)

   500 		{

   501 		//then the tag could be short

   502 		TUint16 paramShort = 0;

   503 		err = iExifRead->GetShortParam(tag, ifd, paramShort);

   504 		if (err == KErrNone)

   505 			{

   506 			//tag was SHORT so set aParam

   507 			aParam = static_cast<TInt>(paramShort);

   508 			}

   509 		else

   510 			{

   511 			err = KErrArgument; //just to ensure behaviour is unaltered from 9.x

   512 			}

   513 		}

   514 	return err;

   515 	}

   516 	

   517 /**

   518 Gets the pixelYDimension tag value of the metadata. 

   519 

   520 @param aParam

   521 	on return, the pixelYDimension value

   522 		

   523 @return error code

   524 	KErrArgument if the requested data type does not match with the tag.

   525 	KErrNotSupported if called on an encoding module.

   526 	KErrNotFound if the tag cannot be found.

   527 */

   528 EXPORT_C TInt TExifReaderUtility::GetPixelYDimension(TInt& aParam) const

   529 	{

   530 	if(iExifRead==NULL)

   531 		{

   532 		return KErrOverflow;

   533 		}

   534 	TInt tag = KTagA003[ETagValue];

   535 	TInt ifd = KExifIfdZero;

   536 

   537 	//This tag can be SHORT or LONG so first try to read as integer if

   538 	//that does not work then try as SHORT

   539 	TInt err = iExifRead->GetIntegerParam(tag, ifd, aParam);

   540 	

   541 	if (err == KErrArgument)

   542 		{

   543 		//then the tag could be short

   544 		TUint16 paramShort = 0;

   545 		err = iExifRead->GetShortParam(tag, ifd, paramShort);

   546 		if (err == KErrNone)

   547 			{

   548 			//tag was SHORT so set aParam

   549 			aParam = static_cast<TInt>(paramShort);

   550 			}

   551 		else

   552 			{

   553 			err = KErrArgument; //just to ensure behaviour is unaltered from 9.x

   554 			}

   555 		}

   556 	return err;

   557 	}

   558 

   559 /**

   560 Gets the thumbnail compression tag value of the metadata. 

   561 

   562 @param aParam

   563 	on return, the thumbnail compression value

   564 	

   565 @return error code

   566 	KErrArgument if the requested data type does not match with the tag.

   567 	KErrNotSupported if called on an encoding module.

   568 	KErrNotFound if the tag cannot be found.

   569 */

   570 EXPORT_C TInt TExifReaderUtility::GetThumbCompression(TUint16& aParam) const

   571 	{

   572 	if(iExifRead==NULL)

   573 		{

   574 		return KErrOverflow;

   575 		}

   576 	TInt tag = KThumbTag0103[ETagValue];

   577 	TInt ifd = KExifIfdOne;

   578 	return iExifRead->GetShortParam(tag, ifd, aParam);

   579 	}

   580 	

   581 /**

   582 Gets the thumbnail resolutionUnit tag value of the metadata. 

   583 

   584 @param aParam

   585 	on return, the thumbnail resolutionUnit value

   586 	

   587 @return error code

   588 	KErrArgument if the requested data type does not match with the tag.

   589 	KErrNotSupported if called on an encoding module.

   590 	KErrNotFound if the tag cannot be found.

   591 */

   592 EXPORT_C TInt TExifReaderUtility::GetThumbResolutionUnit(TUint16& aParam) const

   593 	{

   594 	if(iExifRead==NULL)

   595 		{

   596 		return KErrOverflow;

   597 		}

   598 	TInt tag = KThumbTag0128[ETagValue];

   599 	TInt ifd = KExifIfdOne;

   600 	return iExifRead->GetShortParam(tag, ifd, aParam);

   601 	}

   602 

   603 /**

   604 Gets the thumbnail orientation tag value of the metadata. 

   605 

   606 @param aParam

   607 	on return, the thumbnail orientation value

   608 	

   609 @return error code

   610 	KErrArgument if the requested data type does not match with the tag.

   611 	KErrNotSupported if called on an encoding module.

   612 	KErrNotFound if the tag cannot be found.

   613 */

   614 EXPORT_C TInt TExifReaderUtility::GetThumbOrientation(TUint16& aParam) const

   615 	{

   616 	if(iExifRead==NULL)

   617 		{

   618 		return KErrOverflow;

   619 		}

   620 	TInt tag = KThumbTag0112[ETagValue];

   621 	TInt ifd = KExifIfdOne;

   622 	return iExifRead->GetShortParam(tag, ifd, aParam);

   623 	}

   624 

   625 /**

   626 Gets the image description tag value of the metadata. 

   627 

   628 @param aParam

   629 	on return, the image description value.

   630 

   631 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   632 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   633 		

   634 @return error code

   635 	KErrArgument if the requested data type does not match with the tag.

   636 	KErrNotSupported if called on an encoding module.

   637 	KErrNotFound if the tag cannot be found.

   638 	KErrOverflow if there is an internal error with the Exif metadata.

   639 */

   640 EXPORT_C TInt TExifReaderUtility::GetImageDescription(HBufC8*& aParam) const

   641 	{

   642 	if(iExifRead==NULL)

   643 		{

   644 		return KErrOverflow;

   645 		}

   646 	TInt tag = KTag010E[ETagValue];

   647 	TInt ifd = KExifIfdZero;

   648 	return iExifRead->GetParam8(tag, ifd, aParam);

   649 	}

   650 

   651 /**

   652 Gets the copyright tag value of the metadata. 

   653 

   654 @param aParam

   655 	on return, the copyright value.

   656 

   657 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   658 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   659 	

   660 @return error code

   661 	KErrArgument if the requested data type does not match with the tag.

   662 	KErrNotSupported if called on an encoding module.

   663 	KErrNotFound if the tag cannot be found.

   664 	KErrOverflow if there is an internal error with the Exif metadata.

   665 */

   666 EXPORT_C TInt TExifReaderUtility::GetCopyright(HBufC8*& aParam) const

   667 	{

   668 	if(iExifRead==NULL)

   669 		{

   670 		return KErrOverflow;

   671 		}

   672 	TInt tag = KTag8298[ETagValue];

   673 	TInt ifd = KExifIfdZero;

   674 	return iExifRead->GetParam8(tag, ifd, aParam);

   675 	}

   676 	

   677 /**

   678 Gets the maker note tag value of the metadata. 

   679 

   680 @param aParam

   681 	on return, the maker note value.

   682 

   683 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   684 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   685 	

   686 @return error code

   687 	KErrArgument if the requested data type does not match with the tag.

   688 	KErrNotSupported if called on an encoding module.

   689 	KErrNotFound if the tag cannot be found.

   690 	KErrOverflow if there is an internal error with the Exif metadata.

   691 */

   692 EXPORT_C TInt TExifReaderUtility::GetMakerNote(HBufC8*& aParam) const

   693 	{

   694 	if(iExifRead==NULL)

   695 		{

   696 		return KErrOverflow;

   697 		}

   698 	TInt tag = KTag927C[ETagValue];

   699 	TInt ifd = KExifIfdZero;

   700 	return iExifRead->GetParam8(tag, ifd, aParam);

   701 	}

   702 

   703 /**

   704 Gets the user comment tag value of the metadata. 

   705 

   706 @param aParam

   707 	on return, the user comment value.

   708 	

   709 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   710 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   711 

   712 	Note: The first 8 bytes of aParam may contain a Character Code to indicate the type of encoding used. See table 6 of the Exif 2.2 specification for a list of codes.

   713 		

   714 @return error code

   715 	KErrArgument if the requested data type does not match with the tag.

   716 	KErrNotSupported if called on an encoding module.

   717 	KErrNotFound if the tag cannot be found.

   718 	KErrOverflow if there is an internal error with the Exif metadata.

   719 */

   720 EXPORT_C TInt TExifReaderUtility::GetUserComment(HBufC8*& aParam) const

   721 	{

   722 	if(iExifRead==NULL)

   723 		{

   724 		return KErrOverflow;

   725 		}

   726 	TInt tag = KTag9286[ETagValue];

   727 	TInt ifd = KExifIfdZero;

   728 	return iExifRead->GetParam8(tag, ifd, aParam);

   729 	}

   730 	

   731 /**

   732 Gets the flash tag value of the metadata. 

   733 

   734 @param aParam

   735 	on return, the flash value.

   736 	

   737 @return error code

   738 	KErrArgument if the requested data type does not match with the tag.

   739 	KErrNotSupported if called on an encoding module.

   740 	KErrNotFound if the tag cannot be found.

   741 	KErrOverflow if there is an internal error with the Exif metadata.

   742 */

   743 EXPORT_C TInt TExifReaderUtility::GetFlash(TUint16& aParam) const

   744 	{

   745 	if(iExifRead==NULL)

   746 		{

   747 		return KErrOverflow;

   748 		}

   749 	TInt tag = KTag9209[ETagValue];

   750 	TInt ifd = KExifIfdZero;

   751 	return iExifRead->GetShortParam(tag, ifd, aParam);

   752 	}

   753 

   754 /**

   755 Gets the focal length tag value of the metadata. 

   756 

   757 @param aNumerator

   758 	on return, the focal length numerator value.

   759 		

   760 @param aDenominator

   761 	on return, the focal length denominator value.

   762 	

   763 @return error code

   764 	KErrArgument if the requested data type does not match with the tag.

   765 	KErrNotSupported if called on an encoding module.

   766 	KErrNotFound if the tag cannot be found.

   767 	KErrOverflow if there is an internal error with the Exif metadata.

   768 */

   769 EXPORT_C TInt TExifReaderUtility::GetFocalLength(TInt& aNumerator, TInt& aDenominator) const

   770 	{

   771 	if(iExifRead==NULL)

   772 		{

   773 		return KErrOverflow;

   774 		}

   775 	TInt tag = KTag920A[ETagValue];

   776 	TInt ifd = KExifIfdZero;

   777 	return iExifRead->GetRationalParam(tag, ifd, aNumerator, aDenominator);

   778 	}

   779 	

   780 /**

   781 Gets the shutter speed tag value of the metadata. 

   782 

   783 @param aNumerator

   784 	on return, the shutter speed numerator value.

   785 	

   786 	Note that aNumerator is a true signed quantity, so no typecasting to an unsigned type is required.

   787 

   788 @param aDenominator

   789 	on return, the shutter speed denominator value.

   790 

   791 	Note that aDenominator is a true signed quantity, so no typecasting to an unsigned type is required.

   792 	

   793 @return error code

   794 	KErrArgument if the requested data type does not match with the tag.

   795 	KErrNotSupported if called on an encoding module.

   796 	KErrNotFound if the tag cannot be found.

   797 	KErrOverflow if there is an internal error with the Exif metadata.

   798 */

   799 EXPORT_C TInt TExifReaderUtility::GetShutterSpeedValue(TInt& aNumerator, TInt& aDenominator) const

   800 	{

   801 	if(iExifRead==NULL)

   802 		{

   803 		return KErrOverflow;

   804 		}

   805 	TInt tag = KTag9201[ETagValue];

   806 	TInt ifd = KExifIfdZero;

   807 	return iExifRead->GetRationalParam(tag, ifd, aNumerator, aDenominator);

   808 	}

   809 

   810 /**

   811 Gets the thumbnail jpeg interchange format length of the metadata. 

   812 

   813 @deprecated - Replaced by TExifReaderUtility::GetJpegInterchangeFormatLength(TUint& aParam).

   814 

   815 @param aParam

   816 	on return, the thumbnail jpeg interchange format length.

   817 		

   818 @return error code

   819 	KErrArgument if the requested data type does not match with the tag.

   820 	KErrNotSupported if called on an encoding module.

   821 	KErrNotFound if the tag cannot be found.

   822 	KErrOverflow if there is an internal error with the Exif metadata.

   823 */

   824 EXPORT_C TInt TExifReaderUtility::GetJpegInterchangeFormatLength(TInt& aParam) const

   825 	{

   826 	if(iExifRead==NULL)

   827 		{

   828 		return KErrOverflow;

   829 		}

   830 	TInt tag = KThumbTag0202[ETagValue];

   831 	TInt ifd = KExifIfdOne;

   832 	return iExifRead->GetIntegerParam(tag, ifd, aParam);

   833 	}

   834 

   835 /**

   836 Gets the thumbnail jpeg interchange format length of the metadata. 

   837 

   838 @param aParam

   839 	on return, the thumbnail jpeg interchange format length.

   840 		

   841 @return error code

   842 	KErrNotSupported if called on an encoding module.

   843 	KErrNotFound if the tag cannot be found.

   844 	KErrOverflow if there is an internal error with the Exif metadata.

   845 */

   846 EXPORT_C TInt TExifReaderUtility::GetJpegInterchangeFormatLength(TUint& aParam) const

   847 	{

   848 	if(iExifRead==NULL)

   849 		{

   850 		return KErrOverflow;

   851 		}

   852 	TInt tag = KThumbTag0202[ETagValue];

   853 	TInt ifd = KExifIfdOne;

   854 	TInt value = 0;

   855 	TInt result = iExifRead->GetIntegerParam(tag, ifd, value);

   856 	if (result == KErrNone)

   857 		{

   858 		aParam = static_cast<TUint>(value);

   859 		}

   860 	return result;

   861 	}

   862 	

   863 /**

   864 Gets the gps version id tag value of the metadata. 

   865 

   866 @param aParam

   867 	on return, the gps version id.

   868 	

   869 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   870 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   871 	

   872 @return error code

   873 	KErrArgument if the requested data type does not match with the tag.

   874 	KErrNotSupported if called on an encoding module.

   875 	KErrNotFound if the tag cannot be found.

   876 	KErrOverflow if there is an internal error with the Exif metadata.

   877 */

   878 EXPORT_C TInt TExifReaderUtility::GetGpsVersionId(HBufC8*& aParam) const

   879 	{

   880 	if(iExifRead==NULL)

   881 		{

   882 		return KErrOverflow;

   883 		}

   884 	TInt tag = KTagGPS0000[ETagValue];

   885 

   886 	// We need to specify GPS sub IFD using the upper 16 bits.

   887 	TUint ifd = KExifGpsIfd;

   888 	

   889 	return iExifRead->GetParam8(tag, ifd, aParam);

   890 	}

   891 

   892 /**

   893 Gets the gps north or south latitude tag value of the metadata. 

   894 

   895 @param aParam

   896 	on return, the gps north or south latitude.

   897 	

   898 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   899 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   900 	

   901 @return error code

   902 	KErrArgument if the requested data type does not match with the tag.

   903 	KErrNotSupported if called on an encoding module.

   904 	KErrNotFound if the tag cannot be found.

   905 	KErrOverflow if there is an internal error with the Exif metadata.

   906 */

   907 EXPORT_C TInt TExifReaderUtility::GetGpsLatitudeRef(HBufC8*& aParam) const

   908 	{

   909 	if(iExifRead==NULL)

   910 		{

   911 		return KErrOverflow;

   912 		}

   913 	TInt tag = KTagGPS0001[ETagValue];

   914 	 

   915 	// We need to specify GPS sub IFD using the upper 16 bits.

   916 	TUint ifd = KExifGpsIfd;

   917 	

   918 	return iExifRead->GetParam8(tag, ifd, aParam);

   919 	}

   920 

   921 /**

   922 Gets the gps latitude tag value of the metadata. 

   923 

   924 @param aDegNumerator

   925 	on return, the degrees latitude numerator value.

   926 		

   927 @param aDegDenominator

   928 	on return, the degrees latitude denominator value.

   929 		

   930 @param aMinNumerator

   931 	on return, the minutes latitude numerator value.

   932 		

   933 @param aMinDenominator

   934 	on return, the minutes latitude denominator value.

   935 		

   936 @param aSecNumerator

   937 	on return, the seconds latitude numerator value.

   938 		

   939 @param aSecDenominator

   940 	on return, the seconds latitude denominator value.

   941 			

   942 @return error code

   943 	KErrArgument if the requested data type does not match with the tag.

   944 	KErrNotSupported if called on an encoding module.

   945 	KErrNotFound if the tag cannot be found.

   946 	KErrOverflow if there is an internal error with the Exif metadata.

   947 	KErrNoMemory if there was not enough memory available to complete the request.

   948 	KErrCorrupt if the gps latitude tag value of the metadata is corrupt. 

   949 */

   950 EXPORT_C TInt TExifReaderUtility::GetGpsLatitude(TInt& aDegNumerator, TInt& aDegDenominator, TInt& aMinNumerator, TInt& aMinDenominator, TInt& aSecNumerator, TInt& aSecDenominator) const

   951 	{

   952 	if(iExifRead==NULL)

   953 		{

   954 		return KErrOverflow;

   955 		}

   956 	TInt tag = KTagGPS0002[ETagValue];

   957 	TInt count = KTagGPS0002[EComponentCountValue];

   958 	

   959 	// We need to specify GPS sub IFD using the upper 16 bits.

   960 	TUint ifd = KExifGpsIfd;

   961 

   962 	CArrayFixFlat<TRational>* param = new CArrayFixFlat<TRational>(count);

   963 	if (param == NULL)

   964 		{

   965 		return KErrNoMemory;

   966 		}

   967 

   968 	TInt result = iExifRead->GetRationalArrayParam(tag, ifd, *param);

   969 	if (result==KErrNone)

   970 		{

   971 		if(param->Count()!=count)

   972 			{

   973 			result=KErrCorrupt;

   974 			}

   975 		else

   976 			{

   977 			aDegNumerator = param->At(0).iNumerator;

   978 			aDegDenominator = param->At(0).iDenominator;

   979 			aMinNumerator = param->At(1).iNumerator;

   980 			aMinDenominator = param->At(1).iDenominator;

   981 			aSecNumerator = param->At(2).iNumerator;

   982 			aSecDenominator = param->At(2).iDenominator;

   983 			}

   984 		}		

   985 

   986 	delete param;

   987 	return result;

   988 	}

   989 

   990 /**

   991 Gets the gps east or west longitude tag value of the metadata. 

   992 

   993 @param aParam

   994 	on return, the gps east or west longitude.

   995 	

   996 	Ownership of the buffer pointed to by aParam transfers to the client, which is therefore responsible for deleting the buffer when required. 

   997 	Note: The client should always initialise aParam to NULL, and the plugin should only assign to this parameter when ready to transfer ownership.

   998 	

   999 @return error code

  1000 	KErrArgument if the requested data type does not match with the tag.

  1001 	KErrNotSupported if called on an encoding module.

  1002 	KErrNotFound if the tag cannot be found.

  1003 	KErrOverflow if there is an internal error with the Exif metadata.

  1004 */

  1005 EXPORT_C TInt TExifReaderUtility::GetGpsLongitudeRef(HBufC8*& aParam) const

  1006 	{

  1007 	if(iExifRead==NULL)

  1008 		{

  1009 		return KErrOverflow;

  1010 		}

  1011 	TInt tag = KTagGPS0003[ETagValue];

  1012 

  1013 	// We need to specify GPS sub IFD using the upper 16 bits.

  1014 	TUint ifd = KExifGpsIfd;

  1015 	

  1016 	return iExifRead->GetParam8(tag, ifd, aParam);

  1017 	}

  1018 

  1019 /**

  1020 Gets the gps longitude tag value of the metadata. 

  1021 

  1022 @param aDegNumerator

  1023 	on return, the degrees longitude numerator value.

  1024 		

  1025 @param aDegDenominator

  1026 	on return, the degrees longitude denominator value.

  1027 	

  1028 @param aMinNumerator

  1029 	on return, the minutes longitude numerator value.

  1030 	

  1031 @param aMinDenominator

  1032 	on return, the minutes longitude denominator value.

  1033 	

  1034 @param aSecNumerator

  1035 	on return, the seconds longitude numerator value.

  1036 

  1037 @param aSecDenominator

  1038 	on return, the seconds longitude denominator value.

  1039 		

  1040 @return error code

  1041 	KErrArgument if the requested data type does not match with the tag.

  1042 	KErrNotSupported if called on an encoding module.

  1043 	KErrNotFound if the tag cannot be found.

  1044 	KErrOverflow if there is an internal error with the Exif metadata.

  1045 	KErrNoMemory if there was not enough memory available to complete the request.

  1046 	KErrCorrupt if the gps longitude tag value of the metadata is corrupt. 

  1047 */

  1048 EXPORT_C TInt TExifReaderUtility::GetGpsLongitude(TInt& aDegNumerator, TInt& aDegDenominator, TInt& aMinNumerator, TInt& aMinDenominator, TInt& aSecNumerator, TInt& aSecDenominator) const

  1049 	{

  1050 	if(iExifRead==NULL)

  1051 		{

  1052 		return KErrOverflow;

  1053 		}

  1054 	TInt tag = KTagGPS0004[ETagValue];

  1055 	TInt count = KTagGPS0004[EComponentCountValue];

  1056 

  1057 	// We need to specify GPS sub IFD using the upper 16 bits.

  1058 	TUint ifd = KExifGpsIfd;

  1059 

  1060 	CArrayFixFlat<TRational>* param = new CArrayFixFlat<TRational>(count);

  1061 	if (param == NULL)

  1062 		{

  1063 		return KErrNoMemory;

  1064 		}

  1065 

  1066 	TInt result = iExifRead->GetRationalArrayParam(tag, ifd, *param);

  1067 	if (result==KErrNone)

  1068 		{

  1069 		if(param->Count()!=count)

  1070 			{

  1071 			result=KErrCorrupt;

  1072 			}

  1073 		else

  1074 			{

  1075 			aDegNumerator = param->At(0).iNumerator;

  1076 			aDegDenominator = param->At(0).iDenominator;

  1077 			aMinNumerator = param->At(1).iNumerator;

  1078 			aMinDenominator = param->At(1).iDenominator;

  1079 			aSecNumerator = param->At(2).iNumerator;

  1080 			aSecDenominator = param->At(2).iDenominator;

  1081 			}

  1082 		}		

  1083 

  1084 	delete param;

  1085 	return result;

  1086 	}

  1087 

  1088 /**

  1089 Gets the gps altitude reference tag value of the metadata. 

  1090 

  1091 @param aParam

  1092 	on return, the gps altitude reference.

  1093 	

  1094 @return error code

  1095 	KErrArgument if the requested data type does not match with the tag.

  1096 	KErrNotSupported if called on an encoding module.

  1097 	KErrNotFound if the tag cannot be found.

  1098 	KErrOverflow if there is an internal error with the Exif metadata.

  1099 	KErrNoMemory if there was not enough memory available to complete the request.

  1100 */

  1101 EXPORT_C TInt TExifReaderUtility::GetGpsAltitudeRef(TUint8& aParam) const

  1102 	{

  1103 	if(iExifRead==NULL)

  1104 		{

  1105 		return KErrOverflow;

  1106 		}

  1107 	TInt tag = KTagGPS0005[ETagValue];

  1108 	TInt count = KTagGPS0005[EComponentCountValue];

  1109 	

  1110 	// We need to specify GPS sub IFD using the upper 16 bits.

  1111 	TUint ifd = KExifGpsIfd;

  1112 	

  1113 	HBufC8* data = NULL;

  1114 	TRAPD(err, data=HBufC8::NewL(count));

  1115 	if (err!=KErrNone)

  1116 		{

  1117 		return KErrNoMemory;

  1118 		}

  1119 	TInt result = iExifRead->GetParam8(tag, ifd, data);

  1120 	if (result==KErrNone)

  1121 		{

  1122 		aParam = static_cast<TUint8>((*data)[0]);

  1123 		}

  1124 	delete data;

  1125 	return result;

  1126 	}

  1127 	

  1128 /**

  1129 Gets the gps altitude tag value of the metadata. 

  1130 

  1131 @param aNumerator

  1132 	on return, the gps altitude numerator value.

  1133 		

  1134 @param aDenominator

  1135 	on return, the gps altitude denominator value.