*** empty log message ***

55 files changed, 4298 insertions, 2678 deletions

diff --git a/src/config.mak b/src/config.mak
index d2c3c0d..059eb74 100644
--- a/src/config.mak
+++ b/src/config.mak
@@ -55,6 +55,7 @@ SRCZLIB  := $(addprefix zlib/, $(SRCZLIB))
 INCLUDES += zlib
 
 SRCEXIF = \
+    fuji/exif-mnote-data-fuji.c  fuji/mnote-fuji-entry.c  fuji/mnote-fuji-tag.c              \
     canon/exif-mnote-data-canon.c  canon/mnote-canon-entry.c  canon/mnote-canon-tag.c              \
     olympus/exif-mnote-data-olympus.c  olympus/mnote-olympus-entry.c  olympus/mnote-olympus-tag.c  \
     pentax/exif-mnote-data-pentax.c  pentax/mnote-pentax-entry.c  pentax/mnote-pentax-tag.c        \
diff --git a/src/libexif/canon/exif-mnote-data-canon.c b/src/libexif/canon/exif-mnote-data-canon.c
index b1c5dab..2783d15 100644
--- a/src/libexif/canon/exif-mnote-data-canon.c
+++ b/src/libexif/canon/exif-mnote-data-canon.c
@@ -1,7 +1,7 @@
 /* exif-mnote-data-canon.c
  *
- * Copyright © 2002, 2003 Lutz Müller <lutz@users.sourceforge.net>
- * Copyright © 2003 Matthieu Castet <mat-c@users.sourceforge.net>
+ * Copyright (c) 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
+ * Copyright (c) 2003 Matthieu Castet <mat-c@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -60,14 +60,33 @@ exif_mnote_data_canon_free (ExifMnoteData *n)
 	exif_mnote_data_canon_clear ((ExifMnoteDataCanon *) n);
 }
 
+static void
+exif_mnote_data_canon_get_tags (ExifMnoteDataCanon *dc, unsigned int n,
+		unsigned int *m, unsigned int *s)
+{
+	unsigned int from = 0, to;
+
+	if (!dc || !m) return;
+	for (*m = 0; *m < dc->count; (*m)++) {
+		to = from + mnote_canon_entry_count_values (&dc->entries[*m]);
+		if (to > n) {
+			if (s) *s = n - from;
+			break;
+		}
+		from = to;
+	}
+}
+
 static char *
 exif_mnote_data_canon_get_value (ExifMnoteData *note, unsigned int n, char *val, unsigned int maxlen)
 {
-	ExifMnoteDataCanon *cnote = (ExifMnoteDataCanon *) note;
+	ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) note;
+	unsigned int m, s;
 
-	if (!note) return NULL;
-	if (cnote->count <= n) return NULL;
-	return mnote_canon_entry_get_value (&cnote->entries[n], val, maxlen);
+	if (!dc) return NULL;
+	exif_mnote_data_canon_get_tags (dc, n, &m, &s);
+	if (m >= dc->count) return NULL;
+	return mnote_canon_entry_get_value (&dc->entries[m], s, val, maxlen);
 }
 
 static void
@@ -99,7 +118,9 @@ exif_mnote_data_canon_save (ExifMnoteData *ne,
 	unsigned char **buf, unsigned int *buf_size)
 {
 	ExifMnoteDataCanon *n = (ExifMnoteDataCanon *) ne;
-	unsigned int i, o, s, doff;
+	size_t i, o, s, doff;
+	unsigned char *t;
+	size_t ts;
 
 	if (!n || !buf || !buf_size) return;
 
@@ -124,14 +145,22 @@ exif_mnote_data_canon_save (ExifMnoteData *ne,
 		o += 8;
 		s = exif_format_get_size (n->entries[i].format) *
 						n->entries[i].components;
+		if (s > 65536) {
+			/* Corrupt data: EXIF data size is limited to the
+			 * maximum size of a JPEG segment (64 kb).
+			 */
+			continue;
+		}
 		if (s > 4) {
-			*buf_size += s;
+			ts = *buf_size + s;
 
 			/* Ensure even offsets. Set padding bytes to 0. */
-			if (s & 1) *buf_size += 1;
-			*buf = exif_mem_realloc (ne->mem, *buf,
-						 sizeof (char) * *buf_size);
-			if (!*buf) return;
+			if (s & 1) ts += 1;
+			t = exif_mem_realloc (ne->mem, *buf,
+						 sizeof (char) * ts);
+			if (!t) return;
+			*buf = t;
+			*buf_size = ts;
 			doff = *buf_size - s;
 			if (s & 1) { doff--; *(*buf + *buf_size - 1) = '\0'; }
 			exif_set_long (*buf + o, n->order, n->offset + doff);
@@ -166,7 +195,8 @@ exif_mnote_data_canon_load (ExifMnoteData *ne,
 {
 	ExifMnoteDataCanon *n = (ExifMnoteDataCanon *) ne;
 	ExifShort c;
-	unsigned int i, o, s;
+	size_t i, o, s;
+	MnoteCanonEntry *t;
 
 	if (!n || !buf || !buf_size || (buf_size < 6 + n->offset + 2)) return;
 
@@ -176,86 +206,102 @@ exif_mnote_data_canon_load (ExifMnoteData *ne,
 
 	/* Parse the entries */
 	for (i = 0; i < c; i++) {
-	    o = 6 + 2 + n->offset + 12 * i;
-	    if (o + 8 > buf_size) return;
-
-	    n->count = i + 1;
-	    n->entries = exif_mem_realloc (ne->mem, n->entries,
-					   sizeof (MnoteCanonEntry) * (i+1));
-	    memset (&n->entries[i], 0, sizeof (MnoteCanonEntry));
-	    n->entries[i].tag        = exif_get_short (buf + o, n->order);
-	    n->entries[i].format     = exif_get_short (buf + o + 2, n->order);
-	    n->entries[i].components = exif_get_long (buf + o + 4, n->order);
-	    n->entries[i].order      = n->order;
-
-	    /*
-	     * Size? If bigger than 4 bytes, the actual data is not
-	     * in the entry but somewhere else (offset).
-	     */
-	    s = exif_format_get_size (n->entries[i].format) *
-		    		      n->entries[i].components;
-	    if (!s) return;
-	    o += 8;
-	    if (s > 4) o = exif_get_long (buf + o, n->order) + 6;
-	    if (o + s > buf_size) return;
-	    
-	    /* Sanity check */
-	    n->entries[i].data = exif_mem_alloc (ne->mem, sizeof (char) * s);
-	    if (!n->entries[i].data) return;
-	    n->entries[i].size = s;
-	    memcpy (n->entries[i].data, buf + o, s);
+		o = 6 + 2 + n->offset + 12 * i;
+	  if (o + 8 > buf_size) return;
+
+		t = exif_mem_realloc (ne->mem, n->entries,
+				sizeof (MnoteCanonEntry) * (i + 1));
+		if (!t) return;
+		n->count = i + 1;
+		n->entries = t;
+		memset (&n->entries[i], 0, sizeof (MnoteCanonEntry));
+	  n->entries[i].tag        = exif_get_short (buf + o, n->order);
+	  n->entries[i].format     = exif_get_short (buf + o + 2, n->order);
+	  n->entries[i].components = exif_get_long (buf + o + 4, n->order);
+	  n->entries[i].order      = n->order;
+
+	  /*
+	   * Size? If bigger than 4 bytes, the actual data is not
+	   * in the entry but somewhere else (offset).
+	   */
+	  s = exif_format_get_size (n->entries[i].format) * n->entries[i].components;
+		if (!s) return;
+		o += 8;
+		if (s > 4) o = exif_get_long (buf + o, n->order) + 6;
+		if (o + s > buf_size) return;
+
+		/* Sanity check */
+		n->entries[i].data = exif_mem_alloc (ne->mem, sizeof (char) * s);
+		if (!n->entries[i].data) return;
+		n->entries[i].size = s;
+		memcpy (n->entries[i].data, buf + o, s);
 	}
 }
 
 static unsigned int
 exif_mnote_data_canon_count (ExifMnoteData *n)
 {
-	return n ? ((ExifMnoteDataCanon *) n)->count : 0;
+	ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) n;
+	unsigned int i, c;
+
+	for (i = c = 0; dc && (i < dc->count); i++)
+		c += mnote_canon_entry_count_values (&dc->entries[i]);
+	return c;
 }
 
 static unsigned int
-exif_mnote_data_canon_get_id (ExifMnoteData *d, unsigned int n)
+exif_mnote_data_canon_get_id (ExifMnoteData *d, unsigned int i)
 {
-	ExifMnoteDataCanon *note = (ExifMnoteDataCanon *) d;
+	ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) d;
+	unsigned int m;
 
-	if (!note) return 0;
-	if (note->count <= n) return 0;
-	return note->entries[n].tag;
+	if (!dc) return 0;
+	exif_mnote_data_canon_get_tags (dc, i, &m, NULL);
+	if (m >= dc->count) return 0;
+	return dc->entries[m].tag;
 }
 
 static const char *
 exif_mnote_data_canon_get_name (ExifMnoteData *note, unsigned int i)
 {
-	ExifMnoteDataCanon *cnote = (ExifMnoteDataCanon *) note;
+	ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) note;
+	unsigned int m, s;
 
-	if (!note) return NULL;
-	if (i >= cnote->count) return NULL;
-	return mnote_canon_tag_get_name (cnote->entries[i].tag);
+	if (!dc) return NULL;
+	exif_mnote_data_canon_get_tags (dc, i, &m, &s);
+	if (m >= dc->count) return NULL;
+	return mnote_canon_tag_get_name_sub (dc->entries[m].tag, s, dc->options);
 }
 
 static const char *
 exif_mnote_data_canon_get_title (ExifMnoteData *note, unsigned int i)
 {
-	ExifMnoteDataCanon *cnote = (ExifMnoteDataCanon *) note;
+	ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) note;
+	unsigned int m, s;
 
-	if (!note) return NULL;
-	if (i >= cnote->count) return NULL;
-	return mnote_canon_tag_get_title (cnote->entries[i].tag);
+	if (!dc) return NULL;
+	exif_mnote_data_canon_get_tags (dc, i, &m, &s);
+	if (m >= dc->count) return NULL;
+	return mnote_canon_tag_get_title_sub (dc->entries[m].tag, s, dc->options);
 }
 
 static const char *
 exif_mnote_data_canon_get_description (ExifMnoteData *note, unsigned int i)
 {
-	ExifMnoteDataCanon *cnote = (ExifMnoteDataCanon *) note;
-	if (!note) return NULL;
-	if (i >= cnote->count) return NULL;
-	return mnote_canon_tag_get_description (cnote->entries[i].tag);
+	ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) note;
+	unsigned int m;
+
+	if (!dc) return NULL;
+	exif_mnote_data_canon_get_tags (dc, i, &m, NULL);
+	if (m >= dc->count) return NULL;
+	return mnote_canon_tag_get_description (dc->entries[m].tag);
 }
 
 ExifMnoteData *
-exif_mnote_data_canon_new (ExifMem *mem)
+exif_mnote_data_canon_new (ExifMem *mem, ExifDataOption o)
 {
 	ExifMnoteData *d;
+	ExifMnoteDataCanon *dc;
 
 	if (!mem) return NULL;
 
@@ -277,5 +323,7 @@ exif_mnote_data_canon_new (ExifMem *mem)
 	d->methods.get_description = exif_mnote_data_canon_get_description;
 	d->methods.get_value       = exif_mnote_data_canon_get_value;
 
+	dc = (ExifMnoteDataCanon*)d;
+	dc->options = o;
 	return d;
 }
diff --git a/src/libexif/canon/exif-mnote-data-canon.h b/src/libexif/canon/exif-mnote-data-canon.h
index a476ca0..6d46432 100644
--- a/src/libexif/canon/exif-mnote-data-canon.h
+++ b/src/libexif/canon/exif-mnote-data-canon.h
@@ -1,6 +1,6 @@
 /* exif-mnote-data-canon.h
  *
- * Copyright © 2002, 2003 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -25,6 +25,7 @@
 #include <libexif/exif-mnote-data.h>
 #include <libexif/exif-mnote-data-priv.h>
 #include <libexif/exif-mem.h>
+#include <libexif/exif-data.h>
 
 typedef struct _ExifMnoteDataCanon ExifMnoteDataCanon;
 
@@ -38,8 +39,10 @@ struct _ExifMnoteDataCanon {
 
 	ExifByteOrder order;
 	unsigned int offset;
+
+	ExifDataOption options;
 };
 
-ExifMnoteData *exif_mnote_data_canon_new (ExifMem *mem);
+ExifMnoteData *exif_mnote_data_canon_new (ExifMem *mem, ExifDataOption o);
 
 #endif /* __EXIF_MNOTE_DATA_CANON_H__ */
diff --git a/src/libexif/canon/mnote-canon-entry.c b/src/libexif/canon/mnote-canon-entry.c
index 5fa4991..2a206de 100644
--- a/src/libexif/canon/mnote-canon-entry.c
+++ b/src/libexif/canon/mnote-canon-entry.c
@@ -1,7 +1,7 @@
 /* mnote-canon-entry.c
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
- * Copyright © 2003 Matthieu Castet <mat-c@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ * Copyright (c) 2003 Matthieu Castet <mat-c@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -25,6 +25,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <math.h>
 
 #include <libexif/exif-format.h>
 #include <libexif/exif-utils.h>
@@ -32,9 +33,6 @@
 
 /* #define DEBUG */
 
-#undef  MIN
-#define MIN(a, b)  (((a) < (b)) ? (a) : (b))
-
 #define CF(format,target,v,maxlen)                              \
 {                                                               \
         if (format != target) {                                 \
@@ -67,470 +65,637 @@
 	}                                                               \
 }
 
+#define UNDEFINED 0xFF
+    
+static const struct canon_entry_table_t {
+  unsigned int subtag;
+  ExifShort value;
+  const char *name;
+} entries_settings_1 [] = {
+#ifndef NO_VERBOSE_TAG_DATA
+  { 0,  1, N_("Macro")},
+  { 0,  2, N_("Normal")},
+  { 2,  1, N_("Economy")},
+  { 2,  2, N_("Normal")},  
+  { 2,  3, N_("Fine")},
+  { 2,  4, N_("RAW")},
+  { 2,  5, N_("Superfine")},
+  { 3,  0, N_("Off")},
+  { 3,  1, N_("Auto")},
+  { 3,  2, N_("On")},
+  { 3,  3, N_("Red-eye reduction")},
+  { 3,  4, N_("Slow synchro")},
+  { 3,  5, N_("Auto + Red-eye reduction")},
+  { 3,  6, N_("On + Red-eye reduction")},
+  { 3, 16, N_("External flash")},
+  { 4,  0, N_("Single")},
+  { 4,  1, N_("Continuous")},
+  { 4,  2, N_("Movie")},
+  { 4,  3, N_("Continuous, speed priority")},
+  { 4,  4, N_("Continuous, low")},
+  { 4,  5, N_("Continuous, high")},
+  { 6,  0, N_("One-shot AF")},
+  { 6,  1, N_("AI servo AF")},
+  { 6,  2, N_("AI focus AF")},
+  { 6,  3, N_("Manual focus")},
+  { 6,  4, N_("Single")},
+  { 6,  5, N_("Continuous")},
+  { 6,  6, N_("Manual focus")},
+  { 6,  16, N_("Pan focus")},
+  { 8,  1, N_("JPEG")},
+  { 8,  2, N_("CRW+THM")},
+  { 8,  3, N_("AVI+THM")},
+  { 8,  4, N_("TIF")},
+  { 8,  5, N_("TIF+JPEG")},
+  { 8,  6, N_("CR2")},
+  { 8,  7, N_("CR2+JPEG")},
+  { 9,  0, N_("Large")},
+  { 9,  1, N_("Medium")},
+  { 9,  2, N_("Small")},
+  { 9,  5, N_("Medium 1")},
+  { 9,  6, N_("Medium 2")},
+  { 9,  7, N_("Medium 3")},
+  { 9,  8, N_("Postcard")},
+  { 9,  9, N_("Widescreen")},
+  {10,  0, N_("Full auto")},
+  {10,  1, N_("Manual")},
+  {10,  2, N_("Landscape")},
+  {10,  3, N_("Fast shutter")},
+  {10,  4, N_("Slow shutter")},
+  {10,  5, N_("Night")},
+  {10,  6, N_("Grayscale")},
+  {10,  7, N_("Sepia")},
+  {10,  8, N_("Portrait")},
+  {10,  9, N_("Sports")},
+  {10, 10, N_("Macro")},
+  {10, 11, N_("Black & white")},
+  {10, 12, N_("Pan focus")},
+  {10, 13, N_("Vivid")},
+  {10, 14, N_("Neutral")},
+  {10, 15, N_("Flash off")},
+  {10, 16, N_("Long shutter")},
+  {10, 17, N_("Super macro")},
+  {10, 18, N_("Foliage")},
+  {10, 19, N_("Indoor")},
+  {10, 20, N_("Fireworks")},
+  {10, 21, N_("Beach")},
+  {10, 22, N_("Underwater")},
+  {10, 23, N_("Snow")},
+  {10, 24, N_("Kids & pets")},
+  {10, 25, N_("Night snapshot")},
+  {10, 26, N_("Digital macro")},
+  {10, 27, N_("My colors")},
+  {10, 28, N_("Still image")},
+  {10, 30, N_("Color accent")},
+  {10, 31, N_("Color swap")},
+  {10, 32, N_("Aquarium")},
+  {10, 33, N_("ISO 3200")},
+  {11, 0, N_("None")},
+  {11, 1, N_("2x")},
+  {11, 2, N_("4x")},
+  {11, 3, N_("Other")},
+  {12, 0x0000, N_("Normal")},
+  {12, 0x0001, N_("High")},
+  {12, 0xffff, N_("Low")},
+  {13, 0x0000, N_("Normal")},
+  {13, 0x0001, N_("High")},
+  {13, 0xffff, N_("Low")},
+  {14, 0x0000, N_("Normal")},
+  {14, 0x0001, N_("High")},
+  {14, 0xffff, N_("Low")},
+  {15, 14, N_("Auto high")},
+  {15, 15, N_("Auto")},
+  {15, 16, N_("50")},
+  {15, 17, N_("100")},
+  {15, 18, N_("200")},
+  {15, 19, N_("400")},
+  {15, 20, N_("800")},
+  {16,  0, N_("Default")},
+  {16,  1, N_("Spot")},
+  {16,  2, N_("Average")},	
+  {16,  3, N_("Evaluative")},
+  {16,  4, N_("Partial")},
+  {16,  5, N_("Center-weighted average")},
+  {17,  0, N_("Manual")},
+  {17,  1, N_("Auto")},
+  {17,  2, N_("Not known")},
+  {17,  3, N_("Macro")},
+  {17,  4, N_("Very close")},
+  {17,  5, N_("Close")},
+  {17,  6, N_("Middle range")},
+  {17,  7, N_("Far range")},
+  {17,  8, N_("Pan focus")},
+  {17,  9, N_("Super macro")},
+  {17,  10, N_("Infinity")},
+  {18, 0x2005, N_("Manual AF point selection")},
+  {18, 0x3000, N_("None (MF)")},
+  {18, 0x3001, N_("Auto-selected")},
+  {18, 0x3002, N_("Right")},
+  {18, 0x3003, N_("Center")},
+  {18, 0x3004, N_("Left")},
+  {18, 0x4001, N_("Auto AF point selection")},
+  {19,  0, N_("Easy shooting")},
+  {19,  1, N_("Program")},
+  {19,  2, N_("Tv-priority")},
+  {19,  3, N_("Av-priority")},
+  {19,  4, N_("Manual")},
+  {19,  5, N_("A-DEP")},
+  {19,  6, N_("M-DEP")},
+  {21,   1, N_("Canon EF 50mm f/1.8")},
+  {21,   2, N_("Canon EF 28mm f/2.8")},
+  {21,   4, N_("Sigma UC Zoom 35-135mm f/4-5.6")},
+  {21,   6, N_("Tokina AF193-2 19-35mm f/3.5-4.5")},
+  {21,   7, N_("Canon EF 100-300mm F5.6L")},
+  {21,  10, N_("Sigma 50mm f/2.8 EX or 28mm f/1.8")},
+  {21,  11, N_("Canon EF 35mm f/2")},
+  {21,  13, N_("Canon EF 15mm f/2.8")},
+  {21,  21, N_("Canon EF 80-200mm f/2.8L")},
+  {21,  22, N_("Tokina AT-X280AF PRO 28-80mm F2.8 ASPHERICAL")},
+  {21,  26, N_("Cosina 100mm f/3.5 Macro AF")},
+  {21,  28, N_("Tamron AF Aspherical 28-200mm f/3.8-5.6")},
+  {21,  29, N_("Canon EF 50mm f/1.8 MkII")},
+  {21,  31, N_("Tamron SP AF 300mm f/2.8 LD IF")},
+  {21,  32, N_("Canon EF 24mm f/2.8 or Sigma 15mm f/2.8 EX Fisheye")},
+  {21,  39, N_("Canon EF 75-300mm f/4-5.6")},
+  {21,  40, N_("Canon EF 28-80mm f/3.5-5.6")},
+  {21,  43, N_("Canon EF 28-105mm f/4-5.6")},
+  {21,  45, N_("Canon EF-S 18-55mm f/3.5-5.6")},
+  {21, 124, N_("Canon MP-E 65mm f/2.8 1-5x Macro Photo")},
+  {21, 125, N_("Canon TS-E 24mm f/3.5L")},
+  {21, 126, N_("Canon TS-E 45mm f/2.8")},
+  {21, 127, N_("Canon TS-E 90mm f/2.8")},
+  {21, 130, N_("Canon EF 50mm f/1.0L")},
+  {21, 131, N_("Sigma 17-35mm f2.8-4 EX Aspherical HSM")},
+  {21, 134, N_("Canon EF 600mm f/4L IS")},
+  {21, 135, N_("Canon EF 200mm f/1.8L")},
+  {21, 136, N_("Canon EF 300mm f/2.8L")},
+  {21, 137, N_("Canon EF 85mm f/1.2L")},
+  {21, 139, N_("Canon EF 400mm f/2.8L")},
+  {21, 141, N_("Canon EF 500mm f/4.5L")},
+  {21, 142, N_("Canon EF 300mm f/2.8L IS")},
+  {21, 143, N_("Canon EF 500mm f/4L IS")},
+  {21, 149, N_("Canon EF 100mm f/2")},
+  {21, 150, N_("Sigma 20mm EX f/1.8")},
+  {21, 151, N_("Canon EF 200mm f/2.8L")},
+  {21, 152, N_("Sigma 10-20mm F4-5.6 or 12-24mm f/4.5-5.6 or 14mm f/2.8")},
+  {21, 153, N_("Canon EF 35-350mm f/3.5-5.6L")},
+  {21, 155, N_("Canon EF 85mm f/1.8 USM")},
+  {21, 156, N_("Canon EF 28-105mm f/3.5-4.5 USM")},
+  {21, 160, N_("Canon EF 20-35mm f/3.5-4.5 USM")},
+  {21, 161, N_("Canon EF 28-70mm f/2.8L or Sigma 24-70mm EX f/2.8")},
+  {21, 165, N_("Canon EF 70-200mm f/2.8 L")},
+  {21, 166, N_("Canon EF 70-200mm f/2.8 L + x1.4")},
+  {21, 167, N_("Canon EF 70-200mm f/2.8 L + x2")},
+  {21, 168, N_("Canon EF 28mm f/1.8 USM")},
+  {21, 169, N_("Sigma 15-30mm f/3.5-4.5 EX DG Aspherical")},
+  {21, 170, N_("Canon EF 200mm f/2.8L II")},
+  {21, 173, N_("Canon EF 180mm Macro f/3.5L or Sigma 180mm EX HSM Macro f/3.5")},
+  {21, 174, N_("Canon EF 135mm f/2L")},
+  {21, 176, N_("Canon EF 24-85mm f/3.5-4.5 USM")},
+  {21, 177, N_("Canon EF 300mm f/4L IS")},
+  {21, 178, N_("Canon EF 28-135mm f/3.5-5.6 IS")},
+  {21, 180, N_("Canon EF 35mm f/1.4L")},
+  {21, 181, N_("Canon EF 100-400mm f/4.5-5.6L IS + x1.4")},
+  {21, 182, N_("Canon EF 100-400mm f/4.5-5.6L IS + x2")},
+  {21, 183, N_("Canon EF 100-400mm f/4.5-5.6L IS")},
+  {21, 184, N_("Canon EF 400mm f/2.8L + x2")},
+  {21, 186, N_("Canon EF 70-200mm f/4L")},
+  {21, 190, N_("Canon EF 100mm f/2.8 Macro")},
+  {21, 191, N_("Canon EF 400mm f/4 DO IS")},
+  {21, 197, N_("Canon EF 75-300mm f/4-5.6 IS")},
+  {21, 198, N_("Canon EF 50mm f/1.4")},
+  {21, 202, N_("Canon EF 28-80 f/3.5-5.6 USM IV")},
+  {21, 211, N_("Canon EF 28-200mm f/3.5-5.6")},
+  {21, 213, N_("Canon EF 90-300mm f/4.5-5.6")},
+  {21, 214, N_("Canon EF-S 18-55mm f/3.5-4.5 USM")},
+  {21, 224, N_("Canon EF 70-200mm f/2.8L IS USM")},
+  {21, 225, N_("Canon EF 70-200mm f/2.8L IS USM + x1.4")},
+  {21, 226, N_("Canon EF 70-200mm f/2.8L IS USM + x2")},
+  {21, 229, N_("Canon EF 16-35mm f/2.8L")},
+  {21, 230, N_("Canon EF 24-70mm f/2.8L")},
+  {21, 231, N_("Canon EF 17-40mm f/4L")},
+  {21, 232, N_("Canon EF 70-300mm f/4.5-5.6 DO IS USM")},
+  {21, 234, N_("Canon EF-S 17-85mm f4-5.6 IS USM")},
+  {21, 235, N_("Canon EF-S10-22mm F3.5-4.5 USM")},
+  {21, 236, N_("Canon EF-S60mm F2.8 Macro USM")},
+  {21, 237, N_("Canon EF 24-105mm f/4L IS")},
+  {21, 238, N_("Canon EF 70-300mm F4-5.6 IS USM")},
+  {21, 241, N_("Canon EF 50mm F1.2L USM")},
+  {21, 242, N_("Canon EF 70-200mm f/4L IS USM")},
+  {28, 0, N_("Manual")},
+  {28, 1, N_("TTL")},
+  {28, 2, N_("A-TTL")},
+  {28, 3, N_("E-TTL")},
+  {28, 4, N_("FP sync enabled")},
+  {28, 7, N_("2nd-curtain sync used")},
+  {28, 11, N_("FP sync used")},
+  {28, 13, N_("Internal")},
+  {28, 14, N_("External")},
+  {31,  0, N_("Single")},
+  {31,  1, N_("Continuous")},
+  {32, 0, N_("Normal AE")},
+  {32, 1, N_("Exposure compensation")},
+  {32, 2, N_("AE lock")},
+  {32, 3, N_("AE lock + Exposure compensation")},
+  {32, 4, N_("No AE")},
+  {33, 0, N_("Off")},
+  {33, 1, N_("On")},
+  {33, 2, N_("On, shot only")},
+  {39, 0, N_("Off")},
+  {39, 1, N_("Vivid")},
+  {39, 2, N_("Neutral")},
+  {39, 3, N_("Smooth")},
+  {39, 4, N_("Sepia")},
+  {39, 5, N_("Black & white")},
+  {39, 6, N_("Custom")},
+  {39, 100, N_("My color data")},
+  {40, 0, N_("Off")},
+  {40, 0x0500, N_("Full")},
+  {40, 0x0502, N_("2/3")},
+  {40, 0x0504, N_("1/3")},
+#endif
+  { 0,  0, NULL}
+},
+entries_focal_length [] = {
+#ifndef NO_VERBOSE_TAG_DATA
+	{0, 1, N_("Fixed")},
+	{0, 2, N_("Zoom")},
+#endif
+	{0, 0, NULL}
+},
+entries_settings_2 [] = {
+#ifndef NO_VERBOSE_TAG_DATA
+  { 6,  0, N_("Auto")},
+  { 6,  1, N_("Sunny")},
+  { 6,  2, N_("Cloudy")},
+  { 6,  3, N_("Tungsten")},
+  { 6,  4, N_("Fluorescent")},
+  { 6,  5, N_("Flash")},
+  { 6,  6, N_("Custom")},
+  { 6,  7, N_("Black & white")},
+  { 6,  8, N_("Shade")},
+  { 6,  9, N_("Manual temperature (Kelvin)")},
+  { 6,  10, N_("PC set 1")},
+  { 6,  11, N_("PC set 2")},
+  { 6,  12, N_("PC set 3")},
+  { 6,  14, N_("Daylight fluorescent")},
+  { 6,  15, N_("Custom 1")},
+  { 6,  16, N_("Custom 2")},
+  { 6,  17, N_("Underwater")},
+  { 7,  0, N_("Off")},
+  { 7,  1, N_("Night scene")},
+  { 7,  2, N_("On")},
+  { 7,  3, N_("None")},
+  { 13,  0x3000, N_("None (MF)")},
+  { 13,  0x3001, N_("Right")},
+  { 13,  0x3002, N_("Center")},
+  { 13,  0x3003, N_("Center + Right")},
+  { 13,  0x3004, N_("Left")},
+  { 13,  0x3005, N_("Left + Right")},
+  { 13,  0x3006, N_("Left + Center")},
+  { 13,  0x3007, N_("All")},
+  { 15,  0, N_("Off")},
+  { 15,  1, N_("On (shot 1)")},
+  { 15,  2, N_("On (shot 2)")},
+  { 15,  3, N_("On (shot 3)")},
+  { 15,  0xffff, N_("On")},
+  { 25,  248, N_("EOS high-end")},
+  { 25,  250, N_("Compact")},
+  { 25,  252, N_("EOS mid-range")},
+  { 26,  0, N_("None")},
+  { 26,  1, N_("Rotate 90 CW")},
+  { 26,  2, N_("Rotate 180")},
+  { 26,  3, N_("Rotate 270 CW")},
+  { 26,  0xffff, N_("Rotated by software")},
+  { 27,  0, N_("Off")},
+  { 27,  1, N_("On")}, 
+  { 32,  0, N_("Off")},
+  { 32,  0x0014, N_("1/3")},
+  { 32,  0x008c, N_("2/3")},
+  { 32,  0x07d0, N_("Full")},
+#endif
+  {0, 0, NULL}
+},
+entries_panorama [] = {
+#ifndef NO_VERBOSE_TAG_DATA
+	{0, 0, N_("Left to right")},
+	{0, 1, N_("Right to left")},
+	{0, 2, N_("Bottom to top")},
+	{0, 3, N_("Top to bottom")},
+	{0, 4, N_("2x2 matrix (clockwise)")},
+#endif
+	{0, 0, NULL}
+},
+color_information [] = {
+#ifndef NO_VERBOSE_TAG_DATA
+  {0, 0, N_("Standard")},
+  {0, 1, N_("Manual")},
+  {0, 2, N_("Custom")},
+  {2, 0, N_("N/A")},
+  {2, 1, N_("Lowest")},
+  {2, 2, N_("Low")},
+  {2, 3, N_("Standard")},
+  {2, 4, N_("High")},
+  {2, 5, N_("Highest")},
+  {7,  0, N_("Auto")},
+  {7,  1, N_("Daylight")},
+  {7,  2, N_("Cloudy")},
+  {7,  3, N_("Tungsten")},
+  {7,  4, N_("Fluorescent")},
+  {7,  5, N_("Flash")},
+  {7,  6, N_("Custom")},
+  {7,  7, N_("Black & White")},
+  {7,  8, N_("Shade")},
+  {7,  9, N_("Manual Temperature (Kelvin)")},
+  {7, 10, N_("PC Set1")},
+  {7, 11, N_("PC Set2")},
+  {7, 12, N_("PC Set3")},
+  {7, 14, N_("Daylight Fluorescent")},
+  {7, 15, N_("Custom 1")},
+  {7, 16, N_("Custom 2")},
+  {7, 17, N_("Underwater")},
+  {9, 0x00, N_("None")},
+  {9, 0x01, N_("Standard")},
+  {9, 0x02, N_("Set 1")},
+  {9, 0x03, N_("Set 2")},
+  {9, 0x04, N_("Set 3")},
+  {9, 0x21, N_("User Def. 1")},
+  {9, 0x22, N_("User Def. 2")},
+  {9, 0x23, N_("User Def. 3")},
+  {9, 0x41, N_("External 1")},
+  {9, 0x42, N_("External 2")},
+  {9, 0x43, N_("External 3")},
+  {9, 0x81, N_("Standard")},
+  {9, 0x82, N_("Portrait")},
+  {9, 0x83, N_("Landscape")},
+  {9, 0x84, N_("Neutral")},
+  {9, 0x85, N_("Faithful")},
+  {9, 0x86, N_("Monochrome")},
+#endif
+  {0, 0, NULL}
+};
+
+static void
+canon_search_table_value (const struct canon_entry_table_t table[],
+    unsigned int t, ExifShort vs, char *val, unsigned int maxlen)
+{
+	unsigned int j;
+
+	/* Search the table for the first matching subtag and value. */
+	for (j = 0; table[j].name && ((table[j].subtag < t) ||
+			((table[j].subtag == t) && table[j].value <= vs)); j++) {
+		if ((table[j].subtag == t) && (table[j].value == vs)) {
+			break;
+		}
+	}
+	if ((table[j].subtag == t) && (table[j].value == vs) && table[j].name) {
+		/* Matching subtag and value found. */
+		strncpy (val, _(table[j].name), maxlen);
+	} else {
+		/* No matching subtag and/or value found. */
+		snprintf (val, maxlen, "0x%04x", vs);
+	}
+}
+
+static void
+canon_search_table_bitfield (const struct canon_entry_table_t table[],
+    unsigned int t, ExifShort vs, char *val, unsigned int maxlen)
+{
+	unsigned int j;
+
+	/* Search the table for the first matching subtag. */
+	for (j = 0; table[j].name && (table[j].subtag <= t); j++) {
+		if (table[j].subtag == t) {
+			break;
+		}
+	}
+	if ((table[j].subtag == t) && table[j].name) {
+		unsigned int i, bit, lastbit = 0;
+
+		/*
+		 * Search the table for the last matching bit, because
+		 * that one needs no additional comma appended.
+		 */
+		for (i = j; table[i].name && (table[i].subtag == t); i++) {
+			bit = table[i].value;
+			if ((vs >> bit) & 1) {
+				lastbit = bit;
+			}
+		}
+		/* Search the table for all matching bits. */
+		for (i = j; table[i].name && (table[i].subtag == t); i++) {
+			bit = table[i].value;
+			if ((vs >> bit) & 1) {
+				strncat(val, table[i].name, maxlen - strlen (val));
+				if (bit != lastbit) 
+					strncat (val, N_(", "), maxlen - strlen (val));
+			}
+		}
+	} else {
+		/* No matching subtag found. */
+		snprintf (val, maxlen, "0x%04x", vs);
+	}
+}
+
+unsigned int
+mnote_canon_entry_count_values (const MnoteCanonEntry *entry)
+{
+	unsigned int  val;
+
+	if (!entry) return 0;
+
+	switch (entry->tag) {
+	case MNOTE_CANON_TAG_FOCAL_LENGTH:
+	case MNOTE_CANON_TAG_PANORAMA:
+		return entry->components;
+	case MNOTE_CANON_TAG_SETTINGS_1:
+	case MNOTE_CANON_TAG_SETTINGS_2:
+	case MNOTE_CANON_TAG_CUSTOM_FUNCS:
+	case MNOTE_CANON_TAG_COLOR_INFORMATION:
+		if (entry->format != EXIF_FORMAT_SHORT) return 0;
+
+		val = exif_get_short (entry->data, entry->order);
+		/* val is buffer size, i.e. # of values plus 1 */
+		return MIN (entry->size - 2, val) / 2;
+	default:
+		return 1;
+	}
+}
+
+/*
+ * For reference, see Exif 2.1 specification (Appendix C), 
+ * or http://en.wikipedia.org/wiki/APEX_system
+ */
+static double
+apex_value_to_aperture (double x)
+{
+	return pow (2, x / 2.);
+}
+
+static double
+apex_value_to_shutter_speed(double x)
+{
+	return 1.0 / pow (2, x);
+}
+
+static double
+apex_value_to_iso_speed (double x)
+{
+	return 3.125 * pow (2, x);
+}
+
 char *
-mnote_canon_entry_get_value (const MnoteCanonEntry *entry, char *val, unsigned int maxlen)
+mnote_canon_entry_get_value (const MnoteCanonEntry *entry, unsigned int t, char *val, unsigned int maxlen)
 {
-    char buf[128];
-    ExifLong vl;
-    ExifShort vs, n;
-    int i;
-    unsigned char *data = entry->data;
+	char buf[128];
+	ExifLong vl;
+	ExifShort vs, n;
+	unsigned char *data;
+	double d;
 
-    if (!entry) return NULL;
+	if (!entry) 
+		return NULL;
 
-    memset (val, 0, maxlen);
-    maxlen--;
+	data = entry->data;
+
+	memset (val, 0, maxlen);
+	maxlen--;
 
 	switch (entry->tag) {
 	case MNOTE_CANON_TAG_SETTINGS_1:
 		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 		n = exif_get_short (data, entry->order) / 2;
-		data += 2;
+		if (t >= n) return NULL;
 		CC (entry->components, n, val, maxlen);
-		for (i = 1; i < n; i++) {
-		    vs = exif_get_short (data, entry->order);
-		    data += 2;
-		    switch (i) {
-		    case 1:
-			strncpy (val, _("Macro mode : "), maxlen);
-			switch (vs) {
-			case 1:
-			    strncat (val, _("Macro"), maxlen - strlen(val));
-			    break;
-			case 2:
-			    strncat (val, _("Normal"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
-			break;
-		    case 2:
-			if (vs) {
-				snprintf (buf, sizeof (buf),
-					_(" / Self Timer : %i (ms)"), vs*100);
-				strncat (val, buf, maxlen - strlen(val));
+		vs = exif_get_short (data + 2 + t * 2, entry->order);
+		switch (t) {
+		case 1:
+			if (!vs) {
+				strncpy(val, _("Off"), maxlen);
+				break;
 			}
+			snprintf (val, maxlen, _("%i (ms)"), vs * 100);
 			break;
-		    case 4:
-			strncat (val, _(" / Flash mode : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0:
-			    strncat (val, _("Flash not fired"), maxlen - strlen(val));
-			    break;
-			case 1:
-			    strncat (val, _("auto"), maxlen - strlen(val));
-			    break;
-			case 2:
-			    strncat (val, _("on"), maxlen - strlen(val));
-			    break;
-			case 3:
-			    strncat (val, _("red eyes reduction"), maxlen - strlen(val));
-			    break;
-			case 4:
-			    strncat (val, _("slow synchro"), maxlen - strlen(val));
-			    break;
-			case 5:
-			    strncat (val, _("auto + red eyes reduction"), maxlen - strlen(val));
-			    break;
-			case 6:
-			    strncat (val, _("on + red eyes reduction"), maxlen - strlen(val));
-			    break;
-			case 16:
-			    strncat (val, _("external"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
+		case 15:
+			if (((vs & 0xC000) == 0x4000) && (vs != 0x7FFF)) {
+				/* Canon S3 IS - directly specified value */
+				snprintf (val, maxlen, _("%i"), vs & ~0x4000);
+			} else {
+				/* Standard Canon - index into lookup table */
+				canon_search_table_value (entries_settings_1, t, vs, val, maxlen);
 			}
 			break;
-		    case 5:
-			strncat (val, _(" / Continuous drive mode : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0:
-			    strncat (val, _("single or timer"), maxlen - strlen(val));
-			    break;
-			case 1:
-			    strncat (val, _("continuous"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
+		case 22:
+		case 23:
+		case 24:
+			snprintf (val, maxlen, "%u", vs);
 			break;
-		    case 7:
-			strncat (val, _(" / Focus mode : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0:
-			    strncat (val, _("One-Shot"), maxlen - strlen(val));
-			    break;
-			case 1:
-			    strncat (val, _("AI Servo"), maxlen - strlen(val));
-			    break;
-			case 2:
-			    strncat (val, _("AI Focus"), maxlen - strlen(val));
-			    break;
-			case 3:
-			    strncat (val, _("MF"), maxlen - strlen(val));
-			    break;
-			case 4:
-			    strncat (val, _("Single"), maxlen - strlen(val));
-			    break;
-			case 5:
-			    strncat (val, _("Continuous"), maxlen - strlen(val));
-			    break;
-			case 6:
-			    strncat (val, _("MF"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
+		case 25:
+		case 26:
+			snprintf (val, maxlen, "%.2f", apex_value_to_aperture (vs / 32.0));
 			break;
-		    case 10:
-			strncat (val, _(" / Image size : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0:
-			    strncat (val, _("Large"), maxlen - strlen(val));
-			    break;
-			case 1:
-			    strncat (val, _("Medium"), maxlen - strlen(val));
-			    break;
-			case 2:
-			    strncat (val, _("Small"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
+		case 28:
+			canon_search_table_bitfield(entries_settings_1, t, vs, val, maxlen);
 			break;
-		    case 11:
-			strncat (val, _(" / Easy shooting mode : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0:
-			    strncat (val, _("Full Auto"), maxlen - strlen(val));
-			    break;
-			case 1:
-			    strncat (val, _("Manual"), maxlen - strlen(val));
-			    break;
-			case 2:
-			    strncat (val, _("Landscape"), maxlen - strlen(val));
-			    break;
-			case 3:
-			    strncat (val, _("Fast Shutter"), maxlen - strlen(val));
-			    break;
-			case 4:
-			    strncat (val, _("Slow Shutter"), maxlen - strlen(val));
-			    break;
-			case 5:
-			    strncat (val, _("Night"), maxlen - strlen(val));
-			    break;
-			case 6:
-			    strncat (val, _("Black & White"), maxlen - strlen(val));
-			    break;
-			case 7:
-			    strncat (val, _("Sepia"), maxlen - strlen(val));
-			    break;
-			case 8:
-			    strncat (val, _("Portrait"), maxlen - strlen(val));
-			    break;
-			case 9:
-			    strncat (val, _("Sports"), maxlen - strlen(val));
-			    break;
-			case 10:
-			    strncat (val, _("Macro / Close-Up"), maxlen - strlen(val));
-			    break;
-			case 11:
-			    strncat (val, _("Pan Focus"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
+		case 34:
+			snprintf (val, maxlen, "%.2f", vs / 10.0);
 			break;
-		    case 13:
-			strncat (val, _(" / Contrast : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0xffff:
-			    strncat (val, _("Low"), maxlen - strlen(val));
-			    break;
-			case 0x0000:
-			    strncat (val, _("Normal"), maxlen - strlen(val));
-			    break;
-			case 0x0001:
-			    strncat (val, _("High"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
+		case 35:
+		case 36:
+			snprintf (val, maxlen, "%u", vs);
 			break;
-		    case 14:
-			strncat (val, _(" / Saturation : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0xffff:
-			    strncat (val, _("Low"), maxlen - strlen(val));
-			    break;
-			case 0x0000:
-			    strncat (val, _("Normal"), maxlen - strlen(val));
-			    break;
-			case 0x0001:
-			    strncat (val, _("High"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
-			break;
-		    case 15:
-			strncat (val, _(" / Sharpness : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0xffff:
-			    strncat (val, _("Low"), maxlen - strlen(val));
-			    break;
-			case 0x0000:
-			    strncat (val, _("Normal"), maxlen - strlen(val));
-			    break;
-			case 0x0001:
-			    strncat (val, _("High"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
-			break;
-		    case 16:
-			if (vs) {
-			    strncat (val, _(" / ISO : "), maxlen - strlen(val));
-			    switch (vs) {
-			    case 15:
-				strncat (val, _("auto"), maxlen - strlen(val));
-				break;
-			    case 16:
-				strncat (val, _("50"), maxlen - strlen(val));
-				break;
-			    case 17:
-				strncat (val, _("100"), maxlen - strlen(val));
-				break;
-			    case 18:
-				strncat (val, _("200"), maxlen - strlen(val));
-				break;
-			    case 19:
-				strncat (val, _("400"), maxlen - strlen(val));
-				break;
-			    default:
-				snprintf (buf, sizeof (buf), _("%i???"), vs);
-				strncat (val, buf, maxlen - strlen(val));
-			    }
-			    break;
-			}
-		    case 17:
-			strncat (val, _(" / Metering mode : "), maxlen - strlen(val));
-			switch (vs) {
-			case 3:
-			    strncat (val, _("Evaluative"), maxlen - strlen(val));
-			    break;
-			case 4:
-			    strncat (val, _("Partial"), maxlen - strlen(val));
-			    break;
-			case 5:
-			    strncat (val, _("Center-weighted"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("%i???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
+		default:
+			canon_search_table_value (entries_settings_1, t, vs, val, maxlen);
+		}
+		break;
+
+	case MNOTE_CANON_TAG_FOCAL_LENGTH:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+		vs = exif_get_short (data + t * 2, entry->order);
+		switch (t) {
+		case 1:
+			snprintf (val, maxlen, "%u", vs);
 			break;
-		    case 19:
-			strncat (val, _(" / AF point selected : "), maxlen - strlen(val));
-			switch (vs) {
-			case 0x3000:
-			    strncat (val, _("none (MF)"), maxlen - strlen(val));
-			    break;
-			case 0x3001:
-			    strncat (val, _("auto-selected"), maxlen - strlen(val));
-			    break;
-			case 0x3002:
-			    strncat (val, _("right"), maxlen - strlen(val));
-			    break;
-			case 0x3003:
-			    strncat (val, _("center"), maxlen - strlen(val));
-			    break;
-			case 0x3004:
-			    strncat (val, _("left"), maxlen - strlen(val));
-			    break;
-			default:
-			    snprintf (buf, sizeof (buf), _("0x%x???"), vs);
-			    strncat (val, buf, maxlen - strlen(val));
-			}
+		case 2:
+		case 3:
+			snprintf (val, maxlen, _("%.2f mm"), vs * 25.4 / 1000);
 			break;
-		    case 20:
-				strncat (val, _(" / Exposure mode : "), maxlen - strlen(val));
-				switch (vs) {
-           		case 0:
-					strncat (val, _("Easy shooting"), maxlen - strlen(val));
-                    break;
-                case 1:
-					strncat (val, _("Program"), maxlen - strlen(val));
-					break;
-				case 2:
-					strncat (val, _("Tv-priority"), maxlen - strlen(val));
-					break;
-				case 3:
-					strncat (val, _("Av-priority"), maxlen - strlen(val));
-					break;
-				case 4:
-					strncat (val, _("Manual"), maxlen - strlen(val));
-					break;
-				case 5:
-					strncat (val, _("A-DEP"), maxlen - strlen(val));
-					break;
-				default:
-					snprintf (buf, sizeof (buf), _("%i???"), vs);
-					strncat (val, buf, maxlen - strlen(val));
-                }
-				break;
-			case 23:
-				snprintf (buf, sizeof (buf), _(" / long focal length of lens (in focal units) : %u"), vs);
-				strncat (val, buf, maxlen - strlen(val));
-				break;
-			case 24:
-				snprintf (buf, sizeof (buf), _(" / short focal length of lens (in focal units) : %u"), vs);
-				strncat (val, buf, maxlen - strlen(val));
-				break;
-			case 25:
-				snprintf (buf, sizeof (buf), _(" / focal units per mm : %u"), vs);
-				strncat (val, buf, maxlen - strlen(val));
-				break;
-			case 29:
-				strncat (val, _(" / Flash details : "), maxlen - strlen(val));
-				if ((vs>>14)&1)
-					strncat (val, _("External E-TTL"), maxlen - strlen(val));
-				if ((vs>>13)&1)
-					strncat (val, _("Internal flash"), maxlen - strlen(val));
-				if ((vs>>11)&1)
-					strncat (val, _("FP sync used"), maxlen - strlen(val));
-				if ((vs>>4)&1)
-					strncat (val, _("FP sync enabled"), maxlen - strlen(val));
-#ifdef DEBUG
-				printf ("Value29=0x%08x\n", vs);
-#endif
-				break;
-			case 32:
-				strncat (val, _(" / Focus mode2 : "), maxlen - strlen(val));
-				switch (vs) {
-				case 0:
-					strncat (val, _("Single"), maxlen - strlen(val));
-					break;
-				case 1:
-					strncat (val, _("Continuous"), maxlen - strlen(val));
-					break;
-				default:
-					snprintf (buf, sizeof (buf), _("%i???"), vs);
-					strncat (val, buf, maxlen - strlen(val));
-				}
-				break;
-#ifdef DEBUG
-			default:
-                        	printf ("Value%d=%d\n", i, vs);
-#endif
-			}
+		default:
+			canon_search_table_value (entries_focal_length, t, vs, val, maxlen);
 		}
-
-                break;
+		break;
 
 	case MNOTE_CANON_TAG_SETTINGS_2:
 		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-		n = exif_get_short (data, entry->order)/2;
-		data += 2;
+		n = exif_get_short (data, entry->order) / 2;
+		if (t >= n) return NULL;
 		CC (entry->components, n, val, maxlen);
-#ifdef DEBUG
-		printf ("Setting2 size %d %d\n",n,entry->size);
-#endif
-		for (i=1;i<n;i++)
-		{
-			vs = exif_get_short (data, entry->order);
-			data+=2;
-			switch(i) {
-			case 7:
-				strncpy (val, _("White balance : "), maxlen - strlen(val));
-				switch (vs) {
-				case 0:
-					strncat (val, _("Auto"), maxlen - strlen(val));
-					break;
-				case 1:
-					strncat (val, _("Sunny"), maxlen - strlen(val));
-					break;
-				case 2:
-					strncat (val, _("Cloudy"), maxlen - strlen(val));
-					break;
-				case 3:
-					strncat (val, _("Tungsten"), maxlen - strlen(val));
-					break;
-				case 4:
-					strncat (val, _("Flourescent"), maxlen - strlen(val));
-					break;
-				case 5:
-					strncat (val, _("Flash"), maxlen - strlen(val));
-					break;
-				case 6:
-					strncat (val, _("Custom"), maxlen - strlen(val));
-					break;
-				default:
-					snprintf (buf, sizeof (buf), _("%i???"), vs);
-					strncat (val, buf, maxlen - strlen(val));
-				}
-				break;
-			case 9:
-				snprintf (buf, sizeof (buf), _(" / Sequence number : %u"), vs);
-				strncat (val, buf, maxlen - strlen(val));
-				break;
-			case 14:
-				if (vs>>12)
-				{
-					strncat (val, _(" / AF point used : "), maxlen - strlen(val));
-					if (vs&1)
-						strncat (val, _("Right"), maxlen - strlen(val));
-					if ((vs>>1)&1)
-						strncat (val, _("Center"), maxlen - strlen(val));
-					if ((vs>>2)&1)
-						strncat (val, _("Left"), maxlen - strlen(val));
-					snprintf (buf, sizeof (buf), _(" (%u available focus point)"), vs>>12);
-					strncat (val, buf, maxlen - strlen(val));
-				}
-#ifdef DEBUG
-					printf ("0x%08x\n", vs);
-#endif
-				break;
-			case 15:
-				snprintf (buf, sizeof (buf), _(" / Flash bias : %.2f EV"), vs/32.0);
-				strncat (val, buf, maxlen - strlen(val));
-
-				break;
-			case 19:
-				snprintf (buf, sizeof (buf), _(" / Subject Distance (mm) : %u"), vs);
-				strncat (val, buf, maxlen - strlen(val));
+		vs = exif_get_short (data + 2 + t * 2, entry->order);
+		switch (t) {
+		case 0:
+			snprintf (val, maxlen, "%.3f", pow (2, (ExifSShort)vs / 32.0));
+			break;
+		case 1:
+			snprintf (val, maxlen, "%.0f", apex_value_to_iso_speed ((ExifSShort)vs / 32.0));
+			break;
+		case 2:
+		case 5:
+		case 14:
+		case 16:
+			snprintf (val, maxlen, _("%.2f EV"), vs / 32.0);
+			break;
+		case 3:
+		case 20:
+			snprintf (val, maxlen, "%.2f", apex_value_to_aperture (vs / 32.0));
+			break;
+		case 4:
+		case 21:
+			d = apex_value_to_shutter_speed ((ExifSShort)vs / 32.0);
+			if (d < 1)
+				snprintf (val, maxlen, _("1/%d"),(int)(1.0 / d));
+			else
+				snprintf (val, maxlen, _("%d"), (int) d);
+			break;
+		case 8:
+			snprintf (val, maxlen, "%u", vs);
+			break;
+		case 12:
+			snprintf (val, maxlen, "%.2f", vs / 32.0);
+			break;
+		case 18:
+		case 19:
+			snprintf (val, maxlen, _("%u mm"), vs);
+			break;
+		case 28:
+			if ((ExifSShort)vs <= 0) {
+				strncpy(val, _("Off"), maxlen);
 				break;
-#ifdef DEBUG
-			default:
-				printf ("Value%d=%d\n", i, vs);
-#endif
 			}
+			snprintf (val, maxlen, _("%i (ms)"), vs * 100);
+			break;
+		default:
+			canon_search_table_value (entries_settings_2, t, vs, val, maxlen);
 		}
+		break;
 
+	case MNOTE_CANON_TAG_PANORAMA:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+		vs = exif_get_short (data + t * 2, entry->order);
+		canon_search_table_value (entries_panorama, t, vs, val, maxlen);
 		break;
 
-	case MNOTE_CANON_TAG_IMAGE_TYPE:
 	case MNOTE_CANON_TAG_OWNER:
-		CF (entry->format, EXIF_FORMAT_ASCII, val, maxlen);
 		CC (entry->components, 32, val, maxlen);
-		strncpy (val, data, MIN (entry->size, maxlen));
+		/* Fall through; ImageType can have many sizes */
+	case MNOTE_CANON_TAG_IMAGE_TYPE:
+		CF (entry->format, EXIF_FORMAT_ASCII, val, maxlen);
+		strncpy (val, (char *)data, MIN (entry->size, maxlen));
 		break;
 
 	case MNOTE_CANON_TAG_FIRMWARE:
 		CF (entry->format, EXIF_FORMAT_ASCII, val, maxlen);
-		CC2 (entry->components, 24, 32, val, maxlen);
-		strncpy (val, data, MIN (entry->size, maxlen));
+/*		CC2 (entry->components, 24, 32, val, maxlen); Can also be 22 */
+		strncpy (val, (char *)data, MIN (entry->size, maxlen));
 		break;
 
 	case MNOTE_CANON_TAG_IMAGE_NUMBER:
@@ -551,23 +716,27 @@ mnote_canon_entry_get_value (const MnoteCanonEntry *entry, char *val, unsigned i
 
 	case MNOTE_CANON_TAG_CUSTOM_FUNCS:
 		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-		n = exif_get_short (data, entry->order)/2;
-		data+=2;
+		n = exif_get_short (data, entry->order) / 2;
+		if (t >= n) return NULL;
 		CC (entry->components, n, val, maxlen);
-#ifdef DEBUG
-		printf ("Custom Function size %d %d\n",n,entry->size);
-#endif
-		for (i=1;i<n;i++)
-		{
-			vs = exif_get_short (data, entry->order);
-			data += 2;
-			snprintf (buf, sizeof(buf), _("C.F%d : %u"), i, vs);
-			strncat (val, buf, maxlen - strlen(val));
-		}
+		vs = exif_get_short (data + 2 + t * 2, entry->order);
+		snprintf (buf, sizeof (buf), "%u", vs);
+		strncat (val, buf, maxlen - strlen (val));
+		break;
+
+	case MNOTE_CANON_TAG_COLOR_INFORMATION:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+		n = exif_get_short (data, entry->order) / 2;
+		if (t >= n) return NULL;
+		CC (entry->components, n, val, maxlen);
+		vs = exif_get_short (data + 2 + t * 2, entry->order);
+		canon_search_table_value (color_information, t, vs, val, maxlen);
 		break;
 
 	default:
 #ifdef DEBUG
+	  {
+		int i;
 		if (entry->format == EXIF_FORMAT_SHORT)
 		for(i=0;i<entry->components;i++) {
 			vs = exif_get_short (data, entry->order);
@@ -582,9 +751,9 @@ mnote_canon_entry_get_value (const MnoteCanonEntry *entry, char *val, unsigned i
 		}
 		else if (entry->format == EXIF_FORMAT_ASCII)
 		    strncpy (val, data, MIN (entry->size, maxlen));
+	  }
 #endif
 		break;
-        }
-
-        return val;
+	}
+	return val;
 }
diff --git a/src/libexif/canon/mnote-canon-entry.h b/src/libexif/canon/mnote-canon-entry.h
index 62345d8..e78c639 100644
--- a/src/libexif/canon/mnote-canon-entry.h
+++ b/src/libexif/canon/mnote-canon-entry.h
@@ -1,6 +1,6 @@
 /* mnote-canon-entry.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -38,6 +38,7 @@ struct _MnoteCanonEntry {
 	ExifByteOrder order;
 };
 
-char *mnote_canon_entry_get_value (const MnoteCanonEntry *entry, char *val, unsigned int maxlen);
+unsigned int mnote_canon_entry_count_values (const MnoteCanonEntry *);
+char        *mnote_canon_entry_get_value    (const MnoteCanonEntry *, unsigned int t, char *val, unsigned int maxlen);
 
 #endif /* __MNOTE_CANON_ENTRY_H__ */
diff --git a/src/libexif/canon/mnote-canon-tag.c b/src/libexif/canon/mnote-canon-tag.c
index 890a5fc..447caab 100644
--- a/src/libexif/canon/mnote-canon-tag.c
+++ b/src/libexif/canon/mnote-canon-tag.c
@@ -1,6 +1,6 @@
 /* mnote-canon-tag.c
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -25,34 +25,137 @@
 
 #include <libexif/i18n.h>
 
-static struct {
+static const struct {
 	MnoteCanonTag tag;
 	const char *name;
 	const char *title;
 	const char *description;
 } table[] = {
+#ifndef NO_VERBOSE_TAG_STRINGS
 	{MNOTE_CANON_TAG_SETTINGS_1, "Settings1", N_("Settings (first part)"), ""},
+	{MNOTE_CANON_TAG_FOCAL_LENGTH, "FocalLength", N_("Focal length"), ""},
 	{MNOTE_CANON_TAG_SETTINGS_2, "Settings2", N_("Settings (second part)"), ""},
+	{MNOTE_CANON_TAG_PANORAMA, "Panorama", N_("Panorama"), ""},
 	{MNOTE_CANON_TAG_IMAGE_TYPE, "ImageType", N_("Image type"), ""},
 	{MNOTE_CANON_TAG_FIRMWARE, "FirmwareVersion", N_("Firmware version"), ""},
 	{MNOTE_CANON_TAG_IMAGE_NUMBER, "ImageNumber", N_("Image number"), ""},
 	{MNOTE_CANON_TAG_OWNER, "OwnerName", N_("Owner name"), ""},
+	{MNOTE_CANON_TAG_COLOR_INFORMATION, "ColorInformation", N_("Color information"), ""},
 	{MNOTE_CANON_TAG_SERIAL_NUMBER, "SerialNumber", N_("Serial number"), ""},
 	{MNOTE_CANON_TAG_CUSTOM_FUNCS, "CustomFunctions", N_("Custom functions"), ""},
+#endif
 	{0, NULL, NULL, NULL}
 };
 
+static const struct {
+	MnoteCanonTag tag;
+	unsigned int subtag;
+	const char *name;
+} table_sub[] = {
+#ifndef NO_VERBOSE_TAG_STRINGS
+	{MNOTE_CANON_TAG_SETTINGS_1,  0, N_("Macro mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1,  1, N_("Self-timer")},
+	{MNOTE_CANON_TAG_SETTINGS_1,  2, N_("Quality")},
+	{MNOTE_CANON_TAG_SETTINGS_1,  3, N_("Flash mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1,  4, N_("Drive mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1,  6, N_("Focus mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1,  8, N_("Record mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1,  9, N_("Image size")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 10, N_("Easy shooting mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 11, N_("Digital zoom")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 12, N_("Contrast")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 13, N_("Saturation")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 14, N_("Sharpness")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 15, N_("ISO")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 16, N_("Metering mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 17, N_("Focus range")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 18, N_("AF point")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 19, N_("Exposure mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 21, N_("Lens type")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 22, N_("Long focal length of lens")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 23, N_("Short focal length of lens")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 24, N_("Focal units per mm")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 25, N_("Maximal aperture")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 26, N_("Minimal aperture")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 27, N_("Flash activity")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 28, N_("Flash details")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 31, N_("Focus mode")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 32, N_("AE setting")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 33, N_("Image stabilization")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 34, N_("Display aperture")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 35, N_("Zoom source width")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 36, N_("Zoom target width")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 39, N_("Photo effect")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 40, N_("Manual flash output")},
+	{MNOTE_CANON_TAG_SETTINGS_1, 41, N_("Color tone")},
+	{MNOTE_CANON_TAG_FOCAL_LENGTH, 0, N_("Focal type")},
+	{MNOTE_CANON_TAG_FOCAL_LENGTH, 1, N_("Focal length")},
+	{MNOTE_CANON_TAG_FOCAL_LENGTH, 2, N_("Focal plane x size")},
+	{MNOTE_CANON_TAG_FOCAL_LENGTH, 3, N_("Focal plane y size")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 0, N_("Auto ISO")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 1, N_("Shot ISO")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 2, N_("Measured EV")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 3, N_("Target aperture")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 4, N_("Target exposure time")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 5, N_("Exposure compensation")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 6, N_("White balance")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 7, N_("Slow shutter")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 8, N_("Sequence number")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 12, N_("Flash guide number")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 13, N_("AF point")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 14, N_("Flash exposure compensation")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 15, N_("AE bracketing")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 16, N_("AE bracket value")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 18, N_("Focus distance upper")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 19, N_("Focus distance lower")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 20, N_("FNumber")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 21, N_("Exposure time")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 23, N_("Bulb duration")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 25, N_("Camera type")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 26, N_("Auto rotate")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 27, N_("ND filter")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 28, N_("Self-timer")},
+	{MNOTE_CANON_TAG_SETTINGS_2, 32, N_("Manual flash output")},
+	{MNOTE_CANON_TAG_PANORAMA, 2, N_("Panorama frame")},
+	{MNOTE_CANON_TAG_PANORAMA, 5, N_("Panorama direction")},
+	{MNOTE_CANON_TAG_COLOR_INFORMATION, 0, N_("Tone curve")},
+	{MNOTE_CANON_TAG_COLOR_INFORMATION, 2, N_("Sharpness frequency")},
+	{MNOTE_CANON_TAG_COLOR_INFORMATION, 7, N_("White balance")},
+	{MNOTE_CANON_TAG_COLOR_INFORMATION, 9, N_("Picture style")},
+#endif
+	{0, 0, NULL}
+};
+
 const char *
 mnote_canon_tag_get_name (MnoteCanonTag t)
 {
 	unsigned int i;
 
 	for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
-		if (table[i].tag == t) return (_(table[i].name));
+		if (table[i].tag == t) return table[i].name; /* do not translate */
 	return NULL;
 }
 
 const char *
+mnote_canon_tag_get_name_sub (MnoteCanonTag t, unsigned int s, ExifDataOption o)
+{
+	unsigned int i;
+	int tag_found = 0;
+
+	for (i = 0; i < sizeof (table_sub) / sizeof (table_sub[0]); i++) {
+		if (table_sub[i].tag == t) {
+			if (table_sub[i].subtag == s)
+				return table_sub[i].name;
+			tag_found = 1;
+		}
+	}
+	if (!tag_found || !(o & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS))
+		return mnote_canon_tag_get_name (t);
+	else
+		return NULL;
+}
+
+const char *
 mnote_canon_tag_get_title (MnoteCanonTag t)
 {
 	unsigned int i;
@@ -64,12 +167,35 @@ mnote_canon_tag_get_title (MnoteCanonTag t)
 }
 
 const char *
+mnote_canon_tag_get_title_sub (MnoteCanonTag t, unsigned int s, ExifDataOption o)
+{
+	unsigned int i;
+	int tag_found = 0;
+
+	for (i = 0; i < sizeof (table_sub) / sizeof (table_sub[0]); i++) {
+		if (table_sub[i].tag == t) {
+			if (table_sub[i].subtag == s)
+				return _(table_sub[i].name);
+			tag_found = 1;
+		}
+	}
+	if (!tag_found || !(o & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS))
+		return mnote_canon_tag_get_title (t);
+	else
+		return NULL;
+}
+
+const char *
 mnote_canon_tag_get_description (MnoteCanonTag t)
 {
 	unsigned int i;
 
 	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 	for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
-		if (table[i].tag == t) return (_(table[i].description));
+		if (table[i].tag == t) {
+			if (!*table[i].description)
+				return "";
+			return (_(table[i].description));
+		}
 	return NULL;
 }
diff --git a/src/libexif/canon/mnote-canon-tag.h b/src/libexif/canon/mnote-canon-tag.h
index ce1a72e..aead76e 100644
--- a/src/libexif/canon/mnote-canon-tag.h
+++ b/src/libexif/canon/mnote-canon-tag.h
@@ -1,6 +1,6 @@
 /* mnote-canon-tag.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -21,6 +21,8 @@
 #ifndef __MNOTE_CANON_TAG_H__
 #define __MNOTE_CANON_TAG_H__
 
+#include <libexif/exif-data.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
@@ -28,8 +30,10 @@ extern "C" {
 enum _MnoteCanonTag {
 	MNOTE_CANON_TAG_UNKNOWN_0	= 0x0,
 	MNOTE_CANON_TAG_SETTINGS_1	= 0x1,
+	MNOTE_CANON_TAG_FOCAL_LENGTH	= 0x2,
 	MNOTE_CANON_TAG_UNKNOWN_3	= 0x3,
 	MNOTE_CANON_TAG_SETTINGS_2	= 0x4,
+	MNOTE_CANON_TAG_PANORAMA	= 0x5,
 	MNOTE_CANON_TAG_IMAGE_TYPE	= 0x6,
 	MNOTE_CANON_TAG_FIRMWARE	= 0x7,
 	MNOTE_CANON_TAG_IMAGE_NUMBER	= 0x8,
@@ -37,13 +41,16 @@ enum _MnoteCanonTag {
 	MNOTE_CANON_TAG_UNKNOWN_10	= 0xa,
 	MNOTE_CANON_TAG_SERIAL_NUMBER	= 0xc,
 	MNOTE_CANON_TAG_UNKNOWN_13	= 0xd,
-	MNOTE_CANON_TAG_CUSTOM_FUNCS	= 0xf
+	MNOTE_CANON_TAG_CUSTOM_FUNCS	= 0xf,
+	MNOTE_CANON_TAG_COLOR_INFORMATION = 0xa0
 };
 typedef enum _MnoteCanonTag MnoteCanonTag;
 
-const char *mnote_canon_tag_get_name        (MnoteCanonTag tag);
-const char *mnote_canon_tag_get_title       (MnoteCanonTag tag);
-const char *mnote_canon_tag_get_description (MnoteCanonTag tag);
+const char *mnote_canon_tag_get_name        (MnoteCanonTag);
+const char *mnote_canon_tag_get_name_sub    (MnoteCanonTag, unsigned int, ExifDataOption);
+const char *mnote_canon_tag_get_title       (MnoteCanonTag);
+const char *mnote_canon_tag_get_title_sub   (MnoteCanonTag, unsigned int, ExifDataOption);
+const char *mnote_canon_tag_get_description (MnoteCanonTag);
 
 #ifdef __cplusplus
 }
diff --git a/src/libexif/exif-byte-order.c b/src/libexif/exif-byte-order.c
index 1a4279f..444fece 100644
--- a/src/libexif/exif-byte-order.c
+++ b/src/libexif/exif-byte-order.c
@@ -1,6 +1,6 @@
 /* exif-byte-order.c
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/src/libexif/exif-byte-order.h b/src/libexif/exif-byte-order.h
index bd51d3c..a7c98c9 100644
--- a/src/libexif/exif-byte-order.h
+++ b/src/libexif/exif-byte-order.h
@@ -1,6 +1,6 @@
 /* exif-byte-order.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/src/libexif/exif-content.c b/src/libexif/exif-content.c
index 39d73ad..c763751 100644
--- a/src/libexif/exif-content.c
+++ b/src/libexif/exif-content.c
@@ -1,6 +1,6 @@
 /* exif-content.c
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -21,12 +21,15 @@
 #include <config.h>
 
 #include <libexif/exif-content.h>
+#include <libexif/exif-system.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
-static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
+/* unused constant
+ * static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
+ */
 
 struct _ExifContentPrivate
 {
@@ -120,7 +123,7 @@ exif_content_dump (ExifContent *content, unsigned int indent)
 	if (!content)
 		return;
 
-	printf ("%sDumping exif content (%i entries)...\n", buf,
+	printf ("%sDumping exif content (%u entries)...\n", buf,
 		content->count);
 	for (i = 0; i < content->count; i++)
 		exif_entry_dump (content->entries[i], indent + 1);
@@ -129,6 +132,7 @@ exif_content_dump (ExifContent *content, unsigned int indent)
 void
 exif_content_add_entry (ExifContent *c, ExifEntry *entry)
 {
+	ExifEntry **entries;
 	if (!c || !c->priv || !entry || entry->parent) return;
 
 	/* One tag can only be added once to an IFD. */
@@ -140,19 +144,20 @@ exif_content_add_entry (ExifContent *c, ExifEntry *entry)
 		return;
 	}
 
+	entries = exif_mem_realloc (c->priv->mem,
+		c->entries, sizeof (ExifEntry*) * (c->count + 1));
+	if (!entries) return;
 	entry->parent = c;
-	c->entries = exif_mem_realloc (c->priv->mem,
-		c->entries, sizeof (ExifEntry) * (c->count + 1));
-	if (!c->entries) return;
-	c->entries[c->count] = entry;
+	entries[c->count++] = entry;
+	c->entries = entries;
 	exif_entry_ref (entry);
-	c->count++;
 }
 
 void
 exif_content_remove_entry (ExifContent *c, ExifEntry *e)
 {
 	unsigned int i;
+	ExifEntry **t, *temp;
 
 	if (!c || !c->priv || !e || (e->parent != c)) return;
 
@@ -161,13 +166,26 @@ exif_content_remove_entry (ExifContent *c, ExifEntry *e)
 	if (i == c->count) return;
 
 	/* Remove the entry */
-	memmove (&c->entries[i], &c->entries[i + 1],
-		 sizeof (ExifEntry) * (c->count - i - 1));
-	c->count--;
+	temp = c->entries[c->count-1];
+	if (c->count > 1) {
+		t = exif_mem_realloc (c->priv->mem, c->entries,
+					sizeof(ExifEntry*) * (c->count - 1));
+		if (!t) {
+			return;
+		}
+		c->entries = t;
+		c->count--;
+		if (i != c->count) { /* we deallocated the last slot already */ 
+			memmove (&t[i], &t[i + 1], sizeof (ExifEntry*) * (c->count - i - 1));
+			t[c->count-1] = temp;
+		} 
+	} else {
+		exif_mem_free (c->priv->mem, c->entries);
+		c->entries = NULL;
+		c->count = 0;
+	}
 	e->parent = NULL;
 	exif_entry_unref (e);
-	c->entries = exif_mem_realloc (c->priv->mem, c->entries,
-					sizeof(ExifEntry) * c->count);
 }
 
 ExifEntry *
@@ -207,3 +225,70 @@ exif_content_log (ExifContent *content, ExifLog *log)
 	content->priv->log = log;
 	exif_log_ref (log);
 }
+
+ExifIfd
+exif_content_get_ifd (ExifContent *c)
+{
+	if (!c || !c->parent) return EXIF_IFD_COUNT;
+
+	return 
+		((c)->parent->ifd[EXIF_IFD_0] == (c)) ? EXIF_IFD_0 :
+		((c)->parent->ifd[EXIF_IFD_1] == (c)) ? EXIF_IFD_1 :
+		((c)->parent->ifd[EXIF_IFD_EXIF] == (c)) ? EXIF_IFD_EXIF :
+		((c)->parent->ifd[EXIF_IFD_GPS] == (c)) ? EXIF_IFD_GPS :
+		((c)->parent->ifd[EXIF_IFD_INTEROPERABILITY] == (c)) ? EXIF_IFD_INTEROPERABILITY :
+		EXIF_IFD_COUNT;
+}
+
+static void
+fix_func (ExifEntry *e, void *UNUSED(data))
+{
+	exif_entry_fix (e);
+}
+
+void
+exif_content_fix (ExifContent *c)
+{
+	ExifIfd ifd = exif_content_get_ifd (c);
+	ExifDataType dt;
+	ExifTag t;
+	ExifEntry *e;
+
+	if (!c) return;
+
+	dt = exif_data_get_data_type (c->parent);
+
+	/* First of all, fix all existing entries. */
+	exif_content_foreach_entry (c, fix_func, NULL);
+
+	/*
+	 * Then check for existing tags that are not allowed and for
+	 * non-existing mandatory tags.
+	 */
+	for (t = 0; t <= 0xffff; t++) {
+		switch (exif_tag_get_support_level_in_ifd (t, ifd, dt)) {
+		case EXIF_SUPPORT_LEVEL_MANDATORY:
+			if (exif_content_get_entry (c, t)) break;
+			exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "exif-content",
+					"Tag '%s' is mandatory in IFD '%s' and has therefore been added.",
+					exif_tag_get_name_in_ifd (t, ifd), exif_ifd_get_name (ifd));
+			e = exif_entry_new ();
+			exif_content_add_entry (c, e);
+			exif_entry_initialize (e, t);
+			exif_entry_unref (e);
+			break;
+		case EXIF_SUPPORT_LEVEL_NOT_RECORDED:
+			e = exif_content_get_entry (c, t);
+			if (!e) break;
+			exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "exif-content",
+					"Tag '%s' is not recorded in IFD '%s' and has therefore been "
+					"removed.", exif_tag_get_name_in_ifd (t, ifd),
+					exif_ifd_get_name (ifd));
+			exif_content_remove_entry (c, e);
+			break;
+		case EXIF_SUPPORT_LEVEL_OPTIONAL:
+		default:
+			break;
+		}
+	}
+}
diff --git a/src/libexif/exif-content.h b/src/libexif/exif-content.h
index 115f8ed..ade2e01 100644
--- a/src/libexif/exif-content.h
+++ b/src/libexif/exif-content.h
@@ -1,6 +1,6 @@
 /* exif-content.h
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -52,9 +52,10 @@ void         exif_content_ref     (ExifContent *content);
 void         exif_content_unref   (ExifContent *content);
 void         exif_content_free    (ExifContent *content);
 
-void         exif_content_add_entry     (ExifContent *content, ExifEntry *e);
-void         exif_content_remove_entry  (ExifContent *content, ExifEntry *e);
-ExifEntry   *exif_content_get_entry     (ExifContent *content, ExifTag tag);
+void         exif_content_add_entry    (ExifContent *, ExifEntry *);
+void         exif_content_remove_entry (ExifContent *, ExifEntry *);
+ExifEntry   *exif_content_get_entry    (ExifContent *, ExifTag);
+void         exif_content_fix          (ExifContent *);
 
 typedef void (* ExifContentForeachEntryFunc) (ExifEntry *, void *user_data);
 void         exif_content_foreach_entry (ExifContent *content,
@@ -62,6 +63,7 @@ void         exif_content_foreach_entry (ExifContent *content,
 					 void *user_data);
 
 /* For your convenience */
+ExifIfd exif_content_get_ifd (ExifContent *);
 #define exif_content_get_value(c,t,v,m)					\
 	(exif_content_get_entry (c,t) ?					\
 	 exif_entry_get_value (exif_content_get_entry (c,t),v,m) : NULL)
diff --git a/src/libexif/exif-data-type.h b/src/libexif/exif-data-type.h
new file mode 100644
index 0000000..271a2f2
--- /dev/null
+++ b/src/libexif/exif-data-type.h
@@ -0,0 +1,40 @@
+/* exif-data-tag.h
+ *
+ * Copyright (c) 2005 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __EXIF_DATA_TYPE_H__
+#define __EXIF_DATA_TYPE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef enum {
+	EXIF_DATA_TYPE_UNCOMPRESSED_CHUNKY = 0,
+	EXIF_DATA_TYPE_UNCOMPRESSED_PLANAR,
+	EXIF_DATA_TYPE_UNCOMPRESSED_YCC,
+	EXIF_DATA_TYPE_COMPRESSED,
+	EXIF_DATA_TYPE_COUNT
+} ExifDataType;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __EXIF_TAG_H__ */
diff --git a/src/libexif/exif-data.c b/src/libexif/exif-data.c
index 92e5857..314fd8b 100644
--- a/src/libexif/exif-data.c
+++ b/src/libexif/exif-data.c
@@ -1,6 +1,6 @@
 /* exif-data.c
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -28,18 +28,17 @@
 #include <libexif/exif-loader.h>
 #include <libexif/exif-log.h>
 #include <libexif/i18n.h>
+#include <libexif/exif-system.h>
 
-#include <libexif/olympus/exif-mnote-data-olympus.h>
 #include <libexif/canon/exif-mnote-data-canon.h>
+#include <libexif/fuji/exif-mnote-data-fuji.h>
+#include <libexif/olympus/exif-mnote-data-olympus.h>
 #include <libexif/pentax/exif-mnote-data-pentax.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
-#undef MAX
-#define MAX(a, b)  (((a) > (b)) ? (a) : (b))
-
 #if defined(__WATCOMC__) || defined(_MSC_VER)
 #      define strncasecmp strnicmp
 #endif
@@ -66,6 +65,9 @@ struct _ExifDataPrivate
 
 	/* Temporarily used while loading data */
 	unsigned int offset_mnote;
+
+	ExifDataOption options;
+	ExifDataType data_type;
 };
 
 static void *
@@ -73,10 +75,12 @@ exif_data_alloc (ExifData *data, unsigned int i)
 {
 	void *d;
 
-	if (!data || !i) return NULL;
+	if (!data || !i) 
+		return NULL;
 
 	d = exif_mem_alloc (data->priv->mem, i);
-	if (d) return d;
+	if (d) 
+		return d;
 
 	EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i);
 	return NULL;
@@ -105,12 +109,17 @@ exif_data_new_mem (ExifMem *mem)
 	ExifData *data;
 	unsigned int i;
 
-	if (!mem) return NULL;
+	if (!mem) 
+		return NULL;
 
 	data = exif_mem_alloc (mem, sizeof (ExifData));
-	if (!data) return (NULL);
+	if (!data) 
+		return (NULL);
 	data->priv = exif_mem_alloc (mem, sizeof (ExifDataPrivate));
-	if (!data->priv) { exif_mem_free (mem, data); return (NULL); }
+	if (!data->priv) { 
+	  	exif_mem_free (mem, data); 
+		return (NULL); 
+	}
 	data->priv->ref_count = 1;
 
 	data->priv->mem = mem;
@@ -125,6 +134,19 @@ exif_data_new_mem (ExifMem *mem)
 		data->ifd[i]->parent = data;
 	}
 
+	/* Default options */
+#ifndef NO_VERBOSE_TAG_STRINGS
+	/*
+	 * When the tag list is compiled away, setting this option prevents
+	 * any tags from being loaded
+	 */
+	exif_data_set_option (data, EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS);
+#endif
+	exif_data_set_option (data, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
+
+	/* Default data type: none */
+	exif_data_set_data_type (data, EXIF_DATA_TYPE_COUNT);
+
 	return (data);
 }
 
@@ -138,7 +160,7 @@ exif_data_new_from_data (const unsigned char *data, unsigned int size)
 	return (edata);
 }
 
-static void
+static int
 exif_data_load_data_entry (ExifData *data, ExifEntry *entry,
 			   const unsigned char *d,
 			   unsigned int size, unsigned int offset)
@@ -153,41 +175,56 @@ exif_data_load_data_entry (ExifData *data, ExifEntry *entry,
 		  "Loading entry 0x%x ('%s')...", entry->tag,
 		  exif_tag_get_name (entry->tag));
 
+	/* {0,1,2,4,8} x { 0x00000000 .. 0xffffffff } 
+	 *   -> { 0x000000000 .. 0x7fffffff8 } */
+	s = exif_format_get_size(entry->format) * entry->components;
+	if (s < entry->components) {
+		return 0;
+	}
+	if (0 == s)
+		return 0;
 	/*
 	 * Size? If bigger than 4 bytes, the actual data is not
 	 * in the entry but somewhere else (offset).
 	 */
-	s = exif_format_get_size (entry->format) * entry->components;
-	if (!s)
-		return;
 	if (s > 4)
 		doff = exif_get_long (d + offset + 8, data->priv->order);
 	else
 		doff = offset + 8;
 
-	/* Sanity check */
+	/* Sanity checks */
+	if ((doff + s < doff) || (doff + s < s))
+		return 0;
 	if (size < doff + s)
-		return;
+		return 0;
 
 	entry->data = exif_data_alloc (data, s);
 	if (entry->data) {
 		entry->size = s;
 		memcpy (entry->data, d + doff, s);
+	} else {
+		/* FIXME: What do our callers do if (entry->data == NULL)? */
+		EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", s);
 	}
 
 	/* If this is the MakerNote, remember the offset */
 	if (entry->tag == EXIF_TAG_MAKER_NOTE) {
-		if (entry->size > 6) exif_log (data->priv->log,
-			  EXIF_LOG_CODE_DEBUG, "ExifData",
-		          "MakerNote found (%02x %02x %02x %02x "
-			  "%02x %02x %02x...).",
-			  entry->data[0], entry->data[1], entry->data[2],
-			  entry->data[3], entry->data[4], entry->data[5],
-			  entry->data[6]);
+		if (!entry->data) {
+			exif_log (data->priv->log,
+                                               EXIF_LOG_CODE_DEBUG, "ExifData",
+                                               "MakerNote found with NULL data");	
+		} else if (entry->size > 6) {
+			exif_log (data->priv->log,
+					       EXIF_LOG_CODE_DEBUG, "ExifData",
+					       "MakerNote found (%02x %02x %02x %02x "
+					       "%02x %02x %02x...).",
+					       entry->data[0], entry->data[1], entry->data[2],
+					       entry->data[3], entry->data[4], entry->data[5],
+					       entry->data[6]);
+		}
 		data->priv->offset_mnote = doff;
 	}
-
-	exif_entry_fix (entry);
+	return 1;
 }
 
 static void
@@ -196,8 +233,11 @@ exif_data_save_data_entry (ExifData *data, ExifEntry *e,
 			   unsigned int offset)
 {
 	unsigned int doff, s;
+	unsigned char *t;
+	unsigned int ts;
 
-	if (!data || !data->priv) return;
+	if (!data || !data->priv) 
+		return;
 
 	/*
 	 * Each entry is 12 bytes long. The memory for the entry has
@@ -208,17 +248,17 @@ exif_data_save_data_entry (ExifData *data, ExifEntry *e,
 	exif_set_short (*d + 6 + offset + 2,
 			data->priv->order, (ExifShort) e->format);
 
-#ifndef EXIF_DONT_CHANGE_MAKER_NOTE
-	/* If this is the maker note tag, update it. */
-	if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
-		exif_mem_free (data->priv->mem, e->data);
-		e->data = NULL;
-		e->size = 0;
-		exif_mnote_data_set_offset (data->priv->md, *ds - 6);
-		exif_mnote_data_save (data->priv->md, &e->data, &e->size);
-		e->components = e->size;
+	if (!(data->priv->options & EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE)) {
+		/* If this is the maker note tag, update it. */
+		if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
+			exif_mem_free (data->priv->mem, e->data);
+			e->data = NULL;
+			e->size = 0;
+			exif_mnote_data_set_offset (data->priv->md, *ds - 6);
+			exif_mnote_data_save (data->priv->md, &e->data, &e->size);
+			e->components = e->size;
+		}
 	}
-#endif
 
 	exif_set_long  (*d + 6 + offset + 4,
 			data->priv->order, e->components);
@@ -230,50 +270,62 @@ exif_data_save_data_entry (ExifData *data, ExifEntry *e,
 	s = exif_format_get_size (e->format) * e->components;
 	if (s > 4) {
 		doff = *ds - 6;
-		*ds += s;
+		ts = *ds + s;
 
 		/*
 		 * According to the TIFF specification,
 		 * the offset must be an even number. If we need to introduce
 		 * a padding byte, we set it to 0.
 		 */
-		if (s & 1) (*ds)++;
-		*d = exif_mem_realloc (data->priv->mem, *d, *ds);
-		if (!*d) {
-			EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", *ds);
+		if (s & 1)
+			ts++;
+		t = exif_mem_realloc (data->priv->mem, *d, ts);
+		if (!t) {
+			EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
 		  	return;
 		}
+		*d = t;
+		*ds = ts;
 		exif_set_long (*d + 6 + offset + 8, data->priv->order, doff);
-		if (s & 1) *(*d + *ds - 1) = '\0';
+		if (s & 1) 
+			*(*d + *ds - 1) = '\0';
 
 	} else
 		doff = offset + 8;
 
-	/* Write the data. Fill unneeded bytes with 0. */
-	memcpy (*d + 6 + doff, e->data, s);
-	if (s < 4) memset (*d + 6 + doff + s, 0, (4 - s));
+	/* Write the data. Fill unneeded bytes with 0. Do not crash with
+	 * e->data is NULL */
+	if (e->data) {
+		memcpy (*d + 6 + doff, e->data, s);
+	} else {
+		memset (*d + 6 + doff, 0, s);
+	}
+	if (s < 4) 
+		memset (*d + 6 + doff + s, 0, (4 - s));
 }
 
 static void
 exif_data_load_data_thumbnail (ExifData *data, const unsigned char *d,
 			       unsigned int ds, ExifLong offset, ExifLong size)
 {
-	if (ds < offset + size) {
+	if ((ds < offset + size) || (offset > ds)) {
 		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
-			  "Bogus thumbnail offset and size: %i < %i + %i.",
-			  (int) ds, (int) offset, (int) size);
+			  "Bogus thumbnail offset (%u) or size (%u).",
+			  offset, size);
 		return;
 	}
-	if (data->data) exif_mem_free (data->priv->mem, data->data);
+	if (data->data) 
+		exif_mem_free (data->priv->mem, data->data);
 	data->size = size;
 	data->data = exif_data_alloc (data, data->size);
-	if (!data->data) return;
+	if (!data->data) 
+		return;
 	memcpy (data->data, d + offset, data->size);
 }
 
 #undef CHECK_REC
 #define CHECK_REC(i) 					\
-if (data->ifd[(i)] == ifd) {				\
+if ((i) == ifd) {				\
 	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
 		"ExifData", "Recursive entry in IFD "	\
 		"'%s' detected. Skipping...",		\
@@ -282,7 +334,7 @@ if (data->ifd[(i)] == ifd) {				\
 }							\
 if (data->ifd[(i)]->count) {				\
 	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,	\
-		"ExifData", "Attemt to load IFD "	\
+		"ExifData", "Attempt to load IFD "	\
 		"'%s' multiple times detected. "	\
 		"Skipping...",				\
 		exif_ifd_get_name (i));			\
@@ -290,9 +342,9 @@ if (data->ifd[(i)]->count) {				\
 }
 
 static void
-exif_data_load_data_content (ExifData *data, ExifContent *ifd,
+exif_data_load_data_content (ExifData *data, ExifIfd ifd,
 			     const unsigned char *d,
-			     unsigned int ds, unsigned int offset)
+			     unsigned int ds, unsigned int offset, unsigned int recursion_depth)
 {
 	ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
 	ExifShort n;
@@ -300,17 +352,30 @@ exif_data_load_data_content (ExifData *data, ExifContent *ifd,
 	unsigned int i;
 	ExifTag tag;
 
-	if (!data || !data->priv) return;
+	if (!data || !data->priv) 
+		return;
+
+	/* check for valid ExifIfd enum range */
+	if (( ((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT))
+	  return;
+
+	if (recursion_depth > 150) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
+			  "Deep recursion detected!");
+		return;
+	}
 
 	/* Read the number of entries */
-	if (offset >= ds - 1) return;
+	if (offset >= ds - 1) 
+		return;
 	n = exif_get_short (d + offset, data->priv->order);
 	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 	          "Loading %i entries...", n);
 	offset += 2;
 
 	/* Check if we have enough data. */
-	if (offset + 12 * n > ds) n = (ds - offset) / 12;
+	if (offset + 12 * n > ds) 
+		n = (ds - offset) / 12;
 
 	for (i = 0; i < n; i++) {
 
@@ -326,32 +391,29 @@ exif_data_load_data_content (ExifData *data, ExifContent *ifd,
 			switch (tag) {
 			case EXIF_TAG_EXIF_IFD_POINTER:
 				CHECK_REC (EXIF_IFD_EXIF);
-				exif_data_load_data_content (data,
-					data->ifd[EXIF_IFD_EXIF], d, ds, o);
+				exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o, recursion_depth + 1);
 				break;
 			case EXIF_TAG_GPS_INFO_IFD_POINTER:
 				CHECK_REC (EXIF_IFD_GPS);
-				exif_data_load_data_content (data,
-					data->ifd[EXIF_IFD_GPS], d, ds, o);
+				exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o, recursion_depth + 1);
 				break;
 			case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
 				CHECK_REC (EXIF_IFD_INTEROPERABILITY);
-				exif_data_load_data_content (data,
-					data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds, o);
+				exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o, recursion_depth + 1);
 				break;
 			case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
 				thumbnail_offset = o;
 				if (thumbnail_offset && thumbnail_length)
 					exif_data_load_data_thumbnail (data, d,
-						ds, thumbnail_offset,
-						thumbnail_length);
+								       ds, thumbnail_offset,
+								       thumbnail_length);
 				break;
 			case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
 				thumbnail_length = o;
 				if (thumbnail_offset && thumbnail_length)
 					exif_data_load_data_thumbnail (data, d,
-						ds, thumbnail_offset,
-						thumbnail_length);
+								       ds, thumbnail_offset,
+								       thumbnail_length);
 				break;
 			default:
 				return;
@@ -360,18 +422,33 @@ exif_data_load_data_content (ExifData *data, ExifContent *ifd,
 		default:
 
 			/*
-			 * If we don't know the tag, chances are high
-			 * that the EXIF data does not follow the standard.
+			 * If we don't know the tag, don't fail. It could be that new 
+			 * versions of the standard have defined additional tags. Note that
+			 * 0 is a valid tag in the GPS IFD.
 			 */
-			if (!exif_tag_get_name (tag)) {
+			if (!exif_tag_get_name_in_ifd (tag, ifd)) {
+
+				/*
+				 * Special case: Tag and format 0. That's against specification.
+				 * At least up to 2.2. But Photoshop writes it anyways.
+				 */
+				if (!memcmp (d + offset + 12 * i, "\0\0\0\0", 4)) {
+					exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+						  "Skipping empty entry at position %i in '%s'.", i, 
+						  exif_ifd_get_name (ifd));
+					break;
+				}
 				exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
-				  "Unknown tag %x (entry %i)", tag, i);
-				return;
+					  "Unknown tag 0x%04x (entry %i in '%s'). Please report this tag "
+					  "to <libexif-devel@lists.sourceforge.net>.", tag, i,
+					  exif_ifd_get_name (ifd));
+				if (data->priv->options & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS)
+					break;
 			}
 			entry = exif_entry_new_mem (data->priv->mem);
-			exif_data_load_data_entry (data, entry, d, ds,
-						   offset + 12 * i);
-			exif_content_add_entry (ifd, entry);
+			if (exif_data_load_data_entry (data, entry, d, ds,
+						   offset + 12 * i))
+				exif_content_add_entry (data->ifd[ifd], entry);
 			exif_entry_unref (entry);
 			break;
 		}
@@ -391,14 +468,14 @@ static int
 cmp_func_intel (const void *elem1, const void *elem2)
 {
 	return cmp_func ((const unsigned char *) elem1,
-			(const unsigned char *) elem2, EXIF_BYTE_ORDER_INTEL);
+			 (const unsigned char *) elem2, EXIF_BYTE_ORDER_INTEL);
 }
 
 static int
 cmp_func_motorola (const void *elem1, const void *elem2)
 {
 	return cmp_func ((const unsigned char *) elem1,
-			(const unsigned char *) elem2, EXIF_BYTE_ORDER_MOTOROLA);
+			 (const unsigned char *) elem2, EXIF_BYTE_ORDER_MOTOROLA);
 }
 
 static void
@@ -408,8 +485,11 @@ exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 {
 	unsigned int j, n_ptr = 0, n_thumb = 0;
 	ExifIfd i;
+	unsigned char *t;
+	unsigned int ts;
 
-	if (!data || !data->priv || !ifd || !d || !ds) return;
+	if (!data || !data->priv || !ifd || !d || !ds) 
+		return;
 
 	for (i = 0; i < EXIF_IFD_COUNT; i++)
 		if (ifd == data->ifd[i])
@@ -451,24 +531,33 @@ exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 	 * Allocate enough memory for all entries
 	 * and the number of entries.
 	 */
-	*ds += (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
-	*d = exif_mem_realloc (data->priv->mem, *d, *ds);
-	if (!*d) {
-		EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", *ds);
+	ts = *ds + (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
+	t = exif_mem_realloc (data->priv->mem, *d, ts);
+	if (!t) {
+		EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
 	  	return;
 	}
+	*d = t;
+	*ds = ts;
 
 	/* Save the number of entries */
 	exif_set_short (*d + 6 + offset, data->priv->order,
 			(ExifShort) (ifd->count + n_ptr + n_thumb));
 	offset += 2;
 
-	/* Save each entry */
+	/*
+	 * Save each entry. Make sure that no memcpys from NULL pointers are
+	 * performed
+	 */
 	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 		  "Saving %i entries (IFD '%s', offset: %i)...",
 		  ifd->count, exif_ifd_get_name (i), offset);
-	for (j = 0; j < ifd->count; j++)
-		exif_data_save_data_entry (data, ifd->entries[j], d, ds, offset + 12 * j);
+	for (j = 0; j < ifd->count; j++) {
+		if (ifd->entries[j]) {
+			exif_data_save_data_entry (data, ifd->entries[j], d, ds,
+				offset + 12 * j);
+		}
+	}
 
 	offset += 12 * ifd->count;
 
@@ -493,7 +582,7 @@ exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 			exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 					*ds - 6);
 			exif_data_save_data_content (data,
-				data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
+						     data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
 			offset += 12;
 		}
 
@@ -508,7 +597,7 @@ exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 			exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 					*ds - 6);
 			exif_data_save_data_content (data,
-				data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
+						     data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
 			offset += 12;
 		}
 
@@ -529,8 +618,8 @@ exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 			exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 					*ds - 6);
 			exif_data_save_data_content (data,
-				data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
-				*ds - 6);
+						     data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
+						     *ds - 6);
 			offset += 12;
 		}
 
@@ -552,19 +641,21 @@ exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 					1);
 			exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 					*ds - 6);
-			*ds += data->size;
-			*d = exif_mem_realloc (data->priv->mem, *d, *ds);
-			if (!*d) {
+			ts = *ds + data->size;
+			t = exif_mem_realloc (data->priv->mem, *d, ts);
+			if (!t) {
 				EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData",
-						    *ds);
+						    ts);
 			  	return;
 			}
+			*d = t;
+			*ds = ts;
 			memcpy (*d + *ds - data->size, data->data, data->size);
 			offset += 12;
 
 			/* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
 			exif_set_short (*d + 6 + offset + 0, data->priv->order,
-				EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
+					EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
 			exif_set_short (*d + 6 + offset + 2, data->priv->order,
 					EXIF_FORMAT_LONG);
 			exif_set_long  (*d + 6 + offset + 4, data->priv->order,
@@ -581,12 +672,12 @@ exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 
 	/* Sort the directory according to TIFF specification */
 	qsort (*d + 6 + offset - (ifd->count + n_ptr + n_thumb) * 12,
-			(ifd->count + n_ptr + n_thumb), 12,
-			data->priv->order == EXIF_BYTE_ORDER_INTEL ? cmp_func_intel : cmp_func_motorola);
+	       (ifd->count + n_ptr + n_thumb), 12,
+	       (data->priv->order == EXIF_BYTE_ORDER_INTEL) ? cmp_func_intel : cmp_func_motorola);
 
 	/* Correctly terminate the directory */
 	if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
-					     data->size)) {
+				data->size)) {
 
 		/*
 		 * We are saving IFD 0. Tell where IFD 1 starts and save
@@ -603,7 +694,10 @@ typedef enum {
 	EXIF_DATA_TYPE_MAKER_NOTE_NONE		= 0,
 	EXIF_DATA_TYPE_MAKER_NOTE_CANON		= 1,
 	EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS	= 2,
-	EXIF_DATA_TYPE_MAKER_NOTE_PENTAX	= 3
+	EXIF_DATA_TYPE_MAKER_NOTE_PENTAX		= 3,
+	EXIF_DATA_TYPE_MAKER_NOTE_NIKON		= 4,
+	EXIF_DATA_TYPE_MAKER_NOTE_CASIO		= 5,
+	EXIF_DATA_TYPE_MAKER_NOTE_FUJI 		= 6
 } ExifDataTypeMakerNote;
 
 static ExifDataTypeMakerNote
@@ -612,18 +706,23 @@ exif_data_get_type_maker_note (ExifData *d)
 	ExifEntry *e, *em;
 	char value[1024];
 
-	if (!d) return EXIF_DATA_TYPE_MAKER_NOTE_NONE;
+	if (!d) 
+		return EXIF_DATA_TYPE_MAKER_NOTE_NONE;
 	
 	e = exif_data_get_entry (d, EXIF_TAG_MAKER_NOTE);
-        if (!e) return EXIF_DATA_TYPE_MAKER_NOTE_NONE;
-
-	/* Olympus & Nikon */
-	if ((e->size >= 5) && (!memcmp (e->data, "OLYMP", 5) ||
-			       !memcmp (e->data, "Nikon", 5)))
+	if (!e) 
+		return EXIF_DATA_TYPE_MAKER_NOTE_NONE;
+
+	/* Olympus & Nikon & Sanyo */
+	if ((e->size >= 8) && ( !memcmp (e->data, "OLYMP", 6) ||
+				!memcmp (e->data, "OLYMPUS", 8) ||
+				!memcmp (e->data, "SANYO", 6) ||
+				!memcmp (e->data, "Nikon", 6)))
 		return EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS;
 
 	em = exif_data_get_entry (d, EXIF_TAG_MAKE);
-	if (!em) return EXIF_DATA_TYPE_MAKER_NOTE_NONE;
+	if (!em) 
+		return EXIF_DATA_TYPE_MAKER_NOTE_NONE;
 
 	/* Canon */
 	if (!strcmp (exif_entry_get_value (em, value, sizeof (value)), "Canon"))
@@ -632,12 +731,21 @@ exif_data_get_type_maker_note (ExifData *d)
 	/* Pentax & some variant of Nikon */
 	if ((e->size >= 2) && (e->data[0] == 0x00) && (e->data[1] == 0x1b)) {
 		if (!strncasecmp (
-			exif_entry_get_value (em, value, sizeof(value)),
-					      "Nikon", 5))
-			return EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS;
+			    exif_entry_get_value (em, value, sizeof(value)),
+			    "Nikon", 5))
+			return EXIF_DATA_TYPE_MAKER_NOTE_NIKON;
 		else
 			return EXIF_DATA_TYPE_MAKER_NOTE_PENTAX;
 	}
+	if ((e->size >= 8) && !memcmp (e->data, "AOC", 4)) {
+		return EXIF_DATA_TYPE_MAKER_NOTE_PENTAX;
+	}
+	if ((e->size >= 8) && !memcmp (e->data, "QVC", 4)) {
+		return EXIF_DATA_TYPE_MAKER_NOTE_CASIO;
+	}
+	if ((e->size >= 12) && !memcmp (e->data, "FUJIFILM", 8)) {
+		return EXIF_DATA_TYPE_MAKER_NOTE_FUJI;
+	}
 
 	return EXIF_DATA_TYPE_MAKER_NOTE_NONE;
 }
@@ -656,7 +764,8 @@ exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 	const unsigned char *d = d_orig;
 	unsigned int ds = ds_orig, len;
 
-	if (!data || !data->priv || !d || !ds) return;
+	if (!data || !data->priv || !d || !ds) 
+		return;
 
 	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 		  "Parsing %i byte(s) EXIF data...\n", ds);
@@ -731,7 +840,7 @@ exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 	}
 	if (memcmp (d, ExifHeader, 6)) {
 		exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
-				"ExifData", _("EXIF header not found."));
+			  "ExifData", _("EXIF header not found."));
 		return;
 	}
 
@@ -747,7 +856,7 @@ exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 		data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
 	else {
 		exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
-				"ExifData", _("Unknown encoding."));
+			  "ExifData", _("Unknown encoding."));
 		return;
 	}
 
@@ -761,8 +870,7 @@ exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 		  "IFD 0 at %i.", (int) offset);
 
 	/* Parse the actual exif data (usually offset 14 from start) */
-	exif_data_load_data_content (data, data->ifd[EXIF_IFD_0], d + 6,
-				     ds - 6, offset);
+	exif_data_load_data_content (data, EXIF_IFD_0, d + 6, ds - 6, offset, 0);
 
 	/* IFD 1 offset */
 	if (offset + 6 + 2 > ds) {
@@ -780,12 +888,10 @@ exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 		/* Sanity check. */
 		if (offset > ds - 6) {
 			exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
-				  "ExifData", "Bogus offset.");
-			return;
+				  "ExifData", "Bogus offset of IFD1.");
+		} else {
+		   exif_data_load_data_content (data, EXIF_IFD_1, d + 6, ds - 6, offset, 0);
 		}
-
-		exif_data_load_data_content (data, data->ifd[EXIF_IFD_1], d + 6,
-					     ds - 6, offset);
 	}
 
 	/*
@@ -796,13 +902,18 @@ exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 	 */
 	switch (exif_data_get_type_maker_note (data)) {
 	case EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS:
+	case EXIF_DATA_TYPE_MAKER_NOTE_NIKON:
 		data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
 		break;
 	case EXIF_DATA_TYPE_MAKER_NOTE_PENTAX:
+	case EXIF_DATA_TYPE_MAKER_NOTE_CASIO:
 		data->priv->md = exif_mnote_data_pentax_new (data->priv->mem);
 		break;
 	case EXIF_DATA_TYPE_MAKER_NOTE_CANON:
-		data->priv->md = exif_mnote_data_canon_new (data->priv->mem);
+		data->priv->md = exif_mnote_data_canon_new (data->priv->mem, data->priv->options);
+		break;
+	case EXIF_DATA_TYPE_MAKER_NOTE_FUJI:
+		data->priv->md = exif_mnote_data_fuji_new (data->priv->mem);
 		break;
 	default:
 		break;
@@ -819,18 +930,27 @@ exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 					    data->priv->offset_mnote);
 		exif_mnote_data_load (data->priv->md, d, ds);
 	}
+
+	if (data->priv->options & EXIF_DATA_OPTION_FOLLOW_SPECIFICATION)
+		exif_data_fix (data);
 }
 
 void
 exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds)
 {
+	if (ds)
+		*ds = 0;	/* This means something went wrong */
+
 	if (!data || !d || !ds)
 		return;
 
 	/* Header */
 	*ds = 14;
 	*d = exif_data_alloc (data, *ds);
-	if (!*d) return;
+	if (!*d)  {
+		*ds = 0;
+		return;
+	}
 	memcpy (*d, ExifHeader, 6);
 
 	/* Order (offset 6) */
@@ -886,10 +1006,12 @@ exif_data_ref (ExifData *data)
 void
 exif_data_unref (ExifData *data)
 {
-	if (!data) return;
+	if (!data) 
+		return;
 
 	data->priv->ref_count--;
-	if (!data->priv->ref_count) exif_data_free (data);
+	if (!data->priv->ref_count) 
+		exif_data_free (data);
 }
 
 void
@@ -898,7 +1020,8 @@ exif_data_free (ExifData *data)
 	unsigned int i;
 	ExifMem *mem = (data && data->priv) ? data->priv->mem : NULL;
 
-	if (!data) return;
+	if (!data) 
+		return;
 
 	for (i = 0; i < EXIF_IFD_COUNT; i++) {
 		if (data->ifd[i]) {
@@ -1020,7 +1143,8 @@ exif_data_log (ExifData *data, ExifLog *log)
 {
 	unsigned int i;
 
-	if (!data || !data->priv) return;
+	if (!data || !data->priv) 
+		return;
 	exif_log_unref (data->priv->log);
 	data->priv->log = log;
 	exif_log_ref (log);
@@ -1034,6 +1158,112 @@ ExifLog *exif_data_get_log (ExifData *);
 ExifLog *
 exif_data_get_log (ExifData *data)
 {
-	if (!data || !data->priv) return NULL;
+	if (!data || !data->priv) 
+		return NULL;
 	return data->priv->log;
 }
+
+static const struct {
+	ExifDataOption option;
+	const char *name;
+	const char *description;
+} exif_data_option[] = {
+	{EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS, N_("Ignore unknown tags"),
+	 N_("Ignore unknown tags when loading EXIF data.")},
+	{EXIF_DATA_OPTION_FOLLOW_SPECIFICATION, N_("Follow specification"),
+	 N_("Add, correct and remove entries to get EXIF data that follows "
+	    "the specification.")},
+	{EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE, N_("Do not change maker note"),
+	 N_("When loading and resaving Exif data, save the maker note unmodified."
+	    " Be aware that the maker note can get corrupted.")},
+	{0, NULL, NULL}
+};
+
+const char *
+exif_data_option_get_name (ExifDataOption o)
+{
+	unsigned int i;
+
+	for (i = 0; exif_data_option[i].name; i++)
+		if (exif_data_option[i].option == o) 
+			break;
+	return _(exif_data_option[i].name);
+}
+
+const char *
+exif_data_option_get_description (ExifDataOption o)
+{
+	unsigned int i;
+
+	for (i = 0; exif_data_option[i].description; i++)
+		if (exif_data_option[i].option == o) 
+			break;
+	return _(exif_data_option[i].description);
+}
+
+void
+exif_data_set_option (ExifData *d, ExifDataOption o)
+{
+	if (!d) 
+		return;
+
+	d->priv->options |= o;
+}
+
+void
+exif_data_unset_option (ExifData *d, ExifDataOption o)
+{
+	if (!d) 
+		return;
+
+	d->priv->options &= ~o;
+}
+
+static void
+fix_func (ExifContent *c, void *UNUSED(data))
+{
+	switch (exif_content_get_ifd (c)) {
+	case EXIF_IFD_1:
+		if (c->parent->data)
+			exif_content_fix (c);
+		else {
+			exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
+				  "No thumbnail but entries on thumbnail. These entries have been "
+				  "removed.");
+			while (c->count) {
+				unsigned int cnt = c->count;
+				exif_content_remove_entry (c, c->entries[c->count - 1]);
+				if (cnt == c->count) {
+					/* safety net */
+					exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
+					"failed to remove last entry from entries.");
+					c->count--;
+				}
+			}
+		}
+		break;
+	default:
+		exif_content_fix (c);
+	}
+}
+
+void
+exif_data_fix (ExifData *d)
+{
+	exif_data_foreach_content (d, fix_func, NULL);
+}
+
+void
+exif_data_set_data_type (ExifData *d, ExifDataType dt)
+{
+	if (!d || !d->priv) 
+		return;
+
+	d->priv->data_type = dt;
+}
+
+ExifDataType
+exif_data_get_data_type (ExifData *d)
+{
+	return (d && d->priv) ? d->priv->data_type : EXIF_DATA_TYPE_COUNT;
+}
diff --git a/src/libexif/exif-data.h b/src/libexif/exif-data.h
index 9ecad1d..3b99412 100644
--- a/src/libexif/exif-data.h
+++ b/src/libexif/exif-data.h
@@ -1,7 +1,7 @@
 /*! \file exif-data.h
- * \brief FIXME foo bar blah
+ * \brief Defines the ExifData type and the associated functions.
  *
- * \author Lutz Müller <lutz@users.sourceforge.net>
+ * \author Lutz Mueller <lutz@users.sourceforge.net>
  * \date 2001-2005
  *
  * This library is free software; you can redistribute it and/or
@@ -28,6 +28,7 @@ extern "C" {
 #endif /* __cplusplus */
 
 #include <libexif/exif-byte-order.h>
+#include <libexif/exif-data-type.h>
 #include <libexif/exif-ifd.h>
 #include <libexif/exif-log.h>
 #include <libexif/exif-tag.h>
@@ -54,8 +55,6 @@ ExifData *exif_data_new_mem       (ExifMem *);
 
 /*! \brief load exif data from file
  *  \param[in] path filename including path
- *  
- *  Foo bar blah bleh baz.
  */
 ExifData *exif_data_new_from_file (const char *path);
 ExifData *exif_data_new_from_data (const unsigned char *data,
@@ -74,17 +73,32 @@ ExifByteOrder exif_data_get_byte_order  (ExifData *data);
 void          exif_data_set_byte_order  (ExifData *data, ExifByteOrder order);
 
 ExifMnoteData *exif_data_get_mnote_data (ExifData *);
+void           exif_data_fix (ExifData *);
 
 typedef void (* ExifDataForeachContentFunc) (ExifContent *, void *user_data);
 void          exif_data_foreach_content (ExifData *data,
 					 ExifDataForeachContentFunc func,
 					 void *user_data);
 
+typedef enum {
+	EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS = 1 << 0,
+	EXIF_DATA_OPTION_FOLLOW_SPECIFICATION = 1 << 1,
+	EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE = 1 << 2
+} ExifDataOption;
+
+const char *exif_data_option_get_name        (ExifDataOption);
+const char *exif_data_option_get_description (ExifDataOption);
+void        exif_data_set_option             (ExifData *, ExifDataOption);
+void        exif_data_unset_option           (ExifData *, ExifDataOption);
+
+void         exif_data_set_data_type (ExifData *, ExifDataType);
+ExifDataType exif_data_get_data_type (ExifData *);
+
 /* For debugging purposes and error reporting */
 void exif_data_dump (ExifData *data);
 void exif_data_log  (ExifData *data, ExifLog *log);
 
-/* For your convenience */
+/** convenience macro. */
 #define exif_data_get_entry(d,t)					\
 	(exif_content_get_entry(d->ifd[EXIF_IFD_0],t) ?			\
 	 exif_content_get_entry(d->ifd[EXIF_IFD_0],t) :			\
diff --git a/src/libexif/exif-entry.c b/src/libexif/exif-entry.c
index 09d37e2..02ec510 100644
--- a/src/libexif/exif-entry.c
+++ b/src/libexif/exif-entry.c
@@ -1,6 +1,6 @@
 /* exif-entry.c
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -30,6 +30,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
+#define _USE_MATH_DEFINES  /* required by MS compilers to define M_PI */
 #include <math.h>
 
 struct _ExifEntryPrivate
@@ -42,6 +43,7 @@ struct _ExifEntryPrivate
 /* This function is hidden in exif-data.c */
 ExifLog *exif_data_get_log (ExifData *);
 
+#ifndef NO_VERBOSE_TAG_STRINGS
 static void
 exif_entry_log (ExifEntry *e, ExifLogCode code, const char *format, ...)
 {
@@ -54,6 +56,15 @@ exif_entry_log (ExifEntry *e, ExifLogCode code, const char *format, ...)
 	exif_logv (l, code, "ExifEntry", format, args);
 	va_end (args);
 }
+#else
+#if defined(__STDC_VERSION__) &&  __STDC_VERSION__ >= 199901L
+#define exif_entry_log(...) do { } while (0)
+#elif defined(__GNUC__)
+#define exif_entry_log(x...) do { } while (0)
+#else
+#define exif_entry_log (void)
+#endif
+#endif
 
 static void *
 exif_entry_alloc (ExifEntry *e, unsigned int i)
@@ -199,9 +210,9 @@ exif_entry_fix (ExifEntry *e)
 				exif_format_get_size (e->format);
 			e->data = exif_entry_realloc (e, e->data, e->size);
 			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-				"Tag '%s' was of format '%s' (which is "
+				_("Tag '%s' was of format '%s' (which is "
 				"against specification) and has been "
-				"changed to format '%s'.",
+				"changed to format '%s'."),
 				exif_tag_get_name (e->tag), 
 				exif_format_get_name (EXIF_FORMAT_LONG),
 				exif_format_get_name (EXIF_FORMAT_SHORT));
@@ -233,9 +244,9 @@ exif_entry_fix (ExifEntry *e)
 			}
 			e->format = EXIF_FORMAT_RATIONAL;
 			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-				"Tag '%s' was of format '%s' (which is "
+				_("Tag '%s' was of format '%s' (which is "
 				"against specification) and has been "
-				"changed to format '%s'.",
+				"changed to format '%s'."),
 				exif_tag_get_name (e->tag),
 				exif_format_get_name (EXIF_FORMAT_SRATIONAL),
 				exif_format_get_name (EXIF_FORMAT_RATIONAL));
@@ -250,30 +261,18 @@ exif_entry_fix (ExifEntry *e)
 		/* Format needs to be UNDEFINED. */
 		if (e->format != EXIF_FORMAT_UNDEFINED) {
 			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-				"Tag 'UserComment' had invalid format '%s'. "
-				"Format has been set to 'undefined'.",
+				_("Tag 'UserComment' had invalid format '%s'. "
+				"Format has been set to 'undefined'."),
 				exif_format_get_name (e->format));
 			e->format = EXIF_FORMAT_UNDEFINED;
 		}
+
 		/* Some packages like Canon ZoomBrowser EX 4.5 store
 		   only one zero byte followed by 7 bytes of rubbish */
 		if ((e->size >= 8) && (e->data[0] == 0)) {
 			memcpy(e->data, "\0\0\0\0\0\0\0\0", 8);
 		}
 
-		/* Some cameras fill the tag with '\0' or ' '. */
-		for (i = 0; i < e->size &&
-			    (!e->data[i] || (e->data[i] == ' ')); i++);
-		if (i && (i == e->size)) {
-			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-				"Tag 'UserComment' contained unnecessary "
-				"data which has been removed.");
-			exif_mem_free (e->priv->mem, e->data);
-			e->data = NULL;
-			e->size = 0;
-			e->components = 0;
-		}
-
 		/* There need to be at least 8 bytes. */
 		if (e->size < 8) {
 			e->data = exif_entry_realloc (e, e->data, 8 + e->size);
@@ -289,9 +288,9 @@ exif_entry_fix (ExifEntry *e)
 			e->size += 8;
 			e->components += 8;
 			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-				"Tag 'UserComment' has been expanded to at "
+				_("Tag 'UserComment' has been expanded to at "
 				"least 8 bytes in order to follow the "
-				"specification.");
+				"specification."));
 			break;
 		}
 
@@ -300,14 +299,20 @@ exif_entry_fix (ExifEntry *e)
 		 * afterwards, let's assume ASCII and claim the 8 first
 		 * bytes for the format specifyer.
 		 */
-		if (i >= 8) {
+		for (i = 0; (i < e->size) && !e->data[i]; i++);
+		if (!i) for ( ; (i < e->size) && (e->data[i] == ' '); i++);
+		if ((i >= 8) && (i < e->size)) {
 			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-				"Tag 'UserComment' did not start with "
+				"Tag 'UserComment' is not empty but does not start with "
 				"format identifyer. This has been fixed.");
 			memcpy (e->data, "ASCII\0\0\0", 8);
+			break;
 		}
 
-		/* First 8 bytes need to follow the specification. */
+		/* 
+		 * First 8 bytes need to follow the specification. If they don't, 
+		 * assume ASCII.
+		 */
 		if (memcmp (e->data, "ASCII\0\0\0"     , 8) &&
 		    memcmp (e->data, "UNICODE\0"       , 8) &&
 		    memcmp (e->data, "JIS\0\0\0\0\0"   , 8) &&
@@ -325,8 +330,8 @@ exif_entry_fix (ExifEntry *e)
 			e->size += 8;
 			e->components += 8;
 			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-				"Tag 'UserComment' did not start with "
-				"format identifyer. This has been fixed.");
+				_("Tag 'UserComment' did not start with "
+				"format identifier. This has been fixed."));
 			break;
 		}
 
@@ -384,10 +389,11 @@ exif_entry_dump (ExifEntry *e, unsigned int indent)
 	}								\
 }
 
-static struct {
+static const struct {
 	ExifTag tag;
 	const char *strings[10];
 } list[] = {
+#ifndef NO_VERBOSE_TAG_DATA
   { EXIF_TAG_PLANAR_CONFIGURATION,
     { N_("chunky format"), N_("planar format"), NULL}},
   { EXIF_TAG_SENSING_METHOD,
@@ -401,7 +407,9 @@ static struct {
       N_("right - bottom"), N_("left - bottom"), NULL}},
   { EXIF_TAG_YCBCR_POSITIONING,
     { "", N_("centered"), N_("co-sited"), NULL}},
-  { EXIF_TAG_PHOTOMETRIC_INTERPRETATION, {"", N_("RGB"), N_("YCbCr"), NULL}},
+  { EXIF_TAG_PHOTOMETRIC_INTERPRETATION,
+    {N_("Reversed mono"), N_("Normal mono"), N_("RGB"), N_("Palette"), "",
+      N_("CMYK"), N_("YCbCr"), "", N_("CieLAB"), NULL}},
   { EXIF_TAG_CUSTOM_RENDERED,
     { N_("Normal process"), N_("Custom process"), NULL}},
   { EXIF_TAG_EXPOSURE_MODE,
@@ -418,16 +426,18 @@ static struct {
     { N_("Normal"), N_("Low saturation"), N_("High saturation"), NULL}},
   { EXIF_TAG_CONTRAST , {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
   { EXIF_TAG_SHARPNESS, {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
+#endif
   { 0, {NULL}}
 };
 
-static struct {
+static const struct {
   ExifTag tag;
   struct {
     int index;
     const char *values[4];
   } elem[25];
 } list2[] = {
+#ifndef NO_VERBOSE_TAG_DATA
   { EXIF_TAG_METERING_MODE,
     { {  0, {N_("Unknown"), NULL}},
       {  1, {N_("Average"), N_("avg"), NULL}},
@@ -442,6 +452,9 @@ static struct {
     { {1, {N_("Uncompressed"), NULL}},
       {5, {N_("LZW compression"), NULL}},
       {6, {N_("JPEG compression"), NULL}},
+      {7, {N_("JPEG compression"), NULL}},
+      {8, {N_("Deflate/ZIP compression"), NULL}},
+      {32773, {N_("PackBits compression"), NULL}},
       {0, {NULL}}}},
   { EXIF_TAG_LIGHT_SOURCE,
     { {  0, {N_("Unknown"), NULL}},
@@ -450,7 +463,7 @@ static struct {
       {  3, {N_("Tungsten incandescent light"), N_("Tungsten"), NULL}},
       {  4, {N_("Flash"), NULL}},
       {  9, {N_("Fine weather"), NULL}},
-      { 10, {N_("Cloudy weather"), N_("cloudy"), NULL}},
+      { 10, {N_("Cloudy weather"), N_("Cloudy"), NULL}},
       { 11, {N_("Shade"), NULL}},
       { 12, {N_("Daylight fluorescent"), NULL}},
       { 13, {N_("Day white fluorescent"), NULL}},
@@ -481,7 +494,7 @@ static struct {
       {4, {N_("Shutter priority"),N_("Shutter"), NULL}},
       {5, {N_("Creative program (biased toward depth of field)"),
 	   N_("Creative"), NULL}},
-      {6, {N_("Creative program (biased toward fast shutter speed"),
+      {6, {N_("Creative program (biased toward fast shutter speed)"),
 	   N_("Action"), NULL}},
       {7, {N_("Portrait mode (for closeup photos with the background out "
 	      "of focus)"), N_("Portrait"), NULL}},
@@ -494,12 +507,13 @@ static struct {
       {0x0005, {N_("Strobe return light not detected."), N_("W/o strobe"),
 		NULL}},
       {0x0007, {N_("Strobe return light detected."), N_("W. strobe"), NULL}},
-      {0x0009, {N_("Flash fired, compulsatory flash mode"), NULL}},
-      {0x000d, {N_("Flash fired, compulsatory flash mode, return light "
+      {0x0008, {N_("Flash did not fire."), NULL}}, /* Olympus E-330 */
+      {0x0009, {N_("Flash fired, compulsory flash mode."), NULL}},
+      {0x000d, {N_("Flash fired, compulsory flash mode, return light "
 		   "not detected."), NULL}},
-      {0x000f, {N_("Flash fired, compulsatory flash mode, return light "
+      {0x000f, {N_("Flash fired, compulsory flash mode, return light "
 		   "detected."), NULL}},
-      {0x0010, {N_("Flash did not fire, compulsatory flash mode."), NULL}},
+      {0x0010, {N_("Flash did not fire, compulsory flash mode."), NULL}},
       {0x0018, {N_("Flash did not fire, auto mode."), NULL}},
       {0x0019, {N_("Flash fired, auto mode."), NULL}},
       {0x001d, {N_("Flash fired, auto mode, return light not detected."),
@@ -514,11 +528,11 @@ static struct {
       {0x0049, {N_("Flash fired, compulsory flash mode, red-eye reduction "
 		   "mode."), NULL}},
       {0x004d, {N_("Flash fired, compulsory flash mode, red-eye reduction "
-		  "mode, return light not detected"), NULL}},
-      {0x004f, {N_("Flash fired, compulsory flash mode, red-eye reduction, "
-		   "return light detected"), NULL}},
-      {0x0058, {N_("Flash did not fire, auto mode, red-eye reduction mode"), NULL}},
-      {0x0059, {N_("Flash fired, auto mode, red-eye reduction mode"), NULL}},
+		  "mode, return light not detected."), NULL}},
+      {0x004f, {N_("Flash fired, compulsory flash mode, red-eye reduction mode, "
+		   "return light detected."), NULL}},
+      {0x0058, {N_("Flash did not fire, auto mode, red-eye reduction mode."), NULL}},
+      {0x0059, {N_("Flash fired, auto mode, red-eye reduction mode."), NULL}},
       {0x005d, {N_("Flash fired, auto mode, return light not detected, "
 		   "red-eye reduction mode."), NULL}},
       {0x005f, {N_("Flash fired, auto mode, return light detected, "
@@ -527,13 +541,16 @@ static struct {
   {EXIF_TAG_SUBJECT_DISTANCE_RANGE, 
     { {0, {N_("Unknown"), N_("?"), NULL}},
       {1, {N_("Macro"), NULL}},
-      {2, {N_("Close view"), N_("close"), NULL}},
-      {3, {N_("Distant view"), N_("distant"), NULL}},
+      {2, {N_("Close view"), N_("Close"), NULL}},
+      {3, {N_("Distant view"), N_("Distant"), NULL}},
       {0, {NULL}}}},
   { EXIF_TAG_COLOR_SPACE,
     { {1, {N_("sRGB"), NULL}},
-      {0xffff, {N_("Uncalibrated"), NULL}}}},
-  {0, }
+      {2, {N_("Adobe RGB"), NULL}},
+      {0xffff, {N_("Uncalibrated"), NULL}},
+      {0x0000, {NULL}}}},
+#endif
+  {0, { { 0, {NULL}}} }
 };
 
 const char *
@@ -552,8 +569,8 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 	ExifByteOrder o;
 	double d;
 	ExifEntry *entry;
-	static struct {
-		char *label;
+	static const struct {
+		const char *label;
 		char major, minor;
 	} versions[] = {
 		{"0110", 1,  1},
@@ -566,18 +583,24 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 	};
 
 	/* FIXME: This belongs to somewhere else. */
-	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	/* libexif should use the default system locale.
+	 * If an application specifically requires UTF-8, then we
+	 * must give the application a way to tell libexif that.
+	 * 
+	 * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	 */
 	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 
+	/* make sure the returned string is zero terminated */
+	memset (val, 0, maxlen);
+	maxlen--;
+	memset (b, 0, sizeof (b));
+
 	/* We need the byte order */
 	if (!e || !e->parent || !e->parent->parent)
 		return val;
 	o = exif_data_get_byte_order (e->parent->parent);
 
-	memset (val, 0, maxlen);
-	memset (b, 0, sizeof (b));
-	maxlen--;
-
 	/* Sanity check */
 	if (e->size != e->components * exif_format_get_size (e->format)) {
 		snprintf (val, maxlen, _("Invalid size of entry (%i, "
@@ -632,11 +655,11 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		 * Print as much as possible.
 		 */
 		exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-			"Tag UserComment does not comply "
-			"with standard but contains data.");
+			_("Tag UserComment does not comply "
+			"with standard but contains data."));
 		for (; (i < e->size)  && (strlen (val) < maxlen - 1); i++) {
 			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
-				"Byte at position %i: 0x%02x", i, e->data[i]);
+				_("Byte at position %i: 0x%02x"), i, e->data[i]);
 			val[strlen (val)] =
 				isprint (e->data[i]) ? e->data[i] : '.';
 		}
@@ -674,7 +697,7 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		 * Some cameras store a string like "   " here. Ignore it.
 		 */
 		if (e->size && e->data &&
-		    (strspn (e->data, " ") != strlen ((char *) e->data)))
+		    (strspn ((char *)e->data, " ") != strlen ((char *) e->data)))
 			strncpy (val, (char *) e->data, MIN (maxlen, e->size));
 		else
 			strncpy (val, _("[None]"), maxlen);
@@ -682,14 +705,15 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		strncat (val, _("(Photographer)"), maxlen - strlen (val));
 
 		/* Second part: Editor. */
-		t = e->data + strlen ((char *) e->data) + 1;
-		ts = e->data + e->size - t;
 		strncat (val, " - ", maxlen - strlen (val));
-		if (e->size && e->data && (ts > 0) &&
-		    (strspn (t, " ") != ts))
-			strncat (val, t, MIN (maxlen - strlen (val), ts));
-		else
+		if (e->size && e->data) {
+		    t = e->data + strlen ((char *) e->data) + 1;
+		    ts = e->data + e->size - t;
+		    if ((ts > 0) && (strspn ((char *)t, " ") != ts))
+			strncat (val, (char *)t, MIN (maxlen - strlen (val), ts));
+		} else {
 			strncat (val, _("[None]"), maxlen - strlen (val));
+		}
 		strncat (val, " ", maxlen - strlen (val));
 		strncat (val, _("(Editor)"), maxlen - strlen (val));
 
@@ -699,17 +723,20 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		CC (e, 1, val, maxlen);
 		v_rat = exif_get_rational (e->data, o);
 		if (!v_rat.denominator) return val;
-		snprintf (val, maxlen, "f/%.01f", (float) v_rat.numerator /
-						    (float) v_rat.denominator);
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, "f/%.01lf", d);
 		break;
 	case EXIF_TAG_APERTURE_VALUE:
+	case EXIF_TAG_MAX_APERTURE_VALUE:
 		CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
 		CC (e, 1, val, maxlen);
 		v_rat = exif_get_rational (e->data, o);
 		if (!v_rat.denominator) return val;
-		snprintf (val, maxlen, "f/%.01f",
-			  pow (2 , ((float) v_rat.numerator /
-				    (float) v_rat.denominator) / 2.));
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, _("%.02lf EV"), d);
+		snprintf (b, sizeof (b), _(" (f/%.01f)"), pow (2, d / 2.));
+		if (maxlen > strlen (val) + strlen (b))
+			strncat (val, b, maxlen - strlen (val) - 1);
 		break;
 	case EXIF_TAG_FOCAL_LENGTH:
 		CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
@@ -726,14 +753,14 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		entry = exif_content_get_entry (
 			e->parent->parent->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
 		if (entry && entry->data &&
-		    !strncmp (entry->data, "Minolta", 7)) {
+		    !strncmp ((char *)entry->data, "Minolta", 7)) {
 			entry = exif_content_get_entry (
 					e->parent->parent->ifd[EXIF_IFD_0],
 					EXIF_TAG_MODEL);
 			if (entry && entry->data) {
-				if (!strncmp (entry->data, "DiMAGE 7", 8))
+				if (!strncmp ((char *)entry->data, "DiMAGE 7", 8))
 					d = 3.9;
-				else if (!strncmp (entry->data, "DiMAGE 5", 8))
+				else if (!strncmp ((char *)entry->data, "DiMAGE 5", 8))
 					d = 4.9;
 			}
 		}
@@ -742,8 +769,8 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 				  (int) (d * (double) v_rat.numerator /
 				  	     (double) v_rat.denominator));
 
-		snprintf (val, maxlen, "%.1f mm",
-			(float) v_rat.numerator / (float) v_rat.denominator);
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, "%.1lf mm", d);
 		if (maxlen > strlen (val) + strlen (b))
 			strncat (val, b, maxlen - strlen (val) - 1);
 		break;
@@ -752,8 +779,8 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		CC (e, 1, val, maxlen);
 		v_rat = exif_get_rational (e->data, o);
 		if (!v_rat.denominator) return val;
-		snprintf (val, maxlen, "%.1f m", (float) v_rat.numerator /
-						   (float) v_rat.denominator);
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, "%.1lf m", d);
 		break;
 	case EXIF_TAG_EXPOSURE_TIME:
 		CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
@@ -762,8 +789,7 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		if (!v_rat.denominator) return val;
 		d = (double) v_rat.numerator / (double) v_rat.denominator;
 		if (d < 1)
-			snprintf (val, maxlen, _("1/%d"),
-				  (int) (1. / d));
+			snprintf (val, maxlen, _("1/%d"), (int) (0.5 + 1. / d));
 		else
 			snprintf (val, maxlen, _("%d"), (int) d);
 		if (maxlen > strlen (val) + strlen (_(" sec.")))
@@ -774,23 +800,32 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		CC (e, 1, val, maxlen);
 		v_srat = exif_get_srational (e->data, o);
 		if (!v_srat.denominator) return val;
-		snprintf (val, maxlen, "%.0f/%.0f", (float) v_srat.numerator,
-			  (float) v_srat.denominator);
-		if (maxlen > strlen (val) + strlen (_(" sec.")))
-			strncat (val, _(" sec."), maxlen - strlen (val) - 1);
-		snprintf (b, sizeof (b), " (APEX: %i)",
-			(int) pow (sqrt(2), (float) v_srat.numerator /
-				            (float) v_srat.denominator));
+		d = (double) v_srat.numerator / (double) v_srat.denominator;
+		snprintf (val, maxlen, _("%.02f EV"), d);
+		snprintf (b, sizeof (b), " (APEX: %i)", (int) pow (sqrt(2), d));
 		if (maxlen > strlen (val) + strlen (b))
 			strncat (val, b, maxlen - strlen (val) - 1);
+    d = 1. / pow (2, d);
+    if (d < 1)
+      snprintf (b, sizeof (b), _(" 1/%d sec.)"), (int) (1. / d));
+    else
+      snprintf (b, sizeof (b), _(" %d sec.)"), (int) d);
+    if (maxlen > strlen (val) + strlen (b)) {
+      val[strlen (val) - 1] = ',';
+      strncat (val, b, maxlen - strlen (val) - 1);
+    }
 		break;
 	case EXIF_TAG_BRIGHTNESS_VALUE:
 		CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
 		CC (e, 1, val, maxlen);
 		v_srat = exif_get_srational (e->data, o);
-		snprintf (val, maxlen, "%i/%i", (int) v_srat.numerator,
-						  (int) v_srat.denominator);
-		/* FIXME: How do I calculate the APEX value? */
+		if (!v_srat.denominator) return val;
+		d = (double) v_srat.numerator / (double) v_srat.denominator;
+		snprintf (val, maxlen, _("%.02f EV"), d);
+		snprintf (b, sizeof (b), _(" (%.02f cd/m^2)"),
+			1. / (M_PI * 0.3048 * 0.3048) * pow (2, d));
+		if (maxlen > strlen (val) + strlen (b))
+			strncat (val, b, maxlen - strlen (val) - 1);
 		break;
 	case EXIF_TAG_FILE_SOURCE:
 		CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
@@ -823,10 +858,8 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		CC (e, 1, val, maxlen);
 		v_srat = exif_get_srational (e->data, o);
 		if (!v_srat.denominator) return val;
-		snprintf (val, maxlen, "%s%.01f",
-			  v_srat.denominator * v_srat.numerator > 0 ? "+" : "",
-			  (double) v_srat.numerator /
-			  (double) v_srat.denominator);
+		d = (double) v_srat.numerator / (double) v_srat.denominator;
+		snprintf (val, maxlen, _("%.02f EV"), d);
 		break;
 	case EXIF_TAG_YCBCR_SUB_SAMPLING:
 		CF (e, EXIF_FORMAT_SHORT, val, maxlen);
@@ -842,11 +875,6 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		else
 			snprintf (val, maxlen, "%i, %i", v_short, v_short2);
 		break;
-	case EXIF_TAG_MAKER_NOTE:
-		CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
-		snprintf (val, maxlen, _("%i bytes unknown data"),
-			  (int) e->components);
-		break;
 	case EXIF_TAG_SUBJECT_AREA:
 		CF (e, EXIF_FORMAT_SHORT, val, maxlen);
 		switch (e->components) {
@@ -896,26 +924,26 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		/* Search the tag */
 		for (i = 0; list2[i].tag && (list2[i].tag != e->tag); i++);
 		if (!list2[i].tag) {
-			strncpy (val, "Internal error.", maxlen - 1);
+			snprintf (val, maxlen, _("Internal error (unknown "
+				  "value %i)"), v_short);
 			break;
 		}
 
 		/* Find the value */
-		for (j = 0; list2[i].elem[j].values &&
+		for (j = 0; list2[i].elem[j].values[0] &&
 			    (list2[i].elem[j].index < v_short); j++);
 		if (list2[i].elem[j].index != v_short) {
-			snprintf (val, maxlen, "Internal error (unknown "
-				  "value %i).", v_short);
+			snprintf (val, maxlen, _("Internal error (unknown "
+				  "value %i)"), v_short);
 			break;
 		}
 
 		/* Find a short enough value */
 		memset (val, 0, maxlen);
-		for (k = 0; list2[i].elem[j].values &&
-			    list2[i].elem[j].values[k]; k++) {
+		for (k = 0; list2[i].elem[j].values[k]; k++) {
 		  l = strlen (_(list2[i].elem[j].values[k]));
 		  if ((maxlen > l) && (strlen (val) < l))
-		    strncpy (val, _(list2[i].elem[j].values[k]), maxlen - 1);
+		    strncpy (val, _(list2[i].elem[j].values[k]), maxlen);
 		}
 		if (!strlen (val)) snprintf (val, maxlen, "%i", v_short);
 
@@ -940,7 +968,8 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		/* Search the tag */
 		for (i = 0; list[i].tag && (list[i].tag != e->tag); i++);
 		if (!list[i].tag) {
-			strncpy (val, "Internal error.", maxlen - 1);
+			snprintf (val, maxlen, _("Internal error (unknown "
+				  "value %i)"), v_short);
 			break;
 		}
 
@@ -948,13 +977,35 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 		for (j = 0; list[i].strings[j] && (j < v_short); j++);
 		if (!list[i].strings[j])
 			snprintf (val, maxlen, "%i", v_short);
+		else if (!*list[i].strings[j])
+			val[0] = 0;
 		else
-			strncpy (val, _(list[i].strings[j]), maxlen - 1);
-		break; 	
+			strncpy (val, _(list[i].strings[j]), maxlen);
+		break;
+	case EXIF_TAG_XP_TITLE:
+	case EXIF_TAG_XP_COMMENT:
+	case EXIF_TAG_XP_AUTHOR:
+	case EXIF_TAG_XP_KEYWORDS:
+	case EXIF_TAG_XP_SUBJECT:
+		/* Warning! The texts are converted from UTF16 to UTF8 */
+		exif_convert_utf16_to_utf8(val, (unsigned short*)e->data, MIN(maxlen, e->size));
+		break;
+	case EXIF_TAG_INTEROPERABILITY_VERSION:
+		if (e->format == EXIF_FORMAT_UNDEFINED) {
+			strncpy (val, (char *) e->data, MIN (maxlen, e->size));
+			break;
+		}
+		/* Fall through - EXIF_TAG_GPS_LATITUDE is same as INTEROPERABILITY_VERSION */
 	default:
-		if (!e->components) break;
+		if (!e->size) break;
 		switch (e->format) {
 		case EXIF_FORMAT_UNDEFINED:
+			if ((e->tag == EXIF_TAG_SCENE_TYPE) && (e->size == 1)) {
+				snprintf (val, maxlen, "%i", e->data[0]);
+			} else {
+				snprintf (val, maxlen, _("%i bytes undefined data"),
+					  e->size);
+			}
 			break;
 		case EXIF_FORMAT_BYTE:
 		case EXIF_FORMAT_SBYTE:
@@ -1019,20 +1070,29 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 			break;
 		case EXIF_FORMAT_RATIONAL:
 			v_rat = exif_get_rational (e->data, o);
-			if (v_rat.denominator) {
-				snprintf (val, maxlen, "%2.2f", (double)v_rat.numerator / v_rat.denominator);
-			} else {
-				snprintf (val, maxlen, "%i/%i", v_rat.numerator,  v_rat.denominator);
-			}
+			if (v_rat.denominator)
+				snprintf (val, maxlen, "%2.2lf",
+				          (double) v_rat.numerator /
+					  (double) v_rat.denominator);
+			else
+				snprintf (val, maxlen, "%2.2lf/%2.2lf",
+				          (double) v_rat.numerator,
+					  (double) v_rat.denominator);
 			maxlen -= strlen (val);
 			for (i = 1; i < e->components; i++) {
 				v_rat = exif_get_rational (
 					e->data + 8 * i, o);
-				snprintf (b, sizeof (b), ", %2.2f",
-					   (double)v_rat.numerator / v_rat.denominator);
+				if (v_rat.denominator)
+					snprintf (b, sizeof (b), ", %2.2lf",
+					          (double) v_rat.numerator /
+					          (double) v_rat.denominator);
+				else
+					snprintf (b, sizeof (b), ", %2.2lf/%2.2lf",
+					          (double) v_rat.numerator,
+						  (double) v_rat.denominator);
 				strncat (val, b, maxlen);
 				maxlen -= strlen (b);
-				if ((signed)maxlen <= 0) break;
+				if ((signed) maxlen <= 0) break;
 			}
 			break;
 		case EXIF_FORMAT_SRATIONAL:
@@ -1064,6 +1124,10 @@ exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
 	return val;
 }
 
+
+/**
+ * \bug Log and report failed exif_mem_malloc() calls.
+ */
 void
 exif_entry_initialize (ExifEntry *e, ExifTag tag)
 {
@@ -1092,6 +1156,7 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		e->format = EXIF_FORMAT_LONG;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		break;
 
 	/* SHORT, 1 component, no default */
@@ -1104,8 +1169,8 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 	case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
 	case EXIF_TAG_GAIN_CONTROL:
 	case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
-	case EXIF_TAG_FLASH:
 	case EXIF_TAG_COLOR_SPACE:
+	case EXIF_TAG_FLASH:
 
 	/* SHORT, 1 component, default 0 */
 	case EXIF_TAG_IMAGE_WIDTH:
@@ -1122,36 +1187,40 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		e->format = EXIF_FORMAT_SHORT;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		exif_set_short (e->data, o, 0);
 		break;
 
 	/* SHORT, 1 component, default 1 */
-	case EXIF_TAG_ORIENTATION:
-	case EXIF_TAG_PLANAR_CONFIGURATION:
-	case EXIF_TAG_YCBCR_POSITIONING:
+    case EXIF_TAG_ORIENTATION:
+    case EXIF_TAG_PLANAR_CONFIGURATION:
+    case EXIF_TAG_YCBCR_POSITIONING:
 		e->components = 1;
 		e->format = EXIF_FORMAT_SHORT;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		exif_set_short (e->data, o, 1);
 		break;
 
 	/* SHORT, 1 component, default 2 */
-	case EXIF_TAG_RESOLUTION_UNIT:
+    case EXIF_TAG_RESOLUTION_UNIT:
 	case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
 		e->components = 1;
 		e->format = EXIF_FORMAT_SHORT;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		exif_set_short (e->data, o, 2);
 		break;
 
 	/* SHORT, 1 component, default 3 */
-	case EXIF_TAG_SAMPLES_PER_PIXEL:
+    case EXIF_TAG_SAMPLES_PER_PIXEL:
 		e->components = 1;
 		e->format = EXIF_FORMAT_SHORT;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		exif_set_short (e->data, o, 3);
 		break;
 
@@ -1198,6 +1267,7 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		e->format = EXIF_FORMAT_SRATIONAL;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		break;
 
 	/* RATIONAL, 1 component, no default */
@@ -1218,6 +1288,7 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		e->format = EXIF_FORMAT_RATIONAL;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		break;
 
 	/* RATIONAL, 1 component, default 72/1 */
@@ -1227,6 +1298,7 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		e->format = EXIF_FORMAT_RATIONAL;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		r.numerator = 72;
 		r.denominator = 1;
 		exif_set_rational (e->data, o, r);
@@ -1238,6 +1310,7 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		e->format = EXIF_FORMAT_RATIONAL;
 		e->size = exif_format_get_size (e->format) * e->components;
 		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) break;
 		break;
 
 	/* RATIONAL, 6 components */
@@ -1267,6 +1340,21 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 			e->data + 5 * exif_format_get_size (e->format), o, r);
 		break;
 
+	/* EXIF_FORMAT_ASCII, 13 components */
+	case EXIF_TAG_RELATED_SOUND_FILE:
+		e->components = 13;
+		e->format = EXIF_FORMAT_ASCII;
+		e->size = exif_format_get_size (e->format) * e->components;
+		e->data = exif_entry_alloc (e, e->size);
+		break;
+
+	case EXIF_TAG_IMAGE_UNIQUE_ID:
+		e->components = 33;
+		e->format = EXIF_FORMAT_ASCII;
+		e->size = exif_format_get_size (e->format) * e->components;
+		e->data = exif_entry_alloc (e, e->size);
+		break;
+
 	/* ASCII, 20 components, default current time */
 	case EXIF_TAG_DATE_TIME:
 	case EXIF_TAG_DATE_TIME_ORIGINAL:
@@ -1284,21 +1372,6 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 			  tm->tm_hour, tm->tm_min, tm->tm_sec);
 		break;
 
-	/* EXIF_FORMAT_ASCII, 13 components */
-	case EXIF_TAG_RELATED_SOUND_FILE:
-		e->components = 13;
-		e->format = EXIF_FORMAT_ASCII;
-		e->size = exif_format_get_size (e->format) * e->components;
-		e->data = exif_entry_alloc (e, e->size);
-		break;
-
-	case EXIF_TAG_IMAGE_UNIQUE_ID:
-		e->components = 33;
-		e->format = EXIF_FORMAT_ASCII;
-		e->size = exif_format_get_size (e->format) * e->components;
-		e->data = exif_entry_alloc (e, e->size);
-		break;
-
 	/* ASCII, any components, no default */
 	case EXIF_TAG_SPECTRAL_SENSITIVITY:
 	case EXIF_TAG_SUB_SEC_TIME:
@@ -1317,12 +1390,14 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		break;
 
 	/* UNDEFINED, no components, no default */
+	/* Use this if the tag is otherwise unsupported */
 	case EXIF_TAG_OECF:											 
 	case EXIF_TAG_SPATIAL_FREQUENCY_RESPONSE:
 	case EXIF_TAG_NEW_CFA_PATTERN:					 
 	case EXIF_TAG_DEVICE_SETTING_DESCRIPTION:
 	case EXIF_TAG_MAKER_NOTE:
 	case EXIF_TAG_USER_COMMENT:
+	default:
 		e->components = 0;
 		e->format = EXIF_FORMAT_UNDEFINED;
 		e->size = 0;
@@ -1350,24 +1425,24 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		break;
 
 	/* UNDEFINED, 4 components, default 0 1 0 0 */
-	case EXIF_TAG_FLASH_PIX_VERSION:
-		e->components = 4;
-		e->format = EXIF_FORMAT_UNDEFINED;
-		e->size = exif_format_get_size (e->format) * e->components;
-		e->data = exif_entry_alloc (e, e->size);
+        case EXIF_TAG_FLASH_PIX_VERSION:
+                e->components = 4;
+                e->format = EXIF_FORMAT_UNDEFINED;
+                e->size = exif_format_get_size (e->format) * e->components;
+                e->data = exif_entry_alloc (e, e->size);
 		if (!e->data) break;
-			memcpy (e->data, "0100", 4);
-		break;
-
-	/* UNDEFINED, 4 components, default 0 2 1 0 */
-	case EXIF_TAG_EXIF_VERSION:
-		e->components = 4;
-		e->format = EXIF_FORMAT_UNDEFINED;
-		e->size = exif_format_get_size (e->format) * e->components;
-		e->data = exif_entry_alloc (e, e->size);
+                memcpy (e->data, "0100", 4);
+                break;
+
+        /* UNDEFINED, 4 components, default 0 2 1 0 */
+        case EXIF_TAG_EXIF_VERSION:
+                e->components = 4;
+                e->format = EXIF_FORMAT_UNDEFINED;
+                e->size = exif_format_get_size (e->format) * e->components;
+                e->data = exif_entry_alloc (e, e->size);
 		if (!e->data) break;
-			memcpy (e->data, "0210", 4);
-		break;
+                memcpy (e->data, "0210", 4);
+                break;
 
 	/* UNDEFINED, 4 components, no default */
 	case EXIF_TAG_COMPONENTS_CONFIGURATION:
@@ -1377,7 +1452,5 @@ exif_entry_initialize (ExifEntry *e, ExifTag tag)
 		e->data = malloc (e->size);
 		break;
 
-	default:
-		break;
 	}
 }
diff --git a/src/libexif/exif-entry.h b/src/libexif/exif-entry.h
index 072ee29..23731fe 100644
--- a/src/libexif/exif-entry.h
+++ b/src/libexif/exif-entry.h
@@ -1,6 +1,7 @@
-/* exif-entry.h
+/*! \file exif-entry.h
+ *  \brief Handling EXIF entries
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -32,6 +33,7 @@ typedef struct _ExifEntryPrivate ExifEntryPrivate;
 #include <libexif/exif-format.h>
 #include <libexif/exif-mem.h>
 
+/*! */
 struct _ExifEntry {
         ExifTag tag;
         ExifFormat format;
@@ -47,21 +49,44 @@ struct _ExifEntry {
 };
 
 /* Lifecycle */
+
+/*! Reserve memory for and initialize new #ExifEntry* */
 ExifEntry  *exif_entry_new     (void);
+
 ExifEntry  *exif_entry_new_mem (ExifMem *);
+
+/*! Increase reference counter for #ExifEntry* */
 void        exif_entry_ref     (ExifEntry *entry);
+
+/*! Decrease reference counter for #ExifEntry* */
 void        exif_entry_unref   (ExifEntry *entry);
+
+/*! Actually free the #ExifEntry*
+ *
+ * \deprecated Should not be called directly. Use exif_entry_ref() and
+ *             exif_entry_unref() instead.
+ */
 void        exif_entry_free  (ExifEntry *entry);
 
 void        exif_entry_initialize (ExifEntry *entry, ExifTag tag);
 void        exif_entry_fix        (ExifEntry *entry);
 
 /* For your convenience */
+
+/*! Return the value of the EXIF entry
+ *
+ * CAUTION: The character set of the returned string is not defined.
+ *          It may be UTF-8, latin1, the native encoding of the
+ *          computer, or the native encoding of the camera.
+ */
 const char *exif_entry_get_value (ExifEntry *entry, char *val,
 				  unsigned int maxlen);
 
+/*! Dump text representation of #ExifEntry to stdout */
 void        exif_entry_dump      (ExifEntry *entry, unsigned int indent);
 
+#define exif_entry_get_ifd(e) ((e)?exif_content_get_ifd((e)->parent):EXIF_IFD_COUNT)
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/src/libexif/exif-format.c b/src/libexif/exif-format.c
index e0c3650..d432e9e 100644
--- a/src/libexif/exif-format.c
+++ b/src/libexif/exif-format.c
@@ -1,6 +1,6 @@
 /* exif-format.c
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -25,7 +25,7 @@
 
 #include <stdlib.h>
 
-static struct {
+static const struct {
         ExifFormat format;
 	const char *name;
         unsigned char size;
@@ -51,7 +51,12 @@ exif_format_get_name (ExifFormat format)
 	unsigned int i;
 
 	/* FIXME: This belongs to somewhere else. */
-	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	/* libexif should use the default system locale.
+	 * If an application specifically requires UTF-8, then we
+	 * must give the application a way to tell libexif that.
+	 * 
+	 * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	 */
 	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 
 	for (i = 0; ExifFormatTable[i].name; i++)
diff --git a/src/libexif/exif-format.h b/src/libexif/exif-format.h
index 0eae425..272c865 100644
--- a/src/libexif/exif-format.h
+++ b/src/libexif/exif-format.h
@@ -1,6 +1,6 @@
 /* exif-format.h
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/src/libexif/exif-ifd.c b/src/libexif/exif-ifd.c
index 96de261..7240dce 100644
--- a/src/libexif/exif-ifd.c
+++ b/src/libexif/exif-ifd.c
@@ -1,6 +1,6 @@
 /* exif-ifd.c
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -24,7 +24,7 @@
 
 #include <stdlib.h>
 
-static struct {
+static const struct {
 	ExifIfd ifd;
 	const char *name;
 } ExifIfdTable[] = {
diff --git a/src/libexif/exif-ifd.h b/src/libexif/exif-ifd.h
index 01f0019..48d2083 100644
--- a/src/libexif/exif-ifd.h
+++ b/src/libexif/exif-ifd.h
@@ -1,6 +1,6 @@
 /* exif-ifd.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -22,12 +22,12 @@
 #define __EXIF_IFD_H__
 
 typedef enum {
-	EXIF_IFD_0 = 0,
-	EXIF_IFD_1,
-	EXIF_IFD_EXIF,
-	EXIF_IFD_GPS,
-	EXIF_IFD_INTEROPERABILITY,
-	EXIF_IFD_COUNT
+	EXIF_IFD_0 = 0,                /*!< */
+	EXIF_IFD_1,                    /*!< */
+	EXIF_IFD_EXIF,                 /*!< */
+	EXIF_IFD_GPS,                  /*!< */
+	EXIF_IFD_INTEROPERABILITY,     /*!< */
+	EXIF_IFD_COUNT                 /*!< Not a real value, just (max_value + 1). */
 } ExifIfd;
 
 const char *exif_ifd_get_name (ExifIfd ifd);
diff --git a/src/libexif/exif-loader.c b/src/libexif/exif-loader.c
index d6eba7d..4e5b140 100644
--- a/src/libexif/exif-loader.c
+++ b/src/libexif/exif-loader.c
@@ -1,18 +1,46 @@
+/* exif-loader.c
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
 #include <config.h>
 
 #include <libexif/exif-loader.h>
+#include <libexif/exif-utils.h>
 #include <libexif/i18n.h>
 
+#include <sys/types.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
+#undef JPEG_MARKER_DHT
+#define JPEG_MARKER_DHT  0xc4
 #undef JPEG_MARKER_SOI
 #define JPEG_MARKER_SOI  0xd8
+#undef JPEG_MARKER_DQT
+#define JPEG_MARKER_DQT  0xdb
 #undef JPEG_MARKER_APP0
 #define JPEG_MARKER_APP0 0xe0
 #undef JPEG_MARKER_APP1
 #define JPEG_MARKER_APP1 0xe1
+#undef JPEG_MARKER_APP2
+#define JPEG_MARKER_APP2 0xe2
 #undef JPEG_MARKER_APP13
 #define JPEG_MARKER_APP13 0xed
 #undef JPEG_MARKER_COM
@@ -60,10 +88,12 @@ exif_loader_alloc (ExifLoader *l, unsigned int i)
 {
 	void *d;
 
-	if (!l || !i) return NULL;
+	if (!l || !i) 
+		return NULL;
 
 	d = exif_mem_alloc (l->mem, i);
-	if (d) return d;
+	if (d) 
+		return d;
 
 	EXIF_LOG_NO_MEMORY (l->log, "ExifLog", i);
 	return NULL;
@@ -79,7 +109,8 @@ exif_loader_write_file (ExifLoader *l, const char *path)
 	int size;
 	unsigned char data[1024];
 
-	if (!l) return;
+	if (!l) 
+		return;
 
 	f = fopen (path, "rb");
 	if (!f) {
@@ -89,8 +120,10 @@ exif_loader_write_file (ExifLoader *l, const char *path)
 	}
 	while (1) {
 		size = fread (data, 1, sizeof (data), f);
-		if (size <= 0) break;
-		if (!exif_loader_write (l, data, size)) break;
+		if (size <= 0) 
+			break;
+		if (!exif_loader_write (l, data, size)) 
+			break;
 	}
 	fclose (f);
 }
@@ -98,11 +131,14 @@ exif_loader_write_file (ExifLoader *l, const char *path)
 static unsigned int
 exif_loader_copy (ExifLoader *eld, unsigned char *buf, unsigned int len)
 {
-	if (!eld || (len && !buf) || (eld->bytes_read >= eld->size)) return 0;
+	if (!eld || (len && !buf) || (eld->bytes_read >= eld->size)) 
+		return 0;
 
 	/* If needed, allocate the buffer. */
-	if (!eld->buf) eld->buf = exif_loader_alloc (eld, eld->size);
-	if (!eld->buf) return 0;
+	if (!eld->buf) 
+		eld->buf = exif_loader_alloc (eld, eld->size);
+	if (!eld->buf) 
+		return 0;
 
 	/* Copy memory */
 	len = MIN (len, eld->size - eld->bytes_read);
@@ -117,13 +153,17 @@ exif_loader_write (ExifLoader *eld, unsigned char *buf, unsigned int len)
 {
 	unsigned int i;
 
-	if (!eld || (len && !buf)) return 0;
+	if (!eld || (len && !buf)) 
+		return 0;
 
 	switch (eld->state) {
 	case EL_EXIF_FOUND:
 		return exif_loader_copy (eld, buf, len);
 	case EL_SKIP_BYTES:
-		if (eld->size > len) { eld->size -= len; return 1; }
+		if (eld->size > len) { 
+			eld->size -= len; 
+			return 1; 
+		}
 		len -= eld->size;
 		buf += eld->size;
 		eld->size = 0;
@@ -141,6 +181,8 @@ exif_loader_write (ExifLoader *eld, unsigned char *buf, unsigned int len)
 		break;
 	}
 
+	if (!len)
+		return 1;
 	exif_log (eld->log, EXIF_LOG_CODE_DEBUG, "ExifLoader",
 		  "Scanning %i byte(s) of data...", len);
 
@@ -152,7 +194,8 @@ exif_loader_write (ExifLoader *eld, unsigned char *buf, unsigned int len)
 	if (i) {
 		memcpy (&eld->b[eld->b_len], buf, i);
 		eld->b_len += i;
-		if (eld->b_len < sizeof (eld->b)) return 1;
+		if (eld->b_len < sizeof (eld->b)) 
+			return 1;
 		buf += i;
 		len -= i;
 	}
@@ -183,11 +226,13 @@ exif_loader_write (ExifLoader *eld, unsigned char *buf, unsigned int len)
 		switch (eld->state) {
 		case EL_EXIF_FOUND:
 			if (!exif_loader_copy (eld, eld->b + i,
-					sizeof (eld->b) - i)) return 0;
+					sizeof (eld->b) - i)) 
+				return 0;
 			return exif_loader_copy (eld, buf, len);
 		case EL_SKIP_BYTES:
 			eld->size--;
-			if (!eld->size) eld->state = EL_READ;
+			if (!eld->size) 
+				eld->state = EL_READ;
 			break;
 
 		case EL_READ_SIZE_BYTE_24:
@@ -225,11 +270,18 @@ exif_loader_write (ExifLoader *eld, unsigned char *buf, unsigned int len)
 		default:
 			switch (eld->b[i]) {
 			case JPEG_MARKER_APP1:
-				eld->data_format = EL_DATA_FORMAT_EXIF;
+			  if (!memcmp (eld->b + i + 3, ExifHeader, MIN((ssize_t)(sizeof(ExifHeader)), MAX(0, ((ssize_t)(sizeof(eld->b))) - ((ssize_t)i) - 3)))) {
+					eld->data_format = EL_DATA_FORMAT_EXIF;
+				} else {
+					eld->data_format = EL_DATA_FORMAT_JPEG; /* Probably JFIF - keep searching for APP1 EXIF*/
+				}
 				eld->size = 0;
 				eld->state = EL_READ_SIZE_BYTE_08;
 				break;
+			case JPEG_MARKER_DHT:
+			case JPEG_MARKER_DQT:
 			case JPEG_MARKER_APP0:
+			case JPEG_MARKER_APP2:
 			case JPEG_MARKER_APP13:
 			case JPEG_MARKER_COM:
 				eld->data_format = EL_DATA_FORMAT_JPEG;
@@ -274,10 +326,12 @@ exif_loader_new_mem (ExifMem *mem)
 {
 	ExifLoader *loader;
 
-	if (!mem) return NULL;
+	if (!mem) 
+		return NULL;
 	
 	loader = exif_mem_alloc (mem, sizeof (ExifLoader));
-	if (!loader) return NULL;
+	if (!loader) 
+		return NULL;
 	loader->ref_count = 1;
 
 	loader->mem = mem;
@@ -289,7 +343,8 @@ exif_loader_new_mem (ExifMem *mem)
 void
 exif_loader_ref (ExifLoader *loader)
 {
-	if (loader) loader->ref_count++;
+	if (loader) 
+		loader->ref_count++;
 }
 
 static void
@@ -297,10 +352,12 @@ exif_loader_free (ExifLoader *loader)
 {
 	ExifMem *mem;
 
-	if (!loader) return;
+	if (!loader) 
+		return;
 
 	mem = loader->mem;
 	exif_loader_reset (loader);
+	exif_log_unref (loader->log);
 	exif_mem_free (mem, loader);
 	exif_mem_unref (mem);
 }
@@ -308,7 +365,8 @@ exif_loader_free (ExifLoader *loader)
 void
 exif_loader_unref (ExifLoader *loader)
 {
-	if (!loader) return;
+	if (!loader) 
+		return;
 	if (!--loader->ref_count)
 		exif_loader_free (loader);
 }
@@ -316,7 +374,8 @@ exif_loader_unref (ExifLoader *loader)
 void
 exif_loader_reset (ExifLoader *loader)
 {
-	if (!loader) return;
+	if (!loader) 
+		return;
 	exif_mem_free (loader->mem, loader->buf); loader->buf = NULL;
 	loader->size = 0;
 	loader->bytes_read = 0;
@@ -330,7 +389,9 @@ exif_loader_get_data (ExifLoader *loader)
 {
 	ExifData *ed;
 
-	if (!loader) return NULL;
+	if (!loader || (loader->data_format == EL_DATA_FORMAT_UNKNOWN) ||
+	    !loader->bytes_read)
+		return NULL;
 
 	ed = exif_data_new_mem (loader->mem);
 	exif_data_log (ed, loader->log);
@@ -342,7 +403,8 @@ exif_loader_get_data (ExifLoader *loader)
 void
 exif_loader_log (ExifLoader *loader, ExifLog *log)
 {
-	if (!loader) return;
+	if (!loader) 
+		return;
 	exif_log_unref (loader->log);
 	loader->log = log;
 	exif_log_ref (log);
diff --git a/src/libexif/exif-loader.h b/src/libexif/exif-loader.h
index cf900c8..697e019 100644
--- a/src/libexif/exif-loader.h
+++ b/src/libexif/exif-loader.h
@@ -1,6 +1,8 @@
-/* exif-loader.h
- *
- * Copyright © 2003 Lutz Müller <lutz@users.sourceforge.net>
+/*! \file exif-loader.h
+ * \brief Defines the ExifLoader type
+ */
+/*
+ * Copyright (c) 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -22,7 +24,6 @@
 #define __EXIF_LOADER_H__
 
 #include <libexif/exif-data.h>
-#include <libexif/exif-loader.h>
 #include <libexif/exif-log.h>
 #include <libexif/exif-mem.h>
 
@@ -32,21 +33,48 @@ extern "C" {
 
 typedef struct _ExifLoader ExifLoader;
 
+/*! Allocate a new ExifLoader
+ *  \returns the allocated ExifLoader
+ */
 ExifLoader *exif_loader_new     (void);
-ExifLoader *exif_loader_new_mem (ExifMem *);
-void        exif_loader_ref     (ExifLoader *);
-void        exif_loader_unref   (ExifLoader *);
+/*! Allocate a new ExifLoader using an ExifMem
+ *  \param[in] mem the ExifMem
+ *  \returns the allocated ExifLoader
+ */
+ExifLoader *exif_loader_new_mem (ExifMem *mem);
+/*! Increase the refcount of the ExifLoader
+ *  \param[in] loader the ExifLoader to increase the refcount of.
+ */
+void        exif_loader_ref     (ExifLoader *loader);
+/*! Decrease the refcount of the ExifLoader
+ *  \param[in] loader the ExifLoader to decrease the refcount of.
+ *  If the refcount reaches 0, the ExifLoader is freeed.
+ */
+void        exif_loader_unref   (ExifLoader *loader);
 
-void        exif_loader_write_file (ExifLoader *, const char *fname);
+/*! Write a file to the ExifLoader
+ * \param[in] loader the loader
+ * \param[in] fname the path to the file to read
+ */
+void        exif_loader_write_file (ExifLoader *loader, const char *fname);
 
-/*
- * Returns 1 while EXIF data is read (or while there is still 
- * hope that there will be EXIF data later on), 0 otherwise.
+/*! Write a buffer to the ExifLoader
+ * \param[in] loader the loader to write too
+ * \param[in] buf the buffer to read from
+ * \param[in] sz the size of the buffer
+ * \returns 1 while EXIF data is read (or while there is still hope that there will be EXIF data later on), 0 otherwise.
  */
-unsigned char exif_loader_write (ExifLoader *, unsigned char *, unsigned int);
+unsigned char exif_loader_write (ExifLoader *loader, unsigned char *buf, unsigned int sz);
 
-void          exif_loader_reset (ExifLoader *);
-ExifData     *exif_loader_get_data (ExifLoader *);
+/*! Reset the ExifLoader
+ * \param[in] loader the loader
+ */
+void          exif_loader_reset (ExifLoader *loader);
+/*! Get an ExifData out of an ExifLoader
+ * \param[in] loader the loader
+ * \returns and allocated ExifData
+ */
+ExifData     *exif_loader_get_data (ExifLoader *loader);
 
 void exif_loader_log (ExifLoader *, ExifLog *);
 
diff --git a/src/libexif/exif-log.c b/src/libexif/exif-log.c
index 5dde1ce..195bfe2 100644
--- a/src/libexif/exif-log.c
+++ b/src/libexif/exif-log.c
@@ -1,6 +1,6 @@
 /* exif-log.c
  *
- * Copyright © 2004 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2004 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -35,7 +35,7 @@ struct _ExifLog {
 	ExifMem *mem;
 };
 
-static struct {
+static const struct {
 	ExifLogCode code;
 	const char *title;
 	const char *message;
@@ -127,6 +127,10 @@ exif_log_set_func (ExifLog *log, ExifLogFunc func, void *data)
 	log->data = data;
 }
 
+#ifdef NO_VERBOSE_TAG_STRINGS
+/* exif_log forms part of the API and can't be commented away */
+#undef exif_log
+#endif
 void
 exif_log (ExifLog *log, ExifLogCode code, const char *domain,
 	  const char *format, ...)
diff --git a/src/libexif/exif-log.h b/src/libexif/exif-log.h
index 01eed3f..41f4bcf 100644
--- a/src/libexif/exif-log.h
+++ b/src/libexif/exif-log.h
@@ -1,7 +1,7 @@
 /*! \file exif-log.h
  *  \brief log message infrastructure
  *
- * Copyright © 2004 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2004 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -55,18 +55,28 @@ typedef void (* ExifLogFunc) (ExifLog *log, ExifLogCode, const char *domain,
  */
 void     exif_log_set_func (ExifLog *log, ExifLogFunc func, void *data);
 
+#ifndef NO_VERBOSE_TAG_STRINGS
 void     exif_log  (ExifLog *log, ExifLogCode, const char *domain,
 		    const char *format, ...)
 #ifdef __GNUC__
 			__attribute__((__format__(printf,4,5)))
 #endif
 ;
+#else
+#if defined(__STDC_VERSION__) &&  __STDC_VERSION__ >= 199901L
+#define exif_log(...) do { } while (0)
+#elif defined(__GNUC__)
+#define exif_log(x...) do { } while (0)
+#else
+#define exif_log (void)
+#endif
+#endif
 
 void     exif_logv (ExifLog *log, ExifLogCode, const char *domain,
 		    const char *format, va_list args);
 
 /* For your convenience */
-#define EXIF_LOG_NO_MEMORY(l,d,s) exif_log (l, EXIF_LOG_CODE_NO_MEMORY, d, "Could not allocate %i byte(s).", s)
+#define EXIF_LOG_NO_MEMORY(l,d,s) exif_log ((l), EXIF_LOG_CODE_NO_MEMORY, (d), "Could not allocate %lu byte(s).", (unsigned long)(s))
 
 #ifdef __cplusplus
 }
diff --git a/src/libexif/exif-mem.c b/src/libexif/exif-mem.c
index 12027d1..7290b9d 100644
--- a/src/libexif/exif-mem.c
+++ b/src/libexif/exif-mem.c
@@ -33,7 +33,8 @@ exif_mem_new (ExifMemAllocFunc alloc_func, ExifMemReallocFunc realloc_func,
 {
 	ExifMem *mem;
 
-	if (!alloc_func || !realloc_func) return NULL;
+	if (!alloc_func && !realloc_func) 
+		return NULL;
 	mem = alloc_func ? alloc_func (sizeof (ExifMem)) :
 		           realloc_func (NULL, sizeof (ExifMem));
 	if (!mem) return NULL;
diff --git a/src/libexif/exif-mem.h b/src/libexif/exif-mem.h
index aa774c6..454e034 100644
--- a/src/libexif/exif-mem.h
+++ b/src/libexif/exif-mem.h
@@ -1,6 +1,11 @@
+/*! \file exif-mem.h
+ *  \brief Define the ExifMem data type and the associated functions.
+ *  ExifMem defines the memory management functions used by the ExifLoader.
+ */
+
 /* exif-mem.h
  *
- * Copyright © 2003 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -27,24 +32,49 @@
 extern "C" {
 #endif /* __cplusplus */
 
-/* Should work like calloc: Needs to return initialized memory. */
-typedef void * (* ExifMemAllocFunc)   (ExifLong);
+/*! Should work like calloc()
+ *  \param[in] s the size of the block to allocate.
+ *  \returns the allocated memory and initialized. 
+ */
+typedef void * (* ExifMemAllocFunc)   (ExifLong s);
 
-typedef void * (* ExifMemReallocFunc) (void *, ExifLong);
-typedef void   (* ExifMemFreeFunc)    (void *);
+/*! Should work like realloc()
+ * \param[in] p the pointer to reallocate
+ * \param[in] s the size of the reallocated block
+ * \returns allocated memory 
+ */
+typedef void * (* ExifMemReallocFunc) (void *p, ExifLong s);
+/*! Free method for ExifMem
+ * \param[in] p the pointer to free
+ * \returns the freed pointer
+ */
+typedef void   (* ExifMemFreeFunc)    (void *p);
 
+/*! ExifMem define a memory allocator */
 typedef struct _ExifMem ExifMem;
 
-ExifMem *exif_mem_new   (ExifMemAllocFunc, ExifMemReallocFunc,
-			 ExifMemFreeFunc);
+/*! Create a new ExifMem
+ * \param[in] a the allocator function
+ * \param[in] r the reallocator function
+ * \param[in] f the free function
+ */
+ExifMem *exif_mem_new   (ExifMemAllocFunc a, ExifMemReallocFunc r,
+			 ExifMemFreeFunc f);
+/*! Refcount an ExifMem
+ */
 void     exif_mem_ref   (ExifMem *);
+/*! Unrefcount an ExifMem
+ * If the refcount reaches 0, the ExifMem is freed
+ */
 void     exif_mem_unref (ExifMem *);
 
-void *exif_mem_alloc   (ExifMem *, ExifLong);
-void *exif_mem_realloc (ExifMem *, void *, ExifLong);
-void  exif_mem_free    (ExifMem *, void *);
+void *exif_mem_alloc   (ExifMem *m, ExifLong s);
+void *exif_mem_realloc (ExifMem *m, void *p, ExifLong s);
+void  exif_mem_free    (ExifMem *m, void *p);
 
-/* For your convenience */
+/*! The default ExifMem for your convenience
+ * \returns return the default ExifMem
+ */
 ExifMem *exif_mem_new_default (void);
 
 #ifdef __cplusplus
diff --git a/src/libexif/exif-mnote-data-priv.h b/src/libexif/exif-mnote-data-priv.h
index 3a13883..f8e5317 100644
--- a/src/libexif/exif-mnote-data-priv.h
+++ b/src/libexif/exif-mnote-data-priv.h
@@ -1,6 +1,6 @@
 /* exif-mnote-data-priv.h
  *
- * Copyright © 2003 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/src/libexif/exif-mnote-data.c b/src/libexif/exif-mnote-data.c
index f55cdd4..efd8173 100644
--- a/src/libexif/exif-mnote-data.c
+++ b/src/libexif/exif-mnote-data.c
@@ -1,6 +1,6 @@
 /* exif-mnote-data.c
  *
- * Copyright (C) 2003 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (C) 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/src/libexif/exif-mnote-data.h b/src/libexif/exif-mnote-data.h
index 015f2ae..7c68393 100644
--- a/src/libexif/exif-mnote-data.h
+++ b/src/libexif/exif-mnote-data.h
@@ -1,6 +1,6 @@
 /* exif-mnote-data.h
  *
- * Copyright © 2003 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/src/libexif/exif-system.h b/src/libexif/exif-system.h
new file mode 100644
index 0000000..082db60
--- /dev/null
+++ b/src/libexif/exif-system.h
@@ -0,0 +1,31 @@
+/** \file exif-system.h
+ * \brief System specific definitions, not for installation!
+ *
+ * Copyright (C) 2007 Hans Ulrich Niedermann <gp@n-dimensional.de>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef EXIF_SYSTEM_H
+#define EXIF_SYSTEM_H
+
+#if defined(__GNUC__) && (__GNUC__ >= 2)
+# define UNUSED(param) UNUSED_PARAM_##param __attribute__((unused))
+#else
+# define UNUSED(param) param
+#endif
+
+#endif /* !defined(EXIF_SYSTEM_H) */
diff --git a/src/libexif/exif-tag.c b/src/libexif/exif-tag.c
index 7781611..7a8c7e1 100644
--- a/src/libexif/exif-tag.c
+++ b/src/libexif/exif-tag.c
@@ -1,6 +1,6 @@
 /* exif-tag.c
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -26,22 +26,28 @@
 #include <stdlib.h>
 #include <string.h>
 
-typedef enum {
-	ESL_MANDATORY    = 1, /* Mandatory               */
-	ESL_CMANDATORY   = 2, /* Conditionally mandatory */
-	ESL_OPTIONAL     = 3, /* Optional                */
-	ESL_NOT_RECORDED = 4  /* Not recorded            */
-} ExifSL;                     /* Exif Support Level      */
+#define ESL_NNNN { EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED }
+#define ESL_OOOO { EXIF_SUPPORT_LEVEL_OPTIONAL, EXIF_SUPPORT_LEVEL_OPTIONAL, EXIF_SUPPORT_LEVEL_OPTIONAL, EXIF_SUPPORT_LEVEL_OPTIONAL }
+#define ESL_MMMN { EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_NOT_RECORDED }
+#define ESL_MMMM { EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_MANDATORY }
+#define ESL_OMON { EXIF_SUPPORT_LEVEL_OPTIONAL, EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_OPTIONAL, EXIF_SUPPORT_LEVEL_NOT_RECORDED }
+#define ESL_NNOO { EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_OPTIONAL, EXIF_SUPPORT_LEVEL_OPTIONAL }
+#define ESL_NNMN { EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_NOT_RECORDED }
+#define ESL_NNMM { EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_MANDATORY, EXIF_SUPPORT_LEVEL_MANDATORY }
+#define ESL_NNNM { EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_MANDATORY }
+#define ESL_NNNO { EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_NOT_RECORDED, EXIF_SUPPORT_LEVEL_OPTIONAL }
+#define ESL_GPS { ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN }
 
-static struct {
+static const struct {
 	ExifTag tag;
 	const char *name;
 	const char *title;
 	const char *description;
-	ExifSL esl_0[4], esl_1[4], esl_exif[4], esl_gps[4];
+	ExifSupportLevel esl[EXIF_IFD_COUNT][4];
 } ExifTagTable[] = {
+#ifndef NO_VERBOSE_TAG_STRINGS
 	{EXIF_TAG_NEW_SUBFILE_TYPE, "NewSubfileType",
-	 "New Subfile Type", N_("A general indication of the kind of data "
+	 N_("New Subfile Type"), N_("A general indication of the kind of data "
 	    "contained in this subfile.")},
 	{EXIF_TAG_INTEROPERABILITY_INDEX, "InteroperabilityIndex",
 	 "InteroperabilityIndex",
@@ -49,35 +55,37 @@ static struct {
 	    "Use \"R98\" for stating ExifR98 Rules. Four bytes used "
 	    "including the termination code (NULL). see the separate "
 	    "volume of Recommended Exif Interoperability Rules (ExifR98) "
-	    "for other tags used for ExifR98.")},
+	    "for other tags used for ExifR98."),
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_OOOO } },
 	{EXIF_TAG_INTEROPERABILITY_VERSION, "InteroperabilityVersion",
-	 "InteroperabilityVersion", ""},
+	 "InteroperabilityVersion", "",
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_OOOO } },
 	{EXIF_TAG_IMAGE_WIDTH, "ImageWidth", N_("Image Width"),
 	 N_("The number of columns of image data, equal to the number of "
 	    "pixels per row. In JPEG compressed data a JPEG marker is "
 	    "used instead of this tag."),
-	 {ESL_MANDATORY, ESL_MANDATORY, ESL_MANDATORY, ESL_NOT_RECORDED}},
+	 { ESL_MMMN, ESL_MMMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_IMAGE_LENGTH, "ImageLength", N_("Image Length"),
 	 N_("The number of rows of image data. In JPEG compressed data a "
 	    "JPEG marker is used instead of this tag."), 
-	 {ESL_MANDATORY, ESL_MANDATORY, ESL_MANDATORY, ESL_NOT_RECORDED}},
+	 { ESL_MMMN, ESL_MMMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_BITS_PER_SAMPLE, "BitsPerSample", N_("Bits per Sample"),
 	 N_("The number of bits per image component. In this standard each "
 	    "component of the image is 8 bits, so the value for this "
-	    "tag is 9. See also <SamplesPerPixel>. In JPEG compressed data "
+	    "tag is 8. See also <SamplesPerPixel>. In JPEG compressed data "
 	    "a JPEG marker is used instead of this tag."),
-	 {ESL_MANDATORY, ESL_MANDATORY, ESL_MANDATORY, ESL_NOT_RECORDED}},
+	 { ESL_MMMN, ESL_MMMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_COMPRESSION, "Compression", N_("Compression"),
 	 N_("The compression scheme used for the image data. When a "
 	    "primary image is JPEG compressed, this designation is "
 	    "not necessary and is omitted. When thumbnails use JPEG "
 	    "compression, this tag value is set to 6."),
-	 {ESL_MANDATORY, ESL_MANDATORY, ESL_MANDATORY, ESL_NOT_RECORDED}},
+	 { ESL_MMMN, ESL_MMMM, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_PHOTOMETRIC_INTERPRETATION, "PhotometricInterpretation",
 	 N_("Photometric Interpretation"),
 	 N_("The pixel composition. In JPEG compressed data a JPEG "
 	    "marker is used instead of this tag."),
-	 {ESL_MANDATORY, ESL_MANDATORY, ESL_MANDATORY, ESL_NOT_RECORDED}},
+	 { ESL_MMMN, ESL_MMMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_FILL_ORDER, "FillOrder", N_("Fill Order"), ""},
 	{EXIF_TAG_DOCUMENT_NAME, "DocumentName", N_("Document Name"), ""},
 	{EXIF_TAG_IMAGE_DESCRIPTION, "ImageDescription",
@@ -87,92 +95,105 @@ static struct {
 	    "the like. Two-bytes character codes cannot be used. "
 	    "When a 2-bytes code is necessary, the Exif Private tag "
 	    "<UserComment> is to be used."),
-	 {ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY}},
+	 { ESL_OOOO, ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_MAKE, "Make", N_("Manufacturer"),
 	 N_("The manufacturer of the recording "
 	    "equipment. This is the manufacturer of the DSC, scanner, "
 	    "video digitizer or other equipment that generated the "
 	    "image. When the field is left blank, it is treated as "
 	    "unknown."),
-	 {ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY}},
+	 { ESL_OOOO, ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN }},
 	{EXIF_TAG_MODEL, "Model", N_("Model"),
 	 N_("The model name or model number of the equipment. This is the "
 	    "model name or number of the DSC, scanner, video digitizer "
 	    "or other equipment that generated the image. When the field "
 	    "is left blank, it is treated as unknown."),
-	 {ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY}},
+	 { ESL_OOOO, ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_STRIP_OFFSETS, "StripOffsets", N_("Strip Offsets"),
 	 N_("For each strip, the byte offset of that strip. It is "
 	    "recommended that this be selected so the number of strip "
 	    "bytes does not exceed 64 Kbytes. With JPEG compressed "
 	    "data this designation is not needed and is omitted. See also "
 	    "<RowsPerStrip> and <StripByteCounts>."),
-	 {ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY}},
+	 { ESL_MMMN, ESL_MMMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_ORIENTATION, "Orientation", N_("Orientation"),
 	 N_("The image orientation viewed in terms of rows and columns."),
-	 {ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY, ESL_CMANDATORY}},
+	 { ESL_OOOO, ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_SAMPLES_PER_PIXEL, "SamplesPerPixel",
 	 N_("Samples per Pixel"),
 	 N_("The number of components per pixel. Since this standard applies "
 	    "to RGB and YCbCr images, the value set for this tag is 3. "
 	    "In JPEG compressed data a JPEG marker is used instead of this "
-	    "tag.")},
+	    "tag."), 
+	 { ESL_MMMN, ESL_MMMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_ROWS_PER_STRIP, "RowsPerStrip", N_("Rows per Strip"),
 	 N_("The number of rows per strip. This is the number of rows "
 	    "in the image of one strip when an image is divided into "
 	    "strips. With JPEG compressed data this designation is not "
-	    "needed and is omitted. See also <RowsPerStrip> and "
-	    "<StripByteCounts>.")},
+	    "needed and is omitted. See also <StripOffsets> and "
+	    "<StripByteCounts>."),
+	 { ESL_MMMN, ESL_MMMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_STRIP_BYTE_COUNTS, "StripByteCounts", N_("Strip Byte Count"),
 	 N_("The total number of bytes in each strip. With JPEG compressed "
-	    "data this designation is not needed and is omitted.")},
+	    "data this designation is not needed and is omitted."),
+	 { ESL_MMMN, ESL_MMMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_X_RESOLUTION, "XResolution", N_("x-Resolution"),
 	 N_("The number of pixels per <ResolutionUnit> in the <ImageWidth> "
 	    "direction. When the image resolution is unknown, 72 [dpi] "
-	    "is designated.")},
+	    "is designated."),
+	 { ESL_MMMM, ESL_MMMM, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_Y_RESOLUTION, "YResolution", N_("y-Resolution"),
 	 N_("The number of pixels per <ResolutionUnit> in the <ImageLength> "
-	    "direction. The same value as <XResolution> is designated.")},
+	    "direction. The same value as <XResolution> is designated."),
+	 { ESL_MMMM, ESL_MMMM, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_PLANAR_CONFIGURATION, "PlanarConfiguration",
 	 N_("Planar Configuration"),
 	 N_("Indicates whether pixel components are recorded in a chunky "
 	    "or planar format. In JPEG compressed files a JPEG marker "
 	    "is used instead of this tag. If this field does not exist, "
-	    "the TIFF default of 1 (chunky) is assumed.")},
+	    "the TIFF default of 1 (chunky) is assumed."),
+	 { ESL_OMON, ESL_OMON, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_RESOLUTION_UNIT, "ResolutionUnit", N_("Resolution Unit"),
 	 N_("The unit for measuring <XResolution> and <YResolution>. The same "
 	    "unit is used for both <XResolution> and <YResolution>. If "
-	    "the image resolution is unknown, 2 (inches) is designated.")},
+	    "the image resolution is unknown, 2 (inches) is designated."),
+	 { ESL_MMMM, ESL_MMMM, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_TRANSFER_FUNCTION, "TransferFunction",
 	 N_("Transfer Function"),
 	 N_("A transfer function for the image, described in tabular style. "
 	    "Normally this tag is not necessary, since color space is "
-	    "specified in the color space information tag (<ColorSpace>).")},
+	    "specified in the color space information tag (<ColorSpace>)."),
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_SOFTWARE, "Software", N_("Software"),
 	 N_("This tag records the name and version of the software or "
 	    "firmware of the camera or image input device used to "
 	    "generate the image. The detailed format is not specified, but "
 	    "it is recommended that the example shown below be "
 	    "followed. When the field is left blank, it is treated as "
-	    "unknown.")},
+	    "unknown."),
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_DATE_TIME, "DateTime", N_("Date and Time"),
 	 N_("The date and time of image creation. In this standard "
-	    "(EXIF-2.1) it is the date and time the file was changed.")},
+	    "(EXIF-2.1) it is the date and time the file was changed."),
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_ARTIST, "Artist", N_("Artist"),
 	 N_("This tag records the name of the camera owner, photographer or "
 	    "image creator. The detailed format is not specified, but it is "
 	    "recommended that the information be written as in the example "
 	    "below for ease of Interoperability. When the field is "
-	    "left blank, it is treated as unknown.")},
+	    "left blank, it is treated as unknown."),
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_WHITE_POINT, "WhitePoint", N_("White Point"),
 	 N_("The chromaticity of the white point of the image. Normally "
 	    "this tag is not necessary, since color space is specified "
-	    "in the colorspace information tag (<ColorSpace>).")},
+	    "in the color space information tag (<ColorSpace>)."),
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_PRIMARY_CHROMATICITIES, "PrimaryChromaticities",
 	 N_("Primary Chromaticities"),
 	 N_("The chromaticity of the three primary colors of the image. "
-	    "Normally this tag is not necessary, since colorspace is "
-	    "specified in the colorspace information tag (<ColorSpace>).")},
+	    "Normally this tag is not necessary, since color space is "
+	    "specified in the color space information tag (<ColorSpace>)."),
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_TRANSFER_RANGE, "TransferRange", N_("Transfer Range"), ""},
 	{EXIF_TAG_SUB_IFDS, "SubIFDs", "SubIFD Offsets", N_("Defined by Adobe Corporation "
 	    "to enable TIFF Trees within a TIFF file.")},
@@ -181,7 +202,8 @@ static struct {
 	 N_("JPEG Interchange Format"),
 	 N_("The offset to the start byte (SOI) of JPEG compressed "
 	    "thumbnail data. This is not used for primary image "
-	    "JPEG data.")},
+	    "JPEG data."),
+	 { ESL_NNNN, ESL_NNNM, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH,
 	 "JPEGInterchangeFormatLength", N_("JPEG Interchange Format Length"),
 	 N_("The number of bytes of JPEG compressed thumbnail data. This "
@@ -190,7 +212,8 @@ static struct {
 	    "bitstream from SOI to EOI. Appn and COM markers should "
 	    "not be recorded. Compressed thumbnails must be recorded in no "
 	    "more than 64 Kbytes, including all other data to be "
-	    "recorded in APP1.")},
+	    "recorded in APP1."),
+	 { ESL_NNNN, ESL_NNNM, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_YCBCR_COEFFICIENTS, "YCbCrCoefficients",
 	 N_("YCbCr Coefficients"),
 	 N_("The matrix coefficients for transformation from RGB to YCbCr "
@@ -199,12 +222,14 @@ static struct {
 	    "as the default. The color space is declared in a "
 	    "color space information tag, with the default being the value "
 	    "that gives the optimal image characteristics "
-	    "Interoperability this condition.")},
+	    "Interoperability this condition."),
+	 { ESL_NNOO, ESL_NNOO, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_YCBCR_SUB_SAMPLING, "YCbCrSubSampling",
 	 N_("YCbCr Sub-Sampling"),
 	 N_("The sampling ratio of chrominance components in relation to the "
 	    "luminance component. In JPEG compressed data a JPEG marker "
-	    "is used instead of this tag.")},
+	    "is used instead of this tag."),
+	 { ESL_NNMN, ESL_NNMN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_YCBCR_POSITIONING, "YCbCrPositioning",
 	 N_("YCbCr Positioning"),
 	 N_("The position of chrominance components in relation to the "
@@ -219,7 +244,8 @@ static struct {
 	    "does not have the capability of supporting both kinds of "
 	    "<YCbCrPositioning>, it shall follow the TIFF default regardless "
 	    "of the value in this field. It is preferable that readers "
-	    "be able to support both centered and co-sited positioning.")},
+	    "be able to support both centered and co-sited positioning."),
+	 { ESL_NNMM, ESL_NNOO, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_REFERENCE_BLACK_WHITE, "ReferenceBlackWhite",
 	 N_("Reference Black/White"),
 	 N_("The reference black point value and reference white point "
@@ -227,7 +253,8 @@ static struct {
 	    "below are given as defaults here. The color space is declared "
 	    "in a color space information tag, with the default "
 	    "being the value that gives the optimal image characteristics "
-	    "Interoperability these conditions.")},
+	    "Interoperability these conditions."),
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_XML_PACKET, "XMLPacket", N_("XML Packet"), N_("XMP Metadata")},
 	{EXIF_TAG_RELATED_IMAGE_FILE_FORMAT, "RelatedImageFileFormat",
 	 "RelatedImageFileFormat", ""},
@@ -263,84 +290,113 @@ static struct {
 	    "the photographer copyright part consists of one space followed "
 	    "by a terminating NULL code, then the editor copyright is given "
 	    "(see example 3). When the field is left blank, it is treated "
-	    "as unknown.")},
+	    "as unknown."),
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_EXPOSURE_TIME, "ExposureTime", N_("Exposure Time"),
-	 N_("Exposure time, given in seconds (sec).")},
+	 N_("Exposure time, given in seconds (sec)."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_FNUMBER, "FNumber", N_("FNumber"),
-	 N_("The F number.")},
+	 N_("The F number."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_IPTC_NAA, "IPTC/NAA", "IPTC/NAA", ""},
 	{EXIF_TAG_IMAGE_RESOURCES, "ImageResources", N_("Image Resources Block"), ""},
-	{EXIF_TAG_EXIF_IFD_POINTER, "ExifIFDPointer", "ExifIFDPointer",
+	{EXIF_TAG_EXIF_IFD_POINTER, "ExifIfdPointer", "ExifIFDPointer",
 	 N_("A pointer to the Exif IFD. Interoperability, Exif IFD has the "
 	    "same structure as that of the IFD specified in TIFF. "
 	    "ordinarily, however, it does not contain image data as in "
-	    "the case of TIFF.")},
+	    "the case of TIFF."),
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_INTER_COLOR_PROFILE, "InterColorProfile",
 	 "InterColorProfile", ""},
-	{EXIF_TAG_EXPOSURE_PROGRAM, "ExposureProgram", "ExposureProgram",
+	{EXIF_TAG_EXPOSURE_PROGRAM, "ExposureProgram", N_("Exposure Program"),
 	 N_("The class of the program used by the camera to set exposure "
-	    "when the picture is taken.")},
+	    "when the picture is taken."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_SPECTRAL_SENSITIVITY, "SpectralSensitivity",
 	 N_("Spectral Sensitivity"),
 	 N_("Indicates the spectral sensitivity of each channel of the "
 	    "camera used. The tag value is an ASCII string compatible "
-	    "with the standard developed by the ASTM Technical committee.")},
+	    "with the standard developed by the ASTM Technical Committee."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_GPS_INFO_IFD_POINTER, "GPSInfoIFDPointer", 
 	 "GPSInfoIFDPointer",
 	 N_("A pointer to the GPS Info IFD. The "
 	    "Interoperability structure of the GPS Info IFD, like that of "
-	    "Exif IFD, has no image data.")},
-#if 0
-	{EXIF_TAG_GPS_VERSION_ID, "GPSVersionID", "",
+	    "Exif IFD, has no image data."),
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
+	{EXIF_TAG_GPS_VERSION_ID, "GPSVersionID", N_("GPS tag version"),
 	 N_("Indicates the version of <GPSInfoIFD>. The version is given "
 	    "as 2.0.0.0. This tag is mandatory when <GPSInfo> tag is "
-	    "present. (Note: The <GPSVersionID tag is given in bytes, "
+	    "present. (Note: The <GPSVersionID> tag is given in bytes, "
 	    "unlike the <ExifVersion> tag. When the version is "
-	    "2.0.0.0, the tag value is 02000000.H).")},
-	{EXIF_TAG_GPS_LATITUDE_REF, "GPSLatitudeRef", ""
+	    "2.0.0.0, the tag value is 02000000.H)."), ESL_GPS},
+	{EXIF_TAG_GPS_LATITUDE_REF, "GPSLatitudeRef", N_("North or South Latitude"),
 	 N_("Indicates whether the latitude is north or south latitude. The "
 	    "ASCII value 'N' indicates north latitude, and 'S' is south "
-	    "latitude.")},
-	{EXIF_TAG_GPS_LATITUDE, "GPSLatitude", ""
+	    "latitude."), ESL_GPS},
+	{EXIF_TAG_GPS_LATITUDE, "GPSLatitude", N_("Latitude"),
 	 N_("Indicates the latitude. The latitude is expressed as three "
 	    "RATIONAL values giving the degrees, minutes, and seconds, "
 	    "respectively. When degrees, minutes and seconds are expressed, "
 	    "the format is dd/1,mm/1,ss/1. When degrees and minutes are used "
 	    "and, for example, fractions of minutes are given up to two "
-	    "two decimal places, the format is dd/1,mmmm/100,0/1.")},
-	{EXIF_TAG_GPS_LONGITUDE_REF, "GPSLongitudeRef", ""
+	    "decimal places, the format is dd/1,mmmm/100,0/1."),
+	 ESL_GPS},
+	{EXIF_TAG_GPS_LONGITUDE_REF, "GPSLongitudeRef", N_("East or West Longitude"),
 	 N_("Indicates whether the longitude is east or west longitude. "
 	    "ASCII 'E' indicates east longitude, and 'W' is west "
-	    "longitude.")},
-	{EXIF_TAG_GPS_LONGITUDE, "GPSLongitude", ""
+	    "longitude."), ESL_GPS},
+	{EXIF_TAG_GPS_LONGITUDE, "GPSLongitude", N_("Longitude"),
 	 N_("Indicates the longitude. The longitude is expressed as three "
 	    "RATIONAL values giving the degrees, minutes, and seconds, "
 	    "respectively. When degrees, minutes and seconds are expressed, "
 	    "the format is ddd/1,mm/1,ss/1. When degrees and minutes are "
 	    "used and, for example, fractions of minutes are given up to "
-	    "two decimal places, the format is ddd/1,mmmm/100,0/1.")}, 
-#endif
+	    "two decimal places, the format is ddd/1,mmmm/100,0/1."),
+	 ESL_GPS},
+	{EXIF_TAG_GPS_ALTITUDE_REF, "GPSAltitudeRef", N_("Altitude reference"),
+	 N_("Indicates the altitude used as the reference altitude. If the "
+	    "reference is sea level and the altitude is above sea level, 0 "
+	    "is given. If the altitude is below sea level, a value of 1 is given "
+	    "and the altitude is indicated as an absolute value in the "
+	    "GSPAltitude tag. The reference unit is meters. Note that this tag "
+	    "is BYTE type, unlike other reference tags."), ESL_GPS},
+	{EXIF_TAG_GPS_ALTITUDE, "GPSAltitude", N_("Altitude"),
+	 N_("Indicates the altitude based on the reference in GPSAltitudeRef. "
+	    "Altitude is expressed as one RATIONAL value. The reference unit "
+	    "is meters."), ESL_GPS},
+	{EXIF_TAG_GPS_IMG_DIRECTION_REF, "GPSImgDirectionRef", N_("GPS Img Direction Reference"),
+	 N_("Indicates the reference for giving the direction of the image when it is captured. "
+	    "'T' denotes true direction and 'M' is magnetic direction."), ESL_GPS},
+	{EXIF_TAG_GPS_IMG_DIRECTION, "GPSImgDirection", N_("GPS Img Direction"),
+	 N_("Indicates the direction of the image when it was captured. The range of values is "
+	    "from 0.00 to 359.99."), ESL_GPS},
 	{EXIF_TAG_ISO_SPEED_RATINGS, "ISOSpeedRatings",
 	 N_("ISO Speed Ratings"),
 	 N_("Indicates the ISO Speed and ISO Latitude of the camera or "
-	    "input device as specified in ISO 12232.")},
+	    "input device as specified in ISO 12232."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_OECF, "OECF", "OECF",
-	 N_("Indicates the Opto-Electoric Conversion Function (OECF) "
+	 N_("Indicates the Opto-Electronic Conversion Function (OECF) "
 	    "specified in ISO 14524. <OECF> is the relationship between "
-	    "the camera optical input and the image values.")},
+	    "the camera optical input and the image values."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_EXIF_VERSION, "ExifVersion", N_("Exif Version"),
 	 N_("The version of this standard supported. Nonexistence of this "
-	    "field is taken to mean nonconformance to the standard.")},
+	    "field is taken to mean nonconformance to the standard."),
+	 { ESL_NNNN, ESL_NNNN, ESL_MMMM, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_DATE_TIME_ORIGINAL, "DateTimeOriginal",
 	 N_("Date and Time (original)"),
 	 N_("The date and time when the original image data was generated. "
 	    "For a digital still camera "
-	    "the date and time the picture was taken are recorded.")},
+	    "the date and time the picture was taken are recorded."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_DATE_TIME_DIGITIZED, "DateTimeDigitized",
 	 N_("Date and Time (digitized)"),
-	 N_("The date and time when the image was stored as digital data. ")},
+	 N_("The date and time when the image was stored as digital data. "),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_COMPONENTS_CONFIGURATION, "ComponentsConfiguration",
-	 "ComponentsConfiguration",
+	 N_("Components Configuration"),
 	 N_("Information specific to compressed data. The channels of "
 	    "each component are arranged in order from the 1st "
 	    "component to the 4th. For uncompressed data the data "
@@ -348,44 +404,56 @@ static struct {
 	    "However, since <PhotometricInterpretation> can only "
 	    "express the order of Y, Cb and Cr, this tag is provided "
 	    "for cases when compressed data uses components other than "
-	    "Y, Cb, and Cr and to enable support of other sequences.")},
+	    "Y, Cb, and Cr and to enable support of other sequences."),
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNM, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_COMPRESSED_BITS_PER_PIXEL, "CompressedBitsPerPixel",
 	 N_("Compressed Bits per Pixel"),
 	 N_("Information specific to compressed data. The compression mode "
 	    "used for a compressed image is indicated in unit bits "
-	    "per pixel.")},
+	    "per pixel."),
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_SHUTTER_SPEED_VALUE, "ShutterSpeedValue", N_("Shutter speed"),
 	 N_("Shutter speed. The unit is the APEX (Additive System of "
-	    "Photographic Exposure) setting (see Appendix C).")},
+	    "Photographic Exposure) setting."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_APERTURE_VALUE, "ApertureValue", N_("Aperture"),
-	 N_("The lens aperture. The unit is the APEX value.")},
+	 N_("The lens aperture. The unit is the APEX value."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_BRIGHTNESS_VALUE, "BrightnessValue", N_("Brightness"),
 	 N_("The value of brightness. The unit is the APEX value. "
-	    "Ordinarily it is given in the range of -99.99 to 99.99.")},
+	    "Ordinarily it is given in the range of -99.99 to 99.99."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_EXPOSURE_BIAS_VALUE, "ExposureBiasValue",
 	 N_("Exposure Bias"),
 	 N_("The exposure bias. The units is the APEX value. Ordinarily "
-	    "it is given in the range of -99.99 to 99.99.")},
+	    "it is given in the range of -99.99 to 99.99."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_MAX_APERTURE_VALUE, "MaxApertureValue", "MaxApertureValue",
 	 N_("The smallest F number of the lens. The unit is the APEX value. "
 	    "Ordinarily it is given in the range of 00.00 to 99.99, "
-	    "but it is not limited to this range.")},
+	    "but it is not limited to this range."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_SUBJECT_DISTANCE, "SubjectDistance",
 	 N_("Subject Distance"),
-	 N_("The distance to the subject, given in meters.")},
+	 N_("The distance to the subject, given in meters."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_METERING_MODE, "MeteringMode", N_("Metering Mode"),
-	 N_("The metering mode.")},
+	 N_("The metering mode."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_LIGHT_SOURCE, "LightSource", N_("Light Source"),
-	 N_("The kind of light source.")},
+	 N_("The kind of light source."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_FLASH, "Flash", N_("Flash"),
 	 N_("This tag is recorded when an image is taken using a strobe "
 	    "light (flash).")},
 	{EXIF_TAG_FOCAL_LENGTH, "FocalLength", N_("Focal Length"),
 	 N_("The actual focal length of the lens, in mm. Conversion is not "
-	    "made to the focal length of a 35 mm film camera.")},
+	    "made to the focal length of a 35 mm film camera."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_MAKER_NOTE, "MakerNote", N_("Maker Note"),
 	 N_("A tag for manufacturers of Exif writers to record any desired "
-	    "information. The contents are up to the manufacturer.")},
+	    "information. The contents are up to the manufacturer."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_USER_COMMENT, "UserComment", N_("User Comment"),
 	 N_("A tag for Exif users to write keywords or comments on the image "
 	    "besides those in <ImageDescription>, and without the "
@@ -396,7 +464,7 @@ static struct {
 	    "with NULL (\"00.h\"). ID codes are assigned by means of "
 	    "registration. The designation method and references for each "
 	    "character code are given in Table 6. The value of CountN "
-	    "is determinated based on the 8 bytes in the character code "
+	    "is determined based on the 8 bytes in the character code "
 	    "area and the number of bytes in the user comment part. Since "
 	    "the TYPE is not ASCII, NULL termination is not necessary "
 	    "(see Fig. 9). "
@@ -409,20 +477,35 @@ static struct {
 	    "do not use the <UserComment> tag (see Table 7). "
 	    "When a <UserComment> area is set aside, it is recommended that "
 	    "the ID code be ASCII and that the following user comment "
-	    "part be filled with blank characters [20.H].")},
+	    "part be filled with blank characters [20.H]."),
+			{ ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_SUB_SEC_TIME, "SubsecTime", "SubsecTime",
 	 N_("A tag used to record fractions of seconds for the "
-	    "<DateTime> tag.")},
+	    "<DateTime> tag."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_SUB_SEC_TIME_ORIGINAL, "SubSecTimeOriginal",
 	 "SubSecTimeOriginal",
 	 N_("A tag used to record fractions of seconds for the "
-	    "<DateTimeOriginal> tag.")},
+	    "<DateTimeOriginal> tag."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_SUB_SEC_TIME_DIGITIZED, "SubSecTimeDigitized",
 	 "SubSecTimeDigitized",
 	 N_("A tag used to record fractions of seconds for the "
-	    "<DateTimeDigitized> tag.")},
+	    "<DateTimeDigitized> tag."),
+	 { ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
+	{EXIF_TAG_XP_TITLE, "XPTitle", N_("XP Title"), "",
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
+	{EXIF_TAG_XP_COMMENT, "XPComment", N_("XP Comment"), "",
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
+	{EXIF_TAG_XP_AUTHOR, "XPAuthor", N_("XP Author"), "",
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
+	{EXIF_TAG_XP_KEYWORDS, "XPKeywords", N_("XP Keywords"), "",
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
+	{EXIF_TAG_XP_SUBJECT, "XPSubject", N_("XP Subject"), "",
+	 { ESL_OOOO, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_FLASH_PIX_VERSION, "FlashPixVersion", "FlashPixVersion",
-	 N_("The FlashPix format version supported by a FPXR file.")},
+	 N_("The FlashPix format version supported by a FPXR file."),
+	 { ESL_NNNN, ESL_NNNN, ESL_MMMM, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_COLOR_SPACE, "ColorSpace", N_("Color Space"),
 	 N_("The color space information tag is always "
 	    "recorded as the color space specifier. Normally sRGB (=1) "
@@ -430,14 +513,15 @@ static struct {
 	    "conditions and environment. If a color space other than "
 	    "sRGB is used, Uncalibrated (=FFFF.H) is set. Image data "
 	    "recorded as Uncalibrated can be treated as sRGB when it is "
-	    "converted to FlashPix. On sRGB see Appendix E.")},
+	    "converted to FlashPix."),
+	 { ESL_NNNN, ESL_NNNN, ESL_MMMM, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_PIXEL_X_DIMENSION, "PixelXDimension", "PixelXDimension",
 	 N_("Information specific to compressed data. When a "
 	    "compressed file is recorded, the valid width of the "
 	    "meaningful image must be recorded in this tag, whether or "
 	    "not there is padding data or a restart marker. This tag "
-	    "should not exist in an uncompressed file. For details see "
-	    "section 2.8.1 and Appendix F.")},
+	    "should not exist in an uncompressed file."),
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNM, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_PIXEL_Y_DIMENSION, "PixelYDimension", "PixelYDimension",
 	 N_("Information specific to compressed data. When a compressed "
 	    "file is recorded, the valid height of the meaningful image "
@@ -446,7 +530,8 @@ static struct {
 	    "uncompressed file. For details see section 2.8.1 and Appendix "
 	    "F. Since data padding is unnecessary in the vertical direction, "
 	    "the number of lines recorded in this valid image height tag "
-	    "will in fact be the same as that recorded in the SOF.")},
+	    "will in fact be the same as that recorded in the SOF."),
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNM, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_RELATED_SOUND_FILE, "RelatedSoundFile",
 	 "RelatedSoundFile",
 	 N_("This tag is used to record the name of an audio file related "
@@ -478,7 +563,8 @@ static struct {
 	    "information is an ASCII character string, it is terminated by "
 	    "NULL. When this tag is used to map audio files, the relation "
 	    "of the audio file to image data must also be indicated on the "
-	    "audio file end.")},
+	    "audio file end."),
+			{ ESL_NNNN, ESL_NNNN, ESL_OOOO, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_INTEROPERABILITY_IFD_POINTER, "InteroperabilityIFDPointer",
 	 "InteroperabilityIFDPointer",
 	 N_("Interoperability IFD is composed of tags which stores the "
@@ -488,7 +574,8 @@ static struct {
 	    "the same as TIFF defined IFD structure "
 	    "but does not contain the "
 	    "image data characteristically compared with normal TIFF "
-	    "IFD.")},
+	    "IFD."),
+	 { ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN, ESL_NNNN } },
 	{EXIF_TAG_FLASH_ENERGY, "FlashEnergy", N_("Flash Energy"),
 	 N_("Indicates the strobe energy at the time the image is "
 	    "captured, as measured in Beam Candle Power Seconds (BCPS).")},
@@ -517,9 +604,9 @@ static struct {
 	    "value of this tag represents the pixel at the center of the "
 	    "main subject relative to the left edge, prior to rotation "
 	    "processing as per the <Rotation> tag. The first value "
-	    "indicates the X column number and second indicates "
+	    "indicates the X column number and the second indicates "
 	    "the Y row number.")},
-	{EXIF_TAG_EXPOSURE_INDEX, "ExposureIndex", N_("Exposure index"),
+	{EXIF_TAG_EXPOSURE_INDEX, "ExposureIndex", N_("Exposure Index"),
 	 N_("Indicates the exposure index selected on the camera or "
 	    "input device at the time the image is captured.")},
 	{EXIF_TAG_SENSING_METHOD, "SensingMethod", N_("Sensing Method"),
@@ -527,7 +614,7 @@ static struct {
 	    "device.")},
 	{EXIF_TAG_FILE_SOURCE, "FileSource", N_("File Source"),
 	 N_("Indicates the image source. If a DSC recorded the image, "
-	    "this tag value of this tag always be set to 3, indicating "
+	    "the tag value of this tag always be set to 3, indicating "
 	    "that the image was recorded on a DSC.")},
 	{EXIF_TAG_SCENE_TYPE, "SceneType", N_("Scene Type"),
 	 N_("Indicates the type of scene. If a DSC recorded the image, "
@@ -570,7 +657,7 @@ static struct {
 	 N_("This tag indicates the type of scene that was shot. It can "
 	    "also be used to record the mode in which the image was "
 	    "shot. Note that this differs from the scene type "
-	    "(SceneType) tag.")},
+	    "<SceneType> tag.")},
 	{EXIF_TAG_GAIN_CONTROL, "GainControl", N_("Gain Control"),
 	 N_("This tag indicates the degree of overall image gain "
 	    "adjustment.")},
@@ -596,6 +683,11 @@ static struct {
 	 N_("This tag indicates an identifier assigned uniquely to "
 	    "each image. It is recorded as an ASCII string equivalent "
 	    "to hexadecimal notation and 128-bit fixed length.")},
+	{EXIF_TAG_GAMMA, "Gamma", N_("Gamma"),
+	 N_("Indicates the value of coefficient gamma.")},
+	{EXIF_TAG_PRINT_IMAGE_MATCHING, "PrintImageMatching", N_("PRINT Image Matching"),
+	 N_("Related to Epson's PRINT Image Matching technology")},
+#endif
 	{0, NULL, NULL, NULL}
 };
 
@@ -622,55 +714,144 @@ exif_tag_table_count (void)
 	return sizeof (ExifTagTable) / sizeof (ExifTagTable[0]);
 }
 
+#define RECORDED \
+((ExifTagTable[i].esl[ifd][EXIF_DATA_TYPE_UNCOMPRESSED_CHUNKY] != EXIF_SUPPORT_LEVEL_NOT_RECORDED) || \
+ (ExifTagTable[i].esl[ifd][EXIF_DATA_TYPE_UNCOMPRESSED_PLANAR] != EXIF_SUPPORT_LEVEL_NOT_RECORDED) || \
+ (ExifTagTable[i].esl[ifd][EXIF_DATA_TYPE_UNCOMPRESSED_YCC] != EXIF_SUPPORT_LEVEL_NOT_RECORDED) || \
+ (ExifTagTable[i].esl[ifd][EXIF_DATA_TYPE_COMPRESSED] != EXIF_SUPPORT_LEVEL_NOT_RECORDED))
+
 const char *
-exif_tag_get_name (ExifTag tag)
+exif_tag_get_name_in_ifd (ExifTag tag, ExifIfd ifd)
 {
 	unsigned int i;
 
+	if (ifd >= EXIF_IFD_COUNT) return NULL;
 	for (i = 0; ExifTagTable[i].name; i++)
-		if (ExifTagTable[i].tag == tag)
-			break;
-
+		if ((ExifTagTable[i].tag == tag) && RECORDED) break;
 	return ExifTagTable[i].name;
 }
 
 const char *
-exif_tag_get_title (ExifTag tag)
+exif_tag_get_title_in_ifd (ExifTag tag, ExifIfd ifd)
 {
 	unsigned int i;
 
 	/* FIXME: This belongs to somewhere else. */
-	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	/* libexif should use the default system locale.
+	 * If an application specifically requires UTF-8, then we
+	 * must give the application a way to tell libexif that.
+	 * 
+	 * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	 */
 	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
-
+	if (ifd >= EXIF_IFD_COUNT) return NULL;
 	for (i = 0; ExifTagTable[i].title; i++)
-		if (ExifTagTable[i].tag == tag) break;
+		if ((ExifTagTable[i].tag == tag) && RECORDED) break;
 	return _(ExifTagTable[i].title);
 }
 
 const char *
-exif_tag_get_description (ExifTag tag)
+exif_tag_get_description_in_ifd (ExifTag tag, ExifIfd ifd)
 {
 	unsigned int i;
 
-	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	/* libexif should use the default system locale.
+	 * If an application specifically requires UTF-8, then we
+	 * must give the application a way to tell libexif that.
+	 * 
+	 * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	 */
 	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 
+	if (ifd >= EXIF_IFD_COUNT) return NULL;
 	for (i = 0; ExifTagTable[i].description; i++)
-		if (ExifTagTable[i].tag == tag) break;
-	return _(ExifTagTable[i].description);
+		if ((ExifTagTable[i].tag == tag) && RECORDED) {
+			/* GNU gettext acts strangely when given an empty string */
+			if (!*ExifTagTable[i].description)
+				return "";
+			return _(ExifTagTable[i].description);
+		}
+	return NULL;
+}
+
+
+/**********************************************************************
+ * convenience functions
+ **********************************************************************/
+
+/* generic part: iterate through IFD list and return first result */
+typedef const char * (*get_stuff_func) (ExifTag tag, ExifIfd ifd);
+
+static const char *
+exif_tag_get_stuff (ExifTag tag, get_stuff_func func)
+{
+	static const ExifIfd ifds[5] = {
+		EXIF_IFD_0,
+		EXIF_IFD_1,
+		EXIF_IFD_EXIF,
+		EXIF_IFD_INTEROPERABILITY,
+		EXIF_IFD_GPS
+	};
+	int i;
+	for (i=0; i<5; i++) {
+		const char *result = func(tag, ifds[i]);
+		if (result != NULL) {
+			return result;
+		}
+	}
+	return (const char *) NULL;
+}
+
+/* explicit functions */
+const char *
+exif_tag_get_name (ExifTag tag)
+{
+	return exif_tag_get_stuff(tag, exif_tag_get_name_in_ifd);
 }
 
+const char *
+exif_tag_get_title (ExifTag tag)
+{
+	return exif_tag_get_stuff(tag, exif_tag_get_title_in_ifd);
+}
+
+const char *
+exif_tag_get_description (ExifTag tag)
+{
+	return exif_tag_get_stuff (tag, exif_tag_get_description_in_ifd);
+}
+
+
+
 ExifTag 
 exif_tag_from_name (const char *name)
 {
 	unsigned int i;
+	unsigned int result=0;
 
 	if (!name) return 0;
 
 	for (i = 0; ExifTagTable[i].name; i++)
-		if (!strcmp (ExifTagTable[i].name, name)) break;
-	return ExifTagTable[i].tag;
+		if (!strcmp (ExifTagTable[i].name, name))  {
+		  	result = ExifTagTable[i].tag;
+		  	break;
+		}
+	return result;
+}
+
+ExifSupportLevel
+exif_tag_get_support_level_in_ifd (ExifTag tag, ExifIfd ifd, ExifDataType t)
+{
+	unsigned int i;
+
+	if (ifd >= EXIF_IFD_COUNT) return EXIF_SUPPORT_LEVEL_UNKNOWN;
+	if (t >= EXIF_DATA_TYPE_COUNT) return EXIF_SUPPORT_LEVEL_UNKNOWN;
+
+	for (i = 0; ExifTagTable[i].description; i++)
+		if ((ExifTagTable[i].tag == tag) &&
+				(ExifTagTable[i].esl[ifd][t] != EXIF_SUPPORT_LEVEL_NOT_RECORDED))
+			return ExifTagTable[i].esl[ifd][t];
+	return EXIF_SUPPORT_LEVEL_NOT_RECORDED;
 }
 
 const char *
@@ -683,4 +864,3 @@ exif_tag_get_name_index (unsigned int i, ExifTag *tag)
 
 	return (ExifTagTable[i].name);
 }
-
diff --git a/src/libexif/exif-tag.h b/src/libexif/exif-tag.h
index f928374..8b43405 100644
--- a/src/libexif/exif-tag.h
+++ b/src/libexif/exif-tag.h
@@ -1,6 +1,6 @@
 /* exif-tag.h
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -25,6 +25,9 @@
 extern "C" {
 #endif /* __cplusplus */
 
+#include <libexif/exif-ifd.h>
+#include <libexif/exif-data-type.h>
+
 typedef enum {
 	EXIF_TAG_INTEROPERABILITY_INDEX		= 0x0001,
 	EXIF_TAG_INTEROPERABILITY_VERSION	= 0x0002,
@@ -104,6 +107,11 @@ typedef enum {
 	EXIF_TAG_SUB_SEC_TIME			= 0x9290,
 	EXIF_TAG_SUB_SEC_TIME_ORIGINAL		= 0x9291,
 	EXIF_TAG_SUB_SEC_TIME_DIGITIZED		= 0x9292,
+	EXIF_TAG_XP_TITLE			= 0x9c9b,
+	EXIF_TAG_XP_COMMENT			= 0x9c9c,
+	EXIF_TAG_XP_AUTHOR			= 0x9c9d,
+	EXIF_TAG_XP_KEYWORDS			= 0x9c9e,
+	EXIF_TAG_XP_SUBJECT			= 0x9c9f,
 	EXIF_TAG_FLASH_PIX_VERSION		= 0xa000,
 	EXIF_TAG_COLOR_SPACE			= 0xa001,
 	EXIF_TAG_PIXEL_X_DIMENSION		= 0xa002,
@@ -133,14 +141,66 @@ typedef enum {
 	EXIF_TAG_SHARPNESS			= 0xa40a,
 	EXIF_TAG_DEVICE_SETTING_DESCRIPTION	= 0xa40b,
 	EXIF_TAG_SUBJECT_DISTANCE_RANGE		= 0xa40c,
-	EXIF_TAG_IMAGE_UNIQUE_ID		= 0xa420
+	EXIF_TAG_IMAGE_UNIQUE_ID		= 0xa420,
+	EXIF_TAG_GAMMA				= 0xa500,
+	EXIF_TAG_PRINT_IMAGE_MATCHING		= 0xc4a5
 } ExifTag;
 
-ExifTag         exif_tag_from_name       (const char *);
+/* GPS tags overlap with above ones. */
+#define EXIF_TAG_GPS_VERSION_ID        0x0000
+#define EXIF_TAG_GPS_LATITUDE_REF      0x0001 /* INTEROPERABILITY_INDEX   */
+#define EXIF_TAG_GPS_LATITUDE          0x0002 /* INTEROPERABILITY_VERSION */
+#define EXIF_TAG_GPS_LONGITUDE_REF     0x0003
+#define EXIF_TAG_GPS_LONGITUDE         0x0004
+#define EXIF_TAG_GPS_ALTITUDE_REF      0x0005
+#define EXIF_TAG_GPS_ALTITUDE          0x0006
+#define EXIF_TAG_GPS_TIME_STAMP        0x0007
+#define EXIF_TAG_GPS_SATELLITES        0x0008
+#define EXIF_TAG_GPS_STATUS            0x0009
+#define EXIF_TAG_GPS_MEASURE_MODE      0x000a
+#define EXIF_TAG_GPS_DOP               0x000b
+#define EXIF_TAG_GPS_SPEED_REF         0x000c
+#define EXIF_TAG_GPS_SPEED             0x000d
+#define EXIF_TAG_GPS_TRACK_REF         0x000e
+#define EXIF_TAG_GPS_TRACK             0x000f
+#define EXIF_TAG_GPS_IMG_DIRECTION_REF 0x0010
+#define EXIF_TAG_GPS_IMG_DIRECTION     0x0011
+#define EXIF_TAG_GPS_MAP_DATUM         0x0012
+#define EXIF_TAG_GPS_DEST_LATITUDE_REF 0x0013
+#define EXIF_TAG_GPS_DEST_LATITUDE     0x0014
+#define EXIF_TAG_GPS_DEST_LONGITUDE_REF 0x0015
+#define EXIF_TAG_GPS_DEST_LONGITUDE     0x0016
+#define EXIF_TAG_GPS_DEST_BEARING_REF   0x0017
+#define EXIF_TAG_GPS_DEST_BEARING       0x0018
+#define EXIF_TAG_GPS_DEST_DISTANCE_REF  0x0019
+#define EXIF_TAG_GPS_DEST_DISTANCE      0x001a
+#define EXIF_TAG_GPS_PROCESSING_METHOD  0x001b
+#define EXIF_TAG_GPS_AREA_INFORMATION   0x001c
+#define EXIF_TAG_GPS_DATE_STAMP         0x001d
+#define EXIF_TAG_GPS_DIFFERENTIAL       0x001e
+
+typedef enum {
+	EXIF_SUPPORT_LEVEL_UNKNOWN = 0,
+	EXIF_SUPPORT_LEVEL_NOT_RECORDED,
+	EXIF_SUPPORT_LEVEL_MANDATORY,
+	EXIF_SUPPORT_LEVEL_OPTIONAL
+} ExifSupportLevel;
+
+ExifTag          exif_tag_from_name                (const char *);
+const char      *exif_tag_get_name_in_ifd          (ExifTag, ExifIfd);
+const char      *exif_tag_get_title_in_ifd         (ExifTag, ExifIfd);
+const char      *exif_tag_get_description_in_ifd   (ExifTag, ExifIfd);
+ExifSupportLevel exif_tag_get_support_level_in_ifd (ExifTag, ExifIfd,
+                                                    ExifDataType);
+
+/* Don't use these functions. They are here for compatibility only. */
 const char     *exif_tag_get_name        (ExifTag tag);
 const char     *exif_tag_get_title       (ExifTag tag);
 const char     *exif_tag_get_description (ExifTag tag);
 
+/* Don't use these definitions. They are here for compatibility only. */
+#define EXIF_TAG_UNKNOWN_C4A5 EXIF_TAG_PRINT_IMAGE_MATCHING
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/src/libexif/exif-utils.c b/src/libexif/exif-utils.c
index 9386012..a6e7696 100644
--- a/src/libexif/exif-utils.c
+++ b/src/libexif/exif-utils.c
@@ -1,6 +1,6 @@
 /* exif-utils.c
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -212,3 +212,40 @@ exif_set_srational (unsigned char *buf, ExifByteOrder order,
 	exif_set_slong (buf, order, value.numerator);
 	exif_set_slong (buf + 4, order, value.denominator);
 }
+
+void
+exif_convert_utf16_to_utf8 (char *out, const unsigned short *in, int maxlen)
+{
+	/* This function converts rather UCS2 than UTF16 to UTF8 */
+	if (maxlen <= 0) {
+		return;
+	}
+	while (*in) {
+		if (*in < 0x80) {
+			if (maxlen > 1) {
+				*out++ = (char)*in++;
+				maxlen--;
+			} else {
+				break;
+			}
+		} else if (*in < 0x800) {
+			if (maxlen > 2) {
+				*out++ = ((*in >> 6) & 0x1F) | 0xC0;
+				*out++ = (*in++ & 0x3F) | 0x80;
+				maxlen -= 2;
+			} else {
+				break;
+			}
+		} else {
+			if (maxlen > 2) {
+				*out++ = ((*in >> 12) & 0x0F) | 0xE0;
+				*out++ = ((*in >> 6) & 0x3F) | 0x80;
+				*out++ = (*in++ & 0x3F) | 0x80;
+				maxlen -= 3;
+			} else {
+				break;
+			}
+		}
+	}
+	*out = 0;
+}
diff --git a/src/libexif/exif-utils.h b/src/libexif/exif-utils.h
index a75db0b..85b650a 100644
--- a/src/libexif/exif-utils.h
+++ b/src/libexif/exif-utils.h
@@ -1,6 +1,6 @@
 /* exif-utils.h
  *
- * Copyright © 2001 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -33,14 +33,20 @@ extern "C" {
 /* If these definitions don't work for you, please let us fix the 
  * macro generating _stdint.h */
 	
-typedef char		ExifByte;          /* 1 byte  */
+typedef unsigned char	ExifByte;          /* 1 byte  */
+typedef signed char	ExifSByte;         /* 1 byte  */
 typedef char *		ExifAscii;
 typedef uint16_t	ExifShort;         /* 2 bytes */
 typedef int16_t         ExifSShort;        /* 2 bytes */
 typedef uint32_t	ExifLong;          /* 4 bytes */
+
+/** EXIF Unsigned Rational */
 typedef struct {ExifLong numerator; ExifLong denominator;} ExifRational;
+
 typedef char		ExifUndefined;     /* 1 byte  */
 typedef int32_t		ExifSLong;         /* 4 bytes */
+
+/** EXIF Signed Rational. */
 typedef struct {ExifSLong numerator; ExifSLong denominator;} ExifSRational;
 
 
@@ -64,6 +70,8 @@ void exif_set_rational  (unsigned char *b, ExifByteOrder order,
 void exif_set_srational (unsigned char *b, ExifByteOrder order,
 			 ExifSRational value);
 
+void exif_convert_utf16_to_utf8 (char *out, const unsigned short *in, int maxlen);
+
 /* Please do not use this function outside of the library. */
 void exif_array_set_byte_order (ExifFormat, unsigned char *, unsigned int,
 		ExifByteOrder o_orig, ExifByteOrder o_new);
@@ -71,6 +79,9 @@ void exif_array_set_byte_order (ExifFormat, unsigned char *, unsigned int,
 #undef  MIN
 #define MIN(a, b)  (((a) < (b)) ? (a) : (b))
 
+#undef  MAX
+#define MAX(a, b)  (((a) > (b)) ? (a) : (b))
+
 /* For compatibility with older versions */
 #define EXIF_TAG_SUBSEC_TIME EXIF_TAG_SUB_SEC_TIME
 
diff --git a/src/libexif/exif.c b/src/libexif/exif.c
deleted file mode 100644
index 3be72a3..0000000
--- a/src/libexif/exif.c
+++ /dev/null
@@ -1,1274 +0,0 @@
-/*
-
-Copyright © 2000 Matthias Wandel, The PHP Group, Curtis Galloway
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-*/
-
-#include <sys/time.h>
-#include <malloc.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <math.h>
-#include <sys/stat.h>
-#include <stdarg.h>
-#include <fcntl.h>
-
-#include "exif.h"
-
-typedef unsigned char uchar;
-
-#ifndef TRUE
-#define TRUE 1
-#define FALSE 0
-#endif
-
-/* 
-   This structure stores global state for an EXIF image file.
-*/
-typedef struct {
-	exif_data_t *d;
-	int MotorolaOrder;
-	const char *filename;
-
-	char *Thumbnail;
-	int ThumbnailSize;
-} ImageInfoType;
-
-void *(*exif_malloc_fn)(int);
-void *(*exif_realloc_fn)(void *, int);
-void (*exif_free_fn)(void *);
-
-static char *
-exif_strndup(char *str, int len)
-{
-	char *rval = (*exif_malloc_fn)(len+1);
-	strncpy(rval, str, len);
-	rval[len] = '\0';
-	return rval;
-}
-
-struct exif_data *
-exif_alloc(void)
-{
-	exif_data_t *d;
-
-	d = (*exif_malloc_fn)(sizeof(exif_data_t));
-	bzero(d, sizeof(*d));
-	return d;
-}
-
-static void
-exif_error(char *fmt, ...)
-{
-	va_list ap;
-	va_start(ap, fmt);
-	vprintf(fmt, ap);
-	va_end(ap);
-}
-
-
-/* This structure is used to store a section of a Jpeg file. */
-typedef struct {
-    uchar *Data;
-    int      Type;
-    unsigned Size;
-} Section_t;
-
-#define EXIT_FAILURE  1
-#define EXIT_SUCCESS  0
-
-
-/* 
-   JPEG markers consist of one or more 0xFF bytes, followed by a marker
-   code byte (which is not an FF).  Here are the marker codes of interest
-   in this program.  (See jdmarker.c for a more complete list.)
-*/
-
-#define M_SOF0  0xC0            /* Start Of Frame N                        */
-#define M_SOF1  0xC1            /* N indicates which compression process   */
-#define M_SOF2  0xC2            /* Only SOF0-SOF2 are now in common use    */
-#define M_SOF3  0xC3
-#define M_SOF5  0xC5            /* NB: codes C4 and CC are NOT SOF markers */
-#define M_SOF6  0xC6
-#define M_SOF7  0xC7
-#define M_SOF9  0xC9
-#define M_SOF10 0xCA
-#define M_SOF11 0xCB
-#define M_SOF13 0xCD
-#define M_SOF14 0xCE
-#define M_SOF15 0xCF
-#define M_SOI   0xD8            /* Start Of Image (beginning of datastream) */
-#define M_EOI   0xD9            /* End Of Image (end of datastream)         */
-#define M_SOS   0xDA            /* Start Of Scan (begins compressed data)   */
-#define M_EXIF  0xE1            
-#define M_COM   0xFE            /* COMment                                  */
-
-
-#define PSEUDO_IMAGE_MARKER 0x123; /* Extra value. */
-
-#define EXIF_ALLOC_SIZE 16
-
-/*
- * The name gets copied, so you can pass a static string;
- * the data is not copied, so if it is a string,
- * you must allocate it yourself.
- */
-static int
-exif_append_data(exif_data_t **d_p,
-				 char *name,
-				 char rec_type,
-				 int exif_format,
-				 exif_rec_data_t *data)
-{
-	exif_data_t *d = *d_p;
-
-	if (rec_type == '\0')
-		return EXIT_FAILURE;
-
-	if (d->n_alloc <= d->n_recs) {
-		d->n_alloc += EXIF_ALLOC_SIZE;
-		d = (*exif_realloc_fn)(d, sizeof(exif_data_t) +
-							   sizeof(exif_record_t) * d->n_alloc);
-		*d_p = d;
-	}
-	d->recs[d->n_recs].rec_type = rec_type;
-	bcopy(data, &d->recs[d->n_recs].rec_data, sizeof(exif_rec_data_t));
-	d->recs[d->n_recs].rec_name = (char*)strdup(name);
-	d->n_recs++;
-	return EXIT_SUCCESS;
-}
-
-/*
-   Get 16 bits motorola order (always) for jpeg header stuff.
-*/
-static int
-Get16m(void *Short)
-{
-    return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
-}
-
-
-/*
-   Process a COM marker.
-   We want to print out the marker contents as legible text;
-   we must guard against random junk and varying newline representations.
-*/
-static void
-process_COM (ImageInfoType *ImageInfo, uchar *Data, int length)
-{
-    int ch;
-    char *Comment;
-    int nch;
-    int a;
-    exif_rec_data_t rd;
-
-    nch = 0;
-    Comment = (*exif_malloc_fn)(length+1);
-
-    for (a=2;a<length;a++) {
-        ch = Data[a];
-
-        if (ch == '\r' && Data[a+1] == '\n') continue; /* Remove cr followed by lf. */
-
-        if (isprint(ch) || ch == '\n' || ch == '\t') {
-            Comment[nch++] = (char)ch;
-        } else {
-            Comment[nch++] = '?';
-        }
-    }
-
-    Comment[nch] = '\0'; /* Null terminate */
-
-    rd.s = Comment;
-    exif_append_data(&ImageInfo->d, "Comment", 's', EXIF_FMT_COMPUTED, &rd);
-}
- 
-/* Process a SOFn marker.  This is useful for the image dimensions. */
-static void
-process_SOFn (ImageInfoType *ImageInfo, uchar *Data, int marker)
-{
-    int data_precision, num_components;
-    const char *process;
-    exif_rec_data_t rd;
-
-    data_precision = Data[2];
-    rd.l = Get16m(Data+3);
-    exif_append_data(&ImageInfo->d,
-					 "Height",
-					 'l',
-					 EXIF_FMT_COMPUTED,
-					 &rd);
-    rd.l = Get16m(Data+5);
-    exif_append_data(&ImageInfo->d,
-					 "Width",
-					 'l',
-					 EXIF_FMT_COMPUTED,
-					 &rd);
-    num_components = Data[7];
-
-    if (num_components == 3) {
-		rd.l = 1;
-    } else {
-		rd.l = 0;
-    }
-    exif_append_data(&ImageInfo->d, "IsColor", 'l', EXIF_FMT_COMPUTED, &rd);
-
-    switch (marker) {
-	case M_SOF0:  process = "Baseline";  break;
-	case M_SOF1:  process = "Extended sequential";  break;
-	case M_SOF2:  process = "Progressive";  break;
-	case M_SOF3:  process = "Lossless";  break;
-	case M_SOF5:  process = "Differential sequential";  break;
-	case M_SOF6:  process = "Differential progressive";  break;
-	case M_SOF7:  process = "Differential lossless";  break;
-	case M_SOF9:  process = "Extended sequential, arithmetic coding";  break;
-	case M_SOF10: process = "Progressive, arithmetic coding";  break;
-	case M_SOF11: process = "Lossless, arithmetic coding";  break;
-	case M_SOF13: process = "Differential sequential, arithmetic coding";  break;
-	case M_SOF14: process = "Differential progressive, arithmetic coding"; break;
-	case M_SOF15: process = "Differential lossless, arithmetic coding";  break;
-	default:      process = "Unknown";  break;
-    }
-}
-
-/*
-   Describes format descriptor
-*/
-static int ExifBytesPerFormat[] = {0,1,1,2,4,8,1,1,2,4,8,4,8};
-#define NUM_FORMATS EXIF_FMT_DOUBLE
-
-/*
-   Describes tag values
-*/
-
-#define TAG_EXIF_OFFSET       0x8769
-#define TAG_INTEROP_OFFSET    0xa005
-
-#define TAG_COMPRESSION       0x0103
-
-#define TAG_MAKE              0x010F
-#define TAG_MODEL             0x0110
-#define TAG_ORIENTATION       0x0112
-
-#define TAG_SOFTWARE          0x0131
-
-/* Olympus specific tags */
-#define TAG_SPECIALMODE       0x0200
-#define TAG_JPEGQUAL          0x0201
-#define TAG_MACRO             0x0202
-#define TAG_DIGIZOOM          0x0204
-#define TAG_SOFTWARERELEASE   0x0207
-#define TAG_PICTINFO          0x0208
-#define TAG_CAMERAID          0x0209
-/* end Olympus specific tags */
-
-#define TAG_COPYRIGHT         0x8298
-
-#define TAG_EXPOSURETIME      0x829A
-#define TAG_FNUMBER           0x829D
-
-#define TAG_GPSINFO           0x8825
-#define TAG_ISOSPEED          0x8827
-#define TAG_EXIFVERSION       0x9000
-
-#define TAG_SHUTTERSPEED      0x9201
-#define TAG_APERTURE          0x9202
-#define TAG_MAXAPERTURE       0x9205
-#define TAG_FOCALLENGTH       0x920A
-
-#define TAG_DATETIME_ORIGINAL 0x9003
-#define TAG_USERCOMMENT       0x9286
-
-#define TAG_SUBJECT_DISTANCE  0x9206
-#define TAG_LIGHT_SOURCE      0x9208
-#define TAG_FLASH             0x9209
-
-#define TAG_FOCALPLANEXRES    0xa20E
-#define TAG_FOCALPLANEUNITS   0xa210
-#define TAG_IMAGEWIDTH        0xA002
-
-struct ExifTag {
-    unsigned short Tag;
-    char *Desc;
-	void (*Func)();
-};
-
-
-
-/* Convert a 16 bit unsigned value from file's native byte order */
-static int
-Get16u(void *Short, int MotorolaOrder)
-{
-    if (MotorolaOrder) {
-        return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
-    } else {
-        return (((uchar *)Short)[1] << 8) | ((uchar *)Short)[0];
-    }
-}
-
-/* Convert a 32 bit signed value from file's native byte order */
-static int
-Get32s(void *Long, int MotorolaOrder)
-{
-    if (MotorolaOrder) {
-        return  ((( char *)Long)[0] << 24) | (((uchar *)Long)[1] << 16)
-			| (((uchar *)Long)[2] << 8 ) | (((uchar *)Long)[3] << 0 );
-    } else {
-        return  ((( char *)Long)[3] << 24) | (((uchar *)Long)[2] << 16)
-			| (((uchar *)Long)[1] << 8 ) | (((uchar *)Long)[0] << 0 );
-    }
-}
-
-/* Convert a 32 bit unsigned value from file's native byte order */
-static unsigned
-Get32u(void *Long, int MotorolaOrder)
-{
-    return (unsigned)Get32s(Long, MotorolaOrder) & 0xffffffff;
-}
-
-
-/* Evaluate number, be it int, rational, or float from directory. */
-static double
-ConvertAnyFormat(void *ValuePtr, int Format, int MotorolaOrder)
-{
-    double Value;
-    Value = 0;
-
-    switch(Format) {
-	case EXIF_FMT_SBYTE:     Value = *(signed char *)ValuePtr;  break;
-	case EXIF_FMT_BYTE:      Value = *(uchar *)ValuePtr;        break;
-
-	case EXIF_FMT_USHORT:    Value = Get16u(ValuePtr,MotorolaOrder);          break;
-	case EXIF_FMT_ULONG:     Value = Get32u(ValuePtr,MotorolaOrder);          break;
-
-	case EXIF_FMT_URATIONAL:
-	case EXIF_FMT_SRATIONAL: 
-		{
-			int Num,Den;
-			Num = Get32s(ValuePtr,MotorolaOrder);
-			Den = Get32s(4+(char *)ValuePtr,MotorolaOrder);
-			if (Den == 0) {
-				Value = 0;
-			} else {
-				Value = (double)Num/Den;
-			}
-			break;
-		}
-
-	case EXIF_FMT_SSHORT:    Value = (signed short)Get16u(ValuePtr,MotorolaOrder);  break;
-	case EXIF_FMT_SLONG:     Value = Get32s(ValuePtr,MotorolaOrder);                break;
-
-        /* Not sure if this is correct (never seen float used in Exif format) */
-	case EXIF_FMT_SINGLE:    Value = (double)*(float *)ValuePtr;      break;
-	case EXIF_FMT_DOUBLE:    Value = *(double *)ValuePtr;             break;
-    }
-    return Value;
-}
-
-/* Evaluate number, be it int, rational, or float from directory. */
-static char
-ConvertAnyFormat2(void *ValuePtr, int ByteCount, int Format, int MotorolaOrder, exif_rec_data_t *data_p)
-{
-	char *str, *p;
-	char r_type;
-	unsigned char c;
-	static char hexdigits[] = "0123456789ABCDEF";
-
-    switch(Format) {
-	case EXIF_FMT_STRING:
-		data_p->s = exif_strndup(ValuePtr, ByteCount);
-		r_type = 's';
-		break;
-
-	case EXIF_FMT_SBYTE:
-		data_p->l = (long)*(signed char *)ValuePtr;
-		r_type = 'l';
-		break;
-
-	case EXIF_FMT_BYTE:
-		data_p->l = (long)*(uchar *)ValuePtr;
-		r_type = 'l';
-        break;
-
-	case EXIF_FMT_USHORT:
-		data_p->l = (long)Get16u(ValuePtr,MotorolaOrder);
-		r_type = 'l';
-		break;
-	case EXIF_FMT_ULONG:
-		data_p->l = (long)Get32u(ValuePtr,MotorolaOrder);
-		r_type = 'l';
-		break;
-
-	case EXIF_FMT_URATIONAL:
-	case EXIF_FMT_SRATIONAL: 
-		{
-			int Num,Den;
-			data_p->r.num = Get32s(ValuePtr,MotorolaOrder);
-			data_p->r.denom = Get32s(4+(char *)ValuePtr,MotorolaOrder);
-			r_type = 'r';
-			break;
-		}
-
-	case EXIF_FMT_SSHORT:
-		data_p->l = (signed short)Get16u(ValuePtr,MotorolaOrder);
-		r_type = 'l';
-		break;
-	case EXIF_FMT_SLONG:
-		data_p->l = (long)Get32s(ValuePtr,MotorolaOrder);
-		r_type = 'l';
-		break;
-
-        /* Not sure if this is correct (never seen float used in Exif format) */
-	case EXIF_FMT_SINGLE:
-		data_p->f = *(float *)ValuePtr;
-		r_type = 'f';
-		break;
-
-	case EXIF_FMT_DOUBLE:
-		data_p->g = *(double *)ValuePtr;
-		r_type = 'f';
-		break;
-
-	default:
-		/* unknown type */
-		p = str = (*exif_malloc_fn)(ByteCount*2 + 1);
-		while (ByteCount--) {
-			c = *(unsigned char *)ValuePtr++;
-			*p++ = hexdigits[c / 16];
-			*p++ = hexdigits[c % 16];
-		}
-		*p++ = '\0';
-		data_p->s = str;
-		r_type = 's';
-		break;
-    }
-    return r_type;
-}
-
-
-static void
-ProcessFocalPlaneUnits(ImageInfoType *ImageInfo,
-					   void *ValuePtr,
-					   int ByteCount,
-					   int Format,
-					   struct ExifTag *tag_p)
-{
-    exif_rec_data_t rd;
-	float FocalPlaneUnits;
-
-	switch((int)ConvertAnyFormat(ValuePtr, Format, ImageInfo->MotorolaOrder)) {
-	case 1:
-		FocalPlaneUnits = 25.4;
-		break; /* inch */
-	case 2: 
-		/* According to the information I was using, 2 means meters.
-		   But looking at the Canon PowerShot's files, inches is the only
-		   sensible value. */
-		FocalPlaneUnits = 25.4;
-		break;
-
-	case 3:
-		FocalPlaneUnits = 10;
-		break;  /* centimeter */
-	case 4:
-		FocalPlaneUnits = 1;
-		break;  /* milimeter  */
-	case 5:
-		FocalPlaneUnits = .001;
-		break;  /* micrometer */
-	}
-
-	rd.f = FocalPlaneUnits;
-	exif_append_data(&ImageInfo->d,
-					 "FocalPlaneUnits",
-					 'f',
-					 Format,
-					 &rd);
-}
-
-static void
-ProcessVersion(ImageInfoType *ImageInfo,
-				   void *ValuePtr,
-				   int ByteCount,
-				   int Format,
-				   struct ExifTag *tag_p)
-{
-    exif_rec_data_t rd;
-	rd.s = exif_strndup(ValuePtr, ByteCount);
-	exif_append_data(&ImageInfo->d,
-					 tag_p->Desc,
-					 's',
-					 Format,
-					 &rd);
-}
-
-static void
-ProcessUserComment(ImageInfoType *ImageInfo,
-				   void *_ValuePtr,
-				   int ByteCount,
-				   int Format,
-				   struct ExifTag *tag_p)
-{
-	char *ValuePtr = (char *)_ValuePtr;
-    exif_rec_data_t rd;
-	int a;
-
-	/* Olympus has this padded with trailing spaces.  Remove these first. */
-	for (a=ByteCount;;) {
-		a--;
-		if ((ValuePtr)[a] == ' ') {
-			(ValuePtr)[a] = '\0';
-		} else {
-			break;
-		}
-		if (a == 0) break;
-	}
-
-	/* Copy the comment */
-	if (memcmp(ValuePtr, "ASCII",5) == 0) {
-		for (a=5;a<10;a++) {
-			int c;
-			c = (ValuePtr)[a];
-			if (c != '\0' && c != ' ') {
-				rd.s = exif_strndup(a+ValuePtr, ByteCount - a);
-				exif_append_data(&ImageInfo->d,
-								 "UserComment",
-								 's',
-								 Format,
-								 &rd);
-				break;
-			}
-		}
-                    
-	} else {
-		rd.s = exif_strndup(ValuePtr, ByteCount);
-		exif_append_data(&ImageInfo->d,
-						 "UserComment",
-						 's',
-						 Format,
-						 &rd);
-	}
-}
-
-static void
-ProcessShutterSpeed(ImageInfoType *ImageInfo,
-					void *ValuePtr,
-					int ByteCount,
-					int Format,
-					struct ExifTag *tag_p)
-{
-    exif_rec_data_t rd;
-	char rec_type;
-
-	rec_type = ConvertAnyFormat2(ValuePtr, ByteCount, Format,
-								 ImageInfo->MotorolaOrder,
-								 &rd);
-	exif_append_data(&ImageInfo->d,
-					 tag_p->Desc,
-					 rec_type,
-					 Format,
-					 &rd);
-
-	/* Convert shutter speed value to shutter speed;
-	 * shutter speed is 1/(2**ShutterSpeedValue)
-     */
-	rd.r.denom = (int)pow(2.0, ((double)rd.r.num)/((double)rd.r.denom));
-	rd.r.num = 1;
-	exif_append_data(&ImageInfo->d,
-					 "ShutterSpeed",
-					 'r',
-					 EXIF_FMT_COMPUTED,
-					 &rd);
-	
-}
-
-static void
-ProcessAperture(ImageInfoType *ImageInfo,
-				void *ValuePtr,
-				int ByteCount,
-				int Format,
-				struct ExifTag *tag_p)
-{
-    exif_rec_data_t rd;
-	char rec_type;
-	double fstop;
-	char label[32];
-
-	rec_type = ConvertAnyFormat2(ValuePtr, ByteCount, Format,
-								 ImageInfo->MotorolaOrder,
-								 &rd);
-	exif_append_data(&ImageInfo->d,
-					 tag_p->Desc,
-					 rec_type,
-					 Format,
-					 &rd);
-
-	if (exif_find_record(ImageInfo->d, "FNumber") == NULL) {
-		/* Convert aperture to F-stop. */
-		fstop = pow(sqrt(2), ((double)rd.r.num)/((double)rd.r.denom));
-		sprintf(label, "f%.1g", fstop);
-		rd.s = (char*)strdup(label);
-		exif_append_data(&ImageInfo->d,
-						 "FNumber",
-						 's',
-						 EXIF_FMT_COMPUTED,
-						 &rd);
-	}
-}
-
-static void
-ProcessCanonMakerNote(ImageInfoType *ImageInfo,
-				 void *ValuePtr,
-				 int ByteCount,
-				 int Format,
-				 struct ExifTag *tag_p,
-				 char *OffsetBase)
-{
-	
-	/* This is for the Canon MakerNote. */
-	/* XXX - go by value of Maker tag. */
-    exif_rec_data_t rd;
-	char rec_type;
-	unsigned long n_dir, tag, format, components, offset;
-	char label[32];
-	void *OffsetPtr;
-
-	n_dir = Get16u(ValuePtr, ImageInfo->MotorolaOrder);
-	ValuePtr += 2;
-	while (n_dir--) {
-		tag = Get16u(ValuePtr, ImageInfo->MotorolaOrder);
-		ValuePtr += 2;
-		format = Get16u(ValuePtr, ImageInfo->MotorolaOrder);
-		ValuePtr += 2;
-		components = Get32u(ValuePtr, ImageInfo->MotorolaOrder);
-		ValuePtr += 4;
-		offset = Get32u(ValuePtr, ImageInfo->MotorolaOrder);
-        ByteCount = components * ExifBytesPerFormat[format];
-		if (ByteCount > 4) {
-			OffsetPtr = OffsetBase + offset;
-		} else {
-			OffsetPtr = ValuePtr;
-		}
-		ValuePtr += 4;
-		rec_type = ConvertAnyFormat2(OffsetPtr, ByteCount, format,
-									 ImageInfo->MotorolaOrder,
-									 &rd);
-		sprintf(label, "MakerNote%04x", tag);
-		exif_append_data(&ImageInfo->d,
-						 label,
-						 rec_type,
-						 format,
-						 &rd);
-		
-	}
-}
-
-
-struct MakerNote {
-	char *Make;
-	void (*Func)();
-};
-
-static struct MakerNote
-MakerProcessors[] = {
-	{"Canon", ProcessCanonMakerNote},
-    {NULL, NULL}
-};
-
-static void
-ProcessMakerNote(ImageInfoType *ImageInfo,
-				 void *ValuePtr,
-				 int ByteCount,
-				 int Format,
-				 struct ExifTag *tag_p,
-				 char *OffsetBase)
-{
-	struct MakerNote *mn_p;
-	exif_record_t *rec_p;
-
-	rec_p = exif_find_record(ImageInfo->d, "Make");
-	if (rec_p == NULL) {
-		return;
-	}
-
-	for(mn_p = &MakerProcessors[0]; mn_p->Make != NULL; mn_p++) {
-		if (strcmp(mn_p->Make, rec_p->rec_data.s) == 0) {
-			(*mn_p->Func)(ImageInfo, ValuePtr, ByteCount, Format, tag_p, OffsetBase);
-			break;
-		}
-	}
-}
-
-static struct ExifTag
-TagTable[] = {
-	{   0x0001, "InteroperabilityIndex"},
-	{   0x0002, "InteroperabilityVersion", ProcessVersion},
-	{	0x0100,	"ImageWidth"},
-	{	0x0101,	"ImageLength"},
-	{	0x0102,	"BitsPerSample"},
-	{	0x0103,	"Compression"},
-	{	0x0106,	"PhotometricInterpretation"},
-	{	0x010A,	"FillOrder"},
-	{	0x010D,	"DocumentName"},
-	{	0x010E,	"ImageDescription"},
-	{	0x010F,	"Make"},
-	{	0x0110,	"Model"},
-	{	0x0111,	"StripOffsets"},
-	{	0x0112,	"Orientation"},
-	{	0x0115,	"SamplesPerPixel"},
-	{	0x0116,	"RowsPerStrip"},
-	{	0x0117,	"StripByteCounts"},
-	{	0x011A,	"XResolution"},
-	{	0x011B,	"YResolution"},
-	{	0x011C,	"PlanarConfiguration"},
-	{	0x0128,	"ResolutionUnit"},
-	{	0x012D,	"TransferFunction"},
-	{	0x0131,	"Software"},
-	{	0x0132,	"DateTime"},
-	{	0x013B,	"Artist"},
-	{	0x013E,	"WhitePoint"},
-	{	0x013F,	"PrimaryChromaticities"},
-	{	0x0156,	"TransferRange"},
-	{	0x0200,	"JPEGProc"},
-	{	0x0201,	"JPEGInterchangeFormat"},
-	{	0x0202,	"JPEGInterchangeFormatLength"},
-	{	0x0211,	"YCbCrCoefficients"},
-	{	0x0212,	"YCbCrSubSampling"},
-	{	0x0213,	"YCbCrPositioning"},
-	{	0x0214,	"ReferenceBlackWhite"},
-	{   0x1000, "RelatedImageFileFormat"},
-	{   0x1001, "RelatedImageWidth"},
-	{   0x1002, "RelatedImageLength"},
-	{	0x828D,	"CFARepeatPatternDim"},
-	{	0x828E,	"CFAPattern"},
-	{	0x828F,	"BatteryLevel"},
-	{	0x8298,	"Copyright"},
-	{	0x829A,	"ExposureTime"},
-	{	0x829D,	"FNumber"},
-	{	0x83BB,	"IPTC/NAA"},
-	{	0x8769,	"ExifOffset"},
-	{	0x8773,	"InterColorProfile"},
-	{	0x8822,	"ExposureProgram"},
-	{	0x8824,	"SpectralSensitivity"},
-	{	0x8825,	"GPSInfo"},
-	{	0x8827,	"ISOSpeedRatings"},
-	{	0x8828,	"OECF"},
-	{	0x9000,	"ExifVersion", ProcessVersion},
-	{	0x9003,	"DateTimeOriginal"},
-	{	0x9004,	"DateTimeDigitized"},
-	{	0x9101,	"ComponentsConfiguration"},
-	{	0x9102,	"CompressedBitsPerPixel"},
-	{	0x9201,	"ShutterSpeedValue", ProcessShutterSpeed},
-	{	0x9202,	"ApertureValue", ProcessAperture},
-	{	0x9203,	"BrightnessValue"},
-	{	0x9204,	"ExposureBiasValue"},
-	{	0x9205,	"MaxApertureValue", ProcessAperture},
-	{	0x9206,	"SubjectDistance"},
-	{	0x9207,	"MeteringMode"},
-	{	0x9208,	"LightSource"},
-	{	0x9209,	"Flash"},
-	{	0x920A,	"FocalLength"},
-	{	0x927C,	"MakerNote", ProcessMakerNote},
-	{	0x9286,	"UserComment", ProcessUserComment},
-	{	0x9290,	"SubSecTime"},
-	{	0x9291,	"SubSecTimeOriginal"},
-	{	0x9292,	"SubSecTimeDigitized"},
-	{	0xA000,	"FlashPixVersion", ProcessVersion},
-	{	0xA001,	"ColorSpace"},
-	{	0xA002,	"ExifImageWidth"},
-	{	0xA003,	"ExifImageLength"},
-	{	0xA005,	"InteroperabilityOffset"},
-	{	0xA20B,	"FlashEnergy"},			        /* 0x920B in TIFF/EP */
-	{	0xA20C,	"SpatialFrequencyResponse"},	/* 0x920C    -  -    */
-	{	0xA20E,	"FocalPlaneXResolution"},    	/* 0x920E    -  -    */
-	{	0xA20F,	"FocalPlaneYResolution"},	    /* 0x920F    -  -    */
-	{	0xA210,	"FocalPlaneResolutionUnit", ProcessFocalPlaneUnits},
-	                                            /* 0x9210    -  -    */
-	{	0xA214,	"SubjectLocation"},		        /* 0x9214    -  -    */
-	{	0xA215,	"ExposureIndex"},		        /* 0x9215    -  -    */
-	{	0xA217,	"SensingMethod"},		        /* 0x9217    -  -    */
-	{	0xA300,	"FileSource"},
-	{	0xA301,	"SceneType"},
-	{        0, NULL}
-} ;
-
-
-
-/* Process one of the nested EXIF directories. */
-static int
-ProcessExifDir(ImageInfoType *ImageInfo, char *DirStart, char *OffsetBase, unsigned ExifLength, char *LastExifRefd)
-{
-    int de;
-    int a;
-    int NumDirEntries;
-    exif_rec_data_t rd;
-	char rec_type;
-	char label[32];
-
-    NumDirEntries = Get16u(DirStart, ImageInfo->MotorolaOrder);
-
-    if ((DirStart+2+NumDirEntries*12) > (OffsetBase+ExifLength)) {
-		exif_error("Illegally sized directory");
-		return FALSE;
-    }
-
-
-    for (de=0;de<NumDirEntries;de++) {
-        int Tag, Format, Components;
-        char *ValuePtr;
-        int ByteCount;
-        char *DirEntry;
-		struct ExifTag *tag_p;
-
-        DirEntry = DirStart+2+12*de;
-
-        Tag = Get16u(DirEntry, ImageInfo->MotorolaOrder);
-        Format = Get16u(DirEntry+2, ImageInfo->MotorolaOrder);
-        Components = Get32u(DirEntry+4, ImageInfo->MotorolaOrder);
-
-        if ((Format-1) >= NUM_FORMATS) {
-            /* (-1) catches illegal zero case as unsigned underflows to positive large. */
-			exif_error("Illegal format code in EXIF dir");
-			return FALSE;
-        }
-
-        ByteCount = Components * ExifBytesPerFormat[Format];
-
-        if (ByteCount > 4) {
-            unsigned OffsetVal;
-            OffsetVal = Get32u(DirEntry+8, ImageInfo->MotorolaOrder);
-            /* If its bigger than 4 bytes, the dir entry contains an offset. */
-            if (OffsetVal+ByteCount > ExifLength) {
-                /* Bogus pointer offset and / or bytecount value */
-				/*                printf("Offset %d bytes %d ExifLen %d\n",OffsetVal, ByteCount, ExifLength); */
-
-				exif_error("Illegal pointer offset value in EXIF");
-				return FALSE;
-            }
-            ValuePtr = OffsetBase+OffsetVal;
-        } else {
-            /* 4 bytes or less and value is in the dir entry itself */
-            ValuePtr = DirEntry+8;
-        }
-
-        if (LastExifRefd < ValuePtr+ByteCount) {
-            /* 
-			   Keep track of last byte in the exif header that was actually referenced.
-               That way, we know where the discardable thumbnail data begins.
-			*/
-            LastExifRefd = ValuePtr+ByteCount;
-        }
-
-        if (Tag == TAG_EXIF_OFFSET || Tag == TAG_INTEROP_OFFSET) {
-            char *SubdirStart;
-            SubdirStart = OffsetBase + Get32u(ValuePtr, ImageInfo->MotorolaOrder);
-            if (SubdirStart < OffsetBase || SubdirStart > OffsetBase+ExifLength) {
-				exif_error("Illegal subdirectory link");
-				return FALSE;
-            }
-            ProcessExifDir(ImageInfo, SubdirStart, OffsetBase, ExifLength, LastExifRefd);
-            continue;
-        }
-
-		/* Search through tag table */
-		for (tag_p = &TagTable[0]; tag_p->Desc != NULL; tag_p++) {
-			if (tag_p->Tag == Tag) {
-				if (tag_p->Func != NULL) {
-					(*tag_p->Func)(ImageInfo, ValuePtr, ByteCount, Format, tag_p, OffsetBase);
-				} else {
-					rec_type = ConvertAnyFormat2(ValuePtr, ByteCount, Format,
-												 ImageInfo->MotorolaOrder,
-												 &rd);
-					exif_append_data(&ImageInfo->d,
-									 tag_p->Desc,
-									 rec_type,
-									 Format,
-									 &rd);
-				}
-				break;
-			}
-		}
-		if (tag_p->Desc == NULL) {
-			rec_type = ConvertAnyFormat2(ValuePtr, ByteCount, Format,
-										 ImageInfo->MotorolaOrder,
-										 &rd);
-			sprintf(label, "0x%04x", Tag);
-			exif_append_data(&ImageInfo->d,
-							 label,
-							 rec_type,
-							 Format,
-							 &rd);
-		}
-	}
-    return TRUE;
-}
-
-/* 
-   Process an EXIF marker
-   Describes all the drivel that most digital cameras include...
-*/
-static int
-process_EXIF (ImageInfoType *ImageInfo, char *CharBuf, unsigned int length, char *LastExifRefd)
-{
-	int cc;
-	exif_rec_data_t rd;
-	LastExifRefd = CharBuf;
-
-	{   /* Check the EXIF header component */
-		static const uchar ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
-		if (memcmp(CharBuf+2, ExifHeader,6)) {
-			exif_error("Incorrect Exif header");
-			return FALSE;
-		}
-	}
-
-	if (memcmp(CharBuf+8,"II",2) == 0) {
-		ImageInfo->MotorolaOrder = 0;
-	} else {
-		if (memcmp(CharBuf+8,"MM",2) == 0) {
-			ImageInfo->MotorolaOrder = 1;
-		} else {
-			exif_error("Invalid Exif alignment marker.");
-			return FALSE;
-		}
-	}
-
-	/* Check the next two values for correctness. */
-	if (Get16u(CharBuf+10,ImageInfo->MotorolaOrder) != 0x2a
-		|| Get32u(CharBuf+12,ImageInfo->MotorolaOrder) != 0x08) {
-		exif_error("Invalid Exif start (1, NULL)");
-		return FALSE;
-	}
-
-	/* First directory starts 16 bytes in.  Offsets start at 8 bytes in. */
-	cc = ProcessExifDir(ImageInfo, CharBuf+16, CharBuf+8, length-6, LastExifRefd);
-	if (cc != TRUE) {
-		return cc;
-	}
-	return TRUE;
-}
- 
-/* Parse the marker stream until SOS or EOI is seen; */
-static int 
-scan_JPEG_header (ImageInfoType *ImageInfo, FILE *infile, Section_t *Sections, int *SectionsRead, int ReadAll, char *LastExifRefd)
-{
-    int a;
-    int HaveCom = FALSE;
-
-    a = fgetc(infile);
-    if (a != 0xff || fgetc(infile) != M_SOI) {
-        return FALSE;
-    }
-
-    for(*SectionsRead=0;*SectionsRead < 19;) {
-        int itemlen;
-        int marker = 0;
-        int ll,lh, got;
-        uchar *Data;
-
-        for (a=0;a<7;a++) {
-            marker = fgetc(infile);
-            if (marker != 0xff) break;
-        }
-        if (marker == 0xff) {
-            /* 0xff is legal padding, but if we get that many, something's wrong. */
-			exif_error("too many padding bytes!");
-			return FALSE;
-        }
-
-        Sections[*SectionsRead].Type = marker;
-  
-        /* Read the length of the section. */
-        lh = fgetc(infile);
-        ll = fgetc(infile);
-
-        itemlen = (lh << 8) | ll;
-
-        if (itemlen < 2) {
-			exif_error("invalid marker");
-			return FALSE;
-        }
-
-        Sections[*SectionsRead].Size = itemlen;
-
-        Data = (uchar *)(*exif_malloc_fn)(itemlen+1); /* Add 1 to allow sticking a 0 at the end. */
-        Sections[*SectionsRead].Data = Data;
-
-        /* Store first two pre-read bytes. */
-        Data[0] = (uchar)lh;
-        Data[1] = (uchar)ll;
-
-        got = fread(Data+2, 1, itemlen-2, infile); /* Read the whole section. */
-        if (got != itemlen-2) {
-			exif_error("reading from file");
-			return FALSE;
-        }
-        *SectionsRead += 1;
-
-        switch(marker) {
-		case M_SOS:   /* stop before hitting compressed data  */
-			/* If reading entire image is requested, read the rest of the data. */
-			if (ReadAll) {
-				int cp, ep, size;
-				/* Determine how much file is left. */
-				cp = ftell(infile);
-				fseek(infile, 0, SEEK_END);
-				ep = ftell(infile);
-				fseek(infile, cp, SEEK_SET);
-
-				size = ep-cp;
-				Data = (uchar *)(*exif_malloc_fn)(size);
-				if (Data == NULL) {
-					exif_error("could not allocate data for entire image");
-					return FALSE;
-				}
-
-				got = fread(Data, 1, size, infile);
-				if (got != size) {
-					exif_error("could not read the rest of the image");
-					return FALSE;
-				}
-
-				Sections[*SectionsRead].Data = Data;
-				Sections[*SectionsRead].Size = size;
-				Sections[*SectionsRead].Type = PSEUDO_IMAGE_MARKER;
-				(*SectionsRead)++;
-				/*
-				 *HaveAll = 1;
-				 */
-			}
-			return TRUE;
-
-		case M_EOI:   /* in case it's a tables-only JPEG stream */
-			exif_error("No image in jpeg!");
-			return FALSE;
-
-		case M_COM: /* Comment section */
-			if (HaveCom) {
-				(*SectionsRead) -= 1;
-				(*exif_free_fn)(Sections[*SectionsRead].Data);
-			} else {
-				process_COM(ImageInfo, Data, itemlen);
-				HaveCom = TRUE;
-			}
-			break;
-
-		case M_EXIF:
-			if (*SectionsRead <= 2) {
-				/* Seen files from some 'U-lead' software with Vivitar scanner
-				   that uses marker 31 later in the file (no clue what for!) */
-				process_EXIF(ImageInfo, (char *)Data, itemlen, LastExifRefd);
-			}
-			break;
-
-		case M_SOF0: 
-		case M_SOF1: 
-		case M_SOF2: 
-		case M_SOF3: 
-		case M_SOF5: 
-		case M_SOF6: 
-		case M_SOF7: 
-		case M_SOF9: 
-		case M_SOF10:
-		case M_SOF11:
-		case M_SOF13:
-		case M_SOF14:
-		case M_SOF15:
-			process_SOFn(ImageInfo, Data, marker);
-			break;
-		default:
-			/* skip any other marker silently. */
-			break;
-        }
-    }
-    return TRUE;
-}
-
-/* 
-   Discard read data.
-*/
-static void
-DiscardData(Section_t *Sections, int *SectionsRead)
-{
-    int a;
-    for (a=0;a<*SectionsRead-1;a++) {
-        (*exif_free_fn)(Sections[a].Data);
-    }
-    *SectionsRead = 0;
-}
-
-/* 
-   Read image data.
-*/
-static int
-ReadJpegFile(ImageInfoType *ImageInfo, Section_t *Sections, 
-			 int *SectionsRead, int fd, 
-			 int ReadAll, char *LastExifRefd)
-{
-    FILE *infile;
-    int ret;
-	char *tmp;
-	char **p_argv;
-	int p_argc;
-
-    infile = fdopen(fd, "rb"); /* Unix ignores 'b', windows needs it. */
-
-    if (infile == NULL) {
-		exif_error("Unable to open '%s'", ImageInfo->filename);
-		return FALSE;
-    }
-
-    /* Start with an empty image information structure. */
-    memset(ImageInfo, 0, sizeof(*ImageInfo));
-    memset(Sections, 0, sizeof(*Sections));
-
-    ImageInfo->d = exif_alloc();
-
-    /* Scan the JPEG headers. */
-    ret = scan_JPEG_header(ImageInfo, infile, Sections, SectionsRead, ReadAll, LastExifRefd);
-    if (!ret) {
-		exif_error("Invalid Jpeg file: '%s'",ImageInfo->filename);
-		return FALSE;
-    }
-
-    fclose(infile);
-
-    return ret;
-}
-
-static int
-read_jpeg_exif(ImageInfoType *ImageInfo, int fd, int ReadAll)
-{
-	Section_t Sections[20];
-	int SectionsRead;
-	char *LastExifRefd=NULL;
-	int ret;
-	int thumbsize=0;
-
-	ret = ReadJpegFile(ImageInfo, Sections, &SectionsRead, fd, ReadAll, LastExifRefd); 
-#if 0
-	/*
-	 * Thought this might pick out the embedded thumbnail, but it doesn't work.   -RL
-     */
-	for (i=0;i<SectionsRead-1;i++) {
-		if (Sections[i].Type == M_EXIF) {
-			thumbsize = Sections[i].Size;
-			if(thumbsize>0) {
-				ImageInfo->Thumbnail = (*exif_malloc_fn)(thumbsize+5);
-				ImageInfo->ThumbnailSize = thumbsize;
-				ImageInfo->Thumbnail[0] = 0xff;
-				ImageInfo->Thumbnail[1] = 0xd8;
-				ImageInfo->Thumbnail[2] = 0xff;
-				memcpy(ImageInfo->Thumbnail+4, Sections[i].Data, thumbsize+4);
-			}
-		}
-	}
-#endif
-    if (ret != FALSE) {
-        DiscardData(Sections, &SectionsRead);
-    }
-	return(ret);
-}
-
-exif_data_t *
-exif_parse_fd(int fd)
-{
-	ImageInfoType ImageInfo;
-
-	ImageInfo.filename = "<file stream>";
-	if (read_jpeg_exif(&ImageInfo, fd, 1) != TRUE) {
-		return NULL;
-	}
-	return ImageInfo.d;
-}
-
-exif_data_t *
-exif_parse_file(const char *filename)
-{
-	ImageInfoType ImageInfo;
-	int fd;
-	
-	ImageInfo.filename = filename;
-	fd = open(filename, O_RDONLY);
-	if (fd < 0) {
-		return NULL;
-	}
-
-	if (read_jpeg_exif(&ImageInfo, fd, 1) != TRUE) {
-		return NULL;
-	}
-	return ImageInfo.d;
-}
-
-void
-exif_free_data(struct exif_data *d)
-{
-	int i;
-	for (i=0; i<d->n_recs; i++) {
-		(*exif_free_fn)(d->recs[i].rec_name);
-		if (d->recs[i].rec_type == 's') {
-			(*exif_free_fn)(d->recs[i].rec_data.s);
-		}
-	}
-	(*exif_free_fn)(d);
-}
-
-void
-exif_init(void *(*malloc_fn)(int),
-		  void (*free_fn)(void *),
-		  void *(*realloc_fn)(void *, int))
-{
-	if (malloc_fn == NULL) {
-		malloc_fn = (void *(*)(int))malloc;
-	}
-	exif_malloc_fn = malloc_fn;
-	if (free_fn == NULL) {
-		free_fn = (void (*)(void *))free;
-	}
-	exif_free_fn = free_fn;
-	if (realloc_fn == NULL) {
-		realloc_fn = (void *(*)(void *, int))realloc;
-	}
-	exif_realloc_fn = realloc_fn;
-}
-
-extern exif_record_t *
-exif_find_record(exif_data_t *d, const char *rec_name)
-{
-	int i;
-	for (i=0; i<d->n_recs; i++) {
-		if (strcmp(d->recs[i].rec_name, rec_name) == 0) {
-			return &d->recs[i];
-		}
-	}
-	return NULL;
-}
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- */
-
-
diff --git a/src/libexif/exif.h b/src/libexif/exif.h
deleted file mode 100644
index 32f0a6d..0000000
--- a/src/libexif/exif.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-
-Copyright © 2000 Curtis Galloway
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-*/
-
-typedef struct exif_rational {
-  int      num;
-  unsigned denom;
-} exif_rational_t;
-
-typedef union {
-  long            l;
-  float           f;
-  double          g;
-  char *          s;
-  exif_rational_t r;
-} exif_rec_data_t;
-
-typedef struct exif_record {
-  char *           rec_name;
-  char             rec_type;
-  int              exif_format;
-  exif_rec_data_t  rec_data;
-} exif_record_t;
-
-typedef struct exif_data {
-  int           n_recs;
-  int           n_alloc;
-  exif_record_t recs[0];
-} exif_data_t;
-
-
-/* EXIF data formats */
-
-#define EXIF_FMT_COMPUTED  -1 /* Not in raw data */
-#define EXIF_FMT_BYTE       1 
-#define EXIF_FMT_STRING     2
-#define EXIF_FMT_USHORT     3
-#define EXIF_FMT_ULONG      4
-#define EXIF_FMT_URATIONAL  5
-#define EXIF_FMT_SBYTE      6
-#define EXIF_FMT_UNDEFINED  7
-#define EXIF_FMT_SSHORT     8
-#define EXIF_FMT_SLONG      9
-#define EXIF_FMT_SRATIONAL 10
-#define EXIF_FMT_SINGLE    11
-#define EXIF_FMT_DOUBLE    12
-
-extern void
-exif_init(void *(*malloc_fn)(int),
-	  void (*free_fn)(void *),
-	  void *(*realloc_fn)(void *, int));
-
-extern exif_data_t *
-exif_parse_fd(int fd);
-
-extern exif_data_t *
-exif_parse_file(const char *filename);
-
-extern void
-exif_free_data(exif_data_t *d);
-
-extern exif_record_t *
-exif_find_record(exif_data_t *d, const char *rec_name);
-
-
diff --git a/src/libexif/fuji/exif-mnote-data-fuji.c b/src/libexif/fuji/exif-mnote-data-fuji.c
new file mode 100644
index 0000000..b7b311b
--- /dev/null
+++ b/src/libexif/fuji/exif-mnote-data-fuji.c
@@ -0,0 +1,297 @@
+/* exif-mnote-data-fuji.c
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+
+#include <config.h>
+#include <libexif/exif-byte-order.h>
+#include <libexif/exif-utils.h>
+
+#include "exif-mnote-data-fuji.h"
+
+struct _MNoteFujiDataPrivate {
+	ExifByteOrder order;
+};
+
+static void
+exif_mnote_data_fuji_clear (ExifMnoteDataFuji *n)
+{
+	ExifMnoteData *d = (ExifMnoteData *) n;
+	unsigned int i;
+
+	if (!n) return;
+
+	if (n->entries) {
+		for (i = 0; i < n->count; i++)
+			if (n->entries[i].data) {
+				exif_mem_free (d->mem, n->entries[i].data);
+				n->entries[i].data = NULL;
+			}
+		exif_mem_free (d->mem, n->entries);
+		n->entries = NULL;
+		n->count = 0;
+	}
+}
+
+static void
+exif_mnote_data_fuji_free (ExifMnoteData *n)
+{
+	if (!n) return;
+
+	exif_mnote_data_fuji_clear ((ExifMnoteDataFuji *) n);
+}
+
+static char *
+exif_mnote_data_fuji_get_value (ExifMnoteData *d, unsigned int i, char *val, unsigned int maxlen)
+{
+	ExifMnoteDataFuji *n = (ExifMnoteDataFuji *) d;
+
+	if (!d || !val) return NULL;
+	if (i > n->count -1) return NULL;
+	exif_log (d->log, EXIF_LOG_CODE_DEBUG, "ExifMnoteDataFuji",
+		  "Querying value for tag '%s'...",
+		  mnote_fuji_tag_get_name (n->entries[i].tag));
+	return mnote_fuji_entry_get_value (&n->entries[i], val, maxlen);
+}
+
+static void
+exif_mnote_data_fuji_save (ExifMnoteData *ne, unsigned char **buf,
+			   unsigned int *buf_size)
+{
+	ExifMnoteDataFuji *n = (ExifMnoteDataFuji *) ne;
+	size_t i, o, s, doff;
+	unsigned char *t;
+	size_t ts;
+
+	if (!n || !buf || !buf_size) return;
+
+	/*
+	 * Allocate enough memory for all entries and the number
+	 * of entries.
+	 */
+	*buf_size = 8 + 4 + 2 + n->count * 12 + 4;
+	*buf = exif_mem_alloc (ne->mem, *buf_size);
+	if (!*buf) {
+		*buf_size = 0;
+		return;
+	}
+
+	/*
+	 * Header: "FUJIFILM" and 4 bytes offset to the first entry.
+	 * As the first entry will start right thereafter, the offset is 12.
+	 */
+	memcpy (*buf, "FUJIFILM", 8);
+	exif_set_long (*buf + 8, n->order, 12);
+
+	/* Save the number of entries */
+	exif_set_short (*buf + 8 + 4, n->order, (ExifShort) n->count);
+	
+	/* Save each entry */
+	for (i = 0; i < n->count; i++) {
+		o = 8 + 4 + 2 + i * 12;
+		exif_set_short (*buf + o + 0, n->order, (ExifShort) n->entries[i].tag);
+		exif_set_short (*buf + o + 2, n->order, (ExifShort) n->entries[i].format);
+		exif_set_long  (*buf + o + 4, n->order, n->entries[i].components);
+		o += 8;
+		s = exif_format_get_size (n->entries[i].format) *
+						n->entries[i].components;
+		if (s > 65536) {
+			/* Corrupt data: EXIF data size is limited to the
+			 * maximum size of a JPEG segment (64 kb).
+			 */
+			continue;
+		}
+		if (s > 4) {
+			ts = *buf_size + s;
+
+			/* Ensure even offsets. Set padding bytes to 0. */
+			if (s & 1) ts += 1;
+			t = exif_mem_realloc (ne->mem, *buf, ts);
+			if (!t) {
+				return;
+			}
+			*buf = t;
+			*buf_size = ts;
+			doff = *buf_size - s;
+			if (s & 1) { doff--; *(*buf + *buf_size - 1) = '\0'; }
+			exif_set_long (*buf + o, n->order, doff);
+		} else
+			doff = o;
+
+		/*
+		 * Write the data. Fill unneeded bytes with 0. Do not
+		 * crash if data is NULL.
+		 */
+		if (!n->entries[i].data) memset (*buf + doff, 0, s);
+		else memcpy (*buf + doff, n->entries[i].data, s);
+	}
+}
+
+static void
+exif_mnote_data_fuji_load (ExifMnoteData *en,
+	const unsigned char *buf, unsigned int buf_size)
+{
+	ExifMnoteDataFuji *n = (ExifMnoteDataFuji*) en;
+	ExifLong c;
+	size_t i, o, s, datao = 6 + n->offset;
+	MnoteFujiEntry *t;
+
+	if (!n || !buf || !buf_size || (buf_size < datao + 12)) return;
+
+	/* Read the number of entries and remove old ones. */
+	n->order = EXIF_BYTE_ORDER_INTEL;
+	datao += exif_get_long (buf + datao + 8, EXIF_BYTE_ORDER_INTEL);
+	c = exif_get_short (buf + datao, EXIF_BYTE_ORDER_INTEL);
+	datao += 2;
+	exif_mnote_data_fuji_clear (n);
+
+	/* Parse the entries */
+	for (i = 0; i < c; i++) {
+		o = datao + 12 * i;
+		if (datao + 12 > buf_size) return;
+
+		t = exif_mem_realloc (en->mem, n->entries,
+				sizeof (MnoteFujiEntry) * (i + 1));
+		if (!t) return;
+		n->count = i + 1;
+		n->entries = t;
+		memset (&n->entries[i], 0, sizeof (MnoteFujiEntry));
+		n->entries[i].tag        = exif_get_short (buf + o, n->order);
+		n->entries[i].format     = exif_get_short (buf + o + 2, n->order);
+		n->entries[i].components = exif_get_long (buf + o + 4, n->order);
+		n->entries[i].order      = n->order;
+
+		/*
+		 * Size? If bigger than 4 bytes, the actual data is not
+		 * in the entry but somewhere else (offset).
+		 */
+		s = exif_format_get_size (n->entries[i].format) * n->entries[i].components;
+		if (!s) return;
+		o += 8;
+		if (s > 4) o = exif_get_long (buf + o, n->order) + 6 + n->offset;
+		if (o + s > buf_size) return;
+
+		/* Sanity check */
+		n->entries[i].data = exif_mem_alloc (en->mem, s);
+		if (!n->entries[i].data) return;
+		n->entries[i].size = s;
+		memcpy (n->entries[i].data, buf + o, s);
+	}
+}
+
+static unsigned int
+exif_mnote_data_fuji_count (ExifMnoteData *n)
+{
+	return n ? ((ExifMnoteDataFuji *) n)->count : 0;
+}
+
+static unsigned int
+exif_mnote_data_fuji_get_id (ExifMnoteData *d, unsigned int n)
+{
+	ExifMnoteDataFuji *note = (ExifMnoteDataFuji *) d;
+
+	if (!note) return 0;
+	if (note->count <= n) return 0;
+	return note->entries[n].tag;
+}
+
+static const char *
+exif_mnote_data_fuji_get_name (ExifMnoteData *d, unsigned int i)
+{
+	ExifMnoteDataFuji *n = (ExifMnoteDataFuji *) d;
+
+	if (!n) return NULL;
+	if (i >= n->count) return NULL;
+	return mnote_fuji_tag_get_name (n->entries[i].tag);
+}
+
+static const char *
+exif_mnote_data_fuji_get_title (ExifMnoteData *d, unsigned int i)
+{
+	ExifMnoteDataFuji *n = (ExifMnoteDataFuji *) d;
+	
+	if (!n) return NULL;
+	if (i >= n->count) return NULL;
+        return mnote_fuji_tag_get_title (n->entries[i].tag);
+}
+
+static const char *
+exif_mnote_data_fuji_get_description (ExifMnoteData *d, unsigned int i)
+{
+	ExifMnoteDataFuji *n = (ExifMnoteDataFuji *) d;
+	
+	if (!n) return NULL;
+	if (i >= n->count) return NULL;
+        return mnote_fuji_tag_get_description (n->entries[i].tag);
+}
+
+static void
+exif_mnote_data_fuji_set_byte_order (ExifMnoteData *d, ExifByteOrder o)
+{
+	ExifByteOrder o_orig;
+	ExifMnoteDataFuji *n = (ExifMnoteDataFuji *) d;
+	unsigned int i;
+
+	if (!n) return;
+
+	o_orig = n->order;
+	n->order = o;
+	for (i = 0; i < n->count; i++) {
+		n->entries[i].order = o;
+		exif_array_set_byte_order (n->entries[i].format, n->entries[i].data,
+				n->entries[i].components, o_orig, o);
+	}
+}
+
+static void
+exif_mnote_data_fuji_set_offset (ExifMnoteData *n, unsigned int o)
+{
+	if (n) ((ExifMnoteDataFuji *) n)->offset = o;
+}
+
+ExifMnoteData *
+exif_mnote_data_fuji_new (ExifMem *mem)
+{
+	ExifMnoteData *d;
+
+	if (!mem) return NULL;
+
+	d = exif_mem_alloc (mem, sizeof (ExifMnoteDataFuji));
+	if (!d) return NULL;
+
+	exif_mnote_data_construct (d, mem);
+
+	/* Set up function pointers */
+	d->methods.free            = exif_mnote_data_fuji_free;
+	d->methods.set_byte_order  = exif_mnote_data_fuji_set_byte_order;
+	d->methods.set_offset      = exif_mnote_data_fuji_set_offset;
+	d->methods.load            = exif_mnote_data_fuji_load;
+	d->methods.save            = exif_mnote_data_fuji_save;
+	d->methods.count           = exif_mnote_data_fuji_count;
+	d->methods.get_id          = exif_mnote_data_fuji_get_id;
+	d->methods.get_name        = exif_mnote_data_fuji_get_name;
+	d->methods.get_title       = exif_mnote_data_fuji_get_title;
+	d->methods.get_description = exif_mnote_data_fuji_get_description;
+	d->methods.get_value       = exif_mnote_data_fuji_get_value;
+
+	return d;
+}
diff --git a/src/libexif/fuji/exif-mnote-data-fuji.h b/src/libexif/fuji/exif-mnote-data-fuji.h
new file mode 100644
index 0000000..298193a
--- /dev/null
+++ b/src/libexif/fuji/exif-mnote-data-fuji.h
@@ -0,0 +1,43 @@
+/* exif-mnote-data-fuji.h
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __MNOTE_FUJI_CONTENT_H__
+#define __MNOTE_FUJI_CONTENT_H__
+
+#include <libexif/exif-mnote-data.h>
+
+typedef struct _ExifMnoteDataFuji        ExifMnoteDataFuji;
+
+#include <libexif/exif-mnote-data-priv.h>
+#include <libexif/fuji/mnote-fuji-entry.h>
+
+struct _ExifMnoteDataFuji {
+	ExifMnoteData parent;
+
+	MnoteFujiEntry *entries;
+	unsigned int count;
+
+	ExifByteOrder order;
+	unsigned int offset;
+};
+
+ExifMnoteData *exif_mnote_data_fuji_new (ExifMem *);
+
+#endif /* __MNOTE_FUJI_CONTENT_H__ */
diff --git a/src/libexif/fuji/mnote-fuji-entry.c b/src/libexif/fuji/mnote-fuji-entry.c
new file mode 100644
index 0000000..ea978ac
--- /dev/null
+++ b/src/libexif/fuji/mnote-fuji-entry.c
@@ -0,0 +1,306 @@
+/* mnote-fuji-entry.c
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <config.h>
+
+#include <libexif/i18n.h>
+
+#include "mnote-fuji-entry.h"
+
+#define CF(format,target,v,maxlen)                              \
+{                                                               \
+        if (format != target) {                                 \
+                snprintf (v, maxlen,	                        \
+                        _("Invalid format '%s', "               \
+                        "expected '%s'."),                      \
+                        exif_format_get_name (format),          \
+                        exif_format_get_name (target));         \
+                break;                                          \
+        }                                                       \
+}
+
+#define CC(number,target,v,maxlen)                                      \
+{                                                                       \
+        if (number != target) {                                         \
+                snprintf (v, maxlen,                                    \
+                        _("Invalid number of components (%i, "          \
+                        "expected %i)."), (int) number, (int) target);  \
+                break;                                                  \
+        }                                                               \
+}
+
+static const struct {
+	ExifTag tag;
+	struct {
+		int index;
+		const char *string;
+	} elem[22];
+} items[] = {
+#ifndef NO_VERBOSE_TAG_DATA
+  { MNOTE_FUJI_TAG_SHARPNESS,
+    { {1, N_("Softest")},
+      {2, N_("Soft")},
+      {3, N_("Normal")},
+      {4, N_("Hard")},
+      {5, N_("Hardest")},
+      {0x0082, N_("Medium soft")},
+      {0x0084, N_("Medium hard")},
+      {0x8000, N_("Film simulation mode")},
+      {0xFFFF, N_("Off")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_WHITE_BALANCE,
+    { {0, N_("Auto")},
+      {0x100, N_("Daylight")},
+      {0x200, N_("Cloudy")},
+      {0x300, N_("Daylight-color fluorescent")},
+      {0x301, N_("DayWhite-color fluorescent")},
+      {0x302, N_("White fluorescent")},
+      {0x400, N_("Incandescent")},
+      {0x500, N_("Flash")},
+      {0xF00, N_("Custom")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_COLOR,
+    { {0, N_("Standard")},
+      {0x0080, N_("Medium high")},
+      {0x0100, N_("High")},
+      {0x0180, N_("Medium low")},
+      {0x0200, N_("Original")},
+      {0x0300, N_("Black & white")},
+      {0x8000, N_("Film simulation mode")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_TONE,
+    { {0, N_("Standard")},
+      {0x0080, N_("Medium hard")},
+      {0x0100, N_("Hard")},
+      {0x0180, N_("Medium soft")},
+      {0x0200, N_("Original")},
+      {0x8000, N_("Film simulation mode")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_FLASH_MODE,
+    { {0, N_("Auto")},
+      {1, N_("On")},
+      {2, N_("Off")},
+      {3, N_("Red-eye reduction")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_MACRO,
+    { {0, N_("Off")},
+      {1, N_("On")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_FOCUS_MODE,
+    { {0, N_("Auto")},
+      {1, N_("Manual")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_SLOW_SYNC,
+    { {0, N_("Off")},
+      {1, N_("On")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_PICTURE_MODE,
+    { {0, N_("Auto")},
+      {1, N_("Portrait")},
+      {2, N_("Landscape")},
+      {4, N_("Sports")},
+      {5, N_("Night")},
+      {6, N_("Program AE")},
+      {7, N_("Natural photo")},
+      {8, N_("Vibration reduction")},
+      {0x000A, N_("Sunset")},
+      {0x000B, N_("Museum")},
+      {0x000C, N_("Party")},
+      {0x000D, N_("Flower")},
+      {0x000E, N_("Text")},
+      {0x000F, N_("NP & flash")},
+      {0x0010, N_("Beach")},
+      {0x0011, N_("Snow")},
+      {0x0012, N_("Fireworks")},
+      {0x0013, N_("Underwater")},
+      {0x0100, N_("Aperture priority AE")},
+      {0x0200, N_("Shutter priority AE")},
+      {0x0300, N_("Manual exposure")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_CONT_TAKING,
+    { {0, N_("Off")},
+      {1, N_("On")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_FINEPIX_COLOR,
+    { {0x00, N_("F-Standard")},
+      {0x10, N_("F-Chrome")},
+      {0x30, N_("F-B&W")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_BLUR_CHECK,
+    { {0, N_("No blur")},
+      {1, N_("Blur warning")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_FOCUS_CHECK,
+    { {0, N_("Focus good")},
+      {1, N_("Out of focus")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_AUTO_EXPOSURE_CHECK,
+    { {0, N_("AE good")},
+      {1, N_("Over exposed")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_DYNAMIC_RANGE,
+    { {1, N_("Standard")},
+      {3, N_("Wide")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_FILM_MODE,
+    { {0, N_("F0/Standard")},
+      {0x0100, N_("F1/Studio portrait")},
+      {0x0110, N_("F1a/Professional portrait")},
+      {0x0120, N_("F1b/Professional portrait")},
+      {0x0130, N_("F1c/Professional portrait")},
+      {0x0200, N_("F2/Fujichrome")},
+      {0x0300, N_("F3/Studio portrait Ex")},
+      {0x0400, N_("F4/Velvia")},
+      {0, NULL}}},
+  { MNOTE_FUJI_TAG_DYNAMIC_RANGE_SETTING,
+    { {0, N_("Auto (100-400%)")},
+      {1, N_("RAW")},
+      {0x0100, N_("Standard (100%)")},
+      {0x0200, N_("Wide1 (230%)")},
+      {0x0201, N_("Wide2 (400%)")},
+      {0x8000, N_("Film simulation mode")},
+      {0, NULL}}},
+#endif
+  {0, {{0, NULL}}}
+};
+
+
+char *
+mnote_fuji_entry_get_value (MnoteFujiEntry *entry,
+			      char *val, unsigned int maxlen)
+{
+	ExifLong  vl;
+	ExifSLong vsl;
+	ExifShort vs, vs2;
+	ExifRational vr;
+	ExifSRational vsr;
+	int i, j;
+
+	if (!entry) return (NULL);
+
+	memset (val, 0, maxlen);
+	maxlen--;
+
+	switch (entry->tag) {
+	  case MNOTE_FUJI_TAG_VERSION:
+		CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
+		CC (entry->components, 4, val, maxlen);
+		memcpy (val, entry->data, MIN(maxlen, entry->size));
+		break;
+	  case MNOTE_FUJI_TAG_SHARPNESS:
+	  case MNOTE_FUJI_TAG_WHITE_BALANCE:
+	  case MNOTE_FUJI_TAG_COLOR:
+  	  case MNOTE_FUJI_TAG_TONE:
+	  case MNOTE_FUJI_TAG_FLASH_MODE:
+	  case MNOTE_FUJI_TAG_MACRO:
+	  case MNOTE_FUJI_TAG_FOCUS_MODE:
+	  case MNOTE_FUJI_TAG_SLOW_SYNC:
+	  case MNOTE_FUJI_TAG_PICTURE_MODE:
+	  case MNOTE_FUJI_TAG_CONT_TAKING:
+	  case MNOTE_FUJI_TAG_FINEPIX_COLOR:
+	  case MNOTE_FUJI_TAG_BLUR_CHECK:
+	  case MNOTE_FUJI_TAG_FOCUS_CHECK:
+	  case MNOTE_FUJI_TAG_AUTO_EXPOSURE_CHECK:
+	  case MNOTE_FUJI_TAG_DYNAMIC_RANGE:
+	  case MNOTE_FUJI_TAG_FILM_MODE:
+	  case MNOTE_FUJI_TAG_DYNAMIC_RANGE_SETTING:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+		CC (entry->components, 1, val, maxlen);
+		vs = exif_get_short (entry->data, entry->order);
+
+		/* search the tag */
+		for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++);
+		if (!items[i].tag) {
+			snprintf (val, maxlen,
+				  _("Internal error (unknown value %i)"), vs);
+		  	break;
+		}
+
+		/* find the value */
+		for (j = 0; items[i].elem[j].string &&
+		    (items[i].elem[j].index < vs); j++);
+		if (items[i].elem[j].index != vs) {
+			snprintf (val, maxlen,
+				  _("Internal error (unknown value %i)"), vs);
+			break;
+		}
+		strncpy (val, _(items[i].elem[j].string), maxlen);
+		break;
+	  case MNOTE_FUJI_TAG_FOCUS_POINT:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+		CC (entry->components, 2, val, maxlen);
+		vs = exif_get_short (entry->data, entry->order);
+		vs2 = exif_get_short (entry->data+2, entry->order);
+		snprintf (val, maxlen, "%i, %i", vs, vs2);
+		break;
+	  case MNOTE_FUJI_TAG_MIN_FOCAL_LENGTH:
+	  case MNOTE_FUJI_TAG_MAX_FOCAL_LENGTH:
+		CF (entry->format, EXIF_FORMAT_RATIONAL, val, maxlen);
+		CC (entry->components, 1, val, maxlen);
+		vr = exif_get_rational (entry->data, entry->order);
+		if (!vr.denominator) break;
+		snprintf (val, maxlen, _("%2.2f mm"), (double) vr.numerator /
+			  vr.denominator);
+		break;
+
+	default:
+		switch (entry->format) {
+		case EXIF_FORMAT_ASCII:
+		  strncpy (val, (char *)entry->data, MIN(maxlen, entry->size));
+		  break;
+		case EXIF_FORMAT_SHORT:
+		  vs = exif_get_short (entry->data, entry->order);
+		  snprintf (val, maxlen, "%i", vs);
+		  break;
+		case EXIF_FORMAT_LONG:
+		  vl = exif_get_long (entry->data, entry->order);
+		  snprintf (val, maxlen, "%lu", (long unsigned) vl);
+		  break;
+		case EXIF_FORMAT_SLONG:
+		  vsl = exif_get_slong (entry->data, entry->order);
+		  snprintf (val, maxlen, "%li", (long int) vsl);
+		  break;
+		case EXIF_FORMAT_RATIONAL:
+		  vr = exif_get_rational (entry->data, entry->order);
+		  if (!vr.denominator) break;
+		  snprintf (val, maxlen, "%2.4f", (double) vr.numerator /
+						    vr.denominator);
+		  break;
+		case EXIF_FORMAT_SRATIONAL:
+		  vsr = exif_get_srational (entry->data, entry->order);
+		  if (!vsr.denominator) break;
+		  snprintf (val, maxlen, "%2.4f", (double) vsr.numerator /
+			  vsr.denominator);
+		  break;
+		case EXIF_FORMAT_UNDEFINED:
+		default:
+		  snprintf (val, maxlen, _("%i bytes unknown data"),
+ 			  entry->size);
+		  break;
+		}
+		break;
+	}
+
+	return (val);
+}
diff --git a/src/libexif/fuji/mnote-fuji-entry.h b/src/libexif/fuji/mnote-fuji-entry.h
new file mode 100644
index 0000000..322d2d2
--- /dev/null
+++ b/src/libexif/fuji/mnote-fuji-entry.h
@@ -0,0 +1,45 @@
+/* mnote-fuji-entry.h
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __MNOTE_FUJI_ENTRY_H__
+#define __MNOTE_FUJI_ENTRY_H__
+
+#include <libexif/exif-format.h>
+#include <libexif/fuji/mnote-fuji-tag.h>
+
+typedef struct _MnoteFujiEntry        MnoteFujiEntry;
+typedef struct _MnoteFujiEntryPrivate MnoteFujiEntryPrivate;
+
+#include <libexif/fuji/exif-mnote-data-fuji.h>
+
+struct _MnoteFujiEntry {
+	MnoteFujiTag tag;
+	ExifFormat format;
+	unsigned long components;
+
+	unsigned char *data;
+	unsigned int size;
+
+	ExifByteOrder order;
+};
+
+char *mnote_fuji_entry_get_value (MnoteFujiEntry *entry, char *val, unsigned int maxlen);
+
+#endif /* __MNOTE_FUJI_ENTRY_H__ */
diff --git a/src/libexif/fuji/mnote-fuji-tag.c b/src/libexif/fuji/mnote-fuji-tag.c
new file mode 100644
index 0000000..bff33d8
--- /dev/null
+++ b/src/libexif/fuji/mnote-fuji-tag.c
@@ -0,0 +1,105 @@
+/* mnote-fuji-tag.c
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+
+#include <config.h>
+#include <libexif/i18n.h>
+
+#include "mnote-fuji-tag.h"
+
+
+static struct {
+	MnoteFujiTag tag;
+	const char *name;
+	const char *title;
+	const char *description;
+} table[] = {
+#ifndef NO_VERBOSE_TAG_STRINGS
+	{MNOTE_FUJI_TAG_VERSION, "Version", N_("Maker Note Version"), ""},
+	{MNOTE_FUJI_TAG_SERIAL_NUMBER, "SerialNumber", N_("Serial Number"), N_("This number is unique, it contains the date of manufacture.")},
+	{MNOTE_FUJI_TAG_QUALITY, "Quality", N_("Quality"), ""},
+	{MNOTE_FUJI_TAG_SHARPNESS, "Sharpness", N_("Sharpness"), ""},
+	{MNOTE_FUJI_TAG_WHITE_BALANCE, "WhiteBalance", N_("White Balance"), ""},
+	{MNOTE_FUJI_TAG_COLOR, "ChromaticitySaturation", N_("Chromaticity Saturation"), ""},
+	{MNOTE_FUJI_TAG_TONE, "Contrast", N_("Contrast"), ""},
+	{MNOTE_FUJI_TAG_FLASH_MODE, "FlashMode", N_("Flash Mode"), ""},
+	{MNOTE_FUJI_TAG_FLASH_STRENGTH, "FlashStrength", N_("Flash Firing Strength Compensation"), ""},
+	{MNOTE_FUJI_TAG_MACRO, "MacroMode", N_("Macro mode"), ""},
+	{MNOTE_FUJI_TAG_FOCUS_MODE, "FocusingMode", N_("Focusing Mode"), ""},
+	{MNOTE_FUJI_TAG_FOCUS_POINT, "FocusPoint", N_("Focus Point"), ""},
+	{MNOTE_FUJI_TAG_SLOW_SYNC, "SlowSynchro", N_("Slow Synchro Mode"), ""},
+	{MNOTE_FUJI_TAG_PICTURE_MODE, "PictureMode", N_("Picture Mode"), ""},
+	{MNOTE_FUJI_TAG_CONT_TAKING, "ContinuousTaking", N_("Continuous Taking"), ""},
+	{MNOTE_FUJI_TAG_SEQUENCE_NUMBER, "ContinuousSequence", N_("Continuous Sequence Number"), ""},
+	{MNOTE_FUJI_TAG_FINEPIX_COLOR, "FinePixColor", N_("FinePix Color"), ""},
+	{MNOTE_FUJI_TAG_BLUR_CHECK, "BlurCheck", N_("Blur Check"), ""},
+	{MNOTE_FUJI_TAG_FOCUS_CHECK, "AutoFocusCheck", N_("Auto Focus Check"), ""},
+	{MNOTE_FUJI_TAG_AUTO_EXPOSURE_CHECK, "AutoExposureCheck", N_("Auto Exposure Check"), ""},
+	{MNOTE_FUJI_TAG_DYNAMIC_RANGE, "DynamicRange", N_("Dynamic Range"), ""},
+	{MNOTE_FUJI_TAG_FILM_MODE, "FilmMode", N_("Film simulation Mode"), ""},
+	{MNOTE_FUJI_TAG_DYNAMIC_RANGE_SETTING, "DRangeMode", N_("Dynamic Range Wide Mode"), ""},
+	{MNOTE_FUJI_TAG_DEV_DYNAMIC_RANGE_SETTING, "DevDRangeMode", N_("Development Dynamic Range Wide Mode"), ""},
+	{MNOTE_FUJI_TAG_MIN_FOCAL_LENGTH, "MinFocalLen", N_("Minimum Focal Length"), ""},
+	{MNOTE_FUJI_TAG_MAX_FOCAL_LENGTH, "MaxFocalLen", N_("Maximum Focal Length"), ""},
+	{MNOTE_FUJI_TAG_MAX_APERT_AT_MIN_FOC, "MaxApertAtMinFoc", N_("Maximum Aperture at Minimum Focal"), ""},
+	{MNOTE_FUJI_TAG_MAX_APERT_AT_MAX_FOC, "MaxApertAtMaxFoc", N_("Maximum Aperture at Maximum Focal"), ""},
+	{MNOTE_FUJI_TAG_FILE_SOURCE, "FileSource", N_("File Source"), ""},
+	{MNOTE_FUJI_TAG_ORDER_NUMBER, "OrderNumber", N_("Order Number"), ""},
+	{MNOTE_FUJI_TAG_FRAME_NUMBER, "FrameNumber", N_("Frame Number"), ""},
+#endif
+	{0, NULL, NULL, NULL}
+};
+
+const char *
+mnote_fuji_tag_get_name (MnoteFujiTag t)
+{
+	unsigned int i;
+
+	for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
+		if (table[i].tag == t) return (table[i].name);
+	return NULL;
+}
+
+const char *
+mnote_fuji_tag_get_title (MnoteFujiTag t)
+{
+	unsigned int i;
+
+	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+	for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
+		if (table[i].tag == t) return (_(table[i].title));
+	return NULL;
+}
+
+const char *
+mnote_fuji_tag_get_description (MnoteFujiTag t)
+{
+	unsigned int i;
+
+	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+	for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
+		if (table[i].tag == t) {
+			if (!*table[i].description)
+				return "";
+			return (_(table[i].description));
+		}
+	return NULL;
+}
diff --git a/src/libexif/fuji/mnote-fuji-tag.h b/src/libexif/fuji/mnote-fuji-tag.h
new file mode 100644
index 0000000..7ddde34
--- /dev/null
+++ b/src/libexif/fuji/mnote-fuji-tag.h
@@ -0,0 +1,92 @@
+/* mnote-fuji-tag.h
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __MNOTE_FUJI_TAG_H__
+#define __MNOTE_FUJI_TAG_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <libexif/exif-data.h>
+
+enum _MnoteFujiTag {
+	MNOTE_FUJI_TAG_VERSION                  = 0x0000,
+	MNOTE_FUJI_TAG_SERIAL_NUMBER            = 0x0010,
+	MNOTE_FUJI_TAG_QUALITY                  = 0x1000,
+	MNOTE_FUJI_TAG_SHARPNESS                = 0x1001,
+	MNOTE_FUJI_TAG_WHITE_BALANCE            = 0x1002,
+	MNOTE_FUJI_TAG_COLOR                    = 0x1003,
+	MNOTE_FUJI_TAG_TONE                     = 0x1004,
+	MNOTE_FUJI_TAG_UNKNOWN_1006             = 0x1006,
+	MNOTE_FUJI_TAG_UNKNOWN_1007             = 0x1007,
+	MNOTE_FUJI_TAG_UNKNOWN_1008             = 0x1008,
+	MNOTE_FUJI_TAG_UNKNOWN_1009             = 0x1009,
+	MNOTE_FUJI_TAG_UNKNOWN_100A             = 0x100A,
+	MNOTE_FUJI_TAG_UNKNOWN_100B             = 0x100B,
+	MNOTE_FUJI_TAG_FLASH_MODE               = 0x1010,
+	MNOTE_FUJI_TAG_FLASH_STRENGTH           = 0x1011,
+	MNOTE_FUJI_TAG_MACRO                    = 0x1020,
+	MNOTE_FUJI_TAG_FOCUS_MODE               = 0x1021,
+	MNOTE_FUJI_TAG_UNKNOWN_1022             = 0x1022,
+	MNOTE_FUJI_TAG_FOCUS_POINT              = 0x1023,
+	MNOTE_FUJI_TAG_UNKNOWN_1024             = 0x1024,
+	MNOTE_FUJI_TAG_UNKNOWN_1025             = 0x1025,
+	MNOTE_FUJI_TAG_SLOW_SYNC                = 0x1030,
+	MNOTE_FUJI_TAG_PICTURE_MODE             = 0x1031,
+	MNOTE_FUJI_TAG_UNKNOWN_1032             = 0x1032,
+	MNOTE_FUJI_TAG_CONT_TAKING              = 0x1100,
+	MNOTE_FUJI_TAG_SEQUENCE_NUMBER          = 0x1101,
+	MNOTE_FUJI_TAG_UNKNOWN_1200             = 0x1200,
+	MNOTE_FUJI_TAG_FINEPIX_COLOR            = 0x1210,
+	MNOTE_FUJI_TAG_BLUR_CHECK               = 0x1300,
+	MNOTE_FUJI_TAG_FOCUS_CHECK              = 0x1301,
+	MNOTE_FUJI_TAG_AUTO_EXPOSURE_CHECK      = 0x1302,
+	MNOTE_FUJI_TAG_UNKNOWN_1303             = 0x1303,
+	MNOTE_FUJI_TAG_DYNAMIC_RANGE            = 0x1400,
+	MNOTE_FUJI_TAG_FILM_MODE                = 0x1401,
+	MNOTE_FUJI_TAG_DYNAMIC_RANGE_SETTING    = 0x1402,
+	MNOTE_FUJI_TAG_DEV_DYNAMIC_RANGE_SETTING= 0x1403,
+	MNOTE_FUJI_TAG_MIN_FOCAL_LENGTH         = 0x1404,
+	MNOTE_FUJI_TAG_MAX_FOCAL_LENGTH         = 0x1405,
+	MNOTE_FUJI_TAG_MAX_APERT_AT_MIN_FOC     = 0x1406,
+	MNOTE_FUJI_TAG_MAX_APERT_AT_MAX_FOC     = 0x1407,
+	MNOTE_FUJI_TAG_UNKNOWN_1408             = 0x1408,
+	MNOTE_FUJI_TAG_UNKNOWN_1409             = 0x1409,
+	MNOTE_FUJI_TAG_UNKNOWN_140A             = 0x140A,
+	MNOTE_FUJI_TAG_UNKNOWN_1410             = 0x1410,
+	MNOTE_FUJI_TAG_UNKNOWN_1421             = 0x1421,
+	MNOTE_FUJI_TAG_UNKNOWN_4100             = 0x4100,
+	MNOTE_FUJI_TAG_UNKNOWN_4800             = 0x4800,
+	MNOTE_FUJI_TAG_FILE_SOURCE              = 0x8000,
+	MNOTE_FUJI_TAG_ORDER_NUMBER             = 0x8002,
+	MNOTE_FUJI_TAG_FRAME_NUMBER             = 0x8003
+};
+typedef enum _MnoteFujiTag MnoteFujiTag;
+
+const char *mnote_fuji_tag_get_name        (MnoteFujiTag tag);
+const char *mnote_fuji_tag_get_title       (MnoteFujiTag tag);
+const char *mnote_fuji_tag_get_description (MnoteFujiTag tag);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MNOTE_FUJI_TAG_H__ */
diff --git a/src/libexif/i18n.h b/src/libexif/i18n.h
index 6d08e3c..289435c 100644
--- a/src/libexif/i18n.h
+++ b/src/libexif/i18n.h
@@ -35,6 +35,7 @@
 #else
 #  define textdomain(String) (String)
 #  define gettext(String) (String)
+#  define ngettext(String1,String2,Count) (Count==1?String1:String2)
 #  define dgettext(Domain,Message) (Message)
 #  define dcgettext(Domain,Message,Type) (Message)
 #ifdef __WATCOMC__
diff --git a/src/libexif/olympus/exif-mnote-data-olympus.c b/src/libexif/olympus/exif-mnote-data-olympus.c
index 02794c5..200a276 100644
--- a/src/libexif/olympus/exif-mnote-data-olympus.c
+++ b/src/libexif/olympus/exif-mnote-data-olympus.c
@@ -1,6 +1,6 @@
 /* exif-mnote-data-olympus.c
  *
- * Copyright © 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -71,13 +71,25 @@ exif_mnote_data_olympus_get_value (ExifMnoteData *d, unsigned int i, char *val,
 	return mnote_olympus_entry_get_value (&n->entries[i], val, maxlen);
 }
 
+
+
+
+/** 
+ * @brief save the MnoteData from ne to buf
+ * 
+ * @param ne extract the data from this structure 
+ * @param *buf write the mnoteData to this buffer (buffer will be allocated)
+ * @param buf_size the size of the buffer
+ */
 static void
 exif_mnote_data_olympus_save (ExifMnoteData *ne,
 		unsigned char **buf, unsigned int *buf_size)
 {
 	ExifMnoteDataOlympus *n = (ExifMnoteDataOlympus *) ne;
-	unsigned int i, o, s, doff, base = 0, o2 = 6;
-	int datao = 0;
+	size_t i, o, s, doff, base = 0, o2 = 6 + 2;
+	size_t datao = 0;
+	unsigned char *t;
+	size_t ts;
 
 	if (!n || !buf || !buf_size) return;
 
@@ -86,29 +98,49 @@ exif_mnote_data_olympus_save (ExifMnoteData *ne,
 	 */
 	*buf_size = 6 + 2 + 2 + n->count * 12;
 	switch (n->version) {
-	case 0: /* Olympus */
+	case olympusV1:
+	case sanyoV1:
 		*buf = exif_mem_alloc (ne->mem, *buf_size);
 		if (!*buf) return;
 
 		/* Write the header and the number of entries. */
-		strcpy (*buf, "OLYMP");
-		o2 += 2;
+		strcpy ((char *)*buf, n->version==sanyoV1?"SANYO":"OLYMP");
+		exif_set_short (*buf + 6, n->order, (ExifShort) 1);
 		datao = n->offset;
 		break;
-	case 1: /* Nikon v1 */
+	case olympusV2:
+		*buf_size += 8-6 + 4;
+		*buf = exif_mem_alloc (ne->mem, *buf_size);
+		if (!*buf) return;
+
+		/* Write the header and the number of entries. */
+		strcpy ((char *)*buf, "OLYMPUS");
+		exif_set_short (*buf + 8, n->order, (ExifShort) (
+			(n->order == EXIF_BYTE_ORDER_INTEL) ?
+			('I' << 8) | 'I' :
+			('M' << 8) | 'M'));
+		exif_set_short (*buf + 10, n->order, (ExifShort) 3);
+		o2 += 4;
+		break;
+	case nikonV1: 
 		base = MNOTE_NIKON1_TAG_BASE;
-		*buf_size -= 8;
+
+		/* v1 has offsets based to main IFD, not makernote IFD */
+		datao += n->offset + 10;
+		/* subtract the size here, so the increment in the next case will not harm us */
+		*buf_size -= 8 + 2;
 		/* Fall through */
-	case 2: /* Nikon v2 */
-		*buf_size += 8;
+	case nikonV2: 
+		*buf_size += 8 + 2;
+		*buf_size += 4; /* Next IFD pointer */
 		*buf = exif_mem_alloc (ne->mem, *buf_size);
 		if (!*buf) return;
 
 		/* Write the header and the number of entries. */
-		strcpy (*buf, "Nikon");
+		strcpy ((char *)*buf, "Nikon");
 		(*buf)[6] = n->version;
-		o2 += 2; *buf_size += 2;
-		if (n->version == 2) {
+
+		if (n->version == nikonV2) {
 			exif_set_short (*buf + 10, n->order, (ExifShort) (
 				(n->order == EXIF_BYTE_ORDER_INTEL) ?
 				('I' << 8) | 'I' :
@@ -117,8 +149,13 @@ exif_mnote_data_olympus_save (ExifMnoteData *ne,
 			exif_set_long (*buf + 14, n->order, (ExifShort) 8);
 			o2 += 2 + 8;
 		}
-		datao = -10;
+		datao -= 10;
+		/* Reset next IFD pointer */
+		exif_set_long (*buf + o2 + 2 + n->count * 12, n->order, 0);
 		break;
+
+	default:
+		return;
 	}
 
 	exif_set_short (*buf + o2, n->order, (ExifShort) n->count);
@@ -136,12 +173,20 @@ exif_mnote_data_olympus_save (ExifMnoteData *ne,
 		o += 8;
 		s = exif_format_get_size (n->entries[i].format) *
 						n->entries[i].components;
+		if (s > 65536) {
+			/* Corrupt data: EXIF data size is limited to the
+			 * maximum size of a JPEG segment (64 kb).
+			 */
+			continue;
+		}
 		if (s > 4) {
 			doff = *buf_size;
-			*buf_size += s;
-			*buf = exif_mem_realloc (ne->mem, *buf,
-						 sizeof (char) * *buf_size);
-			if (!*buf) return;
+			ts = *buf_size + s;
+			t = exif_mem_realloc (ne->mem, *buf,
+						 sizeof (char) * ts);
+			if (!t) return;
+			*buf = t;
+			*buf_size = ts;
 			exif_set_long (*buf + o, n->order, datao + doff);
 		} else
 			doff = o;
@@ -162,7 +207,7 @@ exif_mnote_data_olympus_load (ExifMnoteData *en,
 {
 	ExifMnoteDataOlympus *n = (ExifMnoteDataOlympus *) en;
 	ExifShort c;
-	unsigned int i, s, o, o2 = 0, datao = 6, base = 0;
+	size_t i, s, o, o2 = 0, datao = 6, base = 0;
 
 	if (!n || !buf) return;
 
@@ -174,6 +219,9 @@ exif_mnote_data_olympus_load (ExifMnoteData *en,
 	 * a size of 22 bytes (6 for 'OLYMP', 2 other bytes, 2 for the
 	 * number of entries, and 12 for one entry.
 	 *
+	 * Sanyo format is identical and uses identical tags except that
+	 * header starts with "SANYO".
+	 *
 	 * Nikon headers start with "Nikon" (6 bytes including '\0'), 
 	 * version number (1 or 2).
 	 * 
@@ -185,13 +233,46 @@ exif_mnote_data_olympus_load (ExifMnoteData *en,
 	 * lastly 0x2A.
 	 */
 	if (buf_size - n->offset < 22) return;
-	if (!memcmp (buf + o2, "OLYMP", 5)) {
+	if (!memcmp (buf + o2, "OLYMP", 6) || !memcmp (buf + o2, "SANYO", 6)) {
 		exif_log (en->log, EXIF_LOG_CODE_DEBUG, "ExifMnoteDataOlympus",
-			"Parsing Olympus maker note...");
+			"Parsing Olympus/Sanyo maker note v1...");
 
 		/* The number of entries is at position 8. */
-		n->version = 0;
+		if (!memcmp (buf + o2, "SANYO", 6))
+			n->version = sanyoV1;
+		else
+			n->version = olympusV1;
+		if (buf[o2 + 6] == 1)
+			n->order = EXIF_BYTE_ORDER_INTEL;
+		else if (buf[o2 + 6 + 1] == 1)
+			n->order = EXIF_BYTE_ORDER_MOTOROLA;
 		o2 += 8;
+		if (o2 >= buf_size) return;
+		c = exif_get_short (buf + o2, n->order);
+		if ((!(c & 0xFF)) && (c > 0x500)) {
+			if (n->order == EXIF_BYTE_ORDER_INTEL) {
+				n->order = EXIF_BYTE_ORDER_MOTOROLA;
+			} else {
+				n->order = EXIF_BYTE_ORDER_INTEL;
+			}
+		}
+
+	} else if (!memcmp (buf + o2, "OLYMPUS", 8)) {
+		/* Olympus S760, S770 */
+		datao = o2;
+		o2 += 8;
+		exif_log (en->log, EXIF_LOG_CODE_DEBUG, "ExifMnoteDataOlympus",
+			"Parsing Olympus maker note v2 (0x%02x, %02x, %02x, %02x)...",
+			buf[o2], buf[o2 + 1], buf[o2 + 2], buf[o2 + 3]);
+
+		if ((buf[o2] == 'I') && (buf[o2 + 1] == 'I'))
+			n->order = EXIF_BYTE_ORDER_INTEL;
+		else if ((buf[o2] == 'M') && (buf[o2 + 1] == 'M'))
+			n->order = EXIF_BYTE_ORDER_MOTOROLA;
+
+		/* The number of entries is at position 8+4. */
+		n->version = olympusV2;
+		o2 += 4;
 
 	} else if (!memcmp (buf + o2, "Nikon", 6)) {
 		o2 += 6;
@@ -199,8 +280,7 @@ exif_mnote_data_olympus_load (ExifMnoteData *en,
 			"Parsing Nikon maker note (0x%02x, %02x, %02x, "
 			"%02x, %02x, %02x, %02x, %02x)...",
 			buf[o2 + 0], buf[o2 + 1], buf[o2 + 2], buf[o2 + 3], 
-			buf[o2 + 4], buf[o2 + 5], buf[o2 + 6], buf[o2 + 7]); 
-
+			buf[o2 + 4], buf[o2 + 5], buf[o2 + 6], buf[o2 + 7]);
 		/* The first byte is the version. */
 		if (o2 >= buf_size) return;
 		n->version = buf[o2];
@@ -210,12 +290,22 @@ exif_mnote_data_olympus_load (ExifMnoteData *en,
 		o2 += 1;
 
 		switch (n->version) {
-		case 1:
+		case nikonV1:
 
 			base = MNOTE_NIKON1_TAG_BASE;
+			/* Fix endianness, if needed */
+			if (o2 >= buf_size) return;
+			c = exif_get_short (buf + o2, n->order);
+			if ((!(c & 0xFF)) && (c > 0x500)) {
+				if (n->order == EXIF_BYTE_ORDER_INTEL) {
+					n->order = EXIF_BYTE_ORDER_MOTOROLA;
+				} else {
+					n->order = EXIF_BYTE_ORDER_INTEL;
+				}
+			}
 			break;
 
-		case 2:
+		case nikonV2:
 
 			/* Skip 2 unknown bytes (00 00). */
 			o2 += 2;
@@ -226,9 +316,9 @@ exif_mnote_data_olympus_load (ExifMnoteData *en,
 			 */
 			datao = o2;
 			if (o2 >= buf_size) return;
-			if (!strncmp (&buf[o2], "II", 2))
+			if (!strncmp ((char *)&buf[o2], "II", 2))
 				n->order = EXIF_BYTE_ORDER_INTEL;
-			else if (!strncmp (&buf[o2], "MM", 2))
+			else if (!strncmp ((char *)&buf[o2], "MM", 2))
 				n->order = EXIF_BYTE_ORDER_MOTOROLA;
 			else {
 				exif_log (en->log, EXIF_LOG_CODE_DEBUG,
@@ -254,7 +344,9 @@ exif_mnote_data_olympus_load (ExifMnoteData *en,
 			return;
 		}
 	} else if (!memcmp (buf + o2, "\0\x1b", 2)) {
-		n->version = 2;
+		n->version = nikonV2;
+		/* 00 1b is # of entries in Motorola order - the rest should also be in MM order */
+		n->order = EXIF_BYTE_ORDER_MOTOROLA;
 	} else {
 		return;
 	}
@@ -347,7 +439,7 @@ exif_mnote_data_olympus_get_description (ExifMnoteData *d, unsigned int i)
 	
 	if (!n) return NULL;
 	if (i >= n->count) return NULL;
-        return mnote_olympus_tag_get_title (n->entries[i].tag);
+        return mnote_olympus_tag_get_description (n->entries[i].tag);
 }
 
 static void
diff --git a/src/libexif/olympus/exif-mnote-data-olympus.h b/src/libexif/olympus/exif-mnote-data-olympus.h
index b9b4209..4d55cab 100644
--- a/src/libexif/olympus/exif-mnote-data-olympus.h
+++ b/src/libexif/olympus/exif-mnote-data-olympus.h
@@ -1,6 +1,6 @@
 /* mnote-olympus-data.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -26,6 +26,9 @@
 #include <libexif/exif-byte-order.h>
 #include <libexif/exif-mem.h>
 
+enum OlympusVersion {nikonV1 = 1, nikonV2 = 2, olympusV1 = 3, olympusV2 = 4, sanyoV1 = 5 };
+
+
 typedef struct _ExifMnoteDataOlympus ExifMnoteDataOlympus;
 
 struct _ExifMnoteDataOlympus {
diff --git a/src/libexif/olympus/mnote-olympus-entry.c b/src/libexif/olympus/mnote-olympus-entry.c
index 1eff6fe..1e9e1e2 100644
--- a/src/libexif/olympus/mnote-olympus-entry.c
+++ b/src/libexif/olympus/mnote-olympus-entry.c
@@ -1,6 +1,6 @@
 /* mnote-olympus-entry.c
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -42,6 +42,19 @@
         }                                                       \
 }
 
+#define CF2(format,target1,target2,v,maxlen)                    \
+{                                                               \
+        if ((format != target1) && (format != target2)) {       \
+                snprintf (v, maxlen,	                        \
+                        _("Invalid format '%s', "               \
+                        "expected '%s' or '%s'."),              \
+                        exif_format_get_name (format),          \
+                        exif_format_get_name (target1),         \
+                        exif_format_get_name (target2));        \
+                break;                                          \
+        }                                                       \
+}
+
 #define CC(number,target,v,maxlen)                                      \
 {                                                                       \
         if (number != target) {                                         \
@@ -54,7 +67,7 @@
 
 #define CC2(number,t1,t2,v,maxlen)                                      \
 {                                                                       \
-	if ((number != t1) && (number != t2)) {                         \
+	if ((number < t1) || (number > t2)) {                           \
 		snprintf (v, maxlen,                                    \
 			_("Invalid number of components (%i, "          \
 			"expected %i or %i)."), (int) number,		\
@@ -63,7 +76,7 @@
 	}                                                               \
 }
 
-static struct {
+static const struct {
 	ExifTag tag;
     ExifFormat fmt;
 	struct {
@@ -71,6 +84,7 @@ static struct {
 		const char *string;
 	} elem[10];
 } items[] = {
+#ifndef NO_VERBOSE_TAG_DATA
   { MNOTE_NIKON_TAG_LENSTYPE, EXIF_FORMAT_BYTE,
     { {0, N_("AF non D Lens")},
       {1, N_("Manual")},
@@ -116,7 +130,7 @@ static struct {
     { {0, N_("Auto")},
       {1, N_("Preset")},
       {2, N_("Daylight")},
-      {3, N_("Incandescense")},
+      {3, N_("Incandescence")},
       {4, N_("Fluorescence")},
       {5, N_("Cloudy")},
       {6, N_("SpeedLight")},
@@ -129,14 +143,25 @@ static struct {
     { {1, N_("SQ")},
       {2, N_("HQ")},
       {3, N_("SHQ")},
+      {4, N_("RAW")},
+      {5, N_("SQ1")},
+      {6, N_("SQ2")},
+      {17, N_("Standard")},
+      {529, N_("High")},
       {0, NULL}}},
   { MNOTE_OLYMPUS_TAG_MACRO, EXIF_FORMAT_SHORT,
     { {0, N_("No")},
       {1, N_("Yes")},
+      {2, N_("Super Macro")},
       {0, NULL}}},
-  { MNOTE_OLYMPUS_TAG_DIGIZOOM, EXIF_FORMAT_SHORT,
-    { {0, N_("1x")},
-      {2, N_("2x")},
+  { MNOTE_OLYMPUS_TAG_BWMODE, EXIF_FORMAT_SHORT,
+    { {0, N_("No")},
+      {1, N_("Yes")},
+      {0, NULL}}},
+  { MNOTE_OLYMPUS_TAG_ONETOUCHWB, EXIF_FORMAT_SHORT,
+    { {0, N_("Off")},
+      {1, N_("On")},
+      {2, N_("On (Preset)")},
       {0, NULL}}},
   { MNOTE_OLYMPUS_TAG_FLASHMODE, EXIF_FORMAT_SHORT,
     { {0, N_("Auto")},
@@ -144,21 +169,73 @@ static struct {
       {2, N_("Fill")},
       {3, N_("Off")},
       {0, NULL}}},
+  { MNOTE_OLYMPUS_TAG_FLASHDEVICE, EXIF_FORMAT_SHORT,
+    { {0, N_("None")},
+      {1, N_("Internal")},
+      {4, N_("External")},
+      {5, N_("Internal + External")},
+      {0, NULL}}},
+  { MNOTE_OLYMPUS_TAG_FOCUSRANGE, EXIF_FORMAT_SHORT,
+    { {0, N_("Normal")},
+      {1, N_("Macro")},
+      {0, NULL}}},
+  { MNOTE_OLYMPUS_TAG_MANFOCUS, EXIF_FORMAT_SHORT,
+    { {0, N_("Auto")},
+      {1, N_("Manual")},
+      {0, NULL}}},
   { MNOTE_OLYMPUS_TAG_SHARPNESS, EXIF_FORMAT_SHORT,
     { {0, N_("Normal")},
       {1, N_("Hard")},
       {2, N_("Soft")},
       {0, NULL}}},
+  { MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE, EXIF_FORMAT_SHORT,
+    { {0, N_("No")},
+      {1, N_("Yes")},
+      {0, NULL}}},
   { MNOTE_OLYMPUS_TAG_CONTRAST, EXIF_FORMAT_SHORT,
     { {0, N_("Hard")},
       {1, N_("Normal")},
       {2, N_("Soft")},
       {0, NULL}}},
-  { MNOTE_OLYMPUS_TAG_MANFOCUS, EXIF_FORMAT_SHORT,
+  { MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID, EXIF_FORMAT_LONG,
+    { {0, N_("No")},
+      {1, N_("Yes")},
+      {0, NULL}}},
+  { MNOTE_OLYMPUS_TAG_CCDSCANMODE, EXIF_FORMAT_SHORT,
+    { {0, N_("Interlaced")},
+      {1, N_("Progressive")},
+      {0, NULL}}},
+  { MNOTE_SANYO_TAG_SEQUENTIALSHOT, EXIF_FORMAT_SHORT,
+    { {0, N_("None")},
+      {1, N_("Standard")},
+      {2, N_("Best")},
+      {3, N_("Adjust Exposure")},
+      {0, NULL}}},
+  { MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE, EXIF_FORMAT_SHORT,
+    { {0, N_("Record while down")},
+      {1, N_("Press start, press stop")},
+      {0, NULL}}},
+  { MNOTE_SANYO_TAG_RESAVED, EXIF_FORMAT_SHORT,
     { {0, N_("No")},
       {1, N_("Yes")},
       {0, NULL}}},
-  { 0, }
+  { MNOTE_SANYO_TAG_SCENESELECT, EXIF_FORMAT_SHORT,
+    { {0, N_("Off")},
+      {1, N_("Sport")},
+      {2, N_("TV")},
+      {3, N_("Night")},
+      {4, N_("User 1")},
+      {5, N_("User 2")},
+      {6, N_("Lamp")},
+      {0, NULL}}},
+  { MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL, EXIF_FORMAT_SHORT,
+    { {0, N_("5 frames/sec")},
+      {1, N_("10 frames/sec")},
+      {2, N_("15 frames/sec")},
+      {3, N_("20 frames/sec")},
+      {0, NULL}}},
+#endif
+  { 0, 0, { { 0, NULL } } }
 };
 
 char *
@@ -167,7 +244,8 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 	char         buf[30];
 	ExifLong     vl;
 	ExifShort    vs = 0;
-	ExifRational vr;
+	ExifRational vr, vr2;
+	ExifSRational vsr;
 	int          i, j;
 	double       r, b;
 
@@ -177,7 +255,8 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 	memset (v, 0, maxlen);
 	maxlen--;
 
-	if ((!entry->data) && (entry->components > 0)) return (v);
+	if ((!entry->data) && (entry->components > 0)) 
+		return (v);
 
 	switch (entry->tag) {
 	
@@ -212,7 +291,7 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
                 //vl =  exif_get_long (entry->data  , entry->order);
                 //printf("-> 0x%04x\n",entry->data);
                 //printf("-> 0x%s<\n",entry->data - 0);
-                memcpy(v, entry->data ,entry->components);
+                memcpy(v, entry->data, MIN(maxlen, entry->size));
                 //snprintf (v, maxlen, "%s<",  ( entry->data - 9  );
                 break;
 	case MNOTE_NIKON_TAG_COLORMODE:
@@ -225,21 +304,43 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 	case MNOTE_NIKON_TAG_FLASHMODE:
 	case MNOTE_NIKON_TAG_IMAGEADJUSTMENT:
 	case MNOTE_NIKON_TAG_ADAPTER:
-                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
-                memcpy(v, entry->data, MIN (maxlen, entry->components));
-                break;
+	case MNOTE_NIKON_TAG_SATURATION2:
+		CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+		memcpy(v, entry->data, MIN (maxlen, entry->size));
+		break;
 	case MNOTE_NIKON_TAG_TOTALPICTURES:
-                CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
-                CC (entry->components, 1, v, maxlen);
-                vl =  exif_get_long (entry->data, entry->order);
-                snprintf (v, maxlen, "%lu",  (long unsigned int) vl );
-                break;
+		CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
+		CC (entry->components, 1, v, maxlen);
+		vl =  exif_get_long (entry->data, entry->order);
+		snprintf (v, maxlen, "%lu",  (long unsigned int) vl );
+		break;
+	case MNOTE_NIKON_TAG_LENS_FSTOPS:
+	case MNOTE_NIKON_TAG_EXPOSUREDIFF: {
+		unsigned char a,b,c,d;
+		CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
+		CC (entry->components, 4, v, maxlen);
+		vl =  exif_get_long (entry->data, entry->order);
+		a = (vl>>24)&0xff; b = (vl>>16)&0xff; c = (vl>>8)&0xff; d = (vl)&0xff;
+		snprintf (v, maxlen, "%.1f",  c?(float)a*((float)b/(float)c):0 );
+		break;
+	}
+	case MNOTE_NIKON_TAG_FLASHEXPCOMPENSATION:
+	case MNOTE_NIKON_TAG_FLASHEXPOSUREBRACKETVAL:
+		CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
+		CC (entry->components, 4, v, maxlen);
+		vl =  exif_get_long (entry->data, entry->order);
+		snprintf (v, maxlen, "%.1f",  ((long unsigned int) vl>>24)/6.0 );
+		break;
+	case MNOTE_NIKON_TAG_SATURATION:
 	case MNOTE_NIKON_TAG_WHITEBALANCEFINE:
-                CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
-                CC (entry->components, 1, v, maxlen);
-                vs = exif_get_short (entry->data, entry->order);
-                snprintf (v, maxlen, "%hd", vs);
-                break;
+	case MNOTE_NIKON_TAG_HUE:
+	case MNOTE_OLYMPUS_TAG_SENSORTEMPERATURE:
+	case MNOTE_OLYMPUS_TAG_LENSTEMPERATURE:
+		CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
+		CC (entry->components, 1, v, maxlen);
+		vs = exif_get_short (entry->data, entry->order);
+		snprintf (v, maxlen, "%hd", vs);
+		break;
 	case MNOTE_NIKON_TAG_WHITEBALANCERB:
 		CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 		CC (entry->components, 4, v, maxlen);
@@ -248,7 +349,7 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 		vr = exif_get_rational (entry->data+8, entry->order);
 		b = (double)vr.numerator / vr.denominator;
 		//printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
-		snprintf (v, maxlen, "Red Correction %f, Blue Correction %f", r,b);
+		snprintf (v, maxlen, _("Red Correction %f, Blue Correction %f"), r,b);
 		break;
 	case MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE:
 		CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
@@ -256,31 +357,69 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 		vr = exif_get_rational (entry->data, entry->order);
 		if (vr.numerator) {
 			r = (double)vr.numerator / vr.denominator;
-			snprintf (v, maxlen, "%2.2f meters", r);
+			snprintf (v, maxlen, _("%2.2f meters"), r);
 		} else {
 			strncpy (v, _("No manual focus selection"), maxlen);
 		}
 		break;
-	case MNOTE_NIKON_TAG_DIGITALZOOM:
-	case MNOTE_NIKON1_TAG_DIGITALZOOM:
+	case MNOTE_NIKON_TAG_SENSORPIXELSIZE:
 		CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
-		CC (entry->components, 1, v, maxlen);
+		CC (entry->components, 2, v, maxlen);
 		vr = exif_get_rational (entry->data, entry->order);
+		vr2 = exif_get_rational (entry->data+8, entry->order);
 		r = (double)vr.numerator / vr.denominator;
-		snprintf (v, maxlen, "%2.2f", r);
+		b = (double)vr2.numerator / vr2.denominator;
+		snprintf (v, maxlen, "%2.2f x %2.2f um", r, b);
+		break;
+	case MNOTE_NIKON_TAG_BRACKETING:
+		CF2 (entry->format, EXIF_FORMAT_BYTE, EXIF_FORMAT_SHORT, v, maxlen);
+		CC (entry->components, 1, v, maxlen);
+		if (EXIF_FORMAT_SHORT == entry->format) {
+			vs = exif_get_short (entry->data, entry->order);
+		} else {
+			vs = entry->data[0];
+		}
+		snprintf (v, maxlen, "%hd", vs);
 		break;
 	case MNOTE_NIKON_TAG_AFFOCUSPOSITION:
 		CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 		CC (entry->components, 4, v, maxlen);
 		switch (  *( entry->data+1)  ) {
-		  	case  0: strncpy (v, "AF Position: Center", maxlen); break;
-		  	case  1: strncpy (v, "AF Position: Top", maxlen); break;
-		  	case  2: strncpy (v, "AF Position: Bottom", maxlen); break;
-		  	case  3: strncpy (v, "AF Position: Left", maxlen); break;
-		  	case  4: strncpy (v, "AF Position: Right", maxlen); break;
-		  	default: strncpy (v, "Unknown AF Position", maxlen);
+		  	case  0: strncpy (v, _("AF Position: Center"), maxlen); break;
+		  	case  1: strncpy (v, _("AF Position: Top"), maxlen); break;
+		  	case  2: strncpy (v, _("AF Position: Bottom"), maxlen); break;
+		  	case  3: strncpy (v, _("AF Position: Left"), maxlen); break;
+		  	case  4: strncpy (v, _("AF Position: Right"), maxlen); break;
+			case  5: strncpy (v, _("AF Position: Upper-left"), maxlen); break;
+		  	case  6: strncpy (v, _("AF Position: Upper-right"), maxlen); break;
+		  	case  7: strncpy (v, _("AF Position: Lower-left"), maxlen); break;
+		  	case  8: strncpy (v, _("AF Position: Lower-right"), maxlen); break;
+		  	case  9: strncpy (v, _("AF Position: Far Left"), maxlen); break;
+		  	case  10: strncpy (v, _("AF Position: Far Right"), maxlen); break;
+		  	default: strncpy (v, _("Unknown AF Position"), maxlen);
 		}     
 		break;
+	case MNOTE_OLYMPUS_TAG_FLASHDEVICE:
+		CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+		CC (entry->components, 2, v, maxlen);
+		vs = exif_get_short(entry->data, entry->order);
+		/* search for the tag */
+		for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++)
+			;
+		if (!items[i].tag) {
+		  	snprintf (v, maxlen, _("Internal error (unknown value %hi)"), vs);
+		  	break;
+		}
+		CF (entry->format, items[i].fmt, v, maxlen);
+		/* find the value */
+		for (j = 0; items[i].elem[j].string &&
+			    (items[i].elem[j].index < vs); j++);
+		if (items[i].elem[j].index != vs) {
+			snprintf (v, maxlen, _("Unknown value %hi"), vs);
+			break;
+		}
+		strncpy (v, _(items[i].elem[j].string), maxlen);
+		break;
 	case MNOTE_OLYMPUS_TAG_DIGIZOOM:
 		if (entry->format == EXIF_FORMAT_RATIONAL) {
 			CC (entry->components, 1, v, maxlen);
@@ -304,17 +443,21 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 	case MNOTE_NIKON1_TAG_CONVERTER:
 	case MNOTE_OLYMPUS_TAG_QUALITY:
 	case MNOTE_OLYMPUS_TAG_MACRO:
+	case MNOTE_OLYMPUS_TAG_BWMODE:
+	case MNOTE_OLYMPUS_TAG_ONETOUCHWB:
 	case MNOTE_OLYMPUS_TAG_FLASHMODE:
+	case MNOTE_OLYMPUS_TAG_FOCUSRANGE:
+	case MNOTE_OLYMPUS_TAG_MANFOCUS:
 	case MNOTE_OLYMPUS_TAG_SHARPNESS:
+	case MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE:
 	case MNOTE_OLYMPUS_TAG_CONTRAST:
-	case MNOTE_OLYMPUS_TAG_MANFOCUS:
-		/* search the tag */
-		for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++);
-		if (!items[i].tag) {
-		  	strncpy (v, "Internal error", maxlen);
-		  	break;
-		}
-		CF (entry->format, items[i].fmt, v, maxlen);
+	case MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID:
+	case MNOTE_OLYMPUS_TAG_CCDSCANMODE:
+	case MNOTE_SANYO_TAG_SEQUENTIALSHOT:
+	case MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE:
+	case MNOTE_SANYO_TAG_RESAVED:
+	case MNOTE_SANYO_TAG_SCENESELECT:
+	case MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL:
 		CC (entry->components, 1, v, maxlen);
 		switch (entry->format) {
 		case EXIF_FORMAT_BYTE:
@@ -328,16 +471,48 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 			vs = 0;
 			break;
 		}
+		/* search for the tag */
+		for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++)
+			;
+		if (!items[i].tag) {
+		  	snprintf (v, maxlen, _("Internal error (unknown value %hi)"), vs);
+		  	break;
+		}
+		CF (entry->format, items[i].fmt, v, maxlen);
 		/* find the value */
 		for (j = 0; items[i].elem[j].string &&
 			    (items[i].elem[j].index < vs); j++);
 		if (items[i].elem[j].index != vs) {
-			snprintf (v, maxlen, "Unknown value %hi", vs);
+			snprintf (v, maxlen, _("Unknown value %hi"), vs);
+			break;
+		}
+		strncpy (v, _(items[i].elem[j].string), maxlen);
+		break;
+	case MNOTE_OLYMPUS_TAG_NOISEREDUCTION:
+	case MNOTE_SANYO_TAG_WIDERANGE:
+	case MNOTE_SANYO_TAG_COLORADJUSTMENTMODE:
+	case MNOTE_SANYO_TAG_QUICKSHOT:
+	case MNOTE_SANYO_TAG_SELFTIMER:
+	case MNOTE_SANYO_TAG_VOICEMEMO:
+	case MNOTE_SANYO_TAG_FLICKERREDUCE:
+	case MNOTE_SANYO_TAG_OPTICALZOOM:
+	case MNOTE_SANYO_TAG_DIGITALZOOM:
+	case MNOTE_SANYO_TAG_LIGHTSOURCESPECIAL:
+		CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+		CC (entry->components, 1, v, maxlen);
+		vs = exif_get_short (entry->data, entry->order);
+		switch (vs) {
+		case 0:
+			strncpy (v, _("Off"), maxlen);
+			break;
+		case 1:
+			strncpy (v, _("On"), maxlen);
+			break;
+		default:
+			strncpy (v, _("Unknown"), maxlen);
 			break;
 		}
-		strncpy (v, items[i].elem[j].string, maxlen);
 		break;
-
 	case MNOTE_NIKON_TAG_LENS:
 		CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 		CC (entry->components, 4, v, maxlen);
@@ -356,17 +531,6 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 			snprintf (v, maxlen, "%ld-%ldmm 1:%3.1f - %3.1f",a,b,c,d);
 		}
 		break;
-	case MNOTE_NIKON1_TAG_FOCUS:
-		CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
-		CC (entry->components, 1, v, maxlen);
-		vr = exif_get_rational (entry->data, entry->order);
-		if (!vr.denominator) {
-			strncpy (v, _("Infinite"), maxlen);
-		} else {
-			r = (double)vr.numerator / vr.denominator;
-			snprintf (v, maxlen, "%2.2f", r);
-		}
-		break;
 
 	/* Olympus */
 	case MNOTE_OLYMPUS_TAG_MODE:
@@ -412,37 +576,47 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 			strncat (v, buf, maxlen - strlen (v));
 		}
 		break;
-	case MNOTE_OLYMPUS_TAG_UNKNOWN_1:
-		CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
-		CC (entry->components, 1, v, maxlen);
-		strncpy (v, _("Unknown tag."), maxlen);
-		break;
-	case MNOTE_OLYMPUS_TAG_UNKNOWN_2:
-		CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
-		CC (entry->components, 1, v, maxlen);
-		break;
-	case MNOTE_OLYMPUS_TAG_UNKNOWN_3:
+	case MNOTE_OLYMPUS_TAG_LENSDISTORTION:
 		CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
-		CC (entry->components, 1, v, maxlen);
+		CC (entry->components, 6, v, maxlen);
+		for (i=0; i < (int)entry->components; ++i) {
+			vs = exif_get_sshort (entry->data+2*i, entry->order);
+			sprintf (buf, "%hd ", vs);
+			strncat (v, buf, maxlen - strlen (v));
+		}
+		break;
+	case MNOTE_OLYMPUS_TAG_COLORCONTROL:
+		CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+		CC (entry->components, 6, v, maxlen);
+		for (i=0; i < (int)entry->components; ++i) {
+			vs = exif_get_short (entry->data+2*i, entry->order);
+			sprintf (buf, "%hu ", vs);
+			strncat (v, buf, maxlen - strlen (v));
+		}
 		break;
 	case MNOTE_OLYMPUS_TAG_VERSION:
 		CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 		CC2 (entry->components, 5, 8, v, maxlen);
-		strncpy (v, entry->data, MIN (maxlen, entry->size));
+		strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
+		break;
+	case MNOTE_OLYMPUS_TAG_SERIALNUMBER2:
+		CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+		strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 		break;
 	case MNOTE_OLYMPUS_TAG_INFO:
 		CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
-		CC2 (entry->components, 52, 53, v, maxlen);
-		strncpy (v, entry->data, MIN (maxlen, entry->size));
+		CC2 (entry->components, 52, 60, v, maxlen);
+		strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 		break;
 	case MNOTE_OLYMPUS_TAG_ID:
 		CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 		CC (entry->components, 32, v, maxlen);
-		strncpy (v, entry->data, MIN (maxlen, entry->size));
+		strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 		break;
 	case MNOTE_OLYMPUS_TAG_UNKNOWN_4:
 		CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 		CC (entry->components, 30, v, maxlen);
+		/* TODO: display me */
 		break;
 	case MNOTE_OLYMPUS_TAG_FOCUSDIST:
 		CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
@@ -493,7 +667,7 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 					break;
 				}
 				if (colorTemp) {
-					snprintf (v, maxlen, "Manual: %liK", colorTemp);
+					snprintf (v, maxlen, _("Manual: %liK"), colorTemp);
 				}
 				else {
 					strncpy (v, _("Manual: Unknown"), maxlen);
@@ -509,24 +683,75 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int m
 			break;
 		}
 		break;
+	case MNOTE_OLYMPUS_TAG_REDBALANCE:
+	case MNOTE_OLYMPUS_TAG_BLUEBALANCE:
+		CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+		CC (entry->components, 2, v, maxlen);
+		vs = exif_get_short (entry->data, entry->order);
+		snprintf (v, maxlen, "%hu ", vs);
+		vs = exif_get_short (entry->data + 2, entry->order);
+		sprintf (buf, "%hu", vs);
+		strncat (v, buf, maxlen - strlen (v));
+		break;
+	case MNOTE_OLYMPUS_TAG_BLACKLEVEL:
+	case MNOTE_NIKON_TAG_IMAGEBOUNDARY:
+		CC (entry->components, 4, v, maxlen);
+		/* Fall through to COLORMATRIX */
+	case MNOTE_OLYMPUS_TAG_COLORMATRIX:
+		CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+		if (entry->tag == MNOTE_OLYMPUS_TAG_COLORMATRIX)
+			CC (entry->components, 9, v, maxlen);
+		for (i=0; i < (int)entry->components; ++i) {
+			vs = exif_get_short (entry->data+2*i, entry->order);
+			sprintf (buf, "%hu ", vs);
+			strncat (v, buf, maxlen - strlen (v));
+		}
+		break;
+	case MNOTE_NIKON1_TAG_FOCUS:
+	case MNOTE_NIKON_TAG_DIGITALZOOM:
+	case MNOTE_NIKON1_TAG_DIGITALZOOM:
+	case MNOTE_OLYMPUS_TAG_FOCALPLANEDIAGONAL:
+		CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
+		/* Fall through to default handler for display */
 	default:
 		switch (entry->format) {
 		case EXIF_FORMAT_ASCII:
-			strncpy (v, entry->data,
-				 MIN (maxlen, entry->components));
+			strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 			break;
 		case EXIF_FORMAT_SHORT:
+			CC (entry->components, 1, v, maxlen);
 			vs = exif_get_short (entry->data, entry->order);
-			snprintf (v, maxlen, "%hi", vs);
+			snprintf (v, maxlen, "%hu", vs);
 			break;
 		case EXIF_FORMAT_LONG:
+			CC (entry->components, 1, v, maxlen);
 			vl = exif_get_long (entry->data, entry->order);
 			snprintf (v, maxlen, "%li", (long int) vl);
 			break;
+		case EXIF_FORMAT_RATIONAL:
+			CC (entry->components, 1, v, maxlen);
+			vr = exif_get_rational (entry->data, entry->order);
+			if (!vr.denominator) {
+				strncpy (v, _("Infinite"), maxlen);
+			} else {
+				r = (double)vr.numerator / vr.denominator;
+				snprintf (v, maxlen, "%2.3f", r);
+			}
+			break;
+		case EXIF_FORMAT_SRATIONAL:
+			CC (entry->components, 1, v, maxlen);
+			vsr = exif_get_srational (entry->data, entry->order);
+			if (!vsr.denominator) {
+				strncpy (v, _("Infinite"), maxlen);
+			} else {
+				r = (double)vsr.numerator / vsr.denominator;
+				snprintf (v, maxlen, "%2.3f", r);
+			}
+			break;
 		case EXIF_FORMAT_UNDEFINED:
 		default:
-			snprintf (v, maxlen, _("%li bytes unknown data: "),
-				  (long int) entry->size);
+			snprintf (v, maxlen, _("%i bytes unknown data: "),
+				  entry->size);
 			for (i = 0; i < (int)entry->size; i++) {
 				sprintf (buf, "%02x", entry->data[i]);
 				strncat (v, buf, maxlen - strlen (v));
diff --git a/src/libexif/olympus/mnote-olympus-entry.h b/src/libexif/olympus/mnote-olympus-entry.h
index a725228..9526bad 100644
--- a/src/libexif/olympus/mnote-olympus-entry.h
+++ b/src/libexif/olympus/mnote-olympus-entry.h
@@ -1,6 +1,6 @@
 /* mnote-olympus-entry.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/src/libexif/olympus/mnote-olympus-tag.c b/src/libexif/olympus/mnote-olympus-tag.c
index b7beacd..37a6bdc 100644
--- a/src/libexif/olympus/mnote-olympus-tag.c
+++ b/src/libexif/olympus/mnote-olympus-tag.c
@@ -1,6 +1,6 @@
 /* mnote-olympus-tag.c:
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -26,99 +26,163 @@
 
 #include <stdlib.h>
 
-static struct {
+static const struct {
 	MnoteOlympusTag tag;
 	const char *name;
 	const char *title;
 	const char *description;
 } table[] = {
-
+#ifndef NO_VERBOSE_TAG_STRINGS
 	/* Nikon v2 */
-	{MNOTE_NIKON_TAG_FIRMWARE,     "Firmware", N_("Firmware Version"), NULL},
-	{MNOTE_NIKON_TAG_ISO,          "ISO", N_("ISO Setting"), NULL},
-	{MNOTE_NIKON_TAG_COLORMODE1,   "COLORMODE1", N_("Colormode (?)"), NULL},
-	{MNOTE_NIKON_TAG_QUALITY,      "QUALITY", N_("Quality"), NULL},
-	{MNOTE_NIKON_TAG_WHITEBALANCE, "WHITEBALANCE", N_("Whitebalance"), NULL},
-	{MNOTE_NIKON_TAG_SHARPENING,   "SHARPENING",   N_("Image Sharpening"), NULL},
-	{MNOTE_NIKON_TAG_FOCUSMODE,    "FOCUSMODE",   N_("Focus Mode"), NULL},
-	{MNOTE_NIKON_TAG_FLASHSETTING, "FLASHSETTING",   N_("Flash Setting"), NULL},
-	{MNOTE_NIKON_TAG_FLASHMODE,    "FLASHMODE",    N_("Flash Mode"), NULL},
-	{MNOTE_NIKON_TAG_WHITEBALANCEFINE,"WHITEBALANCEFINE",N_("Whitebalance fine ajustment"), NULL},
-	{MNOTE_NIKON_TAG_WHITEBALANCERB,  "WHITEBALANCERB", N_("Whitebalance RB"), NULL},
+	{MNOTE_NIKON_TAG_FIRMWARE,     "Firmware", N_("Firmware Version"), ""},
+	{MNOTE_NIKON_TAG_ISO,          "ISO", N_("ISO Setting"), ""},
+	{MNOTE_NIKON_TAG_COLORMODE1,   "COLORMODE1", N_("Colormode (?)"), ""},
+	{MNOTE_NIKON_TAG_QUALITY,      "QUALITY", N_("Quality"), ""},
+	{MNOTE_NIKON_TAG_WHITEBALANCE, "WHITEBALANCE", N_("Whitebalance"), ""},
+	{MNOTE_NIKON_TAG_SHARPENING,   "SHARPENING",   N_("Image Sharpening"), ""},
+	{MNOTE_NIKON_TAG_FOCUSMODE,    "FOCUSMODE",   N_("Focus Mode"), ""},
+	{MNOTE_NIKON_TAG_FLASHSETTING, "FLASHSETTING",   N_("Flash Setting"), ""},
+	{MNOTE_NIKON_TAG_FLASHMODE,    "FLASHMODE",    N_("Flash Mode"), ""},
+	{MNOTE_NIKON_TAG_WHITEBALANCEFINE,"WHITEBALANCEFINE",N_("Whitebalance fine adjustment"), ""},
+	{MNOTE_NIKON_TAG_WHITEBALANCERB,  "WHITEBALANCERB", N_("Whitebalance RB"), ""},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X000D,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_ISOSELECTION,    "ISOSELECTION", N_("Isoselection"), NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X0011,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_EXPOSUREDIFF,    "EXPOSUREDIFF", N_("Exposurediff ?"), NULL},
-	{MNOTE_NIKON_TAG_FLASHCOMPENSATION, "FLASHCOMPENSATION", N_("Flashcompensation ?"), NULL},
-	{MNOTE_NIKON_TAG_ISO2,            "ISO", N_("ISO Setting"), NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X0016,  NULL, NULL, NULL},
+	{MNOTE_NIKON_TAG_ISOSELECTION,    "ISOSELECTION", N_("Isoselection"), ""},
+	{MNOTE_NIKON_TAG_PREVIEWIMAGE,    "PREVIEWIMAGE", N_("Preview Image"), ""},
+	{MNOTE_NIKON_TAG_EXPOSUREDIFF,    "EXPOSUREDIFF", N_("Exposurediff ?"), ""},
+	{MNOTE_NIKON_TAG_FLASHEXPCOMPENSATION, "FLASHEXPCOMPENSATION", N_("Flash exposure compensation"), ""},
+	{MNOTE_NIKON_TAG_ISO2,            "ISO", N_("ISO Setting"), ""},
+	{MNOTE_NIKON_TAG_IMAGEBOUNDARY,   "IMAGEBOUNDARY", N_("Image Boundary"), ""},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X0017,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X0018,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X0019,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_IMAGEADJUSTMENT, "ImageAdjustment", N_("Image Adjustment"), NULL},
-	{MNOTE_NIKON_TAG_TONECOMPENSATION, "TONECOMPENSATION", N_("Tonecompensation"), NULL},
-	{MNOTE_NIKON_TAG_ADAPTER,         "Adapter", N_("Adapter"), NULL},
-	{MNOTE_NIKON_TAG_LENSTYPE,        "LENSTYPE", N_("Lenstype"), NULL},
-	{MNOTE_NIKON_TAG_LENS,            "LENS", N_("Lens"), NULL},
-	{MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE, "MANUALFOCUSDISTANCE", N_("Manual Focus Distance"), NULL},
-	{MNOTE_NIKON_TAG_DIGITALZOOM,     "DigitalZoom", N_("Digital Zoom"), NULL},
-	{MNOTE_NIKON_TAG_FLASHUSED,       "FLASHUSED", N_("Flash used"), NULL},
-	{MNOTE_NIKON_TAG_AFFOCUSPOSITION, "AFFOCUSPOSITION", N_("AF Focus position"), NULL},
-	{MNOTE_NIKON_TAG_BRACKETING,      "BRACKETING", N_("Bracketing"), NULL},
+	{MNOTE_NIKON_TAG_FLASHEXPOSUREBRACKETVAL,  "FLASHEXPOSUREBRACKETVAL", N_("Flash exposure bracket value"), ""},
+	{MNOTE_NIKON_TAG_EXPOSUREBRACKETVAL,  "EXPOSUREBRACKETVAL", N_("Exposure bracket value"), ""},
+	{MNOTE_NIKON_TAG_IMAGEADJUSTMENT, "ImageAdjustment", N_("Image Adjustment"), ""},
+	{MNOTE_NIKON_TAG_TONECOMPENSATION, "TONECOMPENSATION", N_("Tonecompensation"), ""},
+	{MNOTE_NIKON_TAG_ADAPTER,         "ADAPTER", N_("Adapter"), ""},
+	{MNOTE_NIKON_TAG_LENSTYPE,        "LENSTYPE", N_("Lenstype"), ""},
+	{MNOTE_NIKON_TAG_LENS,            "LENS", N_("Lens"), ""},
+	{MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE, "MANUALFOCUSDISTANCE", N_("Manual Focus Distance"), ""},
+	{MNOTE_NIKON_TAG_DIGITALZOOM,     "DigitalZoom", N_("Digital Zoom"), ""},
+	{MNOTE_NIKON_TAG_FLASHUSED,       "FLASHUSED", N_("Flash used"), ""},
+	{MNOTE_NIKON_TAG_AFFOCUSPOSITION, "AFFOCUSPOSITION", N_("AF Focus position"), ""},
+	{MNOTE_NIKON_TAG_BRACKETING,      "BRACKETING", N_("Bracketing"), ""},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X008A,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X008B,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_CURVE,           "CURVE,", N_("Contrast curve"), NULL},
-	{MNOTE_NIKON_TAG_COLORMODE,       "COLORMODE,", N_("Colormode"), NULL},
-	{MNOTE_NIKON_TAG_LIGHTYPE,        "LIGHTYPE,", N_("Lightype"), NULL},
+	{MNOTE_NIKON_TAG_LENS_FSTOPS,     "LENSFSTOPS", N_("Lens F stops"), ""},
+	{MNOTE_NIKON_TAG_CURVE,           "CURVE,", N_("Contrast curve"), ""},
+	{MNOTE_NIKON_TAG_COLORMODE,       "COLORMODE,", N_("Colormode"), ""},
+	{MNOTE_NIKON_TAG_LIGHTTYPE,       "LIGHTTYPE,", N_("Lighttype"), ""},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X0091,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_HUE,             "Hue,", N_("Hue Adjustment"), NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X0094,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_NOISEREDUCTION,  "NOISEREDUCTION,", N_("Noisereduction"), NULL},
+	{MNOTE_NIKON_TAG_HUE,             "HUE", N_("Hue Adjustment"), ""},
+	{MNOTE_NIKON_TAG_SATURATION,      "SATURATION", N_("Saturation"), ""},
+	{MNOTE_NIKON_TAG_NOISEREDUCTION,  "NOISEREDUCTION,", N_("Noisereduction"), ""},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X0097,  NULL, NULL, NULL},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X0098,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X009A,  NULL, NULL, NULL},
+	{MNOTE_NIKON_TAG_SENSORPIXELSIZE, "SENSORPIXELSIZE", N_("Sensor pixel size"), ""},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X009B,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X00A0,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X00A2,  NULL, NULL, NULL},
+	{MNOTE_NIKON_TAG_SERIALNUMBER,    "SERIALNUMBER", N_("Serial number"), ""},
+	{MNOTE_NIKON_TAG_IMAGE_DATASIZE,  "IMAGEDATASIZE", N_("Image datasize"), N_("Size of compressed image data in bytes.")},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X00A3,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_TOTALPICTURES,   "TOTALPICTURES,", N_("Total number of pictures taken"), NULL},
+	{MNOTE_NIKON_TAG_TOTALPICTURES,   "TOTALPICTURES,", N_("Total number of pictures taken"), ""},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X00A8,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_OPTIMIZATION,    "OPTIMIZATION,", N_("Optimize Image"), NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X00AA,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_UNKNOWN_0X00AB,  NULL, NULL, NULL},
-	{MNOTE_NIKON_TAG_CAPTUREEDITORDATA, "CAPTUREEDITORDATA", N_("Capture Editor Data"), NULL},
-	{MNOTE_NIKON_TAG_CAPTUREEDITORVER, "CAPTUREEDITORVER", N_("Capture Editor Version"), NULL},
+	{MNOTE_NIKON_TAG_OPTIMIZATION,    "OPTIMIZATION,", N_("Optimize Image"), ""},
+	{MNOTE_NIKON_TAG_SATURATION,      "SATURATION", N_("Saturation"), ""},
+	{MNOTE_NIKON_TAG_VARIPROGRAM,     "VARIPROGRAM", N_("Vari Program"), ""},
+	{MNOTE_NIKON_TAG_CAPTUREEDITORDATA, "CAPTUREEDITORDATA", N_("Capture Editor Data"), ""},
+	{MNOTE_NIKON_TAG_CAPTUREEDITORVER, "CAPTUREEDITORVER", N_("Capture Editor Version"), ""},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X0E0E,  NULL, NULL, NULL},
 	{MNOTE_NIKON_TAG_UNKNOWN_0X0E10,  NULL, NULL, NULL},
 	{MNOTE_NIKON1_TAG_UNKNOWN_0X0002, NULL, NULL, NULL},
-	{MNOTE_NIKON1_TAG_QUALITY,        "QUALITY", N_("Quality"), NULL},
-	{MNOTE_NIKON1_TAG_COLORMODE,      "COLORMODE,", N_("Colormode"), NULL},
-	{MNOTE_NIKON1_TAG_IMAGEADJUSTMENT, "ImageAdjustment", N_("Image Adjustment"), NULL},
-	{MNOTE_NIKON1_TAG_CCDSENSITIVITY, "CCDSensitivity", N_("CCD Sensitivity"), NULL},
-	{MNOTE_NIKON1_TAG_WHITEBALANCE,   "WhiteBalance", N_("Whitebalance"), NULL},
-	{MNOTE_NIKON1_TAG_FOCUS,          "Focus", N_("Focus"), NULL},
+	{MNOTE_NIKON1_TAG_QUALITY,        "QUALITY", N_("Quality"), ""},
+	{MNOTE_NIKON1_TAG_COLORMODE,      "COLORMODE,", N_("Colormode"), ""},
+	{MNOTE_NIKON1_TAG_IMAGEADJUSTMENT, "ImageAdjustment", N_("Image Adjustment"), ""},
+	{MNOTE_NIKON1_TAG_CCDSENSITIVITY, "CCDSensitivity", N_("CCD Sensitivity"), ""},
+	{MNOTE_NIKON1_TAG_WHITEBALANCE,   "WhiteBalance", N_("Whitebalance"), ""},
+	{MNOTE_NIKON1_TAG_FOCUS,          "Focus", N_("Focus"), ""},
 	{MNOTE_NIKON1_TAG_UNKNOWN_0X0009, NULL, NULL, NULL},
-	{MNOTE_NIKON1_TAG_DIGITALZOOM,    "DigitalZoom", N_("Digital Zoom"), NULL},
-	{MNOTE_NIKON1_TAG_CONVERTER,      "Converter", N_("Converter"), NULL},
+	{MNOTE_NIKON1_TAG_DIGITALZOOM,    "DigitalZoom", N_("Digital Zoom"), ""},
+	{MNOTE_NIKON1_TAG_CONVERTER,      "Converter", N_("Converter"), ""},
 
-	/* Olympus */
-	{MNOTE_OLYMPUS_TAG_MODE, "Mode", N_("Speed/Sequence/Panorama direction"), NULL},
-	{MNOTE_OLYMPUS_TAG_QUALITY, "Quality", N_("Quality"), NULL},
-	{MNOTE_OLYMPUS_TAG_MACRO, "Macro", N_("Macro"), NULL},
-	{MNOTE_OLYMPUS_TAG_UNKNOWN_1, NULL, NULL, NULL},
-	{MNOTE_OLYMPUS_TAG_DIGIZOOM, "DigiZoom", N_("Digital Zoom"), NULL},
-	{MNOTE_OLYMPUS_TAG_UNKNOWN_2, NULL, NULL, NULL},
-	{MNOTE_OLYMPUS_TAG_UNKNOWN_3, NULL, NULL, NULL},
-	{MNOTE_OLYMPUS_TAG_VERSION, "FirmwareVersion", N_("Firmware version"), NULL},
-	{MNOTE_OLYMPUS_TAG_INFO, "Info", N_("Info"), NULL},
-	{MNOTE_OLYMPUS_TAG_ID, "CameraID", N_("Camera ID"), NULL},
+	/* Olympus & some Sanyo */
+	{MNOTE_OLYMPUS_TAG_THUMBNAILIMAGE, "ThumbnailImage", N_("Thumbnail Image"), ""},
+	{MNOTE_OLYMPUS_TAG_MODE, "Mode", N_("Speed/Sequence/Panorama direction"), ""},
+	{MNOTE_OLYMPUS_TAG_QUALITY, "Quality", N_("Quality"), ""},
+	{MNOTE_OLYMPUS_TAG_MACRO, "Macro", N_("Macro"), ""},
+	{MNOTE_OLYMPUS_TAG_BWMODE, "BWMode", N_("B&W Mode"), ""},
+	{MNOTE_OLYMPUS_TAG_DIGIZOOM, "DigiZoom", N_("Digital Zoom"), ""},
+	{MNOTE_OLYMPUS_TAG_FOCALPLANEDIAGONAL, "FocalPlaneDiagonal", N_("Focal Plane Diagonal"), ""},
+	{MNOTE_OLYMPUS_TAG_LENSDISTORTION, "LensDistortionParams", N_("Lens Distortion Parameters"), ""},
+	{MNOTE_OLYMPUS_TAG_VERSION, "FirmwareVersion", N_("Firmware version"), ""},
+	{MNOTE_OLYMPUS_TAG_INFO, "Info", N_("Info"), ""},
+	{MNOTE_OLYMPUS_TAG_ID, "CameraID", N_("Camera ID"), ""},
+	{MNOTE_OLYMPUS_TAG_PRECAPTUREFRAMES, "PreCaptureFrames", N_("Precapture Frames"), ""},
+	{MNOTE_OLYMPUS_TAG_WHITEBOARD, "WhiteBoard", N_("White Board"), ""},
+	{MNOTE_OLYMPUS_TAG_ONETOUCHWB, "OneTouchWB", N_("One Touch White Balance"), ""},
+	{MNOTE_OLYMPUS_TAG_WHITEBALANCEBRACKET, "WhiteBalanceBracket", N_("White Balance Bracket"), ""},
+	{MNOTE_OLYMPUS_TAG_WHITEBALANCEBIAS, "WhiteBalanceBias", N_("White Balance Bias"), ""},
+	{MNOTE_OLYMPUS_TAG_UNKNOWN_5, NULL, NULL, NULL},
 	{MNOTE_OLYMPUS_TAG_UNKNOWN_4, NULL, NULL, NULL},
-	{MNOTE_OLYMPUS_TAG_FLASHMODE, "FlashMode", N_("Flash Mode"), NULL},
-	{MNOTE_OLYMPUS_TAG_FOCUSDIST, "ManualFocusDistance", N_("Manual Focus Distance"), NULL},
-	{MNOTE_OLYMPUS_TAG_SHARPNESS, "Sharpness", N_("Sharpness Setting"), NULL},
-	{MNOTE_OLYMPUS_TAG_WBALANCE, "WhiteBalance", N_("White Balance Setting"), NULL},
-	{MNOTE_OLYMPUS_TAG_CONTRAST, "Contrast", N_("Contrast Setting"), NULL},
-	{MNOTE_OLYMPUS_TAG_MANFOCUS, "ManualFocus", N_("Manual Focus"), NULL},
+	{MNOTE_OLYMPUS_TAG_SHUTTERSPEED, "ShutterSpeed", N_("Shutter Speed"), ""},
+	{MNOTE_OLYMPUS_TAG_ISOVALUE, "ISOValue", N_("ISO Value"), ""},
+	{MNOTE_OLYMPUS_TAG_APERTUREVALUE, "ApertureValue", N_("Aperture Value"), ""},
+	{MNOTE_OLYMPUS_TAG_BRIGHTNESSVALUE, "BrightnessValue", N_("Brightness Value"), ""},
+	{MNOTE_OLYMPUS_TAG_FLASHMODE, "FlashMode", N_("Flash Mode"), ""},
+	{MNOTE_OLYMPUS_TAG_FLASHDEVICE, "FlashDevice", N_("Flash Device"), ""},
+	{MNOTE_OLYMPUS_TAG_EXPOSURECOMP, "ExposureCompensation", N_("Exposure Compensation"), ""},
+	{MNOTE_OLYMPUS_TAG_SENSORTEMPERATURE, "SensorTemperature", N_("Sensor Temperature"), ""},
+	{MNOTE_OLYMPUS_TAG_LENSTEMPERATURE, "LensTemperature", N_("Lens Temperature"), ""},
+	{MNOTE_OLYMPUS_TAG_LIGHTCONDITION, "LightCondition", N_("Light Condition"), ""},
+	{MNOTE_OLYMPUS_TAG_FOCUSRANGE, "FocusRange", N_("Focus Range"), ""},
+	{MNOTE_OLYMPUS_TAG_MANFOCUS, "FocusMode", N_("Focus Mode"), "Automatic or manual focusing mode"},
+	{MNOTE_OLYMPUS_TAG_FOCUSDIST, "ManualFocusDistance", N_("Manual Focus Distance"), ""},
+	{MNOTE_OLYMPUS_TAG_ZOOMSTEPCOUNT, "ZoomStepCount", N_("Zoom Step Count"), ""},
+	{MNOTE_OLYMPUS_TAG_FOCUSSTEPCOUNT, "FocusStepCount", N_("Focus Step Count"), ""},
+	{MNOTE_OLYMPUS_TAG_SHARPNESS, "Sharpness", N_("Sharpness Setting"), ""},
+	{MNOTE_OLYMPUS_TAG_FLASHCHARGELEVEL, "FlashChargeLevel", N_("Flash Charge Level"), ""},
+	{MNOTE_OLYMPUS_TAG_COLORMATRIX, "ColorMatrix", N_("Color Matrix"), ""},
+	{MNOTE_OLYMPUS_TAG_BLACKLEVEL, "BlackLevel", N_("Black Level"), ""},
+	{MNOTE_OLYMPUS_TAG_WBALANCE, "WhiteBalance", N_("White Balance Setting"), ""},
+	{MNOTE_OLYMPUS_TAG_REDBALANCE, "RedBalance", N_("Red Balance"), ""},
+	{MNOTE_OLYMPUS_TAG_BLUEBALANCE, "BlueBalance", N_("Blue Balance"), ""},
+	{MNOTE_OLYMPUS_TAG_COLORMATRIXNUMBER, "ColorMatrixNumber", N_("Color Matrix Number"), ""},
+	{MNOTE_OLYMPUS_TAG_SERIALNUMBER2, "SerialNumber", N_("Serial Number"), ""},
+	{MNOTE_OLYMPUS_TAG_FLASHEXPOSURECOMP, "FlashExposureComp", N_("Flash Exposure Comp"), ""},
+	{MNOTE_OLYMPUS_TAG_INTERNALFLASHTABLE, "InternalFlashTable", N_("Internal Flash Table"), ""},
+	{MNOTE_OLYMPUS_TAG_EXTERNALFLASHGVALUE, "ExternalFlashGValue", N_("External Flash G Value"), ""},
+	{MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE, "ExternalFlashBounce", N_("External Flash Bounce"), ""},
+	{MNOTE_OLYMPUS_TAG_EXTERNALFLASHZOOM, "ExternalFlashZoom", N_("External Flash Zoom"), ""},
+	{MNOTE_OLYMPUS_TAG_EXTERNALFLASHMODE, "ExternalFlashMode", N_("External Flash Mode"), ""},
+	{MNOTE_OLYMPUS_TAG_CONTRAST, "Contrast", N_("Contrast Setting"), ""},
+	{MNOTE_OLYMPUS_TAG_SHARPNESSFACTOR, "SharpnessFactor", N_("Sharpness Factor"), ""},
+	{MNOTE_OLYMPUS_TAG_COLORCONTROL, "ColorControl", N_("Color Control"), ""},
+	{MNOTE_OLYMPUS_TAG_IMAGEWIDTH, "OlympusImageWidth", N_("Olympus Image Width"), ""},
+	{MNOTE_OLYMPUS_TAG_IMAGEHEIGHT, "OlympusImageHeight", N_("Olympus Image Height"), ""},
+	{MNOTE_OLYMPUS_TAG_SCENEDETECT, "SceneDetect", N_("Scene Detect"), ""},
+	{MNOTE_OLYMPUS_TAG_COMPRESSIONRATIO, "CompressionRatio", N_("Compression Ratio"), ""},
+	{MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID, "PreviewImageValid", N_("Preview Image Valid"), ""},
+	{MNOTE_OLYMPUS_TAG_AFRESULT, "AFResult", N_("AF Result"), ""},
+	{MNOTE_OLYMPUS_TAG_CCDSCANMODE, "CCDScanMode", N_("CCD Scan Mode"), ""},
+	{MNOTE_OLYMPUS_TAG_NOISEREDUCTION, "NoiseReduction", N_("Noise Reduction"), ""},
+	{MNOTE_OLYMPUS_TAG_INFINITYLENSSTEP, "InfinityLensStep", N_("Infinity Lens Step"), ""},
+	{MNOTE_OLYMPUS_TAG_NEARLENSSTEP, "NearLensStep", N_("Near Lens Step"), ""},
+	{MNOTE_OLYMPUS_TAG_LIGHTVALUECENTER, "LightValueCenter", N_("Light Value Center"), ""},
+	{MNOTE_OLYMPUS_TAG_LIGHTVALUEPERIPHERY, "LightValuePeriphery", N_("Light Value Periphery"), ""},
+
+	/* Sanyo */
+	{MNOTE_SANYO_TAG_SEQUENTIALSHOT, "SequentialShot", N_("Sequential Shot"), ""},
+	{MNOTE_SANYO_TAG_WIDERANGE, "WideRange", N_("Wide Range"), ""},
+	{MNOTE_SANYO_TAG_COLORADJUSTMENTMODE, "ColorAdjustmentMode", N_("Color Adjustment Mode"), ""},
+	{MNOTE_SANYO_TAG_QUICKSHOT, "QuickShot", N_("Quick Shot"), ""},
+	{MNOTE_SANYO_TAG_SELFTIMER, "SelfTimer", N_("Self Timer"), ""},
+	{MNOTE_SANYO_TAG_VOICEMEMO, "VoiceMemo", N_("Voice Memo"), ""},
+	{MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE, "RecordShutterRelease", N_("Record Shutter Release"), ""},
+	{MNOTE_SANYO_TAG_FLICKERREDUCE, "FlickerReduce", N_("Flicker Reduce"), ""},
+	{MNOTE_SANYO_TAG_OPTICALZOOM, "OpticalZoom", N_("Optical Zoom"), ""},
+	{MNOTE_SANYO_TAG_DIGITALZOOM, "DigitalZoom", N_("Digital Zoom"), ""},
+	{MNOTE_SANYO_TAG_LIGHTSOURCESPECIAL, "LightSourceSpecial", N_("Light Source Special"), ""},
+	{MNOTE_SANYO_TAG_RESAVED, "Resaved", N_("Resaved"), ""},
+	{MNOTE_SANYO_TAG_SCENESELECT, "SceneSelect", N_("Scene Select"), ""},
+	{MNOTE_SANYO_TAG_MANUALFOCUSDISTANCE, "ManualFocusDistance", N_("Manual Focus Distance"), ""},
+	{MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL, "SequenceShotInterval", N_("Sequence Shot Interval"), ""},
+#endif
 	{0, NULL, NULL, NULL}
 };
 
@@ -150,6 +214,10 @@ mnote_olympus_tag_get_description (MnoteOlympusTag t)
 
 	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 	for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
-		if (table[i].tag == t) return (_(table[i].description));
+		if (table[i].tag == t) {
+			if (!table[i].description || !*table[i].description)
+				return "";
+			return (_(table[i].description));
+		}
 	return NULL;
 }
diff --git a/src/libexif/olympus/mnote-olympus-tag.h b/src/libexif/olympus/mnote-olympus-tag.h
index 22278ac..9ec08a6 100644
--- a/src/libexif/olympus/mnote-olympus-tag.h
+++ b/src/libexif/olympus/mnote-olympus-tag.h
@@ -1,6 +1,6 @@
 /* mnote-olympus-tag.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -42,13 +42,13 @@ enum _MnoteOlympusTag {
 	MNOTE_NIKON_TAG_UNKNOWN_0X000D          = 0x000d,
 	MNOTE_NIKON_TAG_EXPOSUREDIFF            = 0x000e,
 	MNOTE_NIKON_TAG_ISOSELECTION            = 0x000f,
-	MNOTE_NIKON_TAG_UNKNOWN_0X0011          = 0x0011,
-	MNOTE_NIKON_TAG_FLASHCOMPENSATION       = 0x0012,
+	MNOTE_NIKON_TAG_PREVIEWIMAGE            = 0x0011,
+	MNOTE_NIKON_TAG_FLASHEXPCOMPENSATION    = 0x0012,
 	MNOTE_NIKON_TAG_ISO2                    = 0x0013,
-	MNOTE_NIKON_TAG_UNKNOWN_0X0016          = 0x0016,
+	MNOTE_NIKON_TAG_IMAGEBOUNDARY           = 0x0016,
 	MNOTE_NIKON_TAG_UNKNOWN_0X0017          = 0x0017,
-	MNOTE_NIKON_TAG_UNKNOWN_0X0018          = 0x0018,
-	MNOTE_NIKON_TAG_UNKNOWN_0X0019          = 0x0019,
+	MNOTE_NIKON_TAG_FLASHEXPOSUREBRACKETVAL = 0x0018,
+	MNOTE_NIKON_TAG_EXPOSUREBRACKETVAL      = 0x0019,
 	MNOTE_NIKON_TAG_IMAGEADJUSTMENT         = 0x0080,
 	MNOTE_NIKON_TAG_TONECOMPENSATION        = 0x0081,
 	MNOTE_NIKON_TAG_ADAPTER                 = 0x0082,
@@ -60,26 +60,26 @@ enum _MnoteOlympusTag {
 	MNOTE_NIKON_TAG_AFFOCUSPOSITION         = 0x0088,
 	MNOTE_NIKON_TAG_BRACKETING              = 0x0089,
 	MNOTE_NIKON_TAG_UNKNOWN_0X008A          = 0x008a,
-	MNOTE_NIKON_TAG_UNKNOWN_0X008B          = 0x008b,
+	MNOTE_NIKON_TAG_LENS_FSTOPS             = 0x008b,
 	MNOTE_NIKON_TAG_CURVE                   = 0x008c,
 	MNOTE_NIKON_TAG_COLORMODE               = 0x008d,
-	MNOTE_NIKON_TAG_LIGHTYPE                = 0x0090,
+	MNOTE_NIKON_TAG_LIGHTTYPE               = 0x0090,
 	MNOTE_NIKON_TAG_UNKNOWN_0X0091          = 0x0091,
 	MNOTE_NIKON_TAG_HUE                     = 0x0092,
-	MNOTE_NIKON_TAG_UNKNOWN_0X0094          = 0x0094,
+	MNOTE_NIKON_TAG_SATURATION              = 0x0094,
 	MNOTE_NIKON_TAG_NOISEREDUCTION          = 0x0095,
 	MNOTE_NIKON_TAG_UNKNOWN_0X0097          = 0x0097,
 	MNOTE_NIKON_TAG_UNKNOWN_0X0098          = 0x0098,
-	MNOTE_NIKON_TAG_UNKNOWN_0X009A          = 0x009a,
+	MNOTE_NIKON_TAG_SENSORPIXELSIZE         = 0x009a,
 	MNOTE_NIKON_TAG_UNKNOWN_0X009B          = 0x009b,
-	MNOTE_NIKON_TAG_UNKNOWN_0X00A0          = 0x00a0,
-	MNOTE_NIKON_TAG_UNKNOWN_0X00A2          = 0x00a2,
+	MNOTE_NIKON_TAG_SERIALNUMBER            = 0x00a0,
+	MNOTE_NIKON_TAG_IMAGE_DATASIZE          = 0x00a2,
 	MNOTE_NIKON_TAG_UNKNOWN_0X00A3          = 0x00a3,
 	MNOTE_NIKON_TAG_TOTALPICTURES           = 0x00a7,
 	MNOTE_NIKON_TAG_UNKNOWN_0X00A8          = 0x00a8,
 	MNOTE_NIKON_TAG_OPTIMIZATION            = 0x00a9,
-	MNOTE_NIKON_TAG_UNKNOWN_0X00AA          = 0x00aa,
-	MNOTE_NIKON_TAG_UNKNOWN_0X00AB          = 0x00ab,
+	MNOTE_NIKON_TAG_SATURATION2             = 0x00aa,
+	MNOTE_NIKON_TAG_VARIPROGRAM             = 0x00ab,
 	MNOTE_NIKON_TAG_CAPTUREEDITORDATA       = 0x0e01,
 	MNOTE_NIKON_TAG_CAPTUREEDITORVER	= 0x0e09,
 	MNOTE_NIKON_TAG_UNKNOWN_0X0E0E		= 0x0e0e,
@@ -98,27 +98,95 @@ enum _MnoteOlympusTag {
 	MNOTE_NIKON1_TAG_DIGITALZOOM            = 0x000a + MNOTE_NIKON1_TAG_BASE,
 	MNOTE_NIKON1_TAG_CONVERTER              = 0x000b + MNOTE_NIKON1_TAG_BASE,
 
-	/* Olympus */
-	MNOTE_OLYMPUS_TAG_MODE		= 0x0200,
-	MNOTE_OLYMPUS_TAG_QUALITY	= 0x0201,
-	MNOTE_OLYMPUS_TAG_MACRO		= 0x0202,
-	MNOTE_OLYMPUS_TAG_UNKNOWN_1	= 0x0203,
-	MNOTE_OLYMPUS_TAG_DIGIZOOM	= 0x0204,
-	MNOTE_OLYMPUS_TAG_UNKNOWN_2	= 0x0205,
-	MNOTE_OLYMPUS_TAG_UNKNOWN_3	= 0x0206,
-	MNOTE_OLYMPUS_TAG_VERSION	= 0x0207,
-	MNOTE_OLYMPUS_TAG_INFO		= 0x0208,
-	MNOTE_OLYMPUS_TAG_ID		= 0x0209,
-	MNOTE_OLYMPUS_TAG_UNKNOWN_4	= 0x0f04,
-	MNOTE_OLYMPUS_TAG_FLASHMODE	= 0x1004,
-	MNOTE_OLYMPUS_TAG_MANFOCUS	= 0x100b,
-	MNOTE_OLYMPUS_TAG_FOCUSDIST	= 0x100c,
-	MNOTE_OLYMPUS_TAG_SHARPNESS	= 0x100f,
-	MNOTE_OLYMPUS_TAG_WBALANCE	= 0x1015,
-	MNOTE_OLYMPUS_TAG_CONTRAST	= 0x1029
+	/* Olympus and some Sanyo */
+	MNOTE_OLYMPUS_TAG_THUMBNAILIMAGE	= 0x0100,
+	MNOTE_OLYMPUS_TAG_MODE			= 0x0200,
+	MNOTE_OLYMPUS_TAG_QUALITY		= 0x0201,
+	MNOTE_OLYMPUS_TAG_MACRO			= 0x0202,
+	MNOTE_OLYMPUS_TAG_BWMODE		= 0x0203,
+	MNOTE_OLYMPUS_TAG_DIGIZOOM		= 0x0204,
+	MNOTE_OLYMPUS_TAG_FOCALPLANEDIAGONAL	= 0x0205,
+	MNOTE_OLYMPUS_TAG_LENSDISTORTION	= 0x0206,
+	MNOTE_OLYMPUS_TAG_VERSION		= 0x0207,
+	MNOTE_OLYMPUS_TAG_INFO			= 0x0208,
+	MNOTE_OLYMPUS_TAG_ID			= 0x0209,
+	MNOTE_OLYMPUS_TAG_PRECAPTUREFRAMES	= 0x0300,
+	MNOTE_OLYMPUS_TAG_WHITEBOARD		= 0x0301,
+	MNOTE_OLYMPUS_TAG_ONETOUCHWB		= 0x0302,
+	MNOTE_OLYMPUS_TAG_WHITEBALANCEBRACKET	= 0x0303,
+	MNOTE_OLYMPUS_TAG_WHITEBALANCEBIAS	= 0x0304,
+	MNOTE_OLYMPUS_TAG_UNKNOWN_5		= 0x0f00,
+	MNOTE_OLYMPUS_TAG_UNKNOWN_4		= 0x0f04,
+	MNOTE_OLYMPUS_TAG_SHUTTERSPEED		= 0x1000,
+	MNOTE_OLYMPUS_TAG_ISOVALUE		= 0x1001,
+	MNOTE_OLYMPUS_TAG_APERTUREVALUE		= 0x1002,
+	MNOTE_OLYMPUS_TAG_BRIGHTNESSVALUE	= 0x1003,
+	MNOTE_OLYMPUS_TAG_FLASHMODE		= 0x1004,
+	MNOTE_OLYMPUS_TAG_FLASHDEVICE		= 0x1005,
+	MNOTE_OLYMPUS_TAG_EXPOSURECOMP		= 0x1006,
+	MNOTE_OLYMPUS_TAG_SENSORTEMPERATURE	= 0x1007,
+	MNOTE_OLYMPUS_TAG_LENSTEMPERATURE	= 0x1008,
+	MNOTE_OLYMPUS_TAG_LIGHTCONDITION	= 0x1009,
+	MNOTE_OLYMPUS_TAG_FOCUSRANGE		= 0x100a,
+	MNOTE_OLYMPUS_TAG_MANFOCUS		= 0x100b,
+	MNOTE_OLYMPUS_TAG_FOCUSDIST		= 0x100c,
+	MNOTE_OLYMPUS_TAG_ZOOMSTEPCOUNT		= 0x100d,
+	MNOTE_OLYMPUS_TAG_FOCUSSTEPCOUNT	= 0x100e,
+	MNOTE_OLYMPUS_TAG_SHARPNESS		= 0x100f,
+	MNOTE_OLYMPUS_TAG_FLASHCHARGELEVEL	= 0x1010,
+	MNOTE_OLYMPUS_TAG_COLORMATRIX		= 0x1011,
+	MNOTE_OLYMPUS_TAG_BLACKLEVEL		= 0x1012,
+	MNOTE_OLYMPUS_TAG_WBALANCE		= 0x1015,
+	MNOTE_OLYMPUS_TAG_REDBALANCE		= 0x1017,
+	MNOTE_OLYMPUS_TAG_BLUEBALANCE		= 0x1018,
+	MNOTE_OLYMPUS_TAG_COLORMATRIXNUMBER	= 0x1019,
+	MNOTE_OLYMPUS_TAG_SERIALNUMBER2		= 0x101a,
+	MNOTE_OLYMPUS_TAG_FLASHEXPOSURECOMP	= 0x1023,
+	MNOTE_OLYMPUS_TAG_INTERNALFLASHTABLE	= 0x1024,
+	MNOTE_OLYMPUS_TAG_EXTERNALFLASHGVALUE	= 0x1025,
+	MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE	= 0x1026,
+	MNOTE_OLYMPUS_TAG_EXTERNALFLASHZOOM	= 0x1027,
+	MNOTE_OLYMPUS_TAG_EXTERNALFLASHMODE	= 0x1028,
+	MNOTE_OLYMPUS_TAG_CONTRAST		= 0x1029,
+	MNOTE_OLYMPUS_TAG_SHARPNESSFACTOR	= 0x102a,
+	MNOTE_OLYMPUS_TAG_COLORCONTROL		= 0x102b,
+	MNOTE_OLYMPUS_TAG_IMAGEWIDTH		= 0x102e,
+	MNOTE_OLYMPUS_TAG_IMAGEHEIGHT		= 0x102f,
+	MNOTE_OLYMPUS_TAG_SCENEDETECT		= 0x1030,
+	MNOTE_OLYMPUS_TAG_COMPRESSIONRATIO	= 0x1034,
+	MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID	= 0x1035,
+	MNOTE_OLYMPUS_TAG_AFRESULT		= 0x1038,
+	MNOTE_OLYMPUS_TAG_CCDSCANMODE		= 0x1039,
+	MNOTE_OLYMPUS_TAG_NOISEREDUCTION	= 0x103a,
+	MNOTE_OLYMPUS_TAG_INFINITYLENSSTEP	= 0x103b,
+	MNOTE_OLYMPUS_TAG_NEARLENSSTEP		= 0x103c,
+	MNOTE_OLYMPUS_TAG_LIGHTVALUECENTER	= 0x103d,
+	MNOTE_OLYMPUS_TAG_LIGHTVALUEPERIPHERY	= 0x103e,
+
+	/* Sanyo */
+	MNOTE_SANYO_TAG_SEQUENTIALSHOT		= 0x020e,
+	MNOTE_SANYO_TAG_WIDERANGE		= 0x020f,
+	MNOTE_SANYO_TAG_COLORADJUSTMENTMODE	= 0x0210,
+	MNOTE_SANYO_TAG_QUICKSHOT		= 0x0213,
+	MNOTE_SANYO_TAG_SELFTIMER		= 0x0214,
+	MNOTE_SANYO_TAG_VOICEMEMO		= 0x0216,
+	MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE	= 0x0217,
+	MNOTE_SANYO_TAG_FLICKERREDUCE		= 0x0218,
+	MNOTE_SANYO_TAG_OPTICALZOOM		= 0x0219,
+	MNOTE_SANYO_TAG_DIGITALZOOM		= 0x021b,
+	MNOTE_SANYO_TAG_LIGHTSOURCESPECIAL	= 0x021d,
+	MNOTE_SANYO_TAG_RESAVED			= 0x021e,
+	MNOTE_SANYO_TAG_SCENESELECT		= 0x021f,
+	MNOTE_SANYO_TAG_MANUALFOCUSDISTANCE	= 0x0223,
+	MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL	= 0x0224
 };
 typedef enum _MnoteOlympusTag MnoteOlympusTag;
 
+/* Don't use these definitions. They are here for compatibility only. */
+#define MNOTE_OLYMPUS_TAG_UNKNOWN_1	MNOTE_OLYMPUS_TAG_BWMODE
+#define MNOTE_OLYMPUS_TAG_UNKNOWN_2	MNOTE_OLYMPUS_TAG_FOCALPLANEDIAGONAL
+#define MNOTE_OLYMPUS_TAG_UNKNOWN_3	MNOTE_OLYMPUS_TAG_LENSDISTORTION
+
 const char *mnote_olympus_tag_get_name        (MnoteOlympusTag tag);
 const char *mnote_olympus_tag_get_title       (MnoteOlympusTag tag);
 const char *mnote_olympus_tag_get_description (MnoteOlympusTag tag);
diff --git a/src/libexif/pentax/exif-mnote-data-pentax.c b/src/libexif/pentax/exif-mnote-data-pentax.c
index cc2cc12..0d17d62 100644
--- a/src/libexif/pentax/exif-mnote-data-pentax.c
+++ b/src/libexif/pentax/exif-mnote-data-pentax.c
@@ -1,6 +1,6 @@
 /* exif-mnote-data-pentax.c
  *
- * Copyright © 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -73,41 +73,67 @@ exif_mnote_data_pentax_load (ExifMnoteData *en,
 		const unsigned char *buf, unsigned int buf_size)
 {
 	ExifMnoteDataPentax *n = (ExifMnoteDataPentax *) en;
-	unsigned int i, o, s;
+	size_t i, o, s, datao = 6 + n->offset, base = 0;
 	ExifShort c;
 
 	/* Number of entries */
-	if (buf_size < 2) return;
-	c = exif_get_short (buf + 6 + n->offset, n->order);
+	if (buf_size < datao + (4 + 2) + 2) return;
+	if (!memcmp(buf + datao, "AOC", 4)) {
+		if ((buf[datao + 4] == 'I') && (buf[datao + 5] == 'I')) {
+			n->version = pentaxV3;
+			n->order = EXIF_BYTE_ORDER_INTEL;
+		} else if ((buf[datao + 4] == 'M') && (buf[datao + 5] == 'M')) {
+			n->version = pentaxV3;
+			n->order = EXIF_BYTE_ORDER_MOTOROLA;
+		} else {
+			/* Uses Casio v2 tags */
+			n->version = pentaxV2;
+		}
+		datao += 4 + 2;
+		base = MNOTE_PENTAX2_TAG_BASE;
+	} if (!memcmp(buf + datao, "QVC", 4)) {
+		n->version = casioV2;
+		base = MNOTE_CASIO2_TAG_BASE;
+		datao += 4 + 2;
+	} else {
+		n->version = pentaxV1;
+	}
+	c = exif_get_short (buf + datao, n->order);
 	n->entries = exif_mem_alloc (en->mem, sizeof (MnotePentaxEntry) * c);
 	if (!n->entries) return;
 
 	for (i = 0; i < c; i++) {
-	    o = 6 + 2 + n->offset + 12 * i;
-	    if (o + 8 > buf_size) return;
-
-	    n->count = i + 1;
-	    n->entries[i].tag        = exif_get_short (buf + o + 0, n->order);
-	    n->entries[i].format     = exif_get_short (buf + o + 2, n->order);
-	    n->entries[i].components = exif_get_long  (buf + o + 4, n->order);
-	    n->entries[i].order      = n->order;
-
-            /*
-             * Size? If bigger than 4 bytes, the actual data is not
-             * in the entry but somewhere else (offset).
-             */
-            s = exif_format_get_size (n->entries[i].format) *
+		o = datao + 2 + 12 * i;
+		if (o + 8 > buf_size) return;
+
+		n->count = i + 1;
+		n->entries[i].tag        = exif_get_short (buf + o + 0, n->order) + base;
+		n->entries[i].format     = exif_get_short (buf + o + 2, n->order);
+		n->entries[i].components = exif_get_long  (buf + o + 4, n->order);
+		n->entries[i].order      = n->order;
+
+		/*
+		 * Size? If bigger than 4 bytes, the actual data is not
+		 * in the entry but somewhere else (offset).
+		 */
+		s = exif_format_get_size (n->entries[i].format) *
                                       n->entries[i].components;
-            if (!s) return;
-            o += 8;
-            if (s > 4) o = exif_get_long (buf + o, n->order) + 6;
-            if (o + s > buf_size) return;
+		if (s > 65536) {
+			/* Corrupt data: EXIF data size is limited to the
+			 * maximum size of a JPEG segment (64 kb). 
+			 */
+			continue;
+		}
+		if (!s) return;
+		o += 8;
+		if (s > 4) o = exif_get_long (buf + o, n->order) + 6;
+		if (o + s > buf_size) return;
                                                                                 
-            /* Sanity check */
-            n->entries[i].data = exif_mem_alloc (en->mem, sizeof (char) * s);
-            if (!n->entries[i].data) return;
-            n->entries[i].size = s;
-            memcpy (n->entries[i].data, buf + o, s);
+		/* Sanity check */
+		n->entries[i].data = exif_mem_alloc (en->mem, s);
+		if (!n->entries[i].data) return;
+		n->entries[i].size = s;
+		memcpy (n->entries[i].data, buf + o, s);
         }
 }
 
diff --git a/src/libexif/pentax/exif-mnote-data-pentax.h b/src/libexif/pentax/exif-mnote-data-pentax.h
index c04bc41..62f9739 100644
--- a/src/libexif/pentax/exif-mnote-data-pentax.h
+++ b/src/libexif/pentax/exif-mnote-data-pentax.h
@@ -1,6 +1,6 @@
 /* exif-mnote-data-pentax.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -27,6 +27,8 @@
 #include <libexif/pentax/mnote-pentax-entry.h>
 #include <libexif/exif-mem.h>
 
+enum PentaxVersion {pentaxV1 = 1, pentaxV2 = 2, pentaxV3 = 4, casioV2 = 4 };
+
 typedef struct _ExifMnoteDataPentax ExifMnoteDataPentax;
 
 struct _ExifMnoteDataPentax {
@@ -37,6 +39,8 @@ struct _ExifMnoteDataPentax {
 
 	ExifByteOrder order;
 	unsigned int offset;
+
+	enum PentaxVersion version;
 };
 
 ExifMnoteData *exif_mnote_data_pentax_new (ExifMem *);
diff --git a/src/libexif/pentax/mnote-pentax-entry.c b/src/libexif/pentax/mnote-pentax-entry.c
index 3469f22..ac15108 100644
--- a/src/libexif/pentax/mnote-pentax-entry.c
+++ b/src/libexif/pentax/mnote-pentax-entry.c
@@ -1,6 +1,6 @@
 /* mnote-pentax-entry.c
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -34,37 +34,50 @@
 
 #define CF(format,target,v,maxlen)                              \
 {                                                               \
-        if (format != target) {                                 \
-                snprintf (v, maxlen,	                        \
-                        _("Invalid format '%s', "               \
-                        "expected '%s'."),                      \
-                        exif_format_get_name (format),          \
-                        exif_format_get_name (target));         \
-                break;                                          \
-        }                                                       \
+	if (format != target) {                                 \
+		snprintf (v, maxlen,	                        \
+			_("Invalid format '%s', "               \
+			"expected '%s'."),                      \
+			exif_format_get_name (format),          \
+			exif_format_get_name (target));         \
+		break;                                          \
+	}                                                       \
 }
 
 #define CC(number,target,v,maxlen)                                      \
 {                                                                       \
-        if (number != target) {                                         \
-                snprintf (v, maxlen,                                    \
-                        _("Invalid number of components (%i, "          \
-                        "expected %i)."), (int) number, (int) target);  \
-                break;                                                  \
-        }                                                               \
+	if (number != target) {                                         \
+		snprintf (v, maxlen,                                    \
+			_("Invalid number of components (%i, "          \
+			"expected %i)."), (int) number, (int) target);  \
+		break;                                                  \
+	}                                                               \
 }
 
-static struct {
+#define CC2(number,t1,t2,v,maxlen)                                      \
+{                                                                       \
+	if ((number != t1) && (number != t2)) {                         \
+		snprintf (v, maxlen,                                    \
+			_("Invalid number of components (%i, "          \
+			"expected %i or %i)."), (int) number,		\
+			(int) t1, (int) t2);  				\
+		break;                                                  \
+	}                                                               \
+}
+
+static const struct {
 	ExifTag tag;
 	struct {
 		int index;
 		const char *string;
-	} elem[7];
+	} elem[33];
 } items[] = {
+#ifndef NO_VERBOSE_TAG_DATA
   { MNOTE_PENTAX_TAG_MODE,
     { {0, N_("Auto")},
       {1, N_("Night-scene")},
       {2, N_("Manual")},
+      {4, N_("Multi-exposure")},
       {0, NULL}}},
   { MNOTE_PENTAX_TAG_QUALITY,
     { {0, N_("Good")},
@@ -114,6 +127,181 @@ static struct {
       {2, N_("Black & White")},
       {3, N_("Sepia")},
       {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_MODE,
+    { {0, N_("Auto")},
+      {1, N_("Night-scene")},
+      {2, N_("Manual")},
+      {4, N_("Multi-exposure")},
+      {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_QUALITY,
+    { {0, N_("Good")},
+      {1, N_("Better")},
+      {2, N_("Best")},
+      {3, N_("TIFF")},
+      {4, N_("RAW")},
+      {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_IMAGE_SIZE,
+    { {0, "640x480"},
+      {1, N_("Full")},
+      {2, "1024x768"},
+      {3, "1280x960"},
+      {4, "1600x1200"},
+      {5, "2048x1536"},
+      {8, N_("2560x1920 or 2304x1728")},
+      {9, "3072x2304"},
+      {10, "3264x2448"},
+      {19, "320x240"},
+      {20, "2288x1712"},
+      {21, "2592x1944"},
+      {22, N_("2304x1728 or 2592x1944")},
+      {23, "3056x2296"},
+      {25, N_("2816x2212 or 2816x2112")},
+      {27, "3648x2736"},
+      {36, "3008x2008"},
+      {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_PICTURE_MODE,
+    { {0, N_("Program")},
+      {2, N_("Program AE")},
+      {3, N_("Manual")},
+      {5, N_("Portrait")},
+      {6, N_("Landscape")},
+      {8, N_("Sport")},
+      {9, N_("Night Scene")},
+      {11, N_("Soft")},
+      {12, N_("Surf & Snow")},
+      {13, N_("Sunset or Candlelight")},
+      {14, N_("Autumn")},
+      {15, N_("Macro")},
+      {17, N_("Fireworks")},
+      {18, N_("Text")},
+      {19, N_("Panorama")},
+      {30, N_("Self Portrait")},
+      {31, N_("Illustrations")},
+      {33, N_("Digital Filter")},
+      {37, N_("Museum")},
+      {38, N_("Food")},
+      {40, N_("Green Mode")},
+      {49, N_("Light Pet")},
+      {50, N_("Dark Pet")},
+      {51, N_("Medium Pet")},
+      {53, N_("Underwater")},
+      {54, N_("Candlelight")},
+      {55, N_("Natural Skin Tone")},
+      {56, N_("Synchro Sound Record")},
+      {58, N_("Frame Composite")},
+      {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_FLASH_MODE,
+    { {0x0000, N_("Auto, Did not fire")},
+      {0x0001, N_("Off")},
+      {0x0003, N_("Auto, Did not fire, Red-eye reduction")},
+      {0x0100, N_("Auto, Fired")},
+      {0x0102, N_("On")},
+      {0x0103, N_("Auto, Fired, Red-eye reduction")},
+      {0x0104, N_("On, Red-eye reduction")},
+      {0x0105, N_("On, Wireless")},
+      {0x0108, N_("On, Soft")},
+      {0x0109, N_("On, Slow-sync")},
+      {0x010a, N_("On, Slow-sync, Red-eye reduction")},
+      {0x010b, N_("On, Trailing-curtain Sync")},
+      {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_FOCUS_MODE,
+    { {0, N_("Normal")},
+      {1, N_("Macro")},
+      {2, N_("Infinity")},
+      {3, N_("Manual")},
+      {5, N_("Pan Focus")},
+      {16, N_("AF-S")},
+      {17, N_("AF-C")},
+      {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_AFPOINT_SELECTED,
+    { {1, N_("Upper-left")},
+      {2, N_("Top")},
+      {3, N_("Upper-right")},
+      {4, N_("Left")},
+      {5, N_("Mid-left")},
+      {6, N_("Center")},
+      {7, N_("Mid-right")},
+      {8, N_("Right")},
+      {9, N_("Lower-left")},
+      {10, N_("Bottom")},
+      {11, N_("Lower-right")},
+      {0xfffe, N_("Fixed Center")},
+      {0xffff, N_("Auto")},
+      {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_AUTO_AFPOINT,
+    { {0, N_("Multiple")},
+      {1, N_("Top-left")},
+      {2, N_("Top-center")},
+      {3, N_("Top-right")},
+      {4, N_("Left")},
+      {5, N_("Center")},
+      {6, N_("Right")},
+      {7, N_("Bottom-left")},
+      {8, N_("Bottom-center")},
+      {9, N_("Bottom-right")},
+      {0xffff, N_("None")},
+      {0, NULL}}},
+  { MNOTE_PENTAX2_TAG_WHITE_BALANCE,
+    { {0, N_("Auto")},
+      {1, N_("Daylight")},
+      {2, N_("Shade")},
+      {3, N_("Fluorescent")},
+      {4, N_("Tungsten")},
+      {5, N_("Manual")},
+      {6, N_("Daylight Fluorescent")},
+      {7, N_("Daywhite Fluorescent")},
+      {8, N_("White Fluorescent")},
+      {9, N_("Flash")},
+      {10, N_("Cloudy")},
+      {0xfffe, N_("Unknown")},
+      {0xffff, N_("User Selected")},
+      {0, NULL}}},
+  {MNOTE_CASIO2_TAG_BESTSHOT_MODE, 
+    { {0, N_("Off")},
+      {1, N_("On")},
+      {0, NULL}}},
+#endif
+  {0, {{0, NULL}}}
+};
+
+/* Two-component values */
+static const struct {
+	ExifTag tag;
+	struct {
+		int index1, index2;
+		const char *string;
+	} elem[39];
+} items2[] = {
+#ifndef NO_VERBOSE_TAG_DATA
+  { MNOTE_PENTAX2_TAG_IMAGE_SIZE,
+    { {0, 0, "2304x1728"},
+      {4, 0, "1600x1200"},
+      {5, 0, "2048x1536"},
+      {8, 0, "2560x1920"},
+      {34, 0, "1536x1024"},
+      {36, 0, N_("3008x2008 or 3040x2024")},
+      {37, 0, "3008x2000"},
+      {35, 1, "2400x1600"},
+      {32, 2, "960x480"},
+      {33, 2, "1152x768"},
+      {34, 2, "1536x1024"},
+      {0,  0, NULL}}},
+  { MNOTE_PENTAX2_TAG_PICTURE_MODE,
+    { {0,   0, N_("Auto")},
+      {5,   0, N_("Portrait")},
+      {53,  0, N_("Underwater")},
+      {255, 0, N_("Digital Filter?")},
+      {5,   1, N_("Portrait")},
+      {9,   1, N_("Night Scene")},
+      {13,  1, N_("Candlelight")},
+      {15,  1, N_("Macro")},
+      {53,  1, N_("Underwater")},
+      {0,   2, N_("Program AE")},
+      {5,   2, N_("Portrait")},
+      {6,   2, N_("Landscape")},
+      {0,   0, NULL}}},
+#endif
+  {0, {{0, 0, NULL}}}
 };
 
 char *
@@ -121,7 +309,7 @@ mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
 			      char *val, unsigned int maxlen)
 {
 	ExifLong vl;
-	ExifShort vs;
+	ExifShort vs, vs2;
 	int i = 0, j = 0;
 
 	if (!entry) return (NULL);
@@ -140,26 +328,63 @@ mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
 	  case MNOTE_PENTAX_TAG_SATURATION:
 	  case MNOTE_PENTAX_TAG_ISO_SPEED:
 	  case MNOTE_PENTAX_TAG_COLOR:
+	  case MNOTE_PENTAX2_TAG_MODE:
+	  case MNOTE_PENTAX2_TAG_QUALITY:
+	  case MNOTE_PENTAX2_TAG_FLASH_MODE:
+	  case MNOTE_PENTAX2_TAG_FOCUS_MODE:
+	  case MNOTE_PENTAX2_TAG_AFPOINT_SELECTED:
+	  case MNOTE_PENTAX2_TAG_AUTO_AFPOINT:
+	  case MNOTE_PENTAX2_TAG_WHITE_BALANCE:
+	  case MNOTE_PENTAX2_TAG_PICTURE_MODE:
+	  case MNOTE_PENTAX2_TAG_IMAGE_SIZE:
+	  case MNOTE_CASIO2_TAG_BESTSHOT_MODE:
 		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-		CC (entry->components, 1, val, maxlen);
-		vs = exif_get_short (entry->data, entry->order);
+		CC2 (entry->components, 1, 2, val, maxlen);
+		if (entry->components == 1) {
+			vs = exif_get_short (entry->data, entry->order);
 
-		/* search the tag */
-		for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++);
-		if (!items[i].tag) {
-		  	strncpy (val, "Internal error", maxlen);
-		  	break;
-		}
+			/* search the tag */
+			for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++);
+			if (!items[i].tag) {
+				snprintf (val, maxlen,
+					  _("Internal error (unknown value %i)"), vs);
+			  	break;
+			}
 
-		/* find the value */
-		for (j = 0; items[i].elem[j].string &&
+			/* find the value */
+			for (j = 0; items[i].elem[j].string &&
 			    (items[i].elem[j].index < vs); j++);
-		if (items[i].elem[j].index != vs) {
-			snprintf (val, maxlen,
-				  "Internal error (unknown value %i)", vs);
-			break;
+			if (items[i].elem[j].index != vs) {
+				snprintf (val, maxlen,
+					  _("Internal error (unknown value %i)"), vs);
+				break;
+			}
+			strncpy (val, _(items[i].elem[j].string), maxlen);
+		} else {
+			/* Two-component values */
+			CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+			CC2 (entry->components, 1, 2, val, maxlen);
+			vs = exif_get_short (entry->data, entry->order);
+			vs2 = exif_get_short (entry->data+2, entry->order) << 16;
+
+			/* search the tag */
+			for (i = 0; (items2[i].tag && items2[i].tag != entry->tag); i++);
+			if (!items2[i].tag) {
+				snprintf (val, maxlen,
+					  _("Internal error (unknown value %i %i)"), vs, vs2);
+			  	break;
+			}
+
+			/* find the value */
+			for (j = 0; items2[i].elem[j].string && ((items2[i].elem[j].index2 < vs2)
+				|| ((items2[i].elem[j].index2 == vs2) && (items2[i].elem[j].index1 < vs))); j++);
+			if ((items2[i].elem[j].index1 != vs) || (items2[i].elem[j].index2 != vs2)) {
+				snprintf (val, maxlen,
+					  _("Internal error (unknown value %i %i)"), vs, vs2);
+				break;
+			}
+			strncpy (val, _(items2[i].elem[j].string), maxlen);
 		}
-		snprintf (val, maxlen, "%s", items[i].elem[j].string);
 		break;
 
 	case MNOTE_PENTAX_TAG_ZOOM:
@@ -171,23 +396,23 @@ mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
 	case MNOTE_PENTAX_TAG_PRINTIM:
 		CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
 		CC (entry->components, 124, val, maxlen);
-		snprintf (val, maxlen, "%li bytes unknown data",
-			  entry->components);
+		snprintf (val, maxlen, _("%i bytes unknown data"),
+			entry->size);
 		break;
 	case MNOTE_PENTAX_TAG_TZ_CITY:
 		CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
 		CC (entry->components, 4, val, maxlen);
-		snprintf (val, entry->components, "%s", entry->data);
+		strncpy (val, (char*)entry->data, MIN(maxlen, entry->size));
 		break;
 	case MNOTE_PENTAX_TAG_TZ_DST:
 		CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
 		CC (entry->components, 4, val, maxlen);
-		snprintf (val, entry->components, "%s", entry->data);
+		strncpy (val, (char*)entry->data, MIN(maxlen, entry->size));
 		break;
 	default:
 		switch (entry->format) {
 		case EXIF_FORMAT_ASCII:
-		  strncpy (val, entry->data, MIN(maxlen, entry->components));
+		  strncpy (val, (char *)entry->data, MIN(maxlen, entry->size));
 		  break;
 		case EXIF_FORMAT_SHORT:
 		  vs = exif_get_short (entry->data, entry->order);
@@ -199,8 +424,8 @@ mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
 		  break;
 		case EXIF_FORMAT_UNDEFINED:
 		default:
-		  snprintf (val, maxlen, "%li bytes unknown data",
-			    entry->components);
+		  snprintf (val, maxlen, _("%i bytes unknown data"),
+			  entry->size);
 		  break;
 		}
 		break;
diff --git a/src/libexif/pentax/mnote-pentax-entry.h b/src/libexif/pentax/mnote-pentax-entry.h
index 628d5dd..a7025e6 100644
--- a/src/libexif/pentax/mnote-pentax-entry.h
+++ b/src/libexif/pentax/mnote-pentax-entry.h
@@ -1,6 +1,6 @@
 /* mnote-pentax-entry.h
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/src/libexif/pentax/mnote-pentax-tag.c b/src/libexif/pentax/mnote-pentax-tag.c
index 76823a4..dd06cd9 100644
--- a/src/libexif/pentax/mnote-pentax-tag.c
+++ b/src/libexif/pentax/mnote-pentax-tag.c
@@ -1,6 +1,6 @@
 /* mnote-pentax-tag.c:
  *
- * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -25,39 +25,53 @@
 
 #include <libexif/i18n.h>
 
-static struct {
+static const struct {
 	MnotePentaxTag tag;
 	const char *name;
 	const char *title;
 	const char *description;
 } table[] = {
-	{MNOTE_PENTAX_TAG_MODE, "Mode", N_("Capture Mode"), NULL},
-	{MNOTE_PENTAX_TAG_QUALITY, "Quality", N_("Quality Level"), NULL},
-	{MNOTE_PENTAX_TAG_FOCUS, "Focus", N_("Focus Mode"), NULL},
-	{MNOTE_PENTAX_TAG_FLASH, "Flash", N_("Flash Mode"), NULL},
+#ifndef NO_VERBOSE_TAG_STRINGS
+	{MNOTE_PENTAX_TAG_MODE, "Mode", N_("Capture Mode"), ""},
+	{MNOTE_PENTAX_TAG_QUALITY, "Quality", N_("Quality Level"), ""},
+	{MNOTE_PENTAX_TAG_FOCUS, "Focus", N_("Focus Mode"), ""},
+	{MNOTE_PENTAX_TAG_FLASH, "Flash", N_("Flash Mode"), ""},
 	{MNOTE_PENTAX_TAG_UNKNOWN_05, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_UNKNOWN_06, NULL, NULL, NULL},
-	{MNOTE_PENTAX_TAG_WHITE_BALANCE, "WhiteBalance", N_("White Balance"), NULL},
+	{MNOTE_PENTAX_TAG_WHITE_BALANCE, "WhiteBalance", N_("White Balance"), ""},
 	{MNOTE_PENTAX_TAG_UNKNOWN_08, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_UNKNOWN_09, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_ZOOM, "Zoom", N_("Zoom"), NULL},
-	{MNOTE_PENTAX_TAG_SHARPNESS, "Sharpness", N_("Sharpness"), NULL},
-	{MNOTE_PENTAX_TAG_CONTRAST, "Contrast", N_("Contrast"), NULL},
-	{MNOTE_PENTAX_TAG_SATURATION, "Saturation", N_("Saturation"), NULL},
+	{MNOTE_PENTAX_TAG_SHARPNESS, "Sharpness", N_("Sharpness"), ""},
+	{MNOTE_PENTAX_TAG_CONTRAST, "Contrast", N_("Contrast"), ""},
+	{MNOTE_PENTAX_TAG_SATURATION, "Saturation", N_("Saturation"), ""},
 	{MNOTE_PENTAX_TAG_UNKNOWN_14, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_UNKNOWN_15, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_UNKNOWN_16, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_UNKNOWN_17, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_UNKNOWN_18, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_UNKNOWN_19, NULL, NULL, NULL},
-	{MNOTE_PENTAX_TAG_ISO_SPEED, "ISOSpeed", N_("ISOSpeed"), NULL},
+	{MNOTE_PENTAX_TAG_ISO_SPEED, "ISOSpeed", N_("ISOSpeed"), ""},
 	{MNOTE_PENTAX_TAG_UNKNOWN_21, NULL, NULL, NULL},
-	{MNOTE_PENTAX_TAG_COLOR, "Color", N_("Color"), NULL},
+	{MNOTE_PENTAX_TAG_COLOR, "Color", N_("Colors"), ""},
 	{MNOTE_PENTAX_TAG_UNKNOWN_24, NULL, NULL, NULL},
 	{MNOTE_PENTAX_TAG_UNKNOWN_25, NULL, NULL, NULL},
-	{MNOTE_PENTAX_TAG_PRINTIM, "PrintIM", N_("PrintIM Settings"), NULL},
-	{MNOTE_PENTAX_TAG_TZ_CITY, "TimeZone", N_("TimeZone"), NULL},
-	{MNOTE_PENTAX_TAG_TZ_DST, "DaylightSavings", N_("DaylightSavings"), NULL},
+	{MNOTE_PENTAX_TAG_PRINTIM, "PrintIM", N_("PrintIM Settings"), ""},
+	{MNOTE_PENTAX_TAG_TZ_CITY, "TimeZone", N_("Time Zone"), ""},
+	{MNOTE_PENTAX_TAG_TZ_DST, "DaylightSavings", N_("Daylight Savings"), ""},
+	{MNOTE_PENTAX2_TAG_MODE, "Mode", N_("Capture Mode"), ""},
+	{MNOTE_PENTAX2_TAG_QUALITY, "Quality", N_("Quality Level"), ""},
+	{MNOTE_PENTAX2_TAG_IMAGE_SIZE, "ImageSize", N_("Image Size"), ""},
+	{MNOTE_PENTAX2_TAG_PICTURE_MODE, "PictureMode", N_("PictureMode"), ""},
+	{MNOTE_PENTAX2_TAG_FLASH_MODE, "FlashMode", N_("Flash Mode"), ""},
+	{MNOTE_PENTAX2_TAG_FOCUS_MODE, "FocusMode", N_("Focus Mode"), ""},
+	{MNOTE_PENTAX2_TAG_AFPOINT_SELECTED, "AFPointSelected", N_("AF Point Selected"), ""},
+	{MNOTE_PENTAX2_TAG_AUTO_AFPOINT, "AutoAFPoint", N_("Auto AF Point"), ""},
+	{MNOTE_PENTAX2_TAG_WHITE_BALANCE, "WhiteBalance", N_("White Balance"), ""},
+	{MNOTE_CASIO2_TAG_OBJECT_DISTANCE, "ObjectDistance", N_("Object Distance"), N_("Distance of photographed object in millimeters.")},
+	{MNOTE_CASIO2_TAG_TIME_ZONE, "TimeZone", N_("Time Zone"), ""},
+	{MNOTE_CASIO2_TAG_BESTSHOT_MODE, "BestshotMode", N_("Bestshot mode"), ""},
+#endif
 	{0, NULL, NULL, NULL}
 };
 
@@ -89,6 +103,10 @@ mnote_pentax_tag_get_description (MnotePentaxTag t)
 
 	bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 	for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
-		if (table[i].tag == t) return (_(table[i].description));
+		if (table[i].tag == t) {
+			if (!table[i].description || !*table[i].description)
+				return "";
+			return (_(table[i].description));
+		}
 	return NULL;
 }
diff --git a/src/libexif/pentax/mnote-pentax-tag.h b/src/libexif/pentax/mnote-pentax-tag.h
index a261102..872222b 100644
--- a/src/libexif/pentax/mnote-pentax-tag.h
+++ b/src/libexif/pentax/mnote-pentax-tag.h
@@ -1,6 +1,6 @@
 /* mnote-pentax-tag.h
  *
- * Copyright © 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
+ * Copyright (c) 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -59,7 +59,86 @@ enum _MnotePentaxTag {
 	MNOTE_PENTAX_TAG_UNKNOWN_25	= 0x0019,
 	MNOTE_PENTAX_TAG_PRINTIM	= 0x0e00,
 	MNOTE_PENTAX_TAG_TZ_CITY	= 0x1000,
-	MNOTE_PENTAX_TAG_TZ_DST		= 0x1001
+	MNOTE_PENTAX_TAG_TZ_DST		= 0x1001,
+
+	/* Pentax v2, v3: real values + our proprietary base to distinguish from v1 */
+	MNOTE_PENTAX2_TAG_BASE              = 0x4000,
+	MNOTE_PENTAX2_TAG_MODE		    = 0x0001 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_PREVIEW_SIZE      = 0x0002 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_PREVIEW_LENGTH    = 0x0003 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_PREVIEW_START     = 0x0004 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_MODEL_ID          = 0x0005 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_DATE              = 0x0006 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_TIME              = 0x0007 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_QUALITY           = 0x0008 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_IMAGE_SIZE        = 0x0009 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_PICTURE_MODE      = 0x000b + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_FLASH_MODE        = 0x000c + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_FOCUS_MODE        = 0x000d + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_AFPOINT_SELECTED  = 0x000e + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_AUTO_AFPOINT      = 0x000f + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_FOCUS_POSITION    = 0x0010 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_EXPOSURE_TIME     = 0x0012 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_FNUMBER           = 0x0013 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_ISO               = 0x0014 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_EXPOSURE_COMPENSATION = 0x0016 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_METERING_MODE     = 0x0017 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_AUTO_BRACKETING   = 0x0018 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_WHITE_BALANCE     = 0x0019 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_WHITE_BALANCE_MODE= 0x001a + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_BLUE_BALANCE      = 0x001b + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_RED_BALANCE       = 0x001c + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_FOCAL_LENGTH      = 0x001d + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_DIGITAL_ZOOM      = 0x001e + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_SATURATION        = 0x001f + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_CONTRAST          = 0x0020 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_SHARPNESS         = 0x0021 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_WORLDTIME_LOCATION = 0x0022 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_HOMETOWN_CITY     = 0x0023 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_DESTINATION_CITY  = 0x0024 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_HOMETOWN_DST      = 0x0025 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_DESTINATION_DST   = 0x0026 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_FRAME_NUMBER      = 0x0029 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_IMAGE_PROCESSING  = 0x0032 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_PICTURE_MODE2     = 0x0033 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_DRIVE_MODE        = 0x0034 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_COLOR_SPACE       = 0x0037 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_IMAGE_AREA_OFFSET = 0x0038 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_RAW_IMAGE_SIZE    = 0x0039 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_AFPOINTS_USED     = 0x003c + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_LENS_TYPE         = 0x003f + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_CAMERA_TEMPERATURE = 0x0047 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_NOISE_REDUCTION   = 0x0049 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_FLASH_EXPOSURE_COMP = 0x004d + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_IMAGE_TONE        = 0x004f + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_SHAKE_REDUCTION_INFO = 0x005c + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_BLACK_POINT       = 0x0200 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_WHITE_POINT       = 0x0201 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_AE_INFO           = 0x0206 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_LENS_INFO         = 0x0207 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_FLASH_INFO        = 0x0208 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_CAMERA_INFO       = 0x0215 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_BATTERY_INFO      = 0x0216 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_HOMETOWN_CITY_CODE = 0x1000 + MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_PENTAX2_TAG_DESTINATION_CITY_CODE = 0x1001 + MNOTE_PENTAX2_TAG_BASE,
+
+	/* Casio v2: some Casio v2 tags match Pentax v2 tags */
+	MNOTE_CASIO2_TAG_BASE               = MNOTE_PENTAX2_TAG_BASE,
+	MNOTE_CASIO2_TAG_PREVIEW_START      = 0x2000 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_WHITE_BALANCE_BIAS = 0x2011 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_WHITE_BALANCE      = 0x2012 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_OBJECT_DISTANCE    = 0x2022 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_FLASH_DISTANCE     = 0x2034 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_RECORD_MODE        = 0x3000 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_SELF_TIMER         = 0x3001 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_QUALITY            = 0x3002 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_FOCUS_MODE         = 0x3003 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_TIME_ZONE          = 0x3006 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_BESTSHOT_MODE      = 0x3007 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_CCS_ISO_SENSITIVITY = 0x3014 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_COLOR_MODE         = 0x3015 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_ENHANCEMENT        = 0x3016 + MNOTE_CASIO2_TAG_BASE,
+	MNOTE_CASIO2_TAG_FINER              = 0x3017 + MNOTE_CASIO2_TAG_BASE
 };
 typedef enum _MnotePentaxTag MnotePentaxTag;