Add files using upload-large-folder tool

local-test-libexif-delta-01-exif-003/afc-libexif/auto-m4/.gitignore

@@ -0,0 +1 @@
+*.m4

local-test-libexif-delta-01-exif-003/afc-libexif/binary-dist/.gitignore

@@ -0,0 +1,2 @@
+Makefile
+Makefile.in

local-test-libexif-delta-01-exif-003/afc-libexif/binary-dist/Makefile.am

@@ -0,0 +1,13 @@
+if SHIP_BINARIES
+
+EXTRA_DIST = include bin
+
+SH_DIST_HOOK = dist-ship-binary-hook
+dist-ship-binary-hook include bin:
+	cd "$(top_builddir)" && $(MAKE) includedir="$(PWD)/include" DESTDIR="" prefix="$(PWD)/tmp" install
+	$(MKDIR_P) "$(PWD)/bin"
+	cp "$(PWD)/tmp/bin/"*.dll "bin/"
+
+endif
+
+dist-hook: $(SH_DIST_HOOK)

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/.gitignore

@@ -0,0 +1,2 @@
+Makefile
+Makefile.in

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/Makefile.am

@@ -0,0 +1,7 @@
+SUBDIRS = examples
+
+# The c++ and aolserver contrib directories are out of date and are
+# are pointless to distribute in the offical source release.
+
+EXTRA_DIST = watcom/Makefile watcom/_stdint.h
+

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/aolserver/nsexif.c

@@ -0,0 +1,143 @@
+/*
+
+Copyright (c) 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.
+
+This is a loadable module for the AOLserver web server that provides
+an interface to the EXIF tag parsing library.
+
+It adds one Tcl command into the AOLserver Tcl interpreter:
+
+  ns_exif <file>
+
+It returns the ID of an ns_set that contains the tag names and values
+from the EXIF file.
+
+*/
+
+#include "ns.h"
+
+#include "exif.h"
+
+#define BUFSIZE  1024
+
+static void
+rec_put(Ns_Set *set, exif_record_t *rec)
+{
+  char buf[BUFSIZE];
+  char *str = buf;
+
+  switch (rec->rec_type) {
+  case 's':
+    str = rec->rec_data.s;
+    break;
+  case 'f':
+    snprintf(buf, BUFSIZE, "%f", rec->rec_data.f);
+    break;
+  case 'g':
+    snprintf(buf, BUFSIZE, "%g", rec->rec_data.f);
+    break;
+  case 'l':
+    snprintf(buf, BUFSIZE, "%ld", rec->rec_data.l);
+    break;
+  case 'r':
+    snprintf(buf, BUFSIZE, "%d/%d", rec->rec_data.r.num,
+	    rec->rec_data.r.denom);
+    break;
+  default:
+    snprintf(buf, BUFSIZE, "<Unknown record type '%c'>", rec->rec_type);
+    break;
+  }
+  Ns_SetPut(set, rec->rec_name, str);
+}
+
+static int
+Tcl_ReadExifDataCmd (
+		     ClientData    clientData,
+		     Tcl_Interp   *interp,
+		     int           argc,
+		     char        **argv)
+{
+  exif_data_t *d;
+  int i;
+  Ns_Set *rset;
+
+  d = exif_parse_file(argv[1]);
+  if (d == NULL) {
+    Tcl_AppendResult(interp, "Could not process file '", argv[1], "'", NULL);
+    return TCL_ERROR;
+  }
+  rset = Ns_SetCreate("exif");
+
+  for (i=0; i<d->n_recs; i++) {
+    rec_put(rset, &d->recs[i]);
+  }
+
+  Ns_TclEnterSet(interp, rset, NS_TCL_SET_TEMPORARY | NS_TCL_SET_DYNAMIC);
+  exif_free_data(d);
+  return TCL_OK;
+}
+
+
+/*----------------------------------------------------------------------
+ *
+ *  Tcl_InitExif --
+ *
+ *  Initialize the Tcl command.
+ *
+ *----------------------------------------------------------------------
+ */
+void
+Tcl_InitExif (interp)
+    Tcl_Interp *interp;
+{
+  Tcl_CreateCommand (interp, "ns_exif", Tcl_ReadExifDataCmd, 
+		     NULL, NULL);
+}
+
+static int
+nsexif_interp_init (Tcl_Interp *interp, void *dummy)
+{
+  Tcl_InitExif(interp);
+  return TCL_OK;
+}
+
+
+int
+Ns_ModuleInit(char *hServer, char *hModule)
+{
+  char *configPath;
+
+  Ns_Log( Notice, "%s module starting", hModule);
+
+  exif_init((void *(*)(int))Ns_Malloc,
+	    (void (*)(void *))Ns_Free,
+	    (void *(*)(void *, int))Ns_Realloc);
+
+  configPath = Ns_ConfigGetPath(hServer, hModule, NULL);
+  /*  if (!Ns_ConfigGetBool (configPath, "Debug", &debug_p))
+      debug_p = DEFAULT_DEBUG; */
+
+  Ns_TclInitInterps (hServer, nsexif_interp_init, NULL);
+  return NS_OK;
+}
+
+int Ns_ModuleVersion = 1;

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/c++/exif.hxx

@@ -0,0 +1,536 @@
+/* exif.hxx
+ *
+ * Copyright  2002,2003 Hans Meine <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef EXIF_HXX
+#define EXIF_HXX
+
+#include <libexif/exif-entry.h>
+#include <libexif/exif-content.h>
+#include <libexif/exif-ifd.h>
+#include <libexif/exif-data.h>
+#include <libexif/exif-format.h>
+#include <libexif/exif-utils.h>
+#include <stdexcept>
+#include <string>
+
+namespace Exif {
+
+#ifndef EXIF_NO_EXCEPTIONS
+struct InvalidIndex : std::runtime_error
+{
+    InvalidIndex(const std::string& s)
+    : std::runtime_error(s) {}
+};
+
+struct InvalidFormat : std::runtime_error
+{
+    InvalidFormat(const std::string& s)
+    : std::runtime_error(s) {}
+};
+
+struct IOError : std::runtime_error
+{
+    IOError(const std::string& s)
+    : std::runtime_error(s) {}
+};
+#endif // EXIF_NO_EXCEPTIONS
+
+struct Entry
+{
+    ExifEntry *entry_;
+
+        // construct an empty entry, FIXME: is this needed in the public API?
+    Entry()
+    : entry_(exif_entry_new())
+    {}
+
+        // construct an entry for the given tag
+    Entry(ExifTag tag)
+    : entry_(exif_entry_new())
+    {
+        exif_entry_initialize(entry_, tag);
+    }
+
+        // copy constructor
+    Entry(Entry const &other)
+    : entry_(other.entry_)
+    {
+        exif_entry_ref(entry_);
+    }
+
+        // internal, do not use directly
+    Entry(ExifEntry *entry)
+    : entry_(entry)
+    {
+        exif_entry_ref(entry_);
+    }
+
+    ~Entry()
+    {
+        exif_entry_unref(entry_);
+    }
+
+    Entry &operator=(Entry const &other)
+    {
+        exif_entry_unref(entry_);
+        entry_ = other.entry_;
+        exif_entry_ref(entry_);
+        return *this;
+    }
+
+    ExifTag tag() const
+    {
+        return entry_->tag;
+    }
+
+/*
+    void setTag(ExifTag tag)
+    {
+        entry_->tag = tag;
+    }
+*/
+
+    ExifFormat format() const
+    {
+        return entry_->format;
+    }
+
+/*
+    void setFormat(ExifFormat format)
+    {
+        entry_->format = format;
+    }
+*/
+
+    unsigned long components() const
+    {
+        return entry_->components;
+    }
+
+/*
+    void setComponents(unsigned long components)
+    {
+        entry_->components = components;
+    }
+
+    void initialize(ExifTag tag)
+    {
+        exif_entry_initialize(entry_, tag);
+    }
+*/
+
+    ExifByte getByte(unsigned int index) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_BYTE)
+            throw InvalidFormat(
+                "Exif::Entry::getByte(): Format is not EXIF_FORMAT_BYTE");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::getByte: component index out of range");
+#endif
+        return *(entry_->data
+                 + index * exif_format_get_size(entry_->format));
+    }
+
+    const ExifAscii getAscii() const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_ASCII)
+            throw InvalidFormat(
+                "Exif::Entry::getAscii(): Format is not EXIF_FORMAT_ASCII");
+#endif
+        return (ExifAscii)entry_->data;
+    }
+
+    ExifShort getShort(unsigned int index) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_SHORT)
+            throw InvalidFormat(
+                "Exif::Entry::getShort(): Format is not EXIF_FORMAT_SHORT");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::getShort: component index out of range");
+#endif
+        return exif_get_short(entry_->data
+                              + index * exif_format_get_size(entry_->format),
+                              exif_data_get_byte_order(entry_->parent->parent));
+    }
+
+    ExifLong getLong(unsigned int index) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_LONG)
+            throw InvalidFormat(
+                "Exif::Entry::getLong(): Format is not EXIF_FORMAT_LONG");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::getLong: component index out of range");
+#endif
+        return exif_get_long(entry_->data
+                             + index * exif_format_get_size(entry_->format),
+                             exif_data_get_byte_order(entry_->parent->parent));
+    }
+
+    ExifSLong getSLong(unsigned int index) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_SLONG)
+            throw InvalidFormat(
+                "Exif::Entry::getSLong(): Format is not EXIF_FORMAT_SLONG");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::getSLong: component index out of range");
+#endif
+        return exif_get_slong(entry_->data
+                              + index * exif_format_get_size(entry_->format),
+                              exif_data_get_byte_order(entry_->parent->parent));
+    }
+
+    ExifRational getRational(unsigned int index) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_RATIONAL)
+            throw InvalidFormat(
+                "Exif::Entry::getRational(): Format is not EXIF_FORMAT_RATIONAL");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::getRational: component index out of range");
+#endif
+        return exif_get_rational(entry_->data
+                                 + index * exif_format_get_size(entry_->format),
+                                 exif_data_get_byte_order(entry_->parent->parent));
+    }
+
+    ExifSRational getSRational(unsigned int index) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_SRATIONAL)
+            throw InvalidFormat(
+                "Exif::Entry::getSRational(): Format is not EXIF_FORMAT_SRATIONAL");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::getSRational: component index out of range");
+#endif
+        return exif_get_srational(entry_->data
+                                  + index * exif_format_get_size(entry_->format),
+                                  exif_data_get_byte_order(entry_->parent->parent));
+    }
+
+    void setByte(unsigned int index, ExifByte value) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_BYTE)
+            throw InvalidFormat(
+                "Exif::Entry::setByte(): Format is not EXIF_FORMAT_BYTE");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::setByte: component index out of range");
+#endif
+        *(entry_->data
+          + index * exif_format_get_size(entry_->format)) = value;
+    }
+
+/*
+    const ExifAscii setAscii() const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_ASCII)
+            throw InvalidFormat(
+                "Exif::Entry::setAscii(): Format is not EXIF_FORMAT_ASCII");
+#endif
+        return (ExifAscii)entry_->data;
+    }
+*/
+
+    void setShort(unsigned int index, ExifShort value) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_SHORT)
+            throw InvalidFormat(
+                "Exif::Entry::setShort(): Format is not EXIF_FORMAT_SHORT");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::setShort: component index out of range");
+#endif
+        return exif_set_short(entry_->data
+                              + index * exif_format_get_size(entry_->format),
+                              exif_data_get_byte_order(entry_->parent->parent),
+                              value);
+    }
+
+    void setLong(unsigned int index, ExifLong value) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_LONG)
+            throw InvalidFormat(
+                "Exif::Entry::setLong(): Format is not EXIF_FORMAT_LONG");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::setLong: component index out of range");
+#endif
+        return exif_set_long(entry_->data
+                             + index * exif_format_get_size(entry_->format),
+                             exif_data_get_byte_order(entry_->parent->parent),
+                             value);
+    }
+
+    void setSLong(unsigned int index, ExifSLong value) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_SLONG)
+            throw InvalidFormat(
+                "Exif::Entry::setSLong(): Format is not EXIF_FORMAT_SLONG");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::setSLong: component index out of range");
+#endif
+        return exif_set_slong(entry_->data
+                              + index * exif_format_get_size(entry_->format),
+                              exif_data_get_byte_order(entry_->parent->parent),
+                              value);
+    }
+
+    void setRational(unsigned int index, ExifRational value) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_RATIONAL)
+            throw InvalidFormat(
+                "Exif::Entry::setRational(): Format is not EXIF_FORMAT_RATIONAL");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::setRational: component index out of range");
+#endif
+        return exif_set_rational(entry_->data
+                                 + index * exif_format_get_size(entry_->format),
+                                 exif_data_get_byte_order(entry_->parent->parent),
+                                 value);
+    }
+
+    void setSRational(unsigned int index, ExifSRational value) const
+    {
+#ifndef EXIF_NO_EXCEPTIONS
+        if(entry_->format != EXIF_FORMAT_SRATIONAL)
+            throw InvalidFormat(
+                "Exif::Entry::setSRational(): Format is not EXIF_FORMAT_SRATIONAL");
+        if(index >= components())
+            throw InvalidIndex(
+                "Exif::setSRational: component index out of range");
+#endif
+        return exif_set_srational(entry_->data
+                                  + index * exif_format_get_size(entry_->format),
+                                  exif_data_get_byte_order(entry_->parent->parent),
+                                  value);
+    }
+
+    const char *value()
+    {
+        return exif_entry_get_value(entry_);
+    }
+
+    const char *briefValue()
+    {
+        return exif_entry_get_value_brief(entry_);
+    }
+
+    void dump(unsigned int indent = 0) const
+    {
+        exif_entry_dump(entry_, indent);
+    }
+};
+
+struct Content
+{
+    ExifContent *content_;
+
+    Content()
+    : content_(exif_content_new())
+    {}
+
+    Content(Content const &other)
+    : content_(other.content_)
+    {
+        exif_content_ref(content_);
+    }
+
+        // internal, do not use directly
+    Content(ExifContent *content)
+    : content_(content)
+    {
+        exif_content_ref(content_);
+    }
+
+    ~Content()
+    {
+        exif_content_unref(content_);
+    }
+
+    Content &operator=(Content const &other)
+    {
+        exif_content_unref(content_);
+        content_ = other.content_;
+        exif_content_ref(content_);
+        return *this;
+    }
+
+    Entry operator[](ExifTag tag)
+    {
+        ExifEntry *result = exif_content_get_entry(content_, tag);
+        if(result)
+            return Entry(result);
+#ifndef EXIF_NO_EXCEPTIONS
+        throw InvalidIndex(
+            "Exif::Content: IFD does not contain given tag");
+#endif
+        return Entry();
+    }
+
+    Entry operator[](unsigned int index)
+    {
+        if(index < size())
+            return Entry(content_->entries[index]);
+#ifndef EXIF_NO_EXCEPTIONS
+        throw InvalidIndex(
+            "Exif::Content: numeric entry index out of range");
+#endif // EXIF_NO_EXCEPTIONS
+        return Entry();
+    }
+
+    unsigned int size() const
+    {
+        // FIXME: content_ should never be NULL, so this is unneeded!?
+        return content_ ? content_->count : 0;
+    }
+
+    void add(Entry &entry)
+    {
+        exif_content_add_entry(content_, entry.entry_);
+    }
+
+    void remove(Entry &entry)
+    {
+        exif_content_remove_entry(content_, entry.entry_);
+    }
+
+        // for your convenience
+    const char *value(ExifTag tag)
+    {
+        return exif_content_get_value(content_, tag);
+    }
+
+        // for your convenience
+    const char *briefValue(ExifTag tag)
+    {
+        return exif_content_get_value_brief(content_, tag);
+    }
+
+    void dump(unsigned int indent = 0) const
+    {
+        exif_content_dump(content_, indent);
+    }
+};
+
+struct Data
+{
+    ExifData *data_;
+
+    Data()
+    : data_(exif_data_new())
+    {}
+
+    Data(const char *path, bool *success = 0)
+    : data_(exif_data_new_from_file(path))
+    {
+        if(success)
+            *success = data_;
+#ifndef EXIF_NO_EXCEPTIONS
+        else
+            if(!data_)
+                throw IOError("Exif::Data: Could not load file");
+#endif // EXIF_NO_EXCEPTIONS
+        if(!data_)
+            exif_data_new();
+    }
+
+    Data(const unsigned char *data,
+         unsigned int size)
+    : data_(exif_data_new_from_data(data, size))
+    {}
+
+    Data(Data const &other)
+    : data_(other.data_)
+    {
+        exif_data_ref(data_);
+    }
+
+    ~Data()
+    {
+        exif_data_unref(data_);
+    }
+
+    Data &operator=(Data const &other)
+    {
+        exif_data_unref(data_);
+        data_ = other.data_;
+        exif_data_ref(data_);
+        return *this;
+    }
+
+    void save(unsigned char **d, unsigned int *size)
+    {
+        exif_data_save_data(data_, d, size);
+    }
+
+    unsigned int size() const
+    {
+        return EXIF_IFD_COUNT;
+    }
+
+    Content operator[](unsigned int index)
+    {
+        if(index < size())
+            return Content(data_->ifd[index]);
+#ifndef EXIF_NO_EXCEPTIONS
+        throw InvalidIndex(
+            "Exif::Data: IFD index out of range");
+#endif // EXIF_NO_EXCEPTIONS
+        return Content();
+    }
+
+    ExifByteOrder byteOrder() const
+    {
+        return exif_data_get_byte_order(data_);
+    }
+
+    void setByteOrder(ExifByteOrder bo) const
+    {
+        exif_data_set_byte_order(data_, bo);
+    }
+
+    void dump()
+    {
+        exif_data_dump(data_);
+    }
+};
+
+} // namespace Exif
+
+#endif // EXIF_HXX

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/c++/exif_module.cxx

