libexif/exif-data.c

   1 /* exif-data.c
   2  *
   3  * Copyright © 2001 Lutz Müller <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., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <config.h>
  22 #include "exif-mnote-data.h"
  23
  24 #include "exif-data.h"
  25 #include "exif-ifd.h"
  26 #include "exif-mnote-data-priv.h"
  27 #include "exif-utils.h"
  28 #include "exif-loader.h"
  29 #include "jpeg-marker.h"
  30 #include <libexif/exif-log.h>
  31
  32 #include <libexif/olympus/exif-mnote-data-olympus.h>
  33 #include <libexif/canon/exif-mnote-data-canon.h>
  34 #include <libexif/pentax/exif-mnote-data-pentax.h>
  35
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39
  40 #undef MAX
  41 #define MAX(a, b)  (((a) > (b)) ? (a) : (b))
  42
  43 #if defined(__WATCOMC__) || defined(_MSC_VER)
  44 #      define strncasecmp strnicmp
  45 #endif
  46
  47 static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
  48
  49 struct _ExifDataPrivate
  50 {
  51         ExifByteOrder order;
  52
  53         ExifMnoteData *md;
  54
  55         ExifLog *log;
  56         ExifMem *mem;
  57
  58         unsigned int ref_count;
  59
  60         /* Temporarily used while loading data */
  61         unsigned int offset_mnote;
  62 };
  63
  64 static void *
  65 exif_data_alloc (ExifData *data, unsigned int i)
  66 {
  67         void *d;
  68
  69         if (!data || !i) return NULL;
  70
  71         d = exif_mem_alloc (data->priv->mem, i);
  72         if (d) return d;
  73
  74         EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i);
  75         return NULL;
  76 }
  77
  78 ExifMnoteData *
  79 exif_data_get_mnote_data (ExifData *d)
  80 {
  81         return (d && d->priv) ? d->priv->md : NULL;
  82 }
  83
  84 ExifData *
  85 exif_data_new (void)
  86 {
  87         ExifMem *mem = exif_mem_new_default ();
  88         ExifData *d = exif_data_new_mem (mem);
  89
  90         exif_mem_unref (mem);
  91
  92         return d;
  93 }
  94
  95 ExifData *
  96 exif_data_new_mem (ExifMem *mem)
  97 {
  98         ExifData *data;
  99         unsigned int i;
 100
 101         if (!mem) return NULL;
 102
 103         data = exif_mem_alloc (mem, sizeof (ExifData));
 104         if (!data) return (NULL);
 105         data->priv = exif_mem_alloc (mem, sizeof (ExifDataPrivate));
 106         if (!data->priv) { exif_mem_free (mem, data); return (NULL); }
 107         data->priv->ref_count = 1;
 108
 109         data->priv->mem = mem;
 110         exif_mem_ref (mem);
 111
 112         for (i = 0; i < EXIF_IFD_COUNT; i++) {
 113                 data->ifd[i] = exif_content_new_mem (data->priv->mem);
 114                 if (!data->ifd[i]) {
 115                         exif_data_free (data);
 116                         return (NULL);
 117                 }
 118                 data->ifd[i]->parent = data;
 119         }
 120
 121         return (data);
 122 }
 123
 124 ExifData *
 125 exif_data_new_from_data (const unsigned char *data, unsigned int size)
 126 {
 127         ExifData *edata;
 128
 129         edata = exif_data_new ();
 130         exif_data_load_data (edata, data, size);
 131         return (edata);
 132 }
 133
 134 static void
 135 exif_data_load_data_entry (ExifData *data, ExifEntry *entry,
 136                            const unsigned char *d,
 137                            unsigned int size, unsigned int offset)
 138 {
 139         unsigned int s, doff;
 140
 141         entry->tag        = exif_get_short (d + offset + 0, data->priv->order);
 142         entry->format     = exif_get_short (d + offset + 2, data->priv->order);
 143         entry->components = exif_get_long  (d + offset + 4, data->priv->order);
 144
 145         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 146                   "Loading entry 0x%x ('%s')...", entry->tag,
 147                   exif_tag_get_name (entry->tag));
 148
 149         /*
 150          * Size? If bigger than 4 bytes, the actual data is not
 151          * in the entry but somewhere else (offset).
 152          */
 153         s = exif_format_get_size (entry->format) * entry->components;
 154         if (!s)
 155                 return;
 156         if (s > 4)
 157                 doff = exif_get_long (d + offset + 8, data->priv->order);
 158         else
 159                 doff = offset + 8;
 160
 161         /* Sanity check */
 162         if (size < doff + s)
 163                 return;
 164
 165         entry->data = exif_data_alloc (data, s);
 166         if (entry->data) {
 167                 entry->size = s;
 168                 memcpy (entry->data, d + doff, s);
 169         }
 170
 171 #ifndef EXIF_DONT_CHANGE_MAKER_NOTE
 172         /* If this is the MakerNote, remember the offset */
 173         if (entry->tag == EXIF_TAG_MAKER_NOTE) {
 174                 if (entry->size > 6) exif_log (data->priv->log,
 175                           EXIF_LOG_CODE_DEBUG, "ExifData",
 176                           "MakerNote found (%02x %02x %02x %02x "
 177                           "%02x %02x %02x...).",
 178                           entry->data[0], entry->data[1], entry->data[2],
 179                           entry->data[3], entry->data[4], entry->data[5],
 180                           entry->data[6]);
 181                 data->priv->offset_mnote = doff;
 182         }
 183 #endif
 184
 185         exif_entry_fix (entry);
 186 }
 187
 188 static void
 189 exif_data_save_data_entry (ExifData *data, ExifEntry *e,
 190                            unsigned char **d, unsigned int *ds,
 191                            unsigned int offset)
 192 {
 193         unsigned int doff, s;
 194
 195         if (!data || !data->priv) return;
 196
 197         /*
 198          * Each entry is 12 bytes long. The memory for the entry has
 199          * already been allocated.
 200          */
 201         exif_set_short (*d + 6 + offset + 0,
 202                         data->priv->order, (ExifShort) e->tag);
 203         exif_set_short (*d + 6 + offset + 2,
 204                         data->priv->order, (ExifShort) e->format);
 205
 206         /* If this is the maker note tag, update it. */
 207         if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
 208                 exif_mem_free (data->priv->mem, e->data);
 209                 e->data = NULL;
 210                 e->size = 0;
 211                 exif_mnote_data_set_offset (data->priv->md, *ds - 6);
 212                 exif_mnote_data_save (data->priv->md, &e->data, &e->size);
 213                 e->components = e->size;
 214         }
 215
 216         exif_set_long  (*d + 6 + offset + 4,
 217                         data->priv->order, e->components);
 218
 219         /*
 220          * Size? If bigger than 4 bytes, the actual data is not in
 221          * the entry but somewhere else.
 222          */
 223         s = exif_format_get_size (e->format) * e->components;
 224         if (s > 4) {
 225                 doff = *ds - 6;
 226                 *ds += s;
 227                 *d = exif_mem_realloc (data->priv->mem, *d, *ds);
 228                 if (!*d) {
 229                         EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", *ds);
 230                         return;
 231                 }
 232                 exif_set_long (*d + 6 + offset + 8,
 233                                data->priv->order, doff);
 234         } else
 235                 doff = offset + 8;
 236
 237         /* Write the data. Fill unneeded bytes with 0. */
 238         memcpy (*d + 6 + doff, e->data, s);
 239         if (s < 4) memset (*d + 6 + doff + s, 0, (4 - s));
 240 }
 241
 242 static void
 243 exif_data_load_data_thumbnail (ExifData *data, const unsigned char *d,
 244                                unsigned int ds, ExifLong offset, ExifLong size)
 245 {
 246         if (ds < offset + size) {
 247                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 248                           "Bogus thumbnail offset and size: %i < %i + %i.",
 249                           (int) ds, (int) offset, (int) size);
 250                 return;
 251         }
 252         if (data->data) exif_mem_free (data->priv->mem, data->data);
 253         data->size = size;
 254         data->data = exif_data_alloc (data, data->size);
 255         if (!data->data) return;
 256         memcpy (data->data, d + offset, data->size);
 257 }
 258
 259 #undef CHECK_REC
 260 #define CHECK_REC(i)                                    \
 261 if (data->ifd[(i)] == ifd) {                            \
 262         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
 263                 "ExifData", "Recursive entry in IFD "   \
 264                 "'%s' detected. Skipping...",           \
 265                 exif_ifd_get_name (i));                 \
 266         break;                                          \
 267 }
 268
 269 static void
 270 exif_data_load_data_content (ExifData *data, ExifContent *ifd,
 271                              const unsigned char *d,
 272                              unsigned int ds, unsigned int offset)
 273 {
 274         ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
 275         ExifShort n;
 276         ExifEntry *entry;
 277         unsigned int i;
 278         ExifTag tag;
 279
 280         if (!data || !data->priv) return;
 281
 282         /* Read the number of entries */
 283         if (offset >= ds - 1) return;
 284         n = exif_get_short (d + offset, data->priv->order);
 285         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 286                   "Loading %i entries...", n);
 287         offset += 2;
 288
 289         /* Check if we have enough data. */
 290         if (offset + 12 * n > ds) n = (ds - offset) / 12;
 291
 292         for (i = 0; i < n; i++) {
 293
 294                 tag = exif_get_short (d + offset + 12 * i, data->priv->order);
 295                 switch (tag) {
 296                 case EXIF_TAG_EXIF_IFD_POINTER:
 297                 case EXIF_TAG_GPS_INFO_IFD_POINTER:
 298                 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
 299                 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
 300                 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
 301                         o = exif_get_long (d + offset + 12 * i + 8,
 302                                            data->priv->order);
 303                         switch (tag) {
 304                         case EXIF_TAG_EXIF_IFD_POINTER:
 305                                 CHECK_REC (EXIF_IFD_EXIF);
 306                                 exif_data_load_data_content (data,
 307                                         data->ifd[EXIF_IFD_EXIF], d, ds, o);
 308                                 break;
 309                         case EXIF_TAG_GPS_INFO_IFD_POINTER:
 310                                 CHECK_REC (EXIF_IFD_GPS);
 311                                 exif_data_load_data_content (data,
 312                                         data->ifd[EXIF_IFD_GPS], d, ds, o);
 313                                 break;
 314                         case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
 315                                 CHECK_REC (EXIF_IFD_INTEROPERABILITY);
 316                                 exif_data_load_data_content (data,
 317                                         data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds, o);
 318                                 break;
 319                         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
 320                                 thumbnail_offset = o;
 321                                 if (thumbnail_offset && thumbnail_length)
 322                                         exif_data_load_data_thumbnail (data, d,
 323                                                 ds, thumbnail_offset,
 324                                                 thumbnail_length);
 325                                 break;
 326                         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
 327                                 thumbnail_length = o;
 328                                 if (thumbnail_offset && thumbnail_length)
 329                                         exif_data_load_data_thumbnail (data, d,
 330                                                 ds, thumbnail_offset,
 331                                                 thumbnail_length);
 332                                 break;
 333                         default:
 334                                 return;
 335                         }
 336                         break;
 337                 default:
 338
 339                         /*
 340                          * If we don't know the tag, changes are high
 341                          * that the EXIF data does not follow the standard.
 342                          */
 343                         if (!exif_tag_get_name (tag)) {
 344                                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 345                                   "Unknown tag %x (entry %i)", tag, i);
 346                                 return;
 347                         }
 348                         entry = exif_entry_new_mem (data->priv->mem);
 349                         exif_content_add_entry (ifd, entry);
 350                         exif_data_load_data_entry (data, entry, d, ds,
 351                                                    offset + 12 * i);
 352                         exif_entry_unref (entry);
 353                         break;
 354                 }
 355         }
 356 }
 357
 358 static void
 359 exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 360                              unsigned char **d, unsigned int *ds,
 361                              unsigned int offset)
 362 {
 363         unsigned int j, n_ptr = 0, n_thumb = 0;
 364         ExifIfd i;
 365
 366         if (!data || !data->priv || !ifd || !d || !ds) return;
 367
 368         for (i = 0; i < EXIF_IFD_COUNT; i++)
 369                 if (ifd == data->ifd[i])
 370                         break;
 371         if (i == EXIF_IFD_COUNT)
 372                 return;
 373
 374         /*
 375          * Check if we need some extra entries for pointers or the thumbnail.
 376          */
 377         switch (i) {
 378         case EXIF_IFD_0:
 379
 380                 /*
 381                  * The pointer to IFD_EXIF is in IFD_0. The pointer to
 382                  * IFD_INTEROPERABILITY is in IFD_EXIF.
 383                  */
 384                 if (data->ifd[EXIF_IFD_EXIF]->count ||
 385                     data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
 386                         n_ptr++;
 387
 388                 /* The pointer to IFD_GPS is in IFD_0. */
 389                 if (data->ifd[EXIF_IFD_GPS]->count)
 390                         n_ptr++;
 391
 392                 break;
 393         case EXIF_IFD_1:
 394                 if (data->size)
 395                         n_thumb = 2;
 396                 break;
 397         case EXIF_IFD_EXIF:
 398                 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
 399                         n_ptr++;
 400         default:
 401                 break;
 402         }
 403
 404         /*
 405          * Allocate enough memory for all entries
 406          * and the number of entries.
 407          */
 408         *ds += (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
 409         *d = exif_mem_realloc (data->priv->mem, *d, *ds);
 410         if (!*d) {
 411                 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", *ds);
 412                 return;
 413         }
 414
 415         /* Save the number of entries */
 416         exif_set_short (*d + 6 + offset, data->priv->order,
 417                         (ExifShort) (ifd->count + n_ptr + n_thumb));
 418         offset += 2;
 419
 420         /* Save each entry */
 421         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 422                   "Saving %i entries (IFD '%s', offset: %i)...",
 423                   ifd->count, exif_ifd_get_name (i), offset);
 424         for (j = 0; j < ifd->count; j++)
 425                 exif_data_save_data_entry (data, ifd->entries[j],
 426                                 d, ds, offset + 12 * j);
 427         offset += 12 * ifd->count;
 428
 429         /* Now save special entries. */
 430         switch (i) {
 431         case EXIF_IFD_0:
 432
 433                 /*
 434                  * The pointer to IFD_EXIF is in IFD_0.
 435                  * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
 436                  * therefore, if IFD_INTEROPERABILITY is not empty, we need
 437                  * IFD_EXIF even if latter is empty.
 438                  */
 439                 if (data->ifd[EXIF_IFD_EXIF]->count ||
 440                     data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
 441                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 442                                         EXIF_TAG_EXIF_IFD_POINTER);
 443                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 444                                         EXIF_FORMAT_LONG);
 445                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 446                                         1);
 447                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 448                                         *ds - 6);
 449                         exif_data_save_data_content (data,
 450                                 data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
 451                         offset += 12;
 452                 }
 453
 454                 /* The pointer to IFD_GPS is in IFD_0, too. */
 455                 if (data->ifd[EXIF_IFD_GPS]->count) {
 456                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 457                                         EXIF_TAG_GPS_INFO_IFD_POINTER);
 458                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 459                                         EXIF_FORMAT_LONG);
 460                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 461                                         1);
 462                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 463                                         *ds - 6);
 464                         exif_data_save_data_content (data,
 465                                 data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
 466                         offset += 12;
 467                 }
 468
 469                 break;
 470         case EXIF_IFD_EXIF:
 471
 472                 /*
 473                  * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
 474                  * See note above.
 475                  */
 476                 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
 477                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 478                                         EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
 479                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 480                                         EXIF_FORMAT_LONG);
 481                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 482                                         1);
 483                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 484                                         *ds - 6);
 485                         exif_data_save_data_content (data,
 486                                 data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
 487                                 *ds - 6);
 488                         offset += 12;
 489                 }
 490
 491                 break;
 492         case EXIF_IFD_1:
 493
 494                 /*
 495                  * Information about the thumbnail (if any) is saved in
 496                  * IFD_1.
 497                  */
 498                 if (data->size) {
 499
 500                         /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
 501                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 502                                         EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
 503                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 504                                         EXIF_FORMAT_LONG);
 505                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 506                                         1);
 507                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 508                                         *ds - 6);
 509                         *ds += data->size;
 510                         *d = exif_mem_realloc (data->priv->mem, *d, *ds);
 511                         if (!*d) {
 512                                 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData",
 513                                                     *ds);
 514                                 return;
 515                         }
 516                         memcpy (*d + *ds - data->size, data->data, data->size);
 517                         offset += 12;
 518
 519                         /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
 520                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 521                                 EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
 522                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 523                                         EXIF_FORMAT_LONG);
 524                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 525                                         1);
 526                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 527                                         data->size);
 528                         offset += 12;
 529                 }
 530
 531                 break;
 532         default:
 533                 break;
 534         }
 535
 536         /* Correctly terminate the directory */
 537         if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
 538                                              data->size)) {
 539
 540                 /*
 541                  * We are saving IFD 0. Tell where IFD 1 starts and save
 542                  * IFD 1.
 543                  */
 544                 exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6);
 545                 exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds,
 546                                              *ds - 6);
 547         } else
 548                 exif_set_long (*d + 6 + offset, data->priv->order, 0);
 549 }
 550
 551 void
 552 exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 553                      unsigned int ds_orig)
 554 {
 555         unsigned int l;
 556         ExifLong offset;
 557         ExifShort n;
 558         ExifEntry *e, *em;
 559         const unsigned char *d = d_orig;
 560         unsigned int ds = ds_orig, len;
 561
 562         if (!data || !data->priv || !d || !ds) return;
 563
 564         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 565                   "Parsing %i byte(s) EXIF data...\n", ds);
 566
 567         /*
 568          * It can be that the data starts with the EXIF header. If it does
 569          * not, search the EXIF marker.
 570          */
 571         if (ds < 6) {
 572                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 573                           "Size too small.");
 574                 return;
 575         }
 576         if (!memcmp (d, ExifHeader, 6)) {
 577                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 578                           "Found EXIF header.");
 579         } else {
 580                 while (1) {
 581                         while ((d[0] == 0xff) && ds) {
 582                                 d++;
 583                                 ds--;
 584                         }
 585
 586                         /* JPEG_MARKER_SOI */
 587                         if (d[0] == JPEG_MARKER_SOI) {
 588                                 d++;
 589                                 ds--;
 590                                 continue;
 591                         }
 592
 593                         /* JPEG_MARKER_APP0 */
 594                         if (d[0] == JPEG_MARKER_APP0) {
 595                                 d++;
 596                                 ds--;
 597                                 l = (d[0] << 8) | d[1];
 598                                 if (l > ds)
 599                                         return;
 600                                 d += l;
 601                                 ds -= l;
 602                                 continue;
 603                         }
 604
 605                         /* JPEG_MARKER_APP1 */
 606                         if (d[0] == JPEG_MARKER_APP1)
 607                                 break;
 608
 609                         /* Unknown marker or data. Give up. */
 610                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 611                                   "ExifData", "EXIF marker not found.");
 612                         return;
 613                 }
 614                 d++;
 615                 ds--;
 616                 if (ds < 2) {
 617                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 618                                   "ExifData", "Size too small.");
 619                         return;
 620                 }
 621                 len = (d[0] << 8) | d[1];
 622                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 623                           "We have to deal with %i byte(s) of EXIF data.",
 624                           len);
 625                 d += 2;
 626                 ds -= 2;
 627         }
 628
 629         /*
 630          * Verify the exif header
 631          * (offset 2, length 6).
 632          */
 633         if (ds < 6) {
 634                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 635                           "Size too small.");
 636                 return;
 637         }
 638         if (memcmp (d, ExifHeader, 6)) {
 639                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 640                           "EXIF header not found.");
 641                 return;
 642         }
 643
 644         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 645                   "Found EXIF header.");
 646
 647         /* Byte order (offset 6, length 2) */
 648         if (ds < 12)
 649                 return;
 650         if (!memcmp (d + 6, "II", 2))
 651                 data->priv->order = EXIF_BYTE_ORDER_INTEL;
 652         else if (!memcmp (d + 6, "MM", 2))
 653                 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
 654         else
 655                 return;
 656
 657         /* Fixed value */
 658         if (exif_get_short (d + 8, data->priv->order) != 0x002a)
 659                 return;
 660
 661         /* IFD 0 offset */
 662         offset = exif_get_long (d + 10, data->priv->order);
 663         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 664                   "IFD 0 at %i.", (int) offset);
 665
 666         /* Parse the actual exif data (offset 14) */
 667         exif_data_load_data_content (data, data->ifd[EXIF_IFD_0], d + 6,
 668                                      ds - 6, offset);
 669
 670         /* IFD 1 offset */
 671         n = exif_get_short (d + 6 + offset, data->priv->order);
 672         offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order);
 673         if (offset) {
 674                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 675                           "IFD 1 at %i.", (int) offset);
 676
 677                 /* Sanity check. */
 678                 if (offset > ds - 6) {
 679                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 680                                   "ExifData", "Bogus offset!");
 681                         return;
 682                 }
 683
 684                 exif_data_load_data_content (data, data->ifd[EXIF_IFD_1], d + 6,
 685                                              ds - 6, offset);
 686         }
 687
 688         /*
 689          * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
 690          * cameras use pointers in the maker note tag that point to the
 691          * space between IFDs. Here is the only place where we have access
 692          * to that data.
 693          */
 694         e = exif_data_get_entry (data, EXIF_TAG_MAKER_NOTE);
 695         if (e) {
 696
 697             /* Olympus & Nikon */
 698             if ((e->size >= 5) && (!memcmp (e->data, "OLYMP", 5) ||
 699                                    !memcmp (e->data, "Nikon", 5))) {
 700                         data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
 701             } else {
 702                         char value[7];
 703                         em = exif_data_get_entry (data, EXIF_TAG_MAKE);
 704                         /* Pentax & some variant of Nikon */
 705                         if ((e->size >= 2) && (e->data[0] == 0x00)
 706                                     && (e->data[1] == 0x1b)) {
 707                                 if (em && !strncasecmp (exif_entry_get_value (em, value, sizeof(value)), "Nikon", 5)) {
 708                                         data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
 709                                 } else {
 710                                         data->priv->md = exif_mnote_data_pentax_new (data->priv->mem);
 711                                 }
 712
 713                         } else {
 714                                 /* Canon */
 715                                 if (em) {
 716
 717                                         if (!strcmp (exif_entry_get_value (em, value, sizeof(value)), "Canon"))
 718                                                 data->priv->md = exif_mnote_data_canon_new (data->priv->mem);
 719                                 }
 720                         }
 721                 }
 722
 723             /*
 724              * If we are able to interpret the maker note, do so.
 725              */
 726             if (data->priv->md) {
 727                     exif_mnote_data_log (data->priv->md, data->priv->log);
 728                     exif_mnote_data_set_byte_order (data->priv->md,
 729                                                     data->priv->order);
 730                     exif_mnote_data_set_offset (data->priv->md,
 731                                                 data->priv->offset_mnote);
 732                     exif_mnote_data_load (data->priv->md, d, ds);
 733             }
 734         }
 735 }
 736
 737 void
 738 exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds)
 739 {
 740         if (!data || !d || !ds)
 741                 return;
 742
 743         /* Header */
 744         *ds = 14;
 745         *d = exif_data_alloc (data, *ds);
 746         if (!*d) return;
 747         memcpy (*d, ExifHeader, 6);
 748
 749         /* Order (offset 6) */
 750         if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
 751                 memcpy (*d + 6, "II", 2);
 752         } else {
 753                 memcpy (*d + 6, "MM", 2);
 754         }
 755
 756         /* Fixed value (2 bytes, offset 8) */
 757         exif_set_short (*d + 8, data->priv->order, 0x002a);
 758
 759         /*
 760          * IFD 0 offset (4 bytes, offset 10).
 761          * We will start 8 bytes after the
 762          * EXIF header (2 bytes for order, another 2 for the test, and
 763          * 4 bytes for the IFD 0 offset make 8 bytes together).
 764          */
 765         exif_set_long (*d + 10, data->priv->order, 8);
 766
 767         /* Now save IFD 0. IFD 1 will be saved automatically. */
 768         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 769                   "Saving IFDs...");
 770         exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds,
 771                                      *ds - 6);
 772         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 773                   "Saved %i byte(s) EXIF data.", *ds);
 774 }
 775
 776 ExifData *
 777 exif_data_new_from_file (const char *path)
 778 {
 779         ExifData *edata;
 780         ExifLoader *loader;
 781
 782         loader = exif_loader_new ();
 783         exif_loader_write_file (loader, path);
 784         edata = exif_loader_get_data (loader);
 785         exif_loader_unref (loader);
 786
 787         return (edata);
 788 }
 789
 790 void
 791 exif_data_ref (ExifData *data)
 792 {
 793         if (!data)
 794                 return;
 795
 796         data->priv->ref_count++;
 797 }
 798
 799 void
 800 exif_data_unref (ExifData *data)
 801 {
 802         if (!data)
 803                 return;
 804
 805         data->priv->ref_count--;
 806         if (!data->priv->ref_count)
 807                 exif_data_free (data);
 808 }
 809
 810 void
 811 exif_data_free (ExifData *data)
 812 {
 813         unsigned int i;
 814
 815         if (!data) return;
 816
 817         for (i = 0; i < EXIF_IFD_COUNT; i++) {
 818                 if (data->ifd[i]) {
 819                         exif_content_unref (data->ifd[i]);
 820                         data->ifd[i] = NULL;
 821                 }
 822         }
 823
 824         if (data->priv) {
 825                 ExifMem *mem = data->priv->mem;
 826                 if (data->data) {
 827                         exif_mem_free (data->priv->mem, data->data);
 828                         data->data = NULL;
 829                 }
 830                 if (data->priv->md) {
 831                         exif_mnote_data_unref (data->priv->md);
 832                         data->priv->md = NULL;
 833                 }
 834                 exif_mem_free (mem, data->priv);
 835                 exif_mem_free (mem, data);
 836                 exif_mem_unref (mem);
 837         }
 838 }
 839
 840 void
 841 exif_data_dump (ExifData *data)
 842 {
 843         unsigned int i;
 844
 845         if (!data)
 846                 return;
 847
 848         for (i = 0; i < EXIF_IFD_COUNT; i++) {
 849                 if (data->ifd[i] && data->ifd[i]->count) {
 850                         printf ("Dumping IFD '%s'...\n",
 851                                 exif_ifd_get_name (i));
 852                         exif_content_dump (data->ifd[i], 0);
 853                 }
 854         }
 855
 856         if (data->data) {
 857                 printf ("%i byte(s) thumbnail data available.", data->size);
 858                 if (data->size >= 4) {
 859                         printf ("0x%02x 0x%02x ... 0x%02x 0x%02x\n",
 860                                 data->data[0], data->data[1],
 861                                 data->data[data->size - 2],
 862                                 data->data[data->size - 1]);
 863                 }
 864         }
 865 }
 866
 867 ExifByteOrder
 868 exif_data_get_byte_order (ExifData *data)
 869 {
 870         if (!data)
 871                 return (0);
 872
 873         return (data->priv->order);
 874 }
 875
 876 void
 877 exif_data_foreach_content (ExifData *data, ExifDataForeachContentFunc func,
 878                            void *user_data)
 879 {
 880         unsigned int i;
 881
 882         if (!data || !func)
 883                 return;
 884
 885         for (i = 0; i < EXIF_IFD_COUNT; i++)
 886                 func (data->ifd[i], user_data);
 887 }
 888
 889 typedef struct _ByteOrderChangeData ByteOrderChangeData;
 890 struct _ByteOrderChangeData {
 891         ExifByteOrder old, new;
 892 };
 893
 894 static void
 895 entry_set_byte_order (ExifEntry *e, void *data)
 896 {
 897         ByteOrderChangeData *d = data;
 898         unsigned int i;
 899         ExifShort s;
 900         ExifLong l;
 901         ExifSLong sl;
 902         ExifRational r;
 903         ExifSRational sr;
 904
 905         if (!e)
 906                 return;
 907
 908         switch (e->format) {
 909         case EXIF_FORMAT_SHORT:
 910                 for (i = 0; i < e->components; i++) {
 911                         s = exif_get_short (e->data +
 912                                 (i * exif_format_get_size (e->format)),
 913                                 d->old);
 914                         exif_set_short (e->data +
 915                                 (i * exif_format_get_size (e->format)),
 916                                 d->new, s);
 917                 }
 918                 break;
 919         case EXIF_FORMAT_LONG:
 920                 for (i = 0; i < e->components; i++) {
 921                         l = exif_get_long (e->data +
 922                                 (i * exif_format_get_size (e->format)),
 923                                 d->old);
 924                         exif_set_long (e->data +
 925                                 (i * exif_format_get_size (e->format)),
 926                                 d->new, l);
 927                 }
 928                 break;
 929         case EXIF_FORMAT_RATIONAL:
 930                 for (i = 0; i < e->components; i++) {
 931                         r = exif_get_rational (e->data +
 932                                 (i * exif_format_get_size (e->format)),
 933                                 d->old);
 934                         exif_set_rational (e->data +
 935                                 (i * exif_format_get_size (e->format)),
 936                                 d->new, r);
 937                 }
 938                 break;
 939         case EXIF_FORMAT_SLONG:
 940                 for (i = 0; i < e->components; i++) {
 941                         sl = exif_get_slong (e->data +
 942                                 (i * exif_format_get_size (e->format)),
 943                                 d->old);
 944                         exif_set_slong (e->data +
 945                                 (i * exif_format_get_size (e->format)),
 946                                 d->new, sl);
 947                 }
 948                 break;
 949         case EXIF_FORMAT_SRATIONAL:
 950                 for (i = 0; i < e->components; i++) {
 951                         sr = exif_get_srational (e->data +
 952                                 (i * exif_format_get_size (e->format)),
 953                                 d->old);
 954                         exif_set_srational (e->data +
 955                                 (i * exif_format_get_size (e->format)),
 956                                 d->new, sr);
 957                 }
 958                 break;
 959         case EXIF_FORMAT_UNDEFINED:
 960         case EXIF_FORMAT_BYTE:
 961         case EXIF_FORMAT_SBYTE:
 962         case EXIF_FORMAT_ASCII:
 963         default:
 964                 /* Nothing here. */
 965                 break;
 966         }
 967 }
 968
 969 static void
 970 content_set_byte_order (ExifContent *content, void *data)
 971 {
 972         exif_content_foreach_entry (content, entry_set_byte_order, data);
 973 }
 974
 975 void
 976 exif_data_set_byte_order (ExifData *data, ExifByteOrder order)
 977 {
 978         ByteOrderChangeData d;
 979
 980         if (!data || (order == data->priv->order))
 981                 return;
 982
 983         d.old = data->priv->order;
 984         d.new = order;
 985         exif_data_foreach_content (data, content_set_byte_order, &d);
 986         data->priv->order = order;
 987         if (data->priv->md)
 988                 exif_mnote_data_set_byte_order (data->priv->md, order);
 989 }
 990
 991 void
 992 exif_data_log (ExifData *data, ExifLog *log)
 993 {
 994         if (!data || !data->priv) return;
 995         exif_log_unref (data->priv->log);
 996         data->priv->log = log;
 997         exif_log_ref (log);
 998 }
 999
1000 /* Used internally within libexif */
1001 ExifLog *exif_data_get_log (ExifData *);
1002 ExifLog *
1003 exif_data_get_log (ExifData *data)
1004 {
1005         if (!data || !data->priv) return NULL;
1006         return data->priv->log;
1007 }