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