@@ -0,0 +1,524 @@
+/* exif-content.c
+ *
+ * Copyright  2002,2003 Hans Meine <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include "exif.hxx"
+#include <string>
+#include <iostream>
+
+#include <Python.h>
+#include <boost/python.hpp>
+using namespace boost::python;
+
+template<class Wrapper, class Pointer>
+struct WrappedObjectIterator
+{
+	//typedef Wrapper value_type;
+	Pointer *it_, *end_;
+
+	WrappedObjectIterator(Pointer *it, Pointer *end)
+		: it_(it), end_(end)
+	{}
+
+	Wrapper next()
+	{
+		if(it_ == end_)
+		{
+			PyErr_SetString(PyExc_StopIteration, "iterator exhausted");
+			throw_error_already_set();
+		}
+		return Wrapper(*it_++);
+	}
+};
+
+struct PythonEntry : public Exif::Entry
+{
+	PythonEntry() {}
+	PythonEntry(Exif::Entry const &other) : Exif::Entry(other) {}
+
+	object component(long index) const
+	{
+		switch(format())
+		{
+		case EXIF_FORMAT_BYTE:
+			return object(getByte(index));
+		case EXIF_FORMAT_SHORT:
+			return object(getShort(index));
+		case EXIF_FORMAT_LONG:
+			return object(getLong(index));
+		case EXIF_FORMAT_SLONG:
+			return object(getSLong(index));
+		case EXIF_FORMAT_RATIONAL:
+			return object(getRational(index));
+		case EXIF_FORMAT_SRATIONAL:
+			return object(getSRational(index));
+		case EXIF_FORMAT_ASCII:
+			//std::cerr << "returning " << entry_->size << " bytes of data..\n";
+			//std::cerr << " (copied into " << std::string((char *)data, entry_->size).size() << "-character string)\n";
+			return object(std::string((char *)entry_->data, entry_->size));
+		default:
+			break;
+		}
+		return object();
+	}
+
+	object data() const
+	{
+		if((format() == EXIF_FORMAT_ASCII) || (components()==1))
+			return component(0);
+		else
+		{
+			list result;
+			for(unsigned int i=0; i<components(); ++i)
+				result.append(component(i));
+			return result;
+		}
+	}
+
+	template<class Type>
+	Type extractComponent(unsigned int index, object value,
+						  const char *errorString)
+	{
+		extract<Type> extr(value);
+		if(!extr.check())
+		{
+			PyErr_SetString(PyExc_TypeError, errorString);
+			throw_error_already_set();
+		}
+		return extr();
+	}
+
+	void setComponent(unsigned int index, object value)
+	{
+		unsigned char *data= entry_->data
+							 + index * exif_format_get_size(format());
+		ExifByteOrder bo = exif_data_get_byte_order(entry_->parent->parent);
+
+		switch(format())
+		{
+		case EXIF_FORMAT_BYTE:
+			*data= extractComponent<ExifByte>(index, value, "invalid assignment to data: could not convert value to byte format");
+			break;
+		case EXIF_FORMAT_SHORT:
+			exif_set_short(data, bo, extractComponent<ExifShort>(index, value, "invalid assignment to data: could not convert value to short format"));
+			break;
+		case EXIF_FORMAT_LONG:
+			exif_set_long(data, bo, extractComponent<ExifLong>(index, value, "invalid assignment to data: could not convert value to long format"));
+			break;
+		case EXIF_FORMAT_SLONG:
+			exif_set_slong(data, bo, extractComponent<ExifSLong>(index, value, "invalid assignment to data: could not convert value to signed long format"));
+			break;
+		case EXIF_FORMAT_RATIONAL:
+			exif_set_rational(data, bo, extractComponent<ExifRational>(index, value, "invalid assignment to data: could not convert value to rational format (2-tuple expected)"));
+			break;
+		case EXIF_FORMAT_SRATIONAL:
+			exif_set_srational(data, bo, extractComponent<ExifSRational>(index, value, "invalid assignment to data: could not convert value to signed rational format (2-tuple expected)"));
+			break;
+		case EXIF_FORMAT_ASCII: // handled in setData directly
+		case EXIF_FORMAT_UNDEFINED:
+			break;
+		}
+		return;
+	}
+
+	void setData(object data)
+	{
+		if(format() == EXIF_FORMAT_ASCII)
+		{
+			extract<std::string> xstr(data);
+			if(xstr.check())
+			{
+				std::string s= xstr();
+				if(entry_->data)
+					free(entry_->data);
+				entry_->components= s.size();
+				//std::cerr << "assigning " << s.size() << "-character string..\n";
+				entry_->size=
+					exif_format_get_size(format()) * entry_->components;
+				entry_->data= (unsigned char *)malloc(entry_->size);
+				memcpy(entry_->data, s.data(), entry_->size);
+				entry_->data[entry_->size]= 0;
+			}
+			else
+			{
+				PyErr_SetString(PyExc_TypeError,
+								"invalid assignment to data of ASCII format entry: string expected");
+				throw_error_already_set();
+			}
+		}
+		else
+		{
+			if(components()==1)
+				setComponent(0, data);
+			else
+			{
+				extract<list> xlist(data);
+				if(xlist.check())
+				{
+					list l= xlist();
+					for(unsigned i=0; i<components(); ++i)
+						setComponent(i, l[i]);
+				}
+				else
+				{
+					PyErr_SetString(PyExc_TypeError,
+									"invalid assignment to data of entry with more than one component: list expected");
+					throw_error_already_set();
+				}
+			}
+		}
+	}
+};
+
+struct PythonContent : public Exif::Content
+{
+	typedef WrappedObjectIterator<PythonEntry, ExifEntry *> iterator;
+
+	PythonContent() {}
+	PythonContent(Exif::Content const &other) : Exif::Content(other) {}
+
+	PythonEntry entry(object index)
+	{
+		// TODO: use Exif::Content::entry() functions
+
+		extract<ExifTag> xtag(index);
+		if(xtag.check())
+		{
+			ExifTag index= xtag();
+			for(unsigned int i=0; i<size(); i++)
+			{
+				if(content_->entries[i]->tag == index)
+					return Exif::Entry(content_->entries[i]);
+			}
+			PyErr_SetString(PyExc_KeyError,
+							"tag not present in IFD content");
+			throw_error_already_set();
+		}
+		extract<int> xint(index);
+		if(xint.check())
+		{
+			int index= xint();
+			if((index>=0) && (index<(long)size()))
+				return Exif::Entry(content_->entries[index]);
+			if((index<0) && (index>=-(long)size()))
+				return Exif::Entry(content_->entries[size()+index]);
+			PyErr_SetString(PyExc_IndexError,
+							"invalid integer index into IFD content");
+			throw_error_already_set();
+		}
+		PyErr_SetString(PyExc_TypeError,
+						"invalid index into EXIF data (integer or IFD expected)");
+		throw_error_already_set();
+		return Exif::Entry(); // never reached
+	}
+
+	iterator __iter__()
+	{
+		// FIXME: the public API is exif_content_foreach,
+		// relying on memory layout here!
+		return iterator(content_->entries,
+						content_->entries + content_->count);
+	}
+};
+
+struct PythonData : public Exif::Data
+{
+	typedef WrappedObjectIterator<PythonContent, ExifContent *> iterator;
+	bool success_;
+
+	PythonData() {}
+	PythonData(const char *path)
+	: Exif::Data(path, &success_)
+	{
+		if(!success_)
+		{
+			PyErr_SetFromErrno(PyExc_IOError);
+			//PyErr_SetString(PyExc_IOError, "");
+			throw_error_already_set();
+		}
+	}
+	PythonData(const unsigned char *data,
+			   unsigned int size) : Exif::Data(data, size) {}
+	PythonData(Exif::Data const &other) : Exif::Data(other) {}
+
+	PythonContent ifdContent(object index)
+	{
+		extract<ExifIfd> xifd(index);
+		if(xifd.check())
+		{
+			ExifIfd index= xifd();
+			if(index<EXIF_IFD_COUNT)
+				return Exif::Content(data_->ifd[index]);
+			PyErr_SetString(PyExc_IndexError,
+							"invalid IFD index into EXIF data");
+			throw_error_already_set();
+		}
+		extract<int> xint(index);
+		if(xint.check())
+		{
+			int index= xint();
+			if((index>=0) && (index<(long)size()))
+				return Exif::Content(data_->ifd[index]);
+			if((index<0) && (index>=-(long)size()))
+				return Exif::Content(data_->ifd[size()+index]);
+			PyErr_SetString(PyExc_IndexError,
+							"invalid integer index into EXIF data");
+			throw_error_already_set();
+		}
+		PyErr_SetString(PyExc_TypeError,
+						"invalid index into EXIF data (integer or IFD expected)");
+		throw_error_already_set();
+		return Exif::Content(); // never reached
+	}
+
+	iterator __iter__()
+	{
+		return iterator(data_->ifd, data_->ifd + EXIF_IFD_COUNT);
+	}
+};
+
+template<class Rational, class Component>
+struct RationalConverter
+{
+	RationalConverter()
+	{
+		converter::registry::insert(&convertible, &construct,
+									type_id<Rational>());
+	}
+
+    static void* convertible(PyObject* obj)
+    {
+		extract<tuple> xtup(obj);
+		if(xtup.check())
+		{
+			tuple t= xtup();
+			if((t.attr("__len__")() == 2) &&
+			   extract<Component>(t[0]).check() &&
+			   extract<Component>(t[1]).check())
+			{
+				Rational *result = new Rational;
+				result->numerator =   extract<Component>(t[0])();
+				result->denominator = extract<Component>(t[1])();
+				return result;
+			}
+		}
+		return NULL;
+    }
+
+    static void construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data)
+    {
+		Rational const* r =
+			static_cast<Rational*>(data->convertible);
+        void* storage =
+			((converter::rvalue_from_python_storage<Rational>*)data)->storage.bytes;
+        new (storage) Rational();
+		((Rational*)storage)->numerator = r->numerator;
+		((Rational*)storage)->denominator = r->denominator;
+        data->convertible = storage;
+		delete r;
+	}
+
+	static PyObject *convert(Rational r)
+	{
+		tuple t= make_tuple(r.numerator, r.denominator);
+		PyObject *result= t.ptr();
+		Py_INCREF(result);
+		return result;
+	}
+};
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(entrydumps, Exif::Entry::dump, 0, 1)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(contentdumps, Exif::Content::dump, 0, 1)
+
+BOOST_PYTHON_MODULE(exif)
+{
+	RationalConverter<ExifRational, ExifLong>();
+	RationalConverter<ExifSRational, ExifSLong>();
+	to_python_converter<ExifRational,
+		RationalConverter<ExifRational, ExifLong> >();
+	to_python_converter<ExifSRational,
+		RationalConverter<ExifSRational, ExifSLong> >();
+
+	enum_<ExifByteOrder>("ByteOrder")
+		.value("MOTOROLA", EXIF_BYTE_ORDER_MOTOROLA)
+		.value("INTEL", EXIF_BYTE_ORDER_INTEL);
+
+	def("name", &exif_byte_order_get_name);
+
+	enum_<ExifIfd>("IFD")
+		.value("ZERO", EXIF_IFD_0)
+		.value("ONE", EXIF_IFD_1)
+		.value("EXIF", EXIF_IFD_EXIF)
+		.value("GPS", EXIF_IFD_GPS)
+		.value("INTEROPERABILITY", EXIF_IFD_INTEROPERABILITY);
+	//.value("COUNT", EXIF_IFD_COUNT)
+
+	def("name", &exif_ifd_get_name);
+
+	enum_<ExifFormat>("Format")
+		.value("BYTE", EXIF_FORMAT_BYTE)
+		.value("ASCII", EXIF_FORMAT_ASCII)
+		.value("SHORT", EXIF_FORMAT_SHORT)
+		.value("LONG", EXIF_FORMAT_LONG)
+		.value("RATIONAL", EXIF_FORMAT_RATIONAL)
+		.value("UNDEFINED", EXIF_FORMAT_UNDEFINED)
+		.value("SLONG", EXIF_FORMAT_SLONG)
+		.value("SRATIONAL", EXIF_FORMAT_SRATIONAL);
+
+	def("name", &exif_format_get_name);
+	def("size", &exif_format_get_size);
+
+	enum_<ExifTag>("Tag")
+		.value("INTEROPERABILITY_INDEX", EXIF_TAG_INTEROPERABILITY_INDEX)
+		.value("INTEROPERABILITY_VERSION", EXIF_TAG_INTEROPERABILITY_VERSION)
+		.value("IMAGE_WIDTH", EXIF_TAG_IMAGE_WIDTH)
+		.value("IMAGE_LENGTH", EXIF_TAG_IMAGE_LENGTH)
+		.value("BITS_PER_SAMPLE", EXIF_TAG_BITS_PER_SAMPLE)
+		.value("COMPRESSION", EXIF_TAG_COMPRESSION)
+		.value("PHOTOMETRIC_INTERPRETATION", EXIF_TAG_PHOTOMETRIC_INTERPRETATION)
+		.value("FILL_ORDER", EXIF_TAG_FILL_ORDER)
+		.value("DOCUMENT_NAME", EXIF_TAG_DOCUMENT_NAME)
+		.value("IMAGE_DESCRIPTION", EXIF_TAG_IMAGE_DESCRIPTION)
+		.value("MAKE", EXIF_TAG_MAKE)
+		.value("MODEL", EXIF_TAG_MODEL)
+		.value("STRIP_OFFSETS", EXIF_TAG_STRIP_OFFSETS)
+		.value("ORIENTATION", EXIF_TAG_ORIENTATION)
+		.value("SAMPLES_PER_PIXEL", EXIF_TAG_SAMPLES_PER_PIXEL)
+		.value("ROWS_PER_STRIP", EXIF_TAG_ROWS_PER_STRIP)
+		.value("STRIP_BYTE_COUNTS", EXIF_TAG_STRIP_BYTE_COUNTS)
+		.value("X_RESOLUTION", EXIF_TAG_X_RESOLUTION)
+		.value("Y_RESOLUTION", EXIF_TAG_Y_RESOLUTION)
+		.value("PLANAR_CONFIGURATION", EXIF_TAG_PLANAR_CONFIGURATION)
+		.value("RESOLUTION_UNIT", EXIF_TAG_RESOLUTION_UNIT)
+		.value("TRANSFER_FUNCTION", EXIF_TAG_TRANSFER_FUNCTION)
+		.value("SOFTWARE", EXIF_TAG_SOFTWARE)
+		.value("DATE_TIME", EXIF_TAG_DATE_TIME)
+		.value("ARTIST", EXIF_TAG_ARTIST)
+		.value("WHITE_POINT", EXIF_TAG_WHITE_POINT)
+		.value("PRIMARY_CHROMATICITIES", EXIF_TAG_PRIMARY_CHROMATICITIES)
+		.value("TRANSFER_RANGE", EXIF_TAG_TRANSFER_RANGE)
+		.value("JPEG_PROC", EXIF_TAG_JPEG_PROC)
+		.value("JPEG_INTERCHANGE_FORMAT", EXIF_TAG_JPEG_INTERCHANGE_FORMAT)
+		.value("JPEG_INTERCHANGE_FORMAT_LENGTH", EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH)
+		.value("YCBCR_COEFFICIENTS", EXIF_TAG_YCBCR_COEFFICIENTS)
+		.value("YCBCR_SUB_SAMPLING", EXIF_TAG_YCBCR_SUB_SAMPLING)
+		.value("YCBCR_POSITIONING", EXIF_TAG_YCBCR_POSITIONING)
+		.value("REFERENCE_BLACK_WHITE", EXIF_TAG_REFERENCE_BLACK_WHITE)
+		.value("RELATED_IMAGE_FILE_FORMAT", EXIF_TAG_RELATED_IMAGE_FILE_FORMAT)
+		.value("RELATED_IMAGE_WIDTH", EXIF_TAG_RELATED_IMAGE_WIDTH)
+		.value("RELATED_IMAGE_LENGTH", EXIF_TAG_RELATED_IMAGE_LENGTH)
+		.value("CFA_REPEAT_PATTERN_DIM", EXIF_TAG_CFA_REPEAT_PATTERN_DIM)
+		.value("CFA_PATTERN", EXIF_TAG_CFA_PATTERN)
+		.value("BATTERY_LEVEL", EXIF_TAG_BATTERY_LEVEL)
+		.value("COPYRIGHT", EXIF_TAG_COPYRIGHT)
+		.value("EXPOSURE_TIME", EXIF_TAG_EXPOSURE_TIME)
+		.value("FNUMBER", EXIF_TAG_FNUMBER)
+		.value("IPTC_NAA", EXIF_TAG_IPTC_NAA)
+		.value("EXIF_IFD_POINTER", EXIF_TAG_EXIF_IFD_POINTER)
+		.value("INTER_COLOR_PROFILE", EXIF_TAG_INTER_COLOR_PROFILE)
+		.value("EXPOSURE_PROGRAM", EXIF_TAG_EXPOSURE_PROGRAM)
+		.value("SPECTRAL_SENSITIVITY", EXIF_TAG_SPECTRAL_SENSITIVITY)
+		.value("GPS_INFO_IFD_POINTER", EXIF_TAG_GPS_INFO_IFD_POINTER)
+		.value("ISO_SPEED_RATINGS", EXIF_TAG_ISO_SPEED_RATINGS)
+		.value("OECF", EXIF_TAG_OECF)
+		.value("EXIF_VERSION", EXIF_TAG_EXIF_VERSION)
+		.value("DATE_TIME_ORIGINAL", EXIF_TAG_DATE_TIME_ORIGINAL)
+		.value("DATE_TIME_DIGITIZED", EXIF_TAG_DATE_TIME_DIGITIZED)
+		.value("COMPONENTS_CONFIGURATION", EXIF_TAG_COMPONENTS_CONFIGURATION)
+		.value("COMPRESSED_BITS_PER_PIXEL", EXIF_TAG_COMPRESSED_BITS_PER_PIXEL)
+		.value("SHUTTER_SPEED_VALUE", EXIF_TAG_SHUTTER_SPEED_VALUE)
+		.value("APERTURE_VALUE", EXIF_TAG_APERTURE_VALUE)
+		.value("BRIGHTNESS_VALUE", EXIF_TAG_BRIGHTNESS_VALUE)
+		.value("EXPOSURE_BIAS_VALUE", EXIF_TAG_EXPOSURE_BIAS_VALUE)
+		.value("MAX_APERTURE_VALUE", EXIF_TAG_MAX_APERTURE_VALUE)
+		.value("SUBJECT_DISTANCE", EXIF_TAG_SUBJECT_DISTANCE)
+		.value("METERING_MODE", EXIF_TAG_METERING_MODE)
+		.value("LIGHT_SOURCE", EXIF_TAG_LIGHT_SOURCE)
+		.value("FLASH", EXIF_TAG_FLASH)
+		.value("FOCAL_LENGTH", EXIF_TAG_FOCAL_LENGTH)
+		.value("SUBJECT_AREA", EXIF_TAG_SUBJECT_AREA)
+		.value("MAKER_NOTE", EXIF_TAG_MAKER_NOTE)
+		.value("USER_COMMENT", EXIF_TAG_USER_COMMENT)
+		.value("SUBSEC_TIME", EXIF_TAG_SUBSEC_TIME)
+		.value("SUB_SEC_TIME_ORIGINAL", EXIF_TAG_SUB_SEC_TIME_ORIGINAL)
+		.value("SUB_SEC_TIME_DIGITIZED", EXIF_TAG_SUB_SEC_TIME_DIGITIZED)
+		.value("FLASH_PIX_VERSION", EXIF_TAG_FLASH_PIX_VERSION)
+		.value("COLOR_SPACE", EXIF_TAG_COLOR_SPACE)
+		.value("PIXEL_X_DIMENSION", EXIF_TAG_PIXEL_X_DIMENSION)
+		.value("PIXEL_Y_DIMENSION", EXIF_TAG_PIXEL_Y_DIMENSION)
+		.value("RELATED_SOUND_FILE", EXIF_TAG_RELATED_SOUND_FILE)
+		.value("INTEROPERABILITY_IFD_POINTER", EXIF_TAG_INTEROPERABILITY_IFD_POINTER)
+		.value("FLASH_ENERGY", EXIF_TAG_FLASH_ENERGY)
+		.value("SPATIAL_FREQUENCY_RESPONSE", EXIF_TAG_SPATIAL_FREQUENCY_RESPONSE)
+		.value("FOCAL_PLANE_X_RESOLUTION", EXIF_TAG_FOCAL_PLANE_X_RESOLUTION)
+		.value("FOCAL_PLANE_Y_RESOLUTION", EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION)
+		.value("FOCAL_PLANE_RESOLUTION_UNIT", EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT)
+		.value("SUBJECT_LOCATION", EXIF_TAG_SUBJECT_LOCATION)
+		.value("EXPOSURE_INDEX", EXIF_TAG_EXPOSURE_INDEX)
+		.value("SENSING_METHOD", EXIF_TAG_SENSING_METHOD)
+		.value("FILE_SOURCE", EXIF_TAG_FILE_SOURCE)
+		.value("SCENE_TYPE", EXIF_TAG_SCENE_TYPE)
+		.value("NEW_CFA_PATTERN", EXIF_TAG_NEW_CFA_PATTERN)
+		.value("CUSTOM_RENDERED", EXIF_TAG_CUSTOM_RENDERED)
+		.value("EXPOSURE_MODE", EXIF_TAG_EXPOSURE_MODE)
+		.value("WHITE_BALANCE", EXIF_TAG_WHITE_BALANCE)
+		.value("DIGITAL_ZOOM_RATIO", EXIF_TAG_DIGITAL_ZOOM_RATIO)
+		.value("FOCAL_LENGTH_IN_35MM_FILM", EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM)
+		.value("SCENE_CAPTURE_TYPE", EXIF_TAG_SCENE_CAPTURE_TYPE)
+		.value("GAIN_CONTROL", EXIF_TAG_GAIN_CONTROL)
+		.value("CONTRAST", EXIF_TAG_CONTRAST)
+		.value("SATURATION", EXIF_TAG_SATURATION)
+		.value("SHARPNESS", EXIF_TAG_SHARPNESS)
+		.value("DEVICE_SETTING_DESCRIPTION", EXIF_TAG_DEVICE_SETTING_DESCRIPTION)
+		.value("SUBJECT_DISTANCE_RANGE", EXIF_TAG_SUBJECT_DISTANCE_RANGE)
+		.value("IMAGE_UNIQUE_ID", EXIF_TAG_IMAGE_UNIQUE_ID);
+
+	def("name", &exif_tag_get_name);
+	def("title", &exif_tag_get_title);
+	def("description", &exif_tag_get_description);
+
+	class_<PythonEntry>("Entry")
+		.add_property("tag", &Exif::Entry::tag)
+		.add_property("format", &Exif::Entry::format)
+		.add_property("components", &Exif::Entry::components)
+		.add_property("data", &PythonEntry::data,
+					  &PythonEntry::setData)
+		.def("value", &Exif::Entry::value)
+		.def("briefValue", &Exif::Entry::briefValue)
+		.def("dump", &Exif::Entry::dump);//, entrydumps());
+
+	class_<PythonContent::iterator>("ContentIterator", no_init)
+		.def("next", &PythonContent::iterator::next);
+	class_<PythonContent>("Content")
+		.def("__len__", &Exif::Content::size)
+		.def("__getitem__", &PythonContent::entry)
+		.def("__iter__", &PythonContent::__iter__)
+ 		.def("dump", &Exif::Content::dump);//, contentdumps());
+
+	class_<PythonData::iterator>("DataIterator", no_init)
+		.def("next", &PythonData::iterator::next);
+	class_<PythonData>("Data")
+		.def(init<const char *>())
+		.def(init<const unsigned char *, unsigned int>())
+		.def("__len__", &Exif::Data::size)
+		.def("__getitem__", &PythonData::ifdContent)
+		.def("__iter__", &PythonData::__iter__)
+		.def("byteOrder", &Exif::Data::byteOrder)
+		.def("dump", &Exif::Data::dump);
+}

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/examples/.gitignore

@@ -0,0 +1,2 @@
+Makefile
+Makefile.in

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/examples/Makefile.am

@@ -0,0 +1,11 @@
+# Simple example programs
+check_PROGRAMS = photographer thumbnail write-exif
+
+# Example programs with dependencies other than plain libexif
+COMPLICATED_EXAMPLES = cam_features.c
+
+# Build just the simple examples as a sanity check, but include them all in
+# the source archive
+
+EXTRA_DIST = $(COMPLICATED_EXAMPLES)
+LDADD = $(top_builddir)/libexif/libexif.la

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/examples/cam_features.c

@@ -0,0 +1,175 @@
+/***************************************************************************
+ *            cam_features.c
+ *
+ *  Wed Jul 27 11:25:09 2005
+ *  Copyright  2005  User: Naysawn Naderi
+ *  Email: ndn at xiphos dot ca
+ *
+ * Uses libdc1394 and libraw1394
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <sys/times.h>
+#include <errno.h>
+
+#include <libraw1394/raw1394.h>
+#include <libdc1394/dc1394_control.h>
+#include <libdc1394/dc1394_register.h>
+
+//EXIF includes
+#include <libexif/exif-data.h>
+#include <libexif/exif-ifd.h>
+#include <libexif/exif-loader.h>
+
+// Part of the exif command-line source package
+#include "libjpeg/jpeg-data.h"
+
+
+#define FILENAME "test.jpg"
+
+
+static int createEXIF(dc1394featureset_t *xFeatures, ExifData ** pParentEd);
+
+
+int main(int argc, char *argv[])
+{   dc1394camera_t *pCamera, **pCameras=NULL;
+    int iNumCameras;
+    dc1394featureset_t xFeatures;
+    int i;
+    int err=dc1394_find_cameras(&pCameras, &iNumCameras);
+
+    //EXIF STUFF
+    JPEGData *pData;
+    //float fOnefloat;
+    ExifData * pEd;
+
+
+    if (err!=DC1394_SUCCESS) {
+        fprintf( stderr, "Unable to look for cameras\n\n"
+            "Please check \n"
+            "  - if the kernel modules `ieee1394',`raw1394' and `ohci1394' are loaded \n"
+            "  - if you have read/write access to /dev/raw1394\n\n");
+        exit(1);
+    }
+
+
+    /*-----------------------------------------------------------------------
+     *  Initialize the camera
+     *-----------------------------------------------------------------------*/
+    if (iNumCameras<1) {
+        fprintf(stderr, "no cameras found :(\n");
+        exit(1);
+    }
+    pCamera=pCameras[0];
+    for (i=1;i<iNumCameras;i++)
+        dc1394_free_camera(pCameras[i]);
+    free(pCameras);
+
+    if(dc1394_get_camera_feature_set(pCamera, &xFeatures)!=DC1394_SUCCESS)
+            fprintf(stdout, "unable to get feature set\n");
+    else
+            printf("camera's feature set retrieved\n");
+
+    createEXIF(&xFeatures, &pEd);  //tag the file with the settings of the camera
+
+    //exif_data_dump (pEd);
+
+    //write the Exif data to a jpeg file
+    pData = jpeg_data_new_from_file (FILENAME);  //input data
+    if (!pData) {
+        printf ("Could not load '%s'!\n", FILENAME);
+        return (-1);
+    }
+
+    printf("Saving EXIF data to jpeg file\n");
+    jpeg_data_set_exif_data (pData, pEd);
+    printf("Set the data\n");
+    jpeg_data_save_file(pData, "foobar2.jpg");
+
+    return 0;
+
+}
+
+
+int createEXIF(dc1394featureset_t *xFeatures, ExifData ** pParentEd)
+{
+    ExifEntry *pE;
+    ExifData * pEd;
+    int i = !xFeatures->feature[DC1394_FEATURE_WHITE_BALANCE - DC1394_FEATURE_MIN].auto_active;
+
+    ExifSRational xR = {xFeatures->feature[DC1394_FEATURE_BRIGHTNESS - DC1394_FEATURE_MIN].value, xFeatures->feature[DC1394_FEATURE_BRIGHTNESS - DC1394_FEATURE_MIN].max};;
+
+    printf ("Creating EXIF data...\n");
+    pEd = exif_data_new ();
+
+    /*
+
+    Things to tag:
+
+    EXIF_TAG_MAKE               = 0x010f,
+    EXIF_TAG_MODEL              = 0x0110,
+    EXIF_TAG_EXPOSURE_TIME      = 0x829a,
+    EXIF_TAG_BRIGHTNESS_VALUE   = 0x9203,
+    EXIF_TAG_WHITE_BALANCE      = 0xa403,
+    EXIF_TAG_GAIN_CONTROL       = 0xa407,
+    EXIF_TAG_CONTRAST           = 0xa408,
+    EXIF_TAG_SATURATION         = 0xa409,
+    EXIF_TAG_SHARPNESS          = 0xa40a,
+    EXIF_TAG_USER_COMMENT
+    */
+
+    printf ("Adding a Make reference\n");
+    pE = exif_entry_new ();
+    exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
+    exif_entry_initialize (pE, EXIF_TAG_MAKE);
+    pE->data="AVT";
+    exif_entry_unref (pE);
+
+    printf ("Adding a Model reference\n");
+    pE = exif_entry_new ();
+    exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
+    exif_entry_initialize (pE, EXIF_TAG_MODEL);
+    pE->data="510c";
+    exif_entry_unref (pE);
+
+    printf ("Adding a Tag to reference # samples per pixel\n");
+    pE = exif_entry_new ();
+    exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
+    exif_entry_initialize (pE, EXIF_TAG_SAMPLES_PER_PIXEL); //by default is 3
+    exif_entry_unref (pE);
+
+    printf ("Adding a White Balance Reference\n");
+    pE = exif_entry_new ();
+    exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
+    exif_entry_initialize (pE, EXIF_TAG_WHITE_BALANCE);
+    exif_set_short(pE->data, exif_data_get_byte_order (pEd), i);  //0=auto white balance, 1 = manual white balance
+    exif_entry_unref (pE);
+
+    //need to create logic according to the value of the sharpness
+    printf ("Adding a Sharpness Reference\n");
+    pE = exif_entry_new ();
+    exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
+    exif_entry_initialize (pE, EXIF_TAG_SHARPNESS);
+    exif_set_short(pE->data, exif_data_get_byte_order (pEd), 0);
+    exif_entry_unref (pE);
+
+    printf ("Adding a Brightness reference\n");
+
+    //try to get brightness
+    //printf("Float Value: %i\n",xFeatures->feature[DC1394_FEATURE_BRIGHTNESS - DC1394_FEATURE_MIN].value);
+
+    pE = exif_entry_new ();
+    exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
+    exif_entry_initialize (pE, EXIF_TAG_BRIGHTNESS_VALUE);
+    exif_set_srational (pE->data, exif_data_get_byte_order (pEd), xR);
+
+
+    //exif_data_dump (ed);
+    //exif_data_dump (pEd);
+    *pParentEd = pEd;
+    printf("Done!\n");
+
+    return 0;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/examples/photographer.c

@@ -0,0 +1,125 @@
+/*
+ * libexif example program to display the contents of a number of specific
+ * EXIF and MakerNote tags. The tags selected are those that may aid in
+ * identification of the photographer who took the image.
+ *
+ * Placed into the public domain by Dan Fandrich
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <libexif/exif-data.h>
+
+/* Remove spaces on the right of the string */
+static void trim_spaces(char *buf)
+{
+    char *s = buf-1;
+    for (; *buf; ++buf) {
+        if (*buf != ' ')
+            s = buf;
+    }
+    *++s = 0; /* nul terminate the string on the first of the final spaces */
+}
+
+/* Show the tag name and contents if the tag exists */
+static void show_tag(ExifData *d, ExifIfd ifd, ExifTag tag)
+{
+    /* See if this tag exists */
+    ExifEntry *entry = exif_content_get_entry(d->ifd[ifd],tag);
+    if (entry) {
+        char buf[1024];
+
+        /* Get the contents of the tag in human-readable form */
+        exif_entry_get_value(entry, buf, sizeof(buf));
+
+        /* Don't bother printing it if it's entirely blank */
+        trim_spaces(buf);
+        if (*buf) {
+            printf("%s: %s\n", exif_tag_get_name_in_ifd(tag,ifd), buf);
+        }
+    }
+}
+
+/* Show the given MakerNote tag if it exists */
+static void show_mnote_tag(ExifData *d, unsigned tag)
+{
+    ExifMnoteData *mn = exif_data_get_mnote_data(d);
+    if (mn) {
+        int num = exif_mnote_data_count(mn);
+        int i;
+
+        /* Loop through all MakerNote tags, searching for the desired one */
+        for (i=0; i < num; ++i) {
+            char buf[1024];
+            if (exif_mnote_data_get_id(mn, i) == tag) {
+                if (exif_mnote_data_get_value(mn, i, buf, sizeof(buf))) {
+                    /* Don't bother printing it if it's entirely blank */
+                    trim_spaces(buf);
+                    if (*buf) {
+                        printf("%s: %s\n", exif_mnote_data_get_title(mn, i),
+                            buf);
+                    }
+                }
+            }
+        }
+    }
+}
+
+int main(int argc, char **argv)
+{
+    ExifData *ed;
+    ExifEntry *entry;
+
+    if (argc < 2) {
+        printf("Usage: %s image.jpg\n", argv[0]);
+        printf("Displays tags potentially relating to ownership "
+                "of the image.\n");
+        return 1;
+    }
+
+    /* Load an ExifData object from an EXIF file */
+    ed = exif_data_new_from_file(argv[1]);
+    if (!ed) {
+        printf("File not readable or no EXIF data in file %s\n", argv[1]);
+        return 2;
+    }
+
+    /* Show all the tags that might contain information about the
+     * photographer
+     */
+    show_tag(ed, EXIF_IFD_0, EXIF_TAG_ARTIST);
+    show_tag(ed, EXIF_IFD_0, EXIF_TAG_XP_AUTHOR);
+    show_tag(ed, EXIF_IFD_0, EXIF_TAG_COPYRIGHT);
+
+    /* These are much less likely to be useful */
+    show_tag(ed, EXIF_IFD_EXIF, EXIF_TAG_USER_COMMENT);
+    show_tag(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION);
+    show_tag(ed, EXIF_IFD_1, EXIF_TAG_IMAGE_DESCRIPTION);
+
+    /* A couple of MakerNote tags can contain useful data.  Read the
+     * manufacturer tag to see if this image could have one of the recognized
+     * MakerNote tags.
+     */
+    entry = exif_content_get_entry(ed->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
+    if (entry) {
+        char buf[64];
+
+        /* Get the contents of the manufacturer tag as a string */
+        if (exif_entry_get_value(entry, buf, sizeof(buf))) {
+            trim_spaces(buf);
+
+            if (!strcmp(buf, "Canon")) {
+                show_mnote_tag(ed, 9); /* MNOTE_CANON_TAG_OWNER */
+
+            } else if (!strcmp(buf, "Asahi Optical Co.,Ltd.") || 
+                       !strcmp(buf, "PENTAX Corporation")) {
+                show_mnote_tag(ed, 0x23); /* MNOTE_PENTAX2_TAG_HOMETOWN_CITY */
+            }
+        }
+    }
+
+    /* Free the EXIF data */
+    exif_data_unref(ed);
+
+    return 0;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/examples/thumbnail.c

@@ -0,0 +1,66 @@
+/*
+ * libexif example program to extract an EXIF thumbnail from an image
+ * and save it into a new file.
+ *
+ * Placed into the public domain by Dan Fandrich
+ */
+
+#include <stdio.h>
+#include <libexif/exif-loader.h>
+
+int main(int argc, char **argv)
+{
+    int rc = 1;
+    ExifLoader *l;
+
+    if (argc < 2) {
+        printf("Usage: %s image.jpg\n", argv[0]);
+        printf("Extracts a thumbnail from the given EXIF image.\n");
+        return rc;
+    }
+
+    /* Create an ExifLoader object to manage the EXIF loading process */
+    l = exif_loader_new();
+    if (l) {
+        ExifData *ed;
+
+        /* Load the EXIF data from the image file */
+        exif_loader_write_file(l, argv[1]);
+
+        /* Get a pointer to the EXIF data */
+        ed = exif_loader_get_data(l);
+
+	/* The loader is no longer needed--free it */
+        exif_loader_unref(l);
+	l = NULL;
+        if (ed) {
+	    /* Make sure the image had a thumbnail before trying to write it */
+            if (ed->data && ed->size) {
+                FILE *thumb;
+                char thumb_name[1024];
+
+		/* Try to create a unique name for the thumbnail file */
+                snprintf(thumb_name, sizeof(thumb_name),
+                         "%s_thumb.jpg", argv[1]);
+
+                thumb = fopen(thumb_name, "wb");
+                if (thumb) {
+		    /* Write the thumbnail image to the file */
+                    fwrite(ed->data, 1, ed->size, thumb);
+                    fclose(thumb);
+                    printf("Wrote thumbnail to %s\n", thumb_name);
+                    rc = 0;
+                } else {
+                    printf("Could not create file %s\n", thumb_name);
+                    rc = 2;
+                }
+            } else {
+                printf("No EXIF thumbnail in file %s\n", argv[1]);
+                rc = 1;
+            }
+	    /* Free the EXIF data */
+            exif_data_unref(ed);
+        }
+    }
+    return rc;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/examples/write-exif.c

@@ -0,0 +1,301 @@
+/*
+ * write-exif.c
+ *
+ * Placed into the public domain by Daniel Fandrich
+ *
+ * Create a new EXIF data block and write it into a JPEG image file.
+ *
+ * The JPEG image data used in this example is fixed and is guaranteed not
+ * to contain an EXIF tag block already, so it is easy to precompute where
+ * in the file the EXIF data should be. In real life, a library like
+ * libjpeg (included with the exif command-line tool source code) would
+ * be used to write to an existing JPEG file.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <libexif/exif-data.h>
+
+/* this file will be unilaterally overwritten */
+#define FILE_NAME "write-exif.jpg"
+
+/* raw JPEG image data */
+static const unsigned char image_jpg[] = {
+  0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01,
+  0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43,
+  0x00, 0x14, 0x0e, 0x0f, 0x12, 0x0f, 0x0d, 0x14, 0x12, 0x10, 0x12, 0x17,
+  0x15, 0x14, 0x18, 0x1e, 0x32, 0x21, 0x1e, 0x1c, 0x1c, 0x1e, 0x3d, 0x2c,
+  0x2e, 0x24, 0x32, 0x49, 0x40, 0x4c, 0x4b, 0x47, 0x40, 0x46, 0x45, 0x50,
+  0x5a, 0x73, 0x62, 0x50, 0x55, 0x6d, 0x56, 0x45, 0x46, 0x64, 0x88, 0x65,
+  0x6d, 0x77, 0x7b, 0x81, 0x82, 0x81, 0x4e, 0x60, 0x8d, 0x97, 0x8c, 0x7d,
+  0x96, 0x73, 0x7e, 0x81, 0x7c, 0xff, 0xc0, 0x00, 0x0b, 0x08, 0x00, 0x40,
+  0x00, 0x40, 0x01, 0x01, 0x11, 0x00, 0xff, 0xc4, 0x00, 0x1b, 0x00, 0x00,
+  0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x04, 0x03, 0x07, 0x02, 0x01, 0xff,
+  0xc4, 0x00, 0x2f, 0x10, 0x00, 0x01, 0x03, 0x03, 0x02, 0x05, 0x03, 0x03,
+  0x03, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x11,
+  0x00, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x81, 0x61, 0x71,
+  0x91, 0x13, 0x32, 0xa1, 0x14, 0x22, 0xc1, 0x15, 0x23, 0x52, 0xd1, 0xf0,
+  0xff, 0xda, 0x00, 0x08, 0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xb3, 0xa2,
+  0x8a, 0x28, 0xa2, 0x8a, 0x28, 0xa2, 0x97, 0x64, 0x72, 0xd6, 0x58, 0xd4,
+  0x8f, 0xd5, 0x3d, 0xca, 0xa5, 0x7d, 0xa8, 0x4e, 0xaa, 0x3e, 0xb0, 0x3a,
+  0x7a, 0x9d, 0x2b, 0x2d, 0x87, 0x13, 0xe3, 0xaf, 0x9f, 0x0c, 0xb6, 0xb5,
+  0xb6, 0xe2, 0xb4, 0x48, 0x71, 0x30, 0x14, 0x7b, 0x02, 0x09, 0x14, 0xee,
+  0x94, 0x64, 0x38, 0x87, 0x1f, 0x8d, 0x5f, 0xd3, 0x7d, 0xe2, 0xa7, 0x46,
+  0xe8, 0x6c, 0x49, 0x1e, 0xfd, 0x07, 0xb1, 0x33, 0x5f, 0xb8, 0xdc, 0xf5,
+  0x96, 0x51, 0x7c, 0x96, 0xee, 0x14, 0xba, 0x04, 0xf2, 0x2c, 0x42, 0xa3,
+  0xd3, 0x70, 0x7c, 0x1a, 0x6d, 0x45, 0x2c, 0xcd, 0xe5, 0x11, 0x89, 0xb1,
+  0x5b, 0xc4, 0x02, 0xe1, 0xd1, 0xb4, 0xcf, 0xdc, 0xa3, 0xfc, 0x0d, 0xcd,
+  0x41, 0xde, 0xe3, 0xb2, 0x2e, 0xda, 0x1c, 0xbd, 0xe2, 0x4a, 0x90, 0xe9,
+  0x04, 0x95, 0x2b, 0xf7, 0x41, 0xd0, 0x18, 0xe8, 0x36, 0x03, 0xc6, 0x91,
+  0x4a, 0x81, 0x20, 0x82, 0x24, 0x10, 0x66, 0x45, 0x5a, 0xdd, 0xf1, 0x32,
+  0xff, 0x00, 0xa2, 0x5a, 0x8b, 0x62, 0x57, 0x7d, 0x70, 0x80, 0x93, 0x1a,
+  0x94, 0x10, 0x79, 0x4a, 0xa3, 0xb9, 0x20, 0xc0, 0xf3, 0xd3, 0x55, 0x59,
+  0x4e, 0x1c, 0x7a, 0xc7, 0x12, 0x9b, 0xc7, 0x94, 0xa7, 0x2e, 0x14, 0xa9,
+  0x74, 0x0d, 0x42, 0x01, 0x04, 0xc9, 0x3b, 0x93, 0x30, 0x09, 0xdb, 0x5f,
+  0x35, 0x9b, 0x85, 0xad, 0xde, 0x7f, 0x39, 0x6e, 0xa6, 0x82, 0xa1, 0xa5,
+  0x73, 0x2d, 0x40, 0x68, 0x13, 0x06, 0x67, 0xdf, 0x6f, 0x35, 0xe9, 0xb4,
+  0x52, 0x4c, 0xbe, 0x0c, 0x65, 0x72, 0x16, 0xcf, 0x3a, 0xff, 0x00, 0xf6,
+  0x5a, 0xd1, 0x4d, 0x11, 0xa1, 0x13, 0x26, 0x0f, 0x73, 0x00, 0x1f, 0x41,
+  0x5b, 0x72, 0xd6, 0xa2, 0xeb, 0x15, 0x73, 0x6e, 0x13, 0xf7, 0x36, 0x42,
+  0x40, 0xee, 0x04, 0x8f, 0xc8, 0x15, 0xe4, 0xf5, 0x59, 0xc1, 0x16, 0x0d,
+  0x3d, 0x70, 0xed, 0xdb, 0x84, 0x29, 0x6c, 0x40, 0x42, 0x3b, 0x13, 0x3f,
+  0xb8, 0xfc, 0x10, 0x3c, 0xd5, 0xc1, 0x00, 0x88, 0x22, 0x41, 0xef, 0x5f,
+  0x0d, 0xb4, 0x86, 0x81, 0x0d, 0xa1, 0x28, 0x07, 0x52, 0x12, 0x00, 0x06,
+  0xba, 0xd1, 0x45, 0x71, 0xb8, 0xb8, 0x6e, 0xd9, 0x85, 0xbc, 0xf2, 0xb9,
+  0x5b, 0x40, 0x25, 0x47, 0xb0, 0xaf, 0x24, 0x79, 0x48, 0x53, 0xce, 0x29,
+  0xb4, 0x94, 0xa0, 0xa8, 0x94, 0xa7, 0xb0, 0x27, 0x41, 0xf1, 0x54, 0x9c,
+  0x09, 0x71, 0xc9, 0x92, 0x7d, 0x82, 0x74, 0x75, 0xa9, 0x1e, 0xa5, 0x27,
+  0xfd, 0x13, 0x55, 0xd9, 0x3c, 0x83, 0x38, 0xbb, 0x45, 0x5c, 0xbf, 0x3c,
+  0xa1, 0x40, 0x40, 0x02, 0x54, 0x4f, 0x41, 0x3e, 0x4f, 0x83, 0x5a, 0x2d,
+  0xae, 0x1b, 0xba, 0xb7, 0x6d, 0xf6, 0x89, 0x28, 0x71, 0x21, 0x49, 0x24,
+  0x41, 0x83, 0xe9, 0x5d, 0xe9, 0x3f, 0x12, 0x64, 0x97, 0x8b, 0xc6, 0x17,
+  0x59, 0x03, 0xea, 0xa9, 0x61, 0x08, 0x24, 0x48, 0x04, 0xc9, 0x9f, 0x80,
+  0x6a, 0x4b, 0x17, 0xc4, 0xd7, 0xac, 0xdf, 0x36, 0xab, 0xbb, 0x85, 0x39,
+  0x6e, 0xb5, 0x00, 0xe0, 0x50, 0x06, 0x01, 0x3a, 0x91, 0x02, 0x44, 0x6f,
+  0x02, 0xb7, 0x65, 0xb2, 0x0e, 0x71, 0x25, 0xf3, 0x58, 0xdc, 0x72, 0x8f,
+  0xe9, 0xc1, 0xe6, 0x52, 0xe0, 0xc2, 0xa3, 0x72, 0x46, 0xe0, 0x0e, 0x83,
+  0xa9, 0xf1, 0x4b, 0x38, 0x9f, 0x16, 0xde, 0x2e, 0xfd, 0xa4, 0x32, 0x92,
+  0x1a, 0x5b, 0x40, 0x83, 0xdc, 0x8d, 0x0f, 0x9d, 0x01, 0x3e, 0xf5, 0x83,
+  0x17, 0x7a, 0xac, 0x76, 0x41, 0x9b, 0xa4, 0xa7, 0x9b, 0xe9, 0xab, 0x51,
+  0x31, 0x20, 0x82, 0x08, 0xf8, 0x34, 0xf9, 0xdb, 0x97, 0xb8, 0xb7, 0x2c,
+  0xcd, 0xba, 0x12, 0xa6, 0xec, 0xda, 0x3c, 0xca, 0x13, 0x24, 0x0e, 0xa4,
+  0x91, 0xa4, 0x9d, 0x87, 0x69, 0xf7, 0xab, 0x74, 0x21, 0x2d, 0xa1, 0x28,
+  0x4a, 0x42, 0x52, 0x90, 0x02, 0x40, 0xd8, 0x01, 0xb0, 0xae, 0x95, 0x87,
+  0x29, 0x8f, 0x6f, 0x27, 0x64, 0xe5, 0xb3, 0xc4, 0x80, 0xa8, 0x29, 0x50,
+  0xdd, 0x24, 0x6c, 0x47, 0xfd, 0xd4, 0xd4, 0x92, 0x78, 0x1e, 0xef, 0xeb,
+  0x42, 0xae, 0x98, 0x0d, 0x7f, 0x90, 0x0a, 0x27, 0xe2, 0x00, 0xfc, 0xd5,
+  0x4e, 0x27, 0x11, 0x6d, 0x89, 0x60, 0xb7, 0x6e, 0x92, 0x54, 0xa8, 0xe6,
+  0x71, 0x5b, 0xa8, 0xff, 0x00, 0x03, 0xd2, 0xbe, 0x73, 0x38, 0x86, 0x72,
+  0xf6, 0xc1, 0xb7, 0x4f, 0x2a, 0xd1, 0x25, 0x0e, 0x01, 0x25, 0x27, 0xae,
+  0x9d, 0x41, 0xed, 0xed, 0x52, 0xe8, 0xe0, 0x7b, 0xcf, 0xab, 0x0e, 0x5d,
+  0x30, 0x96, 0xe7, 0xee, 0x4f, 0x31, 0x57, 0xc1, 0x00, 0x7e, 0x6a, 0xaf,
+  0x15, 0x8b, 0x63, 0x17, 0x6e, 0x1a, 0x61, 0x24, 0x92, 0x65, 0x6b, 0x3b,
+  0xa8, 0xf7, 0x3e, 0x9d, 0x87, 0x4a, 0x63, 0x45, 0x14, 0x51, 0x45, 0x14,
+  0x51, 0x45, 0x7f, 0xff, 0xd9
+};
+
+/* length of data in image_jpg */
+static const unsigned int image_jpg_len = sizeof(image_jpg);
+
+/* dimensions of image */
+static const unsigned int image_jpg_x = 64;
+static const unsigned int image_jpg_y = 64;
+
+/* start of JPEG image data section */
+static const unsigned int image_data_offset = 20;
+#define image_data_len (image_jpg_len - image_data_offset)
+
+/* raw EXIF header data */
+static const unsigned char exif_header[] = {
+  0xff, 0xd8, 0xff, 0xe1
+};
+/* length of data in exif_header */
+static const unsigned int exif_header_len = sizeof(exif_header);
+
+/* byte order to use in the EXIF block */
+#define FILE_BYTE_ORDER EXIF_BYTE_ORDER_INTEL
+
+/* comment to write into the EXIF block */
+#define FILE_COMMENT "libexif demonstration image"
+
+/* special header required for EXIF_TAG_USER_COMMENT */
+#define ASCII_COMMENT "ASCII\0\0\0"
+
+
+/* Get an existing tag, or create one if it doesn't exist */
+static ExifEntry *init_tag(ExifData *exif, ExifIfd ifd, ExifTag tag)
+{
+	ExifEntry *entry;
+	/* Return an existing tag if one exists */
+	if (!((entry = exif_content_get_entry (exif->ifd[ifd], tag)))) {
+	    /* Allocate a new entry */
+	    entry = exif_entry_new ();
+	    assert(entry != NULL); /* catch an out of memory condition */
+	    entry->tag = tag; /* tag must be set before calling
+				 exif_content_add_entry */
+
+	    /* Attach the ExifEntry to an IFD */
+	    exif_content_add_entry (exif->ifd[ifd], entry);
+
+	    /* Allocate memory for the entry and fill with default data */
+	    exif_entry_initialize (entry, tag);
+
+	    /* Ownership of the ExifEntry has now been passed to the IFD.
+	     * One must be very careful in accessing a structure after
+	     * unref'ing it; in this case, we know "entry" won't be freed
+	     * because the reference count was bumped when it was added to
+	     * the IFD.
+	     */
+	    exif_entry_unref(entry);
+	}
+	return entry;
+}
+
+/* Create a brand-new tag with a data field of the given length, in the
+ * given IFD. This is needed when exif_entry_initialize() isn't able to create
+ * this type of tag itself, or the default data length it creates isn't the
+ * correct length.
+ */
+static ExifEntry *create_tag(ExifData *exif, ExifIfd ifd, ExifTag tag, size_t len)
+{
+	void *buf;
+	ExifEntry *entry;
+	
+	/* Create a memory allocator to manage this ExifEntry */
+	ExifMem *mem = exif_mem_new_default();
+	assert(mem != NULL); /* catch an out of memory condition */
+
+	/* Create a new ExifEntry using our allocator */
+	entry = exif_entry_new_mem (mem);
+	assert(entry != NULL);
+
+	/* Allocate memory to use for holding the tag data */
+	buf = exif_mem_alloc(mem, len);
+	assert(buf != NULL);
+
+	/* Fill in the entry */
+	entry->data = buf;
+	entry->size = len;
+	entry->tag = tag;
+	entry->components = len;
+	entry->format = EXIF_FORMAT_UNDEFINED;
+
+	/* Attach the ExifEntry to an IFD */
+	exif_content_add_entry (exif->ifd[ifd], entry);
+
+	/* The ExifMem and ExifEntry are now owned elsewhere */
+	exif_mem_unref(mem);
+	exif_entry_unref(entry);
+
+	return entry;
+}
+
+int main ()
+{
+	int rc = 1;
+	FILE *f;
+	unsigned char *exif_data;
+	unsigned int exif_data_len;
+	ExifEntry *entry;
+	ExifData *exif = exif_data_new();
+	if (!exif) {
+		fprintf(stderr, "Out of memory\n");
+		return 2;
+	}
+
+	/* Set the image options */
+	exif_data_set_option(exif, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
+	exif_data_set_data_type(exif, EXIF_DATA_TYPE_COMPRESSED);
+	exif_data_set_byte_order(exif, FILE_BYTE_ORDER);
+
+	/* Create the mandatory EXIF fields with default data */
+	exif_data_fix(exif);
+
+	/* All these tags are created with default values by exif_data_fix() */
+	/* Change the data to the correct values for this image. */
+	entry = init_tag(exif, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION);
+	exif_set_long(entry->data, FILE_BYTE_ORDER, image_jpg_x);
+
+	entry = init_tag(exif, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION);
+	exif_set_long(entry->data, FILE_BYTE_ORDER, image_jpg_y);
+
+	entry = init_tag(exif, EXIF_IFD_EXIF, EXIF_TAG_COLOR_SPACE);
+	exif_set_short(entry->data, FILE_BYTE_ORDER, 1);
+
+	/* Create a EXIF_TAG_USER_COMMENT tag. This one must be handled
+	 * differently because that tag isn't automatically created and
+	 * allocated by exif_data_fix(), nor can it be created using
+	 * exif_entry_initialize() so it must be explicitly allocated here.
+	 */
+	entry = create_tag(exif, EXIF_IFD_EXIF, EXIF_TAG_USER_COMMENT, 
+			sizeof(ASCII_COMMENT) + sizeof(FILE_COMMENT) - 2);
+	/* Write the special header needed for a comment tag */
+	memcpy(entry->data, ASCII_COMMENT, sizeof(ASCII_COMMENT)-1);
+	/* Write the actual comment text, without the trailing NUL character */
+	memcpy(entry->data+8, FILE_COMMENT, sizeof(FILE_COMMENT)-1);
+	/* create_tag() happens to set the format and components correctly for
+	 * EXIF_TAG_USER_COMMENT, so there is nothing more to do. */
+
+	/* Create a EXIF_TAG_SUBJECT_AREA tag */
+	entry = create_tag(exif, EXIF_IFD_EXIF, EXIF_TAG_SUBJECT_AREA,
+			   4 * exif_format_get_size(EXIF_FORMAT_SHORT));
+	entry->format = EXIF_FORMAT_SHORT;
+	entry->components = 4;
+	exif_set_short(entry->data, FILE_BYTE_ORDER, image_jpg_x / 2);
+	exif_set_short(entry->data+2, FILE_BYTE_ORDER, image_jpg_y / 2);
+	exif_set_short(entry->data+4, FILE_BYTE_ORDER, image_jpg_x);
+	exif_set_short(entry->data+6, FILE_BYTE_ORDER, image_jpg_y);
+
+	/* Get a pointer to the EXIF data block we just created */
+	exif_data_save_data(exif, &exif_data, &exif_data_len);
+	assert(exif_data != NULL);
+
+	f = fopen(FILE_NAME, "wb");
+	if (!f) {
+		fprintf(stderr, "Error creating file %s\n", FILE_NAME);
+		exif_data_unref(exif);
+		return rc;
+	}
+	/* Write EXIF header */
+	if (fwrite(exif_header, exif_header_len, 1, f) != 1) {
+		fprintf(stderr, "Error writing to file %s\n", FILE_NAME);
+		goto errout;
+	}
+	/* Write EXIF block length in big-endian order */
+	if (fputc((exif_data_len+2) >> 8, f) < 0) {
+		fprintf(stderr, "Error writing to file %s\n", FILE_NAME);
+		goto errout;
+	}
+	if (fputc((exif_data_len+2) & 0xff, f) < 0) {
+		fprintf(stderr, "Error writing to file %s\n", FILE_NAME);
+		goto errout;
+	}
+	/* Write EXIF data block */
+	if (fwrite(exif_data, exif_data_len, 1, f) != 1) {
+		fprintf(stderr, "Error writing to file %s\n", FILE_NAME);
+		goto errout;
+	}
+	/* Write JPEG image data, skipping the non-EXIF header */
+	if (fwrite(image_jpg+image_data_offset, image_data_len, 1, f) != 1) {
+		fprintf(stderr, "Error writing to file %s\n", FILE_NAME);
+		goto errout;
+	}
+	printf("Wrote file %s\n", FILE_NAME);
+	rc = 0;
+
+errout:
+	if (fclose(f)) {
+		fprintf(stderr, "Error writing to file %s\n", FILE_NAME);
+		rc = 1;
+	}
+	/* The allocator we're using for ExifData is the standard one, so use
+	 * it directly to free this pointer.
+	 */
+	free(exif_data);
+	exif_data_unref(exif);
+
+	return rc;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/contrib/watcom/_stdint.h

@@ -0,0 +1,13 @@
+#ifndef __STDINT_H
+#define __STDINT_H
+#include <sys/types.h>
+typedef  unsigned char   uint8_t;
+typedef  unsigned short  uint16_t;
+typedef  unsigned long   uint32_t;
+
+typedef    signed char   int8_t;
+typedef    signed short  int16_t;
+typedef    signed long   int32_t;
+#endif
+
+

local-test-libexif-delta-01-exif-003/afc-libexif/doc/.gitignore

@@ -0,0 +1,8 @@
+Makefile
+Makefile.in
+.libs
+.deps
+*.o
+*.lo
+Doxyfile
+Doxyfile-internals

local-test-libexif-delta-01-exif-003/afc-libexif/doc/Makefile.am

@@ -0,0 +1,113 @@
+########################################################################
+# Conditional rules, depending on tool availability
+########################################################################
+
+DOXYGEN_FILES =
+DOXYGEN_STAMPS =
+DOXYGEN_UPLOAD =
+
+DOXYGEN_INSTALL_TARGETS =
+DOXYGEN_UNINSTALL_TARGETS =
+
+DOXYGEN_CLEAN_TARGETS =
+
+DOXYGEN_TARBALLS =
+
+# FIXME: Depending on the source files would be sufficient, but only
+#        maintainable with a completely non-recursive build.
+#        Depending on libexif.la works at least.
+$(top_builddir)/libexif/libexif.la:
+	cd $(top_builddir)/libexif && $(MAKE) libexif.la
+
+if BUILD_DOCS
+if HAVE_DOXYGEN
+
+DOXYGEN_UPLOAD += $(HTML_APIDOC_DIR).uploaded
+
+DOXYGEN_STAMPS += $(HTML_APIDOC_DIR).stamp
+$(HTML_APIDOC_DIR).stamp: Doxyfile $(top_builddir)/libexif/libexif.la
+	$(DOXYGEN) $<
+	echo > $@
+
+DOXYGEN_TARBALLS += $(HTML_APIDOC_DIR).tar.gz
+$(HTML_APIDOC_DIR).tar.gz: $(HTML_APIDOC_DIR).stamp
+	(cd $(DOXYGEN_OUTPUT_DIR) && $(AMTAR) chof - $(HTML_APIDOC_DIR) | GZIP=--best gzip -c) > $@
+
+if ENABLE_INTERNAL_DOCS
+DOXYGEN_UPLOAD += $(HTML_APIDOC_INTERNALS_DIR).uploaded
+
+DOXYGEN_STAMPS += $(HTML_APIDOC_INTERNALS_DIR).stamp
+$(HTML_APIDOC_INTERNALS_DIR).stamp: Doxyfile-internals $(top_builddir)/libexif/libexif.la
+	$(DOXYGEN) $<
+	echo > $@
+
+DOXYGEN_TARBALLS += $(HTML_APIDOC_INTERNALS_DIR).tar.gz
+$(HTML_APIDOC_INTERNALS_DIR).tar.gz: $(HTML_APIDOC_INTERNALS_DIR).stamp
+	(cd $(DOXYGEN_OUTPUT_DIR) && $(AMTAR) chof - $(HTML_APIDOC_INTERNALS_DIR) | GZIP=--best gzip -c) > $@
+
+DOXYGEN_INSTALL_TARGETS += install-apidocs-internals
+install-apidocs-internals: $(HTML_APIDOC_INTERNALS_DIR).stamp
+	mkdir -p "$(DESTDIR)$(docdir)"
+	find "$(DOXYGEN_OUTPUT_DIR)/$(HTML_APIDOC_INTERNALS_DIR)" \
+		\( -type d -exec chmod 0755 {} \; \) -or \
+		\( -type f -exec chmod 0644 {} \; \)
+	(unset CDPATH; cd "$(DOXYGEN_OUTPUT_DIR)" && tar cpf - "$(HTML_APIDOC_INTERNALS_DIR)") \
+		| (cd "$(DESTDIR)$(docdir)" && tar xpf -)
+
+DOXYGEN_UNINSTALL_TARGETS += uninstall-apidocs-internals
+uninstall-apidocs-internals:
+	rm -rf "$(DESTDIR)$(docdir)/$(HTML_APIDOC_INTERNALS_DIR)"
+
+endif
+
+DOXYGEN_INSTALL_TARGETS += install-apidocs
+install-apidocs: $(HTML_APIDOC_DIR).stamp
+	mkdir -p "$(DESTDIR)$(docdir)"
+	find "$(DOXYGEN_OUTPUT_DIR)/$(HTML_APIDOC_DIR)" \
+		\( -type d -exec chmod 0755 {} \; \) -or \
+		\( -type f -exec chmod 0644 {} \; \)
+	(unset CDPATH; cd "$(DOXYGEN_OUTPUT_DIR)" && tar cpf - "$(HTML_APIDOC_DIR)") \
+		| (cd "$(DESTDIR)$(docdir)" && tar xpf -)
+
+DOXYGEN_UNINSTALL_TARGETS += uninstall-apidocs
+uninstall-apidocs:
+	rm -rf "$(DESTDIR)$(docdir)/$(HTML_APIDOC_DIR)"
+
+DOXYGEN_CLEAN_TARGETS += clean-apidocs
+clean-apidocs:
+	rm -rf $(DOXYGEN_OUTPUT_DIR)
+	rm -f $(HTML_APIDOC_DIR).tar.gz $(HTML_APIDOC_INTERNALS_DIR).tar.gz
+
+$(DOXYGEN_UPLOAD): $(DOXYGEN_STAMPS)
+	find $(DOXYGEN_OUTPUT_DIR) \( -type d -exec chmod a+rx,go-w,g+s {} \; \) \
+		-or \( -type f -exec chmod a+r {} \; \)
+	rsync -avz --progress $(DOXYGEN_OUTPUT_DIR)/$(HTML_APIDOC_DIR)/ sf:/home/users/h/hu/hun/libexif/htdocs/api/
+if ENABLE_INTERNAL_DOCS
+	rsync -avz --progress $(DOXYGEN_OUTPUT_DIR)/$(HTML_APIDOC_INTERNALS_DIR)/ sf:/home/users/h/hu/hun/libexif/htdocs/internals/
+endif
+	ssh "sf" "find /home/groups/l/li/libexif/htdocs/internals /home/groups/l/li/libexif/htdocs/api \( -type d -exec chgrp libexif {} \; -exec chmod g+rwxs,a+rx {} \; \) -or \( -type f -exec chgrp libexif {} \; -exec chmod g+rw {} \; \( -name '*.html' -or -name '*.png' -or -name '*.php' -or -name '*.jpg' -or -name '*.css' -name '*.dot' -name '*.map' \) -exec chmod a+r {} \; \)"
+
+endif # HAVE_DOXYGEN
+endif # BUILD_DOCS
+
+
+########################################################################
+# Common part
+########################################################################
+
+EXTRA_DIST = Doxyfile.in Doxyfile-internals.in footer.html README.apidocs $(HTML_APIDOC_DIR).tar.gz
+
+doc_DATA = $(DOXYGEN_FILES)
+
+all-local: $(DOXYGEN_STAMPS)
+
+install-data-local: $(DOXYGEN_INSTALL_TARGETS)
+
+uninstall-local: $(DOXYGEN_UNINSTALL_TARGETS)
+
+clean-local: $(DOXYGEN_CLEAN_TARGETS)
+
+upload: $(DOXYGEN_UPLOAD)
+
+CLEANFILES = $(DOXYGEN_FILES) $(DOXYGEN_STAMPS)
+

local-test-libexif-delta-01-exif-003/afc-libexif/doc/README.apidocs

@@ -0,0 +1,7 @@
+Rules for the API docs:
+
+  1. Clearly distinguish between internal and the external API/ABI.
+  2. Mark internal stuff with \internal.
+  3. If this has been solved, start documenting the external interface.
+
+Thank you.

local-test-libexif-delta-01-exif-003/afc-libexif/doc/footer.html

@@ -0,0 +1,12 @@
+
+
+<hr size="1">
+<address style="text-align: right;">
+<a href="https://libexif.github.io" target="_top">libexif</a>
+
+<small>Generated by&nbsp;<a href="http://www.doxygen.org/" target="_top"><img src="doxygen.png" alt="doxygen" align="middle" border="0">
+</a>
+</small></address>
+</body>
+</html>
+

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/.gitignore

@@ -0,0 +1,10 @@
+Makefile
+Makefile.in
+.libs
+.deps
+libexif.la
+*.o
+*.lo
+*.la
+libexif.pc
+_stdint.h

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/Makefile.am

@@ -0,0 +1,73 @@
+EXTRA_DIST =
+lib_LTLIBRARIES =
+noinst_LTLIBRARIES =
+
+include apple/Makefile-files
+include canon/Makefile-files
+include fuji/Makefile-files
+include olympus/Makefile-files
+include pentax/Makefile-files
+
+# The -no-undefined makes it possible to build DLLs for Windows,
+# or shared libraries for Tru64 or AIX (according to the autobook
+# chapter on "Portable Library Design"). It doesn't seem to hurt
+# elsewhere, so we can leave it in.
+lib_LTLIBRARIES += libexif.la
+libexif_la_LDFLAGS = \
+	-export-symbols $(srcdir)/libexif.sym \
+	-no-undefined -version-info @LIBEXIF_VERSION_INFO@
+libexif_la_SOURCES =		\
+	exif-byte-order.c	\
+	exif-content.c		\
+	exif-data.c		\
+	exif-entry.c		\
+	exif-format.c		\
+	exif-ifd.c		\
+	exif-loader.c		\
+	exif-log.c		\
+	exif-mem.c		\
+	exif-mnote-data.c	\
+	exif-mnote-data-priv.h	\
+	exif-tag.c		\
+	exif-utils.c		\
+	i18n.h          \
+	exif-gps-ifd.c  \
+	exif-gps-ifd.h
+
+libexif_la_DEPENDENCIES = \
+	$(srcdir)/libexif.sym \
+	libmnote-apple.la		\
+	libmnote-canon.la		\
+	libmnote-fuji.la		\
+	libmnote-olympus.la	\
+	libmnote-pentax.la
+libexif_la_LIBADD =			\
+	$(LTLIBINTL)			\
+	libmnote-apple.la		\
+	libmnote-canon.la		\
+	libmnote-fuji.la	\
+	libmnote-olympus.la	\
+	libmnote-pentax.la
+
+libexifincludedir = $(includedir)/libexif
+libexifinclude_HEADERS = 	\
+	exif-byte-order.h	\
+	exif-content.h		\
+	exif-data.h		\
+	exif-data-type.h \
+	exif-entry.h		\
+	exif-format.h		\
+	exif-ifd.h		\
+	exif-loader.h		\
+	exif-log.h		\
+	exif-mem.h		\
+	exif-mnote-data.h	\
+	exif-tag.h		\
+	exif-utils.h		\
+	_stdint.h
+
+EXTRA_DIST += exif-system.h exif.h
+
+EXTRA_DIST += libexif.sym
+
+DISTCLEANFILES = _stdint.h

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/apple/.gitignore

@@ -0,0 +1,6 @@
+Makefile
+Makefile.in
+.deps
+.libs
+*.la
+*.lo

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/apple/Makefile-files

@@ -0,0 +1,7 @@
+# -*- Makefile -*-
+noinst_LTLIBRARIES += libmnote-apple.la
+libmnote_apple_la_SOURCES = \
+    apple/mnote-apple-entry.c apple/mnote-apple-entry.h \
+    apple/exif-mnote-data-apple.c apple/exif-mnote-data-apple.h \
+    apple/mnote-apple-tag.c apple/mnote-apple-tag.h
+libmnote_apple_la_LIBADD = $(LTLIBINTL)

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/apple/exif-mnote-data-apple.c

@@ -0,0 +1,288 @@
+/* exif-mnote-data-apple.c
+ *
+ * Copyright (c) 2018 zhanwang-sky <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+#include "exif-mnote-data-apple.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libexif/exif-data.h>
+#include <libexif/exif-utils.h>
+
+static void
+exif_mnote_data_apple_free(ExifMnoteData *md) {
+    ExifMnoteDataApple *d = (ExifMnoteDataApple *) md;
+    unsigned int i;
+
+    /*printf("%s\n", __FUNCTION__);*/
+
+    if (!d) {
+        return;
+    }
+
+    if (d->entries) {
+        for (i = 0; i < d->count; i++) {
+            if (d->entries[i].data) {
+                exif_mem_free(md->mem, d->entries[i].data);
+            }
+        }
+        exif_mem_free(md->mem, d->entries);
+        d->entries = NULL;
+        d->count = 0;
+    }
+
+    return;
+}
+
+static void
+exif_mnote_data_apple_load(ExifMnoteData *md, const unsigned char *buf, unsigned int buf_size) {
+    ExifMnoteDataApple *d = (ExifMnoteDataApple *) md;
+    unsigned int tcount, i;
+    unsigned int dsize;
+    unsigned int ofs, dofs;
+
+    /*printf("%s\n", __FUNCTION__);*/
+
+    if (!d || !buf || (buf_size < 6 + 16)) {
+        exif_log(md->log, EXIF_LOG_CODE_CORRUPT_DATA,
+                 "ExifMnoteDataApple", "Short MakerNote");
+        return;
+    }
+
+    /* Start of interesting data */
+    ofs = d->offset + 6;
+
+    if ((buf[ofs + 12] == 'M') && (buf[ofs + 13] == 'M')) {
+        d->order = EXIF_BYTE_ORDER_MOTOROLA;
+    } else if ((buf[ofs + 12] == 'I') && (buf[ofs + 13] == 'I')) {
+        d->order = EXIF_BYTE_ORDER_INTEL;
+    } else {
+        exif_log(md->log, EXIF_LOG_CODE_CORRUPT_DATA,
+                "ExifMnoteDataApple", "Unrecognized byte order");
+        /*printf("%s(%d)\n", __FUNCTION__, __LINE__);*/
+        return;
+    }
+
+    tcount = (unsigned int) exif_get_short(buf + ofs + 14, d->order);
+
+    /* Sanity check the offset */
+    if (buf_size < d->offset + 6 + 16 + tcount * 12 + 4) {
+        exif_log(md->log, EXIF_LOG_CODE_CORRUPT_DATA,
+                 "ExifMnoteDataApple", "Short MakerNote");
+        /*printf("%s(%d)\n", __FUNCTION__, __LINE__);*/
+        return;
+    }
+    memset(d->entries, 0, sizeof(MnoteAppleEntry) * tcount);
+
+    /* printf("%s(%d): total %d tags\n", __FUNCTION__, __LINE__, tcount); */
+
+    ofs += 16;
+
+    exif_mnote_data_apple_free(md);
+
+    /* Reserve enough space for all the possible MakerNote tags */
+    d->entries = exif_mem_alloc(md->mem, sizeof(MnoteAppleEntry) * tcount);
+    if (!d->entries) {
+        EXIF_LOG_NO_MEMORY(md->log, "ExifMnoteApple", sizeof(MnoteAppleEntry) * tcount);
+        /*printf("%s(%d)\n", __FUNCTION__, __LINE__);*/
+        return;
+    }
+
+    for (i = 0; i < tcount; i++) {
+	if (ofs + 12 > buf_size) {
+		exif_log (md->log, EXIF_LOG_CODE_CORRUPT_DATA,
+                                  "ExifMnoteApplet", "Tag size overflow detected (%u vs size %u)", ofs + 12, buf_size);
+		break;
+	}
+        d->entries[i].tag = exif_get_short(buf + ofs, d->order);
+        d->entries[i].format = exif_get_short(buf + ofs + 2, d->order);
+        d->entries[i].components = exif_get_long(buf + ofs + 4, d->order);
+        d->entries[i].order = d->order;
+        dsize = exif_format_get_size(d->entries[i].format) * d->entries[i].components;
+        if (dsize > 4) {
+            dofs = d->offset + exif_get_long(buf + ofs + 8, d->order);
+        } else {
+            dofs = ofs + 8;
+        }
+	if (dofs > buf_size) {
+		exif_log (md->log, EXIF_LOG_CODE_CORRUPT_DATA,
+                                  "ExifMnoteApplet", "Tag size overflow detected (%u vs size %u)", dofs, buf_size);
+		continue;
+	}
+        ofs += 12;
+        d->entries[i].data = exif_mem_alloc(md->mem, dsize);
+        if (!d->entries[i].data) {
+            EXIF_LOG_NO_MEMORY(md->log, "ExifMnoteApple", dsize);
+            continue;
+        }
+        if (dofs + dsize > buf_size) {
+            exif_log(md->log, EXIF_LOG_CODE_CORRUPT_DATA,
+                "ExifMnoteApplet", "Tag size overflow detected (%u vs size %u)", dofs + dsize, buf_size);
+            continue;
+        }
+        memcpy(d->entries[i].data, buf + dofs, dsize);
+        d->entries[i].size = dsize;
+    }
+    d->count = tcount;
+
+    return;
+}
+
+static void
+exif_mnote_data_apple_set_offset(ExifMnoteData *md, unsigned int o) {
+    /*printf("%s\n", __FUNCTION__);*/
+
+    if (md) {
+        ((ExifMnoteDataApple *) md)->offset = o;
+    }
+
+    return;
+}
+
+static void
+exif_mnote_data_apple_set_byte_order(ExifMnoteData *md , ExifByteOrder o) {
+    ExifMnoteDataApple *d = (ExifMnoteDataApple *) md;
+    unsigned int i;
+
+    /*printf("%s\n", __FUNCTION__);*/
+
+    if (!d || d->order == o) {
+        return;
+    }
+
+    for (i = 0; i < d->count; i++) {
+	if (d->entries[i].components && (d->entries[i].size/d->entries[i].components < exif_format_get_size (d->entries[i].format)))
+		continue;
+        exif_array_set_byte_order(d->entries[i].format, d->entries[i].data,
+                                  d->entries[i].components, d->entries[i].order, o);
+        d->entries[i].order = o;
+    }
+    d->order = o;
+
+    return;
+}
+
+static unsigned int
+exif_mnote_data_apple_count(ExifMnoteData *md){
+    /*printf("%s\n", __FUNCTION__);*/
+
+    return md ? ((ExifMnoteDataApple *) md)->count : 0;
+}
+
+static unsigned int
+exif_mnote_data_apple_get_id(ExifMnoteData *md, unsigned int i) {
+    ExifMnoteDataApple *d = (ExifMnoteDataApple *) md;
+
+    if (!d || (d->count <= i)) {
+        return 0;
+    }
+
+    return d->entries[i].tag;
+}
+
+static const char *
+exif_mnote_data_apple_get_name(ExifMnoteData *md, unsigned int i) {
+    ExifMnoteDataApple *d = (ExifMnoteDataApple *) md;
+
+    if (!d || (d->count <= i)) {
+        return NULL;
+    }
+
+    return mnote_apple_tag_get_name(d->entries[i].tag);
+}
+
+static const char *
+exif_mnote_data_apple_get_title(ExifMnoteData *md, unsigned int i) {
+    ExifMnoteDataApple *d = (ExifMnoteDataApple *) md;
+
+    if (!d || (d->count <= i)) {
+        return NULL;
+    }
+
+    return mnote_apple_tag_get_title(d->entries[i].tag);
+}
+
+static const char *
+exif_mnote_data_apple_get_description(ExifMnoteData *md, unsigned int i) {
+    ExifMnoteDataApple *d = (ExifMnoteDataApple *) md;
+
+    if (!d || (d->count <= i)) {
+        return NULL;
+    }
+
+    return mnote_apple_tag_get_description(d->entries[i].tag);
+}
+
+static char *
+exif_mnote_data_apple_get_value(ExifMnoteData *md, unsigned int i, char *val, unsigned int maxlen) {
+    ExifMnoteDataApple *d = (ExifMnoteDataApple *) md;
+
+    if (!val || !d || (d->count <= i)) {
+        return NULL;
+    }
+
+    return mnote_apple_entry_get_value(&d->entries[i], val, maxlen);
+}
+
+int
+exif_mnote_data_apple_identify(const ExifData *ed, const ExifEntry *e) {
+    int variant;
+
+    if (!strcmp((const char *) e->data, "Apple iOS")) {
+        variant = 1;
+    } else {
+        variant = 0;
+    }
+
+    return variant;
+}
+
+ExifMnoteData *
+exif_mnote_data_apple_new(ExifMem *mem) {
+    ExifMnoteData *md;
+
+    /*printf("%s\n", __FUNCTION__);*/
+
+    if (!mem) {
+        return NULL;
+    }
+
+    md = exif_mem_alloc(mem, sizeof(ExifMnoteDataApple));
+    if (!md) {
+        return NULL;
+    }
+
+    exif_mnote_data_construct(md, mem);
+
+    md->methods.free = exif_mnote_data_apple_free;
+    md->methods.load = exif_mnote_data_apple_load;
+    md->methods.set_offset = exif_mnote_data_apple_set_offset;
+    md->methods.set_byte_order = exif_mnote_data_apple_set_byte_order;
+    md->methods.count = exif_mnote_data_apple_count;
+    md->methods.get_id = exif_mnote_data_apple_get_id;
+    md->methods.get_name = exif_mnote_data_apple_get_name;
+    md->methods.get_title = exif_mnote_data_apple_get_title;
+    md->methods.get_description = exif_mnote_data_apple_get_description;
+    md->methods.get_value = exif_mnote_data_apple_get_value;
+
+    return md;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/apple/exif-mnote-data-apple.h

@@ -0,0 +1,44 @@
+/* mnote-apple-data.h
+ *
+ * Copyright (c) 2018 zhanwang-sky <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __MNOTE_APPLE_CONTENT_H__
+#define __MNOTE_APPLE_CONTENT_H__
+
+#include <libexif/exif-byte-order.h>
+#include <libexif/exif-data.h>
+#include <libexif/exif-mem.h>
+#include <libexif/exif-mnote-data-priv.h>
+#include <libexif/apple/mnote-apple-entry.h>
+
+typedef struct _ExifMnoteDataApple ExifMnoteDataApple;
+
+struct _ExifMnoteDataApple {
+    ExifMnoteData parent;
+    ExifByteOrder order;
+    unsigned int offset;
+    MnoteAppleEntry *entries;
+    unsigned int count;
+};
+
+int exif_mnote_data_apple_identify(const ExifData *, const ExifEntry *);
+
+ExifMnoteData *exif_mnote_data_apple_new(ExifMem *);
+
+#endif /* __MNOTE_APPLE_CONTENT_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/apple/mnote-apple-entry.c

@@ -0,0 +1,155 @@
+/* mnote-apple-entry.c
+ *
+ * Copyright (c) 2018 zhanwang-sky <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+#include "mnote-apple-entry.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libexif/exif-entry.h>
+#include <libexif/exif-format.h>
+#include <libexif/exif-utils.h>
+#include <libexif/i18n.h>
+
+char *
+mnote_apple_entry_get_value(MnoteAppleEntry *entry, char *v, unsigned int maxlen) {
+    ExifLong  vl;
+    ExifSLong vsl;
+    ExifShort vs;
+    ExifSShort vss;
+    ExifRational vr;
+    ExifSRational vsr;
+    size_t size;
+    unsigned char *data;
+
+    if (!entry)
+        return NULL;
+
+    memset(v, 0, maxlen);
+    maxlen--;
+
+    size = entry->size;
+    data = entry->data;
+    switch (entry->tag) {
+    case MNOTE_APPLE_TAG_HDR:
+	if (size < 4) return NULL;
+	if (entry->format != EXIF_FORMAT_SLONG) return NULL;
+	if (entry->components != 1) return NULL;
+
+        vsl = exif_get_slong(data, entry->order);
+        snprintf(v, maxlen, "%d", vsl);
+        break;
+    case MNOTE_APPLE_TAG_IMAGE_UNIQUE_ID:
+    case MNOTE_APPLE_TAG_BURST_UUID:
+    case MNOTE_APPLE_TAG_MEDIA_GROUP_UUID:
+	if (entry->format != EXIF_FORMAT_ASCII) return NULL;
+	strncpy (v, (char *) data, MIN (maxlen-1, size));
+	v[MIN (maxlen-1, size)] = 0;
+        break;
+    default:
+	switch (entry->format) {
+	case EXIF_FORMAT_ASCII:
+	    strncpy (v, (char *)data, MIN(maxlen, size));
+	    break;
+	case EXIF_FORMAT_SHORT: {
+	    size_t i, len = 0;
+
+	    for(i=0; i<entry->components; i++) {
+		if (size < 2)
+		    break;
+		if (len > maxlen)
+		    break;
+		vs = exif_get_short (data, entry->order);
+		snprintf (v+len, maxlen-len, "%hu ", vs);
+		len = strlen(v);
+		data += 2;
+		size -= 2;
+	    }
+	    }
+	    break;
+	case EXIF_FORMAT_SSHORT: {
+	    size_t i, len = 0;
+	    for(i=0; i<entry->components; i++) {
+		if (size < 2)
+		    break;
+		if (len > maxlen)
+		    break;
+		vss = exif_get_sshort (data, entry->order);
+		snprintf (v+len, maxlen-len, "%hi ", vss);
+		len = strlen(v);
+		data += 2;
+		size -= 2;
+	    }
+	}
+	break;
+        case EXIF_FORMAT_LONG: {
+	    size_t i, len = 0;
+	    for(i=0; i<entry->components; i++) {
+		if (size < 4)
+		    break;
+		if (len > maxlen)
+		    break;
+		vl = exif_get_long (data, entry->order);
+		snprintf (v+len, maxlen-len, "%lu ", (long unsigned) vl);
+		len = strlen(v);
+		data += 4;
+		size -= 4;
+	    }
+	    }
+	    break;
+	case EXIF_FORMAT_SLONG: {
+	    size_t i, len = 0;
+	    for(i=0; i<entry->components; i++) {
+		if (size < 4)
+		    break;
+		if (len > maxlen)
+		    break;
+		vsl = exif_get_slong (data, entry->order);
+		snprintf (v+len, maxlen-len, "%li ", (long int) vsl);
+		len = strlen(v);
+		data += 4;
+		size -= 4;
+	    }
+	    }
+	    break;
+	case EXIF_FORMAT_RATIONAL:
+	    vr = exif_get_rational (data, entry->order);
+	    if (!vr.denominator) break;
+	    snprintf (v, maxlen, "%2.4f", (double) vr.numerator /
+					    vr.denominator);
+	    break;
+	case EXIF_FORMAT_SRATIONAL:
+	    vsr = exif_get_srational (data, entry->order);
+	    if (!vsr.denominator) break;
+	    snprintf (v, maxlen, "%2.4f", (double) vsr.numerator /
+		  vsr.denominator);
+	    break;
+	case EXIF_FORMAT_UNDEFINED:
+	default:
+	    snprintf (v, maxlen, _("%i bytes unknown data"), entry->size);
+	    break;
+        }
+	break;
+     }
+
+     return v;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/apple/mnote-apple-entry.h

@@ -0,0 +1,41 @@
+/* mnote-apple-entry.h
+ *
+ * Copyright (c) 2018 zhanwang-sky <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __MNOTE_APPLE_ENTRY_H__
+#define __MNOTE_APPLE_ENTRY_H__
+
+#include <libexif/exif-byte-order.h>
+#include <libexif/exif-format.h>
+#include <libexif/apple/mnote-apple-tag.h>
+
+typedef struct _MnoteAppleEntry MnoteAppleEntry;
+
+struct _MnoteAppleEntry {
+    MnoteAppleTag tag;
+    ExifFormat format;
+    unsigned long components;
+    unsigned char *data;
+    unsigned int size;
+    ExifByteOrder order;
+};
+
+char *mnote_apple_entry_get_value(MnoteAppleEntry *, char *, unsigned int);
+
+#endif /* __MNOTE_APPLE_ENTRY_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/apple/mnote-apple-tag.c

@@ -0,0 +1,89 @@
+/* mnote-apple-tag.c:
+ *
+ * Copyright (c) 2018 zhanwang-sky <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+#include "mnote-apple-tag.h"
+
+#include <libexif/i18n.h>
+#include <libexif/exif-utils.h>
+
+#include <stdlib.h>
+
+static const struct {
+    MnoteAppleTag tag;
+    const char *name;
+    const char *title;
+    const char *description;
+} table[] = {
+#ifndef NO_VERBOSE_TAG_STRINGS
+    {MNOTE_APPLE_TAG_HDR, "HDR", N_("HDR Mode"), ""},
+    {MNOTE_APPLE_TAG_RUNTIME, "RUNTIME", N_("Runtime"), ""},
+    {MNOTE_APPLE_TAG_ACCELERATION_VECTOR, "ACCELERATION_VECTOR", N_("Acceleration Vector"), ""},
+    {MNOTE_APPLE_TAG_HDR, "HDR", N_("HDR"), ""},
+    {MNOTE_APPLE_TAG_BURST_UUID, "BURST_UUID", N_("Burst UUID"), ""},
+    {MNOTE_APPLE_TAG_MEDIA_GROUP_UUID, "MEDIA_GROUP_UUID", N_("Media Group UUID"), ""},
+    {MNOTE_APPLE_TAG_IMAGE_UNIQUE_ID, "IMAGE_UNIQUE_ID", N_("Image Unique ID"), ""},
+#endif
+    {0, NULL, NULL, NULL}
+};
+
+const char *
+mnote_apple_tag_get_name(MnoteAppleTag 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_apple_tag_get_title(MnoteAppleTag t) {
+    unsigned int i;
+
+    (void) 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_apple_tag_get_description(MnoteAppleTag t) {
+    unsigned int i;
+
+    for (i = 0; i < sizeof (table) / sizeof (table[0]); i++) {
+        if (table[i].tag == t) {
+            if (!table[i].description || !*table[i].description) {
+                return "";
+            }
+            (void) bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
+            return _(table[i].description);
+        }
+    }
+
+    return NULL;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/apple/mnote-apple-tag.h

@@ -0,0 +1,46 @@
+/* mnote-apple-tag.h
+ *
+ * Copyright (c) 2018 zhanwang-sky <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __MNOTE_APPLE_TAG_H__
+#define __MNOTE_APPLE_TAG_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+enum _MnoteAppleTag {
+    MNOTE_APPLE_TAG_RUNTIME		= 0x3,
+    MNOTE_APPLE_TAG_ACCELERATION_VECTOR	= 0x9,
+    MNOTE_APPLE_TAG_HDR			= 0xA,
+    MNOTE_APPLE_TAG_BURST_UUID 		= 0xB,
+    MNOTE_APPLE_TAG_MEDIA_GROUP_UUID	= 0x11,
+    MNOTE_APPLE_TAG_IMAGE_UNIQUE_ID	= 0x15,
+};
+typedef enum _MnoteAppleTag MnoteAppleTag;
+
+const char *mnote_apple_tag_get_name(MnoteAppleTag);
+const char *mnote_apple_tag_get_title(MnoteAppleTag);
+const char *mnote_apple_tag_get_description(MnoteAppleTag);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MNOTE_APPLE_TAG_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/canon/.gitignore

@@ -0,0 +1,6 @@
+Makefile
+Makefile.in
+.deps
+.libs
+*.la
+*.lo

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/canon/Makefile-files

@@ -0,0 +1,7 @@
+# -*- Makefile -*-
+noinst_LTLIBRARIES += libmnote-canon.la
+libmnote_canon_la_SOURCES = \
+	canon/exif-mnote-data-canon.c canon/exif-mnote-data-canon.h \
+	canon/mnote-canon-entry.c canon/mnote-canon-entry.h \
+	canon/mnote-canon-tag.c canon/mnote-canon-tag.h
+libmnote_canon_la_LIBADD = $(LTLIBINTL)

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/canon/exif-mnote-data-canon.c

@@ -0,0 +1,433 @@
+/* exif-mnote-data-canon.c
+ *
+ * Copyright (c) 2002, 2003 Lutz Mueller <[email protected]>
+ * Copyright (c) 2003 Matthieu Castet <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+#include "exif-mnote-data-canon.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <libexif/exif-byte-order.h>
+#include <libexif/exif-utils.h>
+#include <libexif/exif-data.h>
+
+#define CHECKOVERFLOW(offset,datasize,structsize) (( offset >= datasize) || (structsize > datasize) || (offset > datasize - structsize ))
+
+/* Total size limit to prevent abuse by DoS */
+#define FAILSAFE_SIZE_MAX 1000000L
+
+static void
+exif_mnote_data_canon_clear (ExifMnoteDataCanon *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_canon_free (ExifMnoteData *n)
+{
+	if (!n) return;
+
+	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 *dc = (ExifMnoteDataCanon *) note;
+	unsigned int m, s;
+
+	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
+exif_mnote_data_canon_set_byte_order (ExifMnoteData *d, ExifByteOrder o)
+{
+	ExifByteOrder o_orig;
+	ExifMnoteDataCanon *n = (ExifMnoteDataCanon *) d;
+	unsigned int i;
+
+	if (!n) return;
+
+	o_orig = n->order;
+	n->order = o;
+	for (i = 0; i < n->count; i++) {
+		if (n->entries[i].components && (n->entries[i].size/n->entries[i].components < exif_format_get_size (n->entries[i].format)))
+			continue;
+		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_canon_set_offset (ExifMnoteData *n, unsigned int o)
+{
+	if (n) ((ExifMnoteDataCanon *) n)->offset = o;
+}
+
+static void
+exif_mnote_data_canon_save (ExifMnoteData *ne, 
+	unsigned char **buf, unsigned int *buf_size)
+{
+	ExifMnoteDataCanon *n = (ExifMnoteDataCanon *) 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 = 2 + n->count * 12 + 4;
+	*buf = exif_mem_alloc (ne->mem, sizeof (char) * *buf_size);
+	if (!*buf) {
+		EXIF_LOG_NO_MEMORY(ne->log, "ExifMnoteCanon", *buf_size);
+		return;
+	}
+
+	/* Save the number of entries */
+	exif_set_short (*buf, n->order, (ExifShort) n->count);
+	
+	/* Save each entry */
+	for (i = 0; i < n->count; i++) {
+		o = 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,
+						 sizeof (char) * ts);
+			if (!t) {
+				EXIF_LOG_NO_MEMORY(ne->log, "ExifMnoteCanon", ts);
+				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);
+		} 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);
+		if (s < 4) memset (*buf + doff + s, 0, (4 - s));
+	}
+}
+
+/* XXX
+ * FIXME: exif_mnote_data_canon_load() may fail and there is no
+ *        semantics to express that.
+ *        See bug #1054323 for details, especially the comment by liblit
+ *        after it has supposedly been fixed:
+ *
+ *        https://sourceforge.net/tracker/?func=detail&aid=1054323&group_id=12272&atid=112272
+ *        Unfortunately, the "return" statements aren't commented at
+ *        all, so it isn't trivial to find out what is a normal
+ *        return, and what is a reaction to an error condition.
+ */
+
+static void
+exif_mnote_data_canon_load (ExifMnoteData *ne,
+	const unsigned char *buf, unsigned int buf_size)
+{
+	ExifMnoteDataCanon *n = (ExifMnoteDataCanon *) ne;
+	ExifShort c;
+	size_t i, tcount, o, datao;
+	long failsafe_size = 0;
+
+	if (!n || !buf || !buf_size) {
+		exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
+			  "ExifMnoteCanon", "Short MakerNote");
+		return;
+	}
+	datao = 6 + n->offset;
+	if (CHECKOVERFLOW(datao, buf_size, 2)) {
+		exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
+			  "ExifMnoteCanon", "Short MakerNote");
+		return;
+	}
+
+	/* Read the number of tags */
+	c = exif_get_short (buf + datao, n->order);
+	datao += 2;
+	/* Just use an arbitrary max tag limit here to avoid needing to much memory or time. There are 24 named tags currently.
+	 * The format allows specifying the same range of memory as often as it can, so this multiplies quickly. */
+	if (c > 100) {
+		exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifMnoteCanon", "Too much tags (%d) in Canon MakerNote", c);
+		return;
+	}
+
+	/* Remove any old entries */
+	exif_mnote_data_canon_clear (n);
+
+	/* Reserve enough space for all the possible MakerNote tags */
+	n->entries = exif_mem_alloc (ne->mem, sizeof (MnoteCanonEntry) * c);
+	if (!n->entries) {
+		EXIF_LOG_NO_MEMORY(ne->log, "ExifMnoteCanon", sizeof (MnoteCanonEntry) * c);
+		return;
+	}
+
+	/* Parse the entries */
+	tcount = 0;
+	for (i = c, o = datao; i; --i, o += 12) {
+		size_t s;
+
+		memset(&n->entries[tcount], 0, sizeof(MnoteCanonEntry));
+		if (CHECKOVERFLOW(o,buf_size,12)) {
+			exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
+				"ExifMnoteCanon", "Short MakerNote");
+			break;
+		}
+
+		n->entries[tcount].tag        = exif_get_short (buf + o, n->order);
+		n->entries[tcount].format     = exif_get_short (buf + o + 2, n->order);
+		n->entries[tcount].components = exif_get_long (buf + o + 4, n->order);
+		n->entries[tcount].order      = n->order;
+
+		exif_log (ne->log, EXIF_LOG_CODE_DEBUG, "ExifMnoteCanon",
+			"Loading entry 0x%x ('%s')...", n->entries[tcount].tag,
+			 mnote_canon_tag_get_name (n->entries[tcount].tag));
+
+		/* Check if we overflow the multiplication. Use buf_size as the max size for integer overflow detection,
+		 * we will check the buffer sizes closer later. */
+		if (	exif_format_get_size (n->entries[tcount].format) &&
+			buf_size / exif_format_get_size (n->entries[tcount].format) < n->entries[tcount].components
+		) {
+			exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
+				  "ExifMnoteCanon", "Tag size overflow detected (%u * %lu)", exif_format_get_size (n->entries[tcount].format), n->entries[tcount].components);
+			continue;
+		}
+
+		/*
+		 * 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[tcount].format) * 
+								  n->entries[tcount].components;
+		n->entries[tcount].size = s;
+		if (!s) {
+			exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
+				  "ExifMnoteCanon",
+				  "Invalid zero-length tag size");
+			continue;
+
+		} else {
+			size_t dataofs = o + 8;
+			if (s > 4) dataofs = exif_get_long (buf + dataofs, n->order) + 6;
+
+			if (CHECKOVERFLOW(dataofs, buf_size, s)) {
+				exif_log (ne->log, EXIF_LOG_CODE_DEBUG,
+					"ExifMnoteCanon",
+					"Tag data past end of buffer (%u > %u)",
+					(unsigned)(dataofs + s), buf_size);
+				continue;
+			}
+
+			n->entries[tcount].data = exif_mem_alloc (ne->mem, s);
+			if (!n->entries[tcount].data) {
+				EXIF_LOG_NO_MEMORY(ne->log, "ExifMnoteCanon", s);
+				continue;
+			}
+			memcpy (n->entries[tcount].data, buf + dataofs, s);
+		}
+
+		/* Track the size of decoded tag data. A malicious file could
+		 * be crafted to cause extremely large values here without
+		 * tripping any buffer range checks.  This is especially bad
+		 * with the libexif representation of Canon MakerNotes because
+		 * some arrays are turned into individual tags that the
+		 * application must loop around. */
+		failsafe_size += mnote_canon_entry_count_values(&n->entries[tcount]);
+
+		if (failsafe_size > FAILSAFE_SIZE_MAX) {
+			/* Abort if the total size of the data in the tags extraordinarily large, */
+			exif_mem_free (ne->mem, n->entries[tcount].data);
+			exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
+					  "ExifMnoteCanon", "Failsafe tag size overflow (%lu > %ld)",
+					  failsafe_size, FAILSAFE_SIZE_MAX);
+			break;
+		}
+
+		/* Tag was successfully parsed */
+		++tcount;
+	}
+	/* Store the count of successfully parsed tags */
+	n->count = tcount;
+}
+
+static unsigned int
+exif_mnote_data_canon_count (ExifMnoteData *n)
+{
+	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 i)
+{
+	ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) d;
+	unsigned int m;
+
+	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 *dc = (ExifMnoteDataCanon *) note;
+	unsigned int m, s;
+
+	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 *dc = (ExifMnoteDataCanon *) note;
+	unsigned int m, s;
+
+	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 *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);
+}
+
+int
+exif_mnote_data_canon_identify (const ExifData *ed, const ExifEntry *e)
+{
+	char value[8];
+
+	(void) e;  /* unused */
+	ExifEntry *em = exif_data_get_entry (ed, EXIF_TAG_MAKE);
+	if (!em) 
+		return 0;
+	return !strcmp (exif_entry_get_value (em, value, sizeof (value)), "Canon");
+}
+
+ExifMnoteData *
+exif_mnote_data_canon_new (ExifMem *mem, ExifDataOption o)
+{
+	ExifMnoteData *d;
+	ExifMnoteDataCanon *dc;
+
+	if (!mem) return NULL;
+
+	d = exif_mem_alloc (mem, sizeof (ExifMnoteDataCanon));
+	if (!d)
+		return NULL;
+
+	exif_mnote_data_construct (d, mem);
+
+	/* Set up function pointers */
+	d->methods.free            = exif_mnote_data_canon_free;
+	d->methods.set_byte_order  = exif_mnote_data_canon_set_byte_order;
+	d->methods.set_offset      = exif_mnote_data_canon_set_offset;
+	d->methods.load            = exif_mnote_data_canon_load;
+	d->methods.save            = exif_mnote_data_canon_save;
+	d->methods.count           = exif_mnote_data_canon_count;
+	d->methods.get_id          = exif_mnote_data_canon_get_id;
+	d->methods.get_name        = exif_mnote_data_canon_get_name;
+	d->methods.get_title       = exif_mnote_data_canon_get_title;
+	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;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/canon/exif-mnote-data-canon.h

@@ -0,0 +1,58 @@
+/* exif-mnote-data-canon.h
+ *
+ * Copyright (c) 2002, 2003 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __EXIF_MNOTE_DATA_CANON_H__
+#define __EXIF_MNOTE_DATA_CANON_H__
+
+#include <libexif/exif-byte-order.h>
+#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;
+
+#include <libexif/canon/mnote-canon-entry.h>
+
+struct _ExifMnoteDataCanon {
+	ExifMnoteData parent;
+
+	MnoteCanonEntry *entries;
+	unsigned int count;
+
+	ExifByteOrder order;
+	unsigned int offset;
+
+	ExifDataOption options;
+};
+
+/*! Detect if MakerNote is recognized as one handled by the Canon module.
+ * 
+ * \param[in] ed image #ExifData to identify as as a Canon type
+ * \param[in] e #ExifEntry for EXIF_TAG_MAKER_NOTE, from within ed but
+ *   duplicated here for convenience
+ * \return 0 if not recognized, nonzero if recognized. The specific nonzero 
+ *   value returned may identify a subtype unique within this module.
+ */
+int exif_mnote_data_canon_identify (const ExifData *ed, const ExifEntry *e);
+
+ExifMnoteData *exif_mnote_data_canon_new (ExifMem *mem, ExifDataOption o);
+
+#endif /* __EXIF_MNOTE_DATA_CANON_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/canon/mnote-canon-entry.c

@@ -0,0 +1,822 @@
+/* mnote-canon-entry.c
+ *
+ * Copyright (c) 2002 Lutz Mueller <[email protected]>
+ * Copyright (c) 2003 Matthieu Castet <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include "config.h"
+#include "mnote-canon-entry.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <libexif/exif-format.h>
+#include <libexif/exif-utils.h>
+#include <libexif/i18n.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;                                                  \
+        }                                                               \
+}
+#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;                                                  \
+	}                                                               \
+}
+
+#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,  37, N_("Canon EF 35-80mm f/4-5.6")},
+  {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,  52, N_("Canon EF-S 18-55mm f/3.5-5.6 IS II")},
+  {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")},
+  {21, 251, N_("Canon EF 70-200mm f/2.8L IS II 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 set 1")},
+  {7, 11, N_("PC set 2")},
+  {7, 12, N_("PC set 3")},
+  {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, _(", "), 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, unsigned int t, char *val, unsigned int maxlen)
+{
+	char buf[128];
+	ExifLong vl;
+	ExifSLong vsl;
+	ExifShort vs, n;
+	ExifSShort vss;
+	unsigned char *data;
+	size_t	size;
+	double d;
+
+	if (!entry) 
+		return NULL;
+
+	data = entry->data;
+	size = entry->size;
+
+	memset (val, 0, maxlen);
+	maxlen--;
+
+	switch (entry->tag) {
+	case MNOTE_CANON_TAG_SETTINGS_1:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+
+		if (size < 2) return NULL;
+		n = exif_get_short (data, entry->order) / 2;
+		if (t >= n) return NULL;
+
+		CC (entry->components, n, val, maxlen);
+
+		if (size < 2 + t*2 + 2) return NULL;
+		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 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 22:
+		case 23:
+		case 24:
+			snprintf (val, maxlen, "%u", vs);
+			break;
+		case 25:
+		case 26:
+			snprintf (val, maxlen, "%.2f", apex_value_to_aperture (vs / 32.0));
+			break;
+		case 28:
+			canon_search_table_bitfield(entries_settings_1, t, vs, val, maxlen);
+			break;
+		case 34:
+			snprintf (val, maxlen, "%.2f", vs / 10.0);
+			break;
+		case 35:
+		case 36:
+			snprintf (val, maxlen, "%u", vs);
+			break;
+		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);
+		if (size < t*2 + 2) return NULL;
+		vs = exif_get_short (data + t * 2, entry->order);
+		switch (t) {
+		case 1:
+			snprintf (val, maxlen, "%u", vs);
+			break;
+		case 2:
+		case 3:
+			snprintf (val, maxlen, _("%.2f mm"), vs * 25.4 / 1000);
+			break;
+		default:
+			canon_search_table_value (entries_focal_length, t, vs, val, maxlen);
+		}
+		break;
+
+	case MNOTE_CANON_TAG_SETTINGS_2:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+		if (size < 2) return NULL;
+		n = exif_get_short (data, entry->order) / 2;
+		if (t >= n) return NULL;
+		CC (entry->components, n, val, maxlen);
+		if (size < 2 + t*2 + 2) return NULL;
+		vss = exif_get_sshort (data + 2 + t * 2, entry->order);
+		switch (t) {
+		case 0:
+			snprintf (val, maxlen, "%.3f", pow (2, vss / 32.0));
+			break;
+		case 1:
+			snprintf (val, maxlen, "%.0f", apex_value_to_iso_speed (vss / 32.0));
+			break;
+		case 2:
+		case 5:
+		case 14:
+		case 16:
+			snprintf (val, maxlen, _("%.2f EV"), vss / 32.0);
+			break;
+		case 3:
+		case 20:
+			snprintf (val, maxlen, "%.2f", apex_value_to_aperture (vss / 32.0));
+			break;
+		case 4:
+		case 21:
+			d = apex_value_to_shutter_speed (vss / 32.0);
+			if (d < 1)
+				snprintf (val, maxlen, _("1/%.0f"), 1.0 / d);
+			else
+				snprintf (val, maxlen, "%.0f", d);
+			break;
+		case 8:
+			snprintf (val, maxlen, "%u", vss);
+			break;
+		case 12:
+			snprintf (val, maxlen, "%.2f", vss / 32.0);
+			break;
+		case 18:
+		case 19:
+			snprintf (val, maxlen, _("%u mm"), vss);
+			break;
+		case 28:
+			if (vss <= 0) {
+				strncpy(val, _("Off"), maxlen);
+				break;
+			}
+			snprintf (val, maxlen, _("%i (ms)"), vss * 100);
+			break;
+		default:
+			canon_search_table_value (entries_settings_2, t, vss, val, maxlen);
+		}
+		break;
+
+	case MNOTE_CANON_TAG_PANORAMA:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+		if (size < t*2 + 2) return NULL;
+		vs = exif_get_short (data + t * 2, entry->order);
+		canon_search_table_value (entries_panorama, t, vs, val, maxlen);
+		break;
+
+	case MNOTE_CANON_TAG_OWNER:
+		CC (entry->components, 32, val, 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); Can also be 22 */
+		strncpy (val, (char *)data, MIN (entry->size, maxlen));
+		break;
+
+	case MNOTE_CANON_TAG_IMAGE_NUMBER:
+		CF (entry->format, EXIF_FORMAT_LONG, val, maxlen);
+		CC (entry->components, 1, val, maxlen);
+		if (size < 4) return NULL;
+		vl = exif_get_long (data, entry->order);
+		snprintf (val, maxlen, "%03lu-%04lu",
+				(unsigned long) vl/10000,
+				(unsigned long) vl%10000);
+		break;
+
+	case MNOTE_CANON_TAG_SERIAL_NUMBER:
+		CF (entry->format, EXIF_FORMAT_LONG, val, maxlen);
+		CC (entry->components, 1, val, maxlen);
+		if (size < 4) return NULL;
+		vl = exif_get_long (data, entry->order);
+		snprintf (val, maxlen, "%04X-%05d", (int)vl>>16,(int)vl&0xffff);
+		break;
+
+	case MNOTE_CANON_TAG_CUSTOM_FUNCS:
+		CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
+		if (size < 2) return NULL;
+		n = exif_get_short (data, entry->order) / 2;
+		if (t >= n) return NULL;
+		CC (entry->components, n, val, maxlen);
+		if (size < 2 + t*2 + 2) return NULL;
+		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);
+		if (size < 2) return NULL;
+		n = exif_get_short (data, entry->order) / 2;
+		if (t >= n) return NULL;
+		CC (entry->components, n, val, maxlen);
+		if (size < 2 + t*2 + 2) return NULL;
+		vs = exif_get_short (data + 2 + t * 2, entry->order);
+		canon_search_table_value (color_information, t, vs, val, maxlen);
+		break;
+
+	default:
+		switch (entry->format) {
+		case EXIF_FORMAT_SHORT:
+		  {
+			size_t i, len = strlen(val);
+			for(i=0; i<entry->components; i++) {
+				if (size < 2)
+					break;
+				vs = exif_get_short (data, entry->order);
+				snprintf (val+len, maxlen-len, "%hu ", vs);
+				len = strlen(val);
+				data += 2;
+				size -= 2;
+			}
+		  }
+		  break;
+		case EXIF_FORMAT_SSHORT:
+		  {
+			size_t i, len = strlen(val);
+			for(i=0; i<entry->components; i++) {
+				if (size < 2)
+					break;
+				vss = exif_get_sshort (data, entry->order);
+				snprintf (val+len, maxlen-len, "%hi ", vss);
+				data += 2;
+				size -= 2;
+			}
+		  }
+		  break;
+		case EXIF_FORMAT_LONG:
+		  {
+			size_t i, len = strlen(val);
+			for(i=0; i<entry->components; i++) {
+				if (size < 4)
+					break;
+				vl = exif_get_long (data, entry->order);
+				snprintf (val+len, maxlen-len, "%lu ", (long unsigned) vl);
+				data += 4;
+				size -= 4;
+			}
+		  }
+		  break;
+		case EXIF_FORMAT_SLONG:
+		  {
+			size_t i, len = strlen(val);
+			for(i=0; i<entry->components; i++) {
+				if (size < 4)
+					break;
+				vsl = exif_get_slong (data, entry->order);
+				snprintf (val+len, maxlen-len, "%li ", (long int) vsl);
+				data += 4;
+				size -= 4;
+			}
+		  }
+		  break;
+		case EXIF_FORMAT_ASCII:
+			strncpy (val, (char *)data, MIN (entry->size, maxlen));
+			break;
+		default:
+		  snprintf (val, maxlen, _("%i bytes unknown data"),
+			  entry->size);
+		  break;
+		}
+		break;
+	}
+	return val;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/canon/mnote-canon-entry.h

