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 #if defined(__WATCOMC__) || defined(_MSC_VER)
  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)) {
 331                                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 332                                   "Unknown tag %x (entry %i)", tag, i);
 333                                 return;
 334                         }
 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         /* Save each entry */
 408         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 409                   "Saving %i entries (IFD '%s', offset: %i)...",
 410                   ifd->count, exif_ifd_get_name (i), offset);
 411         for (j = 0; j < ifd->count; j++)
 412                 exif_data_save_data_entry (data, ifd->entries[j],
 413                                 d, ds, offset + 12 * j);
 414         offset += 12 * ifd->count;
 415
 416         /* Now save special entries. */
 417         switch (i) {
 418         case EXIF_IFD_0:
 419
 420                 /*
 421                  * The pointer to IFD_EXIF is in IFD_0.
 422                  * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
 423                  * therefore, if IFD_INTEROPERABILITY is not empty, we need
 424                  * IFD_EXIF even if latter is empty.
 425                  */
 426                 if (data->ifd[EXIF_IFD_EXIF]->count ||
 427                     data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
 428                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 429                                         EXIF_TAG_EXIF_IFD_POINTER);
 430                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 431                                         EXIF_FORMAT_LONG);
 432                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 433                                         1);
 434                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 435                                         *ds - 6);
 436                         exif_data_save_data_content (data,
 437                                 data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
 438                         offset += 12;
 439                 }
 440
 441                 /* The pointer to IFD_GPS is in IFD_0, too. */
 442                 if (data->ifd[EXIF_IFD_GPS]->count) {
 443                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 444                                         EXIF_TAG_GPS_INFO_IFD_POINTER);
 445                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 446                                         EXIF_FORMAT_LONG);
 447                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 448                                         1);
 449                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 450                                         *ds - 6);
 451                         exif_data_save_data_content (data,
 452                                 data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
 453                         offset += 12;
 454                 }
 455
 456                 break;
 457         case EXIF_IFD_EXIF:
 458
 459                 /*
 460                  * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
 461                  * See note above.
 462                  */
 463                 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
 464                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 465                                         EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
 466                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 467                                         EXIF_FORMAT_LONG);
 468                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 469                                         1);
 470                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 471                                         *ds - 6);
 472                         exif_data_save_data_content (data,
 473                                 data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
 474                                 *ds - 6);
 475                         offset += 12;
 476                 }
 477
 478                 break;
 479         case EXIF_IFD_1:
 480
 481                 /*
 482                  * Information about the thumbnail (if any) is saved in
 483                  * IFD_1.
 484                  */
 485                 if (data->size) {
 486
 487                         /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
 488                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 489                                         EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
 490                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 491                                         EXIF_FORMAT_LONG);
 492                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 493                                         1);
 494                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 495                                         *ds - 6);
 496                         *ds += data->size;
 497                         *d = exif_mem_realloc (data->priv->mem, *d, *ds);
 498                         if (!*d) {
 499                                 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData",
 500                                                     *ds);
 501                                 return;
 502                         }
 503                         memcpy (*d + *ds - data->size, data->data, data->size);
 504                         offset += 12;
 505
 506                         /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
 507                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 508                                 EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
 509                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 510                                         EXIF_FORMAT_LONG);
 511                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 512                                         1);
 513                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 514                                         data->size);
 515                         offset += 12;
 516                 }
 517
 518                 break;
 519         default:
 520                 break;
 521         }
 522
 523         /* Correctly terminate the directory */
 524         if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
 525                                              data->size)) {
 526
 527                 /*
 528                  * We are saving IFD 0. Tell where IFD 1 starts and save
 529                  * IFD 1.
 530                  */
 531                 exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6);
 532                 exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds,
 533                                              *ds - 6);
 534         } else
 535                 exif_set_long (*d + 6 + offset, data->priv->order, 0);
 536 }
 537
 538 void
 539 exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 540                      unsigned int ds_orig)
 541 {
 542         unsigned int l;
 543         ExifLong offset;
 544         ExifShort n;
 545         ExifEntry *e, *em;
 546         const unsigned char *d = d_orig;
 547         unsigned int ds = ds_orig, len;
 548
 549         if (!data || !data->priv || !d || !ds) return;
 550
 551         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 552                   "Parsing %i byte(s) EXIF data...\n", ds);
 553
 554         /*
 555          * It can be that the data starts with the EXIF header. If it does
 556          * not, search the EXIF marker.
 557          */
 558         if (ds < 6) {
 559                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 560                           "Size too small.");
 561                 return;
 562         }
 563         if (!memcmp (d, ExifHeader, 6)) {
 564                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 565                           "Found EXIF header.");
 566         } else {
 567                 while (1) {
 568                         while ((d[0] == 0xff) && ds) {
 569                                 d++;
 570                                 ds--;
 571                         }
 572
 573                         /* JPEG_MARKER_SOI */
 574                         if (d[0] == JPEG_MARKER_SOI) {
 575                                 d++;
 576                                 ds--;
 577                                 continue;
 578                         }
 579
 580                         /* JPEG_MARKER_APP0 */
 581                         if (d[0] == JPEG_MARKER_APP0) {
 582                                 d++;
 583                                 ds--;
 584                                 l = (d[0] << 8) | d[1];
 585                                 if (l > ds)
 586                                         return;
 587                                 d += l;
 588                                 ds -= l;
 589                                 continue;
 590                         }
 591
 592                         /* JPEG_MARKER_APP1 */
 593                         if (d[0] == JPEG_MARKER_APP1)
 594                                 break;
 595
 596                         /* Unknown marker or data. Give up. */
 597                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 598                                   "ExifData", "EXIF marker not found.");
 599                         return;
 600                 }
 601                 d++;
 602                 ds--;
 603                 if (ds < 2) {
 604                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 605                                   "ExifData", "Size too small.");
 606                         return;
 607                 }
 608                 len = (d[0] << 8) | d[1];
 609                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 610                           "We have to deal with %i byte(s) of EXIF data.",
 611                           len);
 612                 d += 2;
 613                 ds -= 2;
 614         }
 615
 616         /*
 617          * Verify the exif header
 618          * (offset 2, length 6).
 619          */
 620         if (ds < 6) {
 621                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 622                           "Size too small.");
 623                 return;
 624         }
 625         if (memcmp (d, ExifHeader, 6)) {
 626                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 627                           "EXIF header not found.");
 628                 return;
 629         }
 630
 631         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 632                   "Found EXIF header.");
 633
 634         /* Byte order (offset 6, length 2) */
 635         if (ds < 12)
 636                 return;
 637         if (!memcmp (d + 6, "II", 2))
 638                 data->priv->order = EXIF_BYTE_ORDER_INTEL;
 639         else if (!memcmp (d + 6, "MM", 2))
 640                 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
 641         else
 642                 return;
 643
 644         /* Fixed value */
 645         if (exif_get_short (d + 8, data->priv->order) != 0x002a)
 646                 return;
 647
 648         /* IFD 0 offset */
 649         offset = exif_get_long (d + 10, data->priv->order);
 650         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 651                   "IFD 0 at %i.", (int) offset);
 652
 653         /* Parse the actual exif data (offset 14) */
 654         exif_data_load_data_content (data, data->ifd[EXIF_IFD_0], d + 6,
 655                                      ds - 6, offset);
 656
 657         /* IFD 1 offset */
 658         n = exif_get_short (d + 6 + offset, data->priv->order);
 659         offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order);
 660         if (offset) {
 661                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 662                           "IFD 1 at %i.", (int) offset);
 663
 664                 /* Sanity check. */
 665                 if (offset > ds - 6) {
 666                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 667                                   "ExifData", "Bogus offset!");
 668                         return;
 669                 }
 670
 671                 exif_data_load_data_content (data, data->ifd[EXIF_IFD_1], d + 6,
 672                                              ds - 6, offset);
 673         }
 674
 675         /*
 676          * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
 677          * cameras use pointers in the maker note tag that point to the
 678          * space between IFDs. Here is the only place where we have access
 679          * to that data.
 680          */
 681         e = exif_data_get_entry (data, EXIF_TAG_MAKER_NOTE);
 682         if (e) {
 683
 684             /* Olympus & Nikon */
 685             if ((e->size >= 5) && (!memcmp (e->data, "OLYMP", 5) ||
 686                                    !memcmp (e->data, "Nikon", 5))) {
 687                         data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
 688             } else {
 689                         char value[7];
 690                         em = exif_data_get_entry (data, EXIF_TAG_MAKE);
 691                         /* Pentax & some variant of Nikon */
 692                         if ((e->size >= 2) && (e->data[0] == 0x00)
 693                                     && (e->data[1] == 0x1b)) {
 694                                 if (em && !strncasecmp (exif_entry_get_value (em, value, sizeof(value)), "Nikon", 5)) {
 695                                         data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
 696                                 } else {
 697                                         data->priv->md = exif_mnote_data_pentax_new (data->priv->mem);
 698                                 }
 699
 700                         } else {
 701                                 /* Canon */
 702                                 if (em) {
 703
 704                                         if (!strcmp (exif_entry_get_value (em, value, sizeof(value)), "Canon"))
 705                                                 data->priv->md = exif_mnote_data_canon_new (data->priv->mem);
 706                                 }
 707                         }
 708                 }
 709
 710             /*
 711              * If we are able to interpret the maker note, do so.
 712              */
 713             if (data->priv->md) {
 714                     exif_mnote_data_log (data->priv->md, data->priv->log);
 715                     exif_mnote_data_set_byte_order (data->priv->md,
 716                                                     data->priv->order);
 717                     exif_mnote_data_set_offset (data->priv->md,
 718                                                 data->priv->offset_mnote);
 719                     exif_mnote_data_load (data->priv->md, d, ds);
 720             }
 721         }
 722 }
 723
 724 void
 725 exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds)
 726 {
 727         if (!data || !d || !ds)
 728                 return;
 729
 730         /* Header */
 731         *ds = 14;
 732         *d = exif_data_alloc (data, *ds);
 733         if (!*d) return;
 734         memcpy (*d, ExifHeader, 6);
 735
 736         /* Order (offset 6) */
 737         if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
 738                 memcpy (*d + 6, "II", 2);
 739         } else {
 740                 memcpy (*d + 6, "MM", 2);
 741         }
 742
 743         /* Fixed value (2 bytes, offset 8) */
 744         exif_set_short (*d + 8, data->priv->order, 0x002a);
 745
 746         /*
 747          * IFD 0 offset (4 bytes, offset 10).
 748          * We will start 8 bytes after the
 749          * EXIF header (2 bytes for order, another 2 for the test, and
 750          * 4 bytes for the IFD 0 offset make 8 bytes together).
 751          */
 752         exif_set_long (*d + 10, data->priv->order, 8);
 753
 754         /* Now save IFD 0. IFD 1 will be saved automatically. */
 755         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 756                   "Saving IFDs...");
 757         exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds,
 758                                      *ds - 6);
 759         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 760                   "Saved %i byte(s) EXIF data.", *ds);
 761 }
 762
 763 ExifData *
 764 exif_data_new_from_file (const char *path)
 765 {
 766         ExifData *edata;
 767         ExifLoader *loader;
 768
 769         loader = exif_loader_new ();
 770         exif_loader_write_file (loader, path);
 771         edata = exif_loader_get_data (loader);
 772         exif_loader_unref (loader);
 773
 774         return (edata);
 775 }
 776
 777 void
 778 exif_data_ref (ExifData *data)
 779 {
 780         if (!data)
 781                 return;
 782
 783         data->priv->ref_count++;
 784 }
 785
 786 void
 787 exif_data_unref (ExifData *data)
 788 {
 789         if (!data)
 790                 return;
 791
 792         data->priv->ref_count--;
 793         if (!data->priv->ref_count)
 794                 exif_data_free (data);
 795 }
 796
 797 void
 798 exif_data_free (ExifData *data)
 799 {
 800         unsigned int i;
 801
 802         if (!data) return;
 803
 804         for (i = 0; i < EXIF_IFD_COUNT; i++) {
 805                 if (data->ifd[i]) {
 806                         exif_content_unref (data->ifd[i]);
 807                         data->ifd[i] = NULL;
 808                 }
 809         }
 810
 811         if (data->priv) {
 812                 ExifMem *mem = data->priv->mem;
 813                 if (data->data) {
 814                         exif_mem_free (data->priv->mem, data->data);
 815                         data->data = NULL;
 816                 }
 817                 if (data->priv->md) {
 818                         exif_mnote_data_unref (data->priv->md);
 819                         data->priv->md = NULL;
 820                 }
 821                 exif_mem_free (mem, data->priv);
 822                 exif_mem_free (mem, data);
 823                 exif_mem_unref (mem);
 824         }
 825 }
 826
 827 void
 828 exif_data_dump (ExifData *data)
 829 {
 830         unsigned int i;
 831
 832         if (!data)
 833                 return;
 834
 835         for (i = 0; i < EXIF_IFD_COUNT; i++) {
 836                 if (data->ifd[i] && data->ifd[i]->count) {
 837                         printf ("Dumping IFD '%s'...\n",
 838                                 exif_ifd_get_name (i));
 839                         exif_content_dump (data->ifd[i], 0);
 840                 }
 841         }
 842
 843         if (data->data) {
 844                 printf ("%i byte(s) thumbnail data available.", data->size);
 845                 if (data->size >= 4) {
 846                         printf ("0x%02x 0x%02x ... 0x%02x 0x%02x\n",
 847                                 data->data[0], data->data[1],
 848                                 data->data[data->size - 2],
 849                                 data->data[data->size - 1]);
 850                 }
 851         }
 852 }
 853
 854 ExifByteOrder
 855 exif_data_get_byte_order (ExifData *data)
 856 {
 857         if (!data)
 858                 return (0);
 859
 860         return (data->priv->order);
 861 }
 862
 863 void
 864 exif_data_foreach_content (ExifData *data, ExifDataForeachContentFunc func,
 865                            void *user_data)
 866 {
 867         unsigned int i;
 868
 869         if (!data || !func)
 870                 return;
 871
 872         for (i = 0; i < EXIF_IFD_COUNT; i++)
 873                 func (data->ifd[i], user_data);
 874 }
 875
 876 typedef struct _ByteOrderChangeData ByteOrderChangeData;
 877 struct _ByteOrderChangeData {
 878         ExifByteOrder old, new;
 879 };
 880
 881 static void
 882 entry_set_byte_order (ExifEntry *e, void *data)
 883 {
 884         ByteOrderChangeData *d = data;
 885         unsigned int i;
 886         ExifShort s;
 887         ExifLong l;
 888         ExifSLong sl;
 889         ExifRational r;
 890         ExifSRational sr;
 891
 892         if (!e)
 893                 return;
 894
 895         switch (e->format) {
 896         case EXIF_FORMAT_SHORT:
 897                 for (i = 0; i < e->components; i++) {
 898                         s = exif_get_short (e->data +
 899                                 (i * exif_format_get_size (e->format)),
 900                                 d->old);
 901                         exif_set_short (e->data +
 902                                 (i * exif_format_get_size (e->format)),
 903                                 d->new, s);
 904                 }
 905                 break;
 906         case EXIF_FORMAT_LONG:
 907                 for (i = 0; i < e->components; i++) {
 908                         l = exif_get_long (e->data +
 909                                 (i * exif_format_get_size (e->format)),
 910                                 d->old);
 911                         exif_set_long (e->data +
 912                                 (i * exif_format_get_size (e->format)),
 913                                 d->new, l);
 914                 }
 915                 break;
 916         case EXIF_FORMAT_RATIONAL:
 917                 for (i = 0; i < e->components; i++) {
 918                         r = exif_get_rational (e->data +
 919                                 (i * exif_format_get_size (e->format)),
 920                                 d->old);
 921                         exif_set_rational (e->data +
 922                                 (i * exif_format_get_size (e->format)),
 923                                 d->new, r);
 924                 }
 925                 break;
 926         case EXIF_FORMAT_SLONG:
 927                 for (i = 0; i < e->components; i++) {
 928                         sl = exif_get_slong (e->data +
 929                                 (i * exif_format_get_size (e->format)),
 930                                 d->old);
 931                         exif_set_slong (e->data +
 932                                 (i * exif_format_get_size (e->format)),
 933                                 d->new, sl);
 934                 }
 935                 break;
 936         case EXIF_FORMAT_SRATIONAL:
 937                 for (i = 0; i < e->components; i++) {
 938                         sr = exif_get_srational (e->data +
 939                                 (i * exif_format_get_size (e->format)),
 940                                 d->old);
 941                         exif_set_srational (e->data +
 942                                 (i * exif_format_get_size (e->format)),
 943                                 d->new, sr);
 944                 }
 945                 break;
 946         case EXIF_FORMAT_UNDEFINED:
 947         case EXIF_FORMAT_BYTE:
 948         case EXIF_FORMAT_SBYTE:
 949         case EXIF_FORMAT_ASCII:
 950         default:
 951                 /* Nothing here. */
 952                 break;
 953         }
 954 }
 955
 956 static void
 957 content_set_byte_order (ExifContent *content, void *data)
 958 {
 959         exif_content_foreach_entry (content, entry_set_byte_order, data);
 960 }
 961
 962 void
 963 exif_data_set_byte_order (ExifData *data, ExifByteOrder order)
 964 {
 965         ByteOrderChangeData d;
 966
 967         if (!data || (order == data->priv->order))
 968                 return;
 969
 970         d.old = data->priv->order;
 971         d.new = order;
 972         exif_data_foreach_content (data, content_set_byte_order, &d);
 973         data->priv->order = order;
 974         if (data->priv->md)
 975                 exif_mnote_data_set_byte_order (data->priv->md, order);
 976 }
 977
 978 void
 979 exif_data_log (ExifData *data, ExifLog *log)
 980 {
 981         if (!data || !data->priv) return;
 982         exif_log_unref (data->priv->log);
 983         data->priv->log = log;
 984         exif_log_ref (log);
 985 }
 986
 987 /* Used internally within libexif */
 988 ExifLog *exif_data_get_log (ExifData *);
 989 ExifLog *
 990 exif_data_get_log (ExifData *data)
 991 {
 992         if (!data || !data->priv) return NULL;
 993         return data->priv->log;
 994 }