*** empty log message ***

6 files changed, 674 insertions, 218 deletions

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);