@@ -0,0 +1,44 @@
+/* mnote-canon-entry.h
+ *
+ * Copyright (c) 2002 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __MNOTE_CANON_ENTRY_H__
+#define __MNOTE_CANON_ENTRY_H__
+
+#include <libexif/exif-format.h>
+#include <libexif/exif-byte-order.h>
+#include <libexif/canon/mnote-canon-tag.h>
+
+typedef struct _MnoteCanonEntry        MnoteCanonEntry;
+
+struct _MnoteCanonEntry {
+	MnoteCanonTag tag;
+	ExifFormat format;
+	unsigned long components;
+
+	unsigned char *data;
+	unsigned int size;
+
+	ExifByteOrder order;
+};
+
+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__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/canon/mnote-canon-tag.c

@@ -0,0 +1,201 @@
+/* mnote-canon-tag.c
+ *
+ * Copyright (c) 2002 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+#include "mnote-canon-tag.h"
+
+#include <stdlib.h>
+
+#include <libexif/i18n.h>
+
+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_("F-Number")},
+	{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; /* 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;
+
+	(void) 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_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;
+
+	for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
+		if (table[i].tag == t) {
+			if (!table[i].description || !*table[i].description)
+				return "";
+			(void) bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+			return _(table[i].description);
+		}
+	return NULL;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/canon/mnote-canon-tag.h

@@ -0,0 +1,59 @@
+/* mnote-canon-tag.h
+ *
+ * Copyright (c) 2002 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __MNOTE_CANON_TAG_H__
+#define __MNOTE_CANON_TAG_H__
+
+#include <libexif/exif-data.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+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,
+	MNOTE_CANON_TAG_OWNER		= 0x9,
+	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_COLOR_INFORMATION = 0xa0
+};
+typedef enum _MnoteCanonTag MnoteCanonTag;
+
+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
+}
+#endif /* __cplusplus */
+
+#endif /* __MNOTE_CANON_TAG_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-byte-order.c

