exif.c

/*
 * Copyright (c) 2001-2007, Eric M. Johnston <emj@postal.net>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Eric M. Johnston.
 * 4. Neither the name of the author nor the names of any co-contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $Id: exif.c,v 1.77 2007/12/16 00:25:08 ejohnst Exp $
 */

/*
 * Exchangeable image file format (Exif) parser.
 *
 * Developed using the TIFF 6.0 specification:
 * (http://partners.adobe.com/asn/developer/pdfs/tn/TIFF6.pdf)
 * and the EXIF 2.21 standard: (http://tsc.jeita.or.jp/avs/data/cp3451_1.pdf).
 *
 * Portions of this code were developed while referencing the public domain
 * 'Jhead' program (version 1.2) by Matthias Wandel <mwandel@rim.net>.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include <float.h>
#include <ctype.h>

#include "exif.h"
#include "exifint.h"
#include "makers.h"

#define OLYMPUS_BUGS		/* Work around Olympus stupidity. */
#define WINXP_BUGS		/* Work around Windows XP stupidity. */
#define SIGMA_BUGS		/* Work around Sigma stupidity. */
#define UNCREDITED_BUGS		/* Work around uncredited stupidity. */


/* Function prototypes. */

static void parsetag(struct exifprop *prop, struct ifd *dir,
    struct exiftags *t, int domkr);


/*
 * Create an Exif property from the raw IFD field data.
 */
static void
readtag(struct field *afield, int ifdseq, struct ifd *dir, struct exiftags *t,
    int domkr)
{
	int i, j;
	struct exifprop *prop, *tmpprop;
	u_int16_t tag;

	prop = newprop();
	if (dir->par)
		tag = dir->par->tag;
	else
		tag = EXIF_T_UNKNOWN;

	/* Field info. */

	prop->tag = exif2byte(afield->tag, dir->md.order);
	prop->type = exif2byte(afield->type, dir->md.order);
	prop->count = exif4byte(afield->count, dir->md.order);
	/* XXX Makes dealing with two shorts somewhat messy. */
	if ((prop->type == TIFF_SHORT || prop->type == TIFF_SSHORT) &&
	    prop->count <= 1)
		prop->value = exif2byte(afield->value, dir->md.order);
	else
		prop->value = exif4byte(afield->value, dir->md.order);

	/* IFD identifying info. */

	prop->ifdseq = ifdseq;
	prop->par = dir->par;
	prop->tagset = dir->tagset;

	/* Lookup the field name. */

	for (i = 0; prop->tagset[i].tag < EXIF_T_UNKNOWN &&
	    prop->tagset[i].tag != prop->tag; i++);
	prop->name = prop->tagset[i].name;
	prop->descr = prop->tagset[i].descr;
	prop->lvl = prop->tagset[i].lvl;

	/*
	 * Lookup and check the field type.
	 *
	 * We have to be pretty severe with entries that have an invalid
	 * field type -- too many assumptions in the rest of the code.
	 */

	for (j = 0; ftypes[j].type && ftypes[j].type != prop->type; j++);
	if (!ftypes[j].type) {
		exifwarn2("unknown TIFF field type; discarding", prop->name);
		free(prop);
		return;
	}

	/* Skip sanity checking on maker note tags; we'll get to them later. */

	if (tag != EXIF_T_MAKERNOTE) {
		/*
		 * XXX Ignore UserComment -- a hack to get around an apparent
		 * WinXP Picture Viewer bug (err, liberty).  When you rotate
		 * a picture in the viewer, it modifies the IFD1 (thumbnail)
		 * tags to UserComment without changing the type appropriately.
		 * (At least we're able to ID invalid comments...)
		 */

		if (prop->tagset[i].type && prop->tagset[i].type !=
		    prop->type) {
#ifdef WINXP_BUGS
			if (prop->tag != EXIF_T_USERCOMMENT)
#endif
				exifwarn2("field type mismatch", prop->name);
			prop->lvl = ED_BAD;
		}

		/*
		 * Check the field count.
		 * XXX For whatever the reason, Sigma doesn't follow the
		 * spec on count for FileSource.
		 */

		if (prop->tagset[i].count && prop->tagset[i].count !=
#ifdef SIGMA_BUGS
		    prop->count && prop->tag != EXIF_T_FILESRC) {
#else
		    prop->count) {
#endif
			exifwarn2("field count mismatch", prop->name);

			/* Let's be forgiving with ASCII fields. */
			if (prop->type != TIFF_ASCII)
				prop->lvl = ED_BAD;
		}
	}

	/* Debuggage. */

	dumpprop(prop, afield);

	/*
	 * Do as much as we can with the tag at this point and add it
	 * to our list.
	 */

	parsetag(prop, dir, t, domkr);
	if ((tmpprop = t->props)) {
		while (tmpprop->next)
			tmpprop = tmpprop->next;
		tmpprop->next = prop;
	} else
		t->props = prop;
}


