First commit - moving from LuaForge to SourceForge

6 files changed, 674 insertions, 0 deletions

diff --git a/src/libexif/pentax/exif-mnote-data-pentax.c b/src/libexif/pentax/exif-mnote-data-pentax.c
new file mode 100644
index 0000000..cc2cc12
--- /dev/null
+++ b/src/libexif/pentax/exif-mnote-data-pentax.c
@@ -0,0 +1,209 @@
+/* exif-mnote-data-pentax.c
+ *
+ * Copyright © 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
+ * 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 "exif-mnote-data-pentax.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <libexif/exif-byte-order.h>
+#include <libexif/exif-utils.h>
+
+/* #define DEBUG */
+
+static void
+exif_mnote_data_pentax_clear (ExifMnoteDataPentax *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_pentax_free (ExifMnoteData *n)
+{
+	if (!n) return;
+
+	exif_mnote_data_pentax_clear ((ExifMnoteDataPentax *) n);
+}
+
+static char *
+exif_mnote_data_pentax_get_value (ExifMnoteData *d, unsigned int i, char *val, unsigned int maxlen)
+{
+	ExifMnoteDataPentax *n = (ExifMnoteDataPentax *) d;
+
+	if (!n) return NULL;
+	if (n->count <= i) return NULL;
+	return mnote_pentax_entry_get_value (&n->entries[i], val, maxlen);
+}
+
+static void
+exif_mnote_data_pentax_load (ExifMnoteData *en,
+		const unsigned char *buf, unsigned int buf_size)
+{
+	ExifMnoteDataPentax *n = (ExifMnoteDataPentax *) en;
+	unsigned int i, o, s;
+	ExifShort c;
+
+	/* Number of entries */
+	if (buf_size < 2) return;
+	c = exif_get_short (buf + 6 + n->offset, 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) *
+                                      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 (en->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_pentax_count (ExifMnoteData *n)
+{
+	return n ? ((ExifMnoteDataPentax *) n)->count : 0;
+}
+
+static unsigned int
+exif_mnote_data_pentax_get_id (ExifMnoteData *d, unsigned int n)
+{
+	ExifMnoteDataPentax *note = (ExifMnoteDataPentax *) d;
+
+	if (!note) return 0;
+	if (note->count <= n) return 0;
+	return note->entries[n].tag;
+}
+
+static const char *
+exif_mnote_data_pentax_get_name (ExifMnoteData *d, unsigned int n)
+{
+	ExifMnoteDataPentax *note = (ExifMnoteDataPentax *) d;
+
+	if (!note) return NULL;
+	if (note->count <= n) return NULL;
+	return mnote_pentax_tag_get_name (note->entries[n].tag);
+}
+
+static const char *
+exif_mnote_data_pentax_get_title (ExifMnoteData *d, unsigned int n)
+{
+	ExifMnoteDataPentax *note = (ExifMnoteDataPentax *) d;
+
+	if (!note) return NULL;
+	if (note->count <= n) return NULL;
+	return mnote_pentax_tag_get_title (note->entries[n].tag);
+}
+
+static const char *
+exif_mnote_data_pentax_get_description (ExifMnoteData *d, unsigned int n)
+{
+	ExifMnoteDataPentax *note = (ExifMnoteDataPentax *) d;
+	
+	if (!note) return NULL;
+	if (note->count <= n) return NULL;
+	return mnote_pentax_tag_get_description (note->entries[n].tag);
+}
+
+static void
+exif_mnote_data_pentax_set_offset (ExifMnoteData *d, unsigned int o)
+{
+	if (d) ((ExifMnoteDataPentax *) d)->offset = o;
+}
+
+static void
+exif_mnote_data_pentax_set_byte_order (ExifMnoteData *d, ExifByteOrder o)
+{
+	ExifByteOrder o_orig;
+	ExifMnoteDataPentax *n = (ExifMnoteDataPentax *) 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);
+	}
+}
+
+ExifMnoteData *
+exif_mnote_data_pentax_new (ExifMem *mem)
+{
+	ExifMnoteData *d;
+
+	if (!mem) return NULL;
+
+	d = exif_mem_alloc (mem, sizeof (ExifMnoteDataPentax));
+	if (!d) return NULL;
+
+	exif_mnote_data_construct (d, mem);
+
+	/* Set up function pointers */
+	d->methods.free            = exif_mnote_data_pentax_free;
+	d->methods.set_byte_order  = exif_mnote_data_pentax_set_byte_order;
+	d->methods.set_offset      = exif_mnote_data_pentax_set_offset;
+	d->methods.load            = exif_mnote_data_pentax_load;
+	d->methods.count           = exif_mnote_data_pentax_count;
+	d->methods.get_id          = exif_mnote_data_pentax_get_id;
+	d->methods.get_name        = exif_mnote_data_pentax_get_name;
+	d->methods.get_title       = exif_mnote_data_pentax_get_title;
+	d->methods.get_description = exif_mnote_data_pentax_get_description;
+	d->methods.get_value       = exif_mnote_data_pentax_get_value;
+
+	return d;
+}
diff --git a/src/libexif/pentax/exif-mnote-data-pentax.h b/src/libexif/pentax/exif-mnote-data-pentax.h
new file mode 100644
index 0000000..c04bc41
--- /dev/null
+++ b/src/libexif/pentax/exif-mnote-data-pentax.h
@@ -0,0 +1,44 @@
+/* exif-mnote-data-pentax.h
+ *
+ * Copyright © 2002 Lutz Müller <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_MNOTE_DATA_PENTAX_H__
+#define __EXIF_MNOTE_DATA_PENTAX_H__
+
+#include <libexif/exif-byte-order.h>
+#include <libexif/exif-mnote-data.h>
+#include <libexif/exif-mnote-data-priv.h>
+#include <libexif/pentax/mnote-pentax-entry.h>
+#include <libexif/exif-mem.h>
+
+typedef struct _ExifMnoteDataPentax ExifMnoteDataPentax;
+
+struct _ExifMnoteDataPentax {
+	ExifMnoteData parent;
+
+	MnotePentaxEntry *entries;
+	unsigned int count;
+
+	ExifByteOrder order;
+	unsigned int offset;
+};
+
+ExifMnoteData *exif_mnote_data_pentax_new (ExifMem *);
+
+#endif /* __EXIF_MNOTE_DATA_PENTAX_H__ */
diff --git a/src/libexif/pentax/mnote-pentax-entry.c b/src/libexif/pentax/mnote-pentax-entry.c
new file mode 100644
index 0000000..3469f22
--- /dev/null
+++ b/src/libexif/pentax/mnote-pentax-entry.c
@@ -0,0 +1,210 @@
+/* mnote-pentax-entry.c
+ *
+ * Copyright © 2002 Lutz Müller <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 "mnote-pentax-entry.h"
+
+#include <libexif/i18n.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libexif/exif-format.h>
+#include <libexif/exif-utils.h>
+#include <libexif/exif-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 struct {
+	ExifTag tag;
+	struct {
+		int index;
+		const char *string;
+	} elem[7];
+} items[] = {
+  { MNOTE_PENTAX_TAG_MODE,
+    { {0, N_("Auto")},
+      {1, N_("Night-scene")},
+      {2, N_("Manual")},
+      {0, NULL}}},
+  { MNOTE_PENTAX_TAG_QUALITY,
+    { {0, N_("Good")},
+      {1, N_("Better")},
+      {2, N_("Best")},{0,NULL}}},
+  { MNOTE_PENTAX_TAG_FOCUS,
+    { {2, N_("Custom")},
+      {3, N_("Auto")},
+      {0, NULL}}},
+  { MNOTE_PENTAX_TAG_FLASH,
+    { {1, N_("Auto")},
+      {2, N_("Flash on")},
+      {4, N_("Flash off")},
+      {6, N_("Red-eye Reduction")},
+      {0, NULL}}},
+  { MNOTE_PENTAX_TAG_WHITE_BALANCE,
+    { {0, N_("Auto")},
+      {1, N_("Daylight")},
+      {2, N_("Shade")},
+      {3, N_("Tungsten")},
+      {4, N_("Fluorescent")},
+      {5, N_("Manual")},
+      {0, NULL}}},
+  { MNOTE_PENTAX_TAG_SHARPNESS,
+    { {0, N_("Normal")},
+      {1, N_("Soft")},
+      {2, N_("Hard")},
+      {0, NULL}}},
+  { MNOTE_PENTAX_TAG_CONTRAST,
+    { {0, N_("Normal")},
+      {1, N_("Low")},
+      {2, N_("High")},
+      {0, NULL}}},
+  { MNOTE_PENTAX_TAG_SATURATION,
+    { {0, N_("Normal")},
+      {1, N_("Low")},
+      {2, N_("High")},
+      {0, NULL}}},
+  { MNOTE_PENTAX_TAG_ISO_SPEED,
+    { {10,  N_("100")},
+      {16,  N_("200")},
+      {100, N_("100")},
+      {200, N_("200")},
+      { 0,  NULL}}},
+  { MNOTE_PENTAX_TAG_COLOR,
+    { {1, N_("Full")},
+      {2, N_("Black & White")},
+      {3, N_("Sepia")},
+      {0, NULL}}},
+};
+
+char *
+mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
+			      char *val, unsigned int maxlen)
+{
+	ExifLong vl;
+	ExifShort vs;
+	int i = 0, j = 0;
+
+	if (!entry) return (NULL);
+
+	memset (val, 0, maxlen);
+	maxlen--;
+
+	switch (entry->tag) {
+	  case MNOTE_PENTAX_TAG_MODE:
+	  case MNOTE_PENTAX_TAG_QUALITY:
+	  case MNOTE_PENTAX_TAG_FOCUS:
+	  case MNOTE_PENTAX_TAG_FLASH:
+	  case MNOTE_PENTAX_TAG_WHITE_BALANCE:
+	  case MNOTE_PENTAX_TAG_SHARPNESS:
+	  case MNOTE_PENTAX_TAG_CONTRAST:
+	  case MNOTE_PENTAX_TAG_SATURATION:
+	  case MNOTE_PENTAX_TAG_ISO_SPEED:
+	  case MNOTE_PENTAX_TAG_COLOR:
+		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) {
+		  	strncpy (val, "Internal error", maxlen);
+		  	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;
+		}
+		snprintf (val, maxlen, "%s", items[i].elem[j].string);
+		break;
+
+	case MNOTE_PENTAX_TAG_ZOOM:
+		CF (entry->format, EXIF_FORMAT_LONG, val, maxlen);
+		CC (entry->components, 1, val, maxlen);
+		vl = exif_get_long (entry->data, entry->order);
+		snprintf (val, maxlen, "%li", (long int) vl);
+		break;
+	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);
+		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);
+		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);
+		break;
+	default:
+		switch (entry->format) {
+		case EXIF_FORMAT_ASCII:
+		  strncpy (val, entry->data, MIN(maxlen, entry->components));
+		  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, "%li", (long int) vl);
+		  break;
+		case EXIF_FORMAT_UNDEFINED:
+		default:
+		  snprintf (val, maxlen, "%li bytes unknown data",
+			    entry->components);
+		  break;
+		}
+		break;
+	}
+
+	return (val);
+}
diff --git a/src/libexif/pentax/mnote-pentax-entry.h b/src/libexif/pentax/mnote-pentax-entry.h
new file mode 100644
index 0000000..628d5dd
--- /dev/null
+++ b/src/libexif/pentax/mnote-pentax-entry.h
@@ -0,0 +1,43 @@
+/* mnote-pentax-entry.h
+ *
+ * Copyright © 2002 Lutz Müller <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_PENTAX_ENTRY_H__
+#define __MNOTE_PENTAX_ENTRY_H__
+
+#include <libexif/exif-format.h>
+#include <libexif/exif-byte-order.h>
+#include <libexif/pentax/mnote-pentax-tag.h>
+
+typedef struct _MnotePentaxEntry        MnotePentaxEntry;
+
+struct _MnotePentaxEntry {
+	MnotePentaxTag tag;
+	ExifFormat format;
+	unsigned long components;
+
+	unsigned char *data;
+	unsigned int size;
+
+	ExifByteOrder order;
+};
+
+char *mnote_pentax_entry_get_value (MnotePentaxEntry *entry, char *val, unsigned int maxlen);
+
+#endif /* __MNOTE_PENTAX_ENTRY_H__ */
diff --git a/src/libexif/pentax/mnote-pentax-tag.c b/src/libexif/pentax/mnote-pentax-tag.c
new file mode 100644
index 0000000..76823a4
--- /dev/null
+++ b/src/libexif/pentax/mnote-pentax-tag.c
@@ -0,0 +1,94 @@
+/* mnote-pentax-tag.c:
+ *
+ * Copyright © 2002 Lutz Müller <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 "mnote-pentax-tag.h"
+
+#include <stdlib.h>
+
+#include <libexif/i18n.h>
+
+static 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},
+	{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_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_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_UNKNOWN_21, NULL, NULL, NULL},
+	{MNOTE_PENTAX_TAG_COLOR, "Color", N_("Color"), NULL},
+	{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},
+	{0, NULL, NULL, NULL}
+};
+
+const char *
+mnote_pentax_tag_get_name (MnotePentaxTag 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_pentax_tag_get_title (MnotePentaxTag 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_pentax_tag_get_description (MnotePentaxTag 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));
+	return NULL;
+}
diff --git a/src/libexif/pentax/mnote-pentax-tag.h b/src/libexif/pentax/mnote-pentax-tag.h
new file mode 100644
index 0000000..a261102
--- /dev/null
+++ b/src/libexif/pentax/mnote-pentax-tag.h
@@ -0,0 +1,74 @@
+/* mnote-pentax-tag.h
+ *
+ * Copyright © 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
+ * 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_PENTAX_TAG_H__
+#define __MNOTE_PENTAX_TAG_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * Missing features which are probably in the unknowns somewhere ...
+ * 1/ AF Area (Wide, Spot, Free)
+ * 2/ AE Metering (Multi segment, Centre-weighted, Spot)
+ * 3/ 
+ */
+
+enum _MnotePentaxTag {
+	MNOTE_PENTAX_TAG_MODE		= 0x0001,
+	MNOTE_PENTAX_TAG_QUALITY	= 0x0002,
+	MNOTE_PENTAX_TAG_FOCUS		= 0x0003,
+	MNOTE_PENTAX_TAG_FLASH		= 0x0004,
+	MNOTE_PENTAX_TAG_UNKNOWN_05	= 0x0005,
+	MNOTE_PENTAX_TAG_UNKNOWN_06	= 0x0006,
+	MNOTE_PENTAX_TAG_WHITE_BALANCE	= 0x0007,
+	MNOTE_PENTAX_TAG_UNKNOWN_08	= 0x0008,
+	MNOTE_PENTAX_TAG_UNKNOWN_09	= 0x0009,
+	MNOTE_PENTAX_TAG_ZOOM		= 0x000a,
+	MNOTE_PENTAX_TAG_SHARPNESS	= 0x000b,
+	MNOTE_PENTAX_TAG_CONTRAST	= 0x000c,
+	MNOTE_PENTAX_TAG_SATURATION	= 0x000d,
+	MNOTE_PENTAX_TAG_UNKNOWN_14	= 0x000e,
+	MNOTE_PENTAX_TAG_UNKNOWN_15	= 0x000f,
+	MNOTE_PENTAX_TAG_UNKNOWN_16	= 0x0010,
+	MNOTE_PENTAX_TAG_UNKNOWN_17	= 0x0011,
+	MNOTE_PENTAX_TAG_UNKNOWN_18	= 0x0012,
+	MNOTE_PENTAX_TAG_UNKNOWN_19	= 0x0013,
+	MNOTE_PENTAX_TAG_ISO_SPEED	= 0x0014,
+	MNOTE_PENTAX_TAG_UNKNOWN_21	= 0x0015,
+	MNOTE_PENTAX_TAG_COLOR		= 0x0017,
+	MNOTE_PENTAX_TAG_UNKNOWN_24	= 0x0018,
+	MNOTE_PENTAX_TAG_UNKNOWN_25	= 0x0019,
+	MNOTE_PENTAX_TAG_PRINTIM	= 0x0e00,
+	MNOTE_PENTAX_TAG_TZ_CITY	= 0x1000,
+	MNOTE_PENTAX_TAG_TZ_DST		= 0x1001
+};
+typedef enum _MnotePentaxTag MnotePentaxTag;
+
+const char *mnote_pentax_tag_get_name        (MnotePentaxTag tag);
+const char *mnote_pentax_tag_get_title       (MnotePentaxTag tag);
+const char *mnote_pentax_tag_get_description (MnotePentaxTag tag);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MNOTE_PENTAX_TAG_H__ */