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)
 184                 return;
 185         if (s > 4) {
 186                 doff = *ds - 6;
 187                 *ds += s;
 188                 *d = realloc (*d, sizeof (char) * *ds);
 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, e->size);
 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 (sizeof (char) * data->size);
 214         memcpy (data->data, d + offset, data->size);
 215 }
 216
 217 static void
 218 exif_data_load_data_content (ExifData *data, ExifContent *ifd,
 219                              const unsigned char *d,
 220                              unsigned int ds, unsigned int offset)
 221 {
 222         ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
 223         ExifShort n;
 224         ExifEntry *entry;
 225         unsigned int i;
 226         ExifTag tag;
 227
 228         /* Read the number of entries */
 229         if (offset >= ds - 1) return;
 230         n = exif_get_short (d + offset, data->priv->order);
 231 #ifdef DEBUG
 232         printf ("Loading %i entries...\n", n);
 233 #endif
 234         offset += 2;
 235
 236         /* Check if we have enough data. */
 237         if (offset + 12 * n > ds) n = (ds - offset) / 12;
 238
 239         for (i = 0; i < n; i++) {
 240
 241                 tag = exif_get_short (d + offset + 12 * i, data->priv->order);
 242 #ifdef DEBUG
 243                 printf ("Loading entry '%s' (%i of %i)...\n",
 244                         exif_tag_get_name (tag), i + 1, n);
 245 #endif
 246                 switch (tag) {
 247                 case EXIF_TAG_EXIF_IFD_POINTER:
 248                 case EXIF_TAG_GPS_INFO_IFD_POINTER:
 249                 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
 250                 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
 251                 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
 252                         o = exif_get_long (d + offset + 12 * i + 8,
 253                                            data->priv->order);
 254                         switch (tag) {
 255                         case EXIF_TAG_EXIF_IFD_POINTER:
 256                                 exif_data_load_data_content (data,
 257                                         data->ifd[EXIF_IFD_EXIF], d, ds, o);
 258                                 break;
 259                         case EXIF_TAG_GPS_INFO_IFD_POINTER:
 260                                 exif_data_load_data_content (data,
 261                                         data->ifd[EXIF_IFD_GPS], d, ds, o);
 262                                 break;
 263                         case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
 264                                 exif_data_load_data_content (data,
 265                                         data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds, o);
 266                                 break;
 267                         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
 268 #ifdef DEBUG
 269                                 printf ("Thumbnail at %i.\n", (int) o);
 270 #endif
 271                                 thumbnail_offset = o;
 272                                 if (thumbnail_offset && thumbnail_length)
 273                                         exif_data_load_data_thumbnail (data, d,
 274                                                 ds, thumbnail_offset,
 275                                                 thumbnail_length);
 276                                 break;
 277                         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
 278 #ifdef DEBUG
 279                                 printf ("Thumbnail size: %i.\n", (int) o);
 280 #endif
 281                                 thumbnail_length = o;
 282                                 if (thumbnail_offset && thumbnail_length)
 283                                         exif_data_load_data_thumbnail (data, d,
 284                                                 ds, thumbnail_offset,
 285                                                 thumbnail_length);
 286                                 break;
 287                         default:
 288                                 return;
 289                         }
 290                         break;
 291                 default:
 292
 293                         /*
 294                          * If we don't know the tag, changes are high
 295                          * that the EXIF data does not follow the standard.
 296                          */
 297                         if (!exif_tag_get_name (tag)) return;
 298                         entry = exif_entry_new ();
 299                         exif_content_add_entry (ifd, entry);
 300                         exif_data_load_data_entry (data, entry, d, ds,
 301                                                    offset + 12 * i);
 302                         exif_entry_unref (entry);
 303                         break;
 304                 }
 305         }
 306 }
 307
 308 static void
 309 exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 310                              unsigned char **d, unsigned int *ds,
 311                              unsigned int offset)
 312 {
 313         unsigned int j, n_ptr = 0, n_thumb = 0;
 314         ExifIfd i;
 315
 316         if (!data || !ifd || !d || !ds)
 317                 return;
 318
 319         for (i = 0; i < EXIF_IFD_COUNT; i++)
 320                 if (ifd == data->ifd[i])
 321                         break;
 322         if (i == EXIF_IFD_COUNT)
 323                 return;
 324
 325         /*
 326          * Check if we need some extra entries for pointers or the thumbnail.
 327          */
 328         switch (i) {
 329         case EXIF_IFD_0:
 330
 331                 /*
 332                  * The pointer to IFD_EXIF is in IFD_0. The pointer to
 333                  * IFD_INTEROPERABILITY is in IFD_EXIF.
 334                  */
 335                 if (data->ifd[EXIF_IFD_EXIF]->count ||
 336                     data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
 337                         n_ptr++;
 338
 339                 /* The pointer to IFD_GPS is in IFD_0. */
 340                 if (data->ifd[EXIF_IFD_GPS]->count)
 341                         n_ptr++;
 342
 343                 break;
 344         case EXIF_IFD_1:
 345                 if (data->size)
 346                         n_thumb = 2;
 347                 break;
 348         case EXIF_IFD_EXIF:
 349                 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
 350                         n_ptr++;
 351         default:
 352                 break;
 353         }
 354
 355         /*
 356          * Allocate enough memory for all entries
 357          * and the number of entries.
 358          */
 359         *ds += (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
 360         *d = realloc (*d, sizeof (char) * *ds);
 361
 362         /* Save the number of entries */
 363         exif_set_short (*d + 6 + offset, data->priv->order,
 364                         (ExifShort) (ifd->count + n_ptr + n_thumb));
 365         offset += 2;
 366
 367 #ifdef DEBUG
 368         printf ("Saving %i entries (IFD '%s', offset: %i)...\n",
 369                 ifd->count, exif_ifd_get_name (i), offset);
 370 #endif
 371
 372         /* Save each entry */
 373         for (j = 0; j < ifd->count; j++)
 374                 exif_data_save_data_entry (data, ifd->entries[j],
 375                                 d, ds, offset + 12 * j);
 376         offset += 12 * ifd->count;
 377
 378         /* Now save special entries. */
 379         switch (i) {
 380         case EXIF_IFD_0:
 381
 382                 /*
 383                  * The pointer to IFD_EXIF is in IFD_0.
 384                  * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
 385                  * therefore, if IFD_INTEROPERABILITY is not empty, we need
 386                  * IFD_EXIF even if latter is empty.
 387                  */
 388                 if (data->ifd[EXIF_IFD_EXIF]->count ||
 389                     data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
 390                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 391                                         EXIF_TAG_EXIF_IFD_POINTER);
 392                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 393                                         EXIF_FORMAT_LONG);
 394                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 395                                         1);
 396                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 397                                         *ds - 6);
 398                         exif_data_save_data_content (data,
 399                                 data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
 400                         offset += 12;
 401                 }
 402
 403                 /* The pointer to IFD_GPS is in IFD_0, too. */
 404                 if (data->ifd[EXIF_IFD_GPS]->count) {
 405                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 406                                         EXIF_TAG_GPS_INFO_IFD_POINTER);
 407                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 408                                         EXIF_FORMAT_LONG);
 409                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 410                                         1);
 411                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 412                                         *ds - 6);
 413                         exif_data_save_data_content (data,
 414                                 data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
 415                         offset += 12;
 416                 }
 417
 418                 break;
 419         case EXIF_IFD_EXIF:
 420
 421                 /*
 422                  * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
 423                  * See note above.
 424                  */
 425                 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
 426                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 427                                         EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
 428                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 429                                         EXIF_FORMAT_LONG);
 430                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 431                                         1);
 432                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 433                                         *ds - 6);
 434                         exif_data_save_data_content (data,
 435                                 data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
 436                                 *ds - 6);
 437                         offset += 12;
 438                 }
 439
 440                 break;
 441         case EXIF_IFD_1:
 442
 443                 /*
 444                  * Information about the thumbnail (if any) is saved in
 445                  * IFD_1.
 446                  */
 447                 if (data->size) {
 448
 449                         /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
 450                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 451                                         EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
 452                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 453                                         EXIF_FORMAT_LONG);
 454                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 455                                         1);
 456                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 457                                         *ds - 6);
 458                         *ds += data->size;
 459                         *d = realloc (*d, sizeof (char) * *ds);
 460                         memcpy (*d + *ds - data->size, data->data, data->size);
 461                         offset += 12;
 462 #ifdef DEBUG
 463                         printf ("Wrote %i bytes of thumbnail data at offset "
 464                                 "%i.\n", data->size, *ds - data->size);
 465                         printf ("We currently have %i bytes EXIF data.\n", *ds);
 466 #endif
 467
 468                         /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
 469                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 470                                 EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
 471                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 472                                         EXIF_FORMAT_LONG);
 473                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 474                                         1);
 475                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 476                                         data->size);
 477                         offset += 12;
 478                 }
 479
 480                 break;
 481         default:
 482                 break;
 483         }
 484
 485         /* Correctly terminate the directory */
 486         if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
 487                                              data->size)) {
 488
 489                 /*
 490                  * We are saving IFD 0. Tell where IFD 1 starts and save
 491                  * IFD 1.
 492                  */
 493                 exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6);
 494                 exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds,
 495                                              *ds - 6);
 496         } else
 497                 exif_set_long (*d + 6 + offset, data->priv->order, 0);
 498 }
 499
 500 void
 501 exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 502                      unsigned int ds_orig)
 503 {
 504         unsigned int l;
 505         ExifLong offset;
 506         ExifShort n;
 507         ExifEntry *e, *em;
 508         const unsigned char *d = d_orig;
 509         unsigned int ds = ds_orig, len;
 510
 511         if (!data)
 512                 return;
 513         if (!d || !ds)
 514                 return;
 515
 516 #ifdef DEBUG
 517         printf ("Parsing %i byte(s) EXIF data...\n", ds);
 518 #endif
 519
 520         /*
 521          * It can be that the data starts with the EXIF header. If it does
 522          * not, search the EXIF marker.
 523          */
 524         if (ds < 6) {
 525 #ifdef DEBUG
 526                 printf ("Size too small.\n");
 527 #endif
 528                 return;
 529         }
 530         if (!memcmp (d, ExifHeader, 6)) {
 531 #ifdef DEBUG
 532                 printf ("Found EXIF header.\n");
 533 #endif
 534         } else {
 535 #ifdef DEBUG
 536                 printf ("Data begins with 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x "
 537                         "0x%x...\n", d[0], d[1], d[2], d[3], d[4], d[5], d[6]);
 538 #endif
 539                 while (1) {
 540                         while ((d[0] == 0xff) && ds) {
 541                                 d++;
 542                                 ds--;
 543                         }
 544
 545                         /* JPEG_MARKER_SOI */
 546                         if (d[0] == JPEG_MARKER_SOI) {
 547                                 d++;
 548                                 ds--;
 549                                 continue;
 550                         }
 551
 552                         /* JPEG_MARKER_APP0 */
 553                         if (d[0] == JPEG_MARKER_APP0) {
 554                                 d++;
 555                                 ds--;
 556                                 l = (d[0] << 8) | d[1];
 557                                 if (l > ds)
 558                                         return;
 559                                 d += l;
 560                                 ds -= l;
 561                                 continue;
 562                         }
 563
 564                         /* JPEG_MARKER_APP1 */
 565                         if (d[0] == JPEG_MARKER_APP1)
 566                                 break;
 567
 568                         /* Unknown marker or data. Give up. */
 569 #ifdef DEBUG
 570                         printf ("EXIF marker not found.\n");
 571 #endif
 572                         return;
 573                 }
 574                 d++;
 575                 ds--;
 576                 if (ds < 2) {
 577 #ifdef DEBUG
 578                         printf ("Size too small.\n");
 579 #endif
 580                         return;
 581                 }
 582                 len = (d[0] << 8) | d[1];
 583 #ifdef DEBUG
 584                 printf ("We have to deal with %i byte(s) of EXIF data.\n", len);
 585 #endif
 586                 d += 2;
 587                 ds -= 2;
 588         }
 589
 590         /*
 591          * Verify the exif header
 592          * (offset 2, length 6).
 593          */
 594         if (ds < 6) {
 595 #ifdef DEBUG
 596                 printf ("Size too small.\n");
 597 #endif
 598                 return;
 599         }
 600         if (memcmp (d, ExifHeader, 6)) {
 601 #ifdef DEBUG
 602                 printf ("EXIF header not found.\n");
 603 #endif
 604                 return;
 605         }
 606
 607 #ifdef DEBUG
 608         printf ("Found EXIF header.\n");
 609 #endif
 610
 611         /* Byte order (offset 6, length 2) */
 612         if (ds < 12)
 613                 return;
 614         if (!memcmp (d + 6, "II", 2))
 615                 data->priv->order = EXIF_BYTE_ORDER_INTEL;
 616         else if (!memcmp (d + 6, "MM", 2))
 617                 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
 618         else
 619                 return;
 620
 621         /* Fixed value */
 622         if (exif_get_short (d + 8, data->priv->order) != 0x002a)
 623                 return;
 624
 625         /* IFD 0 offset */
 626         offset = exif_get_long (d + 10, data->priv->order);
 627 #ifdef DEBUG
 628         printf ("IFD 0 at %i.\n", (int) offset);
 629 #endif
 630
 631         /* Parse the actual exif data (offset 14) */
 632         exif_data_load_data_content (data, data->ifd[EXIF_IFD_0], d + 6,
 633                                      ds - 6, offset);
 634
 635         /* IFD 1 offset */
 636         n = exif_get_short (d + 6 + offset, data->priv->order);
 637         offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order);
 638         if (offset) {
 639 #ifdef DEBUG
 640                 printf ("IFD 1 at %i.\n", (int) offset);
 641 #endif
 642
 643                 /* Sanity check. */
 644                 if (offset > ds - 6) {
 645 #ifdef DEBUG
 646                         printf ("Bogus offset!\n");
 647 #endif
 648                         return;
 649                 }
 650
 651                 exif_data_load_data_content (data, data->ifd[EXIF_IFD_1], d + 6,
 652                                              ds - 6, offset);
 653         }
 654
 655         /*
 656          * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
 657          * cameras use pointers in the maker note tag that point to the
 658          * space between IFDs. Here is the only place where we have access
 659          * to that data.
 660          */
 661         e = exif_data_get_entry (data, EXIF_TAG_MAKER_NOTE);
 662         if (e) {
 663
 664             /* Olympus & Nikon */
 665             if ((e->size >= 5) && (!memcmp (e->data, "OLYMP", 5) ||
 666                                    !memcmp (e->data, "Nikon", 5))) {
 667                         data->priv->md = exif_mnote_data_olympus_new ();
 668             } else {
 669                         char value[7];
 670                         em = exif_data_get_entry (data, EXIF_TAG_MAKE);
 671                         /* Pentax & some variant of Nikon */
 672                         if ((e->size >= 2) && (e->data[0] == 0x00)
 673                                     && (e->data[1] == 0x1b)) {
 674                                 if (em && !strnicmp (exif_entry_get_value (em, value, sizeof(value)), "Nikon", 5)) {
 675                                         data->priv->md = exif_mnote_data_olympus_new ();
 676                                 } else {
 677                                         data->priv->md = exif_mnote_data_pentax_new ();
 678                                 }
 679
 680                         } else {
 681                                 /* Canon */
 682                                 if (em) {
 683
 684                                         if (!strcmp (exif_entry_get_value (em, value, sizeof(value)), "Canon"))
 685                                                 data->priv->md = exif_mnote_data_canon_new ();
 686                                 }
 687                         }
 688                 }
 689
 690             /*
 691              * If we are able to interpret the maker note, do so.
 692              */
 693             if (data->priv->md) {
 694                 exif_mnote_data_set_byte_order (data->priv->md,
 695                                                 data->priv->order);
 696                 exif_mnote_data_set_offset (data->priv->md,
 697                                             data->priv->offset_mnote);
 698                 exif_mnote_data_load (data->priv->md, d, ds);
 699             }
 700         }
 701 }
 702
 703 void
 704 exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds)
 705 {
 706         if (!data)
 707                 return;
 708         if (!d || !ds)
 709                 return;
 710
 711         /* Header */
 712         *ds = 6;
 713         *d = malloc (sizeof (char) * *ds);
 714         memcpy (*d, ExifHeader, 6);
 715
 716         /* Order (offset 6) */
 717         *ds += 2;
 718         *d = realloc (*d, sizeof (char) * *ds);
 719         if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
 720                 memcpy (*d + 6, "II", 2);
 721         } else {
 722                 memcpy (*d + 6, "MM", 2);
 723         }
 724
 725         /* Fixed value (2 bytes, offset 8) */
 726         *ds += 2;
 727         *d = realloc (*d, sizeof (char) * *ds);
 728         exif_set_short (*d + 8, data->priv->order, 0x002a);
 729
 730         /*
 731          * IFD 0 offset (4 bytes, offset 10).
 732          * We will start 8 bytes after the
 733          * EXIF header (2 bytes for order, another 2 for the test, and
 734          * 4 bytes for the IFD 0 offset make 8 bytes together).
 735          */
 736         *ds += 4;
 737         *d = realloc (*d, sizeof (char) * *ds);
 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 }