libexif/exif-data.c

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