@@ -0,0 +1,39 @@
+/* exif-byte-order.c
+ *
+ * Copyright (c) 2002 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+
+#include <libexif/exif-byte-order.h>
+#include <libexif/i18n.h>
+
+#include <stdlib.h>
+
+const char *
+exif_byte_order_get_name (ExifByteOrder order)
+{
+	switch (order) {
+	case EXIF_BYTE_ORDER_MOTOROLA:
+		return (_("Motorola"));
+	case EXIF_BYTE_ORDER_INTEL:
+		return (_("Intel"));
+	default:
+		return NULL;
+	}
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-byte-order.h

@@ -0,0 +1,48 @@
+/*! \file exif-byte-order.h
+ * \brief Defines the ExifByteOrder enum and the associated functions.
+ */
+/* 
+ * Copyright (c) 2002 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __EXIF_BYTE_ORDER_H__
+#define __EXIF_BYTE_ORDER_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*! Which byte order to use */
+typedef enum {
+	/*! Big-endian byte order */
+	EXIF_BYTE_ORDER_MOTOROLA,
+	/*! Little-endian byte order */
+	EXIF_BYTE_ORDER_INTEL
+} ExifByteOrder;
+
+/*! Return a short, localized, textual name for the given byte order.
+ * \param[in] order byte order
+ * \return localized textual name of the byte order, or NULL if unknown
+ */
+const char *exif_byte_order_get_name (ExifByteOrder order);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __EXIF_BYTE_ORDER_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-content.c

