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