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., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
23 #include <libexif/exif-entry.h>
24 #include <libexif/exif-ifd.h>
25 #include <libexif/exif-utils.h>
26 #include <libexif/i18n.h>
35 struct _ExifEntryPrivate
37 unsigned int ref_count;
42 /* This function is hidden in exif-data.c */
43 ExifLog *exif_data_get_log (ExifData *);
45 #ifndef NO_VERBOSE_TAG_STRINGS
47 exif_entry_log (ExifEntry *e, ExifLogCode code, const char *format, ...)
52 if (e && e->parent && e->parent->parent)
53 l = exif_data_get_log (e->parent->parent);
54 va_start (args, format);
55 exif_logv (l, code, "ExifEntry", format, args);
59 #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
60 #define exif_entry_log(...) do { } while (0)
61 #elif defined(__GNUC__)
62 #define exif_entry_log(x...) do { } while (0)
64 #define exif_entry_log (void)
69 exif_entry_alloc (ExifEntry *e, unsigned int i)
74 if (!e || !e->priv || !i) return NULL;
76 d = exif_mem_alloc (e->priv->mem, i);
79 if (e->parent && e->parent->parent)
80 l = exif_data_get_log (e->parent->parent);
81 EXIF_LOG_NO_MEMORY (l, "ExifEntry", i);
86 exif_entry_realloc (ExifEntry *e, void *d_orig, unsigned int i)
91 if (!e || !e->priv) return NULL;
93 if (!i) { exif_mem_free (e->priv->mem, d_orig); return NULL; }
95 d = exif_mem_realloc (e->priv->mem, d_orig, i);
98 if (e->parent && e->parent->parent)
99 l = exif_data_get_log (e->parent->parent);
100 EXIF_LOG_NO_MEMORY (l, "ExifEntry", i);
105 exif_entry_new (void)
107 ExifMem *mem = exif_mem_new_default ();
108 ExifEntry *e = exif_entry_new_mem (mem);
110 exif_mem_unref (mem);
116 exif_entry_new_mem (ExifMem *mem)
120 e = exif_mem_alloc (mem, sizeof (ExifEntry));
122 e->priv = exif_mem_alloc (mem, sizeof (ExifEntryPrivate));
123 if (!e->priv) { exif_mem_free (mem, e); return NULL; }
124 e->priv->ref_count = 1;
133 exif_entry_ref (ExifEntry *e)
137 e->priv->ref_count++;
141 exif_entry_unref (ExifEntry *e)
145 e->priv->ref_count--;
146 if (!e->priv->ref_count)
151 exif_entry_free (ExifEntry *e)
156 ExifMem *mem = e->priv->mem;
158 exif_mem_free (mem, e->data);
159 exif_mem_free (mem, e->priv);
160 exif_mem_free (mem, e);
161 exif_mem_unref (mem);
166 exif_entry_fix (ExifEntry *e)
173 if (!e || !e->priv) return;
177 /* These tags all need to be of format SHORT. */
178 case EXIF_TAG_YCBCR_SUB_SAMPLING:
179 case EXIF_TAG_SUBJECT_AREA:
180 case EXIF_TAG_COLOR_SPACE:
181 case EXIF_TAG_PLANAR_CONFIGURATION:
182 case EXIF_TAG_SENSING_METHOD:
183 case EXIF_TAG_ORIENTATION:
184 case EXIF_TAG_YCBCR_POSITIONING:
185 case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
186 case EXIF_TAG_CUSTOM_RENDERED:
187 case EXIF_TAG_EXPOSURE_MODE:
188 case EXIF_TAG_WHITE_BALANCE:
189 case EXIF_TAG_SCENE_CAPTURE_TYPE:
190 case EXIF_TAG_GAIN_CONTROL:
191 case EXIF_TAG_SATURATION:
192 case EXIF_TAG_CONTRAST:
193 case EXIF_TAG_SHARPNESS:
195 case EXIF_FORMAT_LONG:
196 if (!e->parent || !e->parent->parent) break;
197 o = exif_data_get_byte_order (e->parent->parent);
198 for (i = 0; i < e->components; i++)
201 exif_format_get_size (
202 EXIF_FORMAT_SHORT), o,
203 (ExifShort) exif_get_long (
205 exif_format_get_size (
206 EXIF_FORMAT_LONG), o));
207 e->format = EXIF_FORMAT_SHORT;
208 e->size = e->components *
209 exif_format_get_size (e->format);
210 e->data = exif_entry_realloc (e, e->data, e->size);
211 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
212 _("Tag '%s' was of format '%s' (which is "
213 "against specification) and has been "
214 "changed to format '%s'."),
215 exif_tag_get_name (e->tag),
216 exif_format_get_name (EXIF_FORMAT_LONG),
217 exif_format_get_name (EXIF_FORMAT_SHORT));
219 case EXIF_FORMAT_SHORT:
225 /* All these tags need to be of format 'Rational'. */
226 case EXIF_TAG_FNUMBER:
227 case EXIF_TAG_APERTURE_VALUE:
228 case EXIF_TAG_EXPOSURE_TIME:
229 case EXIF_TAG_FOCAL_LENGTH:
231 case EXIF_FORMAT_SRATIONAL:
232 if (!e->parent || !e->parent->parent) break;
233 o = exif_data_get_byte_order (e->parent->parent);
234 for (i = 0; i < e->components; i++) {
235 sr = exif_get_srational (e->data + i *
236 exif_format_get_size (
237 EXIF_FORMAT_SRATIONAL), o);
238 r.numerator = (ExifLong) sr.numerator;
239 r.denominator = (ExifLong) sr.denominator;
240 exif_set_rational (e->data + i *
241 exif_format_get_size (
242 EXIF_FORMAT_RATIONAL), o, r);
244 e->format = EXIF_FORMAT_RATIONAL;
245 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
246 _("Tag '%s' was of format '%s' (which is "
247 "against specification) and has been "
248 "changed to format '%s'."),
249 exif_tag_get_name (e->tag),
250 exif_format_get_name (EXIF_FORMAT_SRATIONAL),
251 exif_format_get_name (EXIF_FORMAT_RATIONAL));
258 case EXIF_TAG_USER_COMMENT:
260 /* Format needs to be UNDEFINED. */
261 if (e->format != EXIF_FORMAT_UNDEFINED) {
262 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
263 _("Tag 'UserComment' had invalid format '%s'. "
264 "Format has been set to 'undefined'."),
265 exif_format_get_name (e->format));
266 e->format = EXIF_FORMAT_UNDEFINED;
269 /* Some packages like Canon ZoomBrowser EX 4.5 store
270 only one zero byte followed by 7 bytes of rubbish */
271 if ((e->size >= 8) && (e->data[0] == 0)) {
272 memcpy(e->data, "\0\0\0\0\0\0\0\0", 8);
275 /* There need to be at least 8 bytes. */
277 e->data = exif_entry_realloc (e, e->data, 8 + e->size);
285 memmove (e->data + 8, e->data, e->size);
286 memcpy (e->data, "ASCII\0\0\0", 8);
289 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
290 _("Tag 'UserComment' has been expanded to at "
291 "least 8 bytes in order to follow the "
297 * If the first 8 bytes are empty and real data starts
298 * afterwards, let's assume ASCII and claim the 8 first
299 * bytes for the format specifyer.
301 for (i = 0; (i < e->size) && !e->data[i]; i++);
302 if (!i) for ( ; (i < e->size) && (e->data[i] == ' '); i++);
303 if ((i >= 8) && (i < e->size)) {
304 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
305 "Tag 'UserComment' is not empty but does not start with "
306 "format identifyer. This has been fixed.");
307 memcpy (e->data, "ASCII\0\0\0", 8);
312 * First 8 bytes need to follow the specification. If they don't,
315 if (memcmp (e->data, "ASCII\0\0\0" , 8) &&
316 memcmp (e->data, "UNICODE\0" , 8) &&
317 memcmp (e->data, "JIS\0\0\0\0\0" , 8) &&
318 memcmp (e->data, "\0\0\0\0\0\0\0\0", 8)) {
319 e->data = exif_entry_realloc (e, e->data, 8 + e->size);
327 memmove (e->data + 8, e->data, e->size);
328 memcpy (e->data, "ASCII\0\0\0", 8);
331 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
332 _("Tag 'UserComment' did not start with "
333 "format identifier. This has been fixed."));
344 exif_entry_dump (ExifEntry *e, unsigned int indent)
350 for (i = 0; i < 2 * indent; i++)
357 printf ("%sTag: 0x%x ('%s')\n", buf, e->tag,
358 exif_tag_get_name (e->tag));
359 printf ("%s Format: %i ('%s')\n", buf, e->format,
360 exif_format_get_name (e->format));
361 printf ("%s Components: %i\n", buf, (int) e->components);
362 printf ("%s Size: %i\n", buf, e->size);
363 printf ("%s Value: %s\n", buf, exif_entry_get_value (e, value, sizeof(value)));
366 #define CF(entry,target,v,maxlen) \
368 if (entry->format != target) { \
369 exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA, \
370 _("The tag '%s' contains data of an invalid " \
371 "format ('%s', expected '%s')."), \
372 exif_tag_get_name (entry->tag), \
373 exif_format_get_name (entry->format), \
374 exif_format_get_name (target)); \
379 #define CC(entry,target,v,maxlen) \
381 if (entry->components != target) { \
382 exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA, \
383 _("The tag '%s' contains an invalid number of " \
384 "components (%i, expected %i)."), \
385 exif_tag_get_name (entry->tag), \
386 (int) entry->components, (int) target); \
391 static const struct {
393 const char *strings[10];
395 #ifndef NO_VERBOSE_TAG_DATA
396 { EXIF_TAG_PLANAR_CONFIGURATION,
397 { N_("chunky format"), N_("planar format"), NULL}},
398 { EXIF_TAG_SENSING_METHOD,
399 { "", N_("Not defined"), N_("One-chip color area sensor"),
400 N_("Two-chip color area sensor"), N_("Three-chip color area sensor"),
401 N_("Color sequential area sensor"), "", N_("Trilinear sensor"),
402 N_("Color sequential linear sensor"), NULL}},
403 { EXIF_TAG_ORIENTATION,
404 { "", N_("top - left"), N_("top - right"), N_("bottom - right"),
405 N_("bottom - left"), N_("left - top"), N_("right - top"),
406 N_("right - bottom"), N_("left - bottom"), NULL}},
407 { EXIF_TAG_YCBCR_POSITIONING,
408 { "", N_("centered"), N_("co-sited"), NULL}},
409 { EXIF_TAG_PHOTOMETRIC_INTERPRETATION,
410 {N_("Reversed mono"), N_("Normal mono"), N_("RGB"), N_("Palette"), "",
411 N_("CMYK"), N_("YCbCr"), "", N_("CieLAB"), NULL}},
412 { EXIF_TAG_CUSTOM_RENDERED,
413 { N_("Normal process"), N_("Custom process"), NULL}},
414 { EXIF_TAG_EXPOSURE_MODE,
415 { N_("Auto exposure"), N_("Manual exposure"), N_("Auto bracket"), NULL}},
416 { EXIF_TAG_WHITE_BALANCE,
417 { N_("Auto white balance"), N_("Manual white balance"), NULL}},
418 { EXIF_TAG_SCENE_CAPTURE_TYPE,
419 { N_("Standard"), N_("Landscape"), N_("Portrait"),
420 N_("Night scene"), NULL}},
421 { EXIF_TAG_GAIN_CONTROL,
422 { N_("Normal"), N_("Low gain up"), N_("High gain up"),
423 N_("Low gain down"), N_("High gain down"), NULL}},
424 { EXIF_TAG_SATURATION,
425 { N_("Normal"), N_("Low saturation"), N_("High saturation"), NULL}},
426 { EXIF_TAG_CONTRAST , {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
427 { EXIF_TAG_SHARPNESS, {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
432 static const struct {
436 const char *values[4];
439 #ifndef NO_VERBOSE_TAG_DATA
440 { EXIF_TAG_METERING_MODE,
441 { { 0, {N_("Unknown"), NULL}},
442 { 1, {N_("Average"), N_("avg"), NULL}},
443 { 2, {N_("Center-Weighted Average"), N_("Center-Weight"), NULL}},
444 { 3, {N_("Spot"), NULL}},
445 { 4, {N_("Multi Spot"), NULL}},
446 { 5, {N_("Pattern"), NULL}},
447 { 6, {N_("Partial"), NULL}},
448 {255, {N_("Other"), NULL}},
450 { EXIF_TAG_COMPRESSION,
451 { {1, {N_("Uncompressed"), NULL}},
452 {5, {N_("LZW compression"), NULL}},
453 {6, {N_("JPEG compression"), NULL}},
454 {7, {N_("JPEG compression"), NULL}},
455 {8, {N_("Deflate/ZIP compression"), NULL}},
456 {32773, {N_("PackBits compression"), NULL}},
458 { EXIF_TAG_LIGHT_SOURCE,
459 { { 0, {N_("Unknown"), NULL}},
460 { 1, {N_("Daylight"), NULL}},
461 { 2, {N_("Fluorescent"), NULL}},
462 { 3, {N_("Tungsten incandescent light"), N_("Tungsten"), NULL}},
463 { 4, {N_("Flash"), NULL}},
464 { 9, {N_("Fine weather"), NULL}},
465 { 10, {N_("Cloudy weather"), N_("Cloudy"), NULL}},
466 { 11, {N_("Shade"), NULL}},
467 { 12, {N_("Daylight fluorescent"), NULL}},
468 { 13, {N_("Day white fluorescent"), NULL}},
469 { 14, {N_("Cool white fluorescent"), NULL}},
470 { 15, {N_("White fluorescent"), NULL}},
471 { 17, {N_("Standard light A"), NULL}},
472 { 18, {N_("Standard light B"), NULL}},
473 { 19, {N_("Standard light C"), NULL}},
474 { 20, {N_("D55"), NULL}},
475 { 21, {N_("D65"), NULL}},
476 { 22, {N_("D75"), NULL}},
477 { 24, {N_("ISO studio tungsten"),NULL}},
478 {255, {N_("Other"), NULL}},
480 { EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT,
481 { {2, {N_("Inch"), N_("in"), NULL}},
482 {3, {N_("Centimeter"), N_("cm"), NULL}},
484 { EXIF_TAG_RESOLUTION_UNIT,
485 { {2, {N_("Inch"), N_("in"), NULL}},
486 {3, {N_("Centimeter"), N_("cm"), NULL}},
488 { EXIF_TAG_EXPOSURE_PROGRAM,
489 { {0, {N_("Not defined"), NULL}},
490 {1, {N_("Manual"), NULL}},
491 {2, {N_("Normal program"), N_("Normal"), NULL}},
492 {3, {N_("Aperture priority"), N_("Aperture"), NULL}},
493 {4, {N_("Shutter priority"),N_("Shutter"), NULL}},
494 {5, {N_("Creative program (biased toward depth of field)"),
495 N_("Creative"), NULL}},
496 {6, {N_("Creative program (biased toward fast shutter speed)"),
497 N_("Action"), NULL}},
498 {7, {N_("Portrait mode (for closeup photos with the background out "
499 "of focus)"), N_("Portrait"), NULL}},
500 {8, {N_("Landscape mode (for landscape photos with the background "
501 "in focus)"), N_("Landscape"), NULL}},
504 { {0x0000, {N_("Flash did not fire."), N_("no flash"), NULL}},
505 {0x0001, {N_("Flash fired."), N_("flash"), N_("Yes"), NULL}},
506 {0x0005, {N_("Strobe return light not detected."), N_("W/o strobe"),
508 {0x0007, {N_("Strobe return light detected."), N_("W. strobe"), NULL}},
509 {0x0008, {N_("Flash did not fire."), NULL}}, /* Olympus E-330 */
510 {0x0009, {N_("Flash fired, compulsory flash mode."), NULL}},
511 {0x000d, {N_("Flash fired, compulsory flash mode, return light "
512 "not detected."), NULL}},
513 {0x000f, {N_("Flash fired, compulsory flash mode, return light "
514 "detected."), NULL}},
515 {0x0010, {N_("Flash did not fire, compulsory flash mode."), NULL}},
516 {0x0018, {N_("Flash did not fire, auto mode."), NULL}},
517 {0x0019, {N_("Flash fired, auto mode."), NULL}},
518 {0x001d, {N_("Flash fired, auto mode, return light not detected."),
520 {0x001f, {N_("Flash fired, auto mode, return light detected."), NULL}},
521 {0x0020, {N_("No flash function."),NULL}},
522 {0x0041, {N_("Flash fired, red-eye reduction mode."), NULL}},
523 {0x0045, {N_("Flash fired, red-eye reduction mode, return light "
524 "not detected."), NULL}},
525 {0x0047, {N_("Flash fired, red-eye reduction mode, return light "
526 "detected."), NULL}},
527 {0x0049, {N_("Flash fired, compulsory flash mode, red-eye reduction "
529 {0x004d, {N_("Flash fired, compulsory flash mode, red-eye reduction "
530 "mode, return light not detected."), NULL}},
531 {0x004f, {N_("Flash fired, compulsory flash mode, red-eye reduction mode, "
532 "return light detected."), NULL}},
533 {0x0058, {N_("Flash did not fire, auto mode, red-eye reduction mode."), NULL}},
534 {0x0059, {N_("Flash fired, auto mode, red-eye reduction mode."), NULL}},
535 {0x005d, {N_("Flash fired, auto mode, return light not detected, "
536 "red-eye reduction mode."), NULL}},
537 {0x005f, {N_("Flash fired, auto mode, return light detected, "
538 "red-eye reduction mode."), NULL}},
540 {EXIF_TAG_SUBJECT_DISTANCE_RANGE,
541 { {0, {N_("Unknown"), N_("?"), NULL}},
542 {1, {N_("Macro"), NULL}},
543 {2, {N_("Close view"), N_("Close"), NULL}},
544 {3, {N_("Distant view"), N_("Distant"), NULL}},
546 { EXIF_TAG_COLOR_SPACE,
547 { {1, {N_("sRGB"), NULL}},
548 {2, {N_("Adobe RGB"), NULL}},
549 {0xffff, {N_("Uncalibrated"), NULL}},
552 {0, { { 0, {NULL}}} }
556 exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
558 unsigned int i, j, k, l, ts;
559 const unsigned char *t;
561 ExifShort v_short, v_short2, v_short3, v_short4;
565 ExifSRational v_srat;
571 static const struct {
584 /* FIXME: This belongs to somewhere else. */
585 /* libexif should use the default system locale.
586 * If an application specifically requires UTF-8, then we
587 * must give the application a way to tell libexif that.
589 * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
591 bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
593 /* make sure the returned string is zero terminated */
594 memset (val, 0, maxlen);
596 memset (b, 0, sizeof (b));
598 /* We need the byte order */
599 if (!e || !e->parent || !e->parent->parent)
601 o = exif_data_get_byte_order (e->parent->parent);
604 if (e->size != e->components * exif_format_get_size (e->format)) {
605 snprintf (val, maxlen, _("Invalid size of entry (%i, "
606 "expected %li x %i)."), e->size, e->components,
607 exif_format_get_size (e->format));
612 case EXIF_TAG_USER_COMMENT:
615 * The specification says UNDEFINED, but some
616 * manufacturers don't care and use ASCII. If this is the
617 * case here, only refuse to read it if there is no chance
618 * of finding readable data.
620 if ((e->format != EXIF_FORMAT_ASCII) ||
622 ( memcmp (e->data, "ASCII\0\0\0" , 8) &&
623 memcmp (e->data, "UNICODE\0" , 8) &&
624 memcmp (e->data, "JIS\0\0\0\0\0", 8) &&
625 memcmp (e->data, "\0\0\0\0\0\0\0\0", 8)))
626 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
629 * Note that, according to the specification (V2.1, p 40),
630 * the user comment field does not have to be
633 if ((e->size >= 8) && !memcmp (e->data, "ASCII\0\0\0", 8)) {
634 strncpy (val, (char *) e->data + 8, MIN (e->size - 8, maxlen));
637 if ((e->size >= 8) && !memcmp (e->data, "UNICODE\0", 8)) {
638 strncpy (val, _("Unsupported UNICODE string"), maxlen);
641 if ((e->size >= 8) && !memcmp (e->data, "JIS\0\0\0\0\0", 8)) {
642 strncpy (val, _("Unsupported JIS string"), maxlen);
646 /* Check if there is really some information in the tag. */
647 for (i = 0; (i < e->size) &&
648 (!e->data[i] || (e->data[i] == ' ')); i++);
649 if (i == e->size) break;
652 * If we reach this point, the tag does not
653 * comply with the standard and seems to contain data.
654 * Print as much as possible.
656 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
657 _("Tag UserComment does not comply "
658 "with standard but contains data."));
659 for (; (i < e->size) && (strlen (val) < maxlen - 1); i++) {
660 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
661 _("Byte at position %i: 0x%02x"), i, e->data[i]);
663 isprint (e->data[i]) ? e->data[i] : '.';
667 case EXIF_TAG_EXIF_VERSION:
668 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
669 CC (e, 4, val, maxlen);
670 strncpy (val, _("Unknown Exif Version"), maxlen);
671 for (i = 0; *versions[i].label; i++) {
672 if (!memcmp (e->data, versions[i].label, 4)) {
673 snprintf (val, maxlen,
674 _("Exif Version %d.%d"),
681 case EXIF_TAG_FLASH_PIX_VERSION:
682 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
683 CC (e, 4, val, maxlen);
684 if (!memcmp (e->data, "0100", 4))
685 strncpy (val, _("FlashPix Version 1.0"), maxlen);
686 else if (!memcmp (e->data, "0101", 4))
687 strncpy (val, _("FlashPix Version 1.01"), maxlen);
689 strncpy (val, _("Unknown FlashPix Version"), maxlen);
691 case EXIF_TAG_COPYRIGHT:
692 CF (e, EXIF_FORMAT_ASCII, val, maxlen);
695 * First part: Photographer.
696 * Some cameras store a string like " " here. Ignore it.
698 if (e->size && e->data &&
699 (strspn ((char *)e->data, " ") != strlen ((char *) e->data)))
700 strncpy (val, (char *) e->data, MIN (maxlen, e->size));
702 strncpy (val, _("[None]"), maxlen);
703 strncat (val, " ", maxlen - strlen (val));
704 strncat (val, _("(Photographer)"), maxlen - strlen (val));
706 /* Second part: Editor. */
707 strncat (val, " - ", maxlen - strlen (val));
708 if (e->size && e->data) {
709 t = e->data + strlen ((char *) e->data) + 1;
710 ts = e->data + e->size - t;
711 if ((ts > 0) && (strspn ((char *)t, " ") != ts))
712 strncat (val, (char *)t, MIN (maxlen - strlen (val), ts));
714 strncat (val, _("[None]"), maxlen - strlen (val));
716 strncat (val, " ", maxlen - strlen (val));
717 strncat (val, _("(Editor)"), maxlen - strlen (val));
720 case EXIF_TAG_FNUMBER:
721 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
722 CC (e, 1, val, maxlen);
723 v_rat = exif_get_rational (e->data, o);
724 if (!v_rat.denominator) return val;
725 d = (double) v_rat.numerator / (double) v_rat.denominator;
726 snprintf (val, maxlen, "f/%.01lf", d);
728 case EXIF_TAG_APERTURE_VALUE:
729 case EXIF_TAG_MAX_APERTURE_VALUE:
730 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
731 CC (e, 1, val, maxlen);
732 v_rat = exif_get_rational (e->data, o);
733 if (!v_rat.denominator) return val;
734 d = (double) v_rat.numerator / (double) v_rat.denominator;
735 snprintf (val, maxlen, _("%.02lf EV"), d);
736 snprintf (b, sizeof (b), _(" (f/%.01f)"), pow (2, d / 2.));
737 if (maxlen > strlen (val) + strlen (b))
738 strncat (val, b, maxlen - strlen (val) - 1);
740 case EXIF_TAG_FOCAL_LENGTH:
741 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
742 CC (e, 1, val, maxlen);
743 v_rat = exif_get_rational (e->data, o);
744 if (!v_rat.denominator) return val;
747 * For calculation of the 35mm equivalent,
748 * Minolta cameras need a multiplier that depends on the
752 entry = exif_content_get_entry (
753 e->parent->parent->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
754 if (entry && entry->data &&
755 !strncmp ((char *)entry->data, "Minolta", 7)) {
756 entry = exif_content_get_entry (
757 e->parent->parent->ifd[EXIF_IFD_0],
759 if (entry && entry->data) {
760 if (!strncmp ((char *)entry->data, "DiMAGE 7", 8))
762 else if (!strncmp ((char *)entry->data, "DiMAGE 5", 8))
767 snprintf (b, sizeof (b), _(" (35 equivalent: %d mm)"),
768 (int) (d * (double) v_rat.numerator /
769 (double) v_rat.denominator));
771 d = (double) v_rat.numerator / (double) v_rat.denominator;
772 snprintf (val, maxlen, "%.1lf mm", d);
773 if (maxlen > strlen (val) + strlen (b))
774 strncat (val, b, maxlen - strlen (val) - 1);
776 case EXIF_TAG_SUBJECT_DISTANCE:
777 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
778 CC (e, 1, val, maxlen);
779 v_rat = exif_get_rational (e->data, o);
780 if (!v_rat.denominator) return val;
781 d = (double) v_rat.numerator / (double) v_rat.denominator;
782 snprintf (val, maxlen, "%.1lf m", d);
784 case EXIF_TAG_EXPOSURE_TIME:
785 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
786 CC (e, 1, val, maxlen);
787 v_rat = exif_get_rational (e->data, o);
788 if (!v_rat.denominator) return val;
789 d = (double) v_rat.numerator / (double) v_rat.denominator;
791 snprintf (val, maxlen, _("1/%d"), (int) (0.5 + 1. / d));
793 snprintf (val, maxlen, _("%d"), (int) d);
794 if (maxlen > strlen (val) + strlen (_(" sec.")))
795 strncat (val, _(" sec."), maxlen - strlen (val) - 1);
797 case EXIF_TAG_SHUTTER_SPEED_VALUE:
798 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
799 CC (e, 1, val, maxlen);
800 v_srat = exif_get_srational (e->data, o);
801 if (!v_srat.denominator) return val;
802 d = (double) v_srat.numerator / (double) v_srat.denominator;
803 snprintf (val, maxlen, _("%.02f EV"), d);
804 snprintf (b, sizeof (b), " (APEX: %i)", (int) pow (sqrt(2), d));
805 if (maxlen > strlen (val) + strlen (b))
806 strncat (val, b, maxlen - strlen (val) - 1);
809 snprintf (b, sizeof (b), _(" 1/%d sec.)"), (int) (1. / d));
811 snprintf (b, sizeof (b), _(" %d sec.)"), (int) d);
812 if (maxlen > strlen (val) + strlen (b)) {
813 val[strlen (val) - 1] = ',';
814 strncat (val, b, maxlen - strlen (val) - 1);
817 case EXIF_TAG_BRIGHTNESS_VALUE:
818 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
819 CC (e, 1, val, maxlen);
820 v_srat = exif_get_srational (e->data, o);
821 if (!v_srat.denominator) return val;
822 d = (double) v_srat.numerator / (double) v_srat.denominator;
823 snprintf (val, maxlen, _("%.02f EV"), d);
824 snprintf (b, sizeof (b), _(" (%.02f cd/m^2)"),
825 1. / (M_PI * 0.3048 * 0.3048) * pow (2, d));
826 if (maxlen > strlen (val) + strlen (b))
827 strncat (val, b, maxlen - strlen (val) - 1);
829 case EXIF_TAG_FILE_SOURCE:
830 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
831 CC (e, 1, val, maxlen);
832 switch (e->data[0]) {
833 case 0x03: strncpy (val, _("DSC"), maxlen); break;
834 default: snprintf (val, maxlen, "0x%02x", e->data[0]); break;
837 case EXIF_TAG_COMPONENTS_CONFIGURATION:
838 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
839 CC (e, 4, val, maxlen);
840 for (i = 0; i < 4; i++) {
841 switch (e->data[i]) {
842 case 0: c = _("-"); break;
843 case 1: c = _("Y"); break;
844 case 2: c = _("Cb"); break;
845 case 3: c = _("Cr"); break;
846 case 4: c = _("R"); break;
847 case 5: c = _("G"); break;
848 case 6: c = _("B"); break;
849 default: c = _("reserved"); break;
851 strncat (val, c, maxlen - strlen (val));
852 if (i < 3) strncat (val, " ", maxlen - strlen (val));
855 case EXIF_TAG_EXPOSURE_BIAS_VALUE:
856 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
857 CC (e, 1, val, maxlen);
858 v_srat = exif_get_srational (e->data, o);
859 if (!v_srat.denominator) return val;
860 d = (double) v_srat.numerator / (double) v_srat.denominator;
861 snprintf (val, maxlen, _("%.02f EV"), d);
863 case EXIF_TAG_YCBCR_SUB_SAMPLING:
864 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
865 CC (e, 2, val, maxlen);
866 v_short = exif_get_short (e->data, o);
867 v_short2 = exif_get_short (
868 e->data + exif_format_get_size (e->format),
870 if ((v_short == 2) && (v_short2 == 1))
871 strncpy (val, _("YCbCr4:2:2"), maxlen);
872 else if ((v_short == 2) && (v_short2 == 2))
873 strncpy (val, _("YCbCr4:2:0"), maxlen);
875 snprintf (val, maxlen, "%i, %i", v_short, v_short2);
877 case EXIF_TAG_SUBJECT_AREA:
878 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
879 switch (e->components) {
881 v_short = exif_get_short (e->data, o);
882 v_short2 = exif_get_short (e->data + 2, o);
883 snprintf (val, maxlen, "(x,y) = (%i,%i)",
887 v_short = exif_get_short (e->data, o);
888 v_short2 = exif_get_short (e->data + 2, o);
889 v_short3 = exif_get_short (e->data + 4, o);
890 snprintf (val, maxlen, _("Within distance %i of "
891 "(x,y) = (%i,%i)"), v_short3, v_short,
895 v_short = exif_get_short (e->data, o);
896 v_short2 = exif_get_short (e->data + 2, o);
897 v_short3 = exif_get_short (e->data + 4, o);
898 v_short4 = exif_get_short (e->data + 6, o);
899 snprintf (val, maxlen, _("Within rectangle "
900 "(width %i, height %i) around "
901 "(x,y) = (%i,%i)"), v_short3, v_short4,
905 snprintf (val, maxlen, _("Unexpected number "
906 "of components (%li, expected 2, 3, or 4)."),
911 case EXIF_TAG_METERING_MODE:
912 case EXIF_TAG_COMPRESSION:
913 case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
914 case EXIF_TAG_RESOLUTION_UNIT:
915 case EXIF_TAG_EXPOSURE_PROGRAM:
917 case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
918 case EXIF_TAG_COLOR_SPACE:
919 CF (e,EXIF_FORMAT_SHORT, val, maxlen);
920 CC (e, 1, val, maxlen);
921 v_short = exif_get_short (e->data, o);
924 for (i = 0; list2[i].tag && (list2[i].tag != e->tag); i++);
926 snprintf (val, maxlen, _("Internal error (unknown "
927 "value %i)"), v_short);
932 for (j = 0; list2[i].elem[j].values[0] &&
933 (list2[i].elem[j].index < v_short); j++);
934 if (list2[i].elem[j].index != v_short) {
935 snprintf (val, maxlen, _("Internal error (unknown "
936 "value %i)"), v_short);
940 /* Find a short enough value */
941 memset (val, 0, maxlen);
942 for (k = 0; list2[i].elem[j].values[k]; k++) {
943 l = strlen (_(list2[i].elem[j].values[k]));
944 if ((maxlen > l) && (strlen (val) < l))
945 strncpy (val, _(list2[i].elem[j].values[k]), maxlen);
947 if (!strlen (val)) snprintf (val, maxlen, "%i", v_short);
950 case EXIF_TAG_PLANAR_CONFIGURATION:
951 case EXIF_TAG_SENSING_METHOD:
952 case EXIF_TAG_ORIENTATION:
953 case EXIF_TAG_YCBCR_POSITIONING:
954 case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
955 case EXIF_TAG_CUSTOM_RENDERED:
956 case EXIF_TAG_EXPOSURE_MODE:
957 case EXIF_TAG_WHITE_BALANCE:
958 case EXIF_TAG_SCENE_CAPTURE_TYPE:
959 case EXIF_TAG_GAIN_CONTROL:
960 case EXIF_TAG_SATURATION:
961 case EXIF_TAG_CONTRAST:
962 case EXIF_TAG_SHARPNESS:
963 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
964 CC (e, 1, val, maxlen);
965 v_short = exif_get_short (e->data, o);
968 for (i = 0; list[i].tag && (list[i].tag != e->tag); i++);
970 snprintf (val, maxlen, _("Internal error (unknown "
971 "value %i)"), v_short);
976 for (j = 0; list[i].strings[j] && (j < v_short); j++);
977 if (!list[i].strings[j])
978 snprintf (val, maxlen, "%i", v_short);
979 else if (!*list[i].strings[j])
982 strncpy (val, _(list[i].strings[j]), maxlen);
984 case EXIF_TAG_XP_TITLE:
985 case EXIF_TAG_XP_COMMENT:
986 case EXIF_TAG_XP_AUTHOR:
987 case EXIF_TAG_XP_KEYWORDS:
988 case EXIF_TAG_XP_SUBJECT:
989 /* Warning! The texts are converted from UTF16 to UTF8 */
990 exif_convert_utf16_to_utf8(val, (unsigned short*)e->data, MIN(maxlen, e->size));
992 case EXIF_TAG_INTEROPERABILITY_VERSION:
993 if (e->format == EXIF_FORMAT_UNDEFINED) {
994 strncpy (val, (char *) e->data, MIN (maxlen, e->size));
997 /* Fall through - EXIF_TAG_GPS_LATITUDE is same as INTEROPERABILITY_VERSION */
1000 switch (e->format) {
1001 case EXIF_FORMAT_UNDEFINED:
1002 if ((e->tag == EXIF_TAG_SCENE_TYPE) && (e->size == 1)) {
1003 snprintf (val, maxlen, "%i", e->data[0]);
1005 snprintf (val, maxlen, _("%i bytes undefined data"),
1009 case EXIF_FORMAT_BYTE:
1010 case EXIF_FORMAT_SBYTE:
1011 v_byte = e->data[0];
1012 snprintf (val, maxlen, "0x%02x", v_byte);
1013 maxlen -= strlen (val);
1014 for (i = 1; i < e->components; i++) {
1015 v_byte = e->data[i];
1016 snprintf (b, sizeof (b), ", 0x%02x", v_byte);
1017 strncat (val, b, maxlen);
1018 maxlen -= strlen (b);
1019 if ((signed)maxlen <= 0) break;
1022 case EXIF_FORMAT_SHORT:
1023 case EXIF_FORMAT_SSHORT:
1024 v_short = exif_get_short (e->data, o);
1025 snprintf (val, maxlen, "%i", v_short);
1026 maxlen -= strlen (val);
1027 for (i = 1; i < e->components; i++) {
1028 v_short = exif_get_short (e->data +
1029 exif_format_get_size (e->format) *
1031 snprintf (b, sizeof (b), ", %i", v_short);
1032 strncat (val, b, maxlen);
1033 maxlen -= strlen (b);
1034 if ((signed)maxlen <= 0) break;
1037 case EXIF_FORMAT_LONG:
1038 v_long = exif_get_long (e->data, o);
1039 snprintf (val, maxlen, "%li", (long int) v_long);
1040 maxlen -= strlen (val);
1041 for (i = 1; i < e->components; i++) {
1042 v_long = exif_get_long (e->data +
1043 exif_format_get_size (e->format) *
1045 snprintf (b, sizeof (b), ", %li",
1047 strncat (val, b, maxlen);
1048 maxlen -= strlen (b);
1049 if ((signed)maxlen <= 0) break;
1052 case EXIF_FORMAT_SLONG:
1053 v_slong = exif_get_slong (e->data, o);
1054 snprintf (val, maxlen, "%li", (long int) v_slong);
1055 maxlen -= strlen (val);
1056 for (i = 1; i < e->components; i++) {
1057 v_long = exif_get_slong (e->data +
1058 exif_format_get_size (e->format) *
1060 snprintf (b, sizeof (b), ", %li",
1062 strncat (val, b, maxlen);
1063 maxlen -= strlen (b);
1064 if ((signed)maxlen <= 0) break;
1067 case EXIF_FORMAT_ASCII:
1068 strncpy (val, (char *) e->data, MIN (maxlen, e->size));
1070 case EXIF_FORMAT_RATIONAL:
1071 v_rat = exif_get_rational (e->data, o);
1072 if (v_rat.denominator)
1073 snprintf (val, maxlen, "%2.2lf",
1074 (double) v_rat.numerator /
1075 (double) v_rat.denominator);
1077 snprintf (val, maxlen, "%2.2lf/%2.2lf",
1078 (double) v_rat.numerator,
1079 (double) v_rat.denominator);
1080 maxlen -= strlen (val);
1081 for (i = 1; i < e->components; i++) {
1082 v_rat = exif_get_rational (
1083 e->data + 8 * i, o);
1084 if (v_rat.denominator)
1085 snprintf (b, sizeof (b), ", %2.2lf",
1086 (double) v_rat.numerator /
1087 (double) v_rat.denominator);
1089 snprintf (b, sizeof (b), ", %2.2lf/%2.2lf",
1090 (double) v_rat.numerator,
1091 (double) v_rat.denominator);
1092 strncat (val, b, maxlen);
1093 maxlen -= strlen (b);
1094 if ((signed) maxlen <= 0) break;
1097 case EXIF_FORMAT_SRATIONAL:
1098 v_srat = exif_get_srational (e->data, o);
1099 if (v_srat.denominator) {
1100 snprintf (val, maxlen, "%2.2f", (double)v_srat.numerator / v_srat.denominator);
1102 snprintf (val, maxlen, "%i/%i", v_srat.numerator, v_srat.denominator);
1104 maxlen -= strlen (val);
1105 for (i = 1; i < e->components; i++) {
1106 v_srat = exif_get_srational (
1107 e->data + 8 * i, o);
1108 snprintf (b, sizeof (b), ", %2.2f",
1109 (double)v_srat.numerator / v_srat.denominator);
1110 strncat (val, b, maxlen);
1111 maxlen -= strlen (b);
1112 if ((signed) maxlen <= 0) break;
1115 case EXIF_FORMAT_DOUBLE:
1116 case EXIF_FORMAT_FLOAT:
1118 /* What to do here? */
1128 * \bug Log and report failed exif_mem_malloc() calls.
1131 exif_entry_initialize (ExifEntry *e, ExifTag tag)
1136 /* We need the byte order */
1137 if (!e || !e->parent || e->data || !e->parent->parent)
1139 o = exif_data_get_byte_order (e->parent->parent);
1144 /* LONG, 1 component, no default */
1145 case EXIF_TAG_PIXEL_X_DIMENSION:
1146 case EXIF_TAG_PIXEL_Y_DIMENSION:
1147 case EXIF_TAG_EXIF_IFD_POINTER:
1148 case EXIF_TAG_GPS_INFO_IFD_POINTER:
1149 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
1150 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
1151 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
1153 e->format = EXIF_FORMAT_LONG;
1154 e->size = exif_format_get_size (e->format) * e->components;
1155 e->data = exif_entry_alloc (e, e->size);
1156 if (!e->data) break;
1159 /* SHORT, 1 component, no default */
1160 case EXIF_TAG_SUBJECT_LOCATION:
1161 case EXIF_TAG_SENSING_METHOD:
1162 case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
1163 case EXIF_TAG_COMPRESSION:
1164 case EXIF_TAG_EXPOSURE_MODE:
1165 case EXIF_TAG_WHITE_BALANCE:
1166 case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
1167 case EXIF_TAG_GAIN_CONTROL:
1168 case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
1169 case EXIF_TAG_COLOR_SPACE:
1170 case EXIF_TAG_FLASH:
1172 /* SHORT, 1 component, default 0 */
1173 case EXIF_TAG_IMAGE_WIDTH:
1174 case EXIF_TAG_IMAGE_LENGTH:
1175 case EXIF_TAG_EXPOSURE_PROGRAM:
1176 case EXIF_TAG_LIGHT_SOURCE:
1177 case EXIF_TAG_METERING_MODE:
1178 case EXIF_TAG_CUSTOM_RENDERED:
1179 case EXIF_TAG_SCENE_CAPTURE_TYPE:
1180 case EXIF_TAG_CONTRAST:
1181 case EXIF_TAG_SATURATION:
1182 case EXIF_TAG_SHARPNESS:
1184 e->format = EXIF_FORMAT_SHORT;
1185 e->size = exif_format_get_size (e->format) * e->components;
1186 e->data = exif_entry_alloc (e, e->size);
1187 if (!e->data) break;
1188 exif_set_short (e->data, o, 0);
1191 /* SHORT, 1 component, default 1 */
1192 case EXIF_TAG_ORIENTATION:
1193 case EXIF_TAG_PLANAR_CONFIGURATION:
1194 case EXIF_TAG_YCBCR_POSITIONING:
1196 e->format = EXIF_FORMAT_SHORT;
1197 e->size = exif_format_get_size (e->format) * e->components;
1198 e->data = exif_entry_alloc (e, e->size);
1199 if (!e->data) break;
1200 exif_set_short (e->data, o, 1);
1203 /* SHORT, 1 component, default 2 */
1204 case EXIF_TAG_RESOLUTION_UNIT:
1205 case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
1207 e->format = EXIF_FORMAT_SHORT;
1208 e->size = exif_format_get_size (e->format) * e->components;
1209 e->data = exif_entry_alloc (e, e->size);
1210 if (!e->data) break;
1211 exif_set_short (e->data, o, 2);
1214 /* SHORT, 1 component, default 3 */
1215 case EXIF_TAG_SAMPLES_PER_PIXEL:
1217 e->format = EXIF_FORMAT_SHORT;
1218 e->size = exif_format_get_size (e->format) * e->components;
1219 e->data = exif_entry_alloc (e, e->size);
1220 if (!e->data) break;
1221 exif_set_short (e->data, o, 3);
1224 case EXIF_TAG_BITS_PER_SAMPLE:
1226 e->format = EXIF_FORMAT_SHORT;
1227 e->size = exif_format_get_size (e->format) * e->components;
1228 e->data = exif_entry_alloc (e, e->size);
1229 if (!e->data) break;
1230 exif_set_short (e->data, o, 8);
1232 e->data + exif_format_get_size (e->format),
1235 e->data + 2 * exif_format_get_size (e->format),
1238 case EXIF_TAG_YCBCR_SUB_SAMPLING:
1240 e->format = EXIF_FORMAT_SHORT;
1241 e->size = exif_format_get_size (e->format) * e->components;
1242 e->data = exif_entry_alloc (e, e->size);
1243 if (!e->data) break;
1244 exif_set_short (e->data, o, 2);
1246 e->data + exif_format_get_size (e->format),
1250 /* SRATIONAL, 1 component, no default */
1251 case EXIF_TAG_EXPOSURE_BIAS_VALUE:
1252 case EXIF_TAG_BRIGHTNESS_VALUE:
1253 case EXIF_TAG_SHUTTER_SPEED_VALUE:
1255 e->format = EXIF_FORMAT_SRATIONAL;
1256 e->size = exif_format_get_size (e->format) * e->components;
1257 e->data = exif_entry_alloc (e, e->size);
1258 if (!e->data) break;
1261 /* RATIONAL, 1 component, no default */
1262 case EXIF_TAG_EXPOSURE_TIME:
1263 case EXIF_TAG_FOCAL_PLANE_X_RESOLUTION:
1264 case EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION:
1265 case EXIF_TAG_EXPOSURE_INDEX:
1266 case EXIF_TAG_FLASH_ENERGY:
1267 case EXIF_TAG_FNUMBER:
1268 case EXIF_TAG_FOCAL_LENGTH:
1269 case EXIF_TAG_SUBJECT_DISTANCE:
1270 case EXIF_TAG_MAX_APERTURE_VALUE:
1271 case EXIF_TAG_APERTURE_VALUE:
1272 case EXIF_TAG_COMPRESSED_BITS_PER_PIXEL:
1273 case EXIF_TAG_PRIMARY_CHROMATICITIES:
1274 case EXIF_TAG_DIGITAL_ZOOM_RATIO:
1276 e->format = EXIF_FORMAT_RATIONAL;
1277 e->size = exif_format_get_size (e->format) * e->components;
1278 e->data = exif_entry_alloc (e, e->size);
1279 if (!e->data) break;
1282 /* RATIONAL, 1 component, default 72/1 */
1283 case EXIF_TAG_X_RESOLUTION:
1284 case EXIF_TAG_Y_RESOLUTION:
1286 e->format = EXIF_FORMAT_RATIONAL;
1287 e->size = exif_format_get_size (e->format) * e->components;
1288 e->data = exif_entry_alloc (e, e->size);
1289 if (!e->data) break;
1292 exif_set_rational (e->data, o, r);
1295 /* RATIONAL, 2 components, no default */
1296 case EXIF_TAG_WHITE_POINT:
1298 e->format = EXIF_FORMAT_RATIONAL;
1299 e->size = exif_format_get_size (e->format) * e->components;
1300 e->data = exif_entry_alloc (e, e->size);
1301 if (!e->data) break;
1304 /* RATIONAL, 6 components */
1305 case EXIF_TAG_REFERENCE_BLACK_WHITE:
1307 e->format = EXIF_FORMAT_RATIONAL;
1308 e->size = exif_format_get_size (e->format) * e->components;
1309 e->data = exif_entry_alloc (e, e->size);
1310 if (!e->data) break;
1313 exif_set_rational (e->data, o, r);
1316 e->data + exif_format_get_size (e->format), o, r);
1319 e->data + 2 * exif_format_get_size (e->format), o, r);
1322 e->data + 3 * exif_format_get_size (e->format), o, r);
1325 e->data + 4 * exif_format_get_size (e->format), o, r);
1328 e->data + 5 * exif_format_get_size (e->format), o, r);
1331 /* ASCII, 20 components */
1332 case EXIF_TAG_DATE_TIME:
1333 case EXIF_TAG_DATE_TIME_ORIGINAL:
1334 case EXIF_TAG_DATE_TIME_DIGITIZED:
1341 #ifdef HAVE_LOCALTIME_R
1342 tm = localtime_r (&t, &tms);
1344 tm = localtime (&t);
1347 e->format = EXIF_FORMAT_ASCII;
1348 e->size = exif_format_get_size (e->format) * e->components;
1349 e->data = exif_entry_alloc (e, e->size);
1350 if (!e->data) break;
1351 snprintf ((char *) e->data, e->size,
1352 "%04i:%02i:%02i %02i:%02i:%02i",
1353 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1354 tm->tm_hour, tm->tm_min, tm->tm_sec);
1358 /* ASCII, no default */
1359 case EXIF_TAG_SUB_SEC_TIME:
1360 case EXIF_TAG_SUB_SEC_TIME_ORIGINAL:
1361 case EXIF_TAG_SUB_SEC_TIME_DIGITIZED:
1363 e->format = EXIF_FORMAT_ASCII;
1367 case EXIF_TAG_IMAGE_DESCRIPTION:
1369 case EXIF_TAG_MODEL:
1370 case EXIF_TAG_SOFTWARE:
1371 case EXIF_TAG_ARTIST:
1372 e->components = strlen (_("[None]")) + 1;
1373 e->format = EXIF_FORMAT_ASCII;
1374 e->size = exif_format_get_size (e->format) * e->components;
1375 e->data = exif_entry_alloc (e, e->size);
1376 if (!e->data) break;
1377 strncpy ((char *)e->data, _("[None]"), e->size);
1379 case EXIF_TAG_COPYRIGHT:
1380 e->components = (strlen (_("[None]")) + 1) * 2;
1381 e->format = EXIF_FORMAT_ASCII;
1382 e->size = exif_format_get_size (e->format) * e->components;
1383 e->data = exif_entry_alloc (e, e->size);
1384 if (!e->data) break;
1385 strcpy (((char *)e->data) + 0, _("[None]"));
1386 strcpy (((char *)e->data) + strlen (_("[None]")) + 1, _("[None]"));
1389 /* UNDEFINED, no components, no default */
1390 /* Use this if the tag is otherwise unsupported */
1391 case EXIF_TAG_MAKER_NOTE:
1392 case EXIF_TAG_USER_COMMENT:
1395 e->format = EXIF_FORMAT_UNDEFINED;
1400 /* UNDEFINED, 1 component, default 1 */
1401 case EXIF_TAG_SCENE_TYPE:
1403 e->format = EXIF_FORMAT_UNDEFINED;
1404 e->size = exif_format_get_size (e->format) * e->components;
1405 e->data = exif_entry_alloc (e, e->size);
1406 if (!e->data) break;
1410 /* UNDEFINED, 1 component, default 3 */
1411 case EXIF_TAG_FILE_SOURCE:
1413 e->format = EXIF_FORMAT_UNDEFINED;
1414 e->size = exif_format_get_size (e->format) * e->components;
1415 e->data = exif_entry_alloc (e, e->size);
1416 if (!e->data) break;
1420 /* UNDEFINED, 4 components, default 0 1 0 0 */
1421 case EXIF_TAG_FLASH_PIX_VERSION:
1423 e->format = EXIF_FORMAT_UNDEFINED;
1424 e->size = exif_format_get_size (e->format) * e->components;
1425 e->data = exif_entry_alloc (e, e->size);
1426 if (!e->data) break;
1427 memcpy (e->data, "0100", 4);
1430 /* UNDEFINED, 4 components, default 0 2 1 0 */
1431 case EXIF_TAG_EXIF_VERSION:
1433 e->format = EXIF_FORMAT_UNDEFINED;
1434 e->size = exif_format_get_size (e->format) * e->components;
1435 e->data = exif_entry_alloc (e, e->size);
1436 if (!e->data) break;
1437 memcpy (e->data, "0210", 4);