@@ -0,0 +1,333 @@
+/* exif-content.c
+ *
+ * Copyright (c) 2001 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+
+#include <libexif/exif-content.h>
+#include <libexif/exif-system.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* unused constant
+ * static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
+ */
+
+struct _ExifContentPrivate
+{
+	unsigned int ref_count;
+
+	ExifMem *mem;
+	ExifLog *log;
+};
+
+ExifContent *
+exif_content_new (void)
+{
+	ExifMem *mem = exif_mem_new_default ();
+	ExifContent *content = exif_content_new_mem (mem);
+
+	exif_mem_unref (mem);
+
+	return content;
+}
+
+ExifContent *
+exif_content_new_mem (ExifMem *mem)
+{
+	ExifContent *content;
+
+	if (!mem) return NULL;
+
+	content = exif_mem_alloc (mem, (ExifLong) sizeof (ExifContent));
+	if (!content)
+		return NULL;
+	content->priv = exif_mem_alloc (mem,
+				(ExifLong) sizeof (ExifContentPrivate));
+	if (!content->priv) {
+		exif_mem_free (mem, content);
+		return NULL;
+	}
+
+	content->priv->ref_count = 1;
+
+	content->priv->mem = mem;
+	exif_mem_ref (mem);
+
+	return content;
+}
+
+void
+exif_content_ref (ExifContent *content)
+{
+	if (!content)
+		return;
+
+	content->priv->ref_count++;
+}
+
+void
+exif_content_unref (ExifContent *content)
+{
+	if (!content)
+		return;
+
+	content->priv->ref_count--;
+	if (!content->priv->ref_count)
+		exif_content_free (content);
+}
+
+void
+exif_content_free (ExifContent *content)
+{
+	ExifMem *mem = (content && content->priv) ? content->priv->mem : NULL;
+	unsigned int i;
+
+	if (!content) return;
+
+	for (i = 0; i < content->count; i++)
+		exif_entry_unref (content->entries[i]);
+	exif_mem_free (mem, content->entries);
+
+	if (content->priv) {
+		exif_log_unref (content->priv->log);
+	}
+
+	exif_mem_free (mem, content->priv);
+	exif_mem_free (mem, content);
+	exif_mem_unref (mem);
+}
+
+void
+exif_content_dump (ExifContent *content, unsigned int indent)
+{
+	char buf[1024];
+	unsigned int i, l;
+
+	if (!content)
+		return;
+
+	l = MIN(sizeof(buf)-1, 2*indent);
+	memset(buf, ' ', l);
+	buf[l] = '\0';
+
+	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);
+}
+
+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. */
+	if (exif_content_get_entry (c, entry->tag)) {
+		exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "ExifContent",
+			"An attempt has been made to add "
+			"the tag '%s' twice to an IFD. This is against "
+			"specification.", exif_tag_get_name (entry->tag));
+		return;
+	}
+
+	entries = exif_mem_realloc (c->priv->mem,
+		c->entries, sizeof (ExifEntry*) * (c->count + 1));
+	if (!entries) return;
+	entry->parent = c;
+	entries[c->count++] = entry;
+	c->entries = entries;
+	exif_entry_ref (entry);
+}
+
+void
+exif_content_remove_entry (ExifContent *c, ExifEntry *e)
+{
+	unsigned int i;
+	ExifEntry **t, *temp;
+
+	if (!c || !c->priv || !e || (e->parent != c)) return;
+
+	/* Search the entry */
+	for (i = 0; i < c->count; i++)
+			if (c->entries[i] == e)
+					break;
+
+	if (i == c->count)
+			return;
+
+	/* Remove the entry */
+	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);
+}
+
+ExifEntry *
+exif_content_get_entry (ExifContent *content, ExifTag tag)
+{
+	unsigned int i;
+
+	if (!content)
+		return (NULL);
+
+	for (i = 0; i < content->count; i++)
+		if (content->entries[i]->tag == tag)
+			return (content->entries[i]);
+	return (NULL);
+}
+
+void
+exif_content_foreach_entry (ExifContent *content,
+			    ExifContentForeachEntryFunc func, void *data)
+{
+	unsigned int i;
+
+	if (!content || !func)
+		return;
+
+	for (i = 0; i < content->count; i++)
+		func (content->entries[i], data);
+}
+
+void
+exif_content_log (ExifContent *content, ExifLog *log)
+{
+	if (!content || !content->priv || !log || content->priv->log == log)
+		return;
+
+	if (content->priv->log) exif_log_unref (content->priv->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_EXIF] == (c)) ? EXIF_IFD_EXIF :
+		((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_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);
+}
+
+/*!
+ * Check if this entry is unknown and if so, delete it.
+ * \note Be careful calling this function in a loop. Deleting an entry from
+ * an ExifContent changes the index of subsequent entries, as well as the
+ * total size of the entries array.
+ */
+static void
+remove_not_recorded (ExifEntry *e, void *UNUSED(data))
+{
+	ExifIfd ifd = exif_entry_get_ifd(e) ;
+	ExifContent *c = e->parent;
+	ExifDataType dt = exif_data_get_data_type (c->parent);
+	ExifTag t = e->tag;
+
+	if (exif_tag_get_support_level_in_ifd (t, ifd, dt) ==
+			 EXIF_SUPPORT_LEVEL_NOT_RECORDED) {
+		exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "exif-content",
+				"Tag 0x%04x is not recorded in IFD '%s' and has therefore been "
+				"removed.", t, exif_ifd_get_name (ifd));
+		exif_content_remove_entry (c, e);
+	}
+
+}
+
+void
+exif_content_fix (ExifContent *c)
+{
+	ExifIfd ifd = exif_content_get_ifd (c);
+	ExifDataType dt;
+	ExifEntry *e;
+	unsigned int i, num;
+
+	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);
+
+	/*
+	 * Go through each tag and if it's not recorded, remove it. If one
+	 * is removed, exif_content_foreach_entry() will skip the next entry,
+	 * so if this happens do the loop again from the beginning to ensure
+	 * they're all checked. This could be avoided if we stop relying on
+	 * exif_content_foreach_entry but loop intelligently here.
+	 */
+	do {
+		num = c->count;
+		exif_content_foreach_entry (c, remove_not_recorded, NULL);
+	} while (num != c->count);
+
+	/*
+	 * Then check for non-existing mandatory tags and create them if needed
+	 */
+	num = exif_tag_table_count();
+	for (i = 0; i < num; ++i) {
+		const ExifTag t = exif_tag_table_get_tag (i);
+		if (exif_tag_get_support_level_in_ifd (t, ifd, dt) ==
+			EXIF_SUPPORT_LEVEL_MANDATORY) {
+			if (exif_content_get_entry (c, t))
+				/* This tag already exists */
+				continue;
+			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);
+		}
+	}
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-content.h

@@ -0,0 +1,181 @@
+/*! \file exif-content.h
+ *  \brief Handling EXIF IFDs
+ */
+/*
+ * Copyright (c) 2001 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __EXIF_CONTENT_H__
+#define __EXIF_CONTENT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*! Holds all EXIF tags in a single IFD */
+typedef struct _ExifContent        ExifContent;
+typedef struct _ExifContentPrivate ExifContentPrivate;
+
+#include <libexif/exif-tag.h>
+#include <libexif/exif-entry.h>
+#include <libexif/exif-data.h>
+#include <libexif/exif-log.h>
+#include <libexif/exif-mem.h>
+
+struct _ExifContent
+{
+        ExifEntry **entries;
+        unsigned int count;
+
+	/*! Data containing this content */
+	ExifData *parent;
+
+	ExifContentPrivate *priv;
+};
+
+/* Lifecycle */
+
+/*! Reserve memory for and initialize a new #ExifContent.
+ *
+ * \return new allocated #ExifContent, or NULL on error
+ *
+ * \see exif_content_new_mem, exif_content_unref
+ */
+ExifContent *exif_content_new     (void);
+
+/*! Reserve memory for and initialize new #ExifContent using the specified
+ * memory allocator.
+ *
+ * \return new allocated #ExifContent, or NULL on error
+ *
+ * \see exif_content_new, exif_content_unref
+ */
+ExifContent *exif_content_new_mem (ExifMem *);
+
+/*! Increase reference counter for #ExifContent.
+ *
+ * \param[in] content #ExifContent
+ *
+ * \see exif_content_unref
+ */
+void         exif_content_ref     (ExifContent *content);
+
+/*! Decrease reference counter for #ExifContent.
+ * When the reference count drops to zero, free the content.
+ *
+ * \param[in] content #ExifContent
+ */
+void         exif_content_unref   (ExifContent *content);
+
+/*! Actually free the #ExifContent.
+ *
+ * \deprecated Should not be called directly. Use #exif_content_ref and
+ *             #exif_content_unref instead.
+ *
+ * \param[in] content #ExifContent
+ */
+void         exif_content_free    (ExifContent *content);
+
+/*! Add an EXIF tag to an IFD.
+ * If this tag already exists in the IFD, this function does nothing.
+ * \pre The "tag" member of the entry must be set on entry.
+ *
+ * \param[out] c IFD
+ * \param[in] entry EXIF entry to add
+ */
+void         exif_content_add_entry    (ExifContent *c, ExifEntry *entry);
+
+/*! Remove an EXIF tag from an IFD.
+ * If this tag does not exist in the IFD, this function does nothing.
+ *
+ * \param[out] c IFD
+ * \param[in] e EXIF entry to remove
+ */
+void         exif_content_remove_entry (ExifContent *c, ExifEntry *e);
+
+/*! Return the #ExifEntry in this IFD corresponding to the given tag.
+ * This is a pointer into a member of the #ExifContent array and must NOT be
+ * freed or unrefed by the caller.
+ *
+ * \param[in] content EXIF content for an IFD
+ * \param[in] tag EXIF tag to return
+ * \return #ExifEntry of the tag, or NULL on error
+ */
+ExifEntry   *exif_content_get_entry    (ExifContent *content, ExifTag tag);
+
+/*! Fix the IFD to bring it into specification. Call #exif_entry_fix on
+ * each entry in this IFD to fix existing entries, create any new entries
+ * that are mandatory in this IFD but do not yet exist, and remove any
+ * entries that are not allowed in this IFD.
+ *
+ * \param[in,out] c EXIF content for an IFD
+ */
+void         exif_content_fix          (ExifContent *c);
+
+typedef void (* ExifContentForeachEntryFunc) (ExifEntry *, void *user_data);
+
+/*! Executes function on each EXIF tag in this IFD in turn.
+ * The tags will not necessarily be visited in numerical order.
+ *
+ * \param[in,out] content IFD over which to iterate
+ * \param[in] func function to call for each entry
+ * \param[in] user_data data to pass into func on each call
+ */
+void         exif_content_foreach_entry (ExifContent *content,
+					 ExifContentForeachEntryFunc func,
+					 void *user_data);
+
+/*! Return the IFD number in which the given #ExifContent is found.
+ *
+ * \param[in] c an #ExifContent*
+ * \return IFD number, or #EXIF_IFD_COUNT on error
+ */
+ExifIfd exif_content_get_ifd (ExifContent *c);
+
+/*! Return a textual representation of the EXIF data for a tag.
+ *
+ * \param[in] c #ExifContent* for an IFD
+ * \param[in] t #ExifTag to return
+ * \param[out] v char* buffer in which to store value
+ * \param[in] m unsigned int length of the buffer v
+ * \return the v pointer, or NULL on error
+ */
+#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)
+
+/*! Dump contents of the IFD to stdout.
+ * This is intended for diagnostic purposes only.
+ *
+ * \param[in] content IFD data
+ * \param[in] indent how many levels deep to indent the data
+ */
+void exif_content_dump  (ExifContent *content, unsigned int indent);
+
+/*! Set the log message object for this IFD.
+ *
+ * \param[in] content IFD
+ * \param[in] log #ExifLog*
+ */
+void exif_content_log   (ExifContent *content, ExifLog *log);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __EXIF_CONTENT_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-data-type.h

@@ -0,0 +1,46 @@
+/* exif-data-tag.h
+ *
+ * Copyright (c) 2005 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __EXIF_DATA_TYPE_H__
+#define __EXIF_DATA_TYPE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*! Represents the type of image data to which the EXIF data applies.
+ * The EXIF tags have different constraints depending on the type of
+ * image data.
+ */
+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,
+
+	EXIF_DATA_TYPE_UNKNOWN = EXIF_DATA_TYPE_COUNT
+} ExifDataType;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __EXIF_TAG_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-data.c