/*
 * Process the Exif tags for each field of an IFD.
 *
 * Note that this function is only called once per IFD.  Therefore, in order
 * to associate an IFD sequence number with the property, we keep track of
 * the count here.  Root IFDs (0 and 1) are processed first (along with any
 * other "root" IFDs we find), then any nested IFDs in the order they're
 * encountered.
 */
static void
readtags(struct ifd *dir, int seq, struct exiftags *t, int domkr)
{
	int i;

	if (debug) {
		/* XXX Byte order info can be off for maker notes. */
		if (dir->par && dir->par->tag != EXIF_T_UNKNOWN) {
			printf("Processing %s directory, %d entries, "
			    "%s-endian\n",
			    dir->par->name, dir->num, dir->md.order == BIG ?
			    "big" : "little");
		} else
			printf("Processing directory %d, %d entries, "
			    "%s-endian\n",
			    seq, dir->num, dir->md.order == BIG ? "big" :
			    "little");
	}

	for (i = 0; i < dir->num; i++)
		readtag(&(dir->fields[i]), seq, dir, t, domkr);

	if (debug)
		printf("\n");
}


/*
 * Post-process property values.  By now we've got all of the standard
 * Exif tags read in (but not maker tags), so it's safe to work out
 * dependencies between tags.
 *
 * XXX At this point, we've lost IFD-level TIFF metadata.  Therefore,
 * assumptions about byte order and beginning of the TIFF might be false.
 */
