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