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