static void
postprop(struct exifprop *prop, struct exiftags *t)
{
	struct exifprop *tmpprop;
	u_int16_t v;
	u_int32_t val;
	float fval;
	enum byteorder o = t->md.order;
	struct exifprop *h = t->props;

	/* Skip bad properties. */

	if (prop->lvl == ED_BAD)
		return;

	/*
	 * Process tags from special IFDs.
	 */

	if (prop->par && prop->par->tagset == tags) {
		switch (prop->par->tag) {

		case EXIF_T_MAKERNOTE:
			if (makers[t->mkrval].propfun) {
				makers[t->mkrval].propfun(prop, t);
				return;
			}
			break;

		case EXIF_T_GPSIFD:
			gpsprop(prop, t);
			return;
		}
	}

	/* Process normal tags. */

	if (prop->tagset != tags)
		return;

	switch (prop->tag) {

	case EXIF_T_XRES:
	case EXIF_T_YRES:
	case EXIF_T_FPXRES:
	case EXIF_T_FPYRES:
		if (prop->tag == EXIF_T_XRES || prop->tag == EXIF_T_YRES) {
			if (!(tmpprop = findprop(h, tags, EXIF_T_RESUNITS)))
				break;
		} else {
			if (!(tmpprop = findprop(h, tags, EXIF_T_FPRESUNITS)))
				break;
		}
		val = exif4byte(t->md.btiff + prop->value, o) /
		    exif4byte(t->md.btiff + prop->value + 4, o);
		snprintf(prop->str, 31, "%d dp%s", val, tmpprop->str);
		prop->str[31] = '\0';
		break;

	/*
	 * Shutter speed doesn't seem all that useful.  It's usually the
	 * same as exposure time and when it's not, it's wrong.
	 * Exposure time overrides it.
	 */

	case EXIF_T_SHUTTER:
		fval = (float)exif4sbyte(t->md.btiff + prop->value, o) /
		    (float)exif4sbyte(t->md.btiff + prop->value + 4, o);
		if (isnan(fval)) fval = 0;
		/* 1 / (2^speed) */
		snprintf(prop->str, 31, "1/%d",
		    (int)floor(pow(2, (double)fval) + 0.5));
		prop->str[31] = '\0';
		/* FALLTHROUGH */

	case EXIF_T_EXPOSURE:
		if (strlen(prop->str) > 27) break;
		strcat(prop->str, " sec");
		if (prop->tag == EXIF_T_EXPOSURE)
			prop->override = EXIF_T_SHUTTER;
		break;

	case EXIF_T_FNUMBER:
		fval = (float)exif4byte(t->md.btiff + prop->value, o) /
		    (float)exif4byte(t->md.btiff + prop->value + 4, o);
		if (isnan(fval)) fval = 0;
		snprintf(prop->str, 31, "f/%.1f", fval);
		prop->str[31] = '\0';
		break;

	case EXIF_T_LAPERTURE:
	case EXIF_T_MAXAPERTURE:
		fval = (float)exif4byte(t->md.btiff + prop->value, o) /
		    (float)exif4byte(t->md.btiff + prop->value + 4, o);
		if (isnan(fval)) fval = 0;
		/* sqrt(2)^aperture */
		snprintf(prop->str, 31, "f/%.1f", pow(1.4142, (double)fval));
		prop->str[31] = '\0';
		break;

	case EXIF_T_BRIGHTVAL:
		if (exif4byte(t->md.btiff + prop->value, o) == 0xffffffff) {
			strcpy(prop->str, "Unknown");
			break;
		}
		/* FALLTHROUGH */

	case EXIF_T_EXPBIASVAL:
		if (strlen(prop->str) > 28) break;
		strcat(prop->str, " EV");
		break;

	case EXIF_T_DISTANCE:
		if (exif4byte(t->md.btiff + prop->value, o) == 0xffffffff) {
			strcpy(prop->str, "Infinity");
			break;
		}
		if (exif4byte(t->md.btiff + prop->value + 4, o) == 0) {
			strcpy(prop->str, "Unknown");
			break;
		}
		fval = (float)exif4byte(t->md.btiff + prop->value, o) /
		    (float)exif4byte(t->md.btiff + prop->value + 4, o);
		if (isnan(fval)) fval = 0;
		snprintf(prop->str, 31, "%.2f m", fval);
		prop->str[31] = '\0';
		break;

	/* Flash consists of a number of bits, which expanded with v2.2. */

#define LFLSH 96

	case EXIF_T_FLASH:
		if (t->exifmaj <= 2 && t->exifmin < 20)
			v = (u_int16_t)(prop->value & 0x7);
		else
			v = (u_int16_t)(prop->value & 0x7F);

		exifstralloc(&prop->str, LFLSH);

		/* Don't do anything else if there isn't a flash. */

		if (catdescr(prop->str, flash_func, (u_int16_t)(v & 0x20),
		    LFLSH))
			break;

		catdescr(prop->str, flash_fire, (u_int16_t)(v & 0x01), LFLSH);
		catdescr(prop->str, flash_mode, (u_int16_t)(v & 0x18), LFLSH);
		catdescr(prop->str, flash_redeye, (u_int16_t)(v & 0x40), LFLSH);
		catdescr(prop->str, flash_return, (u_int16_t)(v & 0x06), LFLSH);
		break;

	case EXIF_T_FOCALLEN:
		fval = (float)exif4byte(t->md.btiff + prop->value, o) /
		    (float)exif4byte(t->md.btiff + prop->value + 4, o);
		if (isnan(fval)) fval = 0;
		snprintf(prop->str, 31, "%.2f mm", fval);
		prop->str[31] = '\0';
		break;

	/* Digital zoom: set to verbose if numerator is 0 or fraction = 1. */

	case EXIF_T_DIGIZOOM:
		if (!exif4byte(t->md.btiff + prop->value, o))
			strcpy(prop->str, "Unused");
		else if (exif4byte(t->md.btiff + prop->value, o) !=
		    exif4byte(t->md.btiff + prop->value + 4, o))
			break;
		prop->lvl = ED_VRB;
		break;

	case EXIF_T_FOCALLEN35:
		exifstralloc(&prop->str, 16);
		snprintf(prop->str, 15, "%d mm", prop->value);
		break;

	/*
	 * XXX This really should be in parsetag() to guarantee that it's
	 * done before we process the maker notes.  However, I haven't seen
	 * model not come first, so it should be safe (and more convenient).
	 */

	case EXIF_T_MODEL:
		t->model = prop->str;
		break;
	}
}


