@img/sharp-libvips-dev 0.0.1

package/include/libexif/exif-entry.h

@@ -0,0 +1,186 @@
+/*! \file exif-entry.h
+ *  \brief Handling EXIF entries
+ */
+/*
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * 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 LIBEXIF_EXIF_ENTRY_H
+#define LIBEXIF_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 /* !defined(LIBEXIF_EXIF_ENTRY_H) */

package/include/libexif/exif-format.h

@@ -0,0 +1,65 @@
+/*! \file exif-format.h
+ *  \brief Handling native EXIF data types
+ */
+/*
+ *
+ * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * 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 LIBEXIF_EXIF_FORMAT_H
+#define LIBEXIF_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 /* !defined(LIBEXIF_EXIF_FORMAT_H) */

package/include/libexif/exif-ifd.h

@@ -0,0 +1,51 @@
+/* exif-ifd.h
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 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 LIBEXIF_EXIF_IFD_H
+#define LIBEXIF_EXIF_IFD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*! Possible EXIF Image File Directories */
+typedef enum {
+	EXIF_IFD_0 = 0,                /*!< */
+	EXIF_IFD_1,                    /*!< */
+	EXIF_IFD_EXIF,                 /*!< */
+	EXIF_IFD_GPS,                  /*!< */
+	EXIF_IFD_INTEROPERABILITY,     /*!< */
+	EXIF_IFD_COUNT                 /*!< Not a real value, just (max_value + 1). */
+} ExifIfd;
+
+/*! Return a textual name of the given IFD. The name is a short, unique,
+ * non-localized text string containing only US-ASCII alphanumeric
+ * characters.
+ *
+ * \param[in] ifd IFD
+ * \return textual name of the IFD, or NULL if unknown
+ */
+const char *exif_ifd_get_name (ExifIfd ifd);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !defined(LIBEXIF_EXIF_IFD_H) */

package/include/libexif/exif-loader.h

@@ -0,0 +1,128 @@
+/*! \file exif-loader.h
+ * \brief Defines the ExifLoader type
+ */
+/*
+ * Copyright (c) 2003 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * 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 LIBEXIF_EXIF_LOADER_H
+#define LIBEXIF_EXIF_LOADER_H
+
+#include <libexif/exif-data.h>
+#include <libexif/exif-log.h>
+#include <libexif/exif-mem.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*! Data used by the loader interface */
+typedef struct _ExifLoader ExifLoader;
+
+/*! Allocate a new #ExifLoader.
+ *
+ *  \return allocated ExifLoader
+ */
+ExifLoader *exif_loader_new     (void);
+
+/*! Allocate a new #ExifLoader using the specified memory allocator.
+ *
+ *  \param[in] mem the ExifMem
+ *  \return allocated ExifLoader
+ */
+ExifLoader *exif_loader_new_mem (ExifMem *mem);
+
+/*! Increase the refcount of the #ExifLoader.
+ *
+ *  \param[in] loader the ExifLoader to increase the refcount of.
+ */
+void        exif_loader_ref     (ExifLoader *loader);
+
+/*! Decrease the refcount of the #ExifLoader.
+ * If the refcount reaches 0, the loader is freed.
+ *
+ * \param[in] loader ExifLoader for which to decrease the refcount
+ */
+void        exif_loader_unref   (ExifLoader *loader);
+
+/*! Load a file into the given #ExifLoader from the filesystem.
+ * The relevant data is copied in raw form into the #ExifLoader.
+ *
+ * \param[in] loader loader to write to
+ * \param[in] fname path to the file to read
+ */
+void        exif_loader_write_file (ExifLoader *loader, const char *fname);
+
+/*! Load a buffer into the #ExifLoader from a memory buffer.
+ * The relevant data is copied in raw form into the #ExifLoader.
+ *
+ * \param[in] loader loader to write to
+ * \param[in] buf buffer to read from
+ * \param[in] sz size of the buffer
+ * \return 1 while EXIF data is read (or while there is still hope that
+ *   there will be EXIF data later on), 0 otherwise.
+ */
+unsigned char exif_loader_write (ExifLoader *loader, unsigned char *buf, unsigned int sz);
+
+/*! Free any data previously loaded and reset the #ExifLoader to its
+ * newly-initialized state.
+ *
+ * \param[in] loader the loader
+ */
+void          exif_loader_reset (ExifLoader *loader);
+
+/*! Create an #ExifData from the data in the loader. The loader must
+ * already contain data from a previous call to #exif_loader_write_file
+ * or #exif_loader_write.
+ *
+ * \note The #ExifData returned is created using its default options, which
+ * may take effect before the data is returned. If other options are desired,
+ * an #ExifData must be created explicitly and data extracted from the loader
+ * using #exif_loader_get_buf instead.
+ *
+ * \param[in] loader the loader
+ * \return allocated ExifData
+ *
+ * \see exif_loader_get_buf
+ */
+ExifData     *exif_loader_get_data (ExifLoader *loader);
+
+/*! Return the raw data read by the loader.  The returned pointer is only
+ * guaranteed to be valid until the next call to a function modifying
+ * this #ExifLoader.  Either or both of buf and buf_size may be NULL on
+ * entry, in which case that value is not returned.
+ *
+ * \param[in] loader the loader
+ * \param[out] buf read-only pointer to the data read by the loader, or NULL
+ *                 in case of error
+ * \param[out] buf_size size of the data at buf, or 0 in case of error
+ */
+void exif_loader_get_buf (ExifLoader *loader, const unsigned char **buf,
+						  unsigned int *buf_size);
+
+/*! Set the log message object used by this #ExifLoader.
+ * \param[in] loader the loader
+ * \param[in] log #ExifLog
+ */
+void exif_loader_log (ExifLoader *loader, ExifLog *log);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !defined(LIBEXIF_EXIF_LOADER_H) */

