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