/* 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);
}