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);
195 if ((doff + s < doff) || (doff + s < s) || (doff + s > size)) {
196 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
197 "Tag data past end of buffer (%u > %u)", doff+s, size);
201 entry->data = exif_data_alloc (data, s);
204 memcpy (entry->data, d + doff, s);
206 EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", s);
210 /* If this is the MakerNote, remember the offset */
211 if (entry->tag == EXIF_TAG_MAKER_NOTE) {
213 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
214 "MakerNote found with empty data");
215 } else if (entry->size > 6) {
216 exif_log (data->priv->log,
217 EXIF_LOG_CODE_DEBUG, "ExifData",
218 "MakerNote found (%02x %02x %02x %02x "
219 "%02x %02x %02x...).",
220 entry->data[0], entry->data[1], entry->data[2],
221 entry->data[3], entry->data[4], entry->data[5],
224 data->priv->offset_mnote = doff;
230 exif_data_save_data_entry (ExifData *data, ExifEntry *e,
231 unsigned char **d, unsigned int *ds,
234 unsigned int doff, s;
237 if (!data || !data->priv)
241 * Each entry is 12 bytes long. The memory for the entry has
242 * already been allocated.
244 exif_set_short (*d + 6 + offset + 0,
245 data->priv->order, (ExifShort) e->tag);
246 exif_set_short (*d + 6 + offset + 2,
247 data->priv->order, (ExifShort) e->format);
249 if (!(data->priv->options & EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE)) {
250 /* If this is the maker note tag, update it. */
251 if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
252 /* TODO: this is using the wrong ExifMem to free e->data */
253 exif_mem_free (data->priv->mem, e->data);
256 exif_mnote_data_set_offset (data->priv->md, *ds - 6);
257 exif_mnote_data_save (data->priv->md, &e->data, &e->size);
258 e->components = e->size;
259 if (exif_format_get_size (e->format) != 1) {
260 /* e->format is taken from input code,
261 * but we need to make sure it is a 1 byte
262 * entity due to the multiplication below. */
263 e->format = EXIF_FORMAT_UNDEFINED;
268 exif_set_long (*d + 6 + offset + 4,
269 data->priv->order, e->components);
272 * Size? If bigger than 4 bytes, the actual data is not in
273 * the entry but somewhere else.
275 s = exif_format_get_size (e->format) * e->components;
282 * According to the TIFF specification,
283 * the offset must be an even number. If we need to introduce
284 * a padding byte, we set it to 0.
288 t = exif_mem_realloc (data->priv->mem, *d, ts);
290 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
295 exif_set_long (*d + 6 + offset + 8, data->priv->order, doff);
297 *(*d + *ds - 1) = '\0';
302 /* Write the data. Fill unneeded bytes with 0. Do not crash with
305 memcpy (*d + 6 + doff, e->data, s);
307 memset (*d + 6 + doff, 0, s);
310 memset (*d + 6 + doff + s, 0, (4 - s));
314 exif_data_load_data_thumbnail (ExifData *data, const unsigned char *d,
315 unsigned int ds, ExifLong o, ExifLong s)
318 if ((o + s < o) || (o + s < s) || (o + s > ds) || (o > ds)) {
319 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
320 "Bogus thumbnail offset (%u) or size (%u).",
326 exif_mem_free (data->priv->mem, data->data);
327 if (!(data->data = exif_data_alloc (data, s))) {
328 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", s);
333 memcpy (data->data, d + o, s);
337 #define CHECK_REC(i) \
339 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
340 "ExifData", "Recursive entry in IFD " \
341 "'%s' detected. Skipping...", \
342 exif_ifd_get_name (i)); \
345 if (data->ifd[(i)]->count) { \
346 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
347 "ExifData", "Attempt to load IFD " \
348 "'%s' multiple times detected. " \
350 exif_ifd_get_name (i)); \
354 /*! Calculate the recursion cost added by one level of IFD loading.
356 * The work performed is related to the cost in the exponential relation
360 level_cost(unsigned int n)
362 static const double log_1_1 = 0.09531017980432493;
364 /* Adding 0.1 protects against the case where n==1 */
365 return ceil(log(n + 0.1)/log_1_1);
368 /*! Load data for an IFD.
370 * \param[in,out] data #ExifData
371 * \param[in] ifd IFD to load
372 * \param[in] d pointer to buffer containing raw IFD data
373 * \param[in] ds size of raw data in buffer at \c d
374 * \param[in] offset offset into buffer at \c d at which IFD starts
375 * \param[in] recursion_cost factor indicating how expensive this recursive
379 exif_data_load_data_content (ExifData *data, ExifIfd ifd,
380 const unsigned char *d,
381 unsigned int ds, unsigned int offset, unsigned int recursion_cost)
383 ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
389 if (!data || !data->priv)
392 /* check for valid ExifIfd enum range */
393 if ((((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT))
396 if (recursion_cost > 170) {
398 * recursion_cost is a logarithmic-scale indicator of how expensive this
399 * recursive call might end up being. It is an indicator of the depth of
400 * recursion as well as the potential for worst-case future recursive
401 * calls. Since it's difficult to tell ahead of time how often recursion
402 * will occur, this assumes the worst by assuming every tag could end up
404 * The value of 170 was chosen to limit typical EXIF structures to a
405 * recursive depth of about 6, but pathological ones (those with very
406 * many tags) to only 2.
408 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
409 "Deep/expensive recursion detected!");
413 /* Read the number of entries */
414 if ((offset + 2 < offset) || (offset + 2 < 2) || (offset + 2 > ds)) {
415 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
416 "Tag data past end of buffer (%u > %u)", offset+2, ds);
419 n = exif_get_short (d + offset, data->priv->order);
420 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
421 "Loading %hu entries...", n);
424 /* Check if we have enough data. */
425 if (offset + 12 * n > ds) {
426 n = (ds - offset) / 12;
427 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
428 "Short data; only loading %hu entries...", n);
431 for (i = 0; i < n; i++) {
433 tag = exif_get_short (d + offset + 12 * i, data->priv->order);
435 case EXIF_TAG_EXIF_IFD_POINTER:
436 case EXIF_TAG_GPS_INFO_IFD_POINTER:
437 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
438 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
439 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
440 o = exif_get_long (d + offset + 12 * i + 8,
442 /* FIXME: IFD_POINTER tags aren't marked as being in a
443 * specific IFD, so exif_tag_get_name_in_ifd won't work
445 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
446 "Sub-IFD entry 0x%x ('%s') at %u.", tag,
447 exif_tag_get_name(tag), o);
449 case EXIF_TAG_EXIF_IFD_POINTER:
450 CHECK_REC (EXIF_IFD_EXIF);
451 exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o,
452 recursion_cost + level_cost(n));
454 case EXIF_TAG_GPS_INFO_IFD_POINTER:
455 CHECK_REC (EXIF_IFD_GPS);
456 exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o,
457 recursion_cost + level_cost(n));
459 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
460 CHECK_REC (EXIF_IFD_INTEROPERABILITY);
461 exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o,
462 recursion_cost + level_cost(n));
464 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
465 thumbnail_offset = o;
466 if (thumbnail_offset && thumbnail_length)
467 exif_data_load_data_thumbnail (data, d,
468 ds, thumbnail_offset,
471 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
472 thumbnail_length = o;
473 if (thumbnail_offset && thumbnail_length)
474 exif_data_load_data_thumbnail (data, d,
475 ds, thumbnail_offset,
485 * If we don't know the tag, don't fail. It could be that new
486 * versions of the standard have defined additional tags. Note that
487 * 0 is a valid tag in the GPS IFD.
489 if (!exif_tag_get_name_in_ifd (tag, ifd)) {
492 * Special case: Tag and format 0. That's against specification
493 * (at least up to 2.2). But Photoshop writes it anyways.
495 if (!memcmp (d + offset + 12 * i, "\0\0\0\0", 4)) {
496 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
497 "Skipping empty entry at position %u in '%s'.", i,
498 exif_ifd_get_name (ifd));
501 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
502 "Unknown tag 0x%04x (entry %u in '%s'). Please report this tag "
503 "to <libexif-devel@lists.sourceforge.net>.", tag, i,
504 exif_ifd_get_name (ifd));
505 if (data->priv->options & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS)
508 entry = exif_entry_new_mem (data->priv->mem);
510 exif_log (data->priv->log, EXIF_LOG_CODE_NO_MEMORY, "ExifData",
511 "Could not allocate memory");
514 if (exif_data_load_data_entry (data, entry, d, ds,
516 exif_content_add_entry (data->ifd[ifd], entry);
517 exif_entry_unref (entry);
524 cmp_func (const unsigned char *p1, const unsigned char *p2, ExifByteOrder o)
526 ExifShort tag1 = exif_get_short (p1, o);
527 ExifShort tag2 = exif_get_short (p2, o);
529 return (tag1 < tag2) ? -1 : (tag1 > tag2) ? 1 : 0;
533 cmp_func_intel (const void *elem1, const void *elem2)
535 return cmp_func ((const unsigned char *) elem1,
536 (const unsigned char *) elem2, EXIF_BYTE_ORDER_INTEL);
540 cmp_func_motorola (const void *elem1, const void *elem2)
542 return cmp_func ((const unsigned char *) elem1,
543 (const unsigned char *) elem2, EXIF_BYTE_ORDER_MOTOROLA);
547 exif_data_save_data_content (ExifData *data, ExifContent *ifd,
548 unsigned char **d, unsigned int *ds,
551 unsigned int j, n_ptr = 0, n_thumb = 0;
556 if (!data || !data->priv || !ifd || !d || !ds)
559 for (i = 0; i < EXIF_IFD_COUNT; i++)
560 if (ifd == data->ifd[i])
562 if (i == EXIF_IFD_COUNT)
566 * Check if we need some extra entries for pointers or the thumbnail.
572 * The pointer to IFD_EXIF is in IFD_0. The pointer to
573 * IFD_INTEROPERABILITY is in IFD_EXIF.
575 if (data->ifd[EXIF_IFD_EXIF]->count ||
576 data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
579 /* The pointer to IFD_GPS is in IFD_0. */
580 if (data->ifd[EXIF_IFD_GPS]->count)
589 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
596 * Allocate enough memory for all entries
597 * and the number of entries.
599 ts = *ds + (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
600 t = exif_mem_realloc (data->priv->mem, *d, ts);
602 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
608 /* Save the number of entries */
609 exif_set_short (*d + 6 + offset, data->priv->order,
610 (ExifShort) (ifd->count + n_ptr + n_thumb));
614 * Save each entry. Make sure that no memcpys from NULL pointers are
617 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
618 "Saving %i entries (IFD '%s', offset: %i)...",
619 ifd->count, exif_ifd_get_name (i), offset);
620 for (j = 0; j < ifd->count; j++) {
621 if (ifd->entries[j]) {
622 exif_data_save_data_entry (data, ifd->entries[j], d, ds,
627 offset += 12 * ifd->count;
629 /* Now save special entries. */
634 * The pointer to IFD_EXIF is in IFD_0.
635 * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
636 * therefore, if IFD_INTEROPERABILITY is not empty, we need
637 * IFD_EXIF even if latter is empty.
639 if (data->ifd[EXIF_IFD_EXIF]->count ||
640 data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
641 exif_set_short (*d + 6 + offset + 0, data->priv->order,
642 EXIF_TAG_EXIF_IFD_POINTER);
643 exif_set_short (*d + 6 + offset + 2, data->priv->order,
645 exif_set_long (*d + 6 + offset + 4, data->priv->order,
647 exif_set_long (*d + 6 + offset + 8, data->priv->order,
649 exif_data_save_data_content (data,
650 data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
654 /* The pointer to IFD_GPS is in IFD_0, too. */
655 if (data->ifd[EXIF_IFD_GPS]->count) {
656 exif_set_short (*d + 6 + offset + 0, data->priv->order,
657 EXIF_TAG_GPS_INFO_IFD_POINTER);
658 exif_set_short (*d + 6 + offset + 2, data->priv->order,
660 exif_set_long (*d + 6 + offset + 4, data->priv->order,
662 exif_set_long (*d + 6 + offset + 8, data->priv->order,
664 exif_data_save_data_content (data,
665 data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
673 * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
676 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
677 exif_set_short (*d + 6 + offset + 0, data->priv->order,
678 EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
679 exif_set_short (*d + 6 + offset + 2, data->priv->order,
681 exif_set_long (*d + 6 + offset + 4, data->priv->order,
683 exif_set_long (*d + 6 + offset + 8, data->priv->order,
685 exif_data_save_data_content (data,
686 data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
695 * Information about the thumbnail (if any) is saved in
700 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
701 exif_set_short (*d + 6 + offset + 0, data->priv->order,
702 EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
703 exif_set_short (*d + 6 + offset + 2, data->priv->order,
705 exif_set_long (*d + 6 + offset + 4, data->priv->order,
707 exif_set_long (*d + 6 + offset + 8, data->priv->order,
709 ts = *ds + data->size;
710 t = exif_mem_realloc (data->priv->mem, *d, ts);
712 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData",
718 memcpy (*d + *ds - data->size, data->data, data->size);
721 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
722 exif_set_short (*d + 6 + offset + 0, data->priv->order,
723 EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
724 exif_set_short (*d + 6 + offset + 2, data->priv->order,
726 exif_set_long (*d + 6 + offset + 4, data->priv->order,
728 exif_set_long (*d + 6 + offset + 8, data->priv->order,
738 /* Sort the directory according to TIFF specification */
739 qsort (*d + 6 + offset - (ifd->count + n_ptr + n_thumb) * 12,
740 (ifd->count + n_ptr + n_thumb), 12,
741 (data->priv->order == EXIF_BYTE_ORDER_INTEL) ? cmp_func_intel : cmp_func_motorola);
743 /* Correctly terminate the directory */
744 if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
748 * We are saving IFD 0. Tell where IFD 1 starts and save
751 exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6);
752 exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds,
755 exif_set_long (*d + 6 + offset, data->priv->order, 0);
759 EXIF_DATA_TYPE_MAKER_NOTE_NONE = 0,
760 EXIF_DATA_TYPE_MAKER_NOTE_CANON = 1,
761 EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS = 2,
762 EXIF_DATA_TYPE_MAKER_NOTE_PENTAX = 3,
763 EXIF_DATA_TYPE_MAKER_NOTE_NIKON = 4,
764 EXIF_DATA_TYPE_MAKER_NOTE_CASIO = 5,
765 EXIF_DATA_TYPE_MAKER_NOTE_FUJI = 6
766 } ExifDataTypeMakerNote;
768 /*! If MakerNote is recognized, load it.
770 * \param[in,out] data #ExifData
771 * \param[in] d pointer to raw EXIF data
772 * \param[in] ds length of data at d
775 interpret_maker_note(ExifData *data, const unsigned char *d, unsigned int ds)
778 ExifEntry* e = exif_data_get_entry (data, EXIF_TAG_MAKER_NOTE);
782 if ((mnoteid = exif_mnote_data_olympus_identify (data, e)) != 0) {
783 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
784 "ExifData", "Olympus MakerNote variant type %d", mnoteid);
785 data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
787 } else if ((mnoteid = exif_mnote_data_canon_identify (data, e)) != 0) {
788 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
789 "ExifData", "Canon MakerNote variant type %d", mnoteid);
790 data->priv->md = exif_mnote_data_canon_new (data->priv->mem, data->priv->options);
792 } else if ((mnoteid = exif_mnote_data_fuji_identify (data, e)) != 0) {
793 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
794 "ExifData", "Fuji MakerNote variant type %d", mnoteid);
795 data->priv->md = exif_mnote_data_fuji_new (data->priv->mem);
797 /* NOTE: Must do Pentax detection last because some of the
798 * heuristics are pretty general. */
799 } else if ((mnoteid = exif_mnote_data_pentax_identify (data, e)) != 0) {
800 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
801 "ExifData", "Pentax MakerNote variant type %d", mnoteid);
802 data->priv->md = exif_mnote_data_pentax_new (data->priv->mem);
806 * If we are able to interpret the maker note, do so.
808 if (data->priv->md) {
809 exif_mnote_data_log (data->priv->md, data->priv->log);
810 exif_mnote_data_set_byte_order (data->priv->md,
812 exif_mnote_data_set_offset (data->priv->md,
813 data->priv->offset_mnote);
814 exif_mnote_data_load (data->priv->md, d, ds);
818 #define LOG_TOO_SMALL \
819 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData", \
820 _("Size of data too small to allow for EXIF data."));
823 exif_data_load_data (ExifData *data, const unsigned char *d_orig,
829 const unsigned char *d = d_orig;
830 unsigned int len, fullds;
832 if (!data || !data->priv || !d || !ds)
835 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
836 "Parsing %i byte(s) EXIF data...\n", ds);
839 * It can be that the data starts with the EXIF header. If it does
840 * not, search the EXIF marker.
846 if (!memcmp (d, ExifHeader, 6)) {
847 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
848 "Found EXIF header at start.");
851 while (ds && (d[0] == 0xff)) {
856 /* JPEG_MARKER_SOI */
857 if (ds && d[0] == JPEG_MARKER_SOI) {
863 /* JPEG_MARKER_APP1 */
864 if (ds && d[0] == JPEG_MARKER_APP1)
867 /* Skip irrelevant APP markers. The branch for APP1 must come before this,
868 otherwise this code block will cause APP1 to be skipped. This code path
869 is only relevant for files that are nonconformant to the EXIF
870 specification. For conformant files, the APP1 code path above will be
872 if (ds >= 3 && d[0] >= 0xe0 && d[0] <= 0xef) { /* JPEG_MARKER_APPn */
875 l = (d[0] << 8) | d[1];
883 /* Unknown marker or data. Give up. */
884 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
885 "ExifData", _("EXIF marker not found."));
894 len = (d[0] << 8) | d[1];
895 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
896 "We have to deal with %i byte(s) of EXIF data.",
903 * Verify the exif header
904 * (offset 2, length 6).
910 if (memcmp (d, ExifHeader, 6)) {
911 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
912 "ExifData", _("EXIF header not found."));
916 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
917 "Found EXIF header.");
919 /* Sanity check the data length */
923 /* The JPEG APP1 section can be no longer than 64 KiB (including a
924 16-bit length), so cap the data length to protect against overflow
925 in future offset calculations */
930 /* Byte order (offset 6, length 2) */
931 if (!memcmp (d + 6, "II", 2))
932 data->priv->order = EXIF_BYTE_ORDER_INTEL;
933 else if (!memcmp (d + 6, "MM", 2))
934 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
936 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
937 "ExifData", _("Unknown encoding."));
942 if (exif_get_short (d + 8, data->priv->order) != 0x002a)
946 offset = exif_get_long (d + 10, data->priv->order);
947 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
948 "IFD 0 at %i.", (int) offset);
950 /* Sanity check the offset, being careful about overflow */
951 if (offset > ds || offset + 6 + 2 > ds)
954 /* Parse the actual exif data (usually offset 14 from start) */
955 exif_data_load_data_content (data, EXIF_IFD_0, d + 6, ds - 6, offset, 0);
958 n = exif_get_short (d + 6 + offset, data->priv->order);
959 if (offset + 6 + 2 + 12 * n + 4 > ds)
962 offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order);
964 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
965 "IFD 1 at %i.", (int) offset);
968 if (offset > ds || offset + 6 > ds) {
969 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
970 "ExifData", "Bogus offset of IFD1.");
972 exif_data_load_data_content (data, EXIF_IFD_1, d + 6, ds - 6, offset, 0);
977 * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
978 * cameras use pointers in the maker note tag that point to the
979 * space between IFDs. Here is the only place where we have access
982 interpret_maker_note(data, d, fullds);
984 /* Fixup tags if requested */
985 if (data->priv->options & EXIF_DATA_OPTION_FOLLOW_SPECIFICATION)
986 exif_data_fix (data);
990 exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds)
993 *ds = 0; /* This means something went wrong */
995 if (!data || !d || !ds)
1000 *d = exif_data_alloc (data, *ds);
1005 memcpy (*d, ExifHeader, 6);
1007 /* Order (offset 6) */
1008 if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
1009 memcpy (*d + 6, "II", 2);
1011 memcpy (*d + 6, "MM", 2);
1014 /* Fixed value (2 bytes, offset 8) */
1015 exif_set_short (*d + 8, data->priv->order, 0x002a);
1018 * IFD 0 offset (4 bytes, offset 10).
1019 * We will start 8 bytes after the
1020 * EXIF header (2 bytes for order, another 2 for the test, and
1021 * 4 bytes for the IFD 0 offset make 8 bytes together).
1023 exif_set_long (*d + 10, data->priv->order, 8);
1025 /* Now save IFD 0. IFD 1 will be saved automatically. */
1026 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1028 exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds,
1030 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1031 "Saved %i byte(s) EXIF data.", *ds);
1035 exif_data_new_from_file (const char *path)
1040 loader = exif_loader_new ();
1041 exif_loader_write_file (loader, path);
1042 edata = exif_loader_get_data (loader);
1043 exif_loader_unref (loader);
1049 exif_data_ref (ExifData *data)
1054 data->priv->ref_count++;
1058 exif_data_unref (ExifData *data)
1063 data->priv->ref_count--;
1064 if (!data->priv->ref_count)
1065 exif_data_free (data);
1069 exif_data_free (ExifData *data)
1072 ExifMem *mem = (data && data->priv) ? data->priv->mem : NULL;
1077 for (i = 0; i < EXIF_IFD_COUNT; i++) {
1079 exif_content_unref (data->ifd[i]);
1080 data->ifd[i] = NULL;
1085 exif_mem_free (mem, data->data);
1090 if (data->priv->log) {
1091 exif_log_unref (data->priv->log);
1092 data->priv->log = NULL;
1094 if (data->priv->md) {
1095 exif_mnote_data_unref (data->priv->md);
1096 data->priv->md = NULL;
1098 exif_mem_free (mem, data->priv);
1099 exif_mem_free (mem, data);
1102 exif_mem_unref (mem);
1106 exif_data_dump (ExifData *data)
1113 for (i = 0; i < EXIF_IFD_COUNT; i++) {
1114 if (data->ifd[i] && data->ifd[i]->count) {
1115 printf ("Dumping IFD '%s'...\n",
1116 exif_ifd_get_name (i));
1117 exif_content_dump (data->ifd[i], 0);
1122 printf ("%i byte(s) thumbnail data available: ", data->size);
1123 if (data->size >= 4) {
1124 printf ("0x%02x 0x%02x ... 0x%02x 0x%02x\n",
1125 data->data[0], data->data[1],
1126 data->data[data->size - 2],
1127 data->data[data->size - 1]);
1133 exif_data_get_byte_order (ExifData *data)
1138 return (data->priv->order);
1142 exif_data_foreach_content (ExifData *data, ExifDataForeachContentFunc func,
1150 for (i = 0; i < EXIF_IFD_COUNT; i++)
1151 func (data->ifd[i], user_data);
1154 typedef struct _ByteOrderChangeData ByteOrderChangeData;
1155 struct _ByteOrderChangeData {
1156 ExifByteOrder old, new;
1160 entry_set_byte_order (ExifEntry *e, void *data)
1162 ByteOrderChangeData *d = data;
1167 exif_array_set_byte_order (e->format, e->data, e->components, d->old, d->new);
1171 content_set_byte_order (ExifContent *content, void *data)
1173 exif_content_foreach_entry (content, entry_set_byte_order, data);
1177 exif_data_set_byte_order (ExifData *data, ExifByteOrder order)
1179 ByteOrderChangeData d;
1181 if (!data || (order == data->priv->order))
1184 d.old = data->priv->order;
1186 exif_data_foreach_content (data, content_set_byte_order, &d);
1187 data->priv->order = order;
1189 exif_mnote_data_set_byte_order (data->priv->md, order);
1193 exif_data_log (ExifData *data, ExifLog *log)
1197 if (!data || !data->priv)
1199 exif_log_unref (data->priv->log);
1200 data->priv->log = log;
1203 for (i = 0; i < EXIF_IFD_COUNT; i++)
1204 exif_content_log (data->ifd[i], log);
1207 /* Used internally within libexif */
1208 ExifLog *exif_data_get_log (ExifData *);
1210 exif_data_get_log (ExifData *data)
1212 if (!data || !data->priv)
1214 return data->priv->log;
1217 static const struct {
1218 ExifDataOption option;
1220 const char *description;
1221 } exif_data_option[] = {
1222 {EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS, N_("Ignore unknown tags"),
1223 N_("Ignore unknown tags when loading EXIF data.")},
1224 {EXIF_DATA_OPTION_FOLLOW_SPECIFICATION, N_("Follow specification"),
1225 N_("Add, correct and remove entries to get EXIF data that follows "
1226 "the specification.")},
1227 {EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE, N_("Do not change maker note"),
1228 N_("When loading and resaving Exif data, save the maker note unmodified."
1229 " Be aware that the maker note can get corrupted.")},
1234 exif_data_option_get_name (ExifDataOption o)
1238 for (i = 0; exif_data_option[i].name; i++)
1239 if (exif_data_option[i].option == o)
1241 return _(exif_data_option[i].name);
1245 exif_data_option_get_description (ExifDataOption o)
1249 for (i = 0; exif_data_option[i].description; i++)
1250 if (exif_data_option[i].option == o)
1252 return _(exif_data_option[i].description);
1256 exif_data_set_option (ExifData *d, ExifDataOption o)
1261 d->priv->options |= o;
1265 exif_data_unset_option (ExifData *d, ExifDataOption o)
1270 d->priv->options &= ~o;
1274 fix_func (ExifContent *c, void *UNUSED(data))
1276 switch (exif_content_get_ifd (c)) {
1278 if (c->parent->data)
1279 exif_content_fix (c);
1280 else if (c->count) {
1281 exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
1282 "No thumbnail but entries on thumbnail. These entries have been "
1285 unsigned int cnt = c->count;
1286 exif_content_remove_entry (c, c->entries[c->count - 1]);
1287 if (cnt == c->count) {
1289 exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
1290 "failed to remove last entry from entries.");
1297 exif_content_fix (c);
1302 exif_data_fix (ExifData *d)
1304 exif_data_foreach_content (d, fix_func, NULL);
1308 exif_data_set_data_type (ExifData *d, ExifDataType dt)
1313 d->priv->data_type = dt;
1317 exif_data_get_data_type (ExifData *d)
1319 return (d && d->priv) ? d->priv->data_type : EXIF_DATA_TYPE_UNKNOWN;