1 /* exif-entry.c
2 *
3 * Copyright -A� 2001 Lutz M�ller <lutz@users.sourceforge.net>$)B
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
19 */
20
21 #include "config.h"
22 #include "exif-entry.h"
23 #include "exif-ifd.h"
24 #include "exif-utils.h"
25 #include "i18n.h"
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <time.h>
31 #include <math.h>
32
33 /* #define DEBUG */
34
35 #undef MIN
36 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
37
38 static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
39
40 struct _ExifEntryPrivate
41 {
42 unsigned int ref_count;
43 };
44
45 ExifEntry *
exif_entry_new(void)46 exif_entry_new (void)
47 {
48 ExifEntry *e;
49
50 e = malloc (sizeof (ExifEntry));
51 if (!e)
52 return (NULL);
53 memset (e, 0, sizeof (ExifEntry));
54 e->priv = malloc (sizeof (ExifEntryPrivate));
55 if (!e->priv) {
56 free (e);
57 return (NULL);
58 }
59 memset (e->priv, 0, sizeof (ExifEntryPrivate));
60 e->priv->ref_count = 1;
61
62 return (e);
63 }
64
65 void
exif_entry_ref(ExifEntry * e)66 exif_entry_ref (ExifEntry *e)
67 {
68 if (!e)
69 return;
70
71 e->priv->ref_count++;
72 }
73
74 void
exif_entry_unref(ExifEntry * e)75 exif_entry_unref (ExifEntry *e)
76 {
77 if (!e)
78 return;
79
80 e->priv->ref_count--;
81 if (!e->priv->ref_count)
82 exif_entry_free (e);
83 }
84
85 void
exif_entry_free(ExifEntry * e)86 exif_entry_free (ExifEntry *e)
87 {
88 if (!e)
89 return;
90
91 if (e->data)
92 free (e->data);
93 free (e->priv);
94 free (e);
95 }
96
97 void
exif_entry_dump(ExifEntry * e,unsigned int indent)98 exif_entry_dump (ExifEntry *e, unsigned int indent)
99 {
100 char buf[1024];
101 unsigned int i;
102
103 for (i = 0; i < 2 * indent; i++)
104 buf[i] = ' ';
105 buf[i] = '\0';
106
107 if (!e)
108 return;
109
110 printf ("%sTag: 0x%x ('%s')\n", buf, e->tag,
111 exif_tag_get_name (e->tag));
112 printf ("%s Format: %i ('%s')\n", buf, e->format,
113 exif_format_get_name (e->format));
114 printf ("%s Components: %i\n", buf, (int) e->components);
115 printf ("%s Size: %i\n", buf, e->size);
116 printf ("%s Value: %s\n", buf, exif_entry_get_value (e));
117 }
118
119 #define CF(format,target,v) \
120 { \
121 if (format != target) { \
122 snprintf (v, sizeof (v), \
123 _("Invalid format '%s', " \
124 "expected '%s'."), \
125 exif_format_get_name (format), \
126 exif_format_get_name (target)); \
127 break; \
128 } \
129 }
130
131 #define CC(number,target,v) \
132 { \
133 if (number != target) { \
134 snprintf (v, sizeof (v), \
135 _("Invalid number of components (%i, " \
136 "expected %i)."), (int) number, (int) target); \
137 break; \
138 } \
139 }
140
141 const char *
exif_entry_get_value(ExifEntry * e)142 exif_entry_get_value (ExifEntry *e)
143 {
144 unsigned int i;
145 ExifByte v_byte;
146 ExifShort v_short, v_short2, v_short3, v_short4;
147 ExifLong v_long;
148 ExifSLong v_slong;
149 ExifRational v_rat;
150 ExifSRational v_srat;
151 static char v[1024], b[1024];
152 const char *c;
153 ExifByteOrder o;
154 double d;
155 ExifEntry *entry;
156
157 bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
158 bindtextdomain (GETTEXT_PACKAGE, LIBEXIF_LOCALEDIR);
159
160 /* We need the byte order */
161 if (!e || !e->parent || !e->parent->parent)
162 return (NULL);
163 o = exif_data_get_byte_order (e->parent->parent);
164
165 memset (v, 0, sizeof (v));
166 memset (b, 0, sizeof (b));
167
168 /* Sanity check */
169 if (e->size != e->components * exif_format_get_size (e->format)) {
170 snprintf (v, sizeof (v), _("Invalid size of entry (%i, "
171 "expected %li x %i)."), e->size, e->components,
172 exif_format_get_size (e->format));
173 return v;
174 }
175
176 switch (e->tag) {
177 case EXIF_TAG_USER_COMMENT:
178 CF (e->format, EXIF_FORMAT_UNDEFINED, v);
179 if (e->size < 8) break;
180 strncpy (v, e->data + 8, sizeof (v) - 1);
181 break;
182 case EXIF_TAG_EXIF_VERSION:
183 CF (e->format, EXIF_FORMAT_UNDEFINED, v);
184 CC (e->components, 4, v);
185 if (!memcmp (e->data, "0200", 4))
186 strncpy (v, "Exif Version 2.0", sizeof (v) - 1);
187 else if (!memcmp (e->data, "0210", 4))
188 strncpy (v, "Exif Version 2.1", sizeof (v) - 1);
189 else if (!memcmp (e->data, "0220", 4))
190 strncpy (v, "Exif Version 2.2", sizeof (v) - 1);
191 else strncpy (v, _("Unknown Exif Version"), sizeof (v) - 1);
192 break;
193 case EXIF_TAG_FLASH_PIX_VERSION:
194 CF (e->format, EXIF_FORMAT_UNDEFINED, v);
195 CC (e->components, 4, v);
196 if (!memcmp (e->data, "0100", 4))
197 strncpy (v, "FlashPix Version 1.0", sizeof (v));
198 else
199 strncpy (v, _("Unknown FlashPix Version"), sizeof (v));
200 break;
201 case EXIF_TAG_COPYRIGHT:
202 CF (e->format, EXIF_FORMAT_ASCII, v);
203
204 /*
205 * First part: Photographer.
206 * Some cameras store a string like " " here. Ignore it.
207 */
208 if (e->size && e->data &&
209 (strspn (e->data, " ") != strlen ((char *) e->data)))
210 strncpy (v, e->data, MIN (sizeof (v) - 1, e->size));
211 else
212 strncpy (v, _("[None]"), sizeof (v) - 1);
213 strncat (v, " ", sizeof (v) - 1);
214 strncat (v, _("(Photographer)"), sizeof (v) - 1);
215
216 /* Second part: Editor. */
217 strncat (v, " - ", sizeof (v) - 1);
218 if (e->size && e->data &&
219 (strlen ((char *) e->data) + 1 < e->size) &&
220 (strspn (e->data, " ") != strlen ((char *) e->data)))
221 strncat (v, e->data + strlen (e->data) + 1,
222 sizeof (v) - 1);
223 else
224 strncat (v, _("[None]"), sizeof (v) - 1);
225 strncat (v, " ", sizeof (v) - 1);
226 strncat (v, _("(Editor)"), sizeof (v) - 1);
227
228 break;
229 case EXIF_TAG_FNUMBER:
230 CF (e->format, EXIF_FORMAT_RATIONAL, v);
231 CC (e->components, 1, v);
232 v_rat = exif_get_rational (e->data, o);
233 if (!v_rat.denominator) return (NULL);
234 snprintf (v, sizeof (v), "f/%.01f", (float) v_rat.numerator /
235 (float) v_rat.denominator);
236 break;
237 case EXIF_TAG_APERTURE_VALUE:
238 CF (e->format, EXIF_FORMAT_RATIONAL, v);
239 CC (e->components, 1, v);
240 v_rat = exif_get_rational (e->data, o);
241 if (!v_rat.denominator) return (NULL);
242 snprintf (v, sizeof (v), "f/%.01f",
243 pow (2 , ((float) v_rat.numerator /
244 (float) v_rat.denominator) / 2.));
245 break;
246 case EXIF_TAG_FOCAL_LENGTH:
247 CF (e->format, EXIF_FORMAT_RATIONAL, v);
248 CC (e->components, 1, v);
249 v_rat = exif_get_rational (e->data, o);
250 if (!v_rat.denominator) return (NULL);
251
252 /*
253 * For calculation of the 35mm equivalent,
254 * Minolta cameras need a multiplier that depends on the
255 * camera model.
256 */
257 d = 0.;
258 entry = exif_content_get_entry (
259 e->parent->parent->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
260 if (entry && entry->data &&
261 !strncmp (entry->data, "Minolta", 7)) {
262 entry = exif_content_get_entry (
263 e->parent->parent->ifd[EXIF_IFD_0],
264 EXIF_TAG_MODEL);
265 if (entry && entry->data) {
266 if (!strncmp (entry->data, "DiMAGE 7", 8))
267 d = 3.9;
268 else if (!strncmp (entry->data, "DiMAGE 5", 8))
269 d = 4.9;
270 }
271 }
272 if (d)
273 snprintf (b, sizeof (b), _(" (35 equivalent: %d mm)"),
274 (int) (d * (double) v_rat.numerator /
275 (double) v_rat.denominator));
276
277 snprintf (v, sizeof (v), "%.1f mm%s",
278 (float) v_rat.numerator / (float) v_rat.denominator,
279 b);
280 break;
281 case EXIF_TAG_SUBJECT_DISTANCE:
282 CF (e->format, EXIF_FORMAT_RATIONAL, v);
283 CC (e->components, 1, v);
284 v_rat = exif_get_rational (e->data, o);
285 if (!v_rat.denominator) return (NULL);
286 snprintf (v, sizeof (v), "%.1f m", (float) v_rat.numerator /
287 (float) v_rat.denominator);
288 break;
289 case EXIF_TAG_EXPOSURE_TIME:
290 CF (e->format, EXIF_FORMAT_RATIONAL, v);
291 CC (e->components, 1, v);
292 v_rat = exif_get_rational (e->data, o);
293 if (!v_rat.denominator) return (NULL);
294 d = (double) v_rat.numerator / (double) v_rat.denominator;
295 if (d < 1)
296 snprintf (v, sizeof (v), _("1/%d sec."),
297 (int) (1. / d));
298 else
299 snprintf (v, sizeof (v), _("%d sec."), (int) d);
300 break;
301 case EXIF_TAG_SHUTTER_SPEED_VALUE:
302 CF (e->format, EXIF_FORMAT_SRATIONAL, v);
303 CC (e->components, 1, v);
304 v_srat = exif_get_srational (e->data, o);
305 if (!v_srat.denominator) return (NULL);
306 snprintf (b, sizeof (b), "%.0f/%.0f sec.",
307 (float) v_srat.numerator, (float) v_srat.denominator);
308 snprintf (v, sizeof (v), "%s (APEX: %i)", b,
309 (int) pow (sqrt(2), (float) v_srat.numerator /
310 (float) v_srat.denominator));
311 break;
312 case EXIF_TAG_BRIGHTNESS_VALUE:
313 CF (e->format, EXIF_FORMAT_SRATIONAL, v);
314 CC (e->components, 1, v);
315 v_srat = exif_get_srational (e->data, o);
316 snprintf (v, sizeof (v), "%i/%i", (int) v_srat.numerator,
317 (int) v_srat.denominator);
318 /* FIXME: How do I calculate the APEX value? */
319 break;
320 case EXIF_TAG_METERING_MODE:
321 CF (e->format, EXIF_FORMAT_SHORT, v);
322 CC (e->components, 1, v);
323 v_short = exif_get_short (e->data, o);
324 switch (v_short) {
325 case 0: strncpy (v, _("Unknown"), sizeof (v)); break;
326 case 1: strncpy (v, _("Average"), sizeof (v)); break;
327 case 2: strncpy (v, _("Center-Weighted Average"), sizeof (v));
328 break;
329 case 3: strncpy (v, _("Spot"), sizeof (v)); break;
330 case 4: strncpy (v, _("Multi Spot"), sizeof (v)); break;
331 case 5: strncpy (v, _("Pattern"), sizeof (v)); break;
332 case 6: strncpy (v, _("Partial"), sizeof (v)); break;
333 case 255: strncpy (v, _("Other"), sizeof (v)); break;
334 default: snprintf (v, sizeof (v), "%i", v_short); break;
335 }
336 break;
337 case EXIF_TAG_COMPRESSION:
338 CF (e->format, EXIF_FORMAT_SHORT, v);
339 CC (e->components, 1, v);
340 v_short = exif_get_short (e->data, o);
341 switch (v_short) {
342 case 1: strncpy (v, _("Uncompressed"), sizeof (v)); break;
343 case 6: strncpy (v, _("JPEG compression"), sizeof (v)); break;
344 default: snprintf (v, sizeof (v), "%i", v_short); break;
345 }
346 break;
347 case EXIF_TAG_FILE_SOURCE:
348 CF (e->format, EXIF_FORMAT_UNDEFINED, v);
349 CC (e->components, 1, v);
350 switch (e->data[0]) {
351 case 0x03: strncpy (v, _("DSC"), sizeof (v)); break;
352 default: snprintf (v, sizeof (v), "0x%02x", e->data[0]); break;
353 }
354 break;
355 case EXIF_TAG_PLANAR_CONFIGURATION:
356 CF (e->format, EXIF_FORMAT_SHORT, v);
357 CC (e->components, 1, v);
358 v_short = exif_get_short (e->data, o);
359 switch (v_short) {
360 case 1: strncpy (v, _("chunky format"), sizeof (v)); break;
361 case 2: strncpy (v, _("planar format"), sizeof (v)); break;
362 default: snprintf (v, sizeof (v), "%i", v_short); break;
363 }
364 break;
365 case EXIF_TAG_COMPONENTS_CONFIGURATION:
366 CF (e->format, EXIF_FORMAT_UNDEFINED, v);
367 CC (e->components, 4, v);
368 for (i = 0; i < 4; i++) {
369 switch (e->data[i]) {
370 case 0: c = _("-"); break;
371 case 1: c = _("Y"); break;
372 case 2: c = _("Cb"); break;
373 case 3: c = _("Cr"); break;
374 case 4: c = _("R"); break;
375 case 5: c = _("G"); break;
376 case 6: c = _("B"); break;
377 default: c = _("reserved"); break;
378 }
379 strncat (v, c, sizeof (v));
380 if (i < 3) strncat (v, " ", sizeof (v));
381 }
382 break;
383 case EXIF_TAG_SENSING_METHOD:
384 CF (e->format, EXIF_FORMAT_SHORT, v);
385 CC (e->components, 1, v);
386 v_short = exif_get_short (e->data, o);
387 switch (v_short) {
388 case 1: strncpy (v, _("Not defined"), sizeof (v)); break;
389 case 2:
390 strncpy (v, _("One-chip color area sensor"),
391 sizeof (v));
392 break;
393 case 3:
394 strncpy (v, _("Two-chip color area sensor"),
395 sizeof (v));
396 break;
397 case 4:
398 strncpy (v, _("Three-chip color area sensor"),
399 sizeof (v));
400 break;
401 case 5:
402 strncpy (v, _("Color sequential area sensor"),
403 sizeof (v));
404 break;
405 case 7: strncpy (v, _("Trilinear sensor"), sizeof (v)); break;
406 case 8:
407 strncpy (v, _("Color sequential linear sensor"),
408 sizeof (v));
409 break;
410 default: snprintf (v, sizeof (v), "%i", v_short); break;
411 }
412 break;
413 case EXIF_TAG_LIGHT_SOURCE:
414 CF (e->format, EXIF_FORMAT_SHORT, v);
415 CC (e->components, 1, v);
416 v_short = exif_get_short (e->data, o);
417 switch (v_short) {
418 case 0: strncpy (v, _("Unknown"), sizeof (v)); break;
419 case 1: strncpy (v, _("Daylight"), sizeof (v)); break;
420 case 2: strncpy (v, _("Fluorescent"), sizeof (v)); break;
421 case 3:
422 strncpy (v, _("Tungsten (incandescent light)"),
423 sizeof (v));
424 break;
425 case 4: strncpy (v, _("Flash"), sizeof (v)); break;
426 case 9: strncpy (v, _("Fine weather"), sizeof (v)); break;
427 case 10: strncpy (v, _("Cloudy weather"), sizeof (v)); break;
428 case 11: strncpy (v, _("Shade"), sizeof (v)); break;
429 case 12:
430 strncpy (v, _("Daylight fluorescent"), sizeof (v));
431 break;
432 case 13:
433 strncpy (v, _("Day white fluorescent"), sizeof (v));
434 break;
435 case 14:
436 strncpy (v, _("Cool white fluorescent"), sizeof (v));
437 break;
438 case 15:
439 strncpy (v, _("White fluorescent"), sizeof (v));
440 break;
441 case 17:
442 strncpy (v, _("Standard light A"), sizeof (v)); break;
443 case 18: strncpy (v, _("Standard light B"), sizeof (v)); break;
444 case 19: strncpy (v, _("Standard light C"), sizeof (v)); break;
445 case 20: strncpy (v, _("D55"), sizeof (v)); break;
446 case 21: strncpy (v, _("D65"), sizeof (v)); break;
447 case 22: strncpy (v, _("D75"), sizeof (v)); break;
448 case 24:
449 strncpy (v, _("ISO studio tungsten"), sizeof (v));
450 break;
451 case 255: strncpy (v, _("Other"), sizeof (v)); break;
452 default: snprintf (v, sizeof (v), "%i", v_short); break;
453 }
454 break;
455 case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
456 case EXIF_TAG_RESOLUTION_UNIT:
457 CF (e->format, EXIF_FORMAT_SHORT, v);
458 CC (e->components, 1, v);
459 v_short = exif_get_short (e->data, o);
460 switch (v_short) {
461 case 2: strncpy (v, _("Inch"), sizeof (v)); break;
462 case 3: strncpy (v, _("Centimeter"), sizeof (v)); break;
463 default: snprintf (v, sizeof (v), "%i", v_short); break;
464 }
465 break;
466 case EXIF_TAG_EXPOSURE_PROGRAM:
467 CF (e->format, EXIF_FORMAT_SHORT, v);
468 CC (e->components, 1, v);
469 v_short = exif_get_short (e->data, o);
470 switch (v_short) {
471 case 0: strncpy (v, _("Not defined"), sizeof (v)); break;
472 case 1: strncpy (v, _("Manual"), sizeof (v)); break;
473 case 2: strncpy (v, _("Normal program"), sizeof (v)); break;
474 case 3: strncpy (v, _("Aperture priority"), sizeof (v)); break;
475 case 4: strncpy (v, _("Shutter priority"), sizeof (v)); break;
476 case 5:
477 strncpy (v, _("Creative program (biased toward "
478 "depth of field)"), sizeof (v));
479 break;
480 case 6:
481 strncpy (v, _("Action program (biased toward "
482 "fast shutter speed)"), sizeof (v));
483 break;
484 case 7:
485 strncpy (v, _("Portrait mode (for closeup photos "
486 "with the background out of focus"),
487 sizeof (v));
488 break;
489 case 8:
490 strncpy (v, _("Landscape mode (for landscape "
491 "photos with the background in focus"),
492 sizeof (v));
493 break;
494 default: snprintf (v, sizeof (v), "%i", v_short); break;
495 }
496 break;
497 case EXIF_TAG_EXPOSURE_BIAS_VALUE:
498 CF (e->format, EXIF_FORMAT_SRATIONAL, v);
499 CC (e->components, 1, v);
500 v_srat = exif_get_srational (e->data, o);
501 if (!v_srat.denominator)
502 return (NULL);
503 snprintf (v, sizeof (v), "%s%.01f",
504 v_srat.denominator * v_srat.numerator > 0 ? "+" : "",
505 (double) v_srat.numerator /
506 (double) v_srat.denominator);
507 break;
508 case EXIF_TAG_ORIENTATION:
509 CF (e->format, EXIF_FORMAT_SHORT, v);
510 CC (e->components, 1, v);
511 v_short = exif_get_short (e->data, o);
512 switch (v_short) {
513 case 1:
514 strncpy (v, _("top - left"), sizeof (v));
515 break;
516 case 2:
517 strncpy (v, _("top - right"), sizeof (v));
518 break;
519 case 3:
520 strncpy (v, _("bottom - right"), sizeof (v));
521 break;
522 case 4:
523 strncpy (v, _("bottom - left"), sizeof (v));
524 break;
525 case 5:
526 strncpy (v, _("left - top"), sizeof (v));
527 break;
528 case 6:
529 strncpy (v, _("right - top"), sizeof (v));
530 break;
531 case 7:
532 strncpy (v, _("right - bottom"), sizeof (v));
533 break;
534 case 8:
535 strncpy (v, _("left - bottom"), sizeof (v));
536 break;
537 default:
538 snprintf (v, sizeof (v), "%i", v_short);
539 break;
540 }
541 break;
542 case EXIF_TAG_YCBCR_POSITIONING:
543 CF (e->format, EXIF_FORMAT_SHORT, v);
544 CC (e->components, 1, v);
545 v_short = exif_get_short (e->data, o);
546 switch (v_short) {
547 case 1:
548 strncpy (v, _("centered"), sizeof (v));
549 break;
550 case 2:
551 strncpy (v, _("co-sited"), sizeof (v));
552 break;
553 default:
554 snprintf (v, sizeof (v), "%i", v_short);
555 break;
556 }
557 break;
558 case EXIF_TAG_YCBCR_SUB_SAMPLING:
559 CF (e->format, EXIF_FORMAT_SHORT, v);
560 CC (e->components, 2, v);
561 v_short = exif_get_short (e->data, o);
562 v_short2 = exif_get_short (
563 e->data + exif_format_get_size (e->format),
564 o);
565 if ((v_short == 2) && (v_short2 == 1))
566 strncpy (v, _("YCbCr4:2:2"), sizeof (v));
567 else if ((v_short == 2) && (v_short2 == 2))
568 strncpy (v, _("YCbCr4:2:0"), sizeof (v));
569 else
570 snprintf (v, sizeof (v), "%i, %i", v_short, v_short2);
571 break;
572 case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
573 CF (e->format, EXIF_FORMAT_SHORT, v);
574 CC (e->components, 1, v);
575 v_short = exif_get_short (e->data, o);
576 switch (v_short) {
577 case 2:
578 strncpy (v, _("RGB"), sizeof (v));
579 break;
580 case 6:
581 strncpy (v, _("YCbCr"), sizeof (v));
582 break;
583 default:
584 snprintf (v, sizeof (v), "%i", v_short);
585 break;
586 }
587 break;
588 case EXIF_TAG_COLOR_SPACE:
589 CF (e->format, EXIF_FORMAT_SHORT, v);
590 CC (e->components, 1, v);
591 v_short = exif_get_short (e->data, o);
592 switch (v_short) {
593 case 1:
594 strncpy (v, _("sRGB"), sizeof (v));
595 break;
596 case 0xffff:
597 strncpy (v, _("Uncalibrated"), sizeof (v));
598 break;
599 default:
600 snprintf (v, sizeof (v), "%i", v_short);
601 break;
602 }
603 break;
604 case EXIF_TAG_FLASH:
605 CF (e->format, EXIF_FORMAT_SHORT, v);
606 CC (e->components, 1, v);
607 v_short = exif_get_short (e->data, o);
608 switch (v_short) {
609 case 0x000:
610 strncpy (v, _("Flash did not fire."), sizeof (v));
611 break;
612 case 0x0001:
613 strncpy (v, _("Flash fired."), sizeof (v));
614 break;
615 case 0x0005:
616 strncpy (v, _("Strobe return light not detected."),
617 sizeof (v));
618 break;
619 case 0x0007:
620 strncpy (v, _("Strobe return light detected."),
621 sizeof (v));
622 break;
623 case 0x000d:
624 strncpy (v, _("Flash fired, compulsory flash mode, "
625 "return light not detected."), sizeof (v));
626 break;
627 case 0x000f:
628 strncpy (v, _("Flash fired, compulsory flash mode, "
629 "return light detected."), sizeof (v));
630 break;
631 case 0x0010:
632 strncpy (v, _("Flash did not fire, compulsory flash "
633 "mode."), sizeof (v));
634 break;
635 case 0x0018:
636 strncpy (v, _("Flash did not fire, auto mode."),
637 sizeof (v));
638 break;
639 case 0x0019:
640 strncpy (v, _("Flash fired, auto mode."), sizeof (v));
641 break;
642 case 0x001d:
643 strncpy (v, _("Flash fired, auto mode, return light "
644 "not detected."), sizeof (v));
645 break;
646 case 0x001f:
647 strncpy (v, _("Flash fired, auto mode, return light "
648 "detected."), sizeof (v));
649 break;
650 case 0x0020:
651 strncpy (v, _("No flash function."), sizeof (v));
652 break;
653 case 0x0041:
654 strncpy (v, _("Flash fired, red-eye reduction mode."),
655 sizeof (v));
656 break;
657 case 0x0045:
658 strncpy (v, _("Flash fired, red-eye reduction mode, "
659 "return light not detected."), sizeof (v));
660 break;
661 case 0x0047:
662 strncpy (v, _("Flash fired, red-eye reduction mode, "
663 "return light detected."), sizeof (v));
664 break;
665 case 0x0049:
666 strncpy (v, _("Flash fired, compulsory flash mode, "
667 "red-eye reduction mode."), sizeof (v));
668 break;
669 case 0x004d:
670 strncpy (v, _("Flash fired, compulsory flash mode, "
671 "red-eye reduction mode, return light not "
672 "detected."), sizeof (v));
673 break;
674 case 0x004f:
675 strncpy (v, _("Flash fired, compulsory flash mode, "
676 "red-eye reduction mode, return light "
677 "detected."), sizeof (v));
678 break;
679 case 0x0059:
680 strncpy (v, _("Flash fired, auto mode, red-eye "
681 "reduction mode."), sizeof (v));
682 break;
683 case 0x005d:
684 strncpy (v, _("Flash fired, auto mode, return light "
685 "not detected, red-eye reduction mode."),
686 sizeof (v));
687 break;
688 case 0x005f:
689 strncpy (v, _("Flash fired, auto mode, return light "
690 "detected, red-eye reduction mode."),
691 sizeof (v));
692 break;
693 default:
694 snprintf (v, sizeof (v), "%i", v_short);
695 break;
696 }
697 break;
698 case EXIF_TAG_MAKER_NOTE:
699 CF (e->format, EXIF_FORMAT_UNDEFINED, v);
700 snprintf (v, sizeof (v), _("%i bytes unknown data"),
701 (int) e->components);
702 break;
703 case EXIF_TAG_CUSTOM_RENDERED:
704 CF (e->format, EXIF_FORMAT_SHORT, v);
705 CC (e->components, 1, v);
706 v_short = exif_get_short (e->data, o);
707 switch (v_short) {
708 case 0:
709 strncpy (v, _("Normal process"), sizeof (v));
710 break;
711 case 1:
712 strncpy (v, _("Custom process"), sizeof (v));
713 break;
714 default:
715 snprintf (v, sizeof (v), "%i", v_short);
716 break;
717 }
718 break;
719 case EXIF_TAG_EXPOSURE_MODE:
720 CF (e->format, EXIF_FORMAT_SHORT, v);
721 CC (e->components, 1, v);
722 v_short = exif_get_short (e->data, o);
723 switch (v_short) {
724 case 0:
725 strncpy (v, _("Auto exposure"), sizeof (v));
726 break;
727 case 1:
728 strncpy (v, _("Manual exposure"), sizeof (v));
729 break;
730 case 2:
731 strncpy (v, _("Auto bracket"), sizeof (v));
732 break;
733 default:
734 snprintf (v, sizeof (v), "%i", v_short);
735 break;
736 }
737 break;
738 case EXIF_TAG_WHITE_BALANCE:
739 CF (e->format, EXIF_FORMAT_SHORT, v);
740 CC (e->components, 1, v);
741 v_short = exif_get_short (e->data, o);
742 switch (v_short) {
743 case 0:
744 strncpy (v, _("Auto white balance"), sizeof (v));
745 break;
746 case 1:
747 strncpy (v, _("Manual white balance"), sizeof (v));
748 break;
749 default:
750 snprintf (v, sizeof (v), "%i", v_short);
751 break;
752 }
753 break;
754 case EXIF_TAG_SCENE_CAPTURE_TYPE:
755 CF (e->format, EXIF_FORMAT_SHORT, v);
756 CC (e->components, 1, v);
757 v_short = exif_get_short (e->data, o);
758 switch (v_short) {
759 case 0:
760 strncpy (v, _("Standard"), sizeof (v));
761 break;
762 case 1:
763 strncpy (v, _("Landscape"), sizeof (v));
764 break;
765 case 2:
766 strncpy (v, _("Portrait"), sizeof (v));
767 break;
768 case 3:
769 strncpy (v, _("Night scene"), sizeof (v));
770 break;
771 default:
772 snprintf (v, sizeof (v), "%i", v_short);
773 break;
774 }
775 break;
776 case EXIF_TAG_GAIN_CONTROL:
777 CF (e->format, EXIF_FORMAT_SHORT, v);
778 CC (e->components, 1, v);
779 v_short = exif_get_short (e->data, o);
780 switch (v_short) {
781 case 0:
782 strncpy (v, _("Normal"), sizeof (v));
783 break;
784 case 1:
785 strncpy (v, _("Low gain up"), sizeof (v));
786 break;
787 case 2:
788 strncpy (v, _("High gain up"), sizeof (v));
789 break;
790 case 3:
791 strncpy (v, _("Low gain down"), sizeof (v));
792 break;
793 case 4:
794 strncpy (v, _("High gain down"), sizeof (v));
795 break;
796 default:
797 snprintf (v, sizeof (v), "%i", v_short);
798 break;
799 }
800 break;
801 case EXIF_TAG_SATURATION:
802 CF (e->format, EXIF_FORMAT_SHORT, v);
803 CC (e->components, 1, v);
804 v_short = exif_get_short (e->data, o);
805 switch (v_short) {
806 case 0:
807 strncpy (v, _("Normal"), sizeof (v));
808 break;
809 case 1:
810 strncpy (v, _("Low saturation"), sizeof (v));
811 break;
812 case 2:
813 strncpy (v, _("High saturation"), sizeof (v));
814 break;
815 default:
816 snprintf (v, sizeof (v), "%i", v_short);
817 break;
818 }
819 break;
820 case EXIF_TAG_CONTRAST:
821 case EXIF_TAG_SHARPNESS:
822 CF (e->format, EXIF_FORMAT_SHORT, v);
823 CC (e->components, 1, v);
824 v_short = exif_get_short (e->data, o);
825 switch (v_short) {
826 case 0:
827 strncpy (v, _("Normal"), sizeof (v));
828 break;
829 case 1:
830 strncpy (v, _("Soft"), sizeof (v));
831 break;
832 case 2:
833 strncpy (v, _("Hard"), sizeof (v));
834 break;
835 default:
836 snprintf (v, sizeof (v), "%i", v_short);
837 break;
838 }
839 break;
840 case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
841 CF (e->format, EXIF_FORMAT_SHORT, v);
842 CC (e->components, 1, v);
843 v_short = exif_get_short (e->data, o);
844 switch (v_short) {
845 case 0:
846 strncpy (v, _("Unknown"), sizeof (v));
847 break;
848 case 1:
849 strncpy (v, _("Macro"), sizeof (v));
850 break;
851 case 2:
852 strncpy (v, _("Close view"), sizeof (v));
853 break;
854 case 3:
855 strncpy (v, _("Distant view"), sizeof (v));
856 break;
857 default:
858 snprintf (v, sizeof (v), "%i", v_short);
859 break;
860 }
861 break;
862 case EXIF_TAG_SUBJECT_AREA:
863 CF (e->format, EXIF_FORMAT_SHORT, v);
864 switch (e->components) {
865 case 2:
866 v_short = exif_get_short (e->data, o);
867 v_short2 = exif_get_short (e->data + 2, o);
868 snprintf (v, sizeof (v), "(x,y) = (%i,%i)",
869 v_short, v_short2);
870 break;
871 case 3:
872 v_short = exif_get_short (e->data, o);
873 v_short2 = exif_get_short (e->data + 2, o);
874 v_short3 = exif_get_short (e->data + 4, o);
875 snprintf (v, sizeof (v), _("Within distance %i of "
876 "(x,y) = (%i,%i)"), v_short3, v_short,
877 v_short2);
878 break;
879 case 4:
880 v_short = exif_get_short (e->data, o);
881 v_short2 = exif_get_short (e->data + 2, o);
882 v_short3 = exif_get_short (e->data + 4, o);
883 v_short4 = exif_get_short (e->data + 6, o);
884 snprintf (v, sizeof (v), _("Within rectangle "
885 "(width %i, height %i) around "
886 "(x,y) = (%i,%i)"), v_short3, v_short4,
887 v_short, v_short2);
888 break;
889 default:
890 snprintf (v, sizeof (v), _("Unexpected number "
891 "of components (%li, expected 2, 3, or 4)."),
892 e->components);
893 }
894 default:
895 if (!e->components) break;
896 switch (e->format) {
897 case EXIF_FORMAT_UNDEFINED:
898 break;
899 case EXIF_FORMAT_BYTE:
900 v_byte = e->data[0];
901 snprintf (v, sizeof (v), "0x%02x", v_byte);
902 for (i = 1; i < e->components; i++) {
903 v_byte = e->data[i];
904 snprintf (b, sizeof (b), "0x%02x", v_byte);
905 strncat (v, ", ", sizeof (v));
906 strncat (v, b, sizeof (v));
907 }
908 break;
909 case EXIF_FORMAT_SHORT:
910 v_short = exif_get_short (e->data, o);
911 snprintf (v, sizeof (v), "%i", v_short);
912 for (i = 1; i < e->components; i++) {
913 v_short = exif_get_short (e->data +
914 exif_format_get_size (e->format) *
915 i, o);
916 snprintf (b, sizeof (b), "%i", v_short);
917 strncat (v, ", ", sizeof (v));
918 strncat (v, b, sizeof (v));
919 }
920 break;
921 case EXIF_FORMAT_LONG:
922 v_long = exif_get_long (e->data, o);
923 snprintf (v, sizeof (v), "%i", (int) v_long);
924 for (i = 1; i < e->components; i++) {
925 v_long = exif_get_long (e->data +
926 exif_format_get_size (e->format) *
927 i, o);
928 snprintf (b, sizeof (b), "%li", v_long);
929 strncat (v, ", ", sizeof (v));
930 strncat (v, b, sizeof (v));
931 }
932 break;
933 case EXIF_FORMAT_SLONG:
934 v_slong = exif_get_slong (e->data, o);
935 snprintf (v, sizeof (v), "%li", v_slong);
936 for (i = 1; i < e->components; i++) {
937 v_long = exif_get_slong (e->data +
938 exif_format_get_size (e->format) *
939 i, o);
940 snprintf (b, sizeof (b), "%li", v_long);
941 strncat (v, ", ", sizeof (v));
942 strncat (v, b, sizeof (v));
943 }
944 break;
945 case EXIF_FORMAT_ASCII:
946 strncpy (v, e->data, MIN (sizeof (v), e->size));
947 break;
948 case EXIF_FORMAT_RATIONAL:
949 v_rat = exif_get_rational (e->data, o);
950 snprintf (v, sizeof (v), "%i/%i",
951 (int) v_rat.numerator,
952 (int) v_rat.denominator);
953 for (i = 1; i < e->components; i++) {
954 v_rat = exif_get_rational (
955 e->data + 8 * i, o);
956 snprintf (b, sizeof (b), "%i/%i",
957 (int) v_rat.numerator,
958 (int) v_rat.denominator);
959 strncat (v, ", ", sizeof (v));
960 strncat (v, b, sizeof (v));
961 }
962 break;
963 case EXIF_FORMAT_SRATIONAL:
964 v_srat = exif_get_srational (e->data, o);
965 snprintf (v, sizeof (v), "%i/%i",
966 (int) v_srat.numerator,
967 (int) v_srat.denominator);
968 for (i = 1; i < e->components; i++) {
969 v_srat = exif_get_srational (
970 e->data + 8 * i, o);
971 snprintf (b, sizeof (b), "%i/%i",
972 (int) v_srat.numerator,
973 (int) v_srat.denominator);
974 strncat (v, ", ", sizeof (v));
975 strncat (v, b, sizeof (v));
976 }
977 break;
978 }
979 }
980
981 return (v);
982 }
983
984 const char *
exif_entry_get_value_brief(ExifEntry * e)985 exif_entry_get_value_brief (ExifEntry *e)
986 {
987 ExifByteOrder o;
988 ExifEntry *entry;
989 static char v[1024];
990 ExifRational v_rat;
991 ExifSRational v_srat;
992 ExifShort v_short;
993 double d;
994
995 /* We need the byte order */
996 if (!e || !e->parent || !e->parent->parent)
997 return (NULL);
998 o = exif_data_get_byte_order (e->parent->parent);
999
1000 memset (v, 0, sizeof (v));
1001
1002 switch (e->tag) {
1003 case EXIF_TAG_FOCAL_LENGTH:
1004 CF (e->format, EXIF_FORMAT_RATIONAL, v);
1005 CC (e->components, 1, v);
1006 v_rat = exif_get_rational (e->data, o);
1007 if (!v_rat.denominator)
1008 return (NULL);
1009
1010 /*
1011 * For calculation of the 35mm equivalent,
1012 * Minolta cameras need a multiplier that depends on the
1013 * camera model.
1014 */
1015 d = (double) v_rat.numerator / (double) v_rat.denominator;
1016 entry = exif_content_get_entry (
1017 e->parent->parent->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
1018 if (entry && entry->data &&
1019 !strncmp (entry->data, "Minolta", 7)) {
1020 entry = exif_content_get_entry (
1021 e->parent->parent->ifd[EXIF_IFD_0],
1022 EXIF_TAG_MODEL);
1023 if (entry && entry->data) {
1024 if (!strncmp (entry->data, "DiMAGE 7", 8))
1025 d *= 3.9;
1026 else if (!strncmp (entry->data, "DiMAGE 5", 8))
1027 d *= 4.9;
1028 }
1029 }
1030 snprintf (v, sizeof (v), "%dmm",
1031 (int) (d * (double) v_rat.numerator /
1032 (double) v_rat.denominator));
1033 break;
1034 case EXIF_TAG_EXPOSURE_TIME:
1035 CF (e->format, EXIF_FORMAT_RATIONAL, v);
1036 CC (e->components, 1, v);
1037 v_rat = exif_get_rational (e->data, o);
1038 if (!v_rat.denominator)
1039 return (NULL);
1040 d = (double) v_rat.numerator / (double) v_rat.denominator;
1041 if (d < 1.)
1042 snprintf (v, sizeof (v), "1/%d", (int) (1. / d));
1043 else
1044 snprintf (v, sizeof (v), "%d", (int) d);
1045 break;
1046 case EXIF_TAG_SHUTTER_SPEED_VALUE:
1047 CF (e->format, EXIF_FORMAT_SRATIONAL, v);
1048 CC (e->components, 1, v);
1049 v_srat = exif_get_srational (e->data, o);
1050 if (!v_srat.denominator)
1051 return (NULL);
1052 d = 1. / pow (2., (double) v_srat.numerator /
1053 (double) v_srat.denominator);
1054 if (d < 1.)
1055 snprintf (v, sizeof (v), "1/%d", (int) (1. / d));
1056 else
1057 snprintf (v, sizeof (v), "%d", (int) d);
1058 break;
1059 case EXIF_TAG_METERING_MODE:
1060 CF (e->format, EXIF_FORMAT_SHORT, v);
1061 CC (e->components, 1, v);
1062 v_short = exif_get_short (e->data, o);
1063 switch (v_short) {
1064 case 0:
1065 strncpy (v, _("unknown"), sizeof (v));
1066 break;
1067 case 1:
1068 strncpy (v, _("average"), sizeof (v));
1069 break;
1070 case 2:
1071 strncpy (v, _("center-weight"), sizeof (v));
1072 break;
1073 case 3:
1074 strncpy (v, _("spot"), sizeof (v));
1075 break;
1076 case 4:
1077 strncpy (v, _("multi-spot"), sizeof (v));
1078 break;
1079 case 5:
1080 strncpy (v, _("matrix"), sizeof (v));
1081 break;
1082 case 6:
1083 strncpy (v, _("partial"), sizeof (v));
1084 break;
1085 case 255:
1086 strncpy (v, _("other"), sizeof (v));
1087 break;
1088 default:
1089 snprintf (v, sizeof (v), "%i", v_short);
1090 break;
1091 }
1092 break;
1093 case EXIF_TAG_LIGHT_SOURCE:
1094 CF (e->format, EXIF_FORMAT_SHORT, v);
1095 CC (e->components, 1, v);
1096 v_short = exif_get_short (e->data, o);
1097 switch (v_short) {
1098 case 0:
1099 strncpy (v, _("sunny"), sizeof (v));
1100 break;
1101 case 1:
1102 strncpy (v, _("fluorescent"), sizeof (v));
1103 break;
1104 case 2:
1105 strncpy (v, _("tungsten"), sizeof (v));
1106 break;
1107 case 3:
1108 strncpy (v, _("cloudy"), sizeof (v));
1109 break;
1110 default:
1111 return (exif_entry_get_value (e));
1112 }
1113 break;
1114 case EXIF_TAG_RESOLUTION_UNIT:
1115 CF (e->format, EXIF_FORMAT_SHORT, v);
1116 CC (e->components, 1, v);
1117 v_short = exif_get_short (e->data, o);
1118 switch (v_short) {
1119 case 2:
1120 strncpy (v, _("in"), sizeof (v));
1121 break;
1122 case 3:
1123 strncpy (v, _("cm"), sizeof (v));
1124 break;
1125 default:
1126 return (NULL);
1127 }
1128 break;
1129 case EXIF_TAG_EXPOSURE_PROGRAM:
1130 CF (e->format, EXIF_FORMAT_SHORT, v);
1131 CC (e->components, 1, v);
1132 v_short = exif_get_short (e->data, o);
1133 switch (v_short) {
1134 case 1:
1135 strncpy (v, _("manual"), sizeof (v));
1136 break;
1137 case 2:
1138 strncpy (v, _("normal"), sizeof (v));
1139 break;
1140 case 3:
1141 strncpy (v, _("aperture"), sizeof (v));
1142 break;
1143 case 4:
1144 strncpy (v, _("shutter"), sizeof (v));
1145 break;
1146 case 5:
1147 strncpy (v, _("creative"), sizeof (v));
1148 break;
1149 case 6:
1150 strncpy (v, _("action"), sizeof (v));
1151 break;
1152 case 7:
1153 strncpy (v, _("portrait"), sizeof (v));
1154 break;
1155 case 8:
1156 strncpy (v, _("landscape"), sizeof (v));
1157 break;
1158 default:
1159 return (exif_entry_get_value (e));
1160 }
1161 break;
1162 case EXIF_TAG_FLASH:
1163 CF (e->format, EXIF_FORMAT_SHORT, v);
1164 CC (e->components, 1, v);
1165 v_short = exif_get_short (e->data, o);
1166 switch (v_short) {
1167 case 0x0001:
1168 strncpy (v, _("yes"), sizeof (v));
1169 break;
1170 case 0x0005:
1171 strncpy (v, _("w/o strobe"), sizeof (v));
1172 break;
1173 case 0x0007:
1174 strncpy (v, _("w. strobe"), sizeof (v));
1175 break;
1176 default:
1177 return (exif_entry_get_value (e));
1178 }
1179 break;
1180 default:
1181 return (exif_entry_get_value (e));
1182 }
1183
1184 return (v);
1185 }
1186
1187 void
exif_entry_initialize(ExifEntry * e,ExifTag tag)1188 exif_entry_initialize (ExifEntry *e, ExifTag tag)
1189 {
1190 time_t t;
1191 struct tm *tm;
1192 ExifRational r;
1193 ExifByteOrder o;
1194
1195 /* We need the byte order */
1196 if (!e || !e->parent || e->data || !e->parent->parent)
1197 return;
1198 o = exif_data_get_byte_order (e->parent->parent);
1199
1200 e->tag = tag;
1201 switch (tag) {
1202
1203 /* LONG, 1 component, no default */
1204 case EXIF_TAG_EXIF_IFD_POINTER:
1205 case EXIF_TAG_GPS_INFO_IFD_POINTER:
1206 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
1207 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
1208 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
1209 e->components = 1;
1210 e->format = EXIF_FORMAT_LONG;
1211 e->size = exif_format_get_size (e->format) * e->components;
1212 e->data = malloc (e->size);
1213 memset (e->data, 0, e->size);
1214 break;
1215
1216 /* SHORT, 1 component, no default */
1217 case EXIF_TAG_SUBJECT_LOCATION:
1218 case EXIF_TAG_SENSING_METHOD:
1219 case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
1220 case EXIF_TAG_COMPRESSION:
1221 case EXIF_TAG_EXPOSURE_MODE:
1222 case EXIF_TAG_WHITE_BALANCE:
1223 case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
1224 case EXIF_TAG_GAIN_CONTROL:
1225 case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
1226
1227 /* SHORT, 1 component, default 0 */
1228 case EXIF_TAG_IMAGE_WIDTH:
1229 case EXIF_TAG_IMAGE_LENGTH:
1230 case EXIF_TAG_EXPOSURE_PROGRAM:
1231 case EXIF_TAG_LIGHT_SOURCE:
1232 case EXIF_TAG_METERING_MODE:
1233 case EXIF_TAG_CUSTOM_RENDERED:
1234 case EXIF_TAG_SCENE_CAPTURE_TYPE:
1235 case EXIF_TAG_CONTRAST:
1236 case EXIF_TAG_SATURATION:
1237 case EXIF_TAG_SHARPNESS:
1238 e->components = 1;
1239 e->format = EXIF_FORMAT_SHORT;
1240 e->size = exif_format_get_size (e->format) * e->components;
1241 e->data = malloc (e->size);
1242 exif_set_short (e->data, o, 0);
1243 break;
1244
1245 /* SHORT, 1 component, default 1 */
1246 case EXIF_TAG_ORIENTATION:
1247 case EXIF_TAG_PLANAR_CONFIGURATION:
1248 case EXIF_TAG_YCBCR_POSITIONING:
1249 e->components = 1;
1250 e->format = EXIF_FORMAT_SHORT;
1251 e->size = exif_format_get_size (e->format) * e->components;
1252 e->data = malloc (e->size);
1253 exif_set_short (e->data, o, 1);
1254 break;
1255
1256 /* SHORT, 1 component, default 2 */
1257 case EXIF_TAG_RESOLUTION_UNIT:
1258 case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
1259 e->components = 1;
1260 e->format = EXIF_FORMAT_SHORT;
1261 e->size = exif_format_get_size (e->format) * e->components;
1262 e->data = malloc (e->size);
1263 exif_set_short (e->data, o, 2);
1264 break;
1265
1266 /* SHORT, 1 component, default 3 */
1267 case EXIF_TAG_SAMPLES_PER_PIXEL:
1268 e->components = 1;
1269 e->format = EXIF_FORMAT_SHORT;
1270 e->size = exif_format_get_size (e->format) * e->components;
1271 e->data = malloc (e->size);
1272 exif_set_short (e->data, o, 3);
1273 break;
1274
1275 case EXIF_TAG_BITS_PER_SAMPLE:
1276 e->components = 3;
1277 e->format = EXIF_FORMAT_SHORT;
1278 e->size = exif_format_get_size (e->format) * e->components;
1279 e->data = malloc (e->size);
1280 exif_set_short (e->data, o, 8);
1281 exif_set_short (
1282 e->data + exif_format_get_size (e->format),
1283 o, 8);
1284 exif_set_short (
1285 e->data + 2 * exif_format_get_size (e->format),
1286 o, 8);
1287 break;
1288 case EXIF_TAG_YCBCR_SUB_SAMPLING:
1289 e->components = 2;
1290 e->format = EXIF_FORMAT_SHORT;
1291 e->size = exif_format_get_size (e->format) * e->components;
1292 e->data = malloc (e->size);
1293 exif_set_short (e->data, o, 2);
1294 exif_set_short (
1295 e->data + exif_format_get_size (e->format),
1296 o, 1);
1297 break;
1298
1299 /* SRATIONAL, 1 component, no default */
1300 case EXIF_TAG_EXPOSURE_BIAS_VALUE:
1301 case EXIF_TAG_BRIGHTNESS_VALUE:
1302 case EXIF_TAG_SHUTTER_SPEED_VALUE:
1303 e->components = 1;
1304 e->format = EXIF_FORMAT_SRATIONAL;
1305 e->size = exif_format_get_size (e->format) * e->components;
1306 e->data = malloc (e->size);
1307 memset (e->data, 0, e->size);
1308 break;
1309
1310 /* RATIONAL, 1 component, no default */
1311 case EXIF_TAG_EXPOSURE_TIME:
1312 case EXIF_TAG_FOCAL_PLANE_X_RESOLUTION:
1313 case EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION:
1314 case EXIF_TAG_EXPOSURE_INDEX:
1315 case EXIF_TAG_FLASH_ENERGY:
1316 case EXIF_TAG_FNUMBER:
1317 case EXIF_TAG_FOCAL_LENGTH:
1318 case EXIF_TAG_SUBJECT_DISTANCE:
1319 case EXIF_TAG_MAX_APERTURE_VALUE:
1320 case EXIF_TAG_APERTURE_VALUE:
1321 case EXIF_TAG_COMPRESSED_BITS_PER_PIXEL:
1322 case EXIF_TAG_PRIMARY_CHROMATICITIES:
1323 case EXIF_TAG_DIGITAL_ZOOM_RATIO:
1324 e->components = 1;
1325 e->format = EXIF_FORMAT_RATIONAL;
1326 e->size = exif_format_get_size (e->format) * e->components;
1327 e->data = malloc (e->size);
1328 memset (e->data, 0, e->size);
1329 break;
1330
1331 /* RATIONAL, 1 component, default 72/1 */
1332 case EXIF_TAG_X_RESOLUTION:
1333 case EXIF_TAG_Y_RESOLUTION:
1334 e->components = 1;
1335 e->format = EXIF_FORMAT_RATIONAL;
1336 e->size = exif_format_get_size (e->format) * e->components;
1337 e->data = malloc (e->size);
1338 r.numerator = 72;
1339 r.denominator = 1;
1340 exif_set_rational (e->data, o, r);
1341 break;
1342
1343 /* RATIONAL, 2 components, no default */
1344 case EXIF_TAG_WHITE_POINT:
1345 e->components = 2;
1346 e->format = EXIF_FORMAT_RATIONAL;
1347 e->size = exif_format_get_size (e->format) * e->components;
1348 e->data = malloc (e->size);
1349 memset (e->data, 0, e->size);
1350 break;
1351
1352 /* RATIONAL, 6 components */
1353 case EXIF_TAG_REFERENCE_BLACK_WHITE:
1354 e->components = 6;
1355 e->format = EXIF_FORMAT_RATIONAL;
1356 e->size = exif_format_get_size (e->format) * e->components;
1357 e->data = malloc (e->size);
1358 r.denominator = 1;
1359 r.numerator = 0;
1360 exif_set_rational (e->data, o, r);
1361 r.numerator = 255;
1362 exif_set_rational (
1363 e->data + exif_format_get_size (e->format), o, r);
1364 r.numerator = 0;
1365 exif_set_rational (
1366 e->data + 2 * exif_format_get_size (e->format), o, r);
1367 r.numerator = 255;
1368 exif_set_rational (
1369 e->data + 3 * exif_format_get_size (e->format), o, r);
1370 r.numerator = 0;
1371 exif_set_rational (
1372 e->data + 4 * exif_format_get_size (e->format), o, r);
1373 r.numerator = 255;
1374 exif_set_rational (
1375 e->data + 5 * exif_format_get_size (e->format), o, r);
1376 break;
1377 case EXIF_TAG_DATE_TIME:
1378 case EXIF_TAG_DATE_TIME_ORIGINAL:
1379 case EXIF_TAG_DATE_TIME_DIGITIZED:
1380 t = time (NULL);
1381 tm = localtime (&t);
1382 e->components = 20;
1383 e->format = EXIF_FORMAT_ASCII;
1384 e->size = exif_format_get_size (e->format) * e->components;
1385 e->data = malloc (e->size);
1386 snprintf ((char *) e->data, e->size,
1387 "%04i:%02i:%02i %02i:%02i:%02i",
1388 tm->tm_year + 1900, tm->tm_mon, tm->tm_mday,
1389 tm->tm_hour, tm->tm_min, tm->tm_sec);
1390 break;
1391 case EXIF_TAG_IMAGE_DESCRIPTION:
1392 case EXIF_TAG_MAKE:
1393 case EXIF_TAG_MODEL:
1394 case EXIF_TAG_SOFTWARE:
1395 case EXIF_TAG_ARTIST:
1396 e->components = strlen ("[None]") + 1;
1397 e->format = EXIF_FORMAT_ASCII;
1398 e->size = exif_format_get_size (e->format) * e->components;
1399 e->data = malloc (e->size);
1400 strncpy (e->data, "[None]", e->size);
1401 break;
1402 case EXIF_TAG_COPYRIGHT:
1403 e->components = (strlen ("[None]") + 1) * 2;
1404 e->format = EXIF_FORMAT_ASCII;
1405 e->size = exif_format_get_size (e->format) * e->components;
1406 e->data = malloc (e->size);
1407 strcpy (e->data + 0, "[None]");
1408 strcpy (e->data + strlen ("[None]") + 1, "[None]");
1409 break;
1410
1411 /* UNDEFINED, no components, no default */
1412 case EXIF_TAG_USER_COMMENT:
1413 e->components = 0;
1414 e->format = EXIF_FORMAT_UNDEFINED;
1415 e->size = 0;
1416 e->data = 0;
1417 break;
1418
1419 /* UNDEFINED, 1 component, default 1 */
1420 case EXIF_TAG_SCENE_TYPE:
1421 e->components = 1;
1422 e->format = EXIF_FORMAT_UNDEFINED;
1423 e->size = exif_format_get_size (e->format) * e->components;
1424 e->data = malloc (e->size);
1425 e->data[0] = 0x01;
1426 break;
1427
1428 /* UNDEFINED, 1 component, default 3 */
1429 case EXIF_TAG_FILE_SOURCE:
1430 e->components = 1;
1431 e->format = EXIF_FORMAT_UNDEFINED;
1432 e->size = exif_format_get_size (e->format) * e->components;
1433 e->data = malloc (e->size);
1434 e->data[0] = 0x03;
1435 break;
1436
1437 /* UNDEFINED, 4 components, default 0 1 0 0 */
1438 case EXIF_TAG_FLASH_PIX_VERSION:
1439 e->components = 4;
1440 e->format = EXIF_FORMAT_UNDEFINED;
1441 e->size = exif_format_get_size (e->format) * e->components;
1442 e->data = malloc (e->size);
1443 memcpy (e->data, "0100", 4);
1444 break;
1445
1446 /* UNDEFINED, 4 components, default 0 2 1 0 */
1447 case EXIF_TAG_EXIF_VERSION:
1448 e->components = 4;
1449 e->format = EXIF_FORMAT_UNDEFINED;
1450 e->size = exif_format_get_size (e->format) * e->components;
1451 e->data = malloc (e->size);
1452 memcpy (e->data, "0210", 4);
1453 break;
1454
1455 default:
1456 break;
1457 }
1458 }
1459