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