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