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