@@ -0,0 +1,1348 @@
+/* exif-data.c
+ *
+ * Copyright (c) 2001 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+
+#include <libexif/exif-mnote-data.h>
+#include <libexif/exif-data.h>
+#include <libexif/exif-ifd.h>
+#include <libexif/exif-mnote-data-priv.h>
+#include <libexif/exif-utils.h>
+#include <libexif/exif-loader.h>
+#include <libexif/exif-log.h>
+#include <libexif/i18n.h>
+#include <libexif/exif-system.h>
+
+#include <libexif/apple/exif-mnote-data-apple.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 <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#undef JPEG_MARKER_SOI
+#define JPEG_MARKER_SOI  0xd8
+#undef JPEG_MARKER_APP0
+#define JPEG_MARKER_APP0 0xe0
+#undef JPEG_MARKER_APP1
+#define JPEG_MARKER_APP1 0xe1
+
+#define CHECKOVERFLOW(offset,datasize,structsize) (( offset >= datasize) || (structsize > datasize) || (offset > datasize - structsize ))
+
+static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
+
+struct _ExifDataPrivate
+{
+	ExifByteOrder order;
+
+	ExifMnoteData *md;
+
+	ExifLog *log;
+	ExifMem *mem;
+
+	unsigned int ref_count;
+
+	/* Temporarily used while loading data */
+	unsigned int offset_mnote;
+
+	ExifDataOption options;
+	ExifDataType data_type;
+};
+
+static void *
+exif_data_alloc (ExifData *data, unsigned int i)
+{
+	void *d;
+
+	if (!data || !i) 
+		return NULL;
+
+	d = exif_mem_alloc (data->priv->mem, i);
+	if (d) 
+		return d;
+
+	EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i);
+	return NULL;
+}
+
+ExifMnoteData *
+exif_data_get_mnote_data (ExifData *d)
+{
+	return (d && d->priv) ? d->priv->md : NULL;
+}
+
+ExifData *
+exif_data_new (void)
+{
+	ExifMem *mem = exif_mem_new_default ();
+	ExifData *d = exif_data_new_mem (mem);
+
+	exif_mem_unref (mem);
+
+	return d;
+}
+
+ExifData *
+exif_data_new_mem (ExifMem *mem)
+{
+	ExifData *data;
+	unsigned int i;
+
+	if (!mem) 
+		return NULL;
+
+	data = exif_mem_alloc (mem, sizeof (ExifData));
+	if (!data) 
+		return (NULL);
+	data->priv = exif_mem_alloc (mem, sizeof (ExifDataPrivate));
+	if (!data->priv) { 
+	  	exif_mem_free (mem, data); 
+		return (NULL); 
+	}
+	data->priv->ref_count = 1;
+
+	data->priv->mem = mem;
+	exif_mem_ref (mem);
+
+	for (i = 0; i < EXIF_IFD_COUNT; i++) {
+		data->ifd[i] = exif_content_new_mem (data->priv->mem);
+		if (!data->ifd[i]) {
+			exif_data_free (data);
+			return (NULL);
+		}
+		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);
+}
+
+ExifData *
+exif_data_new_from_data (const unsigned char *data, unsigned int size)
+{
+	ExifData *edata;
+
+	edata = exif_data_new ();
+	exif_data_load_data (edata, data, size);
+	return (edata);
+}
+
+static int
+exif_data_load_data_entry (ExifData *data, ExifEntry *entry,
+			   const unsigned char *d,
+			   unsigned int size, unsigned int offset)
+{
+	unsigned int s, doff;
+
+	entry->tag        = exif_get_short (d + offset + 0, data->priv->order);
+	entry->format     = exif_get_short (d + offset + 2, data->priv->order);
+	entry->components = exif_get_long  (d + offset + 4, data->priv->order);
+
+	/* FIXME: should use exif_tag_get_name_in_ifd here but entry->parent 
+	 * has not been set yet
+	 */
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+		  "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) || (s == 0)){
+		return 0;
+	}
+
+	/*
+	 * Size? If bigger than 4 bytes, the actual data is not
+	 * in the entry but somewhere else (offset).
+	 */
+	if (s > 4)
+		doff = exif_get_long (d + offset + 8, data->priv->order);
+	else
+		doff = offset + 8;
+
+	/* Sanity checks */
+	if (doff >= size) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+				  "Tag starts past end of buffer (%u > %u)", doff, size);
+		return 0;
+	}
+
+	if (s > size - doff) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+				  "Tag data goes past end of buffer (%u > %u)", doff+s, size);
+		return 0;
+	}
+
+	entry->data = exif_data_alloc (data, s);
+	if (entry->data) {
+		entry->size = s;
+		memcpy (entry->data, d + doff, s);
+	} else {
+		EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", s);
+		return 0;
+	}
+
+	/* If this is the MakerNote, remember the offset */
+	if (entry->tag == EXIF_TAG_MAKER_NOTE) {
+		if (!entry->data) {
+			exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+					  "MakerNote found with empty 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;
+	}
+	return 1;
+}
+
+static void
+exif_data_save_data_entry (ExifData *data, ExifEntry *e,
+			   unsigned char **d, unsigned int *ds,
+			   unsigned int offset)
+{
+	unsigned int doff, s;
+	unsigned int ts;
+
+	if (!data || !data->priv) 
+		return;
+
+	/*
+	 * Each entry is 12 bytes long. The memory for the entry has
+	 * already been allocated.
+	 */
+	exif_set_short (*d + 6 + offset + 0,
+			data->priv->order, (ExifShort) e->tag);
+	exif_set_short (*d + 6 + offset + 2,
+			data->priv->order, (ExifShort) e->format);
+
+	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) {
+			/* TODO: this is using the wrong ExifMem to free e->data */
+			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 (exif_format_get_size (e->format) != 1) {
+				/* e->format is taken from input code,
+				 * but we need to make sure it is a 1 byte
+				 * entity due to the multiplication below. */
+				e->format = EXIF_FORMAT_UNDEFINED;
+			}
+		}
+	}
+
+	exif_set_long  (*d + 6 + offset + 4,
+			data->priv->order, e->components);
+
+	/*
+	 * Size? If bigger than 4 bytes, the actual data is not in
+	 * the entry but somewhere else.
+	 */
+	s = exif_format_get_size (e->format) * e->components;
+	if (s > 4) {
+		unsigned char *t;
+		doff = *ds - 6;
+		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)
+			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';
+
+	} else
+		doff = offset + 8;
+
+	/* Write the data. Fill unneeded bytes with 0. Do not crash with
+	 * e->data is NULL */
+	if (e->data) {
+		unsigned int len = s;
+		if (e->size < s) len = e->size;
+		memcpy (*d + 6 + doff, e->data, len);
+	} 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 o, ExifLong s)
+{
+	/* Sanity checks */
+	if (o >= ds) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", "Bogus thumbnail offset (%u).", o);
+		return;
+	}
+	if (CHECKOVERFLOW(o,ds,s)) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", "Bogus thumbnail size (%u), max would be %u.", s, ds-o);
+		return;
+	}
+	if (data->data) 
+		exif_mem_free (data->priv->mem, data->data);
+	if (!(data->data = exif_data_alloc (data, s))) {
+		EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", s);
+		data->size = 0;
+		return;
+	}
+	data->size = s;
+	memcpy (data->data, d + o, s);
+}
+
+#undef CHECK_REC
+#define CHECK_REC(i) 					\
+if ((i) == ifd) {				\
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
+		"ExifData", "Recursive entry in IFD "	\
+		"'%s' detected. Skipping...",		\
+		exif_ifd_get_name (i));			\
+	break;						\
+}							\
+if (data->ifd[(i)]->count) {				\
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,	\
+		"ExifData", "Attempt to load IFD "	\
+		"'%s' multiple times detected. "	\
+		"Skipping...",				\
+		exif_ifd_get_name (i));			\
+	break;						\
+}
+
+/*! Calculate the recursion cost added by one level of IFD loading.
+ *
+ * The work performed is related to the cost in the exponential relation
+ *   work=1.1**cost
+ */
+static unsigned int
+level_cost(unsigned int n)
+{
+    static const double log_1_1 = 0.09531017980432493;
+
+	/* Adding 0.1 protects against the case where n==1 */
+	return ceil(log(n + 0.1)/log_1_1);
+}
+
+/*! Load data for an IFD.
+ *
+ * \param[in,out] data #ExifData
+ * \param[in] ifd IFD to load
+ * \param[in] d pointer to buffer containing raw IFD data
+ * \param[in] ds size of raw data in buffer at \c d
+ * \param[in] offset offset into buffer at \c d at which IFD starts
+ * \param[in] recursion_cost factor indicating how expensive this recursive
+ * call could be
+ */
+static void
+exif_data_load_data_content (ExifData *data, ExifIfd ifd,
+			     const unsigned char *d,
+			     unsigned int ds, unsigned int offset, unsigned int recursion_cost)
+{
+	ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
+	ExifShort n;
+	ExifEntry *entry;
+	unsigned int i;
+	ExifTag tag;
+
+	if (!data || !data->priv) 
+		return;
+
+	/* check for valid ExifIfd enum range */
+	if ((((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT))
+	  return;
+
+	if (recursion_cost > 170) {
+		/*
+		 * recursion_cost is a logarithmic-scale indicator of how expensive this
+		 * recursive call might end up being. It is an indicator of the depth of
+		 * recursion as well as the potential for worst-case future recursive
+		 * calls. Since it's difficult to tell ahead of time how often recursion
+		 * will occur, this assumes the worst by assuming every tag could end up
+		 * causing recursion.
+		 * The value of 170 was chosen to limit typical EXIF structures to a
+		 * recursive depth of about 6, but pathological ones (those with very
+		 * many tags) to only 2.
+		 */
+		exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
+			  "Deep/expensive recursion detected!");
+		return;
+	}
+
+	/* Read the number of entries */
+	if (CHECKOVERFLOW(offset, ds, 2)) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
+			  "Tag data past end of buffer (%u+2 > %u)", offset, ds);
+		return;
+	}
+	n = exif_get_short (d + offset, data->priv->order);
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+	          "Loading %hu entries...", n);
+	offset += 2;
+
+	/* Check if we have enough data. */
+	if (CHECKOVERFLOW(offset, ds, 12*n)) {
+		n = (ds - offset) / 12;
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+				  "Short data; only loading %hu entries...", n);
+	}
+
+	for (i = 0; i < n; i++) {
+
+		tag = exif_get_short (d + offset + 12 * i, data->priv->order);
+		switch (tag) {
+		case EXIF_TAG_EXIF_IFD_POINTER:
+		case EXIF_TAG_GPS_INFO_IFD_POINTER:
+		case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
+		case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
+		case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
+			o = exif_get_long (d + offset + 12 * i + 8,
+					   data->priv->order);
+			if (o >= ds) {
+				exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
+					  "Tag data past end of buffer (%u > %u)", offset+2, ds);
+				return;
+			}
+			/* FIXME: IFD_POINTER tags aren't marked as being in a
+			 * specific IFD, so exif_tag_get_name_in_ifd won't work
+			 */
+			exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+				  "Sub-IFD entry 0x%x ('%s') at %u.", tag,
+				  exif_tag_get_name(tag), o);
+			switch (tag) {
+			case EXIF_TAG_EXIF_IFD_POINTER:
+				CHECK_REC (EXIF_IFD_EXIF);
+				exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o,
+					recursion_cost + level_cost(n));
+				break;
+			case EXIF_TAG_GPS_INFO_IFD_POINTER:
+				CHECK_REC (EXIF_IFD_GPS);
+				exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o,
+					recursion_cost + level_cost(n));
+				break;
+			case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
+				CHECK_REC (EXIF_IFD_INTEROPERABILITY);
+				exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o,
+					recursion_cost + level_cost(n));
+				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);
+				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);
+				break;
+			default:
+				return;
+			}
+			break;
+		default:
+
+			/*
+			 * 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_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 %u in '%s'.", i, 
+						  exif_ifd_get_name (ifd));
+					break;
+				}
+				exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+					  "Unknown tag 0x%04x (entry %u in '%s'). Please report this tag "
+					  "to <[email protected]>.", 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);
+			if (!entry) {
+				  exif_log (data->priv->log, EXIF_LOG_CODE_NO_MEMORY, "ExifData",
+                                          "Could not allocate memory");
+				  return;
+			}
+			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;
+		}
+	}
+}
+
+static int
+cmp_func (const unsigned char *p1, const unsigned char *p2, ExifByteOrder o)
+{
+	ExifShort tag1 = exif_get_short (p1, o);
+	ExifShort tag2 = exif_get_short (p2, o);
+
+	return (tag1 < tag2) ? -1 : (tag1 > tag2) ? 1 : 0;
+}
+
+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);
+}
+
+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);
+}
+
+static void
+exif_data_save_data_content (ExifData *data, ExifContent *ifd,
+			     unsigned char **d, unsigned int *ds,
+			     unsigned int offset)
+{
+	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;
+
+	for (i = 0; i < EXIF_IFD_COUNT; i++)
+		if (ifd == data->ifd[i])
+			break;
+	if (i == EXIF_IFD_COUNT)
+		return;	/* error */
+
+	/*
+	 * Check if we need some extra entries for pointers or the thumbnail.
+	 */
+	switch (i) {
+	case EXIF_IFD_0:
+
+		/*
+		 * The pointer to IFD_EXIF is in IFD_0. The pointer to
+		 * IFD_INTEROPERABILITY is in IFD_EXIF.
+		 */
+		if (data->ifd[EXIF_IFD_EXIF]->count ||
+		    data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
+			n_ptr++;
+
+		/* The pointer to IFD_GPS is in IFD_0. */
+		if (data->ifd[EXIF_IFD_GPS]->count)
+			n_ptr++;
+
+		break;
+	case EXIF_IFD_1:
+		if (data->size)
+			n_thumb = 2;
+		break;
+	case EXIF_IFD_EXIF:
+		if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
+			n_ptr++;
+	default:
+		break;
+	}
+
+	/*
+	 * Allocate enough memory for all entries
+	 * and the number of entries.
+	 */
+	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. 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++) {
+		if (ifd->entries[j]) {
+			exif_data_save_data_entry (data, ifd->entries[j], d, ds,
+				offset + 12 * j);
+		}
+	}
+
+	offset += 12 * ifd->count;
+
+	/* Now save special entries. */
+	switch (i) {
+	case EXIF_IFD_0:
+
+		/*
+		 * The pointer to IFD_EXIF is in IFD_0.
+		 * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
+		 * therefore, if IFD_INTEROPERABILITY is not empty, we need
+		 * IFD_EXIF even if latter is empty.
+		 */
+		if (data->ifd[EXIF_IFD_EXIF]->count ||
+		    data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
+			exif_set_short (*d + 6 + offset + 0, data->priv->order,
+					EXIF_TAG_EXIF_IFD_POINTER);
+			exif_set_short (*d + 6 + offset + 2, data->priv->order,
+					EXIF_FORMAT_LONG);
+			exif_set_long  (*d + 6 + offset + 4, data->priv->order,
+					1);
+			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);
+			offset += 12;
+		}
+
+		/* The pointer to IFD_GPS is in IFD_0, too. */
+		if (data->ifd[EXIF_IFD_GPS]->count) {
+			exif_set_short (*d + 6 + offset + 0, data->priv->order,
+					EXIF_TAG_GPS_INFO_IFD_POINTER);
+			exif_set_short (*d + 6 + offset + 2, data->priv->order,
+					EXIF_FORMAT_LONG);
+			exif_set_long  (*d + 6 + offset + 4, data->priv->order,
+					1);
+			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);
+			offset += 12;
+		}
+
+		break;
+	case EXIF_IFD_EXIF:
+
+		/*
+		 * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
+		 * See note above.
+		 */
+		if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
+			exif_set_short (*d + 6 + offset + 0, data->priv->order,
+					EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
+			exif_set_short (*d + 6 + offset + 2, data->priv->order,
+					EXIF_FORMAT_LONG);
+			exif_set_long  (*d + 6 + offset + 4, data->priv->order,
+					1);
+			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);
+			offset += 12;
+		}
+
+		break;
+	case EXIF_IFD_1:
+
+		/*
+		 * Information about the thumbnail (if any) is saved in
+		 * IFD_1.
+		 */
+		if (data->size) {
+
+			/* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
+			exif_set_short (*d + 6 + offset + 0, data->priv->order,
+					EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
+			exif_set_short (*d + 6 + offset + 2, data->priv->order,
+					EXIF_FORMAT_LONG);
+			exif_set_long  (*d + 6 + offset + 4, data->priv->order,
+					1);
+			exif_set_long  (*d + 6 + offset + 8, data->priv->order,
+					*ds - 6);
+			ts = *ds + data->size;
+			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;
+			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_set_short (*d + 6 + offset + 2, data->priv->order,
+					EXIF_FORMAT_LONG);
+			exif_set_long  (*d + 6 + offset + 4, data->priv->order,
+					1);
+			exif_set_long  (*d + 6 + offset + 8, data->priv->order,
+					data->size);
+			offset += 12;
+		}
+
+		break;
+	default:
+		break;
+	}
+
+	/* 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);
+
+	/* Correctly terminate the directory */
+	if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
+				data->size)) {
+
+		/*
+		 * We are saving IFD 0. Tell where IFD 1 starts and save
+		 * IFD 1.
+		 */
+		exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6);
+		exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds,
+					     *ds - 6);
+	} else
+		exif_set_long (*d + 6 + offset, data->priv->order, 0);
+}
+
+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_NIKON		= 4,
+	EXIF_DATA_TYPE_MAKER_NOTE_CASIO		= 5,
+	EXIF_DATA_TYPE_MAKER_NOTE_FUJI 		= 6
+} ExifDataTypeMakerNote;
+
+/*! If MakerNote is recognized, load it.
+ *
+ * \param[in,out] data #ExifData
+ * \param[in] d pointer to raw EXIF data
+ * \param[in] ds length of data at d
+ */
+static void
+interpret_maker_note(ExifData *data, const unsigned char *d, unsigned int ds)
+{
+	int mnoteid;
+	ExifEntry* e = exif_data_get_entry (data, EXIF_TAG_MAKER_NOTE);
+	if (!e)
+		return;
+	
+	if ((mnoteid = exif_mnote_data_olympus_identify (data, e)) != 0) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
+			"ExifData", "Olympus MakerNote variant type %d", mnoteid);
+		data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
+
+	} else if ((mnoteid = exif_mnote_data_canon_identify (data, e)) != 0) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
+			"ExifData", "Canon MakerNote variant type %d", mnoteid);
+		data->priv->md = exif_mnote_data_canon_new (data->priv->mem, data->priv->options);
+
+	} else if ((mnoteid = exif_mnote_data_fuji_identify (data, e)) != 0) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
+			"ExifData", "Fuji MakerNote variant type %d", mnoteid);
+		data->priv->md = exif_mnote_data_fuji_new (data->priv->mem);
+
+	/* NOTE: Must do Pentax detection last because some of the
+	 * heuristics are pretty general. */
+	} else if ((mnoteid = exif_mnote_data_pentax_identify (data, e)) != 0) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
+			"ExifData", "Pentax MakerNote variant type %d", mnoteid);
+		data->priv->md = exif_mnote_data_pentax_new (data->priv->mem);
+	} else if ((mnoteid = exif_mnote_data_apple_identify (data, e)) != 0) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
+			"ExifData", "Apple MakerNote variant type %d", mnoteid);
+		data->priv->md = exif_mnote_data_apple_new (data->priv->mem);
+	}
+
+	/* 
+	 * If we are able to interpret the maker note, do so.
+	 */
+	if (data->priv->md) {
+		exif_mnote_data_log (data->priv->md, data->priv->log);
+		exif_mnote_data_set_byte_order (data->priv->md,
+						data->priv->order);
+		exif_mnote_data_set_offset (data->priv->md,
+					    data->priv->offset_mnote);
+		exif_mnote_data_load (data->priv->md, d, ds);
+	}
+}
+
+#define LOG_TOO_SMALL \
+exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData", \
+		_("Size of data too small to allow for EXIF data."));
+
+void
+exif_data_load_data (ExifData *data, const unsigned char *d_orig,
+		     unsigned int ds)
+{
+	unsigned int l;
+	ExifLong offset;
+	ExifShort n;
+	const unsigned char *d = d_orig;
+	unsigned int len, fullds;
+
+	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);
+
+	/*
+	 * It can be that the data starts with the EXIF header. If it does
+	 * not, search the EXIF marker.
+	 */
+	if (ds < 6) {
+		LOG_TOO_SMALL;
+		return;
+	}
+	if (!memcmp (d, ExifHeader, 6)) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+			  "Found EXIF header at start.");
+	} else {
+		while (ds >= 3) {
+			while (ds && (d[0] == 0xff)) {
+				d++;
+				ds--;
+			}
+
+			/* JPEG_MARKER_SOI */
+			if (ds && d[0] == JPEG_MARKER_SOI) {
+				d++;
+				ds--;
+				continue;
+			}
+
+			/* JPEG_MARKER_APP1 */
+			if (ds && d[0] == JPEG_MARKER_APP1) {
+				/*
+				 * Verify the exif header
+				 * (offset 2, length 6).
+				 */
+				if ((ds >= 10) && !memcmp (d+4, ExifHeader, 6))
+					break;
+				/* fallthrough */
+			}
+			/* Skip irrelevant APP markers. The branch for APP1 must come before this,
+			   otherwise this code block will cause APP1 to be skipped. This code path
+			   is only relevant for files that are nonconformant to the EXIF
+			   specification. For conformant files, the APP1 code path above will be
+			   taken. */
+			if (ds >= 3 && d[0] >= 0xe0 && d[0] <= 0xef) {  /* JPEG_MARKER_APPn */
+				d++;
+				ds--;
+				l = (((unsigned int)d[0]) << 8) | d[1];
+				if (l > ds)
+					return;
+				d += l;
+				ds -= l;
+				continue;
+			}
+
+			/* Unknown marker or data. Give up. */
+			exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
+				  "ExifData", _("EXIF marker not found."));
+			return;
+		}
+		if (ds < 3) {
+			LOG_TOO_SMALL;
+			return;
+		}
+		d++;
+		ds--;
+		len = (((unsigned int)d[0]) << 8) | d[1];
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+			  "We have to deal with %i byte(s) of EXIF data.",
+			  len);
+		d += 2;
+		ds = len - 2;	/* we do not want the full rest size, but only the size of the tag */
+	}
+
+	/*
+	 * Verify the exif header
+	 * (offset 2, length 6).
+	 */
+	if (ds < 6) {
+		LOG_TOO_SMALL;
+		return;
+	}
+	if (memcmp (d, ExifHeader, 6)) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
+			  "ExifData", _("EXIF header not found."));
+		return;
+	}
+
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+		  "Found EXIF header.");
+
+	/* Sanity check the data length */
+	if (ds < 14)
+		return;
+
+	/* The JPEG APP1 section can be no longer than 64 KiB (including a
+	   16-bit length), so cap the data length to protect against overflow
+	   in future offset calculations */
+	fullds = ds;
+	if (ds > 0xfffe)
+		ds = 0xfffe;
+
+	/* Byte order (offset 6, length 2) */
+	if (!memcmp (d + 6, "II", 2))
+		data->priv->order = EXIF_BYTE_ORDER_INTEL;
+	else if (!memcmp (d + 6, "MM", 2))
+		data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
+	else {
+		exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
+			  "ExifData", _("Unknown encoding."));
+		return;
+	}
+
+	/* Fixed value */
+	if (exif_get_short (d + 8, data->priv->order) != 0x002a)
+		return;
+
+	/* IFD 0 offset */
+	offset = exif_get_long (d + 10, data->priv->order);
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", 
+		  "IFD 0 at %i.", (int) offset);
+
+	/* ds is restricted to 16 bit above, so offset is restricted too, and offset+8 should not overflow. */
+	if (offset > ds || offset + 6 + 2 > ds)
+		return;
+
+	/* Parse the actual exif data (usually offset 14 from start) */
+	exif_data_load_data_content (data, EXIF_IFD_0, d + 6, ds - 6, offset, 0);
+
+	/* IFD 1 offset */
+	n = exif_get_short (d + 6 + offset, data->priv->order);
+	/* offset < 2<<16, n is 16 bit at most, so this op will not overflow */
+	if (offset + 6 + 2 + 12 * n + 4 > ds)
+		return;
+
+	offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order);
+	if (offset) {
+		exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+			  "IFD 1 at %i.", (int) offset);
+
+		/* Sanity check. ds is ensured to be above 6 above, offset is 16bit */
+		if (offset > ds - 6) {
+			exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
+				  "ExifData", "Bogus offset of IFD1.");
+		} else {
+		   exif_data_load_data_content (data, EXIF_IFD_1, d + 6, ds - 6, offset, 0);
+		}
+	}
+
+	/*
+	 * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
+	 * cameras use pointers in the maker note tag that point to the
+	 * space between IFDs. Here is the only place where we have access
+	 * to that data.
+	 */
+	interpret_maker_note(data, d, fullds);
+
+	/* Fixup tags if requested */
+	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)  {
+		*ds = 0;
+		return;
+	}
+	memcpy (*d, ExifHeader, 6);
+
+	/* Order (offset 6) */
+	if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
+		memcpy (*d + 6, "II", 2);
+	} else {
+		memcpy (*d + 6, "MM", 2);
+	}
+
+	/* Fixed value (2 bytes, offset 8) */
+	exif_set_short (*d + 8, data->priv->order, 0x002a);
+
+	/*
+	 * IFD 0 offset (4 bytes, offset 10).
+	 * We will start 8 bytes after the
+	 * EXIF header (2 bytes for order, another 2 for the test, and
+	 * 4 bytes for the IFD 0 offset make 8 bytes together).
+	 */
+	exif_set_long (*d + 10, data->priv->order, 8);
+
+	/* Now save IFD 0. IFD 1 will be saved automatically. */
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+		  "Saving IFDs...");
+	exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds,
+				     *ds - 6);
+	exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
+		  "Saved %i byte(s) EXIF data.", *ds);
+}
+
+ExifData *
+exif_data_new_from_file (const char *path)
+{
+	ExifData *edata;
+	ExifLoader *loader;
+
+	loader = exif_loader_new ();
+	exif_loader_write_file (loader, path);
+	edata = exif_loader_get_data (loader);
+	exif_loader_unref (loader);
+
+	return (edata);
+}
+
+void
+exif_data_ref (ExifData *data)
+{
+	if (!data)
+		return;
+
+	data->priv->ref_count++;
+}
+
+void
+exif_data_unref (ExifData *data)
+{
+	if (!data) 
+		return;
+
+	data->priv->ref_count--;
+	if (!data->priv->ref_count) 
+		exif_data_free (data);
+}
+
+void
+exif_data_free (ExifData *data)
+{
+	unsigned int i;
+	ExifMem *mem = (data && data->priv) ? data->priv->mem : NULL;
+
+	if (!data) 
+		return;
+
+	for (i = 0; i < EXIF_IFD_COUNT; i++) {
+		if (data->ifd[i]) {
+			exif_content_unref (data->ifd[i]);
+			data->ifd[i] = NULL;
+		}
+	}
+
+	if (data->data) {
+		exif_mem_free (mem, data->data);
+		data->data = NULL;
+	}
+
+	if (data->priv) {
+		if (data->priv->log) {
+			exif_log_unref (data->priv->log);
+			data->priv->log = NULL;
+		}
+		if (data->priv->md) {
+			exif_mnote_data_unref (data->priv->md);
+			data->priv->md = NULL;
+		}
+		exif_mem_free (mem, data->priv);
+		exif_mem_free (mem, data);
+	}
+
+	exif_mem_unref (mem);
+}
+
+void
+exif_data_dump (ExifData *data)
+{
+	unsigned int i;
+
+	if (!data)
+		return;
+
+	for (i = 0; i < EXIF_IFD_COUNT; i++) {
+		if (data->ifd[i] && data->ifd[i]->count) {
+			printf ("Dumping IFD '%s'...\n",
+				exif_ifd_get_name (i));
+			exif_content_dump (data->ifd[i], 0);
+		}
+	}
+
+	if (data->data) {
+		printf ("%i byte(s) thumbnail data available: ", data->size);
+		if (data->size >= 4) {
+			printf ("0x%02x 0x%02x ... 0x%02x 0x%02x\n",
+				data->data[0], data->data[1],
+				data->data[data->size - 2],
+				data->data[data->size - 1]);
+		}
+	}
+}
+
+ExifByteOrder
+exif_data_get_byte_order (ExifData *data)
+{
+	if (!data)
+		return (0);
+
+	return (data->priv->order);
+}
+
+void
+exif_data_foreach_content (ExifData *data, ExifDataForeachContentFunc func,
+			   void *user_data)
+{
+	unsigned int i;
+
+	if (!data || !func)
+		return;
+
+	for (i = 0; i < EXIF_IFD_COUNT; i++)
+		func (data->ifd[i], user_data);
+}
+
+typedef struct _ByteOrderChangeData ByteOrderChangeData;
+struct _ByteOrderChangeData {
+	ExifByteOrder old, new;
+};
+
+static void
+entry_set_byte_order (ExifEntry *e, void *data)
+{
+	ByteOrderChangeData *d = data;
+
+	if (!e)
+		return;
+
+	exif_array_set_byte_order (e->format, e->data, e->components, d->old, d->new);
+}
+
+static void
+content_set_byte_order (ExifContent *content, void *data)
+{
+	exif_content_foreach_entry (content, entry_set_byte_order, data);
+}
+
+void
+exif_data_set_byte_order (ExifData *data, ExifByteOrder order)
+{
+	ByteOrderChangeData d;
+
+	if (!data || (order == data->priv->order))
+		return;
+
+	d.old = data->priv->order;
+	d.new = order;
+	exif_data_foreach_content (data, content_set_byte_order, &d);
+	data->priv->order = order;
+	if (data->priv->md)
+		exif_mnote_data_set_byte_order (data->priv->md, order);
+}
+
+void
+exif_data_log (ExifData *data, ExifLog *log)
+{
+	unsigned int i;
+
+	if (!data || !data->priv) 
+		return;
+	exif_log_unref (data->priv->log);
+	data->priv->log = log;
+	exif_log_ref (log);
+
+	for (i = 0; i < EXIF_IFD_COUNT; i++)
+		exif_content_log (data->ifd[i], log);
+}
+
+/* Used internally within libexif */
+ExifLog *exif_data_get_log (ExifData *);
+ExifLog *
+exif_data_get_log (ExifData *data)
+{
+	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 if (c->count) {
+			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_UNKNOWN;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-data.h

@@ -0,0 +1,267 @@
+/*! \file exif-data.h
+ * \brief Defines the ExifData type and the associated functions.
+ */
+/*
+ * \author Lutz Mueller <[email protected]>
+ * \date 2001-2005
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __EXIF_DATA_H__
+#define __EXIF_DATA_H__
+
+#ifdef __cplusplus
+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>
+
+/*! Represents the entire EXIF data found in an image */
+typedef struct _ExifData        ExifData;
+typedef struct _ExifDataPrivate ExifDataPrivate;
+
+#include <libexif/exif-content.h>
+#include <libexif/exif-mnote-data.h>
+#include <libexif/exif-mem.h>
+
+/*! Represents the entire EXIF data found in an image */
+struct _ExifData
+{
+	/*! Data for each IFD */
+	ExifContent *ifd[EXIF_IFD_COUNT];
+
+	/*! Pointer to thumbnail image, or NULL if not available */
+	unsigned char *data;
+
+	/*! Number of bytes in thumbnail image at \c data */
+	unsigned int size;
+
+	ExifDataPrivate *priv;
+};
+
+/*! Allocate a new #ExifData. The #ExifData contains an empty
+ * #ExifContent for each IFD and the default set of options,
+ * which has #EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS
+ * and #EXIF_DATA_OPTION_FOLLOW_SPECIFICATION set.
+ *
+ * \return allocated #ExifData, or NULL on error
+ */
+ExifData *exif_data_new           (void);
+
+/*! Allocate a new #ExifData using the given memory allocator.
+ * The #ExifData contains an empty #ExifContent for each IFD and the default
+ * set of options, which has #EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS and
+ * #EXIF_DATA_OPTION_FOLLOW_SPECIFICATION set.
+ *
+ * \return allocated #ExifData, or NULL on error
+ */
+ExifData *exif_data_new_mem       (ExifMem *);
+
+/*! Allocate a new #ExifData and load EXIF data from a JPEG file.
+ * Uses an #ExifLoader internally to do the loading.
+ *
+ * \param[in] path filename including path
+ * \return allocated #ExifData, or NULL on error
+ */
+ExifData *exif_data_new_from_file (const char *path);
+
+/*! Allocate a new #ExifData and load EXIF data from a memory buffer.
+ *
+ * \param[in] data pointer to raw JPEG or EXIF data
+ * \param[in] size number of bytes of data at data
+ * \return allocated #ExifData, or NULL on error
+ */
+ExifData *exif_data_new_from_data (const unsigned char *data,
+				   unsigned int size);
+
+/*! Load the #ExifData structure from the raw JPEG or EXIF data in the given
+ * memory buffer. If the EXIF data contains a recognized MakerNote, it is
+ * loaded and stored as well for later retrieval by #exif_data_get_mnote_data.
+ * If the #EXIF_DATA_OPTION_FOLLOW_SPECIFICATION option has been set on this
+ * #ExifData, then the tags are automatically fixed after loading (by calling
+ * #exif_data_fix).
+ *
+ * \param[in,out] data EXIF data
+ * \param[in] d pointer to raw JPEG or EXIF data
+ * \param[in] size number of bytes of data at d
+ */
+void      exif_data_load_data (ExifData *data, const unsigned char *d, 
+			       unsigned int size);
+
+/*! Store raw EXIF data representing the #ExifData structure into a memory
+ * buffer. The buffer is allocated by this function and must subsequently be
+ * freed by the caller using the matching free function as used by the #ExifMem
+ * in use by this #ExifData.
+ *
+ * \param[in] data EXIF data
+ * \param[out] d pointer to buffer pointer containing raw EXIF data on return
+ * \param[out] ds pointer to variable to hold the number of bytes of
+ *   data at d, or set to 0 on error
+ */
+void      exif_data_save_data (ExifData *data, unsigned char **d,
+			       unsigned int *ds);
+
+void      exif_data_ref   (ExifData *data);
+void      exif_data_unref (ExifData *data);
+void      exif_data_free  (ExifData *data);
+
+/*! Return the byte order in use by this EXIF structure.
+ *
+ * \param[in] data EXIF data
+ * \return byte order
+ */
+ExifByteOrder exif_data_get_byte_order  (ExifData *data);
+
+/*! Set the byte order to use for this EXIF data. If any tags already exist
+ * (including MakerNote tags) they are are converted to the specified byte
+ * order.
+ *
+ * \param[in,out] data EXIF data
+ * \param[in] order byte order
+ */
+void          exif_data_set_byte_order  (ExifData *data, ExifByteOrder order);
+
+/*! Return the MakerNote data out of the EXIF data.  Only certain
+ * MakerNote formats that are recognized by libexif are supported.
+ * The pointer references a member of the #ExifData structure and must NOT be
+ * freed by the caller.
+ *
+ * \param[in] d EXIF data
+ * \return MakerNote data, or NULL if not found or not supported
+ */
+ExifMnoteData *exif_data_get_mnote_data (ExifData *d);
+
+/*! Fix the EXIF data to bring it into specification. Call #exif_content_fix
+ * on each IFD to fix existing entries, create any new entries that are
+ * mandatory but do not yet exist, and remove any entries that are not
+ * allowed.
+ *
+ * \param[in,out] d EXIF data
+ */
+void           exif_data_fix (ExifData *d);
+
+typedef void (* ExifDataForeachContentFunc) (ExifContent *, void *user_data);
+
+/*! Execute a function on each IFD in turn.
+ *
+ * \param[in] data EXIF data over which to iterate
+ * \param[in] func function to call for each entry
+ * \param[in] user_data data to pass into func on each call
+ */
+void          exif_data_foreach_content (ExifData *data,
+					 ExifDataForeachContentFunc func,
+					 void *user_data);
+
+/*! Options to configure the behaviour of #ExifData */
+typedef enum {
+	/*! Act as though unknown tags are not present */
+	EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS = 1 << 0,
+
+	/*! Fix the EXIF tags to follow the spec */
+	EXIF_DATA_OPTION_FOLLOW_SPECIFICATION = 1 << 1,
+
+	/*! Leave the MakerNote alone, which could cause it to be corrupted */
+	EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE = 1 << 2
+} ExifDataOption;
+
+/*! Return a short textual description of the given #ExifDataOption.
+ *
+ * \param[in] o option
+ * \return localized textual description of the option,
+ *   or NULL if unknown
+ */
+const char *exif_data_option_get_name        (ExifDataOption o);
+
+/*! Return a verbose textual description of the given #ExifDataOption.
+ *
+ * \param[in] o option
+ * \return verbose localized textual description of the option,
+ *   or NULL if unknown
+ */
+const char *exif_data_option_get_description (ExifDataOption o);
+
+/*! Set the given option on the given #ExifData.
+ *
+ * \param[in] d EXIF data
+ * \param[in] o option
+ */
+void        exif_data_set_option             (ExifData *d, ExifDataOption o);
+
+/*! Clear the given option on the given #ExifData.
+ *
+ * \param[in] d EXIF data
+ * \param[in] o option
+ */
+void        exif_data_unset_option           (ExifData *d, ExifDataOption o);
+
+/*! Set the data type for the given #ExifData.
+ *
+ * \param[in] d EXIF data
+ * \param[in] dt data type
+ */
+void         exif_data_set_data_type (ExifData *d, ExifDataType dt);
+
+/*! Return the data type for the given #ExifData.
+ *
+ * \param[in] d EXIF data
+ * \return data type, or #EXIF_DATA_TYPE_UNKNOWN on error
+ */
+ExifDataType exif_data_get_data_type (ExifData *d);
+
+/*! Dump all EXIF data to stdout.
+ * This is intended for diagnostic purposes only.
+ *
+ * \param[in] data EXIF data
+ */
+void exif_data_dump (ExifData *data);
+
+/*! Set the log message object for all IFDs.
+ *
+ * \param[in] data EXIF data
+ * \param[in] log #ExifLog
+ */
+void exif_data_log  (ExifData *data, ExifLog *log);
+
+/*! Return an #ExifEntry for the given tag if found in any IFD.
+ * Each IFD is searched in turn and the first containing a tag with
+ * this number is returned.
+ *
+ * \param[in] d #ExifData
+ * \param[in] t #ExifTag
+ * \return #ExifEntry* if found, else NULL if not found
+ */
+#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) :			\
+	 exif_content_get_entry(d->ifd[EXIF_IFD_1],t) ?			\
+	 exif_content_get_entry(d->ifd[EXIF_IFD_1],t) :			\
+	 exif_content_get_entry(d->ifd[EXIF_IFD_EXIF],t) ?		\
+	 exif_content_get_entry(d->ifd[EXIF_IFD_EXIF],t) :		\
+	 exif_content_get_entry(d->ifd[EXIF_IFD_GPS],t) ?		\
+	 exif_content_get_entry(d->ifd[EXIF_IFD_GPS],t) :		\
+	 exif_content_get_entry(d->ifd[EXIF_IFD_INTEROPERABILITY],t) ?	\
+	 exif_content_get_entry(d->ifd[EXIF_IFD_INTEROPERABILITY],t) : NULL)
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __EXIF_DATA_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-entry.c

@@ -0,0 +1,1809 @@
+/* exif-entry.c
+ *
+ * Copyright (c) 2001 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+
+#include <libexif/exif-entry.h>
+#include <libexif/exif-ifd.h>
+#include <libexif/exif-utils.h>
+#include <libexif/i18n.h>
+
+#include <libexif/exif-gps-ifd.h>
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <math.h>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+struct _ExifEntryPrivate
+{
+	unsigned int ref_count;
+
+	ExifMem *mem;
+};
+
+/* 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, ...)
+{
+	va_list args;
+	ExifLog *l = NULL;
+
+	if (e && e->parent && e->parent->parent)
+		l = exif_data_get_log (e->parent->parent);
+	va_start (args, 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)
+{
+	void *d;
+	ExifLog *l = NULL;
+
+	if (!e || !e->priv || !i) return NULL;
+
+	d = exif_mem_alloc (e->priv->mem, i);
+	if (d) return d;
+
+	if (e->parent && e->parent->parent)
+		l = exif_data_get_log (e->parent->parent);
+	EXIF_LOG_NO_MEMORY (l, "ExifEntry", i);
+	return NULL;
+}
+
+static void *
+exif_entry_realloc (ExifEntry *e, void *d_orig, unsigned int i)
+{
+	void *d;
+	ExifLog *l = NULL;
+
+	if (!e || !e->priv) return NULL;
+
+	if (!i) { exif_mem_free (e->priv->mem, d_orig); return NULL; }
+
+	d = exif_mem_realloc (e->priv->mem, d_orig, i);
+	if (d) return d;
+
+	if (e->parent && e->parent->parent)
+		l = exif_data_get_log (e->parent->parent);
+	EXIF_LOG_NO_MEMORY (l, "ExifEntry", i);
+	return NULL;
+}
+
+ExifEntry *
+exif_entry_new (void)
+{
+	ExifMem *mem = exif_mem_new_default ();
+	ExifEntry *e = exif_entry_new_mem (mem);
+
+	exif_mem_unref (mem);
+
+	return e;
+}
+
+ExifEntry *
+exif_entry_new_mem (ExifMem *mem)
+{
+	ExifEntry *e = NULL;
+
+	e = exif_mem_alloc (mem, sizeof (ExifEntry));
+	if (!e) return NULL;
+	e->priv = exif_mem_alloc (mem, sizeof (ExifEntryPrivate));
+	if (!e->priv) { exif_mem_free (mem, e); return NULL; }
+	e->priv->ref_count = 1;
+
+	e->priv->mem = mem;
+	exif_mem_ref (mem);
+
+	return e;
+}
+
+void
+exif_entry_ref (ExifEntry *e)
+{
+	if (!e) return;
+
+	e->priv->ref_count++;
+}
+
+void
+exif_entry_unref (ExifEntry *e)
+{
+	if (!e) return;
+
+	e->priv->ref_count--;
+	if (!e->priv->ref_count)
+		exif_entry_free (e);
+}
+
+void
+exif_entry_free (ExifEntry *e)
+{
+	if (!e) return;
+
+	if (e->priv) {
+		ExifMem *mem = e->priv->mem;
+		if (e->data)
+			exif_mem_free (mem, e->data);
+		exif_mem_free (mem, e->priv);
+		exif_mem_free (mem, e);
+		exif_mem_unref (mem);
+	}
+}
+
+static void
+clear_entry (ExifEntry *e)
+{
+	e->components = 0;
+	e->size = 0;
+}
+
+/*! Get a value and convert it to an ExifShort.
+ * \bug Not all types are converted that could be converted and no indication
+ *      is made when that occurs
+ */
+static inline ExifShort
+exif_get_short_convert (const unsigned char *buf, ExifFormat format,
+			ExifByteOrder order)
+{
+	switch (format) {
+	case EXIF_FORMAT_LONG:
+		return (ExifShort) exif_get_long (buf, order);
+	case EXIF_FORMAT_SLONG:
+		return (ExifShort) exif_get_slong (buf, order);
+	case EXIF_FORMAT_SHORT:
+		return (ExifShort) exif_get_short (buf, order);
+	case EXIF_FORMAT_SSHORT:
+		return (ExifShort) exif_get_sshort (buf, order);
+	case EXIF_FORMAT_BYTE:
+	case EXIF_FORMAT_SBYTE:
+		return (ExifShort) buf[0];
+	default:
+		/* Unsupported type */
+		return (ExifShort) 0;
+	}
+}
+
+void
+exif_entry_fix (ExifEntry *e)
+{
+	unsigned int i, newsize;
+	unsigned char *newdata;
+	ExifByteOrder o;
+	ExifRational r;
+	ExifSRational sr;
+
+	if (!e || !e->priv) return;
+
+	switch (e->tag) {
+	
+	/* These tags all need to be of format SHORT. */
+	case EXIF_TAG_YCBCR_SUB_SAMPLING:
+	case EXIF_TAG_SUBJECT_AREA:
+	case EXIF_TAG_COLOR_SPACE:
+	case EXIF_TAG_PLANAR_CONFIGURATION:
+	case EXIF_TAG_SENSING_METHOD:
+	case EXIF_TAG_ORIENTATION:
+	case EXIF_TAG_YCBCR_POSITIONING:
+	case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
+	case EXIF_TAG_CUSTOM_RENDERED:
+	case EXIF_TAG_EXPOSURE_MODE:
+	case EXIF_TAG_WHITE_BALANCE:
+	case EXIF_TAG_SCENE_CAPTURE_TYPE:
+	case EXIF_TAG_GAIN_CONTROL:
+	case EXIF_TAG_SATURATION:
+	case EXIF_TAG_CONTRAST:
+	case EXIF_TAG_SHARPNESS:
+	case EXIF_TAG_ISO_SPEED_RATINGS:
+		switch (e->format) {
+		case EXIF_FORMAT_LONG:
+		case EXIF_FORMAT_SLONG:
+		case EXIF_FORMAT_BYTE:
+		case EXIF_FORMAT_SBYTE:
+		case EXIF_FORMAT_SSHORT:
+			if (!e->parent || !e->parent->parent) break;
+			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
+				_("Tag '%s' was of format '%s' (which is "
+				"against specification) and has been "
+				"changed to format '%s'."),
+				exif_tag_get_name_in_ifd(e->tag,
+							exif_entry_get_ifd(e)),
+				exif_format_get_name (e->format),
+				exif_format_get_name (EXIF_FORMAT_SHORT));
+
+			o = exif_data_get_byte_order (e->parent->parent);
+			newsize = e->components * exif_format_get_size (EXIF_FORMAT_SHORT);
+			newdata = exif_entry_alloc (e, newsize);
+			if (!newdata) {
+				exif_entry_log (e, EXIF_LOG_CODE_NO_MEMORY,
+					"Could not allocate %lu byte(s).", (unsigned long)newsize);
+				break;
+			}
+
+			for (i = 0; i < e->components; i++)
+				exif_set_short (
+					newdata + i *
+					exif_format_get_size (
+					 EXIF_FORMAT_SHORT), o,
+					 exif_get_short_convert (
+					  e->data + i *
+					  exif_format_get_size (e->format),
+					  e->format, o));
+
+			exif_mem_free (e->priv->mem, e->data);
+			e->data = newdata;
+			e->size = newsize;
+			e->format = EXIF_FORMAT_SHORT;
+			break;
+		case EXIF_FORMAT_SHORT:
+			/* No conversion necessary */
+			break;
+		default:
+			exif_entry_log (e, EXIF_LOG_CODE_CORRUPT_DATA,
+				_("Tag '%s' is of format '%s' (which is "
+				"against specification) but cannot be changed "
+				"to format '%s'."),
+				exif_tag_get_name_in_ifd(e->tag,
+							exif_entry_get_ifd(e)),
+				exif_format_get_name (e->format),
+				exif_format_get_name (EXIF_FORMAT_SHORT));
+			break;
+		}
+		break;
+
+	/* All these tags need to be of format 'Rational'. */
+	case EXIF_TAG_FNUMBER:
+	case EXIF_TAG_APERTURE_VALUE:
+	case EXIF_TAG_EXPOSURE_TIME:
+	case EXIF_TAG_FOCAL_LENGTH:
+		switch (e->format) {
+		case EXIF_FORMAT_SRATIONAL:
+			if (!e->parent || !e->parent->parent) break;
+			o = exif_data_get_byte_order (e->parent->parent);
+			for (i = 0; i < e->components; i++) {
+				sr = exif_get_srational (e->data + i * 
+					exif_format_get_size (
+						EXIF_FORMAT_SRATIONAL), o);
+				r.numerator = (ExifLong) sr.numerator;
+				r.denominator = (ExifLong) sr.denominator;
+				exif_set_rational (e->data + i *
+					exif_format_get_size (
+						EXIF_FORMAT_RATIONAL), o, r);
+			}
+			e->format = EXIF_FORMAT_RATIONAL;
+			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
+				_("Tag '%s' was of format '%s' (which is "
+				"against specification) and has been "
+				"changed to format '%s'."),
+				exif_tag_get_name_in_ifd(e->tag,
+							exif_entry_get_ifd(e)),
+				exif_format_get_name (EXIF_FORMAT_SRATIONAL),
+				exif_format_get_name (EXIF_FORMAT_RATIONAL));
+			break;
+		default:
+			break;
+		}
+		break;
+
+	/* All these tags need to be of format 'SRational'. */
+	case EXIF_TAG_EXPOSURE_BIAS_VALUE:
+	case EXIF_TAG_BRIGHTNESS_VALUE:
+	case EXIF_TAG_SHUTTER_SPEED_VALUE:
+		switch (e->format) {
+		case EXIF_FORMAT_RATIONAL:
+			if (!e->parent || !e->parent->parent) break;
+			o = exif_data_get_byte_order (e->parent->parent);
+			for (i = 0; i < e->components; i++) {
+				r = exif_get_rational (e->data + i * 
+					exif_format_get_size (
+						EXIF_FORMAT_RATIONAL), o);
+				sr.numerator = (ExifLong) r.numerator;
+				sr.denominator = (ExifLong) r.denominator;
+				exif_set_srational (e->data + i *
+					exif_format_get_size (
+						EXIF_FORMAT_SRATIONAL), o, sr);
+			}
+			e->format = EXIF_FORMAT_SRATIONAL;
+			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
+				_("Tag '%s' was of format '%s' (which is "
+				"against specification) and has been "
+				"changed to format '%s'."),
+				exif_tag_get_name_in_ifd(e->tag,
+							exif_entry_get_ifd(e)),
+				exif_format_get_name (EXIF_FORMAT_RATIONAL),
+				exif_format_get_name (EXIF_FORMAT_SRATIONAL));
+			break;
+		default:
+			break;
+		}
+		break;
+
+	case EXIF_TAG_USER_COMMENT:
+
+		/* 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'."),
+				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);
+		}
+
+		/* There need to be at least 8 bytes. */
+		if (e->size < 8) {
+			e->data = exif_entry_realloc (e, e->data, 8 + e->size);
+			if (!e->data) {
+				clear_entry(e);
+				return;
+			}
+
+			/* Assume ASCII */
+			memmove (e->data + 8, e->data, e->size);
+			memcpy (e->data, "ASCII\0\0\0", 8);
+			e->size += 8;
+			e->components += 8;
+			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
+				_("Tag 'UserComment' has been expanded to at "
+				"least 8 bytes in order to follow the "
+				"specification."));
+			break;
+		}
+
+		/*
+		 * If the first 8 bytes are empty and real data starts
+		 * afterwards, let's assume ASCII and claim the 8 first
+		 * bytes for the format specifyer.
+		 */
+		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' is not empty but does not "
+				"start with a format identifier. "
+				"This has been fixed."));
+			memcpy (e->data, "ASCII\0\0\0", 8);
+			break;
+		}
+
+		/* 
+		 * 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) &&
+		    memcmp (e->data, "\0\0\0\0\0\0\0\0", 8)) {
+			e->data = exif_entry_realloc (e, e->data, 8 + e->size);
+			if (!e->data) {
+				clear_entry(e);
+				break;
+			}
+
+			/* Assume ASCII */
+			memmove (e->data + 8, e->data, e->size);
+			memcpy (e->data, "ASCII\0\0\0", 8);
+			e->size += 8;
+			e->components += 8;
+			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
+				_("Tag 'UserComment' did not start with a "
+				"format identifier. This has been fixed."));
+			break;
+		}
+
+		break;
+	default:
+		break;
+	}
+}
+
+/*! Format the value of an ExifEntry for human display in a generic way.
+ * The output is localized. The formatting is independent of the tag number
+ * and is based entirely on the data type.
+ * \pre The ExifEntry is already a member of an ExifData.
+ * \param[in] e EXIF entry
+ * \param[out] val buffer in which to store value
+ * \param[in] maxlen the length of the buffer val
+ */
+static void
+exif_entry_format_value(ExifEntry *e, char *val, size_t maxlen)
+{
+	ExifByte v_byte;
+	ExifShort v_short;
+	ExifSShort v_sshort;
+	ExifLong v_long;
+	ExifRational v_rat;
+	ExifSRational v_srat;
+	ExifSLong v_slong;
+	unsigned int i;
+	size_t len;
+	const ExifByteOrder o = exif_data_get_byte_order (e->parent->parent);
+
+	if (!e->size || !maxlen)
+		return;
+	switch (e->format) {
+	case EXIF_FORMAT_UNDEFINED:
+		snprintf (val, maxlen, _("%i bytes undefined data"), e->size);
+		break;
+	case EXIF_FORMAT_BYTE:
+	case EXIF_FORMAT_SBYTE:
+		v_byte = e->data[0];
+		snprintf (val, maxlen, "0x%02x", v_byte);
+		len = strlen (val);
+		for (i = 1; i < e->components; i++) {
+			v_byte = e->data[i];
+			snprintf (val+len, maxlen-len, ", 0x%02x", v_byte);
+			len += strlen (val+len);
+			if (len >= maxlen-1) break;
+		}
+		break;
+	case EXIF_FORMAT_SHORT:
+		v_short = exif_get_short (e->data, o);
+		snprintf (val, maxlen, "%u", v_short);
+		len = strlen (val);
+		for (i = 1; i < e->components; i++) {
+			v_short = exif_get_short (e->data +
+				exif_format_get_size (e->format) * i, o);
+			snprintf (val+len, maxlen-len, ", %u", v_short);
+			len += strlen (val+len);
+			if (len >= maxlen-1) break;
+		}
+		break;
+	case EXIF_FORMAT_SSHORT:
+		v_sshort = exif_get_sshort (e->data, o);
+		snprintf (val, maxlen, "%i", v_sshort);
+		len = strlen (val);
+		for (i = 1; i < e->components; i++) {
+			v_sshort = exif_get_short (e->data +
+				exif_format_get_size (e->format) *
+				i, o);
+			snprintf (val+len, maxlen-len, ", %i", v_sshort);
+			len += strlen (val+len);
+			if (len >= maxlen-1) break;
+		}
+		break;
+	case EXIF_FORMAT_LONG:
+		v_long = exif_get_long (e->data, o);
+		snprintf (val, maxlen, "%lu", (unsigned long) v_long);
+		len = strlen (val);
+		for (i = 1; i < e->components; i++) {
+			v_long = exif_get_long (e->data +
+				exif_format_get_size (e->format) *
+				i, o);
+			snprintf (val+len, maxlen-len, ", %lu", (unsigned long) v_long);
+			len += strlen (val+len);
+			if (len >= maxlen-1) break;
+		}
+		break;
+	case EXIF_FORMAT_SLONG:
+		v_slong = exif_get_slong (e->data, o);
+		snprintf (val, maxlen, "%li", (long) v_slong);
+		len = strlen (val);
+		for (i = 1; i < e->components; i++) {
+			v_slong = exif_get_slong (e->data +
+				exif_format_get_size (e->format) * i, o);
+			snprintf (val+len, maxlen-len, ", %li", (long) v_slong);
+			len += strlen (val+len);
+			if (len >= maxlen-1) break;
+		}
+		break;
+	case EXIF_FORMAT_ASCII:
+		strncpy (val, (char *) e->data, MIN (maxlen-1, e->size));
+		val[MIN (maxlen-1, e->size)] = 0;
+		break;
+	case EXIF_FORMAT_RATIONAL:
+		len = 0;
+		for (i = 0; i < e->components; i++) {
+			if (i > 0) {
+				snprintf (val+len, maxlen-len, ", ");
+				len += strlen (val+len);
+			}
+			v_rat = exif_get_rational (
+				e->data + 8 * i, o);
+			if (v_rat.denominator) {
+				/*
+				 * Choose the number of significant digits to
+				 * display based on the size of the denominator.
+				 * It is scaled so that denominators within the
+				 * range 13..120 will show 2 decimal points.
+				 */
+				int decimals = (int)(log10(v_rat.denominator)-0.08+1.0);
+				snprintf (val+len, maxlen-len, "%2.*f",
+					  decimals,
+					  (double) v_rat.numerator /
+					  (double) v_rat.denominator);
+			} else
+				snprintf (val+len, maxlen-len, "%lu/%lu",
+				  (unsigned long) v_rat.numerator,
+				  (unsigned long) v_rat.denominator);
+			len += strlen (val+len);
+			if (len >= maxlen-1) break;
+		}
+		break;
+	case EXIF_FORMAT_SRATIONAL:
+		len = 0;
+		for (i = 0; i < e->components; i++) {
+			if (i > 0) {
+				snprintf (val+len, maxlen-len, ", ");
+				len += strlen (val+len);
+			}
+			v_srat = exif_get_srational (
+				e->data + 8 * i, o);
+			if (v_srat.denominator) {
+				int decimals = (int)(log10(abs(v_srat.denominator))-0.08+1.0);
+				snprintf (val+len, maxlen-len, "%2.*f",
+					  decimals,
+					  (double) v_srat.numerator /
+					  (double) v_srat.denominator);
+			} else
+				snprintf (val+len, maxlen-len, "%li/%li",
+				  (long) v_srat.numerator,
+				  (long) v_srat.denominator);
+			len += strlen (val+len);
+			if (len >= maxlen-1) break;
+		}
+		break;
+	case EXIF_FORMAT_DOUBLE:
+	case EXIF_FORMAT_FLOAT:
+	default:
+		snprintf (val, maxlen, _("%i bytes unsupported data type"),
+			  e->size);
+		break;
+	}
+}
+
+void
+exif_entry_dump (ExifEntry *e, unsigned int indent)
+{
+	char buf[1024];
+	char value[1024];
+	unsigned int l;
+
+	if (!e)
+		return;
+
+	l = MIN(sizeof(buf)-1, 2*indent);
+	memset(buf, ' ', l);
+	buf[l] = '\0';
+
+	printf ("%sTag: 0x%x ('%s')\n", buf, e->tag,
+		exif_tag_get_name_in_ifd (e->tag, exif_entry_get_ifd(e)));
+	printf ("%s  Format: %i ('%s')\n", buf, e->format,
+		exif_format_get_name (e->format));
+	printf ("%s  Components: %i\n", buf, (int) e->components);
+	printf ("%s  Size: %i\n", buf, e->size);
+	printf ("%s  Value: %s\n", buf, exif_entry_get_value (e, value, sizeof(value)));
+}
+
+/*! Check if a string consists entirely of a single, repeated character.
+ * Up to first n bytes are checked.
+ * 
+ * \param[in] data pointer of string to check
+ * \param[in] ch character to match
+ * \param[in] n maximum number of characters to match
+ *
+ * \return 0 if the string matches or is of zero length, nonzero otherwise
+ */
+static int
+match_repeated_char(const unsigned char *data, unsigned char ch, size_t n)
+{
+	int i;
+	for (i=n; i; --i, ++data) {
+		if (*data == 0) {
+			i = 0;	/* all bytes before NUL matched */
+			break;
+		}
+		if (*data != ch)
+			break;
+	}
+	return i;
+}
+
+#define CF(entry,target,v,maxlen)					\
+{									\
+	if (entry->format != target) {					\
+		exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA,	\
+			_("The tag '%s' contains data of an invalid "	\
+			"format ('%s', expected '%s')."),		\
+			exif_tag_get_name (entry->tag),			\
+			exif_format_get_name (entry->format),		\
+			exif_format_get_name (target));			\
+		break;							\
+	}								\
+}
+
+#define CC(entry,target,v,maxlen)					\
+{									\
+	if (entry->components != target) {				\
+		exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA,	\
+			_("The tag '%s' contains an invalid number of "	\
+			  "components (%i, expected %i)."),		\
+			exif_tag_get_name (entry->tag),		\
+			(int) entry->components, (int) target);		\
+		break;							\
+	}								\
+}
+
+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,
+    { "", N_("Not defined"), N_("One-chip color area sensor"),
+      N_("Two-chip color area sensor"), N_("Three-chip color area sensor"),
+      N_("Color sequential area sensor"), "", N_("Trilinear sensor"),
+      N_("Color sequential linear sensor"), NULL}},
+  { EXIF_TAG_ORIENTATION,
+    { "", N_("Top-left"), N_("Top-right"), N_("Bottom-right"),
+      N_("Bottom-left"), N_("Left-top"), N_("Right-top"),
+      N_("Right-bottom"), N_("Left-bottom"), NULL}},
+  { EXIF_TAG_YCBCR_POSITIONING,
+    { "", N_("Centered"), N_("Co-sited"), 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,
+    { N_("Auto exposure"), N_("Manual exposure"), N_("Auto bracket"), NULL}},
+  { EXIF_TAG_WHITE_BALANCE,
+    { N_("Auto white balance"), N_("Manual white balance"), NULL}},
+  { EXIF_TAG_SCENE_CAPTURE_TYPE,
+    { N_("Standard"), N_("Landscape"), N_("Portrait"),
+      N_("Night scene"), NULL}},
+  { EXIF_TAG_GAIN_CONTROL,
+    { N_("Normal"), N_("Low gain up"), N_("High gain up"),
+      N_("Low gain down"), N_("High gain down"), NULL}},
+  { EXIF_TAG_SATURATION,
+    { 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 const struct {
+  ExifTag tag;
+  struct {
+    ExifShort index;
+    const char *values[4]; /*!< list of progressively shorter string
+			    descriptions; the longest one that fits will be
+			    selected */
+  } elem[25];
+} list2[] = {
+#ifndef NO_VERBOSE_TAG_DATA
+  { EXIF_TAG_METERING_MODE,
+    { {  0, {N_("Unknown"), NULL}},
+      {  1, {N_("Average"), N_("Avg"), NULL}},
+      {  2, {N_("Center-weighted average"), N_("Center-weight"), NULL}},
+      {  3, {N_("Spot"), NULL}},
+      {  4, {N_("Multi spot"), NULL}},
+      {  5, {N_("Pattern"), NULL}},
+      {  6, {N_("Partial"), NULL}},
+      {255, {N_("Other"), NULL}},
+      {  0, {NULL}}}},
+  { EXIF_TAG_COMPRESSION,
+    { {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}},
+      {  1, {N_("Daylight"), NULL}},
+      {  2, {N_("Fluorescent"), NULL}},
+      {  3, {N_("Tungsten incandescent light"), N_("Tungsten"), NULL}},
+      {  4, {N_("Flash"), NULL}},
+      {  9, {N_("Fine weather"), NULL}},
+      { 10, {N_("Cloudy weather"), N_("Cloudy"), NULL}},
+      { 11, {N_("Shade"), NULL}},
+      { 12, {N_("Daylight fluorescent"), NULL}},
+      { 13, {N_("Day white fluorescent"), NULL}},
+      { 14, {N_("Cool white fluorescent"), NULL}},
+      { 15, {N_("White fluorescent"), NULL}},
+      { 17, {N_("Standard light A"), NULL}},
+      { 18, {N_("Standard light B"), NULL}},
+      { 19, {N_("Standard light C"), NULL}},
+      { 20, {N_("D55"), NULL}},
+      { 21, {N_("D65"), NULL}},
+      { 22, {N_("D75"), NULL}},
+      { 24, {N_("ISO studio tungsten"),NULL}},
+      {255, {N_("Other"), NULL}},
+      {  0, {NULL}}}},
+  { EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT,
+    { {2, {N_("Inch"), N_("in"), NULL}},
+      {3, {N_("Centimeter"), N_("cm"), NULL}},
+      {0, {NULL}}}},
+  { EXIF_TAG_RESOLUTION_UNIT,
+    { {2, {N_("Inch"), N_("in"), NULL}},
+      {3, {N_("Centimeter"), N_("cm"), NULL}}, 
+      {0, {NULL}}}},
+  { EXIF_TAG_EXPOSURE_PROGRAM,
+    { {0, {N_("Not defined"), NULL}},
+      {1, {N_("Manual"), NULL}},
+      {2, {N_("Normal program"), N_("Normal"), NULL}},
+      {3, {N_("Aperture priority"), N_("Aperture"), NULL}},
+      {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)"),
+	   N_("Action"), NULL}},
+      {7, {N_("Portrait mode (for closeup photos with the background out "
+	      "of focus)"), N_("Portrait"), NULL}},
+      {8, {N_("Landscape mode (for landscape photos with the background "
+	      "in focus)"), N_("Landscape"), NULL}},
+      {0, {NULL}}}},
+  { EXIF_TAG_SENSITIVITY_TYPE,
+    { {0, {N_("Unknown"), NULL}},
+      {1, {N_("Standard output sensitivity (SOS)"), NULL}},
+      {2, {N_("Recommended exposure index (REI)"), NULL}},
+      {3, {N_("ISO speed"), NULL}},
+      {4, {N_("Standard output sensitivity (SOS) and recommended exposure index (REI)"), NULL}},
+      {5, {N_("Standard output sensitivity (SOS) and ISO speed"), NULL}},
+      {6, {N_("Recommended exposure index (REI) and ISO speed"), NULL}},
+      {7, {N_("Standard output sensitivity (SOS) and recommended exposure index (REI) and ISO speed"), NULL}},
+      {0, {NULL}}}},
+  { EXIF_TAG_FLASH,
+    { {0x0000, {N_("Flash did not fire"), N_("No flash"), NULL}},
+      {0x0001, {N_("Flash fired"), N_("Flash"), N_("Yes"), NULL}},
+      {0x0005, {N_("Strobe return light not detected"), N_("Without strobe"),
+		NULL}},
+      {0x0007, {N_("Strobe return light detected"), N_("With strobe"), NULL}},
+      {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, compulsory flash mode, return light "
+		   "detected"), 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"),
+		NULL}},
+      {0x001f, {N_("Flash fired, auto mode, return light detected"), NULL}},
+      {0x0020, {N_("No flash function"),NULL}},
+      {0x0041, {N_("Flash fired, red-eye reduction mode"), NULL}},
+      {0x0045, {N_("Flash fired, red-eye reduction mode, return light "
+		   "not detected"), NULL}},
+      {0x0047, {N_("Flash fired, red-eye reduction mode, return light "
+		   "detected"), NULL}},
+      {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 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, "
+		   "red-eye reduction mode"), NULL}},
+      {0x0000, {NULL}}}},
+  { 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}},
+      {0, {NULL}}}},
+  { EXIF_TAG_COLOR_SPACE,
+    { {1, {N_("sRGB"), NULL}},
+      {2, {N_("Adobe RGB"), NULL}},
+      {0xffff, {N_("Uncalibrated"), NULL}},
+      {0x0000, {NULL}}}},
+#endif
+  {0, { { 0, {NULL}}} }
+};
+
+const char *
+exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
+{
+	unsigned int i, j, k;
+	ExifShort v_short, v_short2, v_short3, v_short4;
+	ExifByte v_byte;
+	ExifRational v_rat;
+	ExifSRational v_srat;
+	char b[64];
+	const char *c;
+	ExifByteOrder o;
+	double d;
+	ExifEntry *entry;
+	static const struct {
+		char label[5];
+		char major, minor;
+	} versions[] = {
+		{"0110", 1,  1},
+		{"0120", 1,  2},
+		{"0200", 2,  0},
+		{"0210", 2,  1},
+		{"0220", 2,  2},
+		{"0221", 2, 21},
+		{"0230", 2,  3},
+		{"0231", 2, 31},
+		{"0232", 2, 32},
+		{""    , 0,  0}
+	};
+
+	(void) bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+
+	if (!e || !e->parent || !e->parent->parent || !maxlen || !val)
+		return val;
+
+	/* make sure the returned string is zero terminated */
+	/* FIXME: this is inefficient in the case of long buffers and should
+	 * instead be taken care of on each write instead. */
+	memset (val, 0, maxlen);
+
+	/* We need the byte order */
+	o = exif_data_get_byte_order (e->parent->parent);
+
+	/* Sanity check */
+	if (e->size != e->components * exif_format_get_size (e->format)) {
+		snprintf (val, maxlen, _("Invalid size of entry (%i, "
+			"expected %li x %i)."), e->size, e->components,
+				exif_format_get_size (e->format));
+		return val;
+	}
+
+	switch (e->tag) {
+	case EXIF_TAG_USER_COMMENT:
+
+		/*
+		 * The specification says UNDEFINED, but some
+		 * manufacturers don't care and use ASCII. If this is the
+		 * case here, only refuse to read it if there is no chance
+		 * of finding readable data.
+		 */
+		if ((e->format != EXIF_FORMAT_ASCII) || 
+		    (e->size <= 8) ||
+		    ( memcmp (e->data, "ASCII\0\0\0"  , 8) &&
+		      memcmp (e->data, "UNICODE\0"    , 8) &&
+		      memcmp (e->data, "JIS\0\0\0\0\0", 8) &&
+		      memcmp (e->data, "\0\0\0\0\0\0\0\0", 8)))
+			CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
+
+		/*
+		 * Note that, according to the specification (V2.1, p 40),
+		 * the user comment field does not have to be 
+		 * NULL terminated.
+		 */
+		if ((e->size >= 8) && !memcmp (e->data, "ASCII\0\0\0", 8)) {
+			strncpy (val, (char *) e->data + 8, MIN (e->size - 8, maxlen-1));
+			break;
+		}
+		if ((e->size >= 8) && !memcmp (e->data, "UNICODE\0", 8)) {
+			strncpy (val, _("Unsupported UNICODE string"), maxlen-1);
+		/* FIXME: use iconv to convert into the locale encoding.
+		 * EXIF 2.2 implies (but does not say) that this encoding is
+		 * UCS-2.
+		 */
+			break;
+		}
+		if ((e->size >= 8) && !memcmp (e->data, "JIS\0\0\0\0\0", 8)) {
+			strncpy (val, _("Unsupported JIS string"), maxlen-1);
+		/* FIXME: use iconv to convert into the locale encoding */
+			break;
+		}
+
+		/* Check if there is really some information in the tag. */
+		for (i = 0; (i < e->size) &&
+			    (!e->data[i] || (e->data[i] == ' ')); i++);
+		if (i == e->size) break;
+
+		/*
+		 * If we reach this point, the tag does not
+ 		 * comply with the standard but seems to contain data.
+		 * Print as much as possible.
+		 * Note: make sure we do not overwrite the final \0 at maxlen-1
+		 */
+		exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
+			_("Tag UserComment contains data but is "
+			  "against specification."));
+ 		for (j = 0; (i < e->size) && (j < maxlen-1); i++, j++) {
+			exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
+				_("Byte at position %i: 0x%02x"), i, e->data[i]);
+ 			val[j] = isprint (e->data[i]) ? e->data[i] : '.';
+		}
+		break;
+
+	case EXIF_TAG_EXIF_VERSION:
+		CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
+		CC (e, 4, val, maxlen);
+		strncpy (val, _("Unknown Exif Version"), maxlen-1);
+		for (i = 0; *versions[i].label; i++) {
+			if (!memcmp (e->data, versions[i].label, 4)) {
+    				snprintf (val, maxlen,
+					_("Exif Version %d.%d"),
+					versions[i].major,
+					versions[i].minor);
+    				break;
+			}
+		}
+		break;
+	case EXIF_TAG_FLASH_PIX_VERSION:
+		CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
+		CC (e, 4, val, maxlen);
+		if (!memcmp (e->data, "0100", 4))
+			strncpy (val, _("FlashPix Version 1.0"), maxlen-1);
+		else if (!memcmp (e->data, "0101", 4))
+			strncpy (val, _("FlashPix Version 1.01"), maxlen-1);
+		else
+			strncpy (val, _("Unknown FlashPix Version"), maxlen-1);
+		break;
+	case EXIF_TAG_COPYRIGHT:
+		CF (e, EXIF_FORMAT_ASCII, val, maxlen);
+
+		/*
+		 * First part: Photographer.
+		 * Some cameras store a string like "   " here. Ignore it.
+		 * Remember that a corrupted tag might not be NUL-terminated
+		 */
+		if (e->size && e->data && match_repeated_char(e->data, ' ', e->size))
+			strncpy (val, (char *) e->data, MIN (maxlen-1, e->size));
+		else
+			strncpy (val, _("[None]"), maxlen-1);
+		strncat (val, " ", maxlen-1 - strlen (val));
+		strncat (val, _("(Photographer)"), maxlen-1 - strlen (val));
+
+		/* Second part: Editor. */
+		strncat (val, " - ", maxlen-1 - strlen (val));
+		k = 0;
+		if (e->size && e->data) {
+			const unsigned char *tagdata = memchr(e->data, 0, e->size);
+			if (tagdata++) {
+				unsigned int editor_ofs = tagdata - e->data;
+				unsigned int remaining = e->size - editor_ofs;
+				if (match_repeated_char(tagdata, ' ', remaining)) {
+					strncat (val, (const char*)tagdata, MIN (maxlen-1 - strlen (val), remaining));
+					++k;
+				}
+			}
+		}
+		if (!k)
+			strncat (val, _("[None]"), maxlen-1 - strlen (val));
+		strncat (val, " ", maxlen-1 - strlen (val));
+		strncat (val, _("(Editor)"), maxlen-1 - strlen (val));
+
+		break;
+	case EXIF_TAG_FNUMBER:
+		CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_rat = exif_get_rational (e->data, o);
+		if (!v_rat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, "f/%.01f", 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 || (0x80000000 == v_rat.numerator)) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, _("%.02f EV"), d);
+		snprintf (b, sizeof (b), _(" (f/%.01f)"), pow (2, d / 2.));
+		strncat (val, b, maxlen-1 - strlen (val));
+		break;
+	case EXIF_TAG_FOCAL_LENGTH:
+		CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_rat = exif_get_rational (e->data, o);
+		if (!v_rat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+
+		/*
+		 * For calculation of the 35mm equivalent,
+		 * Minolta cameras need a multiplier that depends on the
+		 * camera model.
+		 */
+		d = 0.;
+		entry = exif_content_get_entry (
+			e->parent->parent->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
+		if (entry && entry->data && entry->size >= 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 && entry->size >= 8) {
+				if (!strncmp ((char *)entry->data, "DiMAGE 7", 8))
+					d = 3.9;
+				else if (!strncmp ((char *)entry->data, "DiMAGE 5", 8))
+					d = 4.9;
+			}
+		}
+		if (d)
+			snprintf (b, sizeof (b), _(" (35 equivalent: %.0f mm)"),
+				  (d * (double) v_rat.numerator /
+				       (double) v_rat.denominator));
+		else
+			b[0] = 0;
+
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, "%.1f mm", d);
+		strncat (val, b, maxlen-1 - strlen (val));
+		break;
+	case EXIF_TAG_SUBJECT_DISTANCE:
+		CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_rat = exif_get_rational (e->data, o);
+		if (!v_rat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, "%.1f m", d);
+		break;
+	case EXIF_TAG_EXPOSURE_TIME:
+		CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_rat = exif_get_rational (e->data, o);
+		if (!v_rat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		if (d < 1 && d)
+			snprintf (val, maxlen, _("1/%.0f"), 1. / d);
+		else
+			snprintf (val, maxlen, "%.0f", d);
+		strncat (val, _(" sec."), maxlen-1 - strlen (val));
+		break;
+	case EXIF_TAG_SHUTTER_SPEED_VALUE:
+		CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_srat = exif_get_srational (e->data, o);
+		if (!v_srat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		d = (double) v_srat.numerator / (double) v_srat.denominator;
+		snprintf (val, maxlen, _("%.02f EV"), d);
+		if (pow (2, d))
+			d = 1. / pow (2, d);
+		if (d < 1 && d)
+		  snprintf (b, sizeof (b), _(" (1/%.0f sec.)"), 1. / d);
+		else
+		  snprintf (b, sizeof (b), _(" (%.0f sec.)"), d);
+		strncat (val, b, maxlen-1 - strlen (val));
+		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);
+		if (!v_srat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		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));
+		strncat (val, b, maxlen-1 - strlen (val));
+		break;
+	case EXIF_TAG_FILE_SOURCE:
+		CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_byte = e->data[0];
+		if (v_byte == 3)
+			strncpy (val, _("DSC"), maxlen-1);
+		else
+			snprintf (val, maxlen, _("Internal error (unknown "
+				  "value %i)"), v_byte);
+		break;
+	case EXIF_TAG_COMPONENTS_CONFIGURATION:
+		CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
+		CC (e, 4, val, maxlen);
+		for (i = 0; i < 4; i++) {
+			switch (e->data[i]) {
+			case 0: c = _("-"); break;
+			case 1: c = _("Y"); break;
+			case 2: c = _("Cb"); break;
+			case 3: c = _("Cr"); break;
+			case 4: c = _("R"); break;
+			case 5: c = _("G"); break;
+			case 6: c = _("B"); break;
+			default: c = _("Reserved"); break;
+			}
+			strncat (val, c, maxlen-1 - strlen (val));
+			if (i < 3)
+				strncat (val, " ", maxlen-1 - strlen (val));
+		}
+		break;
+	case EXIF_TAG_EXPOSURE_BIAS_VALUE:
+		CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_srat = exif_get_srational (e->data, o);
+		if (!v_srat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		d = (double) v_srat.numerator / (double) v_srat.denominator;
+		snprintf (val, maxlen, _("%.02f EV"), d);
+		break;
+	case EXIF_TAG_SCENE_TYPE:
+		CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_byte = e->data[0];
+		if (v_byte == 1)
+			strncpy (val, _("Directly photographed"), maxlen-1);
+		else
+			snprintf (val, maxlen, _("Internal error (unknown "
+				  "value %i)"), v_byte);
+		break;
+	case EXIF_TAG_YCBCR_SUB_SAMPLING:
+		CF (e, EXIF_FORMAT_SHORT, val, maxlen);
+		CC (e, 2, val, maxlen);
+		v_short  = exif_get_short (e->data, o);
+		v_short2 = exif_get_short (
+			e->data + exif_format_get_size (e->format),
+			o);
+		if ((v_short == 2) && (v_short2 == 1))
+			strncpy (val, _("YCbCr4:2:2"), maxlen-1);
+		else if ((v_short == 2) && (v_short2 == 2))
+			strncpy (val, _("YCbCr4:2:0"), maxlen-1);
+		else
+			snprintf (val, maxlen, "%u, %u", v_short, v_short2);
+		break;
+	case EXIF_TAG_SUBJECT_AREA:
+		CF (e, EXIF_FORMAT_SHORT, val, maxlen);
+		switch (e->components) {
+		case 2:
+			v_short  = exif_get_short (e->data, o);
+			v_short2 = exif_get_short (e->data + 2, o);
+			snprintf (val, maxlen, "(x,y) = (%i,%i)",
+				  v_short, v_short2);
+			break;
+		case 3:
+			v_short  = exif_get_short (e->data, o);
+			v_short2 = exif_get_short (e->data + 2, o);
+			v_short3 = exif_get_short (e->data + 4, o);
+			snprintf (val, maxlen, _("Within distance %i of "
+				"(x,y) = (%i,%i)"), v_short3, v_short,
+				v_short2);
+			break;
+		case 4:
+			v_short  = exif_get_short (e->data, o);
+			v_short2 = exif_get_short (e->data + 2, o);
+			v_short3 = exif_get_short (e->data + 4, o);
+			v_short4 = exif_get_short (e->data + 6, o);
+			snprintf (val, maxlen, _("Within rectangle "
+				"(width %i, height %i) around "
+				"(x,y) = (%i,%i)"), v_short3, v_short4,
+				v_short, v_short2);
+			break;
+		default:
+			snprintf (val, maxlen, _("Unexpected number "
+				"of components (%li, expected 2, 3, or 4)."),
+				e->components);	
+		}
+		break;
+	case EXIF_TAG_GPS_VERSION_ID:
+		/* This is only valid in the GPS IFD */
+		CF (e, EXIF_FORMAT_BYTE, val, maxlen);
+		CC (e, 4, val, maxlen);
+		v_byte = e->data[0];
+		snprintf (val, maxlen, "%u", v_byte);
+		for (i = 1; i < e->components; i++) {
+			v_byte = e->data[i];
+			snprintf (b, sizeof (b), ".%u", v_byte);
+			strncat (val, b, maxlen-1 - strlen (val));
+		}
+		break;
+	case EXIF_TAG_INTEROPERABILITY_VERSION:
+	/* a.k.a. case EXIF_TAG_GPS_LATITUDE: */
+		/* This tag occurs in EXIF_IFD_INTEROPERABILITY */
+		if (e->format == EXIF_FORMAT_UNDEFINED) {
+			strncpy (val, (char *) e->data, MIN (maxlen-1, e->size));
+			break;
+		}
+		/* EXIF_TAG_GPS_LATITUDE is the same numerically as
+		 * EXIF_TAG_INTEROPERABILITY_VERSION but in EXIF_IFD_GPS
+		 */
+		exif_entry_format_value(e, val, maxlen);
+		break;
+	case EXIF_TAG_GPS_ALTITUDE_REF:
+		/* This is only valid in the GPS IFD */
+		CF (e, EXIF_FORMAT_BYTE, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_byte = e->data[0];
+		if (v_byte == 0)
+			strncpy (val, _("Sea level"), maxlen-1);
+		else if (v_byte == 1)
+			strncpy (val, _("Sea level reference"), maxlen-1);
+		else
+			snprintf (val, maxlen, _("Internal error (unknown "
+				  "value %i)"), v_byte);
+		break;
+	case EXIF_TAG_GPS_TIME_STAMP:
+		/* This is only valid in the GPS IFD */
+		CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
+		CC (e, 3, val, maxlen);
+
+		v_rat  = exif_get_rational (e->data, o);
+		if (!v_rat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		i = v_rat.numerator / v_rat.denominator;
+
+		v_rat = exif_get_rational (e->data +
+					     exif_format_get_size (e->format),
+					   o);
+		if (!v_rat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		j = v_rat.numerator / v_rat.denominator;
+
+		v_rat = exif_get_rational (e->data +
+					     2*exif_format_get_size (e->format),
+					     o);
+		if (!v_rat.denominator) {
+			exif_entry_format_value(e, val, maxlen);
+			break;
+		}
+		d = (double) v_rat.numerator / (double) v_rat.denominator;
+		snprintf (val, maxlen, "%02u:%02u:%05.2f", i, j, d);
+		break;
+
+	case EXIF_TAG_METERING_MODE:
+	case EXIF_TAG_COMPRESSION:
+	case EXIF_TAG_LIGHT_SOURCE:
+	case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
+	case EXIF_TAG_RESOLUTION_UNIT:
+	case EXIF_TAG_EXPOSURE_PROGRAM:
+	case EXIF_TAG_SENSITIVITY_TYPE:
+	case EXIF_TAG_FLASH:
+	case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
+	case EXIF_TAG_COLOR_SPACE:
+		CF (e,EXIF_FORMAT_SHORT, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_short = exif_get_short (e->data, o);
+
+		/* Search the tag */
+		for (i = 0; list2[i].tag && (list2[i].tag != e->tag); i++);
+		if (!list2[i].tag) {
+			snprintf (val, maxlen, _("Internal error (unknown "
+				  "value %i)"), v_short);
+			break;
+		}
+
+		/* Find the value */
+		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);
+			break;
+		}
+
+		/* Find a short enough value */
+		memset (val, 0, maxlen);
+		for (k = 0; list2[i].elem[j].values[k]; k++) {
+			size_t l = strlen (_(list2[i].elem[j].values[k]));
+			if ((maxlen > l) && (strlen (val) < l))
+				strncpy (val, _(list2[i].elem[j].values[k]), maxlen-1);
+		}
+		if (!val[0]) snprintf (val, maxlen, "%i", v_short);
+
+		break;
+
+	case EXIF_TAG_PLANAR_CONFIGURATION:
+	case EXIF_TAG_SENSING_METHOD:
+	case EXIF_TAG_ORIENTATION:
+	case EXIF_TAG_YCBCR_POSITIONING:
+	case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
+	case EXIF_TAG_CUSTOM_RENDERED:
+	case EXIF_TAG_EXPOSURE_MODE:
+	case EXIF_TAG_WHITE_BALANCE:
+	case EXIF_TAG_SCENE_CAPTURE_TYPE:
+	case EXIF_TAG_GAIN_CONTROL:
+	case EXIF_TAG_SATURATION:
+	case EXIF_TAG_CONTRAST:
+	case EXIF_TAG_SHARPNESS:
+		CF (e, EXIF_FORMAT_SHORT, val, maxlen);
+		CC (e, 1, val, maxlen);
+		v_short = exif_get_short (e->data, o);
+
+		/* Search the tag */
+		for (i = 0; list[i].tag && (list[i].tag != e->tag); i++);
+		if (!list[i].tag) {
+			snprintf (val, maxlen, _("Internal error (unknown "
+				  "value %i)"), v_short);
+			break;
+		}
+
+		/* Find the value */
+		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])
+			snprintf (val, maxlen, _("Unknown value %i"), v_short);
+		else
+			strncpy (val, _(list[i].strings[j]), maxlen-1);
+		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:
+	{
+		unsigned char *utf16;
+
+		/* Sanity check the size to prevent overflow. Note EXIF files are 64kb at most. */
+		if (e->size >= 65536 - sizeof(uint16_t)*2) break;
+
+		/* The tag may not be U+0000-terminated , so make a local
+		   U+0000-terminated copy before converting it */
+		utf16 = exif_mem_alloc (e->priv->mem, e->size+sizeof(uint16_t)+1);
+		if (!utf16) break;
+		memcpy(utf16, e->data, e->size);
+
+		/* NUL terminate the string. If the size is odd (which isn't possible
+		 * for a valid UTF16 string), then this will overwrite the high byte of
+		 * the final half word, plus add a full zero NUL word at the end.
+		 */
+		utf16[e->size] = 0;
+		utf16[e->size+1] = 0;
+		utf16[e->size+2] = 0;
+
+		/* Warning! The texts are converted from UTF16 to UTF8 */
+		/* FIXME: use iconv to convert into the locale encoding */
+		exif_convert_utf16_to_utf8(val, utf16, maxlen);
+		exif_mem_free(e->priv->mem, utf16);
+		break;
+	}
+
+	default:
+		/* Use a generic value formatting */
+		exif_entry_format_value(e, val, maxlen);
+	}
+
+	return val;
+}
+
+static
+void exif_entry_initialize_gps(ExifEntry *e, ExifTag tag) {
+  const ExifGPSIfdTagInfo* info = exif_get_gps_tag_info(tag);
+
+  if(!info) {
+    e->components = 0;
+    e->format = EXIF_FORMAT_UNDEFINED;
+    e->size = 0;
+    e->data = NULL;
+    return;
+  }
+
+  e->format = info->format;
+  e->components = info->components;
+
+  if(info->components == 0) {
+    /* No pre-allocation */
+    e->size = 0;
+    e->data = NULL;
+  } else {
+    int hasDefault = (info->default_size && info->default_value);
+    int allocSize = hasDefault ? info->default_size : (exif_format_get_size (e->format) * e->components);
+    e->size = allocSize;
+    e->data = exif_entry_alloc (e, e->size);
+    if(!e->data) {
+      clear_entry(e);
+      return;
+    }
+    if(hasDefault) {
+      memcpy(e->data, info->default_value, info->default_size);
+    }
+  }
+}
+
+/*!
+ * \bug Log and report failed exif_mem_malloc() calls.
+ */
+void
+exif_entry_initialize (ExifEntry *e, ExifTag tag)
+{
+	ExifRational r;
+	ExifByteOrder o;
+
+	/* We need the byte order */
+	if (!e || !e->parent || e->data || !e->parent->parent)
+		return;
+	o = exif_data_get_byte_order (e->parent->parent);
+
+	e->tag = tag;
+
+	if(exif_entry_get_ifd(e) == EXIF_IFD_GPS) {
+	  exif_entry_initialize_gps(e, tag);
+      return;
+	}
+
+	switch (tag) {
+
+	/* LONG, 1 component, no default */
+	case EXIF_TAG_PIXEL_X_DIMENSION:
+	case EXIF_TAG_PIXEL_Y_DIMENSION:
+	case EXIF_TAG_EXIF_IFD_POINTER:
+	case EXIF_TAG_GPS_INFO_IFD_POINTER:
+	case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
+	case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
+	case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
+		e->components = 1;
+		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) { clear_entry(e); break; }
+		break;
+
+	/* SHORT, 1 component, no default */
+	case EXIF_TAG_SUBJECT_LOCATION:
+	case EXIF_TAG_SENSING_METHOD:
+	case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
+	case EXIF_TAG_COMPRESSION:
+	case EXIF_TAG_EXPOSURE_MODE:
+	case EXIF_TAG_WHITE_BALANCE:
+	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_ISO_SPEED_RATINGS:
+	case EXIF_TAG_SENSITIVITY_TYPE:
+
+	/* SHORT, 1 component, default 0 */
+	case EXIF_TAG_IMAGE_WIDTH:
+	case EXIF_TAG_IMAGE_LENGTH:
+	case EXIF_TAG_EXPOSURE_PROGRAM:
+	case EXIF_TAG_LIGHT_SOURCE:
+	case EXIF_TAG_METERING_MODE:
+	case EXIF_TAG_CUSTOM_RENDERED:
+	case EXIF_TAG_SCENE_CAPTURE_TYPE:
+	case EXIF_TAG_CONTRAST:
+	case EXIF_TAG_SATURATION:
+	case EXIF_TAG_SHARPNESS:
+		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) { clear_entry(e); 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:
+		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) { clear_entry(e); break; }
+		exif_set_short (e->data, o, 1);
+		break;
+
+	/* SHORT, 1 component, default 2 */
+	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) { clear_entry(e); break; }
+		exif_set_short (e->data, o, 2);
+		break;
+
+	/* SHORT, 1 component, default 3 */
+	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) { clear_entry(e); break; }
+		exif_set_short (e->data, o, 3);
+		break;
+
+	/* SHORT, 1 component, default 0xffff */
+	case EXIF_TAG_COLOR_SPACE:
+		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) { clear_entry(e); break; }
+		exif_set_short (e->data, o, 0xffff);
+		break;
+
+	/* SHORT, 3 components, default 8 8 8 */
+	case EXIF_TAG_BITS_PER_SAMPLE:
+		e->components = 3;
+		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) { clear_entry(e); break; }
+		exif_set_short (e->data, o, 8);
+		exif_set_short (
+			e->data + exif_format_get_size (e->format),
+			o, 8);
+		exif_set_short (
+			e->data + 2 * exif_format_get_size (e->format),
+			o, 8);
+		break;
+
+	/* SHORT, 2 components, default 2 1 */
+	case EXIF_TAG_YCBCR_SUB_SAMPLING:
+		e->components = 2;
+		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) { clear_entry(e); break; }
+		exif_set_short (e->data, o, 2);
+		exif_set_short (
+			e->data + exif_format_get_size (e->format),
+			o, 1);
+		break;
+
+	/* SRATIONAL, 1 component, no default */
+	case EXIF_TAG_EXPOSURE_BIAS_VALUE:
+	case EXIF_TAG_BRIGHTNESS_VALUE:
+	case EXIF_TAG_SHUTTER_SPEED_VALUE:
+		e->components = 1;
+		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) { clear_entry(e); break; }
+		break;
+
+	/* RATIONAL, 1 component, no default */
+	case EXIF_TAG_EXPOSURE_TIME:
+	case EXIF_TAG_FOCAL_PLANE_X_RESOLUTION:
+	case EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION:
+	case EXIF_TAG_EXPOSURE_INDEX:
+	case EXIF_TAG_FLASH_ENERGY:
+	case EXIF_TAG_FNUMBER:
+	case EXIF_TAG_FOCAL_LENGTH:
+	case EXIF_TAG_SUBJECT_DISTANCE:
+	case EXIF_TAG_MAX_APERTURE_VALUE:
+	case EXIF_TAG_APERTURE_VALUE:
+	case EXIF_TAG_COMPRESSED_BITS_PER_PIXEL:
+	case EXIF_TAG_PRIMARY_CHROMATICITIES:
+	case EXIF_TAG_DIGITAL_ZOOM_RATIO:
+		e->components = 1;
+		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) { clear_entry(e); break; }
+		break;
+
+	/* RATIONAL, 1 component, default 72/1 */
+	case EXIF_TAG_X_RESOLUTION:
+	case EXIF_TAG_Y_RESOLUTION:
+		e->components = 1;
+		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) { clear_entry(e); break; }
+		r.numerator = 72;
+		r.denominator = 1;
+		exif_set_rational (e->data, o, r);
+		break;
+
+	/* RATIONAL, 2 components, no default */
+	case EXIF_TAG_WHITE_POINT:
+		e->components = 2;
+		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) { clear_entry(e); break; }
+		break;
+
+	/* RATIONAL, 6 components */
+	case EXIF_TAG_REFERENCE_BLACK_WHITE:
+		e->components = 6;
+		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) { clear_entry(e); break; }
+		r.denominator = 1;
+		r.numerator = 0;
+		exif_set_rational (e->data, o, r);
+		r.numerator = 255;
+		exif_set_rational (
+			e->data + exif_format_get_size (e->format), o, r);
+		r.numerator = 0;
+		exif_set_rational (
+			e->data + 2 * exif_format_get_size (e->format), o, r);
+		r.numerator = 255;
+		exif_set_rational (
+			e->data + 3 * exif_format_get_size (e->format), o, r);
+		r.numerator = 0;
+		exif_set_rational (
+			e->data + 4 * exif_format_get_size (e->format), o, r);
+		r.numerator = 255;
+		exif_set_rational (
+			e->data + 5 * exif_format_get_size (e->format), o, r);
+		break;
+
+	/* ASCII, 20 components */
+	case EXIF_TAG_DATE_TIME:
+	case EXIF_TAG_DATE_TIME_ORIGINAL:
+	case EXIF_TAG_DATE_TIME_DIGITIZED:
+	{
+		time_t t;
+#if defined(HAVE_LOCALTIME_R) || defined(HAVE_LOCALTIME_S)
+		struct tm tms;
+#endif
+		struct tm *tm;
+
+		t = time (NULL);
+#ifdef HAVE_LOCALTIME_R
+		tm = localtime_r (&t, &tms);
+#elif HAVE_LOCALTIME_S
+		localtime_s (&tms, &t);
+		tm = &tms;
+#else
+		tm = localtime (&t);
+#endif
+		e->components = 20;
+		e->format = EXIF_FORMAT_ASCII;
+		e->size = exif_format_get_size (e->format) * e->components;
+		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) { clear_entry(e); break; }
+		snprintf ((char *) e->data, e->size,
+			  "%04i:%02i:%02i %02i:%02i:%02i",
+			  tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+			  tm->tm_hour, tm->tm_min, tm->tm_sec);
+		break;
+	}
+
+	/* ASCII, no default */
+	case EXIF_TAG_SUB_SEC_TIME:
+	case EXIF_TAG_SUB_SEC_TIME_ORIGINAL:
+	case EXIF_TAG_SUB_SEC_TIME_DIGITIZED:
+		e->components = 0;
+		e->format = EXIF_FORMAT_ASCII;
+		e->size = 0;
+		e->data = NULL;
+		break;
+
+	/* ASCII, default "[None]" */
+	case EXIF_TAG_IMAGE_DESCRIPTION:
+	case EXIF_TAG_MAKE:
+	case EXIF_TAG_MODEL:
+	case EXIF_TAG_SOFTWARE:
+	case EXIF_TAG_ARTIST:
+		e->components = strlen (_("[None]")) + 1;
+		e->format = EXIF_FORMAT_ASCII;
+		e->size = exif_format_get_size (e->format) * e->components;
+		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) { clear_entry(e); break; }
+		strncpy ((char *)e->data, _("[None]"), e->size);
+		break;
+	/* ASCII, default "[None]\0[None]\0" */
+	case EXIF_TAG_COPYRIGHT:
+		e->components = (strlen (_("[None]")) + 1) * 2;
+		e->format = EXIF_FORMAT_ASCII;
+		e->size = exif_format_get_size (e->format) * e->components;
+		e->data = exif_entry_alloc (e, e->size);
+		if (!e->data) { clear_entry(e); break; }
+		strcpy (((char *)e->data) + 0, _("[None]"));
+		strcpy (((char *)e->data) + strlen (_("[None]")) + 1, _("[None]"));
+		break;
+
+	/* UNDEFINED, 1 component, default 1 */
+	case EXIF_TAG_SCENE_TYPE:
+		e->components = 1;
+		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) { clear_entry(e); break; }
+		e->data[0] = 0x01;
+		break;
+
+	/* UNDEFINED, 1 component, default 3 */
+	case EXIF_TAG_FILE_SOURCE:
+		e->components = 1;
+		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) { clear_entry(e); break; }
+		e->data[0] = 0x03;
+		break;
+
+	/* UNDEFINED, 4 components, default 48 49 48 48 */
+        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) { clear_entry(e); break; }
+                memcpy (e->data, "0100", 4);
+                break;
+
+        /* UNDEFINED, 4 components, default 48 50 49 48 */
+        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) { clear_entry(e); break; }
+                memcpy (e->data, "0210", 4);
+                break;
+
+        /* UNDEFINED, 4 components, default 1 2 3 0 */
+        case EXIF_TAG_COMPONENTS_CONFIGURATION:
+                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) { clear_entry(e); break; }
+		e->data[0] = 1;
+		e->data[1] = 2;
+		e->data[2] = 3;
+		e->data[3] = 0;
+                break;
+
+	/* UNDEFINED, no components, no default */
+	/* Use this if the tag is otherwise unsupported */
+	case EXIF_TAG_MAKER_NOTE:
+	case EXIF_TAG_USER_COMMENT:
+	default:
+		e->components = 0;
+		e->format = EXIF_FORMAT_UNDEFINED;
+		e->size = 0;
+		e->data = NULL;
+		break;
+	}
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-entry.h