/*
 * This gives us an opportunity to change the dump level based on
 * property values after all properties are established.
 */
static void
tweaklvl(struct exifprop *prop, struct exiftags *t)
{
	char *c;
	struct exifprop *tmpprop;

	/* Change any ASCII properties to verbose if they're empty. */

	if (prop->type == TIFF_ASCII &&
	    (prop->lvl & (ED_CAM | ED_IMG | ED_PAS))) {
		c = prop->str;
		while (c && *c && (isspace((int)*c) ||
		    (unsigned char)*c < ' ')) c++;
		if (!c || !*c)
			prop->lvl = ED_VRB;
	}

	/*
	 * Don't let unprintable characters slip through -- we'll just replace
	 * them with '_'.  (Can see this with some corrupt maker notes.)
	 * Remove trailing whitespace while we're at it.
	 */

	if (prop->str && prop->type == TIFF_ASCII) {
		c = prop->str;
		while (*c) {
			/* Catch those pesky chars > 127. */
			if ((unsigned char)*c < ' ')
				*c = '_';
			c++;
		}

		c = prop->str + strlen(prop->str);
		while (c > prop->str && isspace((int)*(c - 1))) --c;
		*c = '\0';
	}

	/*
	 * IFD1 refers to the thumbnail image; we don't really care.
	 * It seems that some images might not have an IFD1 (does FinePix
	 * Viewer strip it?), so make sure that the property doesn't have
	 * a parent association.
	 */

	if (prop->ifdseq == 1 && !prop->par && prop->lvl != ED_UNK)
		prop->lvl = ED_VRB;

	/* Maker tags can override normal Exif tags. */

	if (prop->override && (tmpprop = findprop(t->props, tags,
	    prop->override)))
		if (tmpprop->lvl & (ED_CAM | ED_IMG | ED_PAS))
			tmpprop->lvl = ED_OVR;
}


/*
 * Fetch the data for an Exif tag.
 */
