3 * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
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.
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.
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., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301 USA.
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 #include <libexif/i18n.h>
31 #include <libexif/exif-system.h>
33 #include <libexif/canon/exif-mnote-data-canon.h>
34 #include <libexif/fuji/exif-mnote-data-fuji.h>
35 #include <libexif/olympus/exif-mnote-data-olympus.h>
36 #include <libexif/pentax/exif-mnote-data-pentax.h>
43 #undef JPEG_MARKER_SOI
44 #define JPEG_MARKER_SOI 0xd8
45 #undef JPEG_MARKER_APP0
46 #define JPEG_MARKER_APP0 0xe0
47 #undef JPEG_MARKER_APP1
48 #define JPEG_MARKER_APP1 0xe1
50 static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
52 struct _ExifDataPrivate
61 unsigned int ref_count;
63 /* Temporarily used while loading data */
64 unsigned int offset_mnote;
66 ExifDataOption options;
67 ExifDataType data_type;
71 exif_data_alloc (ExifData *data, unsigned int i)
78 d = exif_mem_alloc (data->priv->mem, i);
82 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i);
87 exif_data_get_mnote_data (ExifData *d)
89 return (d && d->priv) ? d->priv->md : NULL;
95 ExifMem *mem = exif_mem_new_default ();
96 ExifData *d = exif_data_new_mem (mem);
104 exif_data_new_mem (ExifMem *mem)
112 data = exif_mem_alloc (mem, sizeof (ExifData));
115 data->priv = exif_mem_alloc (mem, sizeof (ExifDataPrivate));
117 exif_mem_free (mem, data);
120 data->priv->ref_count = 1;
122 data->priv->mem = mem;
125 for (i = 0; i < EXIF_IFD_COUNT; i++) {
126 data->ifd[i] = exif_content_new_mem (data->priv->mem);
128 exif_data_free (data);
131 data->ifd[i]->parent = data;
134 /* Default options */
135 #ifndef NO_VERBOSE_TAG_STRINGS
137 * When the tag list is compiled away, setting this option prevents
138 * any tags from being loaded
140 exif_data_set_option (data, EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS);
142 exif_data_set_option (data, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
144 /* Default data type: none */
145 exif_data_set_data_type (data, EXIF_DATA_TYPE_COUNT);
151 exif_data_new_from_data (const unsigned char *data, unsigned int size)
155 edata = exif_data_new ();
156 exif_data_load_data (edata, data, size);
161 exif_data_load_data_entry (ExifData *data, ExifEntry *entry,
162 const unsigned char *d,
163 unsigned int size, unsigned int offset)
165 unsigned int s, doff;
167 entry->tag = exif_get_short (d + offset + 0, data->priv->order);
168 entry->format = exif_get_short (d + offset + 2, data->priv->order);
169 entry->components = exif_get_long (d + offset + 4, data->priv->order);
171 /* FIXME: should use exif_tag_get_name_in_ifd here but entry->parent
172 * has not been set yet
174 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
175 "Loading entry 0x%x ('%s')...", entry->tag,
176 exif_tag_get_name (entry->tag));
178 /* {0,1,2,4,8} x { 0x00000000 .. 0xffffffff }
179 * -> { 0x000000000 .. 0x7fffffff8 } */
180 s = exif_format_get_size(entry->format) * entry->components;
181 if ((s < entry->components) || (s == 0)){
186 * Size? If bigger than 4 bytes, the actual data is not
187 * in the entry but somewhere else (offset).
190 doff = exif_get_long (d + offset + 8, data->priv->order);
196 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
197 "Tag starts past end of buffer (%u > %u)", doff, size);
201 if (s > size - doff) {
202 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
203 "Tag data goes past end of buffer (%u > %u)", doff+s, size);
207 entry->data = exif_data_alloc (data, s);
210 memcpy (entry->data, d + doff, s);
212 EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", s);
216 /* If this is the MakerNote, remember the offset */
217 if (entry->tag == EXIF_TAG_MAKER_NOTE) {
219 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
220 "MakerNote found with empty data");
221 } else if (entry->size > 6) {
222 exif_log (data->priv->log,
223 EXIF_LOG_CODE_DEBUG, "ExifData",
224 "MakerNote found (%02x %02x %02x %02x "
225 "%02x %02x %02x...).",
226 entry->data[0], entry->data[1], entry->data[2],
227 entry->data[3], entry->data[4], entry->data[5],
230 data->priv->offset_mnote = doff;
236 exif_data_save_data_entry (ExifData *data, ExifEntry *e,
237 unsigned char **d, unsigned int *ds,
240 unsigned int doff, s;
243 if (!data || !data->priv)
247 * Each entry is 12 bytes long. The memory for the entry has
248 * already been allocated.
250 exif_set_short (*d + 6 + offset + 0,
251 data->priv->order, (ExifShort) e->tag);
252 exif_set_short (*d + 6 + offset + 2,
253 data->priv->order, (ExifShort) e->format);
255 if (!(data->priv->options & EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE)) {
256 /* If this is the maker note tag, update it. */
257 if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
258 /* TODO: this is using the wrong ExifMem to free e->data */
259 exif_mem_free (data->priv->mem, e->data);
262 exif_mnote_data_set_offset (data->priv->md, *ds - 6);
263 exif_mnote_data_save (data->priv->md, &e->data, &e->size);
264 e->components = e->size;
265 if (exif_format_get_size (e->format) != 1) {
266 /* e->format is taken from input code,
267 * but we need to make sure it is a 1 byte
268 * entity due to the multiplication below. */
269 e->format = EXIF_FORMAT_UNDEFINED;
274 exif_set_long (*d + 6 + offset + 4,
275 data->priv->order, e->components);
278 * Size? If bigger than 4 bytes, the actual data is not in
279 * the entry but somewhere else.
281 s = exif_format_get_size (e->format) * e->components;
288 * According to the TIFF specification,
289 * the offset must be an even number. If we need to introduce
290 * a padding byte, we set it to 0.
294 t = exif_mem_realloc (data->priv->mem, *d, ts);
296 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
301 exif_set_long (*d + 6 + offset + 8, data->priv->order, doff);
303 *(*d + *ds - 1) = '\0';
308 /* Write the data. Fill unneeded bytes with 0. Do not crash with
311 memcpy (*d + 6 + doff, e->data, s);
313 memset (*d + 6 + doff, 0, s);
316 memset (*d + 6 + doff + s, 0, (4 - s));
320 exif_data_load_data_thumbnail (ExifData *data, const unsigned char *d,
321 unsigned int ds, ExifLong o, ExifLong s)
325 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", "Bogus thumbnail offset (%u).", o);
329 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", "Bogus thumbnail size (%u), max would be %u.", s, ds-o);
333 exif_mem_free (data->priv->mem, data->data);
334 if (!(data->data = exif_data_alloc (data, s))) {
335 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", s);
340 memcpy (data->data, d + o, s);
344 #define CHECK_REC(i) \
346 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
347 "ExifData", "Recursive entry in IFD " \
348 "'%s' detected. Skipping...", \
349 exif_ifd_get_name (i)); \
352 if (data->ifd[(i)]->count) { \
353 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
354 "ExifData", "Attempt to load IFD " \
355 "'%s' multiple times detected. " \
357 exif_ifd_get_name (i)); \
361 /*! Calculate the recursion cost added by one level of IFD loading.
363 * The work performed is related to the cost in the exponential relation
367 level_cost(unsigned int n)
369 static const double log_1_1 = 0.09531017980432493;
371 /* Adding 0.1 protects against the case where n==1 */
372 return ceil(log(n + 0.1)/log_1_1);
375 /*! Load data for an IFD.
377 * \param[in,out] data #ExifData
378 * \param[in] ifd IFD to load
379 * \param[in] d pointer to buffer containing raw IFD data
380 * \param[in] ds size of raw data in buffer at \c d
381 * \param[in] offset offset into buffer at \c d at which IFD starts
382 * \param[in] recursion_cost factor indicating how expensive this recursive
386 exif_data_load_data_content (ExifData *data, ExifIfd ifd,
387 const unsigned char *d,
388 unsigned int ds, unsigned int offset, unsigned int recursion_cost)
390 ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
396 if (!data || !data->priv)
399 /* check for valid ExifIfd enum range */
400 if ((((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT))
403 if (recursion_cost > 170) {
405 * recursion_cost is a logarithmic-scale indicator of how expensive this
406 * recursive call might end up being. It is an indicator of the depth of
407 * recursion as well as the potential for worst-case future recursive
408 * calls. Since it's difficult to tell ahead of time how often recursion
409 * will occur, this assumes the worst by assuming every tag could end up
411 * The value of 170 was chosen to limit typical EXIF structures to a
412 * recursive depth of about 6, but pathological ones (those with very
413 * many tags) to only 2.
415 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
416 "Deep/expensive recursion detected!");
420 /* Read the number of entries */
421 if ((offset + 2 < offset) || (offset + 2 < 2) || (offset + 2 > ds)) {
422 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
423 "Tag data past end of buffer (%u > %u)", offset+2, ds);
426 n = exif_get_short (d + offset, data->priv->order);
427 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
428 "Loading %hu entries...", n);
431 /* Check if we have enough data. */
432 if (offset + 12 * n > ds) {
433 n = (ds - offset) / 12;
434 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
435 "Short data; only loading %hu entries...", n);
438 for (i = 0; i < n; i++) {
440 tag = exif_get_short (d + offset + 12 * i, data->priv->order);
442 case EXIF_TAG_EXIF_IFD_POINTER:
443 case EXIF_TAG_GPS_INFO_IFD_POINTER:
444 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
445 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
446 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
447 o = exif_get_long (d + offset + 12 * i + 8,
449 /* FIXME: IFD_POINTER tags aren't marked as being in a
450 * specific IFD, so exif_tag_get_name_in_ifd won't work
452 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
453 "Sub-IFD entry 0x%x ('%s') at %u.", tag,
454 exif_tag_get_name(tag), o);
456 case EXIF_TAG_EXIF_IFD_POINTER:
457 CHECK_REC (EXIF_IFD_EXIF);
458 exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o,
459 recursion_cost + level_cost(n));
461 case EXIF_TAG_GPS_INFO_IFD_POINTER:
462 CHECK_REC (EXIF_IFD_GPS);
463 exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o,
464 recursion_cost + level_cost(n));
466 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
467 CHECK_REC (EXIF_IFD_INTEROPERABILITY);
468 exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o,
469 recursion_cost + level_cost(n));
471 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
472 thumbnail_offset = o;
473 if (thumbnail_offset && thumbnail_length)
474 exif_data_load_data_thumbnail (data, d,
475 ds, thumbnail_offset,
478 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
479 thumbnail_length = o;
480 if (thumbnail_offset && thumbnail_length)
481 exif_data_load_data_thumbnail (data, d,
482 ds, thumbnail_offset,
492 * If we don't know the tag, don't fail. It could be that new
493 * versions of the standard have defined additional tags. Note that
494 * 0 is a valid tag in the GPS IFD.
496 if (!exif_tag_get_name_in_ifd (tag, ifd)) {
499 * Special case: Tag and format 0. That's against specification
500 * (at least up to 2.2). But Photoshop writes it anyways.
502 if (!memcmp (d + offset + 12 * i, "\0\0\0\0", 4)) {
503 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
504 "Skipping empty entry at position %u in '%s'.", i,
505 exif_ifd_get_name (ifd));
508 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
509 "Unknown tag 0x%04x (entry %u in '%s'). Please report this tag "
510 "to <libexif-devel@lists.sourceforge.net>.", tag, i,
511 exif_ifd_get_name (ifd));
512 if (data->priv->options & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS)
515 entry = exif_entry_new_mem (data->priv->mem);
517 exif_log (data->priv->log, EXIF_LOG_CODE_NO_MEMORY, "ExifData",
518 "Could not allocate memory");
521 if (exif_data_load_data_entry (data, entry, d, ds,
523 exif_content_add_entry (data->ifd[ifd], entry);
524 exif_entry_unref (entry);
531 cmp_func (const unsigned char *p1, const unsigned char *p2, ExifByteOrder o)
533 ExifShort tag1 = exif_get_short (p1, o);
534 ExifShort tag2 = exif_get_short (p2, o);
536 return (tag1 < tag2) ? -1 : (tag1 > tag2) ? 1 : 0;
540 cmp_func_intel (const void *elem1, const void *elem2)
542 return cmp_func ((const unsigned char *) elem1,
543 (const unsigned char *) elem2, EXIF_BYTE_ORDER_INTEL);
547 cmp_func_motorola (const void *elem1, const void *elem2)
549 return cmp_func ((const unsigned char *) elem1,
550 (const unsigned char *) elem2, EXIF_BYTE_ORDER_MOTOROLA);
554 exif_data_save_data_content (ExifData *data, ExifContent *ifd,
555 unsigned char **d, unsigned int *ds,
558 unsigned int j, n_ptr = 0, n_thumb = 0;
563 if (!data || !data->priv || !ifd || !d || !ds)
566 for (i = 0; i < EXIF_IFD_COUNT; i++)
567 if (ifd == data->ifd[i])
569 if (i == EXIF_IFD_COUNT)
573 * Check if we need some extra entries for pointers or the thumbnail.
579 * The pointer to IFD_EXIF is in IFD_0. The pointer to
580 * IFD_INTEROPERABILITY is in IFD_EXIF.
582 if (data->ifd[EXIF_IFD_EXIF]->count ||
583 data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
586 /* The pointer to IFD_GPS is in IFD_0. */
587 if (data->ifd[EXIF_IFD_GPS]->count)
596 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
603 * Allocate enough memory for all entries
604 * and the number of entries.
606 ts = *ds + (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
607 t = exif_mem_realloc (data->priv->mem, *d, ts);
609 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
615 /* Save the number of entries */
616 exif_set_short (*d + 6 + offset, data->priv->order,
617 (ExifShort) (ifd->count + n_ptr + n_thumb));
621 * Save each entry. Make sure that no memcpys from NULL pointers are
624 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
625 "Saving %i entries (IFD '%s', offset: %i)...",
626 ifd->count, exif_ifd_get_name (i), offset);
627 for (j = 0; j < ifd->count; j++) {
628 if (ifd->entries[j]) {
629 exif_data_save_data_entry (data, ifd->entries[j], d, ds,
634 offset += 12 * ifd->count;
636 /* Now save special entries. */
641 * The pointer to IFD_EXIF is in IFD_0.
642 * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
643 * therefore, if IFD_INTEROPERABILITY is not empty, we need
644 * IFD_EXIF even if latter is empty.
646 if (data->ifd[EXIF_IFD_EXIF]->count ||
647 data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
648 exif_set_short (*d + 6 + offset + 0, data->priv->order,
649 EXIF_TAG_EXIF_IFD_POINTER);
650 exif_set_short (*d + 6 + offset + 2, data->priv->order,
652 exif_set_long (*d + 6 + offset + 4, data->priv->order,
654 exif_set_long (*d + 6 + offset + 8, data->priv->order,
656 exif_data_save_data_content (data,
657 data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
661 /* The pointer to IFD_GPS is in IFD_0, too. */
662 if (data->ifd[EXIF_IFD_GPS]->count) {
663 exif_set_short (*d + 6 + offset + 0, data->priv->order,
664 EXIF_TAG_GPS_INFO_IFD_POINTER);
665 exif_set_short (*d + 6 + offset + 2, data->priv->order,
667 exif_set_long (*d + 6 + offset + 4, data->priv->order,
669 exif_set_long (*d + 6 + offset + 8, data->priv->order,
671 exif_data_save_data_content (data,
672 data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
680 * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
683 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
684 exif_set_short (*d + 6 + offset + 0, data->priv->order,
685 EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
686 exif_set_short (*d + 6 + offset + 2, data->priv->order,
688 exif_set_long (*d + 6 + offset + 4, data->priv->order,
690 exif_set_long (*d + 6 + offset + 8, data->priv->order,
692 exif_data_save_data_content (data,
693 data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
702 * Information about the thumbnail (if any) is saved in
707 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
708 exif_set_short (*d + 6 + offset + 0, data->priv->order,
709 EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
710 exif_set_short (*d + 6 + offset + 2, data->priv->order,
712 exif_set_long (*d + 6 + offset + 4, data->priv->order,
714 exif_set_long (*d + 6 + offset + 8, data->priv->order,
716 ts = *ds + data->size;
717 t = exif_mem_realloc (data->priv->mem, *d, ts);
719 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData",
725 memcpy (*d + *ds - data->size, data->data, data->size);
728 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
729 exif_set_short (*d + 6 + offset + 0, data->priv->order,
730 EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
731 exif_set_short (*d + 6 + offset + 2, data->priv->order,
733 exif_set_long (*d + 6 + offset + 4, data->priv->order,
735 exif_set_long (*d + 6 + offset + 8, data->priv->order,
745 /* Sort the directory according to TIFF specification */
746 qsort (*d + 6 + offset - (ifd->count + n_ptr + n_thumb) * 12,
747 (ifd->count + n_ptr + n_thumb), 12,
748 (data->priv->order == EXIF_BYTE_ORDER_INTEL) ? cmp_func_intel : cmp_func_motorola);
750 /* Correctly terminate the directory */
751 if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
755 * We are saving IFD 0. Tell where IFD 1 starts and save
758 exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6);
759 exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds,
762 exif_set_long (*d + 6 + offset, data->priv->order, 0);
766 EXIF_DATA_TYPE_MAKER_NOTE_NONE = 0,
767 EXIF_DATA_TYPE_MAKER_NOTE_CANON = 1,
768 EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS = 2,
769 EXIF_DATA_TYPE_MAKER_NOTE_PENTAX = 3,
770 EXIF_DATA_TYPE_MAKER_NOTE_NIKON = 4,
771 EXIF_DATA_TYPE_MAKER_NOTE_CASIO = 5,
772 EXIF_DATA_TYPE_MAKER_NOTE_FUJI = 6
773 } ExifDataTypeMakerNote;
775 /*! If MakerNote is recognized, load it.
777 * \param[in,out] data #ExifData
778 * \param[in] d pointer to raw EXIF data
779 * \param[in] ds length of data at d
782 interpret_maker_note(ExifData *data, const unsigned char *d, unsigned int ds)
785 ExifEntry* e = exif_data_get_entry (data, EXIF_TAG_MAKER_NOTE);
789 if ((mnoteid = exif_mnote_data_olympus_identify (data, e)) != 0) {
790 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
791 "ExifData", "Olympus MakerNote variant type %d", mnoteid);
792 data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
794 } else if ((mnoteid = exif_mnote_data_canon_identify (data, e)) != 0) {
795 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
796 "ExifData", "Canon MakerNote variant type %d", mnoteid);
797 data->priv->md = exif_mnote_data_canon_new (data->priv->mem, data->priv->options);
799 } else if ((mnoteid = exif_mnote_data_fuji_identify (data, e)) != 0) {
800 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
801 "ExifData", "Fuji MakerNote variant type %d", mnoteid);
802 data->priv->md = exif_mnote_data_fuji_new (data->priv->mem);
804 /* NOTE: Must do Pentax detection last because some of the
805 * heuristics are pretty general. */
806 } else if ((mnoteid = exif_mnote_data_pentax_identify (data, e)) != 0) {
807 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
808 "ExifData", "Pentax MakerNote variant type %d", mnoteid);
809 data->priv->md = exif_mnote_data_pentax_new (data->priv->mem);
813 * If we are able to interpret the maker note, do so.
815 if (data->priv->md) {
816 exif_mnote_data_log (data->priv->md, data->priv->log);
817 exif_mnote_data_set_byte_order (data->priv->md,
819 exif_mnote_data_set_offset (data->priv->md,
820 data->priv->offset_mnote);
821 exif_mnote_data_load (data->priv->md, d, ds);
825 #define LOG_TOO_SMALL \
826 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData", \
827 _("Size of data too small to allow for EXIF data."));
830 exif_data_load_data (ExifData *data, const unsigned char *d_orig,
836 const unsigned char *d = d_orig;
837 unsigned int len, fullds;
839 if (!data || !data->priv || !d || !ds)
842 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
843 "Parsing %i byte(s) EXIF data...\n", ds);
846 * It can be that the data starts with the EXIF header. If it does
847 * not, search the EXIF marker.
853 if (!memcmp (d, ExifHeader, 6)) {
854 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
855 "Found EXIF header at start.");
858 while (ds && (d[0] == 0xff)) {
863 /* JPEG_MARKER_SOI */
864 if (ds && d[0] == JPEG_MARKER_SOI) {
870 /* JPEG_MARKER_APP1 */
871 if (ds && d[0] == JPEG_MARKER_APP1)
874 /* Skip irrelevant APP markers. The branch for APP1 must come before this,
875 otherwise this code block will cause APP1 to be skipped. This code path
876 is only relevant for files that are nonconformant to the EXIF
877 specification. For conformant files, the APP1 code path above will be
879 if (ds >= 3 && d[0] >= 0xe0 && d[0] <= 0xef) { /* JPEG_MARKER_APPn */
882 l = (d[0] << 8) | d[1];
890 /* Unknown marker or data. Give up. */
891 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
892 "ExifData", _("EXIF marker not found."));
901 len = (d[0] << 8) | d[1];
902 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
903 "We have to deal with %i byte(s) of EXIF data.",
910 * Verify the exif header
911 * (offset 2, length 6).
917 if (memcmp (d, ExifHeader, 6)) {
918 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
919 "ExifData", _("EXIF header not found."));
923 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
924 "Found EXIF header.");
926 /* Sanity check the data length */
930 /* The JPEG APP1 section can be no longer than 64 KiB (including a
931 16-bit length), so cap the data length to protect against overflow
932 in future offset calculations */
937 /* Byte order (offset 6, length 2) */
938 if (!memcmp (d + 6, "II", 2))
939 data->priv->order = EXIF_BYTE_ORDER_INTEL;
940 else if (!memcmp (d + 6, "MM", 2))
941 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
943 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
944 "ExifData", _("Unknown encoding."));
949 if (exif_get_short (d + 8, data->priv->order) != 0x002a)
953 offset = exif_get_long (d + 10, data->priv->order);
954 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
955 "IFD 0 at %i.", (int) offset);
957 /* ds is restricted to 16 bit above, so offset is restricted too, and offset+8 should not overflow. */
958 if (offset > ds || offset + 6 + 2 > ds)
961 /* Parse the actual exif data (usually offset 14 from start) */
962 exif_data_load_data_content (data, EXIF_IFD_0, d + 6, ds - 6, offset, 0);
965 n = exif_get_short (d + 6 + offset, data->priv->order);
966 /* offset < 2<<16, n is 16 bit at most, so this op will not overflow */
967 if (offset + 6 + 2 + 12 * n + 4 > ds)
970 offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order);
972 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
973 "IFD 1 at %i.", (int) offset);
975 /* Sanity check. ds is ensured to be above 6 above, offset is 16bit */
976 if (offset > ds - 6) {
977 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
978 "ExifData", "Bogus offset of IFD1.");
980 exif_data_load_data_content (data, EXIF_IFD_1, d + 6, ds - 6, offset, 0);
985 * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
986 * cameras use pointers in the maker note tag that point to the
987 * space between IFDs. Here is the only place where we have access
990 interpret_maker_note(data, d, fullds);
992 /* Fixup tags if requested */
993 if (data->priv->options & EXIF_DATA_OPTION_FOLLOW_SPECIFICATION)
994 exif_data_fix (data);
998 exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds)
1001 *ds = 0; /* This means something went wrong */
1003 if (!data || !d || !ds)
1008 *d = exif_data_alloc (data, *ds);
1013 memcpy (*d, ExifHeader, 6);
1015 /* Order (offset 6) */
1016 if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
1017 memcpy (*d + 6, "II", 2);
1019 memcpy (*d + 6, "MM", 2);
1022 /* Fixed value (2 bytes, offset 8) */
1023 exif_set_short (*d + 8, data->priv->order, 0x002a);
1026 * IFD 0 offset (4 bytes, offset 10).
1027 * We will start 8 bytes after the
1028 * EXIF header (2 bytes for order, another 2 for the test, and
1029 * 4 bytes for the IFD 0 offset make 8 bytes together).
1031 exif_set_long (*d + 10, data->priv->order, 8);
1033 /* Now save IFD 0. IFD 1 will be saved automatically. */
1034 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1036 exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds,
1038 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1039 "Saved %i byte(s) EXIF data.", *ds);
1043 exif_data_new_from_file (const char *path)
1048 loader = exif_loader_new ();
1049 exif_loader_write_file (loader, path);
1050 edata = exif_loader_get_data (loader);
1051 exif_loader_unref (loader);
1057 exif_data_ref (ExifData *data)
1062 data->priv->ref_count++;
1066 exif_data_unref (ExifData *data)
1071 data->priv->ref_count--;
1072 if (!data->priv->ref_count)
1073 exif_data_free (data);
1077 exif_data_free (ExifData *data)
1080 ExifMem *mem = (data && data->priv) ? data->priv->mem : NULL;
1085 for (i = 0; i < EXIF_IFD_COUNT; i++) {
1087 exif_content_unref (data->ifd[i]);
1088 data->ifd[i] = NULL;
1093 exif_mem_free (mem, data->data);
1098 if (data->priv->log) {
1099 exif_log_unref (data->priv->log);
1100 data->priv->log = NULL;
1102 if (data->priv->md) {
1103 exif_mnote_data_unref (data->priv->md);
1104 data->priv->md = NULL;
1106 exif_mem_free (mem, data->priv);
1107 exif_mem_free (mem, data);
1110 exif_mem_unref (mem);
1114 exif_data_dump (ExifData *data)
1121 for (i = 0; i < EXIF_IFD_COUNT; i++) {
1122 if (data->ifd[i] && data->ifd[i]->count) {
1123 printf ("Dumping IFD '%s'...\n",
1124 exif_ifd_get_name (i));
1125 exif_content_dump (data->ifd[i], 0);
1130 printf ("%i byte(s) thumbnail data available: ", data->size);
1131 if (data->size >= 4) {
1132 printf ("0x%02x 0x%02x ... 0x%02x 0x%02x\n",
1133 data->data[0], data->data[1],
1134 data->data[data->size - 2],
1135 data->data[data->size - 1]);
1141 exif_data_get_byte_order (ExifData *data)
1146 return (data->priv->order);
1150 exif_data_foreach_content (ExifData *data, ExifDataForeachContentFunc func,
1158 for (i = 0; i < EXIF_IFD_COUNT; i++)
1159 func (data->ifd[i], user_data);
1162 typedef struct _ByteOrderChangeData ByteOrderChangeData;
1163 struct _ByteOrderChangeData {
1164 ExifByteOrder old, new;
1168 entry_set_byte_order (ExifEntry *e, void *data)
1170 ByteOrderChangeData *d = data;
1175 exif_array_set_byte_order (e->format, e->data, e->components, d->old, d->new);
1179 content_set_byte_order (ExifContent *content, void *data)
1181 exif_content_foreach_entry (content, entry_set_byte_order, data);
1185 exif_data_set_byte_order (ExifData *data, ExifByteOrder order)
1187 ByteOrderChangeData d;
1189 if (!data || (order == data->priv->order))
1192 d.old = data->priv->order;
1194 exif_data_foreach_content (data, content_set_byte_order, &d);
1195 data->priv->order = order;
1197 exif_mnote_data_set_byte_order (data->priv->md, order);
1201 exif_data_log (ExifData *data, ExifLog *log)
1205 if (!data || !data->priv)
1207 exif_log_unref (data->priv->log);
1208 data->priv->log = log;
1211 for (i = 0; i < EXIF_IFD_COUNT; i++)
1212 exif_content_log (data->ifd[i], log);
1215 /* Used internally within libexif */
1216 ExifLog *exif_data_get_log (ExifData *);
1218 exif_data_get_log (ExifData *data)
1220 if (!data || !data->priv)
1222 return data->priv->log;
1225 static const struct {
1226 ExifDataOption option;
1228 const char *description;
1229 } exif_data_option[] = {
1230 {EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS, N_("Ignore unknown tags"),
1231 N_("Ignore unknown tags when loading EXIF data.")},
1232 {EXIF_DATA_OPTION_FOLLOW_SPECIFICATION, N_("Follow specification"),
1233 N_("Add, correct and remove entries to get EXIF data that follows "
1234 "the specification.")},
1235 {EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE, N_("Do not change maker note"),
1236 N_("When loading and resaving Exif data, save the maker note unmodified."
1237 " Be aware that the maker note can get corrupted.")},
1242 exif_data_option_get_name (ExifDataOption o)
1246 for (i = 0; exif_data_option[i].name; i++)
1247 if (exif_data_option[i].option == o)
1249 return _(exif_data_option[i].name);
1253 exif_data_option_get_description (ExifDataOption o)
1257 for (i = 0; exif_data_option[i].description; i++)
1258 if (exif_data_option[i].option == o)
1260 return _(exif_data_option[i].description);
1264 exif_data_set_option (ExifData *d, ExifDataOption o)
1269 d->priv->options |= o;
1273 exif_data_unset_option (ExifData *d, ExifDataOption o)
1278 d->priv->options &= ~o;
1282 fix_func (ExifContent *c, void *UNUSED(data))
1284 switch (exif_content_get_ifd (c)) {
1286 if (c->parent->data)
1287 exif_content_fix (c);
1288 else if (c->count) {
1289 exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
1290 "No thumbnail but entries on thumbnail. These entries have been "
1293 unsigned int cnt = c->count;
1294 exif_content_remove_entry (c, c->entries[c->count - 1]);
1295 if (cnt == c->count) {
1297 exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
1298 "failed to remove last entry from entries.");
1305 exif_content_fix (c);
1310 exif_data_fix (ExifData *d)
1312 exif_data_foreach_content (d, fix_func, NULL);
1316 exif_data_set_data_type (ExifData *d, ExifDataType dt)
1321 d->priv->data_type = dt;
1325 exif_data_get_data_type (ExifData *d)
1327 return (d && d->priv) ? d->priv->data_type : EXIF_DATA_TYPE_UNKNOWN;