@@ -0,0 +1,186 @@
+/*! \file exif-entry.h
+ *  \brief Handling EXIF entries
+ */
+/*
+ * Copyright (c) 2001 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __EXIF_ENTRY_H__
+#define __EXIF_ENTRY_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*! Data found in one EXIF tag.
+ * The #exif_entry_get_value function can provide access to the
+ * formatted contents, or the struct members can be used directly to
+ * access the raw contents.
+ */
+typedef struct _ExifEntry        ExifEntry;
+typedef struct _ExifEntryPrivate ExifEntryPrivate;
+
+#include <libexif/exif-content.h>
+#include <libexif/exif-format.h>
+#include <libexif/exif-mem.h>
+
+/*! Data found in one EXIF tag */
+struct _ExifEntry {
+	/*! EXIF tag for this entry */
+        ExifTag tag;
+	
+	/*! Type of data in this entry */
+        ExifFormat format;
+
+	/*! Number of elements in the array, if this is an array entry.
+	 * Contains 1 for non-array data types. */
+        unsigned long components;
+
+	/*! Pointer to the raw EXIF data for this entry. It is allocated
+	 * by #exif_entry_initialize and is NULL beforehand. Data contained
+	 * here may be manipulated using the functions in exif-utils.h */
+        unsigned char *data;
+
+	/*! Number of bytes in the buffer at \c data. This must be no less
+	 * than exif_format_get_size(format)*components */
+        unsigned int size;
+
+	/*! #ExifContent containing this entry. 
+	 * \see exif_entry_get_ifd */
+	ExifContent *parent;
+
+	/*! Internal data to be used by libexif itself */
+	ExifEntryPrivate *priv;
+};
+
+/* Lifecycle */
+
+/*! Reserve memory for and initialize a new #ExifEntry.
+ * No memory is allocated for the \c data element of the returned #ExifEntry.
+ *
+ * \return new allocated #ExifEntry, or NULL on error
+ *
+ * \see exif_entry_new_mem, exif_entry_unref
+ */
+ExifEntry  *exif_entry_new     (void);
+
+/*! Reserve memory for and initialize new #ExifEntry using the specified
+ * memory allocator.
+ * No memory is allocated for the \c data element of the returned #ExifEntry.
+ *
+ * \return new allocated #ExifEntry, or NULL on error
+ *
+ * \see exif_entry_new, exif_entry_unref
+ */
+ExifEntry  *exif_entry_new_mem (ExifMem *);
+
+/*! Increase reference counter for #ExifEntry.
+ *
+ * \param[in] entry #ExifEntry
+ *
+ * \see exif_entry_unref
+ */
+void        exif_entry_ref     (ExifEntry *entry);
+
+/*! Decrease reference counter for #ExifEntry.
+ * When the reference count drops to zero, free the entry.
+ *
+ * \param[in] entry #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.
+ *
+ * \param[in] entry EXIF entry
+ */
+void        exif_entry_free  (ExifEntry *entry);
+
+/*! Initialize an empty #ExifEntry with default data in the correct format
+ * for the given tag. If the entry is already initialized, this function
+ * does nothing.
+ * This call allocates memory for the \c data element of the given #ExifEntry.
+ * That memory is freed at the same time as the #ExifEntry.
+ *
+ * \param[out] e entry to initialize
+ * \param[in] tag tag number to initialize as
+ */
+void        exif_entry_initialize (ExifEntry *e, ExifTag tag);
+
+/*! Fix the type or format of the given EXIF entry to bring it into spec.
+ * If the data for this EXIF tag is in of the wrong type or is in an invalid
+ * format according to the EXIF specification, then it is converted to make it
+ * valid. This may involve, for example, converting an EXIF_FORMAT_LONG into a
+ * EXIF_FORMAT_SHORT. If the tag is unknown, its value is untouched.
+ *
+ * \note Unfortunately, some conversions are to a type with a more restricted
+ * range, which could have the side effect that the converted data becomes
+ * invalid. This is unlikely as the range of each tag in the standard is
+ * designed to encompass all likely data.
+ *
+ * \param[in,out] entry EXIF entry
+ */
+void        exif_entry_fix        (ExifEntry *entry);
+
+
+/* For your convenience */
+
+/*! Return a localized textual representation of the value of the EXIF entry.
+ * This is meant for display to the user. The format of each tag is subject
+ * to change between locales and in newer versions of libexif.  Users who
+ * require the tag data in an unambiguous form should access the data members
+ * of the #ExifEntry structure directly.
+ *
+ * \warning The character set of the returned string may be in
+ *          the encoding of the current locale or the native encoding
+ *          of the camera.
+ * \bug     The EXIF_TAG_XP_* tags are currently always returned in UTF-8,
+ *          regardless of locale, and code points above U+FFFF are not
+ *          supported.
+ *
+ * \param[in] entry EXIF entry
+ * \param[out] val buffer in which to store value; if entry is valid and
+ *   maxlen > 0 then this string will be NUL-terminated
+ * \param[in] maxlen length of the buffer val
+ * \return val pointer
+ */
+const char *exif_entry_get_value (ExifEntry *entry, char *val,
+				  unsigned int maxlen);
+
+/*! Dump text representation of #ExifEntry to stdout.
+ * This is intended for diagnostic purposes only.
+ *
+ * \param[in] entry EXIF tag data
+ * \param[in] indent how many levels deep to indent the data
+ */
+void        exif_entry_dump      (ExifEntry *entry, unsigned int indent);
+
+/*! Return the IFD number of the given #ExifEntry
+ *
+ * \param[in] e an #ExifEntry*
+ * \return #ExifIfd, or #EXIF_IFD_COUNT on error
+ */
+#define exif_entry_get_ifd(e) ((e)?exif_content_get_ifd((e)->parent):EXIF_IFD_COUNT)
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __EXIF_ENTRY_H__ */

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-format.c

