1/* exif-data.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-mnote-data.h> 24#include <libexif/exif-data.h> 25#include <libexif/exif-ifd.h> 26#include <libexif/exif-mnote-data-priv.h> 27#include <libexif/exif-utils.h> 28#include <libexif/exif-loader.h> 29#include <libexif/exif-log.h> 30#include <libexif/i18n.h> 31#include <libexif/exif-system.h> 32 33#include <libexif/canon/exif-mnote-data-canon.h> 34#include <libexif/fuji/exif-mnote-data-fuji.h> 35#include <libexif/olympus/exif-mnote-data-olympus.h> 36#include <libexif/pentax/exif-mnote-data-pentax.h> 37 38#include <stdlib.h> 39#include <stdio.h> 40#include <string.h> 41 42#if defined(__WATCOMC__) || defined(_MSC_VER) 43# define strncasecmp strnicmp 44#endif 45 46#undef JPEG_MARKER_SOI 47#define JPEG_MARKER_SOI 0xd8 48#undef JPEG_MARKER_APP0 49#define JPEG_MARKER_APP0 0xe0 50#undef JPEG_MARKER_APP1 51#define JPEG_MARKER_APP1 0xe1 52 53static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00}; 54 55struct _ExifDataPrivate 56{ 57 ExifByteOrder order; 58 59 ExifMnoteData *md; 60 61 ExifLog *log; 62 ExifMem *mem; 63 64 unsigned int ref_count; 65 66 /* Temporarily used while loading data */ 67 unsigned int offset_mnote; 68 69 ExifDataOption options; 70 ExifDataType data_type; 71}; 72 73static void * 74exif_data_alloc (ExifData *data, unsigned int i) 75{ 76 void *d; 77 78 if (!data || !i) 79 return NULL; 80 81 d = exif_mem_alloc (data->priv->mem, i); 82 if (d) 83 return d; 84 85 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i); 86 return NULL; 87} 88 89ExifMnoteData * 90exif_data_get_mnote_data (ExifData *d) 91{ 92 return (d && d->priv) ? d->priv->md : NULL; 93} 94 95ExifData * 96exif_data_new (void) 97{ 98 ExifMem *mem = exif_mem_new_default (); 99 ExifData *d = exif_data_new_mem (mem); 100 101 exif_mem_unref (mem); 102 103 return d; 104} 105 106ExifData * 107exif_data_new_mem (ExifMem *mem) 108{ 109 ExifData *data; 110 unsigned int i; 111 112 if (!mem) 113 return NULL; 114 115 data = exif_mem_alloc (mem, sizeof (ExifData)); 116 if (!data) 117 return (NULL); 118 data->priv = exif_mem_alloc (mem, sizeof (ExifDataPrivate)); 119 if (!data->priv) { 120 exif_mem_free (mem, data); 121 return (NULL); 122 } 123 data->priv->ref_count = 1; 124 125 data->priv->mem = mem; 126 exif_mem_ref (mem); 127 128 for (i = 0; i < EXIF_IFD_COUNT; i++) { 129 data->ifd[i] = exif_content_new_mem (data->priv->mem); 130 if (!data->ifd[i]) { 131 exif_data_free (data); 132 return (NULL); 133 } 134 data->ifd[i]->parent = data; 135 } 136 137 /* Default options */ 138#ifndef NO_VERBOSE_TAG_STRINGS 139 /* 140 * When the tag list is compiled away, setting this option prevents 141 * any tags from being loaded 142 */ 143 exif_data_set_option (data, EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS); 144#endif 145 exif_data_set_option (data, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION); 146 147 /* Default data type: none */ 148 exif_data_set_data_type (data, EXIF_DATA_TYPE_COUNT); 149 150 return (data); 151} 152 153ExifData * 154exif_data_new_from_data (const unsigned char *data, unsigned int size) 155{ 156 ExifData *edata; 157 158 edata = exif_data_new (); 159 exif_data_load_data (edata, data, size); 160 return (edata); 161} 162 163static int 164exif_data_load_data_entry (ExifData *data, ExifEntry *entry, 165 const unsigned char *d, 166 unsigned int size, unsigned int offset) 167{ 168 unsigned int s, doff; 169 170 entry->tag = exif_get_short (d + offset + 0, data->priv->order); 171 entry->format = exif_get_short (d + offset + 2, data->priv->order); 172 entry->components = exif_get_long (d + offset + 4, data->priv->order); 173 174 /* FIXME: should use exif_tag_get_name_in_ifd here but entry->parent 175 * has not been set yet 176 */ 177 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 178 "Loading entry 0x%x ('%s')...", entry->tag, 179 exif_tag_get_name (entry->tag)); 180 181 /* {0,1,2,4,8} x { 0x00000000 .. 0xffffffff } 182 * -> { 0x000000000 .. 0x7fffffff8 } */ 183 s = exif_format_get_size(entry->format) * entry->components; 184 if ((s < entry->components) || (s == 0)){ 185 return 0; 186 } 187 188 /* 189 * Size? If bigger than 4 bytes, the actual data is not 190 * in the entry but somewhere else (offset). 191 */ 192 if (s > 4) 193 doff = exif_get_long (d + offset + 8, data->priv->order); 194 else 195 doff = offset + 8; 196 197 /* Sanity checks */ 198 if ((doff + s < doff) || (doff + s < s) || (doff + s > size)) { 199 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 200 "Tag data past end of buffer (%u > %u)", doff+s, size); 201 return 0; 202 } 203 204 entry->data = exif_data_alloc (data, s); 205 if (entry->data) { 206 entry->size = s; 207 memcpy (entry->data, d + doff, s); 208 } else { 209 /* FIXME: What do our callers do if (entry->data == NULL)? */ 210 EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", s); 211 } 212 213 /* If this is the MakerNote, remember the offset */ 214 if (entry->tag == EXIF_TAG_MAKER_NOTE) { 215 if (!entry->data) { 216 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 217 "MakerNote found with empty data"); 218 } else if (entry->size > 6) { 219 exif_log (data->priv->log, 220 EXIF_LOG_CODE_DEBUG, "ExifData", 221 "MakerNote found (%02x %02x %02x %02x " 222 "%02x %02x %02x...).", 223 entry->data[0], entry->data[1], entry->data[2], 224 entry->data[3], entry->data[4], entry->data[5], 225 entry->data[6]); 226 } 227 data->priv->offset_mnote = doff; 228 } 229 return 1; 230} 231 232static void 233exif_data_save_data_entry (ExifData *data, ExifEntry *e, 234 unsigned char **d, unsigned int *ds, 235 unsigned int offset) 236{ 237 unsigned int doff, s; 238 unsigned char *t; 239 unsigned int ts; 240 241 if (!data || !data->priv) 242 return; 243 244 /* 245 * Each entry is 12 bytes long. The memory for the entry has 246 * already been allocated. 247 */ 248 exif_set_short (*d + 6 + offset + 0, 249 data->priv->order, (ExifShort) e->tag); 250 exif_set_short (*d + 6 + offset + 2, 251 data->priv->order, (ExifShort) e->format); 252 253 if (!(data->priv->options & EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE)) { 254 /* If this is the maker note tag, update it. */ 255 if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) { 256 exif_mem_free (data->priv->mem, e->data); 257 e->data = NULL; 258 e->size = 0; 259 exif_mnote_data_set_offset (data->priv->md, *ds - 6); 260 exif_mnote_data_save (data->priv->md, &e->data, &e->size); 261 e->components = e->size; 262 } 263 } 264 265 exif_set_long (*d + 6 + offset + 4, 266 data->priv->order, e->components); 267 268 /* 269 * Size? If bigger than 4 bytes, the actual data is not in 270 * the entry but somewhere else. 271 */ 272 s = exif_format_get_size (e->format) * e->components; 273 if (s > 4) { 274 doff = *ds - 6; 275 ts = *ds + s; 276 277 /* 278 * According to the TIFF specification, 279 * the offset must be an even number. If we need to introduce 280 * a padding byte, we set it to 0. 281 */ 282 if (s & 1) 283 ts++; 284 t = exif_mem_realloc (data->priv->mem, *d, ts); 285 if (!t) { 286 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts); 287 return; 288 } 289 *d = t; 290 *ds = ts; 291 exif_set_long (*d + 6 + offset + 8, data->priv->order, doff); 292 if (s & 1) 293 *(*d + *ds - 1) = '\0'; 294 295 } else 296 doff = offset + 8; 297 298 /* Write the data. Fill unneeded bytes with 0. Do not crash with 299 * e->data is NULL */ 300 if (e->data) { 301 memcpy (*d + 6 + doff, e->data, s); 302 } else { 303 memset (*d + 6 + doff, 0, s); 304 } 305 if (s < 4) 306 memset (*d + 6 + doff + s, 0, (4 - s)); 307} 308 309static void 310exif_data_load_data_thumbnail (ExifData *data, const unsigned char *d, 311 unsigned int ds, ExifLong o, ExifLong s) 312{ 313 /* Sanity checks */ 314 if ((o + s < o) || (o + s < s) || (o + s > ds) || (o > ds)) { 315 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 316 "Bogus thumbnail offset (%u) or size (%u).", 317 o, s); 318 return; 319 } 320 321 if (data->data) 322 exif_mem_free (data->priv->mem, data->data); 323 if (!(data->data = exif_data_alloc (data, s))) { 324 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", s); 325 data->size = 0; 326 return; 327 } 328 data->size = s; 329 memcpy (data->data, d + o, s); 330} 331 332#undef CHECK_REC 333#define CHECK_REC(i) \ 334if ((i) == ifd) { \ 335 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \ 336 "ExifData", "Recursive entry in IFD " \ 337 "'%s' detected. Skipping...", \ 338 exif_ifd_get_name (i)); \ 339 break; \ 340} \ 341if (data->ifd[(i)]->count) { \ 342 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \ 343 "ExifData", "Attempt to load IFD " \ 344 "'%s' multiple times detected. " \ 345 "Skipping...", \ 346 exif_ifd_get_name (i)); \ 347 break; \ 348} 349 350/*! Load data for an IFD. 351 * 352 * \param[in,out] data #ExifData 353 * \param[in] ifd IFD to load 354 * \param[in] d pointer to buffer containing raw IFD data 355 * \param[in] ds size of raw data in buffer at \c d 356 * \param[in] offset offset into buffer at \c d at which IFD starts 357 * \param[in] recursion_depth number of times this function has been 358 * recursively called without returning 359 */ 360static void 361exif_data_load_data_content (ExifData *data, ExifIfd ifd, 362 const unsigned char *d, 363 unsigned int ds, unsigned int offset, unsigned int recursion_depth) 364{ 365 ExifLong o, thumbnail_offset = 0, thumbnail_length = 0; 366 ExifShort n; 367 ExifEntry *entry; 368 unsigned int i; 369 ExifTag tag; 370 371 if (!data || !data->priv) 372 return; 373 374 /* check for valid ExifIfd enum range */ 375 if ((((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT)) 376 return; 377 378 if (recursion_depth > 30) { 379 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData", 380 "Deep recursion detected!"); 381 return; 382 } 383 384 /* Read the number of entries */ 385 if ((offset + 2 < offset) || (offset + 2 < 2) || (offset + 2 > ds)) { 386 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData", 387 "Tag data past end of buffer (%u > %u)", offset+2, ds); 388 return; 389 } 390 n = exif_get_short (d + offset, data->priv->order); 391 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 392 "Loading %hu entries...", n); 393 offset += 2; 394 395 /* Check if we have enough data. */ 396 if (offset + 12 * n > ds) { 397 n = (ds - offset) / 12; 398 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 399 "Short data; only loading %hu entries...", n); 400 } 401 402 for (i = 0; i < n; i++) { 403 404 tag = exif_get_short (d + offset + 12 * i, data->priv->order); 405 switch (tag) { 406 case EXIF_TAG_EXIF_IFD_POINTER: 407 case EXIF_TAG_GPS_INFO_IFD_POINTER: 408 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER: 409 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH: 410 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT: 411 o = exif_get_long (d + offset + 12 * i + 8, 412 data->priv->order); 413 /* FIXME: IFD_POINTER tags aren't marked as being in a 414 * specific IFD, so exif_tag_get_name_in_ifd won't work 415 */ 416 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 417 "Sub-IFD entry 0x%x ('%s') at %u.", tag, 418 exif_tag_get_name(tag), o); 419 switch (tag) { 420 case EXIF_TAG_EXIF_IFD_POINTER: 421 CHECK_REC (EXIF_IFD_EXIF); 422 exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o, recursion_depth + 1); 423 break; 424 case EXIF_TAG_GPS_INFO_IFD_POINTER: 425 CHECK_REC (EXIF_IFD_GPS); 426 exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o, recursion_depth + 1); 427 break; 428 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER: 429 CHECK_REC (EXIF_IFD_INTEROPERABILITY); 430 exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o, recursion_depth + 1); 431 break; 432 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT: 433 thumbnail_offset = o; 434 if (thumbnail_offset && thumbnail_length) 435 exif_data_load_data_thumbnail (data, d, 436 ds, thumbnail_offset, 437 thumbnail_length); 438 break; 439 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH: 440 thumbnail_length = o; 441 if (thumbnail_offset && thumbnail_length) 442 exif_data_load_data_thumbnail (data, d, 443 ds, thumbnail_offset, 444 thumbnail_length); 445 break; 446 default: 447 return; 448 } 449 break; 450 default: 451 452 /* 453 * If we don't know the tag, don't fail. It could be that new 454 * versions of the standard have defined additional tags. Note that 455 * 0 is a valid tag in the GPS IFD. 456 */ 457 if (!exif_tag_get_name_in_ifd (tag, ifd)) { 458 459 /* 460 * Special case: Tag and format 0. That's against specification 461 * (at least up to 2.2). But Photoshop writes it anyways. 462 */ 463 if (!memcmp (d + offset + 12 * i, "\0\0\0\0", 4)) { 464 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 465 "Skipping empty entry at position %u in '%s'.", i, 466 exif_ifd_get_name (ifd)); 467 break; 468 } 469 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 470 "Unknown tag 0x%04x (entry %u in '%s'). Please report this tag " 471 "to <libexif-devel@lists.sourceforge.net>.", tag, i, 472 exif_ifd_get_name (ifd)); 473 if (data->priv->options & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS) 474 break; 475 } 476 entry = exif_entry_new_mem (data->priv->mem); 477 if (exif_data_load_data_entry (data, entry, d, ds, 478 offset + 12 * i)) 479 exif_content_add_entry (data->ifd[ifd], entry); 480 exif_entry_unref (entry); 481 break; 482 } 483 } 484} 485 486static int 487cmp_func (const unsigned char *p1, const unsigned char *p2, ExifByteOrder o) 488{ 489 ExifShort tag1 = exif_get_short (p1, o); 490 ExifShort tag2 = exif_get_short (p2, o); 491 492 return (tag1 < tag2) ? -1 : (tag1 > tag2) ? 1 : 0; 493} 494 495static int 496cmp_func_intel (const void *elem1, const void *elem2) 497{ 498 return cmp_func ((const unsigned char *) elem1, 499 (const unsigned char *) elem2, EXIF_BYTE_ORDER_INTEL); 500} 501 502static int 503cmp_func_motorola (const void *elem1, const void *elem2) 504{ 505 return cmp_func ((const unsigned char *) elem1, 506 (const unsigned char *) elem2, EXIF_BYTE_ORDER_MOTOROLA); 507} 508 509static void 510exif_data_save_data_content (ExifData *data, ExifContent *ifd, 511 unsigned char **d, unsigned int *ds, 512 unsigned int offset) 513{ 514 unsigned int j, n_ptr = 0, n_thumb = 0; 515 ExifIfd i; 516 unsigned char *t; 517 unsigned int ts; 518 519 if (!data || !data->priv || !ifd || !d || !ds) 520 return; 521 522 for (i = 0; i < EXIF_IFD_COUNT; i++) 523 if (ifd == data->ifd[i]) 524 break; 525 if (i == EXIF_IFD_COUNT) 526 return; /* error */ 527 528 /* 529 * Check if we need some extra entries for pointers or the thumbnail. 530 */ 531 switch (i) { 532 case EXIF_IFD_0: 533 534 /* 535 * The pointer to IFD_EXIF is in IFD_0. The pointer to 536 * IFD_INTEROPERABILITY is in IFD_EXIF. 537 */ 538 if (data->ifd[EXIF_IFD_EXIF]->count || 539 data->ifd[EXIF_IFD_INTEROPERABILITY]->count) 540 n_ptr++; 541 542 /* The pointer to IFD_GPS is in IFD_0. */ 543 if (data->ifd[EXIF_IFD_GPS]->count) 544 n_ptr++; 545 546 break; 547 case EXIF_IFD_1: 548 if (data->size) 549 n_thumb = 2; 550 break; 551 case EXIF_IFD_EXIF: 552 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) 553 n_ptr++; 554 default: 555 break; 556 } 557 558 /* 559 * Allocate enough memory for all entries 560 * and the number of entries. 561 */ 562 ts = *ds + (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4); 563 t = exif_mem_realloc (data->priv->mem, *d, ts); 564 if (!t) { 565 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts); 566 return; 567 } 568 *d = t; 569 *ds = ts; 570 571 /* Save the number of entries */ 572 exif_set_short (*d + 6 + offset, data->priv->order, 573 (ExifShort) (ifd->count + n_ptr + n_thumb)); 574 offset += 2; 575 576 /* 577 * Save each entry. Make sure that no memcpys from NULL pointers are 578 * performed 579 */ 580 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 581 "Saving %i entries (IFD '%s', offset: %i)...", 582 ifd->count, exif_ifd_get_name (i), offset); 583 for (j = 0; j < ifd->count; j++) { 584 if (ifd->entries[j]) { 585 exif_data_save_data_entry (data, ifd->entries[j], d, ds, 586 offset + 12 * j); 587 } 588 } 589 590 offset += 12 * ifd->count; 591 592 /* Now save special entries. */ 593 switch (i) { 594 case EXIF_IFD_0: 595 596 /* 597 * The pointer to IFD_EXIF is in IFD_0. 598 * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF, 599 * therefore, if IFD_INTEROPERABILITY is not empty, we need 600 * IFD_EXIF even if latter is empty. 601 */ 602 if (data->ifd[EXIF_IFD_EXIF]->count || 603 data->ifd[EXIF_IFD_INTEROPERABILITY]->count) { 604 exif_set_short (*d + 6 + offset + 0, data->priv->order, 605 EXIF_TAG_EXIF_IFD_POINTER); 606 exif_set_short (*d + 6 + offset + 2, data->priv->order, 607 EXIF_FORMAT_LONG); 608 exif_set_long (*d + 6 + offset + 4, data->priv->order, 609 1); 610 exif_set_long (*d + 6 + offset + 8, data->priv->order, 611 *ds - 6); 612 exif_data_save_data_content (data, 613 data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6); 614 offset += 12; 615 } 616 617 /* The pointer to IFD_GPS is in IFD_0, too. */ 618 if (data->ifd[EXIF_IFD_GPS]->count) { 619 exif_set_short (*d + 6 + offset + 0, data->priv->order, 620 EXIF_TAG_GPS_INFO_IFD_POINTER); 621 exif_set_short (*d + 6 + offset + 2, data->priv->order, 622 EXIF_FORMAT_LONG); 623 exif_set_long (*d + 6 + offset + 4, data->priv->order, 624 1); 625 exif_set_long (*d + 6 + offset + 8, data->priv->order, 626 *ds - 6); 627 exif_data_save_data_content (data, 628 data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6); 629 offset += 12; 630 } 631 632 break; 633 case EXIF_IFD_EXIF: 634 635 /* 636 * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF. 637 * See note above. 638 */ 639 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) { 640 exif_set_short (*d + 6 + offset + 0, data->priv->order, 641 EXIF_TAG_INTEROPERABILITY_IFD_POINTER); 642 exif_set_short (*d + 6 + offset + 2, data->priv->order, 643 EXIF_FORMAT_LONG); 644 exif_set_long (*d + 6 + offset + 4, data->priv->order, 645 1); 646 exif_set_long (*d + 6 + offset + 8, data->priv->order, 647 *ds - 6); 648 exif_data_save_data_content (data, 649 data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds, 650 *ds - 6); 651 offset += 12; 652 } 653 654 break; 655 case EXIF_IFD_1: 656 657 /* 658 * Information about the thumbnail (if any) is saved in 659 * IFD_1. 660 */ 661 if (data->size) { 662 663 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */ 664 exif_set_short (*d + 6 + offset + 0, data->priv->order, 665 EXIF_TAG_JPEG_INTERCHANGE_FORMAT); 666 exif_set_short (*d + 6 + offset + 2, data->priv->order, 667 EXIF_FORMAT_LONG); 668 exif_set_long (*d + 6 + offset + 4, data->priv->order, 669 1); 670 exif_set_long (*d + 6 + offset + 8, data->priv->order, 671 *ds - 6); 672 ts = *ds + data->size; 673 t = exif_mem_realloc (data->priv->mem, *d, ts); 674 if (!t) { 675 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", 676 ts); 677 return; 678 } 679 *d = t; 680 *ds = ts; 681 memcpy (*d + *ds - data->size, data->data, data->size); 682 offset += 12; 683 684 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */ 685 exif_set_short (*d + 6 + offset + 0, data->priv->order, 686 EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH); 687 exif_set_short (*d + 6 + offset + 2, data->priv->order, 688 EXIF_FORMAT_LONG); 689 exif_set_long (*d + 6 + offset + 4, data->priv->order, 690 1); 691 exif_set_long (*d + 6 + offset + 8, data->priv->order, 692 data->size); 693 offset += 12; 694 } 695 696 break; 697 default: 698 break; 699 } 700 701 /* Sort the directory according to TIFF specification */ 702 qsort (*d + 6 + offset - (ifd->count + n_ptr + n_thumb) * 12, 703 (ifd->count + n_ptr + n_thumb), 12, 704 (data->priv->order == EXIF_BYTE_ORDER_INTEL) ? cmp_func_intel : cmp_func_motorola); 705 706 /* Correctly terminate the directory */ 707 if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count || 708 data->size)) { 709 710 /* 711 * We are saving IFD 0. Tell where IFD 1 starts and save 712 * IFD 1. 713 */ 714 exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6); 715 exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds, 716 *ds - 6); 717 } else 718 exif_set_long (*d + 6 + offset, data->priv->order, 0); 719} 720 721typedef enum { 722 EXIF_DATA_TYPE_MAKER_NOTE_NONE = 0, 723 EXIF_DATA_TYPE_MAKER_NOTE_CANON = 1, 724 EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS = 2, 725 EXIF_DATA_TYPE_MAKER_NOTE_PENTAX = 3, 726 EXIF_DATA_TYPE_MAKER_NOTE_NIKON = 4, 727 EXIF_DATA_TYPE_MAKER_NOTE_CASIO = 5, 728 EXIF_DATA_TYPE_MAKER_NOTE_FUJI = 6 729} ExifDataTypeMakerNote; 730 731static ExifDataTypeMakerNote 732exif_data_get_type_maker_note (ExifData *d) 733{ 734 ExifEntry *e, *em; 735 char value[1024]; 736 737 if (!d) 738 return EXIF_DATA_TYPE_MAKER_NOTE_NONE; 739 740 e = exif_data_get_entry (d, EXIF_TAG_MAKER_NOTE); 741 if (!e) 742 return EXIF_DATA_TYPE_MAKER_NOTE_NONE; 743 744 /* Olympus & Nikon & Sanyo */ 745 if ((e->size >= 8) && ( !memcmp (e->data, "OLYMP", 6) || 746 !memcmp (e->data, "OLYMPUS", 8) || 747 !memcmp (e->data, "SANYO", 6) || 748 !memcmp (e->data, "EPSON", 6) || 749 !memcmp (e->data, "Nikon", 6))) 750 return EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS; 751 752 em = exif_data_get_entry (d, EXIF_TAG_MAKE); 753 if (!em) 754 return EXIF_DATA_TYPE_MAKER_NOTE_NONE; 755 756 /* Canon */ 757 if (!strcmp (exif_entry_get_value (em, value, sizeof (value)), "Canon")) 758 return EXIF_DATA_TYPE_MAKER_NOTE_CANON; 759 760 /* Pentax & some variant of Nikon */ 761 if ((e->size >= 2) && (e->data[0] == 0x00) && (e->data[1] == 0x1b)) { 762 if (!strncasecmp ( 763 exif_entry_get_value (em, value, sizeof(value)), 764 "Nikon", 5)) 765 return EXIF_DATA_TYPE_MAKER_NOTE_NIKON; 766 else 767 return EXIF_DATA_TYPE_MAKER_NOTE_PENTAX; 768 } 769 if ((e->size >= 8) && !memcmp (e->data, "AOC", 4)) { 770 return EXIF_DATA_TYPE_MAKER_NOTE_PENTAX; 771 } 772 if ((e->size >= 8) && !memcmp (e->data, "QVC", 4)) { 773 return EXIF_DATA_TYPE_MAKER_NOTE_CASIO; 774 } 775 if ((e->size >= 12) && !memcmp (e->data, "FUJIFILM", 8)) { 776 return EXIF_DATA_TYPE_MAKER_NOTE_FUJI; 777 } 778 779 return EXIF_DATA_TYPE_MAKER_NOTE_NONE; 780} 781 782#define LOG_TOO_SMALL \ 783exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData", \ 784 _("Size of data too small to allow for EXIF data.")); 785 786void 787exif_data_load_data (ExifData *data, const unsigned char *d_orig, 788 unsigned int ds_orig) 789{ 790 unsigned int l; 791 ExifLong offset; 792 ExifShort n; 793 const unsigned char *d = d_orig; 794 unsigned int ds = ds_orig, len; 795 796 if (!data || !data->priv || !d || !ds) 797 return; 798 799 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 800 "Parsing %i byte(s) EXIF data...\n", ds); 801 802 /* 803 * It can be that the data starts with the EXIF header. If it does 804 * not, search the EXIF marker. 805 */ 806 if (ds < 6) { 807 LOG_TOO_SMALL; 808 return; 809 } 810 if (!memcmp (d, ExifHeader, 6)) { 811 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 812 "Found EXIF header."); 813 } else { 814 while (1) { 815 while ((d[0] == 0xff) && ds) { 816 d++; 817 ds--; 818 } 819 820 /* JPEG_MARKER_SOI */ 821 if (d[0] == JPEG_MARKER_SOI) { 822 d++; 823 ds--; 824 continue; 825 } 826 827 /* JPEG_MARKER_APP0 */ 828 if (d[0] == JPEG_MARKER_APP0) { 829 d++; 830 ds--; 831 l = (d[0] << 8) | d[1]; 832 if (l > ds) 833 return; 834 d += l; 835 ds -= l; 836 continue; 837 } 838 839 /* JPEG_MARKER_APP1 */ 840 if (d[0] == JPEG_MARKER_APP1) 841 break; 842 843 /* Unknown marker or data. Give up. */ 844 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, 845 "ExifData", _("EXIF marker not found.")); 846 return; 847 } 848 d++; 849 ds--; 850 if (ds < 2) { 851 LOG_TOO_SMALL; 852 return; 853 } 854 len = (d[0] << 8) | d[1]; 855 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 856 "We have to deal with %i byte(s) of EXIF data.", 857 len); 858 d += 2; 859 ds -= 2; 860 } 861 862 /* 863 * Verify the exif header 864 * (offset 2, length 6). 865 */ 866 if (ds < 6) { 867 LOG_TOO_SMALL; 868 return; 869 } 870 if (memcmp (d, ExifHeader, 6)) { 871 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, 872 "ExifData", _("EXIF header not found.")); 873 return; 874 } 875 876 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 877 "Found EXIF header."); 878 879 /* Byte order (offset 6, length 2) */ 880 if (ds < 14) 881 return; 882 if (!memcmp (d + 6, "II", 2)) 883 data->priv->order = EXIF_BYTE_ORDER_INTEL; 884 else if (!memcmp (d + 6, "MM", 2)) 885 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA; 886 else { 887 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, 888 "ExifData", _("Unknown encoding.")); 889 return; 890 } 891 892 /* Fixed value */ 893 if (exif_get_short (d + 8, data->priv->order) != 0x002a) 894 return; 895 896 /* IFD 0 offset */ 897 offset = exif_get_long (d + 10, data->priv->order); 898 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 899 "IFD 0 at %i.", (int) offset); 900 901 /* Parse the actual exif data (usually offset 14 from start) */ 902 exif_data_load_data_content (data, EXIF_IFD_0, d + 6, ds - 6, offset, 0); 903 904 /* IFD 1 offset */ 905 if (offset + 6 + 2 > ds) { 906 return; 907 } 908 n = exif_get_short (d + 6 + offset, data->priv->order); 909 if (offset + 6 + 2 + 12 * n + 4 > ds) { 910 return; 911 } 912 offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order); 913 if (offset) { 914 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 915 "IFD 1 at %i.", (int) offset); 916 917 /* Sanity check. */ 918 if (offset > ds - 6) { 919 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, 920 "ExifData", "Bogus offset of IFD1."); 921 } else { 922 exif_data_load_data_content (data, EXIF_IFD_1, d + 6, ds - 6, offset, 0); 923 } 924 } 925 926 /* 927 * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some 928 * cameras use pointers in the maker note tag that point to the 929 * space between IFDs. Here is the only place where we have access 930 * to that data. 931 */ 932 switch (exif_data_get_type_maker_note (data)) { 933 case EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS: 934 case EXIF_DATA_TYPE_MAKER_NOTE_NIKON: 935 data->priv->md = exif_mnote_data_olympus_new (data->priv->mem); 936 break; 937 case EXIF_DATA_TYPE_MAKER_NOTE_PENTAX: 938 case EXIF_DATA_TYPE_MAKER_NOTE_CASIO: 939 data->priv->md = exif_mnote_data_pentax_new (data->priv->mem); 940 break; 941 case EXIF_DATA_TYPE_MAKER_NOTE_CANON: 942 data->priv->md = exif_mnote_data_canon_new (data->priv->mem, data->priv->options); 943 break; 944 case EXIF_DATA_TYPE_MAKER_NOTE_FUJI: 945 data->priv->md = exif_mnote_data_fuji_new (data->priv->mem); 946 break; 947 default: 948 break; 949 } 950 951 /* 952 * If we are able to interpret the maker note, do so. 953 */ 954 if (data->priv->md) { 955 exif_mnote_data_log (data->priv->md, data->priv->log); 956 exif_mnote_data_set_byte_order (data->priv->md, 957 data->priv->order); 958 exif_mnote_data_set_offset (data->priv->md, 959 data->priv->offset_mnote); 960 exif_mnote_data_load (data->priv->md, d, ds); 961 } 962 963 if (data->priv->options & EXIF_DATA_OPTION_FOLLOW_SPECIFICATION) 964 exif_data_fix (data); 965} 966 967void 968exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds) 969{ 970 if (ds) 971 *ds = 0; /* This means something went wrong */ 972 973 if (!data || !d || !ds) 974 return; 975 976 /* Header */ 977 *ds = 14; 978 *d = exif_data_alloc (data, *ds); 979 if (!*d) { 980 *ds = 0; 981 return; 982 } 983 memcpy (*d, ExifHeader, 6); 984 985 /* Order (offset 6) */ 986 if (data->priv->order == EXIF_BYTE_ORDER_INTEL) { 987 memcpy (*d + 6, "II", 2); 988 } else { 989 memcpy (*d + 6, "MM", 2); 990 } 991 992 /* Fixed value (2 bytes, offset 8) */ 993 exif_set_short (*d + 8, data->priv->order, 0x002a); 994 995 /* 996 * IFD 0 offset (4 bytes, offset 10). 997 * We will start 8 bytes after the 998 * EXIF header (2 bytes for order, another 2 for the test, and 999 * 4 bytes for the IFD 0 offset make 8 bytes together). 1000 */ 1001 exif_set_long (*d + 10, data->priv->order, 8); 1002 1003 /* Now save IFD 0. IFD 1 will be saved automatically. */ 1004 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 1005 "Saving IFDs..."); 1006 exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds, 1007 *ds - 6); 1008 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 1009 "Saved %i byte(s) EXIF data.", *ds); 1010} 1011 1012ExifData * 1013exif_data_new_from_file (const char *path) 1014{ 1015 ExifData *edata; 1016 ExifLoader *loader; 1017 1018 loader = exif_loader_new (); 1019 exif_loader_write_file (loader, path); 1020 edata = exif_loader_get_data (loader); 1021 exif_loader_unref (loader); 1022 1023 return (edata); 1024} 1025 1026void 1027exif_data_ref (ExifData *data) 1028{ 1029 if (!data) 1030 return; 1031 1032 data->priv->ref_count++; 1033} 1034 1035void 1036exif_data_unref (ExifData *data) 1037{ 1038 if (!data) 1039 return; 1040 1041 data->priv->ref_count--; 1042 if (!data->priv->ref_count) 1043 exif_data_free (data); 1044} 1045 1046void 1047exif_data_free (ExifData *data) 1048{ 1049 unsigned int i; 1050 ExifMem *mem = (data && data->priv) ? data->priv->mem : NULL; 1051 1052 if (!data) 1053 return; 1054 1055 for (i = 0; i < EXIF_IFD_COUNT; i++) { 1056 if (data->ifd[i]) { 1057 exif_content_unref (data->ifd[i]); 1058 data->ifd[i] = NULL; 1059 } 1060 } 1061 1062 if (data->data) { 1063 exif_mem_free (mem, data->data); 1064 data->data = NULL; 1065 } 1066 1067 if (data->priv) { 1068 if (data->priv->log) { 1069 exif_log_unref (data->priv->log); 1070 data->priv->log = NULL; 1071 } 1072 if (data->priv->md) { 1073 exif_mnote_data_unref (data->priv->md); 1074 data->priv->md = NULL; 1075 } 1076 exif_mem_free (mem, data->priv); 1077 exif_mem_free (mem, data); 1078 } 1079 1080 exif_mem_unref (mem); 1081} 1082 1083void 1084exif_data_dump (ExifData *data) 1085{ 1086 unsigned int i; 1087 1088 if (!data) 1089 return; 1090 1091 for (i = 0; i < EXIF_IFD_COUNT; i++) { 1092 if (data->ifd[i] && data->ifd[i]->count) { 1093 printf ("Dumping IFD '%s'...\n", 1094 exif_ifd_get_name (i)); 1095 exif_content_dump (data->ifd[i], 0); 1096 } 1097 } 1098 1099 if (data->data) { 1100 printf ("%i byte(s) thumbnail data available.", data->size); 1101 if (data->size >= 4) { 1102 printf ("0x%02x 0x%02x ... 0x%02x 0x%02x\n", 1103 data->data[0], data->data[1], 1104 data->data[data->size - 2], 1105 data->data[data->size - 1]); 1106 } 1107 } 1108} 1109 1110ExifByteOrder 1111exif_data_get_byte_order (ExifData *data) 1112{ 1113 if (!data) 1114 return (0); 1115 1116 return (data->priv->order); 1117} 1118 1119void 1120exif_data_foreach_content (ExifData *data, ExifDataForeachContentFunc func, 1121 void *user_data) 1122{ 1123 unsigned int i; 1124 1125 if (!data || !func) 1126 return; 1127 1128 for (i = 0; i < EXIF_IFD_COUNT; i++) 1129 func (data->ifd[i], user_data); 1130} 1131 1132typedef struct _ByteOrderChangeData ByteOrderChangeData; 1133struct _ByteOrderChangeData { 1134 ExifByteOrder old, new; 1135}; 1136 1137static void 1138entry_set_byte_order (ExifEntry *e, void *data) 1139{ 1140 ByteOrderChangeData *d = data; 1141 1142 if (!e) 1143 return; 1144 1145 exif_array_set_byte_order (e->format, e->data, e->components, d->old, d->new); 1146} 1147 1148static void 1149content_set_byte_order (ExifContent *content, void *data) 1150{ 1151 exif_content_foreach_entry (content, entry_set_byte_order, data); 1152} 1153 1154void 1155exif_data_set_byte_order (ExifData *data, ExifByteOrder order) 1156{ 1157 ByteOrderChangeData d; 1158 1159 if (!data || (order == data->priv->order)) 1160 return; 1161 1162 d.old = data->priv->order; 1163 d.new = order; 1164 exif_data_foreach_content (data, content_set_byte_order, &d); 1165 data->priv->order = order; 1166 if (data->priv->md) 1167 exif_mnote_data_set_byte_order (data->priv->md, order); 1168} 1169 1170void 1171exif_data_log (ExifData *data, ExifLog *log) 1172{ 1173 unsigned int i; 1174 1175 if (!data || !data->priv) 1176 return; 1177 exif_log_unref (data->priv->log); 1178 data->priv->log = log; 1179 exif_log_ref (log); 1180 1181 for (i = 0; i < EXIF_IFD_COUNT; i++) 1182 exif_content_log (data->ifd[i], log); 1183} 1184 1185/* Used internally within libexif */ 1186ExifLog *exif_data_get_log (ExifData *); 1187ExifLog * 1188exif_data_get_log (ExifData *data) 1189{ 1190 if (!data || !data->priv) 1191 return NULL; 1192 return data->priv->log; 1193} 1194 1195static const struct { 1196 ExifDataOption option; 1197 const char *name; 1198 const char *description; 1199} exif_data_option[] = { 1200 {EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS, N_("Ignore unknown tags"), 1201 N_("Ignore unknown tags when loading EXIF data.")}, 1202 {EXIF_DATA_OPTION_FOLLOW_SPECIFICATION, N_("Follow specification"), 1203 N_("Add, correct and remove entries to get EXIF data that follows " 1204 "the specification.")}, 1205 {EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE, N_("Do not change maker note"), 1206 N_("When loading and resaving Exif data, save the maker note unmodified." 1207 " Be aware that the maker note can get corrupted.")}, 1208 {0, NULL, NULL} 1209}; 1210 1211const char * 1212exif_data_option_get_name (ExifDataOption o) 1213{ 1214 unsigned int i; 1215 1216 for (i = 0; exif_data_option[i].name; i++) 1217 if (exif_data_option[i].option == o) 1218 break; 1219 return _(exif_data_option[i].name); 1220} 1221 1222const char * 1223exif_data_option_get_description (ExifDataOption o) 1224{ 1225 unsigned int i; 1226 1227 for (i = 0; exif_data_option[i].description; i++) 1228 if (exif_data_option[i].option == o) 1229 break; 1230 return _(exif_data_option[i].description); 1231} 1232 1233void 1234exif_data_set_option (ExifData *d, ExifDataOption o) 1235{ 1236 if (!d) 1237 return; 1238 1239 d->priv->options |= o; 1240} 1241 1242void 1243exif_data_unset_option (ExifData *d, ExifDataOption o) 1244{ 1245 if (!d) 1246 return; 1247 1248 d->priv->options &= ~o; 1249} 1250 1251static void 1252fix_func (ExifContent *c, void *UNUSED(data)) 1253{ 1254 switch (exif_content_get_ifd (c)) { 1255 case EXIF_IFD_1: 1256 if (c->parent->data) 1257 exif_content_fix (c); 1258 else { 1259 exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data", 1260 "No thumbnail but entries on thumbnail. These entries have been " 1261 "removed."); 1262 while (c->count) { 1263 unsigned int cnt = c->count; 1264 exif_content_remove_entry (c, c->entries[c->count - 1]); 1265 if (cnt == c->count) { 1266 /* safety net */ 1267 exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data", 1268 "failed to remove last entry from entries."); 1269 c->count--; 1270 } 1271 } 1272 } 1273 break; 1274 default: 1275 exif_content_fix (c); 1276 } 1277} 1278 1279void 1280exif_data_fix (ExifData *d) 1281{ 1282 exif_data_foreach_content (d, fix_func, NULL); 1283} 1284 1285void 1286exif_data_set_data_type (ExifData *d, ExifDataType dt) 1287{ 1288 if (!d || !d->priv) 1289 return; 1290 1291 d->priv->data_type = dt; 1292} 1293 1294ExifDataType 1295exif_data_get_data_type (ExifData *d) 1296{ 1297 return (d && d->priv) ? d->priv->data_type : EXIF_DATA_TYPE_UNKNOWN; 1298} 1299