package/include/libexif/exif-log.h

@@ -0,0 +1,116 @@
+/*! \file exif-log.h
+ *  \brief Log message infrastructure
+ */
+/*
+ * Copyright (c) 2004 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * 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 LIBEXIF_EXIF_LOG_H
+#define LIBEXIF_EXIF_LOG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <libexif/exif-mem.h>
+#include <stdarg.h>
+
+/*! State maintained by the logging interface */
+typedef struct _ExifLog        ExifLog;
+
+/*! Create a new logging instance.
+ * \see exif_log_free
+ *
+ * \return new instance of #ExifLog
+ */
+ExifLog *exif_log_new     (void);
+ExifLog *exif_log_new_mem (ExifMem *);
+void     exif_log_ref     (ExifLog *log);
+void     exif_log_unref   (ExifLog *log);
+
+/*! Delete instance of #ExifLog.
+ * \see exif_log_new
+ *
+ * \param[in] log #ExifLog
+ * \return new instance of #ExifLog
+ */
+void     exif_log_free    (ExifLog *log);
+
+typedef enum {
+	EXIF_LOG_CODE_NONE,
+	EXIF_LOG_CODE_DEBUG,
+	EXIF_LOG_CODE_NO_MEMORY,
+	EXIF_LOG_CODE_CORRUPT_DATA
+} ExifLogCode;
+
+/*! Return a textual description of the given class of error log.
+ *
+ * \param[in] code logging message class
+ * \return textual description of the log class, or NULL if unknown
+ */
+const char *exif_log_code_get_title   (ExifLogCode code);
+
+/*! Return a verbose description of the given class of error log.
+ *
+ * \param[in] code logging message class
+ * \return verbose description of the log class, or NULL if unknown
+ */
+const char *exif_log_code_get_message (ExifLogCode code);
+
+/*! Log callback function prototype.
+ */
+typedef void (* ExifLogFunc) (ExifLog *log, ExifLogCode, const char *domain,
+			      const char *format, va_list args, void *data);
+
+/*! Register log callback function.
+ * Calls to the log callback function are purely for diagnostic purposes.
+ *
+ * \param[in] log logging state variable
+ * \param[in] func callback function to set
+ * \param[in] data data to pass into callback function
+ */
+void     exif_log_set_func (ExifLog *log, ExifLogFunc func, void *data);
+
+#ifndef NO_VERBOSE_TAG_STRINGS
+void     exif_log  (ExifLog *log, ExifLogCode, const char *domain,
+		    const char *format, ...)
+#ifdef __GNUC__
+			__attribute__((__format__(printf,4,5)))
+#endif
+;
+#else
+#if defined(__STDC_VERSION__) &&  __STDC_VERSION__ >= 199901L
+#define exif_log(...) do { } while (0)
+#elif defined(__GNUC__)
+#define exif_log(x...) do { } while (0)
+#else
+#define exif_log (void)
+#endif
+#endif
+
+void     exif_logv (ExifLog *log, ExifLogCode, const char *domain,
+		    const char *format, va_list args);
+
+/* For your convenience */
+#define EXIF_LOG_NO_MEMORY(l,d,s) exif_log ((l), EXIF_LOG_CODE_NO_MEMORY, (d), "Could not allocate %lu byte(s).", (unsigned long)(s))
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !defined(LIBEXIF_EXIF_LOG_H) */

package/include/libexif/exif-mem.h

@@ -0,0 +1,91 @@
+/*! \file exif-mem.h
+ *  \brief Define the ExifMem data type and the associated functions.
+ *  ExifMem defines the memory management functions used within libexif.
+ */
+/* exif-mem.h
+ *
+ * Copyright (c) 2003 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * 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 LIBEXIF_EXIF_MEM_H
+#define LIBEXIF_EXIF_MEM_H
+
+#include <libexif/exif-utils.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*! Should work like calloc()
+ *
+ *  \param[in] s the size of the block to allocate.
+ *  \return the allocated memory and initialized. 
+ */
+typedef void * (* ExifMemAllocFunc)   (ExifLong s);
+
+/*! Should work like realloc()
+ *
+ * \param[in] p the pointer to reallocate
+ * \param[in] s the size of the reallocated block
+ * \return allocated memory 
+ */
+typedef void * (* ExifMemReallocFunc) (void *p, ExifLong s);
+
+/*! Free method for ExifMem
+ *
+ * \param[in] p the pointer to free
+ * \return the freed pointer
+ */
+typedef void   (* ExifMemFreeFunc)    (void *p);
+
+/*! ExifMem define a memory allocator */
+typedef struct _ExifMem ExifMem;
+
+/*! Create a new ExifMem
+ *
+ * \param[in] a the allocator function
+ * \param[in] r the reallocator function
+ * \param[in] f the free function
+ * \return allocated #ExifMem, or NULL on error
+ */
+ExifMem *exif_mem_new   (ExifMemAllocFunc a, ExifMemReallocFunc r,
+			 ExifMemFreeFunc f);
+/*! Refcount an ExifMem
+ */
+void     exif_mem_ref   (ExifMem *);
+
+/*! Unrefcount an ExifMem.
+ * If the refcount reaches 0, the ExifMem is freed
+ */
+void     exif_mem_unref (ExifMem *);
+
+void *exif_mem_alloc   (ExifMem *m, ExifLong s);
+void *exif_mem_realloc (ExifMem *m, void *p, ExifLong s);
+void  exif_mem_free    (ExifMem *m, void *p);
+
+/*! Create a new ExifMem with default values for your convenience
+ *
+ * \return return a new default ExifMem
+ */
+ExifMem *exif_mem_new_default (void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !defined(LIBEXIF_EXIF_MEM_H) */