static void
parsetag(struct exifprop *prop, struct ifd *dir, struct exiftags *t, int domkr)
{
	unsigned int i, len;
	u_int16_t v = (u_int16_t)prop->value;
	u_int32_t un, ud, denom;
	int32_t sn, sd;
	char buf[32], *c, *d;
	struct tiffmeta *md;
	unsigned char *btiff = dir->md.btiff;
	enum byteorder o = dir->md.order;

	/* If the tag's already marked as bad, no sense in continuing. */

	if (prop->lvl == ED_BAD)
		return;

	/* Set description if we have a lookup table. */

	for (i = 0; prop->tagset[i].tag < EXIF_T_UNKNOWN &&
	    prop->tagset[i].tag != prop->tag; i++);
	if (prop->tagset[i].table) {
		prop->str = finddescr(prop->tagset[i].table, v);
		return;
	}

	/* XXX Probably shouldn't process this switch for non-standard tags. */

	switch (prop->tag) {

	/* Process an Exif IFD. */

	case EXIF_T_EXIFIFD:
	case EXIF_T_GPSIFD:
	case EXIF_T_INTEROP:
		md = &dir->md;
		while (dir->next)
			dir = dir->next;

		/*
		 * XXX Olympus cameras don't seem to include a proper offset
		 * at the end of the ExifOffset IFD, so just read one IFD.
		 * Hopefully this won't cause us to miss anything...
		 */
#ifdef OLYMPUS_BUGS
		if (prop->tag == EXIF_T_EXIFIFD)
			readifd(prop->value, &dir->next, tags, md);
		else
#endif
			if (prop->tag == EXIF_T_GPSIFD) {
				dir->next = readifds(prop->value, gpstags, md);
			} else {
				dir->next = readifds(prop->value, tags, md);
			}

		if (!dir->next) {

			/*
			 * XXX Ignore the case where interoperability offset
			 * is invalid.  This appears to be the case with some
			 * Olympus cameras, and we don't want to abort things
			 * things on an IFD we don't really care about anyway.
			 */
#ifdef OLYMPUS_BUGS
			if (prop->tag == EXIF_T_INTEROP)
				break;
#endif
			exifwarn2("invalid Exif format: IFD length mismatch",
			    prop->name);
			break;
		}

		/* XXX Doesn't catch multiple IFDs. */
		dir->next->par = prop;
		return;

	/* Record the Exif version. */

	case EXIF_T_VERSION:
		byte4exif(prop->value, (unsigned char *)buf, o);
		buf[4] = '\0';
		t->exifmin = (short)atoi(buf + 2);
		buf[2] = '\0';
		t->exifmaj = (short)atoi(buf);

		exifstralloc(&prop->str, 8);
		snprintf(prop->str, 7, "%d.%02d", t->exifmaj, t->exifmin);
		break;

	/* Process a maker note. */

	case EXIF_T_MAKERNOTE:
		if (!domkr)
			return;

		/* Maker function can change metadata if necessary. */

		t->mkrmd = dir->md;
		md = &t->mkrmd;
		while (dir->next)
			dir = dir->next;

		/*
		 * Try to process maker note IFDs using the function
		 * specified for the maker.
		 *
		 * XXX Note that for this to work right, we have to see
		 * the manufacturer tag first to figure out makerifd().
		 */

		if (makers[t->mkrval].ifdfun) {
			if (!offsanity(prop, 1, dir))
				dir->next =
				    makers[t->mkrval].ifdfun(prop->value, md);
		} else
			exifwarn("maker note not supported");

		if (!dir->next)
			break;

		/* XXX Doesn't catch multiple IFDs. */
		dir->next->par = prop;
		return;

	/* Lookup functions for maker note. */

	case EXIF_T_EQUIPMAKE:

		/* Sanity check the offset. */

		if (offsanity(prop, 1, dir))
			return;

		strncpy(buf, (const char *)(btiff + prop->value), sizeof(buf));
		buf[sizeof(buf) - 1] = '\0';
		for (c = buf; *c; c++) *c = tolower(*c);

		for (i = 0; makers[i].val != EXIF_MKR_UNKNOWN; i++)
			if (!strncmp(buf, makers[i].name,
			    strlen(makers[i].name)))
				break;
		t->mkrval = (short)i;

		/* Keep processing (ASCII value). */
		break;

	/*
	 * Handle user comment.  According to the spec, the first 8 bytes
	 * of the comment indicate what charset follows.  For now, we
	 * just support ASCII.
	 *
	 * XXX A handful of the GPS tags are also stored in this format.
	 */

	case 0x001b:	/* GPSProcessingMethod */
	case 0x001c:	/* GPSAreaInformation */
		/*
		 * XXX Note that this is kind of dangerous -- any other
		 * tag set won't reach the end of the switch...
		 */
		if (prop->tagset != gpstags)
			break;
		/* FALLTHROUGH */

	case EXIF_T_USERCOMMENT:

		/* Check for a comment type and sane offset. */

		if (prop->count < 8) {
			exifwarn("invalid user comment length");
			prop->lvl = ED_BAD;
			return;
		}

		if (offsanity(prop, 1, dir))
			return;

		/* Ignore the 'comments' WinXP creates when rotating. */
#ifdef WINXP_BUGS
		for (i = 0; tags[i].tag < EXIF_T_UNKNOWN &&
		    tags[i].tag != EXIF_T_USERCOMMENT; i++);
		if (tags[i].type && tags[i].type != prop->type)
			break;
#endif
		/* Lookup the comment type. */

		for (i = 0; ucomment[i].descr; i++)
			if (!memcmp(ucomment[i].descr, btiff + prop->value, 8))
				break;

		/* Handle an ASCII comment; strip any trailing whitespace. */

		if (ucomment[i].val == TIFF_ASCII) {
			c = (char *)(btiff + prop->value + 8);
			d = strlen(c) < prop->count - 8 ? c + strlen(c) :
			    c + prop->count - 8;

			while (d > c && isspace((int)*(d - 1))) --d;

			exifstralloc(&prop->str, d - c + 1);
			strncpy(prop->str, c, d - c);
			prop->lvl = prop->str[0] ? ED_IMG : ED_VRB;
			return;
		}
		break;

	case EXIF_T_FILESRC:
		/*
		 * This 'undefined' field is one byte; runs afoul of XP
		 * not zeroing out stuff.
		 */
#ifdef WINXP_BUGS
		prop->str = finddescr(filesrcs, (u_int16_t)(v & 0xFFU));
#else
		prop->str = finddescr(filesrcs, v);
#endif
		return;
	}

	/*
	 * ASCII types.
	 */

	if (prop->type == TIFF_ASCII) {
		/* Should fit in the value field. */
		if (prop->count < 5) {
			exifstralloc(&prop->str, 5);
			byte4exif(prop->value, (unsigned char *)prop->str, o);
			return;
		}

		/* Sanity check the offset. */
		if (!offsanity(prop, 1, dir)) {
			exifstralloc(&prop->str, prop->count + 1);
			strncpy(prop->str, (const char *)(btiff + prop->value),
			    prop->count);
		}
		return;
	}

	/*
	 * Rational types.  (Note that we'll redo some in our later pass.)
	 * We'll reduce and simplify the fraction.
	 *
	 * XXX Misses multiple rationals.
	 */

	if ((prop->type == TIFF_RTNL || prop->type == TIFF_SRTNL) &&
	    !offsanity(prop, 8, dir)) {

		exifstralloc(&prop->str, 32);

		if (prop->type == TIFF_RTNL) {
			un = exif4byte(btiff + prop->value, o);
			ud = exif4byte(btiff + prop->value + 4, o);
			denom = gcd(un, ud);
			fixfract(prop->str, un, ud, denom);
		} else {
			sn = exif4sbyte(btiff + prop->value, o);
			sd = exif4sbyte(btiff + prop->value + 4, o);
			denom = gcd(abs(sn), abs(sd));
			fixfract(prop->str, sn, sd, (int32_t)denom);
		}
		return;
	}

	/*
	 * Multiple short values.
	 * XXX For now, we're going to ignore tags with count > 8.  Maker
	 * note tags frequently consist of many shorts; we don't really
	 * want to be spitting these out.  (Plus, TransferFunction is huge.)
	 *
	 * XXX Note that this doesn't apply to two shorts, which are
	 * stuffed into the value.
	 */

	if ((prop->type == TIFF_SHORT || prop->type == TIFF_SSHORT) &&
	    prop->count > 2 && !offsanity(prop, 2, dir)) {

		if (prop->count > 8)
			return;
		len = 8 * prop->count + 1;
		exifstralloc(&prop->str, len);

		for (i = 0; i < prop->count; i++) {
			if (prop->type == TIFF_SHORT)
				snprintf(prop->str + strlen(prop->str),
				    len - strlen(prop->str) - 1, "%d, ",
				    exif2byte(btiff + prop->value +
				    (i * 2), o));
			else
				snprintf(prop->str + strlen(prop->str),
				    len - strlen(prop->str) - 1, "%d, ",
				    exif2sbyte(btiff + prop->value +
				    (i * 2), o));
		}
		prop->str[strlen(prop->str) - 2] = '\0';
		return;
	}
	return;
}


