Add libexif to deps/third_party.

libexif/sources/libexif/exif-loader.c

+/* exif-loader.c
+ *
+ * Copyright (c) 2002 Lutz Mueller <lutz@users.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details. 
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA.
+ */
+
+#include <config.h>
+
+#include <libexif/exif-loader.h>
+#include <libexif/exif-utils.h>
+#include <libexif/i18n.h>
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#undef JPEG_MARKER_DHT
+#define JPEG_MARKER_DHT  0xc4
+#undef JPEG_MARKER_SOI
+#define JPEG_MARKER_SOI  0xd8
+#undef JPEG_MARKER_DQT
+#define JPEG_MARKER_DQT  0xdb
+#undef JPEG_MARKER_APP0
+#define JPEG_MARKER_APP0 0xe0
+#undef JPEG_MARKER_APP1
+#define JPEG_MARKER_APP1 0xe1
+#undef JPEG_MARKER_APP2
+#define JPEG_MARKER_APP2 0xe2
+#undef JPEG_MARKER_APP13
+#define JPEG_MARKER_APP13 0xed
+#undef JPEG_MARKER_COM
+#define JPEG_MARKER_COM 0xfe
+
+typedef enum {
+        EL_READ = 0,
+        EL_READ_SIZE_BYTE_24,
+        EL_READ_SIZE_BYTE_16,
+        EL_READ_SIZE_BYTE_08,
+        EL_READ_SIZE_BYTE_00,
+        EL_SKIP_BYTES,
+        EL_EXIF_FOUND,
+} ExifLoaderState;
+
+typedef enum {
+        EL_DATA_FORMAT_UNKNOWN,
+        EL_DATA_FORMAT_EXIF,
+        EL_DATA_FORMAT_JPEG,
+        EL_DATA_FORMAT_FUJI_RAW
+} ExifLoaderDataFormat;
+
+/*! \internal */
+struct _ExifLoader {
+        ExifLoaderState state;
+        ExifLoaderDataFormat data_format;
+
+        /*! Small buffer used for detection of format */
+        unsigned char b[12];
+
+        /*! Number of bytes in the small buffer \c b */
+        unsigned char b_len;
+
+        unsigned int size;
+        unsigned char *buf;
+        unsigned int bytes_read;
+
+        unsigned int ref_count;
+
+        ExifLog *log;
+        ExifMem *mem;
+};
+
+/*! Magic number for EXIF header */
+static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
+
+static void *
+exif_loader_alloc (ExifLoader *l, unsigned int i)
+{
+        void *d;
+
+        if (!l || !i) 
+                return NULL;
+
+        d = exif_mem_alloc (l->mem, i);
+        if (d) 
+                return d;
+
+        EXIF_LOG_NO_MEMORY (l->log, "ExifLog", i);
+        return NULL;
+}
+
+void
+exif_loader_write_file (ExifLoader *l, const char *path)
+{
+        FILE *f;
+        int size;
+        unsigned char data[1024];
+
+        if (!l) 
+                return;
+
+        f = fopen (path, "rb");
+        if (!f) {
+                exif_log (l->log, EXIF_LOG_CODE_NONE, "ExifLoader",
+                          _("The file '%s' could not be opened."), path);
+                return;
+        }
+        while (1) {
+                size = fread (data, 1, sizeof (data), f);
+                if (size <= 0) 
+                        break;
+                if (!exif_loader_write (l, data, size)) 
+                        break;
+        }
+        fclose (f);
+}
+
+static unsigned int
+exif_loader_copy (ExifLoader *eld, unsigned char *buf, unsigned int len)
+{
+        if (!eld || (len && !buf) || (eld->bytes_read >= eld->size)) 
+                return 0;
+
+        /* If needed, allocate the buffer. */
+        if (!eld->buf) 
+                eld->buf = exif_loader_alloc (eld, eld->size);
+        if (!eld->buf) 
+                return 0;
+
+        /* Copy memory */
+        len = MIN (len, eld->size - eld->bytes_read);
+        memcpy (eld->buf + eld->bytes_read, buf, len);
+        eld->bytes_read += len;
+
+        return (eld->bytes_read >= eld->size) ? 0 : 1;
+}
+
+unsigned char
+exif_loader_write (ExifLoader *eld, unsigned char *buf, unsigned int len)
+{
+        unsigned int i;
+
+        if (!eld || (len && !buf)) 
+                return 0;
+
+        switch (eld->state) {
+        case EL_EXIF_FOUND:
+                return exif_loader_copy (eld, buf, len);
+        case EL_SKIP_BYTES:
+                if (eld->size > len) { 
+                        eld->size -= len; 
+                        return 1; 
+                }
+                len -= eld->size;
+                buf += eld->size;
+                eld->size = 0;
+                eld->b_len = 0;
+                switch (eld->data_format) {
+                case EL_DATA_FORMAT_FUJI_RAW:
+                        eld->state = EL_READ_SIZE_BYTE_24;
+                        break;
+                default:
+                        eld->state = EL_READ;
+                        break;
+                }
+                break;
+
+        case EL_READ:
+        default:
+                break;
+        }
+
+        if (!len)
+                return 1;
+        exif_log (eld->log, EXIF_LOG_CODE_DEBUG, "ExifLoader",
+                  "Scanning %i byte(s) of data...", len);
+
+        /*
+         * First fill the small buffer. Only continue if the buffer
+         * is filled. Note that EXIF data contains at least 12 bytes.
+         */
+        i = MIN (len, sizeof (eld->b) - eld->b_len);
+        if (i) {
+                memcpy (&eld->b[eld->b_len], buf, i);
+                eld->b_len += i;
+                if (eld->b_len < sizeof (eld->b)) 
+                        return 1;
+                buf += i;
+                len -= i;
+        }
+
+        switch (eld->data_format) {
+        case EL_DATA_FORMAT_UNKNOWN:
+
+                /* Check the small buffer against known formats. */
+                if (!memcmp (eld->b, "FUJIFILM", 8)) {
+
+                        /* Skip to byte 84. There is another offset there. */
+                        eld->data_format = EL_DATA_FORMAT_FUJI_RAW;
+                        eld->size = 84;
+                        eld->state = EL_SKIP_BYTES;
+                        eld->size = 84;
+
+                } else if (!memcmp (eld->b + 2, ExifHeader, sizeof (ExifHeader))) {
+
+                        /* Read the size (2 bytes). */
+                        eld->data_format = EL_DATA_FORMAT_EXIF;
+                        eld->state = EL_READ_SIZE_BYTE_08;
+                }
+        default:
+                break;
+        }
+
+        for (i = 0; i < sizeof (eld->b); i++)
+                switch (eld->state) {
+                case EL_EXIF_FOUND:
+                        if (!exif_loader_copy (eld, eld->b + i,
+                                        sizeof (eld->b) - i)) 
+                                return 0;
+                        return exif_loader_copy (eld, buf, len);
+                case EL_SKIP_BYTES:
+                        eld->size--;
+                        if (!eld->size) 
+                                eld->state = EL_READ;
+                        break;
+
+                case EL_READ_SIZE_BYTE_24:
+                        eld->size |= eld->b[i] << 24;
+                        eld->state = EL_READ_SIZE_BYTE_16;
+                        break;
+                case EL_READ_SIZE_BYTE_16:
+                        eld->size |= eld->b[i] << 16;
+                        eld->state = EL_READ_SIZE_BYTE_08;
+                        break;
+                case EL_READ_SIZE_BYTE_08:
+                        eld->size |= eld->b[i] << 8;
+                        eld->state = EL_READ_SIZE_BYTE_00;
+                        break;
+                case EL_READ_SIZE_BYTE_00:
+                        eld->size |= eld->b[i] << 0;
+                        switch (eld->data_format) {
+                        case EL_DATA_FORMAT_JPEG:
+                                eld->state = EL_SKIP_BYTES;
+                                eld->size -= 2;
+                                break;
+                        case EL_DATA_FORMAT_FUJI_RAW:
+                                eld->data_format = EL_DATA_FORMAT_EXIF;
+                                eld->state = EL_SKIP_BYTES;
+                                eld->size -= 86;
+                                break;
+                        case EL_DATA_FORMAT_EXIF:
+                                eld->state = EL_EXIF_FOUND;
+                                break;
+                        default:
+                                break;
+                        }
+                        break;
+
+                default:
+                        switch (eld->b[i]) {
+                        case JPEG_MARKER_APP1:
+                          if (!memcmp (eld->b + i + 3, ExifHeader, MIN((ssize_t)(sizeof(ExifHeader)), MAX(0, ((ssize_t)(sizeof(eld->b))) - ((ssize_t)i) - 3)))) {
+                                        eld->data_format = EL_DATA_FORMAT_EXIF;
+                                } else {
+                                        eld->data_format = EL_DATA_FORMAT_JPEG; /* Probably JFIF - keep searching for APP1 EXIF*/
+                                }
+                                eld->size = 0;
+                                eld->state = EL_READ_SIZE_BYTE_08;
+                                break;
+                        case JPEG_MARKER_DHT:
+                        case JPEG_MARKER_DQT:
+                        case JPEG_MARKER_APP0:
+                        case JPEG_MARKER_APP2:
+                        case JPEG_MARKER_APP13:
+                        case JPEG_MARKER_COM:
+                                eld->data_format = EL_DATA_FORMAT_JPEG;
+                                eld->size = 0;
+                                eld->state = EL_READ_SIZE_BYTE_08;
+                                break;
+                        case 0xff:
+                        case JPEG_MARKER_SOI:
+                                break;
+                        default:
+                                exif_log (eld->log,
+                                        EXIF_LOG_CODE_CORRUPT_DATA,
+                                        "ExifLoader", _("The data supplied "
+                                                "does not seem to contain "
+                                                "EXIF data."));
+                                exif_loader_reset (eld);
+                                return 0;
+                        }
+                }
+
+        /*
+         * If we reach this point, the buffer has not been big enough
+         * to read all data we need. Fill it with new data.
+         */
+        eld->b_len = 0;
+        return exif_loader_write (eld, buf, len);
+}
+
+ExifLoader *
+exif_loader_new (void)
+{
+        ExifMem *mem = exif_mem_new_default ();
+        ExifLoader *l = exif_loader_new_mem (mem);
+
+        exif_mem_unref (mem);
+
+        return l;
+}
+
+ExifLoader *
+exif_loader_new_mem (ExifMem *mem)
+{
+        ExifLoader *loader;
+
+        if (!mem) 
+                return NULL;
+        
+        loader = exif_mem_alloc (mem, sizeof (ExifLoader));
+        if (!loader) 
+                return NULL;
+        loader->ref_count = 1;
+
+        loader->mem = mem;
+        exif_mem_ref (mem);
+
+        return loader;
+}
+
+void
+exif_loader_ref (ExifLoader *loader)
+{
+        if (loader) 
+                loader->ref_count++;
+}
+
+static void
+exif_loader_free (ExifLoader *loader)
+{
+        ExifMem *mem;
+
+        if (!loader) 
+                return;
+
+        mem = loader->mem;
+        exif_loader_reset (loader);
+        exif_log_unref (loader->log);
+        exif_mem_free (mem, loader);
+        exif_mem_unref (mem);
+}
+        
+void
+exif_loader_unref (ExifLoader *loader)
+{
+        if (!loader) 
+                return;
+        if (!--loader->ref_count)
+                exif_loader_free (loader);
+}
+
+void
+exif_loader_reset (ExifLoader *loader)
+{
+        if (!loader) 
+                return;
+        exif_mem_free (loader->mem, loader->buf); loader->buf = NULL;
+        loader->size = 0;
+        loader->bytes_read = 0;
+        loader->state = 0;
+        loader->b_len = 0;
+        loader->data_format = EL_DATA_FORMAT_UNKNOWN;
+}
+
+ExifData *
+exif_loader_get_data (ExifLoader *loader)
+{
+        ExifData *ed;
+
+        if (!loader || (loader->data_format == EL_DATA_FORMAT_UNKNOWN) ||
+            !loader->bytes_read)
+                return NULL;
+
+        ed = exif_data_new_mem (loader->mem);
+        exif_data_log (ed, loader->log);
+        exif_data_load_data (ed, loader->buf, loader->bytes_read);
+
+        return ed;
+}
+
+void
+exif_loader_get_buf (ExifLoader *loader, const unsigned char **buf,
+                                                  unsigned int *buf_size)
+{
+        const unsigned char* b = NULL;
+        unsigned int s = 0;
+
+        if (!loader || (loader->data_format == EL_DATA_FORMAT_UNKNOWN)) {
+                exif_log (loader->log, EXIF_LOG_CODE_DEBUG, "ExifLoader",
+                          "Loader format unknown");
+        } else {
+                b = loader->buf;
+                s = loader->bytes_read;
+        }
+        if (buf)
+                *buf = b;
+        if (buf_size)
+                *buf_size = s;
+}
+
+void
+exif_loader_log (ExifLoader *loader, ExifLog *log)
+{
+        if (!loader) 
+                return;
+        exif_log_unref (loader->log);
+        loader->log = log;
+        exif_log_ref (log);
+}