@@ -0,0 +1,74 @@
+/* exif-format.c
+ *
+ * Copyright (c) 2001 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+
+#include <libexif/exif-format.h>
+#include <libexif/i18n.h>
+
+#include <stdlib.h>
+
+/*! Table of data format types, descriptions and sizes.
+ * This table should be sorted in decreasing order of popularity in order
+ * to decrease the total average lookup time.
+ */
+static const struct {
+        ExifFormat format;
+	const char *name;
+        unsigned char size;
+} ExifFormatTable[] = {
+        {EXIF_FORMAT_SHORT,     N_("Short"),     2},
+        {EXIF_FORMAT_RATIONAL,  N_("Rational"),  8},
+        {EXIF_FORMAT_SRATIONAL, N_("SRational"), 8},
+        {EXIF_FORMAT_UNDEFINED, N_("Undefined"), 1},
+        {EXIF_FORMAT_ASCII,     N_("ASCII"),     1},
+        {EXIF_FORMAT_LONG,      N_("Long"),      4},
+        {EXIF_FORMAT_BYTE,      N_("Byte"),      1},
+	{EXIF_FORMAT_SBYTE,     N_("SByte"),     1},
+	{EXIF_FORMAT_SSHORT,    N_("SShort"),    2},
+        {EXIF_FORMAT_SLONG,     N_("SLong"),     4},
+	{EXIF_FORMAT_FLOAT,     N_("Float"),     4},
+	{EXIF_FORMAT_DOUBLE,    N_("Double"),    8},
+        {0, NULL, 0}
+};
+
+const char *
+exif_format_get_name (ExifFormat format)
+{
+	unsigned int i;
+
+	(void) bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+
+	for (i = 0; ExifFormatTable[i].name; i++)
+		if (ExifFormatTable[i].format == format)
+			return _(ExifFormatTable[i].name);
+	return NULL;
+}
+
+unsigned char
+exif_format_get_size (ExifFormat format)
+{
+	unsigned int i;
+
+	for (i = 0; ExifFormatTable[i].size; i++)
+		if (ExifFormatTable[i].format == format)
+			return ExifFormatTable[i].size;
+	return 0;
+}

local-test-libexif-delta-01-exif-003/afc-libexif/libexif/exif-format.h

@@ -0,0 +1,65 @@
+/*! \file exif-format.h
+ *  \brief Handling native EXIF data types
+ */
+/*
+ *
+ * Copyright (c) 2001 Lutz Mueller <[email protected]>
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#ifndef __EXIF_FORMAT_H__
+#define __EXIF_FORMAT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*! EXIF tag data formats */
+typedef enum {
+        EXIF_FORMAT_BYTE       =  1,
+        EXIF_FORMAT_ASCII      =  2,
+        EXIF_FORMAT_SHORT      =  3,
+        EXIF_FORMAT_LONG       =  4,
+        EXIF_FORMAT_RATIONAL   =  5,
+	EXIF_FORMAT_SBYTE      =  6,
+        EXIF_FORMAT_UNDEFINED  =  7,
+	EXIF_FORMAT_SSHORT     =  8,
+        EXIF_FORMAT_SLONG      =  9,
+        EXIF_FORMAT_SRATIONAL  = 10,
+	EXIF_FORMAT_FLOAT      = 11,
+	EXIF_FORMAT_DOUBLE     = 12
+} ExifFormat;
+
+/*! Return a textual representation of the given EXIF data type.
+ *
+ * \param[in] format EXIF data format
+ * \return localized textual name, or NULL if unknown
+ */
+const char   *exif_format_get_name (ExifFormat format);
+
+/*! Return the raw size of the given EXIF data type.
+ *
+ * \param[in] format EXIF data format
+ * \return size in bytes
+ */
+unsigned char exif_format_get_size (ExifFormat format);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __EXIF_FORMAT_H__ */