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