1/* exif-entry.c 2 * 3 * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net> 4 * 5 * This library is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU Lesser General Public 7 * License as published by the Free Software Foundation; either 8 * version 2 of the License, or (at your option) any later version. 9 * 10 * This library is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public 16 * License along with this library; if not, write to the 17 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 18 * Boston, MA 02110-1301 USA. 19 */ 20 21#include <config.h> 22 23#include <libexif/exif-entry.h> 24#include <libexif/exif-ifd.h> 25#include <libexif/exif-utils.h> 26#include <libexif/i18n.h> 27 28#include <ctype.h> 29#include <stdlib.h> 30#include <stdio.h> 31#include <string.h> 32#include <time.h> 33#include <math.h> 34 35#ifndef M_PI 36#define M_PI 3.14159265358979323846 37#endif 38 39struct _ExifEntryPrivate 40{ 41 unsigned int ref_count; 42 43 ExifMem *mem; 44}; 45 46/* This function is hidden in exif-data.c */ 47ExifLog *exif_data_get_log (ExifData *); 48 49#ifndef NO_VERBOSE_TAG_STRINGS 50static void 51exif_entry_log (ExifEntry *e, ExifLogCode code, const char *format, ...) 52{ 53 va_list args; 54 ExifLog *l = NULL; 55 56 if (e && e->parent && e->parent->parent) 57 l = exif_data_get_log (e->parent->parent); 58 va_start (args, format); 59 exif_logv (l, code, "ExifEntry", format, args); 60 va_end (args); 61} 62#else 63#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 64#define exif_entry_log(...) do { } while (0) 65#elif defined(__GNUC__) 66#define exif_entry_log(x...) do { } while (0) 67#else 68#define exif_entry_log (void) 69#endif 70#endif 71 72static void * 73exif_entry_alloc (ExifEntry *e, unsigned int i) 74{ 75 void *d; 76 ExifLog *l = NULL; 77 78 if (!e || !e->priv || !i) return NULL; 79 80 d = exif_mem_alloc (e->priv->mem, i); 81 if (d) return d; 82 83 if (e->parent && e->parent->parent) 84 l = exif_data_get_log (e->parent->parent); 85 EXIF_LOG_NO_MEMORY (l, "ExifEntry", i); 86 return NULL; 87} 88 89static void * 90exif_entry_realloc (ExifEntry *e, void *d_orig, unsigned int i) 91{ 92 void *d; 93 ExifLog *l = NULL; 94 95 if (!e || !e->priv) return NULL; 96 97 if (!i) { exif_mem_free (e->priv->mem, d_orig); return NULL; } 98 99 d = exif_mem_realloc (e->priv->mem, d_orig, i); 100 if (d) return d; 101 102 if (e->parent && e->parent->parent) 103 l = exif_data_get_log (e->parent->parent); 104 EXIF_LOG_NO_MEMORY (l, "ExifEntry", i); 105 return NULL; 106} 107 108ExifEntry * 109exif_entry_new (void) 110{ 111 ExifMem *mem = exif_mem_new_default (); 112 ExifEntry *e = exif_entry_new_mem (mem); 113 114 exif_mem_unref (mem); 115 116 return e; 117} 118 119ExifEntry * 120exif_entry_new_mem (ExifMem *mem) 121{ 122 ExifEntry *e = NULL; 123 124 e = exif_mem_alloc (mem, sizeof (ExifEntry)); 125 if (!e) return NULL; 126 e->priv = exif_mem_alloc (mem, sizeof (ExifEntryPrivate)); 127 if (!e->priv) { exif_mem_free (mem, e); return NULL; } 128 e->priv->ref_count = 1; 129 130 e->priv->mem = mem; 131 exif_mem_ref (mem); 132 133 return e; 134} 135 136void 137exif_entry_ref (ExifEntry *e) 138{ 139 if (!e) return; 140 141 e->priv->ref_count++; 142} 143 144void 145exif_entry_unref (ExifEntry *e) 146{ 147 if (!e) return; 148 149 e->priv->ref_count--; 150 if (!e->priv->ref_count) 151 exif_entry_free (e); 152} 153 154void 155exif_entry_free (ExifEntry *e) 156{ 157 if (!e) return; 158 159 if (e->priv) { 160 ExifMem *mem = e->priv->mem; 161 if (e->data) 162 exif_mem_free (mem, e->data); 163 exif_mem_free (mem, e->priv); 164 exif_mem_free (mem, e); 165 exif_mem_unref (mem); 166 } 167} 168 169/*! Get a value and convert it to an ExifShort. 170 * \bug Not all types are converted that could be converted and no indication 171 * is made when that occurs 172 */ 173static inline ExifShort 174exif_get_short_convert (const unsigned char *buf, ExifFormat format, 175 ExifByteOrder order) 176{ 177 switch (format) { 178 case EXIF_FORMAT_LONG: 179 return (ExifShort) exif_get_long (buf, order); 180 case EXIF_FORMAT_SLONG: 181 return (ExifShort) exif_get_slong (buf, order); 182 case EXIF_FORMAT_SHORT: 183 return (ExifShort) exif_get_short (buf, order); 184 case EXIF_FORMAT_SSHORT: 185 return (ExifShort) exif_get_sshort (buf, order); 186 case EXIF_FORMAT_BYTE: 187 case EXIF_FORMAT_SBYTE: 188 return (ExifShort) buf[0]; 189 default: 190 /* Unsupported type */ 191 return (ExifShort) 0; 192 } 193} 194 195void 196exif_entry_fix (ExifEntry *e) 197{ 198 unsigned int i, newsize; 199 unsigned char *newdata; 200 ExifByteOrder o; 201 ExifRational r; 202 ExifSRational sr; 203 204 if (!e || !e->priv) return; 205 206 switch (e->tag) { 207 208 /* These tags all need to be of format SHORT. */ 209 case EXIF_TAG_YCBCR_SUB_SAMPLING: 210 case EXIF_TAG_SUBJECT_AREA: 211 case EXIF_TAG_COLOR_SPACE: 212 case EXIF_TAG_PLANAR_CONFIGURATION: 213 case EXIF_TAG_SENSING_METHOD: 214 case EXIF_TAG_ORIENTATION: 215 case EXIF_TAG_YCBCR_POSITIONING: 216 case EXIF_TAG_PHOTOMETRIC_INTERPRETATION: 217 case EXIF_TAG_CUSTOM_RENDERED: 218 case EXIF_TAG_EXPOSURE_MODE: 219 case EXIF_TAG_WHITE_BALANCE: 220 case EXIF_TAG_SCENE_CAPTURE_TYPE: 221 case EXIF_TAG_GAIN_CONTROL: 222 case EXIF_TAG_SATURATION: 223 case EXIF_TAG_CONTRAST: 224 case EXIF_TAG_SHARPNESS: 225 case EXIF_TAG_ISO_SPEED_RATINGS: 226 switch (e->format) { 227 case EXIF_FORMAT_LONG: 228 case EXIF_FORMAT_SLONG: 229 case EXIF_FORMAT_BYTE: 230 case EXIF_FORMAT_SBYTE: 231 case EXIF_FORMAT_SSHORT: 232 if (!e->parent || !e->parent->parent) break; 233 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 234 _("Tag '%s' was of format '%s' (which is " 235 "against specification) and has been " 236 "changed to format '%s'."), 237 exif_tag_get_name_in_ifd(e->tag, 238 exif_entry_get_ifd(e)), 239 exif_format_get_name (e->format), 240 exif_format_get_name (EXIF_FORMAT_SHORT)); 241 242 o = exif_data_get_byte_order (e->parent->parent); 243 newsize = e->components * exif_format_get_size (EXIF_FORMAT_SHORT); 244 newdata = exif_entry_alloc (e, newsize); 245 if (!newdata) { 246 exif_entry_log (e, EXIF_LOG_CODE_NO_MEMORY, 247 "Could not allocate %lu byte(s).", (unsigned long)newsize); 248 break; 249 } 250 251 for (i = 0; i < e->components; i++) 252 exif_set_short ( 253 newdata + i * 254 exif_format_get_size ( 255 EXIF_FORMAT_SHORT), o, 256 exif_get_short_convert ( 257 e->data + i * 258 exif_format_get_size (e->format), 259 e->format, o)); 260 261 exif_mem_free (e->priv->mem, e->data); 262 e->data = newdata; 263 e->size = newsize; 264 e->format = EXIF_FORMAT_SHORT; 265 break; 266 case EXIF_FORMAT_SHORT: 267 /* No conversion necessary */ 268 break; 269 default: 270 exif_entry_log (e, EXIF_LOG_CODE_CORRUPT_DATA, 271 _("Tag '%s' is of format '%s' (which is " 272 "against specification) but cannot be changed " 273 "to format '%s'."), 274 exif_tag_get_name_in_ifd(e->tag, 275 exif_entry_get_ifd(e)), 276 exif_format_get_name (e->format), 277 exif_format_get_name (EXIF_FORMAT_SHORT)); 278 break; 279 } 280 break; 281 282 /* All these tags need to be of format 'Rational'. */ 283 case EXIF_TAG_FNUMBER: 284 case EXIF_TAG_APERTURE_VALUE: 285 case EXIF_TAG_EXPOSURE_TIME: 286 case EXIF_TAG_FOCAL_LENGTH: 287 switch (e->format) { 288 case EXIF_FORMAT_SRATIONAL: 289 if (!e->parent || !e->parent->parent) break; 290 o = exif_data_get_byte_order (e->parent->parent); 291 for (i = 0; i < e->components; i++) { 292 sr = exif_get_srational (e->data + i * 293 exif_format_get_size ( 294 EXIF_FORMAT_SRATIONAL), o); 295 r.numerator = (ExifLong) sr.numerator; 296 r.denominator = (ExifLong) sr.denominator; 297 exif_set_rational (e->data + i * 298 exif_format_get_size ( 299 EXIF_FORMAT_RATIONAL), o, r); 300 } 301 e->format = EXIF_FORMAT_RATIONAL; 302 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 303 _("Tag '%s' was of format '%s' (which is " 304 "against specification) and has been " 305 "changed to format '%s'."), 306 exif_tag_get_name_in_ifd(e->tag, 307 exif_entry_get_ifd(e)), 308 exif_format_get_name (EXIF_FORMAT_SRATIONAL), 309 exif_format_get_name (EXIF_FORMAT_RATIONAL)); 310 break; 311 default: 312 break; 313 } 314 break; 315 316 /* All these tags need to be of format 'SRational'. */ 317 case EXIF_TAG_EXPOSURE_BIAS_VALUE: 318 case EXIF_TAG_BRIGHTNESS_VALUE: 319 case EXIF_TAG_SHUTTER_SPEED_VALUE: 320 switch (e->format) { 321 case EXIF_FORMAT_RATIONAL: 322 if (!e->parent || !e->parent->parent) break; 323 o = exif_data_get_byte_order (e->parent->parent); 324 for (i = 0; i < e->components; i++) { 325 r = exif_get_rational (e->data + i * 326 exif_format_get_size ( 327 EXIF_FORMAT_RATIONAL), o); 328 sr.numerator = (ExifLong) r.numerator; 329 sr.denominator = (ExifLong) r.denominator; 330 exif_set_srational (e->data + i * 331 exif_format_get_size ( 332 EXIF_FORMAT_SRATIONAL), o, sr); 333 } 334 e->format = EXIF_FORMAT_SRATIONAL; 335 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 336 _("Tag '%s' was of format '%s' (which is " 337 "against specification) and has been " 338 "changed to format '%s'."), 339 exif_tag_get_name_in_ifd(e->tag, 340 exif_entry_get_ifd(e)), 341 exif_format_get_name (EXIF_FORMAT_RATIONAL), 342 exif_format_get_name (EXIF_FORMAT_SRATIONAL)); 343 break; 344 default: 345 break; 346 } 347 break; 348 349 case EXIF_TAG_USER_COMMENT: 350 351 /* Format needs to be UNDEFINED. */ 352 if (e->format != EXIF_FORMAT_UNDEFINED) { 353 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 354 _("Tag 'UserComment' had invalid format '%s'. " 355 "Format has been set to 'undefined'."), 356 exif_format_get_name (e->format)); 357 e->format = EXIF_FORMAT_UNDEFINED; 358 } 359 360 /* Some packages like Canon ZoomBrowser EX 4.5 store 361 only one zero byte followed by 7 bytes of rubbish */ 362 if ((e->size >= 8) && (e->data[0] == 0)) { 363 memcpy(e->data, "\0\0\0\0\0\0\0\0", 8); 364 } 365 366 /* There need to be at least 8 bytes. */ 367 if (e->size < 8) { 368 e->data = exif_entry_realloc (e, e->data, 8 + e->size); 369 if (!e->data) { 370 e->size = 0; 371 e->components = 0; 372 return; 373 } 374 375 /* Assume ASCII */ 376 memmove (e->data + 8, e->data, e->size); 377 memcpy (e->data, "ASCII\0\0\0", 8); 378 e->size += 8; 379 e->components += 8; 380 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 381 _("Tag 'UserComment' has been expanded to at " 382 "least 8 bytes in order to follow the " 383 "specification.")); 384 break; 385 } 386 387 /* 388 * If the first 8 bytes are empty and real data starts 389 * afterwards, let's assume ASCII and claim the 8 first 390 * bytes for the format specifyer. 391 */ 392 for (i = 0; (i < e->size) && !e->data[i]; i++); 393 if (!i) for ( ; (i < e->size) && (e->data[i] == ' '); i++); 394 if ((i >= 8) && (i < e->size)) { 395 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 396 _("Tag 'UserComment' is not empty but does not " 397 "start with a format identifier. " 398 "This has been fixed.")); 399 memcpy (e->data, "ASCII\0\0\0", 8); 400 break; 401 } 402 403 /* 404 * First 8 bytes need to follow the specification. If they don't, 405 * assume ASCII. 406 */ 407 if (memcmp (e->data, "ASCII\0\0\0" , 8) && 408 memcmp (e->data, "UNICODE\0" , 8) && 409 memcmp (e->data, "JIS\0\0\0\0\0" , 8) && 410 memcmp (e->data, "\0\0\0\0\0\0\0\0", 8)) { 411 e->data = exif_entry_realloc (e, e->data, 8 + e->size); 412 if (!e->data) { 413 e->size = 0; 414 e->components = 0; 415 break; 416 } 417 418 /* Assume ASCII */ 419 memmove (e->data + 8, e->data, e->size); 420 memcpy (e->data, "ASCII\0\0\0", 8); 421 e->size += 8; 422 e->components += 8; 423 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 424 _("Tag 'UserComment' did not start with a " 425 "format identifier. This has been fixed.")); 426 break; 427 } 428 429 break; 430 default: 431 break; 432 } 433} 434 435/*! Format the value of an ExifEntry for human display in a generic way. 436 * The output is localized. The formatting is independent of the tag number. 437 * \pre The buffer at val is entirely cleared to 0. This guarantees that the 438 * resulting string will be NUL terminated. 439 * \pre The ExifEntry is already a member of an ExifData. 440 * \param[in] e EXIF entry 441 * \param[out] val buffer in which to store value 442 * \param[in] maxlen one less than the length of the buffer val 443 */ 444static void 445exif_entry_format_value(ExifEntry *e, char *val, size_t maxlen) 446{ 447 ExifByte v_byte; 448 ExifShort v_short; 449 ExifSShort v_sshort; 450 ExifLong v_long; 451 ExifRational v_rat; 452 ExifSRational v_srat; 453 ExifSLong v_slong; 454 char b[64]; 455 unsigned int i; 456 const ExifByteOrder o = exif_data_get_byte_order (e->parent->parent); 457 458 if (!e->size) 459 return; 460 switch (e->format) { 461 case EXIF_FORMAT_UNDEFINED: 462 snprintf (val, maxlen, _("%i bytes undefined data"), e->size); 463 break; 464 case EXIF_FORMAT_BYTE: 465 case EXIF_FORMAT_SBYTE: 466 v_byte = e->data[0]; 467 snprintf (val, maxlen, "0x%02x", v_byte); 468 maxlen -= strlen (val); 469 for (i = 1; i < e->components; i++) { 470 v_byte = e->data[i]; 471 snprintf (b, sizeof (b), ", 0x%02x", v_byte); 472 strncat (val, b, maxlen); 473 maxlen -= strlen (b); 474 if ((signed)maxlen <= 0) break; 475 } 476 break; 477 case EXIF_FORMAT_SHORT: 478 v_short = exif_get_short (e->data, o); 479 snprintf (val, maxlen, "%u", v_short); 480 maxlen -= strlen (val); 481 for (i = 1; i < e->components; i++) { 482 v_short = exif_get_short (e->data + 483 exif_format_get_size (e->format) * i, o); 484 snprintf (b, sizeof (b), ", %u", v_short); 485 strncat (val, b, maxlen); 486 maxlen -= strlen (b); 487 if ((signed)maxlen <= 0) break; 488 } 489 break; 490 case EXIF_FORMAT_SSHORT: 491 v_sshort = exif_get_sshort (e->data, o); 492 snprintf (val, maxlen, "%i", v_sshort); 493 maxlen -= strlen (val); 494 for (i = 1; i < e->components; i++) { 495 v_sshort = exif_get_short (e->data + 496 exif_format_get_size (e->format) * 497 i, o); 498 snprintf (b, sizeof (b), ", %i", v_sshort); 499 strncat (val, b, maxlen); 500 maxlen -= strlen (b); 501 if ((signed)maxlen <= 0) break; 502 } 503 break; 504 case EXIF_FORMAT_LONG: 505 v_long = exif_get_long (e->data, o); 506 snprintf (val, maxlen, "%lu", (long int) v_long); 507 maxlen -= strlen (val); 508 for (i = 1; i < e->components; i++) { 509 v_long = exif_get_long (e->data + 510 exif_format_get_size (e->format) * 511 i, o); 512 snprintf (b, sizeof (b), ", %lu", (long int) v_long); 513 strncat (val, b, maxlen); 514 maxlen -= strlen (b); 515 if ((signed)maxlen <= 0) break; 516 } 517 break; 518 case EXIF_FORMAT_SLONG: 519 v_slong = exif_get_slong (e->data, o); 520 snprintf (val, maxlen, "%li", (long) v_slong); 521 maxlen -= strlen (val); 522 for (i = 1; i < e->components; i++) { 523 v_slong = exif_get_slong (e->data + 524 exif_format_get_size (e->format) * i, o); 525 snprintf (b, sizeof (b), ", %li", (long) v_slong); 526 strncat (val, b, maxlen); 527 maxlen -= strlen (b); 528 if ((signed)maxlen <= 0) break; 529 } 530 break; 531 case EXIF_FORMAT_ASCII: 532 strncpy (val, (char *) e->data, MIN (maxlen, e->size)); 533 break; 534 case EXIF_FORMAT_RATIONAL: 535 v_rat = exif_get_rational (e->data, o); 536 if (v_rat.denominator) 537 snprintf (val, maxlen, "%2.2lf", 538 (double) v_rat.numerator / 539 (double) v_rat.denominator); 540 else 541 snprintf (val, maxlen, "%lu/%lu", 542 (unsigned long) v_rat.numerator, 543 (unsigned long) v_rat.denominator); 544 maxlen -= strlen (val); 545 for (i = 1; i < e->components; i++) { 546 v_rat = exif_get_rational ( 547 e->data + 8 * i, o); 548 if (v_rat.denominator) 549 snprintf (b, sizeof (b), ", %2.2lf", 550 (double) v_rat.numerator / 551 (double) v_rat.denominator); 552 else 553 snprintf (b, sizeof (b), ", %lu/%lu", 554 (unsigned long) v_rat.numerator, 555 (unsigned long) v_rat.denominator); 556 strncat (val, b, maxlen); 557 maxlen -= strlen (b); 558 if ((signed) maxlen <= 0) break; 559 } 560 break; 561 case EXIF_FORMAT_SRATIONAL: 562 v_srat = exif_get_srational (e->data, o); 563 if (v_srat.denominator) { 564 snprintf (val, maxlen, "%2.2f", 565 (double)v_srat.numerator / v_srat.denominator); 566 } else { 567 snprintf (val, maxlen, "%li/%li", 568 (long) v_srat.numerator, 569 (long) v_srat.denominator); 570 } 571 maxlen -= strlen (val); 572 for (i = 1; i < e->components; i++) { 573 v_srat = exif_get_srational ( 574 e->data + 8 * i, o); 575 if (v_srat.denominator) 576 snprintf (b, sizeof (b), ", %2.2f", 577 (double)v_srat.numerator / v_srat.denominator); 578 else 579 snprintf (b, sizeof (b), ", %li/%li", 580 (long) v_srat.numerator, 581 (long) v_srat.denominator); 582 strncat (val, b, maxlen); 583 maxlen -= strlen (b); 584 if ((signed) maxlen <= 0) break; 585 } 586 break; 587 case EXIF_FORMAT_DOUBLE: 588 case EXIF_FORMAT_FLOAT: 589 default: 590 snprintf (val, maxlen, _("%i bytes unsupported data type"), 591 e->size); 592 break; 593 } 594} 595 596void 597exif_entry_dump (ExifEntry *e, unsigned int indent) 598{ 599 char buf[1024]; 600 char value[1024]; 601 unsigned int i; 602 603 for (i = 0; i < 2 * indent; i++) 604 buf[i] = ' '; 605 buf[i] = '\0'; 606 607 if (!e) 608 return; 609 610 printf ("%sTag: 0x%x ('%s')\n", buf, e->tag, 611 exif_tag_get_name (e->tag)); 612 printf ("%s Format: %i ('%s')\n", buf, e->format, 613 exif_format_get_name (e->format)); 614 printf ("%s Components: %i\n", buf, (int) e->components); 615 printf ("%s Size: %i\n", buf, e->size); 616 printf ("%s Value: %s\n", buf, exif_entry_get_value (e, value, sizeof(value))); 617} 618 619#define CF(entry,target,v,maxlen) \ 620{ \ 621 if (entry->format != target) { \ 622 exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA, \ 623 _("The tag '%s' contains data of an invalid " \ 624 "format ('%s', expected '%s')."), \ 625 exif_tag_get_name (entry->tag), \ 626 exif_format_get_name (entry->format), \ 627 exif_format_get_name (target)); \ 628 break; \ 629 } \ 630} 631 632#define CC(entry,target,v,maxlen) \ 633{ \ 634 if (entry->components != target) { \ 635 exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA, \ 636 _("The tag '%s' contains an invalid number of " \ 637 "components (%i, expected %i)."), \ 638 exif_tag_get_name (entry->tag), \ 639 (int) entry->components, (int) target); \ 640 break; \ 641 } \ 642} 643 644static const struct { 645 ExifTag tag; 646 const char *strings[10]; 647} list[] = { 648#ifndef NO_VERBOSE_TAG_DATA 649 { EXIF_TAG_PLANAR_CONFIGURATION, 650 { N_("chunky format"), N_("planar format"), NULL}}, 651 { EXIF_TAG_SENSING_METHOD, 652 { "", N_("Not defined"), N_("One-chip color area sensor"), 653 N_("Two-chip color area sensor"), N_("Three-chip color area sensor"), 654 N_("Color sequential area sensor"), "", N_("Trilinear sensor"), 655 N_("Color sequential linear sensor"), NULL}}, 656 { EXIF_TAG_ORIENTATION, 657 { "", N_("top - left"), N_("top - right"), N_("bottom - right"), 658 N_("bottom - left"), N_("left - top"), N_("right - top"), 659 N_("right - bottom"), N_("left - bottom"), NULL}}, 660 { EXIF_TAG_YCBCR_POSITIONING, 661 { "", N_("centered"), N_("co-sited"), NULL}}, 662 { EXIF_TAG_PHOTOMETRIC_INTERPRETATION, 663 { N_("Reversed mono"), N_("Normal mono"), N_("RGB"), N_("Palette"), "", 664 N_("CMYK"), N_("YCbCr"), "", N_("CieLAB"), NULL}}, 665 { EXIF_TAG_CUSTOM_RENDERED, 666 { N_("Normal process"), N_("Custom process"), NULL}}, 667 { EXIF_TAG_EXPOSURE_MODE, 668 { N_("Auto exposure"), N_("Manual exposure"), N_("Auto bracket"), NULL}}, 669 { EXIF_TAG_WHITE_BALANCE, 670 { N_("Auto white balance"), N_("Manual white balance"), NULL}}, 671 { EXIF_TAG_SCENE_CAPTURE_TYPE, 672 { N_("Standard"), N_("Landscape"), N_("Portrait"), 673 N_("Night scene"), NULL}}, 674 { EXIF_TAG_GAIN_CONTROL, 675 { N_("Normal"), N_("Low gain up"), N_("High gain up"), 676 N_("Low gain down"), N_("High gain down"), NULL}}, 677 { EXIF_TAG_SATURATION, 678 { N_("Normal"), N_("Low saturation"), N_("High saturation"), NULL}}, 679 { EXIF_TAG_CONTRAST , {N_("Normal"), N_("Soft"), N_("Hard"), NULL}}, 680 { EXIF_TAG_SHARPNESS, {N_("Normal"), N_("Soft"), N_("Hard"), NULL}}, 681#endif 682 { 0, {NULL}} 683}; 684 685static const struct { 686 ExifTag tag; 687 struct { 688 int index; 689 const char *values[4]; 690 } elem[25]; 691} list2[] = { 692#ifndef NO_VERBOSE_TAG_DATA 693 { EXIF_TAG_METERING_MODE, 694 { { 0, {N_("Unknown"), NULL}}, 695 { 1, {N_("Average"), N_("avg"), NULL}}, 696 { 2, {N_("Center-Weighted Average"), N_("Center-Weight"), NULL}}, 697 { 3, {N_("Spot"), NULL}}, 698 { 4, {N_("Multi Spot"), NULL}}, 699 { 5, {N_("Pattern"), NULL}}, 700 { 6, {N_("Partial"), NULL}}, 701 {255, {N_("Other"), NULL}}, 702 { 0, {NULL}}}}, 703 { EXIF_TAG_COMPRESSION, 704 { {1, {N_("Uncompressed"), NULL}}, 705 {5, {N_("LZW compression"), NULL}}, 706 {6, {N_("JPEG compression"), NULL}}, 707 {7, {N_("JPEG compression"), NULL}}, 708 {8, {N_("Deflate/ZIP compression"), NULL}}, 709 {32773, {N_("PackBits compression"), NULL}}, 710 {0, {NULL}}}}, 711 { EXIF_TAG_LIGHT_SOURCE, 712 { { 0, {N_("Unknown"), NULL}}, 713 { 1, {N_("Daylight"), NULL}}, 714 { 2, {N_("Fluorescent"), NULL}}, 715 { 3, {N_("Tungsten incandescent light"), N_("Tungsten"), NULL}}, 716 { 4, {N_("Flash"), NULL}}, 717 { 9, {N_("Fine weather"), NULL}}, 718 { 10, {N_("Cloudy weather"), N_("Cloudy"), NULL}}, 719 { 11, {N_("Shade"), NULL}}, 720 { 12, {N_("Daylight fluorescent"), NULL}}, 721 { 13, {N_("Day white fluorescent"), NULL}}, 722 { 14, {N_("Cool white fluorescent"), NULL}}, 723 { 15, {N_("White fluorescent"), NULL}}, 724 { 17, {N_("Standard light A"), NULL}}, 725 { 18, {N_("Standard light B"), NULL}}, 726 { 19, {N_("Standard light C"), NULL}}, 727 { 20, {N_("D55"), NULL}}, 728 { 21, {N_("D65"), NULL}}, 729 { 22, {N_("D75"), NULL}}, 730 { 24, {N_("ISO studio tungsten"),NULL}}, 731 {255, {N_("Other"), NULL}}, 732 { 0, {NULL}}}}, 733 { EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT, 734 { {2, {N_("Inch"), N_("in"), NULL}}, 735 {3, {N_("Centimeter"), N_("cm"), NULL}}, 736 {0, {NULL}}}}, 737 { EXIF_TAG_RESOLUTION_UNIT, 738 { {2, {N_("Inch"), N_("in"), NULL}}, 739 {3, {N_("Centimeter"), N_("cm"), NULL}}, 740 {0, {NULL}}}}, 741 { EXIF_TAG_EXPOSURE_PROGRAM, 742 { {0, {N_("Not defined"), NULL}}, 743 {1, {N_("Manual"), NULL}}, 744 {2, {N_("Normal program"), N_("Normal"), NULL}}, 745 {3, {N_("Aperture priority"), N_("Aperture"), NULL}}, 746 {4, {N_("Shutter priority"),N_("Shutter"), NULL}}, 747 {5, {N_("Creative program (biased toward depth of field)"), 748 N_("Creative"), NULL}}, 749 {6, {N_("Creative program (biased toward fast shutter speed)"), 750 N_("Action"), NULL}}, 751 {7, {N_("Portrait mode (for closeup photos with the background out " 752 "of focus)"), N_("Portrait"), NULL}}, 753 {8, {N_("Landscape mode (for landscape photos with the background " 754 "in focus)"), N_("Landscape"), NULL}}, 755 {0, {NULL}}}}, 756 { EXIF_TAG_FLASH, 757 { {0x0000, {N_("Flash did not fire"), N_("no flash"), NULL}}, 758 {0x0001, {N_("Flash fired"), N_("flash"), N_("Yes"), NULL}}, 759 {0x0005, {N_("Strobe return light not detected"), N_("W/o strobe"), 760 NULL}}, 761 {0x0007, {N_("Strobe return light detected"), N_("W. strobe"), NULL}}, 762 {0x0008, {N_("Flash did not fire"), NULL}}, /* Olympus E-330 */ 763 {0x0009, {N_("Flash fired, compulsory flash mode"), NULL}}, 764 {0x000d, {N_("Flash fired, compulsory flash mode, return light " 765 "not detected"), NULL}}, 766 {0x000f, {N_("Flash fired, compulsory flash mode, return light " 767 "detected"), NULL}}, 768 {0x0010, {N_("Flash did not fire, compulsory flash mode"), NULL}}, 769 {0x0018, {N_("Flash did not fire, auto mode"), NULL}}, 770 {0x0019, {N_("Flash fired, auto mode"), NULL}}, 771 {0x001d, {N_("Flash fired, auto mode, return light not detected"), 772 NULL}}, 773 {0x001f, {N_("Flash fired, auto mode, return light detected"), NULL}}, 774 {0x0020, {N_("No flash function"),NULL}}, 775 {0x0041, {N_("Flash fired, red-eye reduction mode"), NULL}}, 776 {0x0045, {N_("Flash fired, red-eye reduction mode, return light " 777 "not detected"), NULL}}, 778 {0x0047, {N_("Flash fired, red-eye reduction mode, return light " 779 "detected"), NULL}}, 780 {0x0049, {N_("Flash fired, compulsory flash mode, red-eye reduction " 781 "mode"), NULL}}, 782 {0x004d, {N_("Flash fired, compulsory flash mode, red-eye reduction " 783 "mode, return light not detected"), NULL}}, 784 {0x004f, {N_("Flash fired, compulsory flash mode, red-eye reduction mode, " 785 "return light detected"), NULL}}, 786 {0x0058, {N_("Flash did not fire, auto mode, red-eye reduction mode"), NULL}}, 787 {0x0059, {N_("Flash fired, auto mode, red-eye reduction mode"), NULL}}, 788 {0x005d, {N_("Flash fired, auto mode, return light not detected, " 789 "red-eye reduction mode"), NULL}}, 790 {0x005f, {N_("Flash fired, auto mode, return light detected, " 791 "red-eye reduction mode"), NULL}}, 792 {0x0000, {NULL}}}}, 793 { EXIF_TAG_SUBJECT_DISTANCE_RANGE, 794 { {0, {N_("Unknown"), N_("?"), NULL}}, 795 {1, {N_("Macro"), NULL}}, 796 {2, {N_("Close view"), N_("Close"), NULL}}, 797 {3, {N_("Distant view"), N_("Distant"), NULL}}, 798 {0, {NULL}}}}, 799 { EXIF_TAG_COLOR_SPACE, 800 { {1, {N_("sRGB"), NULL}}, 801 {2, {N_("Adobe RGB"), NULL}}, 802 {0xffff, {N_("Uncalibrated"), NULL}}, 803 {0x0000, {NULL}}}}, 804#endif 805 {0, { { 0, {NULL}}} } 806}; 807 808const char * 809exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen) 810{ 811 unsigned int i, j, k; 812 const unsigned char *t; 813 ExifShort v_short, v_short2, v_short3, v_short4; 814 ExifByte v_byte; 815 ExifRational v_rat; 816 ExifSRational v_srat; 817 char b[64]; 818 const char *c; 819 ExifByteOrder o; 820 double d; 821 ExifEntry *entry; 822 static const struct { 823 char label[5]; 824 char major, minor; 825 } versions[] = { 826 {"0110", 1, 1}, 827 {"0120", 1, 2}, 828 {"0200", 2, 0}, 829 {"0210", 2, 1}, 830 {"0220", 2, 2}, 831 {"0221", 2, 21}, 832 {"" , 0, 0} 833 }; 834 835 /* FIXME: This belongs to somewhere else. */ 836 /* libexif should use the default system locale. 837 * If an application specifically requires UTF-8, then we 838 * must give the application a way to tell libexif that. 839 * 840 * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); 841 */ 842 bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); 843 844 /* make sure the returned string is zero terminated */ 845 memset (val, 0, maxlen); 846 maxlen--; 847 memset (b, 0, sizeof (b)); 848 849 /* We need the byte order */ 850 if (!e || !e->parent || !e->parent->parent) 851 return val; 852 o = exif_data_get_byte_order (e->parent->parent); 853 854 /* Sanity check */ 855 if (e->size != e->components * exif_format_get_size (e->format)) { 856 snprintf (val, maxlen, _("Invalid size of entry (%i, " 857 "expected %li x %i)."), e->size, e->components, 858 exif_format_get_size (e->format)); 859 return val; 860 } 861 862 switch (e->tag) { 863 case EXIF_TAG_USER_COMMENT: 864 865 /* 866 * The specification says UNDEFINED, but some 867 * manufacturers don't care and use ASCII. If this is the 868 * case here, only refuse to read it if there is no chance 869 * of finding readable data. 870 */ 871 if ((e->format != EXIF_FORMAT_ASCII) || 872 (e->size <= 8) || 873 ( memcmp (e->data, "ASCII\0\0\0" , 8) && 874 memcmp (e->data, "UNICODE\0" , 8) && 875 memcmp (e->data, "JIS\0\0\0\0\0", 8) && 876 memcmp (e->data, "\0\0\0\0\0\0\0\0", 8))) 877 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen); 878 879 /* 880 * Note that, according to the specification (V2.1, p 40), 881 * the user comment field does not have to be 882 * NULL terminated. 883 */ 884 if ((e->size >= 8) && !memcmp (e->data, "ASCII\0\0\0", 8)) { 885 strncpy (val, (char *) e->data + 8, MIN (e->size - 8, maxlen)); 886 break; 887 } 888 if ((e->size >= 8) && !memcmp (e->data, "UNICODE\0", 8)) { 889 strncpy (val, _("Unsupported UNICODE string"), maxlen); 890 /* FIXME: use iconv to convert into the locale encoding. 891 * EXIF 2.2 implies (but does not say) that this encoding is 892 * UCS-2. 893 */ 894 break; 895 } 896 if ((e->size >= 8) && !memcmp (e->data, "JIS\0\0\0\0\0", 8)) { 897 strncpy (val, _("Unsupported JIS string"), maxlen); 898 /* FIXME: use iconv to convert into the locale encoding */ 899 break; 900 } 901 902 /* Check if there is really some information in the tag. */ 903 for (i = 0; (i < e->size) && 904 (!e->data[i] || (e->data[i] == ' ')); i++); 905 if (i == e->size) break; 906 907 /* 908 * If we reach this point, the tag does not 909 * comply with the standard and seems to contain data. 910 * Print as much as possible. 911 */ 912 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 913 _("Tag UserComment does not comply " 914 "with standard but contains data.")); 915 for (; (i < e->size) && (strlen (val) < maxlen - 1); i++) { 916 exif_entry_log (e, EXIF_LOG_CODE_DEBUG, 917 _("Byte at position %i: 0x%02x"), i, e->data[i]); 918 val[strlen (val)] = 919 isprint (e->data[i]) ? e->data[i] : '.'; 920 } 921 break; 922 923 case EXIF_TAG_EXIF_VERSION: 924 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen); 925 CC (e, 4, val, maxlen); 926 strncpy (val, _("Unknown Exif Version"), maxlen); 927 for (i = 0; *versions[i].label; i++) { 928 if (!memcmp (e->data, versions[i].label, 4)) { 929 snprintf (val, maxlen, 930 _("Exif Version %d.%d"), 931 versions[i].major, 932 versions[i].minor); 933 break; 934 } 935 } 936 break; 937 case EXIF_TAG_FLASH_PIX_VERSION: 938 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen); 939 CC (e, 4, val, maxlen); 940 if (!memcmp (e->data, "0100", 4)) 941 strncpy (val, _("FlashPix Version 1.0"), maxlen); 942 else if (!memcmp (e->data, "0101", 4)) 943 strncpy (val, _("FlashPix Version 1.01"), maxlen); 944 else 945 strncpy (val, _("Unknown FlashPix Version"), maxlen); 946 break; 947 case EXIF_TAG_COPYRIGHT: 948 CF (e, EXIF_FORMAT_ASCII, val, maxlen); 949 950 /* 951 * First part: Photographer. 952 * Some cameras store a string like " " here. Ignore it. 953 */ 954 if (e->size && e->data && 955 (strspn ((char *)e->data, " ") != strlen ((char *) e->data))) 956 strncpy (val, (char *) e->data, MIN (maxlen, e->size)); 957 else 958 strncpy (val, _("[None]"), maxlen); 959 strncat (val, " ", maxlen - strlen (val)); 960 strncat (val, _("(Photographer)"), maxlen - strlen (val)); 961 962 /* Second part: Editor. */ 963 strncat (val, " - ", maxlen - strlen (val)); 964 if (e->size && e->data) { 965 size_t ts; 966 t = e->data + strlen ((char *) e->data) + 1; 967 ts = e->data + e->size - t; 968 if ((ts > 0) && (strspn ((char *)t, " ") != ts)) 969 strncat (val, (char *)t, MIN (maxlen - strlen (val), ts)); 970 } else { 971 strncat (val, _("[None]"), maxlen - strlen (val)); 972 } 973 strncat (val, " ", maxlen - strlen (val)); 974 strncat (val, _("(Editor)"), maxlen - strlen (val)); 975 976 break; 977 case EXIF_TAG_FNUMBER: 978 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen); 979 CC (e, 1, val, maxlen); 980 v_rat = exif_get_rational (e->data, o); 981 if (!v_rat.denominator) { 982 exif_entry_format_value(e, val, maxlen); 983 break; 984 } 985 d = (double) v_rat.numerator / (double) v_rat.denominator; 986 snprintf (val, maxlen, "f/%.01lf", d); 987 break; 988 case EXIF_TAG_APERTURE_VALUE: 989 case EXIF_TAG_MAX_APERTURE_VALUE: 990 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen); 991 CC (e, 1, val, maxlen); 992 v_rat = exif_get_rational (e->data, o); 993 if (!v_rat.denominator) { 994 exif_entry_format_value(e, val, maxlen); 995 break; 996 } 997 d = (double) v_rat.numerator / (double) v_rat.denominator; 998 snprintf (val, maxlen, _("%.02lf EV"), d); 999 snprintf (b, sizeof (b), _(" (f/%.01f)"), pow (2, d / 2.)); 1000 if (maxlen > strlen (val) + strlen (b)) 1001 strncat (val, b, maxlen - strlen (val)); 1002 break; 1003 case EXIF_TAG_FOCAL_LENGTH: 1004 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen); 1005 CC (e, 1, val, maxlen); 1006 v_rat = exif_get_rational (e->data, o); 1007 if (!v_rat.denominator) { 1008 exif_entry_format_value(e, val, maxlen); 1009 break; 1010 } 1011 1012 /* 1013 * For calculation of the 35mm equivalent, 1014 * Minolta cameras need a multiplier that depends on the 1015 * camera model. 1016 */ 1017 d = 0.; 1018 entry = exif_content_get_entry ( 1019 e->parent->parent->ifd[EXIF_IFD_0], EXIF_TAG_MAKE); 1020 if (entry && entry->data && 1021 !strncmp ((char *)entry->data, "Minolta", 7)) { 1022 entry = exif_content_get_entry ( 1023 e->parent->parent->ifd[EXIF_IFD_0], 1024 EXIF_TAG_MODEL); 1025 if (entry && entry->data) { 1026 if (!strncmp ((char *)entry->data, "DiMAGE 7", 8)) 1027 d = 3.9; 1028 else if (!strncmp ((char *)entry->data, "DiMAGE 5", 8)) 1029 d = 4.9; 1030 } 1031 } 1032 if (d) 1033 snprintf (b, sizeof (b), _(" (35 equivalent: %d mm)"), 1034 (int) (d * (double) v_rat.numerator / 1035 (double) v_rat.denominator)); 1036 1037 d = (double) v_rat.numerator / (double) v_rat.denominator; 1038 snprintf (val, maxlen, "%.1lf mm", d); 1039 if (maxlen > strlen (val) + strlen (b)) 1040 strncat (val, b, maxlen - strlen (val)); 1041 break; 1042 case EXIF_TAG_SUBJECT_DISTANCE: 1043 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen); 1044 CC (e, 1, val, maxlen); 1045 v_rat = exif_get_rational (e->data, o); 1046 if (!v_rat.denominator) { 1047 exif_entry_format_value(e, val, maxlen); 1048 break; 1049 } 1050 d = (double) v_rat.numerator / (double) v_rat.denominator; 1051 snprintf (val, maxlen, "%.1lf m", d); 1052 break; 1053 case EXIF_TAG_EXPOSURE_TIME: 1054 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen); 1055 CC (e, 1, val, maxlen); 1056 v_rat = exif_get_rational (e->data, o); 1057 if (!v_rat.denominator) { 1058 exif_entry_format_value(e, val, maxlen); 1059 break; 1060 } 1061 d = (double) v_rat.numerator / (double) v_rat.denominator; 1062 if (d < 1) 1063 snprintf (val, maxlen, _("1/%i"), (int) (0.5 + 1. / d)); 1064 else 1065 snprintf (val, maxlen, "%i", (int) d); 1066 if (maxlen > strlen (val) + strlen (_(" sec."))) 1067 strncat (val, _(" sec."), maxlen - strlen (val)); 1068 break; 1069 case EXIF_TAG_SHUTTER_SPEED_VALUE: 1070 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen); 1071 CC (e, 1, val, maxlen); 1072 v_srat = exif_get_srational (e->data, o); 1073 if (!v_srat.denominator) { 1074 exif_entry_format_value(e, val, maxlen); 1075 break; 1076 } 1077 d = (double) v_srat.numerator / (double) v_srat.denominator; 1078 snprintf (val, maxlen, _("%.02f EV"), d); 1079 d = 1. / pow (2, d); 1080 if (d < 1) 1081 snprintf (b, sizeof (b), _(" (1/%d sec.)"), (int) (1. / d)); 1082 else 1083 snprintf (b, sizeof (b), _(" (%d sec.)"), (int) d); 1084 strncat (val, b, maxlen - strlen (val)); 1085 break; 1086 case EXIF_TAG_BRIGHTNESS_VALUE: 1087 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen); 1088 CC (e, 1, val, maxlen); 1089 v_srat = exif_get_srational (e->data, o); 1090 if (!v_srat.denominator) { 1091 exif_entry_format_value(e, val, maxlen); 1092 break; 1093 } 1094 d = (double) v_srat.numerator / (double) v_srat.denominator; 1095 snprintf (val, maxlen, _("%.02f EV"), d); 1096 snprintf (b, sizeof (b), _(" (%.02f cd/m^2)"), 1097 1. / (M_PI * 0.3048 * 0.3048) * pow (2, d)); 1098 if (maxlen > strlen (val) + strlen (b)) 1099 strncat (val, b, maxlen - strlen (val)); 1100 break; 1101 case EXIF_TAG_FILE_SOURCE: 1102 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen); 1103 CC (e, 1, val, maxlen); 1104 v_byte = e->data[0]; 1105 if (v_byte == 3) 1106 strncpy (val, _("DSC"), maxlen); 1107 else 1108 snprintf (val, maxlen, _("Internal error (unknown " 1109 "value %i)"), v_byte); 1110 break; 1111 case EXIF_TAG_COMPONENTS_CONFIGURATION: 1112 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen); 1113 CC (e, 4, val, maxlen); 1114 for (i = 0; i < 4; i++) { 1115 switch (e->data[i]) { 1116 case 0: c = _("-"); break; 1117 case 1: c = _("Y"); break; 1118 case 2: c = _("Cb"); break; 1119 case 3: c = _("Cr"); break; 1120 case 4: c = _("R"); break; 1121 case 5: c = _("G"); break; 1122 case 6: c = _("B"); break; 1123 default: c = _("reserved"); break; 1124 } 1125 strncat (val, c, maxlen - strlen (val)); 1126 if (i < 3) 1127 strncat (val, " ", maxlen - strlen (val)); 1128 } 1129 break; 1130 case EXIF_TAG_EXPOSURE_BIAS_VALUE: 1131 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen); 1132 CC (e, 1, val, maxlen); 1133 v_srat = exif_get_srational (e->data, o); 1134 if (!v_srat.denominator) { 1135 exif_entry_format_value(e, val, maxlen); 1136 break; 1137 } 1138 d = (double) v_srat.numerator / (double) v_srat.denominator; 1139 snprintf (val, maxlen, _("%.02f EV"), d); 1140 break; 1141 case EXIF_TAG_SCENE_TYPE: 1142 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen); 1143 CC (e, 1, val, maxlen); 1144 v_byte = e->data[0]; 1145 if (v_byte == 1) 1146 strncpy (val, _("Directly photographed"), maxlen); 1147 else 1148 snprintf (val, maxlen, _("Internal error (unknown " 1149 "value %i)"), v_byte); 1150 break; 1151 case EXIF_TAG_YCBCR_SUB_SAMPLING: 1152 CF (e, EXIF_FORMAT_SHORT, val, maxlen); 1153 CC (e, 2, val, maxlen); 1154 v_short = exif_get_short (e->data, o); 1155 v_short2 = exif_get_short ( 1156 e->data + exif_format_get_size (e->format), 1157 o); 1158 if ((v_short == 2) && (v_short2 == 1)) 1159 strncpy (val, _("YCbCr4:2:2"), maxlen); 1160 else if ((v_short == 2) && (v_short2 == 2)) 1161 strncpy (val, _("YCbCr4:2:0"), maxlen); 1162 else 1163 snprintf (val, maxlen, "%u, %u", v_short, v_short2); 1164 break; 1165 case EXIF_TAG_SUBJECT_AREA: 1166 CF (e, EXIF_FORMAT_SHORT, val, maxlen); 1167 switch (e->components) { 1168 case 2: 1169 v_short = exif_get_short (e->data, o); 1170 v_short2 = exif_get_short (e->data + 2, o); 1171 snprintf (val, maxlen, "(x,y) = (%i,%i)", 1172 v_short, v_short2); 1173 break; 1174 case 3: 1175 v_short = exif_get_short (e->data, o); 1176 v_short2 = exif_get_short (e->data + 2, o); 1177 v_short3 = exif_get_short (e->data + 4, o); 1178 snprintf (val, maxlen, _("Within distance %i of " 1179 "(x,y) = (%i,%i)"), v_short3, v_short, 1180 v_short2); 1181 break; 1182 case 4: 1183 v_short = exif_get_short (e->data, o); 1184 v_short2 = exif_get_short (e->data + 2, o); 1185 v_short3 = exif_get_short (e->data + 4, o); 1186 v_short4 = exif_get_short (e->data + 6, o); 1187 snprintf (val, maxlen, _("Within rectangle " 1188 "(width %i, height %i) around " 1189 "(x,y) = (%i,%i)"), v_short3, v_short4, 1190 v_short, v_short2); 1191 break; 1192 default: 1193 snprintf (val, maxlen, _("Unexpected number " 1194 "of components (%li, expected 2, 3, or 4)."), 1195 e->components); 1196 } 1197 break; 1198 case EXIF_TAG_GPS_VERSION_ID: 1199 /* This is only valid in the GPS IFD */ 1200 CF (e, EXIF_FORMAT_BYTE, val, maxlen); 1201 CC (e, 4, val, maxlen); 1202 v_byte = e->data[0]; 1203 snprintf (val, maxlen, "%u", v_byte); 1204 maxlen -= strlen (val); 1205 for (i = 1; i < e->components; i++) { 1206 v_byte = e->data[i]; 1207 snprintf (b, sizeof (b), ".%u", v_byte); 1208 strncat (val, b, maxlen); 1209 maxlen -= strlen (b); 1210 if ((signed)maxlen <= 0) break; 1211 } 1212 break; 1213 case EXIF_TAG_INTEROPERABILITY_VERSION: 1214 /* a.k.a. case EXIF_TAG_GPS_LATITUDE: */ 1215 /* This tag occurs in EXIF_IFD_INTEROPERABILITY */ 1216 if (e->format == EXIF_FORMAT_UNDEFINED) { 1217 strncpy (val, (char *) e->data, MIN (maxlen, e->size)); 1218 break; 1219 } 1220 /* EXIF_TAG_GPS_LATITUDE is the same numerically as 1221 * EXIF_TAG_INTEROPERABILITY_VERSION but in EXIF_IFD_GPS 1222 */ 1223 exif_entry_format_value(e, val, maxlen); 1224 break; 1225 case EXIF_TAG_GPS_ALTITUDE_REF: 1226 /* This is only valid in the GPS IFD */ 1227 CF (e, EXIF_FORMAT_BYTE, val, maxlen); 1228 CC (e, 1, val, maxlen); 1229 v_byte = e->data[0]; 1230 if (v_byte == 0) 1231 strncpy (val, _("Sea level"), maxlen); 1232 else if (v_byte == 1) 1233 strncpy (val, _("Sea level reference"), maxlen); 1234 else 1235 snprintf (val, maxlen, _("Internal error (unknown " 1236 "value %i)"), v_byte); 1237 break; 1238 case EXIF_TAG_GPS_TIME_STAMP: 1239 /* This is only valid in the GPS IFD */ 1240 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen); 1241 CC (e, 3, val, maxlen); 1242 1243 v_rat = exif_get_rational (e->data, o); 1244 if (!v_rat.denominator) { 1245 exif_entry_format_value(e, val, maxlen); 1246 break; 1247 } 1248 i = v_rat.numerator / v_rat.denominator; 1249 1250 v_rat = exif_get_rational (e->data + 1251 exif_format_get_size (e->format), 1252 o); 1253 if (!v_rat.denominator) { 1254 exif_entry_format_value(e, val, maxlen); 1255 break; 1256 } 1257 j = v_rat.numerator / v_rat.denominator; 1258 1259 v_rat = exif_get_rational (e->data + 1260 2*exif_format_get_size (e->format), 1261 o); 1262 if (!v_rat.denominator) { 1263 exif_entry_format_value(e, val, maxlen); 1264 break; 1265 } 1266 d = (double) v_rat.numerator / (double) v_rat.denominator; 1267 snprintf (val, maxlen, "%02u:%02u:%05.2f", i, j, d); 1268 break; 1269 1270 case EXIF_TAG_METERING_MODE: 1271 case EXIF_TAG_COMPRESSION: 1272 case EXIF_TAG_LIGHT_SOURCE: 1273 case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT: 1274 case EXIF_TAG_RESOLUTION_UNIT: 1275 case EXIF_TAG_EXPOSURE_PROGRAM: 1276 case EXIF_TAG_FLASH: 1277 case EXIF_TAG_SUBJECT_DISTANCE_RANGE: 1278 case EXIF_TAG_COLOR_SPACE: 1279 CF (e,EXIF_FORMAT_SHORT, val, maxlen); 1280 CC (e, 1, val, maxlen); 1281 v_short = exif_get_short (e->data, o); 1282 1283 /* Search the tag */ 1284 for (i = 0; list2[i].tag && (list2[i].tag != e->tag); i++); 1285 if (!list2[i].tag) { 1286 snprintf (val, maxlen, _("Internal error (unknown " 1287 "value %i)"), v_short); 1288 break; 1289 } 1290 1291 /* Find the value */ 1292 for (j = 0; list2[i].elem[j].values[0] && 1293 (list2[i].elem[j].index < v_short); j++); 1294 if (list2[i].elem[j].index != v_short) { 1295 snprintf (val, maxlen, _("Internal error (unknown " 1296 "value %i)"), v_short); 1297 break; 1298 } 1299 1300 /* Find a short enough value */ 1301 memset (val, 0, maxlen); 1302 for (k = 0; list2[i].elem[j].values[k]; k++) { 1303 size_t l = strlen (_(list2[i].elem[j].values[k])); 1304 if ((maxlen > l) && (strlen (val) < l)) 1305 strncpy (val, _(list2[i].elem[j].values[k]), maxlen); 1306 } 1307 if (!val[0]) snprintf (val, maxlen, "%i", v_short); 1308 1309 break; 1310 1311 case EXIF_TAG_PLANAR_CONFIGURATION: 1312 case EXIF_TAG_SENSING_METHOD: 1313 case EXIF_TAG_ORIENTATION: 1314 case EXIF_TAG_YCBCR_POSITIONING: 1315 case EXIF_TAG_PHOTOMETRIC_INTERPRETATION: 1316 case EXIF_TAG_CUSTOM_RENDERED: 1317 case EXIF_TAG_EXPOSURE_MODE: 1318 case EXIF_TAG_WHITE_BALANCE: 1319 case EXIF_TAG_SCENE_CAPTURE_TYPE: 1320 case EXIF_TAG_GAIN_CONTROL: 1321 case EXIF_TAG_SATURATION: 1322 case EXIF_TAG_CONTRAST: 1323 case EXIF_TAG_SHARPNESS: 1324 CF (e, EXIF_FORMAT_SHORT, val, maxlen); 1325 CC (e, 1, val, maxlen); 1326 v_short = exif_get_short (e->data, o); 1327 1328 /* Search the tag */ 1329 for (i = 0; list[i].tag && (list[i].tag != e->tag); i++); 1330 if (!list[i].tag) { 1331 snprintf (val, maxlen, _("Internal error (unknown " 1332 "value %i)"), v_short); 1333 break; 1334 } 1335 1336 /* Find the value */ 1337 for (j = 0; list[i].strings[j] && (j < v_short); j++); 1338 if (!list[i].strings[j]) 1339 snprintf (val, maxlen, "%i", v_short); 1340 else if (!*list[i].strings[j]) 1341 snprintf (val, maxlen, _("Unknown value %i"), v_short); 1342 else 1343 strncpy (val, _(list[i].strings[j]), maxlen); 1344 break; 1345 1346 case EXIF_TAG_XP_TITLE: 1347 case EXIF_TAG_XP_COMMENT: 1348 case EXIF_TAG_XP_AUTHOR: 1349 case EXIF_TAG_XP_KEYWORDS: 1350 case EXIF_TAG_XP_SUBJECT: 1351 /* Warning! The texts are converted from UTF16 to UTF8 */ 1352 /* FIXME: use iconv to convert into the locale encoding */ 1353 exif_convert_utf16_to_utf8(val, (unsigned short*)e->data, MIN(maxlen, e->size)); 1354 break; 1355 1356 default: 1357 /* Use a generic value formatting */ 1358 exif_entry_format_value(e, val, maxlen); 1359 } 1360 1361 return val; 1362} 1363 1364 1365/*! 1366 * \bug Log and report failed exif_mem_malloc() calls. 1367 */ 1368void 1369exif_entry_initialize (ExifEntry *e, ExifTag tag) 1370{ 1371 ExifRational r; 1372 ExifByteOrder o; 1373 1374 /* We need the byte order */ 1375 if (!e || !e->parent || e->data || !e->parent->parent) 1376 return; 1377 o = exif_data_get_byte_order (e->parent->parent); 1378 1379 e->tag = tag; 1380 switch (tag) { 1381 1382 /* LONG, 1 component, no default */ 1383 case EXIF_TAG_PIXEL_X_DIMENSION: 1384 case EXIF_TAG_PIXEL_Y_DIMENSION: 1385 case EXIF_TAG_EXIF_IFD_POINTER: 1386 case EXIF_TAG_GPS_INFO_IFD_POINTER: 1387 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER: 1388 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH: 1389 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT: 1390 e->components = 1; 1391 e->format = EXIF_FORMAT_LONG; 1392 e->size = exif_format_get_size (e->format) * e->components; 1393 e->data = exif_entry_alloc (e, e->size); 1394 if (!e->data) break; 1395 break; 1396 1397 /* SHORT, 1 component, no default */ 1398 case EXIF_TAG_SUBJECT_LOCATION: 1399 case EXIF_TAG_SENSING_METHOD: 1400 case EXIF_TAG_PHOTOMETRIC_INTERPRETATION: 1401 case EXIF_TAG_COMPRESSION: 1402 case EXIF_TAG_EXPOSURE_MODE: 1403 case EXIF_TAG_WHITE_BALANCE: 1404 case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM: 1405 case EXIF_TAG_GAIN_CONTROL: 1406 case EXIF_TAG_SUBJECT_DISTANCE_RANGE: 1407 case EXIF_TAG_FLASH: 1408 case EXIF_TAG_ISO_SPEED_RATINGS: 1409 1410 /* SHORT, 1 component, default 0 */ 1411 case EXIF_TAG_IMAGE_WIDTH: 1412 case EXIF_TAG_IMAGE_LENGTH: 1413 case EXIF_TAG_EXPOSURE_PROGRAM: 1414 case EXIF_TAG_LIGHT_SOURCE: 1415 case EXIF_TAG_METERING_MODE: 1416 case EXIF_TAG_CUSTOM_RENDERED: 1417 case EXIF_TAG_SCENE_CAPTURE_TYPE: 1418 case EXIF_TAG_CONTRAST: 1419 case EXIF_TAG_SATURATION: 1420 case EXIF_TAG_SHARPNESS: 1421 e->components = 1; 1422 e->format = EXIF_FORMAT_SHORT; 1423 e->size = exif_format_get_size (e->format) * e->components; 1424 e->data = exif_entry_alloc (e, e->size); 1425 if (!e->data) break; 1426 exif_set_short (e->data, o, 0); 1427 break; 1428 1429 /* SHORT, 1 component, default 1 */ 1430 case EXIF_TAG_ORIENTATION: 1431 case EXIF_TAG_PLANAR_CONFIGURATION: 1432 case EXIF_TAG_YCBCR_POSITIONING: 1433 e->components = 1; 1434 e->format = EXIF_FORMAT_SHORT; 1435 e->size = exif_format_get_size (e->format) * e->components; 1436 e->data = exif_entry_alloc (e, e->size); 1437 if (!e->data) break; 1438 exif_set_short (e->data, o, 1); 1439 break; 1440 1441 /* SHORT, 1 component, default 2 */ 1442 case EXIF_TAG_RESOLUTION_UNIT: 1443 case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT: 1444 e->components = 1; 1445 e->format = EXIF_FORMAT_SHORT; 1446 e->size = exif_format_get_size (e->format) * e->components; 1447 e->data = exif_entry_alloc (e, e->size); 1448 if (!e->data) break; 1449 exif_set_short (e->data, o, 2); 1450 break; 1451 1452 /* SHORT, 1 component, default 3 */ 1453 case EXIF_TAG_SAMPLES_PER_PIXEL: 1454 e->components = 1; 1455 e->format = EXIF_FORMAT_SHORT; 1456 e->size = exif_format_get_size (e->format) * e->components; 1457 e->data = exif_entry_alloc (e, e->size); 1458 if (!e->data) break; 1459 exif_set_short (e->data, o, 3); 1460 break; 1461 1462 case EXIF_TAG_COLOR_SPACE: 1463 /* SHORT, 1 component, default 0xffff */ 1464 e->components = 1; 1465 e->format = EXIF_FORMAT_SHORT; 1466 e->size = exif_format_get_size (e->format) * e->components; 1467 e->data = exif_entry_alloc (e, e->size); 1468 if (!e->data) break; 1469 exif_set_short (e->data, o, 0xffff); 1470 break; 1471 1472 case EXIF_TAG_BITS_PER_SAMPLE: 1473 e->components = 3; 1474 e->format = EXIF_FORMAT_SHORT; 1475 e->size = exif_format_get_size (e->format) * e->components; 1476 e->data = exif_entry_alloc (e, e->size); 1477 if (!e->data) break; 1478 exif_set_short (e->data, o, 8); 1479 exif_set_short ( 1480 e->data + exif_format_get_size (e->format), 1481 o, 8); 1482 exif_set_short ( 1483 e->data + 2 * exif_format_get_size (e->format), 1484 o, 8); 1485 break; 1486 1487 case EXIF_TAG_YCBCR_SUB_SAMPLING: 1488 e->components = 2; 1489 e->format = EXIF_FORMAT_SHORT; 1490 e->size = exif_format_get_size (e->format) * e->components; 1491 e->data = exif_entry_alloc (e, e->size); 1492 if (!e->data) break; 1493 exif_set_short (e->data, o, 2); 1494 exif_set_short ( 1495 e->data + exif_format_get_size (e->format), 1496 o, 1); 1497 break; 1498 1499 /* SRATIONAL, 1 component, no default */ 1500 case EXIF_TAG_EXPOSURE_BIAS_VALUE: 1501 case EXIF_TAG_BRIGHTNESS_VALUE: 1502 case EXIF_TAG_SHUTTER_SPEED_VALUE: 1503 e->components = 1; 1504 e->format = EXIF_FORMAT_SRATIONAL; 1505 e->size = exif_format_get_size (e->format) * e->components; 1506 e->data = exif_entry_alloc (e, e->size); 1507 if (!e->data) break; 1508 break; 1509 1510 /* RATIONAL, 1 component, no default */ 1511 case EXIF_TAG_EXPOSURE_TIME: 1512 case EXIF_TAG_FOCAL_PLANE_X_RESOLUTION: 1513 case EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION: 1514 case EXIF_TAG_EXPOSURE_INDEX: 1515 case EXIF_TAG_FLASH_ENERGY: 1516 case EXIF_TAG_FNUMBER: 1517 case EXIF_TAG_FOCAL_LENGTH: 1518 case EXIF_TAG_SUBJECT_DISTANCE: 1519 case EXIF_TAG_MAX_APERTURE_VALUE: 1520 case EXIF_TAG_APERTURE_VALUE: 1521 case EXIF_TAG_COMPRESSED_BITS_PER_PIXEL: 1522 case EXIF_TAG_PRIMARY_CHROMATICITIES: 1523 case EXIF_TAG_DIGITAL_ZOOM_RATIO: 1524 e->components = 1; 1525 e->format = EXIF_FORMAT_RATIONAL; 1526 e->size = exif_format_get_size (e->format) * e->components; 1527 e->data = exif_entry_alloc (e, e->size); 1528 if (!e->data) break; 1529 break; 1530 1531 /* RATIONAL, 1 component, default 72/1 */ 1532 case EXIF_TAG_X_RESOLUTION: 1533 case EXIF_TAG_Y_RESOLUTION: 1534 e->components = 1; 1535 e->format = EXIF_FORMAT_RATIONAL; 1536 e->size = exif_format_get_size (e->format) * e->components; 1537 e->data = exif_entry_alloc (e, e->size); 1538 if (!e->data) break; 1539 r.numerator = 72; 1540 r.denominator = 1; 1541 exif_set_rational (e->data, o, r); 1542 break; 1543 1544 /* RATIONAL, 2 components, no default */ 1545 case EXIF_TAG_WHITE_POINT: 1546 e->components = 2; 1547 e->format = EXIF_FORMAT_RATIONAL; 1548 e->size = exif_format_get_size (e->format) * e->components; 1549 e->data = exif_entry_alloc (e, e->size); 1550 if (!e->data) break; 1551 break; 1552 1553 /* RATIONAL, 6 components */ 1554 case EXIF_TAG_REFERENCE_BLACK_WHITE: 1555 e->components = 6; 1556 e->format = EXIF_FORMAT_RATIONAL; 1557 e->size = exif_format_get_size (e->format) * e->components; 1558 e->data = exif_entry_alloc (e, e->size); 1559 if (!e->data) break; 1560 r.denominator = 1; 1561 r.numerator = 0; 1562 exif_set_rational (e->data, o, r); 1563 r.numerator = 255; 1564 exif_set_rational ( 1565 e->data + exif_format_get_size (e->format), o, r); 1566 r.numerator = 0; 1567 exif_set_rational ( 1568 e->data + 2 * exif_format_get_size (e->format), o, r); 1569 r.numerator = 255; 1570 exif_set_rational ( 1571 e->data + 3 * exif_format_get_size (e->format), o, r); 1572 r.numerator = 0; 1573 exif_set_rational ( 1574 e->data + 4 * exif_format_get_size (e->format), o, r); 1575 r.numerator = 255; 1576 exif_set_rational ( 1577 e->data + 5 * exif_format_get_size (e->format), o, r); 1578 break; 1579 1580 /* ASCII, 20 components */ 1581 case EXIF_TAG_DATE_TIME: 1582 case EXIF_TAG_DATE_TIME_ORIGINAL: 1583 case EXIF_TAG_DATE_TIME_DIGITIZED: 1584 { 1585 time_t t; 1586#ifdef HAVE_LOCALTIME_R 1587 struct tm tms; 1588#endif 1589 struct tm *tm; 1590 1591 t = time (NULL); 1592#ifdef HAVE_LOCALTIME_R 1593 tm = localtime_r (&t, &tms); 1594#else 1595 tm = localtime (&t); 1596#endif 1597 e->components = 20; 1598 e->format = EXIF_FORMAT_ASCII; 1599 e->size = exif_format_get_size (e->format) * e->components; 1600 e->data = exif_entry_alloc (e, e->size); 1601 if (!e->data) break; 1602 snprintf ((char *) e->data, e->size, 1603 "%04i:%02i:%02i %02i:%02i:%02i", 1604 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, 1605 tm->tm_hour, tm->tm_min, tm->tm_sec); 1606 break; 1607 } 1608 1609 /* ASCII, no default */ 1610 case EXIF_TAG_SUB_SEC_TIME: 1611 case EXIF_TAG_SUB_SEC_TIME_ORIGINAL: 1612 case EXIF_TAG_SUB_SEC_TIME_DIGITIZED: 1613 e->components = 0; 1614 e->format = EXIF_FORMAT_ASCII; 1615 e->size = 0; 1616 e->data = NULL; 1617 break; 1618 case EXIF_TAG_IMAGE_DESCRIPTION: 1619 case EXIF_TAG_MAKE: 1620 case EXIF_TAG_MODEL: 1621 case EXIF_TAG_SOFTWARE: 1622 case EXIF_TAG_ARTIST: 1623 e->components = strlen (_("[None]")) + 1; 1624 e->format = EXIF_FORMAT_ASCII; 1625 e->size = exif_format_get_size (e->format) * e->components; 1626 e->data = exif_entry_alloc (e, e->size); 1627 if (!e->data) break; 1628 strncpy ((char *)e->data, _("[None]"), e->size); 1629 break; 1630 case EXIF_TAG_COPYRIGHT: 1631 e->components = (strlen (_("[None]")) + 1) * 2; 1632 e->format = EXIF_FORMAT_ASCII; 1633 e->size = exif_format_get_size (e->format) * e->components; 1634 e->data = exif_entry_alloc (e, e->size); 1635 if (!e->data) break; 1636 strcpy (((char *)e->data) + 0, _("[None]")); 1637 strcpy (((char *)e->data) + strlen (_("[None]")) + 1, _("[None]")); 1638 break; 1639 1640 /* UNDEFINED, no components, no default */ 1641 /* Use this if the tag is otherwise unsupported */ 1642 case EXIF_TAG_MAKER_NOTE: 1643 case EXIF_TAG_USER_COMMENT: 1644 default: 1645 e->components = 0; 1646 e->format = EXIF_FORMAT_UNDEFINED; 1647 e->size = 0; 1648 e->data = NULL; 1649 break; 1650 1651 /* UNDEFINED, 1 component, default 1 */ 1652 case EXIF_TAG_SCENE_TYPE: 1653 e->components = 1; 1654 e->format = EXIF_FORMAT_UNDEFINED; 1655 e->size = exif_format_get_size (e->format) * e->components; 1656 e->data = exif_entry_alloc (e, e->size); 1657 if (!e->data) break; 1658 e->data[0] = 0x01; 1659 break; 1660 1661 /* UNDEFINED, 1 component, default 3 */ 1662 case EXIF_TAG_FILE_SOURCE: 1663 e->components = 1; 1664 e->format = EXIF_FORMAT_UNDEFINED; 1665 e->size = exif_format_get_size (e->format) * e->components; 1666 e->data = exif_entry_alloc (e, e->size); 1667 if (!e->data) break; 1668 e->data[0] = 0x03; 1669 break; 1670 1671 /* UNDEFINED, 4 components, default 0 1 0 0 */ 1672 case EXIF_TAG_FLASH_PIX_VERSION: 1673 e->components = 4; 1674 e->format = EXIF_FORMAT_UNDEFINED; 1675 e->size = exif_format_get_size (e->format) * e->components; 1676 e->data = exif_entry_alloc (e, e->size); 1677 if (!e->data) break; 1678 memcpy (e->data, "0100", 4); 1679 break; 1680 1681 /* UNDEFINED, 4 components, default 0 2 1 0 */ 1682 case EXIF_TAG_EXIF_VERSION: 1683 e->components = 4; 1684 e->format = EXIF_FORMAT_UNDEFINED; 1685 e->size = exif_format_get_size (e->format) * e->components; 1686 e->data = exif_entry_alloc (e, e->size); 1687 if (!e->data) break; 1688 memcpy (e->data, "0210", 4); 1689 break; 1690 1691 /* UNDEFINED, 4 components, default 1,2,3,0 */ 1692 case EXIF_TAG_COMPONENTS_CONFIGURATION: 1693 e->components = 4; 1694 e->format = EXIF_FORMAT_UNDEFINED; 1695 e->size = exif_format_get_size (e->format) * e->components; 1696 e->data = exif_entry_alloc (e, e->size); 1697 if (!e->data) break; 1698 e->data[0] = 1; 1699 e->data[1] = 2; 1700 e->data[2] = 3; 1701 e->data[3] = 0; 1702 break; 1703 } 1704} 1705