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 ExifMnoteData *
  62 exif_data_get_mnote_data (ExifData *d)
  63 {
  64         return (d && d->priv) ? d->priv->md : NULL;
  65 }
  66
  67 ExifData *
  68 exif_data_new (void)
  69 {
  70         ExifData *data;
  71         unsigned int i;
  72
  73         data = malloc (sizeof (ExifData));
  74         if (!data)
  75                 return (NULL);
  76         memset (data, 0, sizeof (ExifData));
  77         data->priv = malloc (sizeof (ExifDataPrivate));
  78         if (!data->priv) {
  79                 free (data);
  80                 return (NULL);
  81         }
  82         memset (data->priv, 0, sizeof (ExifDataPrivate));
  83         data->priv->ref_count = 1;
  84
  85         for (i = 0; i < EXIF_IFD_COUNT; i++) {
  86                 data->ifd[i] = exif_content_new ();
  87                 if (!data->ifd[i]) {
  88                         exif_data_free (data);
  89                         return (NULL);
  90                 }
  91                 data->ifd[i]->parent = data;
  92         }
  93
  94         return (data);
  95 }
  96
  97 ExifData *
  98 exif_data_new_from_data (const unsigned char *data, unsigned int size)
  99 {
 100         ExifData *edata;
 101
 102         edata = exif_data_new ();
 103         exif_data_load_data (edata, data, size);
 104         return (edata);
 105 }
 106
 107 static void
 108 exif_data_load_data_entry (ExifData *data, ExifEntry *entry,
 109                            const unsigned char *d,
 110                            unsigned int size, unsigned int offset)
 111 {
 112         unsigned int s, doff;
 113
 114         entry->tag        = exif_get_short (d + offset + 0, data->priv->order);
 115         entry->format     = exif_get_short (d + offset + 2, data->priv->order);
 116         entry->components = exif_get_long  (d + offset + 4, data->priv->order);
 117
 118         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 119                   "Loading entry 0x%x ('%s')...", entry->tag,
 120                   exif_tag_get_name (entry->tag));
 121
 122         /*
 123          * Size? If bigger than 4 bytes, the actual data is not
 124          * in the entry but somewhere else (offset).
 125          */
 126         s = exif_format_get_size (entry->format) * entry->components;
 127         if (!s)
 128                 return;
 129         if (s > 4)
 130                 doff = exif_get_long (d + offset + 8, data->priv->order);
 131         else
 132                 doff = offset + 8;
 133
 134         /* Sanity check */
 135         if (size < doff + s)
 136                 return;
 137
 138         entry->data = malloc (s);
 139         if (!entry->data) {
 140                 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", s);
 141                 return;
 142         }
 143         entry->size = s;
 144         memcpy (entry->data, d + doff, s);
 145
 146         /* If this is the MakerNote, remember the offset */
 147         if (entry->tag == EXIF_TAG_MAKER_NOTE) {
 148                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 149                           "MakerNote found (%02x %02x %02x %02x "
 150                           "%02x %02x %02x...).",
 151                           entry->data[0], entry->data[1], entry->data[2],
 152                           entry->data[3], entry->data[4], entry->data[5],
 153                           entry->data[6]);
 154                 data->priv->offset_mnote = doff;
 155         }
 156 }
 157
 158 static void
 159 exif_data_save_data_entry (ExifData *data, ExifEntry *e,
 160                            unsigned char **d, unsigned int *ds,
 161                            unsigned int offset)
 162 {
 163         unsigned int doff, s;
 164
 165         /*
 166          * Each entry is 12 bytes long. The memory for the entry has
 167          * already been allocated.
 168          */
 169         exif_set_short (*d + 6 + offset + 0,
 170                         data->priv->order, (ExifShort) e->tag);
 171         exif_set_short (*d + 6 + offset + 2,
 172                         data->priv->order, (ExifShort) e->format);
 173
 174         /* If this is the maker note tag, update it. */
 175         if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
 176                 free (e->data);
 177                 e->data = NULL;
 178                 e->size = 0;
 179                 exif_mnote_data_set_offset (data->priv->md, *ds - 6);
 180                 exif_mnote_data_save (data->priv->md, &e->data, &e->size);
 181                 e->components = e->size;
 182         }
 183
 184         exif_set_long  (*d + 6 + offset + 4,
 185                         data->priv->order, e->components);
 186
 187         /*
 188          * Size? If bigger than 4 bytes, the actual data is not in
 189          * the entry but somewhere else.
 190          */
 191         s = exif_format_get_size (e->format) * e->components;
 192         if (s > 4) {
 193                 doff = *ds - 6;
 194                 *ds += s;
 195                 *d = realloc (*d, *ds);
 196                 if (!*d) {
 197                         EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", *ds);
 198                         return;
 199                 }
 200                 exif_set_long (*d + 6 + offset + 8,
 201                                data->priv->order, doff);
 202         } else
 203                 doff = offset + 8;
 204
 205         /* Write the data. Fill unneeded bytes with 0. */
 206         memcpy (*d + 6 + doff, e->data, s);
 207         if (s < 4) memset (*d + 6 + doff + s, 0, (4 - s));
 208 }
 209
 210 static void
 211 exif_data_load_data_thumbnail (ExifData *data, const unsigned char *d,
 212                                unsigned int ds, ExifLong offset, ExifLong size)
 213 {
 214         if (ds < offset + size) {
 215                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 216                           "Bogus thumbnail offset and size: %i < %i + %i.",
 217                           (int) ds, (int) offset, (int) size);
 218                 return;
 219         }
 220         if (data->data)
 221                 free (data->data);
 222         data->size = size;
 223         data->data = malloc (data->size);
 224         if (!data->data) {
 225                 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", data->size);
 226                 return;
 227         }
 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 = malloc (*ds);
 731         if (!*d)
 732                 return;
 733         memcpy (*d, ExifHeader, 6);
 734
 735         /* Order (offset 6) */
 736         if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
 737                 memcpy (*d + 6, "II", 2);
 738         } else {
 739                 memcpy (*d + 6, "MM", 2);
 740         }
 741
 742         /* Fixed value (2 bytes, offset 8) */
 743         exif_set_short (*d + 8, data->priv->order, 0x002a);
 744
 745         /*
 746          * IFD 0 offset (4 bytes, offset 10).
 747          * We will start 8 bytes after the
 748          * EXIF header (2 bytes for order, another 2 for the test, and
 749          * 4 bytes for the IFD 0 offset make 8 bytes together).
 750          */
 751         exif_set_long (*d + 10, data->priv->order, 8);
 752
 753         /* Now save IFD 0. IFD 1 will be saved automatically. */
 754 #ifdef DEBUG
 755         printf ("Saving IFDs...\n");
 756 #endif
 757         exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds,
 758                                      *ds - 6);
 759
 760 #ifdef DEBUG
 761         printf ("Saved %i byte(s) EXIF data.\n", *ds);
 762 #endif
 763 }
 764
 765 ExifData *
 766 exif_data_new_from_file (const char *path)
 767 {
 768         ExifData *edata;
 769         ExifLoader *loader;
 770
 771         loader = exif_loader_new ();
 772         exif_loader_write_file (loader, path);
 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 }
 978
 979 void
 980 exif_data_log (ExifData *data, ExifLog *log)
 981 {
 982         if (!data || !data->priv) return;
 983         exif_log_unref (data->priv->log);
 984         data->priv->log = log;
 985         exif_log_ref (log);
 986 }