/*
 * Delete dynamic Exif property and IFD memory.
 */
void
exiffree(struct exiftags *t)
{
	struct exifprop *tmpprop;
	struct ifdoff *tmpoff;

	if (!t) return;

	while ((tmpprop = t->props)) {
		if (t->props->str) free(t->props->str);
		t->props = t->props->next;
		free(tmpprop);
	}
	while ((tmpoff = (struct ifdoff *)(t->md.ifdoffs))) {
		t->md.ifdoffs = (void *)tmpoff->next;
		free(tmpoff);
	}
	free(t);
}


/*
 * Scan the Exif section.
 */
struct exiftags *
exifscan(unsigned char *b, int len, int domkr)
{
	int seq;
	u_int32_t ifdoff;
	struct exiftags *t;
	struct ifd *curifd, *tmpifd;

	/* Create and initialize our file info structure. */

	t = (struct exiftags *)malloc(sizeof(struct exiftags));
	if (!t) {
		exifwarn2("can't allocate file info",
		    (const char *)strerror(errno));
		return (NULL);
	}
	memset(t, 0, sizeof(struct exiftags));

	seq = 0;
	t->md.etiff = b + len;	/* End of TIFF. */

	/*
	 * Make sure we've got the proper Exif header.  If not, we're
	 * looking at somebody else's APP1 (e.g., Photoshop).
	 */

	if (memcmp(b, "Exif\0\0", 6)) {
		exiffree(t);
		return (NULL);
	}
	b += 6;

	/* Determine endianness of the TIFF data. */

	if (!memcmp(b, "MM", 2))
		t->md.order = BIG;
	else if (!memcmp(b, "II", 2))
		t->md.order = LITTLE;
	else {
		exifwarn("invalid TIFF header");
		exiffree(t);
		return (NULL);
	}

	t->md.btiff = b;	/* Beginning of TIFF. */
	b += 2;

	/* Verify the TIFF header. */

	if (exif2byte(b, t->md.order) != 42) {
		exifwarn("invalid TIFF header");
		exiffree(t);
		return (NULL);
	}
	b += 2;

	/* Get the 0th IFD, where all of the good stuff should start. */

	ifdoff = exif4byte(b, t->md.order);
	curifd = readifds(ifdoff, tags, &t->md);
	if (!curifd) {
		exifwarn("invalid Exif format (couldn't read IFD0)");
		exiffree(t);
		return (NULL);
	}

	/* Now, let's parse the fields... */

	while ((tmpifd = curifd)) {
		readtags(curifd, seq++, t, domkr);
		curifd = curifd->next;
		free(tmpifd);		/* No need to keep it around... */
	}

	return (t);
}


/*
 * Read the Exif section and prepare the data for output.
 */
struct exiftags *
exifparse(unsigned char *b, int len)
{
	struct exiftags *t;
	struct exifprop *curprop;

	/* Find the section and scan it. */

	if (!(t = exifscan(b, len, TRUE)))
		return (NULL);

	/* Make field values pretty. */

	curprop = t->props;
	while (curprop) {
		postprop(curprop, t);
		tweaklvl(curprop, t);
		curprop = curprop->next;
	}

	return (t);
}