src/tiff/tif_dirinfo.c

/* $Header$ */

/*
 * Copyright (c) 1988-1997 Sam Leffler
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software and
 * its documentation for any purpose is hereby granted without fee, provided
 * that (i) the above copyright notices and this permission notice appear in
 * all copies of the software and related documentation, and (ii) the names of
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 * publicity relating to the software without the specific, prior written
 * permission of Sam Leffler and Silicon Graphics.
 *
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

/*
 * TIFF Library.
 *
 * Core Directory Tag Support.
 */
#include "tiffiop.h"
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>

/*
 * NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
 *     If a tag can have both LONG and SHORT types
 *     then the LONG must be placed before the SHORT for
 *     writing to work properly.
 *
 * NOTE: The second field (field_readcount) and third field (field_writecount)
 *       sometimes use the values TIFF_VARIABLE (-1), TIFF_VARIABLE2 (-3)
 *       and TIFFTAG_SPP (-2). The macros should be used but would throw off
 *       the formatting of the code, so please interprete the -1, -2 and -3
 *       values accordingly.
 */
#ifndef VMS
static
#endif
const TIFFFieldInfo tiffFieldInfo[] = {
    { TIFFTAG_SUBFILETYPE,	 1, 1, TIFF_LONG,	FIELD_SUBFILETYPE,
      TRUE,	FALSE,	"SubfileType" },
/* XXX SHORT for compatibility w/ old versions of the library */
    { TIFFTAG_SUBFILETYPE,	 1, 1, TIFF_SHORT,	FIELD_SUBFILETYPE,
      TRUE,	FALSE,	"SubfileType" },
    { TIFFTAG_OSUBFILETYPE,	 1, 1, TIFF_SHORT,	FIELD_SUBFILETYPE,
      TRUE,	FALSE,	"OldSubfileType" },
    { TIFFTAG_IMAGEWIDTH,	 1, 1, TIFF_LONG,	FIELD_IMAGEDIMENSIONS,
      FALSE,	FALSE,	"ImageWidth" },
    { TIFFTAG_IMAGEWIDTH,	 1, 1, TIFF_SHORT,	FIELD_IMAGEDIMENSIONS,
      FALSE,	FALSE,	"ImageWidth" },
    { TIFFTAG_IMAGELENGTH,	 1, 1, TIFF_LONG,	FIELD_IMAGEDIMENSIONS,
      TRUE,	FALSE,	"ImageLength" },
    { TIFFTAG_IMAGELENGTH,	 1, 1, TIFF_SHORT,	FIELD_IMAGEDIMENSIONS,
      TRUE,	FALSE,	"ImageLength" },
/* XXX LONG for compatibility with some broken TIFF writers */
    { TIFFTAG_BITSPERSAMPLE,	-1,-1, TIFF_LONG,	FIELD_BITSPERSAMPLE,
      FALSE,	FALSE,	"BitsPerSample" },
    { TIFFTAG_BITSPERSAMPLE,	-1,-1, TIFF_SHORT,	FIELD_BITSPERSAMPLE,
      FALSE,	FALSE,	"BitsPerSample" },
/* XXX LONG for compatibility with some broken TIFF writers */
    { TIFFTAG_COMPRESSION,	-1, 1, TIFF_LONG,	FIELD_COMPRESSION,
      FALSE,	FALSE,	"Compression" },
    { TIFFTAG_COMPRESSION,	-1, 1, TIFF_SHORT,	FIELD_COMPRESSION,
      FALSE,	FALSE,	"Compression" },
/* XXX LONG for compatibility with some broken TIFF writers */
    { TIFFTAG_PHOTOMETRIC,	 1, 1, TIFF_LONG,	FIELD_PHOTOMETRIC,
      FALSE,	FALSE,	"PhotometricInterpretation" },
    { TIFFTAG_PHOTOMETRIC,	 1, 1, TIFF_SHORT,	FIELD_PHOTOMETRIC,
      FALSE,	FALSE,	"PhotometricInterpretation" },
    { TIFFTAG_THRESHHOLDING,	 1, 1, TIFF_SHORT,	FIELD_THRESHHOLDING,
      TRUE,	FALSE,	"Threshholding" },
    { TIFFTAG_CELLWIDTH,	 1, 1, TIFF_SHORT,	FIELD_IGNORE,
      TRUE,	FALSE,	"CellWidth" },
    { TIFFTAG_CELLLENGTH,	 1, 1, TIFF_SHORT,	FIELD_IGNORE,
      TRUE,	FALSE,	"CellLength" },
    { TIFFTAG_FILLORDER,	 1, 1, TIFF_SHORT,	FIELD_FILLORDER,
      FALSE,	FALSE,	"FillOrder" },
    { TIFFTAG_DOCUMENTNAME,	-1,-1, TIFF_ASCII,	FIELD_DOCUMENTNAME,
      TRUE,	FALSE,	"DocumentName" },
    { TIFFTAG_IMAGEDESCRIPTION,	-1,-1, TIFF_ASCII,	FIELD_IMAGEDESCRIPTION,
      TRUE,	FALSE,	"ImageDescription" },
    { TIFFTAG_MAKE,		-1,-1, TIFF_ASCII,	FIELD_MAKE,
      TRUE,	FALSE,	"Make" },
    { TIFFTAG_MODEL,		-1,-1, TIFF_ASCII,	FIELD_MODEL,
      TRUE,	FALSE,	"Model" },
    { TIFFTAG_STRIPOFFSETS,	-1,-1, TIFF_LONG,	FIELD_STRIPOFFSETS,
      FALSE,	FALSE,	"StripOffsets" },
    { TIFFTAG_STRIPOFFSETS,	-1,-1, TIFF_SHORT,	FIELD_STRIPOFFSETS,
      FALSE,	FALSE,	"StripOffsets" },
    { TIFFTAG_ORIENTATION,	 1, 1, TIFF_SHORT,	FIELD_ORIENTATION,
      FALSE,	FALSE,	"Orientation" },
    { TIFFTAG_SAMPLESPERPIXEL,	 1, 1, TIFF_SHORT,	FIELD_SAMPLESPERPIXEL,
      FALSE,	FALSE,	"SamplesPerPixel" },
    { TIFFTAG_ROWSPERSTRIP,	 1, 1, TIFF_LONG,	FIELD_ROWSPERSTRIP,
      FALSE,	FALSE,	"RowsPerStrip" },
    { TIFFTAG_ROWSPERSTRIP,	 1, 1, TIFF_SHORT,	FIELD_ROWSPERSTRIP,
      FALSE,	FALSE,	"RowsPerStrip" },
    { TIFFTAG_STRIPBYTECOUNTS,	-1,-1, TIFF_LONG,	FIELD_STRIPBYTECOUNTS,
      FALSE,	FALSE,	"StripByteCounts" },
    { TIFFTAG_STRIPBYTECOUNTS,	-1,-1, TIFF_SHORT,	FIELD_STRIPBYTECOUNTS,
      FALSE,	FALSE,	"StripByteCounts" },
    { TIFFTAG_MINSAMPLEVALUE,	-2,-1, TIFF_SHORT,	FIELD_MINSAMPLEVALUE,
      TRUE,	FALSE,	"MinSampleValue" },
    { TIFFTAG_MAXSAMPLEVALUE,	-2,-1, TIFF_SHORT,	FIELD_MAXSAMPLEVALUE,
      TRUE,	FALSE,	"MaxSampleValue" },
    { TIFFTAG_XRESOLUTION,	 1, 1, TIFF_RATIONAL,	FIELD_RESOLUTION,
      FALSE,	FALSE,	"XResolution" },
    { TIFFTAG_YRESOLUTION,	 1, 1, TIFF_RATIONAL,	FIELD_RESOLUTION,
      FALSE,	FALSE,	"YResolution" },
    { TIFFTAG_PLANARCONFIG,	 1, 1, TIFF_SHORT,	FIELD_PLANARCONFIG,
      FALSE,	FALSE,	"PlanarConfiguration" },
    { TIFFTAG_PAGENAME,		-1,-1, TIFF_ASCII,	FIELD_PAGENAME,
      TRUE,	FALSE,	"PageName" },
    { TIFFTAG_XPOSITION,	 1, 1, TIFF_RATIONAL,	FIELD_POSITION,
      TRUE,	FALSE,	"XPosition" },
    { TIFFTAG_YPOSITION,	 1, 1, TIFF_RATIONAL,	FIELD_POSITION,
      TRUE,	FALSE,	"YPosition" },
    { TIFFTAG_FREEOFFSETS,	-1,-1, TIFF_LONG,	FIELD_IGNORE,
      FALSE,	FALSE,	"FreeOffsets" },
    { TIFFTAG_FREEBYTECOUNTS,	-1,-1, TIFF_LONG,	FIELD_IGNORE,
      FALSE,	FALSE,	"FreeByteCounts" },
    { TIFFTAG_GRAYRESPONSEUNIT,	 1, 1, TIFF_SHORT,	FIELD_IGNORE,
      TRUE,	FALSE,	"GrayResponseUnit" },
    { TIFFTAG_GRAYRESPONSECURVE,-1,-1, TIFF_SHORT,	FIELD_IGNORE,
      TRUE,	FALSE,	"GrayResponseCurve" },
    { TIFFTAG_RESOLUTIONUNIT,	 1, 1, TIFF_SHORT,	FIELD_RESOLUTIONUNIT,
      FALSE,	FALSE,	"ResolutionUnit" },
    { TIFFTAG_PAGENUMBER,	 2, 2, TIFF_SHORT,	FIELD_PAGENUMBER,
      TRUE,	FALSE,	"PageNumber" },
    { TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT,	FIELD_IGNORE,
      TRUE,	FALSE,	"ColorResponseUnit" },
    { TIFFTAG_TRANSFERFUNCTION,	-1,-1, TIFF_SHORT,	FIELD_TRANSFERFUNCTION,
      TRUE,	FALSE,	"TransferFunction" },
    { TIFFTAG_SOFTWARE,		-1,-1, TIFF_ASCII,	FIELD_CUSTOM,
      TRUE,	FALSE,	"Software" },
    { TIFFTAG_DATETIME,		20,20, TIFF_ASCII,	FIELD_DATETIME,
      TRUE,	FALSE,	"DateTime" },
    { TIFFTAG_ARTIST,		-1,-1, TIFF_ASCII,	FIELD_ARTIST,
      TRUE,	FALSE,	"Artist" },
    { TIFFTAG_HOSTCOMPUTER,	-1,-1, TIFF_ASCII,	FIELD_HOSTCOMPUTER,
      TRUE,	FALSE,	"HostComputer" },
    { TIFFTAG_WHITEPOINT,	 2, 2, TIFF_RATIONAL,FIELD_WHITEPOINT,
      TRUE,	FALSE,	"WhitePoint" },
    { TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL,FIELD_PRIMARYCHROMAS,
      TRUE,	FALSE,	"PrimaryChromaticities" },
    { TIFFTAG_COLORMAP,		-1,-1, TIFF_SHORT,	FIELD_COLORMAP,
      TRUE,	FALSE,	"ColorMap" },
    { TIFFTAG_HALFTONEHINTS,	 2, 2, TIFF_SHORT,	FIELD_HALFTONEHINTS,
      TRUE,	FALSE,	"HalftoneHints" },
    { TIFFTAG_TILEWIDTH,	 1, 1, TIFF_LONG,	FIELD_TILEDIMENSIONS,
      FALSE,	FALSE,	"TileWidth" },
    { TIFFTAG_TILEWIDTH,	 1, 1, TIFF_SHORT,	FIELD_TILEDIMENSIONS,
      FALSE,	FALSE,	"TileWidth" },
    { TIFFTAG_TILELENGTH,	 1, 1, TIFF_LONG,	FIELD_TILEDIMENSIONS,
      FALSE,	FALSE,	"TileLength" },
    { TIFFTAG_TILELENGTH,	 1, 1, TIFF_SHORT,	FIELD_TILEDIMENSIONS,
      FALSE,	FALSE,	"TileLength" },
    { TIFFTAG_TILEOFFSETS,	-1, 1, TIFF_LONG,	FIELD_STRIPOFFSETS,
      FALSE,	FALSE,	"TileOffsets" },
    { TIFFTAG_TILEBYTECOUNTS,	-1, 1, TIFF_LONG,	FIELD_STRIPBYTECOUNTS,
      FALSE,	FALSE,	"TileByteCounts" },
    { TIFFTAG_TILEBYTECOUNTS,	-1, 1, TIFF_SHORT,	FIELD_STRIPBYTECOUNTS,
      FALSE,	FALSE,	"TileByteCounts" },
    { TIFFTAG_SUBIFD,		-1,-1, TIFF_LONG,	FIELD_SUBIFD,
      TRUE,	TRUE,	"SubIFD" },
    { TIFFTAG_INKSET,		 1, 1, TIFF_SHORT,	FIELD_INKSET,
      FALSE,	FALSE,	"InkSet" },
    { TIFFTAG_INKNAMES,		-1,-1, TIFF_ASCII,	FIELD_INKNAMES,
      TRUE,	TRUE,	"InkNames" },
    { TIFFTAG_NUMBEROFINKS,	 1, 1, TIFF_SHORT,	FIELD_NUMBEROFINKS,
      TRUE,	FALSE,	"NumberOfInks" },
    { TIFFTAG_DOTRANGE,		 2, 2, TIFF_SHORT,	FIELD_DOTRANGE,
      FALSE,	FALSE,	"DotRange" },
    { TIFFTAG_DOTRANGE,		 2, 2, TIFF_BYTE,	FIELD_DOTRANGE,
      FALSE,	FALSE,	"DotRange" },
    { TIFFTAG_TARGETPRINTER,	-1,-1, TIFF_ASCII,	FIELD_TARGETPRINTER,
      TRUE,	FALSE,	"TargetPrinter" },
    { TIFFTAG_EXTRASAMPLES,	-1,-1, TIFF_SHORT,	FIELD_EXTRASAMPLES,
      FALSE,	FALSE,	"ExtraSamples" },
/* XXX for bogus Adobe Photoshop v2.5 files */
    { TIFFTAG_EXTRASAMPLES,	-1,-1, TIFF_BYTE,	FIELD_EXTRASAMPLES,
      FALSE,	FALSE,	"ExtraSamples" },
    { TIFFTAG_SAMPLEFORMAT,	-1,-1, TIFF_SHORT,	FIELD_SAMPLEFORMAT,
      FALSE,	FALSE,	"SampleFormat" },
    { TIFFTAG_SMINSAMPLEVALUE,	-2,-1, TIFF_ANY,	FIELD_SMINSAMPLEVALUE,
      TRUE,	FALSE,	"SMinSampleValue" },
    { TIFFTAG_SMAXSAMPLEVALUE,	-2,-1, TIFF_ANY,	FIELD_SMAXSAMPLEVALUE,
      TRUE,	FALSE,	"SMaxSampleValue" },
    { TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL,	FIELD_YCBCRCOEFFICIENTS,
      FALSE,	FALSE,	"YCbCrCoefficients" },
    { TIFFTAG_YCBCRSUBSAMPLING,	 2, 2, TIFF_SHORT,	FIELD_YCBCRSUBSAMPLING,
      FALSE,	FALSE,	"YCbCrSubsampling" },
    { TIFFTAG_YCBCRPOSITIONING,	 1, 1, TIFF_SHORT,	FIELD_YCBCRPOSITIONING,
      FALSE,	FALSE,	"YCbCrPositioning" },
    { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_RATIONAL,	FIELD_REFBLACKWHITE,
      TRUE,	FALSE,	"ReferenceBlackWhite" },
/* XXX temporarily accept LONG for backwards compatibility */
    { TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_LONG,	FIELD_REFBLACKWHITE,
      TRUE,	FALSE,	"ReferenceBlackWhite" },
    { TIFFTAG_XMLPACKET,	-1,-3, TIFF_UNDEFINED,	FIELD_XMLPACKET,
      FALSE,	TRUE,	"XMLPacket" },
/* begin SGI tags */
    { TIFFTAG_MATTEING,		 1, 1, TIFF_SHORT,	FIELD_EXTRASAMPLES,
      FALSE,	FALSE,	"Matteing" },
    { TIFFTAG_DATATYPE,		-2,-1, TIFF_SHORT,	FIELD_SAMPLEFORMAT,
      FALSE,	FALSE,	"DataType" },
    { TIFFTAG_IMAGEDEPTH,	 1, 1, TIFF_LONG,	FIELD_IMAGEDEPTH,
      FALSE,	FALSE,	"ImageDepth" },
    { TIFFTAG_IMAGEDEPTH,	 1, 1, TIFF_SHORT,	FIELD_IMAGEDEPTH,
      FALSE,	FALSE,	"ImageDepth" },
    { TIFFTAG_TILEDEPTH,	 1, 1, TIFF_LONG,	FIELD_TILEDEPTH,
      FALSE,	FALSE,	"TileDepth" },
    { TIFFTAG_TILEDEPTH,	 1, 1, TIFF_SHORT,	FIELD_TILEDEPTH,
      FALSE,	FALSE,	"TileDepth" },
/* end SGI tags */
/* begin Pixar tags */
    { TIFFTAG_PIXAR_IMAGEFULLWIDTH,  1, 1, TIFF_LONG,	FIELD_IMAGEFULLWIDTH,
      TRUE,	FALSE,	"ImageFullWidth" },
    { TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG,	FIELD_IMAGEFULLLENGTH,
      TRUE,	FALSE,	"ImageFullLength" },
    { TIFFTAG_PIXAR_TEXTUREFORMAT,  -1,-1, TIFF_ASCII,	FIELD_TEXTUREFORMAT,
      TRUE,	FALSE,	"TextureFormat" },
    { TIFFTAG_PIXAR_WRAPMODES,	    -1,-1, TIFF_ASCII,	FIELD_WRAPMODES,
      TRUE,	FALSE,	"TextureWrapModes" },
    { TIFFTAG_PIXAR_FOVCOT,	     1, 1, TIFF_FLOAT,	FIELD_FOVCOT,
      TRUE,	FALSE,	"FieldOfViewCotan" },
    { TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN,	16,16,	TIFF_FLOAT,
      FIELD_MATRIX_WORLDTOSCREEN,	TRUE,	FALSE,	"MatrixWorldToScreen" },
    { TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA,	16,16,	TIFF_FLOAT,
       FIELD_MATRIX_WORLDTOCAMERA,	TRUE,	FALSE,	"MatrixWorldToCamera" },
    { TIFFTAG_COPYRIGHT,	-1,-1, TIFF_ASCII,	FIELD_COPYRIGHT,
      TRUE,	FALSE,	"Copyright" },
/* end Pixar tags */
#ifdef IPTC_SUPPORT
#ifdef PHOTOSHOP_SUPPORT
    { TIFFTAG_RICHTIFFIPTC, -1,-1, TIFF_LONG,   FIELD_RICHTIFFIPTC,
      FALSE,    TRUE,   "RichTIFFIPTC" },
#else
    { TIFFTAG_RICHTIFFIPTC, -1,-3, TIFF_UNDEFINED, FIELD_RICHTIFFIPTC,
      FALSE,    TRUE,   "RichTIFFIPTC" },
#endif
#endif
    { TIFFTAG_PHOTOSHOP,    -1,-3, TIFF_BYTE,   FIELD_PHOTOSHOP,
      FALSE,    TRUE,   "Photoshop" },
    { TIFFTAG_ICCPROFILE,	-1,-3, TIFF_UNDEFINED,	FIELD_ICCPROFILE,
      FALSE,	TRUE,	"ICC Profile" },
    { TIFFTAG_STONITS,		 1, 1, TIFF_DOUBLE,	FIELD_STONITS,
      FALSE,	FALSE,	"StoNits" },
};
#define	N(a)	(sizeof (a) / sizeof (a[0]))

void
_TIFFSetupFieldInfo(TIFF* tif)
{
	if (tif->tif_fieldinfo) {
		int  i;

		for (i = 0; i < tif->tif_nfields; i++)
		{
			TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
			if (fld->field_bit == FIELD_CUSTOM &&
				strncmp("Tag ", fld->field_name, 4) == 0)
				{
				_TIFFfree(fld->field_name);
				_TIFFfree(fld);
				}
		}

		_TIFFfree(tif->tif_fieldinfo);
		tif->tif_nfields = 0;
	}
	_TIFFMergeFieldInfo(tif, tiffFieldInfo, N(tiffFieldInfo));
}

static int
tagCompare(const void* a, const void* b)
{
	const TIFFFieldInfo* ta = *(const TIFFFieldInfo**) a;
	const TIFFFieldInfo* tb = *(const TIFFFieldInfo**) b;
	/* NB: be careful of return values for 16-bit platforms */
	if (ta->field_tag != tb->field_tag)
		return (ta->field_tag < tb->field_tag ? -1 : 1);
	else
		return ((int)tb->field_type - (int)ta->field_type);
}

void
_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
{
	TIFFFieldInfo** tp;
	int i;

	if (tif->tif_nfields > 0) {
		tif->tif_fieldinfo = (TIFFFieldInfo**)
		    _TIFFrealloc(tif->tif_fieldinfo,
			(tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
	} else {
		tif->tif_fieldinfo = (TIFFFieldInfo**)
		    _TIFFmalloc(n * sizeof (TIFFFieldInfo*));
	}
	assert(tif->tif_fieldinfo != NULL);
	tp = &tif->tif_fieldinfo[tif->tif_nfields];
	for (i = 0; i < n; i++)
		tp[i] = (TIFFFieldInfo*) &info[i];	/* XXX */

        /* Sort the field info by tag number */
        qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n),
              sizeof (TIFFFieldInfo*), tagCompare);
}

void
_TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
{
	int i;

	fprintf(fd, "%s: \n", tif->tif_name);
	for (i = 0; i < tif->tif_nfields; i++) {
		const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
		fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
			, i
			, (unsigned long) fip->field_tag
			, fip->field_readcount, fip->field_writecount
			, fip->field_type
			, fip->field_bit
			, fip->field_oktochange ? "TRUE" : "FALSE"
			, fip->field_passcount ? "TRUE" : "FALSE"
			, fip->field_name
		);
	}
}

/*
 * Return size of TIFFDataType in bytes
 */
int
TIFFDataWidth(TIFFDataType type)
{
	switch(type)
	{
	case 0:  /* nothing */
	case 1:  /* TIFF_BYTE */
	case 2:  /* TIFF_ASCII */
	case 6:  /* TIFF_SBYTE */
	case 7:  /* TIFF_UNDEFINED */
		return 1;
	case 3:  /* TIFF_SHORT */
	case 8:  /* TIFF_SSHORT */
		return 2;
	case 4:  /* TIFF_LONG */
	case 9:  /* TIFF_SLONG */
	case 11: /* TIFF_FLOAT */
        case 13: /* TIFF_IFD */
		return 4;
	case 5:  /* TIFF_RATIONAL */
	case 10: /* TIFF_SRATIONAL */
	case 12: /* TIFF_DOUBLE */
		return 8;
	default:
		return 0; /* will return 0 for unknown types */
	}
}

/*
 * Return nearest TIFFDataType to the sample type of an image.
 */
TIFFDataType
_TIFFSampleToTagType(TIFF* tif)
{
	uint32 bps = TIFFhowmany8(tif->tif_dir.td_bitspersample);

	switch (tif->tif_dir.td_sampleformat) {
	case SAMPLEFORMAT_IEEEFP:
		return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
	case SAMPLEFORMAT_INT:
		return (bps <= 1 ? TIFF_SBYTE :
		    bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
	case SAMPLEFORMAT_UINT:
		return (bps <= 1 ? TIFF_BYTE :
		    bps <= 2 ? TIFF_SHORT : TIFF_LONG);
	case SAMPLEFORMAT_VOID:
		return (TIFF_UNDEFINED);
	}
	/*NOTREACHED*/
	return (TIFF_UNDEFINED);
}

const TIFFFieldInfo*
_TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
{
	static const TIFFFieldInfo *last = NULL;
	int i, n;

	if (last && last->field_tag == tag &&
	    (dt == TIFF_ANY || dt == last->field_type))
		return (last);
	/* NB: if table gets big, use sorted search (e.g. binary search) */
	if(dt != TIFF_ANY) {
            TIFFFieldInfo key = {0, 0, 0, 0, 0, 0, 0, 0};
            key.field_tag = tag;
            key.field_type = dt;
            return((const TIFFFieldInfo *) bsearch(&key,
						   tif->tif_fieldinfo,
						   tif->tif_nfields,
						   sizeof(TIFFFieldInfo),
						   tagCompare));
        } else for (i = 0, n = tif->tif_nfields; i < n; i++) {
		const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
		if (fip->field_tag == tag &&
		    (dt == TIFF_ANY || fip->field_type == dt))
			return (last = fip);
	}
	return ((const TIFFFieldInfo *)0);
}

const TIFFFieldInfo*
_TIFFFieldWithTag(TIFF* tif, ttag_t tag)
{
	const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
	if (!fip) {
		TIFFError("TIFFFieldWithTag",
		    "Internal error, unknown tag 0x%x", (u_int) tag);
		assert(fip != NULL);
		/*NOTREACHED*/
	}
	return (fip);
}

const TIFFFieldInfo*
_TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt )

{
    const TIFFFieldInfo *fld;

    fld = _TIFFFindFieldInfo( tif, tag, dt );
    if( fld == NULL )
    {
        fld = _TIFFCreateAnonFieldInfo( tif, tag, dt );
        _TIFFMergeFieldInfo( tif, fld, 1 );
    }

    return fld;
}

TIFFFieldInfo*
_TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
{
    TIFFFieldInfo *fld;

    fld = (TIFFFieldInfo *) _TIFFmalloc(sizeof (TIFFFieldInfo));
    if (fld == NULL)
	return NULL;
    _TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) );

    fld->field_tag = tag;
    fld->field_readcount = TIFF_VARIABLE;
    fld->field_writecount = TIFF_VARIABLE;
    fld->field_type = field_type;
    fld->field_bit = FIELD_CUSTOM;
    fld->field_oktochange = TRUE;
    fld->field_passcount = TRUE;
    fld->field_name = (char *) _TIFFmalloc(32);
    if (fld->field_name == NULL) {
	_TIFFfree(fld);
	return NULL;
    }

    /* note that this name is a special sign to TIFFClose() and
     * _TIFFSetupFieldInfo() to free the field
     */
    sprintf(fld->field_name, "Tag %d", (int) tag);

    return fld;
}
Commit	Line	Data
	1	/* $Header$ */
	2
	3	/*
	4	* Copyright (c) 1988-1997 Sam Leffler
	5	* Copyright (c) 1991-1997 Silicon Graphics, Inc.
	6	*
	7	* Permission to use, copy, modify, distribute, and sell this software and
	8	* its documentation for any purpose is hereby granted without fee, provided
	9	* that (i) the above copyright notices and this permission notice appear in
	10	* all copies of the software and related documentation, and (ii) the names of
	11	* Sam Leffler and Silicon Graphics may not be used in any advertising or
	12	* publicity relating to the software without the specific, prior written
	13	* permission of Sam Leffler and Silicon Graphics.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
	16	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
	17	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
	18	*
	19	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
	20	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
	21	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	22	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
	23	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	24	* OF THIS SOFTWARE.
	25	*/
	26
	27	/*
	28	* TIFF Library.
	29	*
	30	* Core Directory Tag Support.
	31	*/
	32	#include "tiffiop.h"
	33	#include <stdlib.h>
	34	#include <assert.h>
	35	#include <stdio.h>
	36
	37	/*
	38	* NB: NB: THIS ARRAY IS ASSUMED TO BE SORTED BY TAG.
	39	* If a tag can have both LONG and SHORT types
	40	* then the LONG must be placed before the SHORT for
	41	* writing to work properly.
	42	*
	43	* NOTE: The second field (field_readcount) and third field (field_writecount)
	44	* sometimes use the values TIFF_VARIABLE (-1), TIFF_VARIABLE2 (-3)
	45	* and TIFFTAG_SPP (-2). The macros should be used but would throw off
	46	* the formatting of the code, so please interprete the -1, -2 and -3
	47	* values accordingly.
	48	*/
	49	#ifndef VMS
	50	static
	51	#endif
	52	const TIFFFieldInfo tiffFieldInfo[] = {
	53	{ TIFFTAG_SUBFILETYPE, 1, 1, TIFF_LONG, FIELD_SUBFILETYPE,
	54	TRUE, FALSE, "SubfileType" },
	55	/* XXX SHORT for compatibility w/ old versions of the library */
	56	{ TIFFTAG_SUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE,
	57	TRUE, FALSE, "SubfileType" },
	58	{ TIFFTAG_OSUBFILETYPE, 1, 1, TIFF_SHORT, FIELD_SUBFILETYPE,
	59	TRUE, FALSE, "OldSubfileType" },
	60	{ TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS,
	61	FALSE, FALSE, "ImageWidth" },
	62	{ TIFFTAG_IMAGEWIDTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
	63	FALSE, FALSE, "ImageWidth" },
	64	{ TIFFTAG_IMAGELENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEDIMENSIONS,
	65	TRUE, FALSE, "ImageLength" },
	66	{ TIFFTAG_IMAGELENGTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDIMENSIONS,
	67	TRUE, FALSE, "ImageLength" },
	68	/* XXX LONG for compatibility with some broken TIFF writers */
	69	{ TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_LONG, FIELD_BITSPERSAMPLE,
	70	FALSE, FALSE, "BitsPerSample" },
	71	{ TIFFTAG_BITSPERSAMPLE, -1,-1, TIFF_SHORT, FIELD_BITSPERSAMPLE,
	72	FALSE, FALSE, "BitsPerSample" },
	73	/* XXX LONG for compatibility with some broken TIFF writers */
	74	{ TIFFTAG_COMPRESSION, -1, 1, TIFF_LONG, FIELD_COMPRESSION,
	75	FALSE, FALSE, "Compression" },
	76	{ TIFFTAG_COMPRESSION, -1, 1, TIFF_SHORT, FIELD_COMPRESSION,
	77	FALSE, FALSE, "Compression" },
	78	/* XXX LONG for compatibility with some broken TIFF writers */
	79	{ TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_LONG, FIELD_PHOTOMETRIC,
	80	FALSE, FALSE, "PhotometricInterpretation" },
	81	{ TIFFTAG_PHOTOMETRIC, 1, 1, TIFF_SHORT, FIELD_PHOTOMETRIC,
	82	FALSE, FALSE, "PhotometricInterpretation" },
	83	{ TIFFTAG_THRESHHOLDING, 1, 1, TIFF_SHORT, FIELD_THRESHHOLDING,
	84	TRUE, FALSE, "Threshholding" },
	85	{ TIFFTAG_CELLWIDTH, 1, 1, TIFF_SHORT, FIELD_IGNORE,
	86	TRUE, FALSE, "CellWidth" },
	87	{ TIFFTAG_CELLLENGTH, 1, 1, TIFF_SHORT, FIELD_IGNORE,
	88	TRUE, FALSE, "CellLength" },
	89	{ TIFFTAG_FILLORDER, 1, 1, TIFF_SHORT, FIELD_FILLORDER,
	90	FALSE, FALSE, "FillOrder" },
	91	{ TIFFTAG_DOCUMENTNAME, -1,-1, TIFF_ASCII, FIELD_DOCUMENTNAME,
	92	TRUE, FALSE, "DocumentName" },
	93	{ TIFFTAG_IMAGEDESCRIPTION, -1,-1, TIFF_ASCII, FIELD_IMAGEDESCRIPTION,
	94	TRUE, FALSE, "ImageDescription" },
	95	{ TIFFTAG_MAKE, -1,-1, TIFF_ASCII, FIELD_MAKE,
	96	TRUE, FALSE, "Make" },
	97	{ TIFFTAG_MODEL, -1,-1, TIFF_ASCII, FIELD_MODEL,
	98	TRUE, FALSE, "Model" },
	99	{ TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_LONG, FIELD_STRIPOFFSETS,
	100	FALSE, FALSE, "StripOffsets" },
	101	{ TIFFTAG_STRIPOFFSETS, -1,-1, TIFF_SHORT, FIELD_STRIPOFFSETS,
	102	FALSE, FALSE, "StripOffsets" },
	103	{ TIFFTAG_ORIENTATION, 1, 1, TIFF_SHORT, FIELD_ORIENTATION,
	104	FALSE, FALSE, "Orientation" },
	105	{ TIFFTAG_SAMPLESPERPIXEL, 1, 1, TIFF_SHORT, FIELD_SAMPLESPERPIXEL,
	106	FALSE, FALSE, "SamplesPerPixel" },
	107	{ TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_LONG, FIELD_ROWSPERSTRIP,
	108	FALSE, FALSE, "RowsPerStrip" },
	109	{ TIFFTAG_ROWSPERSTRIP, 1, 1, TIFF_SHORT, FIELD_ROWSPERSTRIP,
	110	FALSE, FALSE, "RowsPerStrip" },
	111	{ TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_STRIPBYTECOUNTS,
	112	FALSE, FALSE, "StripByteCounts" },
	113	{ TIFFTAG_STRIPBYTECOUNTS, -1,-1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
	114	FALSE, FALSE, "StripByteCounts" },
	115	{ TIFFTAG_MINSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MINSAMPLEVALUE,
	116	TRUE, FALSE, "MinSampleValue" },
	117	{ TIFFTAG_MAXSAMPLEVALUE, -2,-1, TIFF_SHORT, FIELD_MAXSAMPLEVALUE,
	118	TRUE, FALSE, "MaxSampleValue" },
	119	{ TIFFTAG_XRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION,
	120	FALSE, FALSE, "XResolution" },
	121	{ TIFFTAG_YRESOLUTION, 1, 1, TIFF_RATIONAL, FIELD_RESOLUTION,
	122	FALSE, FALSE, "YResolution" },
	123	{ TIFFTAG_PLANARCONFIG, 1, 1, TIFF_SHORT, FIELD_PLANARCONFIG,
	124	FALSE, FALSE, "PlanarConfiguration" },
	125	{ TIFFTAG_PAGENAME, -1,-1, TIFF_ASCII, FIELD_PAGENAME,
	126	TRUE, FALSE, "PageName" },
	127	{ TIFFTAG_XPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION,
	128	TRUE, FALSE, "XPosition" },
	129	{ TIFFTAG_YPOSITION, 1, 1, TIFF_RATIONAL, FIELD_POSITION,
	130	TRUE, FALSE, "YPosition" },
	131	{ TIFFTAG_FREEOFFSETS, -1,-1, TIFF_LONG, FIELD_IGNORE,
	132	FALSE, FALSE, "FreeOffsets" },
	133	{ TIFFTAG_FREEBYTECOUNTS, -1,-1, TIFF_LONG, FIELD_IGNORE,
	134	FALSE, FALSE, "FreeByteCounts" },
	135	{ TIFFTAG_GRAYRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE,
	136	TRUE, FALSE, "GrayResponseUnit" },
	137	{ TIFFTAG_GRAYRESPONSECURVE,-1,-1, TIFF_SHORT, FIELD_IGNORE,
	138	TRUE, FALSE, "GrayResponseCurve" },
	139	{ TIFFTAG_RESOLUTIONUNIT, 1, 1, TIFF_SHORT, FIELD_RESOLUTIONUNIT,
	140	FALSE, FALSE, "ResolutionUnit" },
	141	{ TIFFTAG_PAGENUMBER, 2, 2, TIFF_SHORT, FIELD_PAGENUMBER,
	142	TRUE, FALSE, "PageNumber" },
	143	{ TIFFTAG_COLORRESPONSEUNIT, 1, 1, TIFF_SHORT, FIELD_IGNORE,
	144	TRUE, FALSE, "ColorResponseUnit" },
	145	{ TIFFTAG_TRANSFERFUNCTION, -1,-1, TIFF_SHORT, FIELD_TRANSFERFUNCTION,
	146	TRUE, FALSE, "TransferFunction" },
	147	{ TIFFTAG_SOFTWARE, -1,-1, TIFF_ASCII, FIELD_CUSTOM,
	148	TRUE, FALSE, "Software" },
	149	{ TIFFTAG_DATETIME, 20,20, TIFF_ASCII, FIELD_DATETIME,
	150	TRUE, FALSE, "DateTime" },
	151	{ TIFFTAG_ARTIST, -1,-1, TIFF_ASCII, FIELD_ARTIST,
	152	TRUE, FALSE, "Artist" },
	153	{ TIFFTAG_HOSTCOMPUTER, -1,-1, TIFF_ASCII, FIELD_HOSTCOMPUTER,
	154	TRUE, FALSE, "HostComputer" },
	155	{ TIFFTAG_WHITEPOINT, 2, 2, TIFF_RATIONAL,FIELD_WHITEPOINT,
	156	TRUE, FALSE, "WhitePoint" },
	157	{ TIFFTAG_PRIMARYCHROMATICITIES,6,6,TIFF_RATIONAL,FIELD_PRIMARYCHROMAS,
	158	TRUE, FALSE, "PrimaryChromaticities" },
	159	{ TIFFTAG_COLORMAP, -1,-1, TIFF_SHORT, FIELD_COLORMAP,
	160	TRUE, FALSE, "ColorMap" },
	161	{ TIFFTAG_HALFTONEHINTS, 2, 2, TIFF_SHORT, FIELD_HALFTONEHINTS,
	162	TRUE, FALSE, "HalftoneHints" },
	163	{ TIFFTAG_TILEWIDTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS,
	164	FALSE, FALSE, "TileWidth" },
	165	{ TIFFTAG_TILEWIDTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS,
	166	FALSE, FALSE, "TileWidth" },
	167	{ TIFFTAG_TILELENGTH, 1, 1, TIFF_LONG, FIELD_TILEDIMENSIONS,
	168	FALSE, FALSE, "TileLength" },
	169	{ TIFFTAG_TILELENGTH, 1, 1, TIFF_SHORT, FIELD_TILEDIMENSIONS,
	170	FALSE, FALSE, "TileLength" },
	171	{ TIFFTAG_TILEOFFSETS, -1, 1, TIFF_LONG, FIELD_STRIPOFFSETS,
	172	FALSE, FALSE, "TileOffsets" },
	173	{ TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_LONG, FIELD_STRIPBYTECOUNTS,
	174	FALSE, FALSE, "TileByteCounts" },
	175	{ TIFFTAG_TILEBYTECOUNTS, -1, 1, TIFF_SHORT, FIELD_STRIPBYTECOUNTS,
	176	FALSE, FALSE, "TileByteCounts" },
	177	{ TIFFTAG_SUBIFD, -1,-1, TIFF_LONG, FIELD_SUBIFD,
	178	TRUE, TRUE, "SubIFD" },
	179	{ TIFFTAG_INKSET, 1, 1, TIFF_SHORT, FIELD_INKSET,
	180	FALSE, FALSE, "InkSet" },
	181	{ TIFFTAG_INKNAMES, -1,-1, TIFF_ASCII, FIELD_INKNAMES,
	182	TRUE, TRUE, "InkNames" },
	183	{ TIFFTAG_NUMBEROFINKS, 1, 1, TIFF_SHORT, FIELD_NUMBEROFINKS,
	184	TRUE, FALSE, "NumberOfInks" },
	185	{ TIFFTAG_DOTRANGE, 2, 2, TIFF_SHORT, FIELD_DOTRANGE,
	186	FALSE, FALSE, "DotRange" },
	187	{ TIFFTAG_DOTRANGE, 2, 2, TIFF_BYTE, FIELD_DOTRANGE,
	188	FALSE, FALSE, "DotRange" },
	189	{ TIFFTAG_TARGETPRINTER, -1,-1, TIFF_ASCII, FIELD_TARGETPRINTER,
	190	TRUE, FALSE, "TargetPrinter" },
	191	{ TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_SHORT, FIELD_EXTRASAMPLES,
	192	FALSE, FALSE, "ExtraSamples" },
	193	/* XXX for bogus Adobe Photoshop v2.5 files */
	194	{ TIFFTAG_EXTRASAMPLES, -1,-1, TIFF_BYTE, FIELD_EXTRASAMPLES,
	195	FALSE, FALSE, "ExtraSamples" },
	196	{ TIFFTAG_SAMPLEFORMAT, -1,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT,
	197	FALSE, FALSE, "SampleFormat" },
	198	{ TIFFTAG_SMINSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMINSAMPLEVALUE,
	199	TRUE, FALSE, "SMinSampleValue" },
	200	{ TIFFTAG_SMAXSAMPLEVALUE, -2,-1, TIFF_ANY, FIELD_SMAXSAMPLEVALUE,
	201	TRUE, FALSE, "SMaxSampleValue" },
	202	{ TIFFTAG_YCBCRCOEFFICIENTS, 3, 3, TIFF_RATIONAL, FIELD_YCBCRCOEFFICIENTS,
	203	FALSE, FALSE, "YCbCrCoefficients" },
	204	{ TIFFTAG_YCBCRSUBSAMPLING, 2, 2, TIFF_SHORT, FIELD_YCBCRSUBSAMPLING,
	205	FALSE, FALSE, "YCbCrSubsampling" },
	206	{ TIFFTAG_YCBCRPOSITIONING, 1, 1, TIFF_SHORT, FIELD_YCBCRPOSITIONING,
	207	FALSE, FALSE, "YCbCrPositioning" },
	208	{ TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_RATIONAL, FIELD_REFBLACKWHITE,
	209	TRUE, FALSE, "ReferenceBlackWhite" },
	210	/* XXX temporarily accept LONG for backwards compatibility */
	211	{ TIFFTAG_REFERENCEBLACKWHITE,6,6,TIFF_LONG, FIELD_REFBLACKWHITE,
	212	TRUE, FALSE, "ReferenceBlackWhite" },
	213	{ TIFFTAG_XMLPACKET, -1,-3, TIFF_UNDEFINED, FIELD_XMLPACKET,
	214	FALSE, TRUE, "XMLPacket" },
	215	/* begin SGI tags */
	216	{ TIFFTAG_MATTEING, 1, 1, TIFF_SHORT, FIELD_EXTRASAMPLES,
	217	FALSE, FALSE, "Matteing" },
	218	{ TIFFTAG_DATATYPE, -2,-1, TIFF_SHORT, FIELD_SAMPLEFORMAT,
	219	FALSE, FALSE, "DataType" },
	220	{ TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_LONG, FIELD_IMAGEDEPTH,
	221	FALSE, FALSE, "ImageDepth" },
	222	{ TIFFTAG_IMAGEDEPTH, 1, 1, TIFF_SHORT, FIELD_IMAGEDEPTH,
	223	FALSE, FALSE, "ImageDepth" },
	224	{ TIFFTAG_TILEDEPTH, 1, 1, TIFF_LONG, FIELD_TILEDEPTH,
	225	FALSE, FALSE, "TileDepth" },
	226	{ TIFFTAG_TILEDEPTH, 1, 1, TIFF_SHORT, FIELD_TILEDEPTH,
	227	FALSE, FALSE, "TileDepth" },
	228	/* end SGI tags */
	229	/* begin Pixar tags */
	230	{ TIFFTAG_PIXAR_IMAGEFULLWIDTH, 1, 1, TIFF_LONG, FIELD_IMAGEFULLWIDTH,
	231	TRUE, FALSE, "ImageFullWidth" },
	232	{ TIFFTAG_PIXAR_IMAGEFULLLENGTH, 1, 1, TIFF_LONG, FIELD_IMAGEFULLLENGTH,
	233	TRUE, FALSE, "ImageFullLength" },
	234	{ TIFFTAG_PIXAR_TEXTUREFORMAT, -1,-1, TIFF_ASCII, FIELD_TEXTUREFORMAT,
	235	TRUE, FALSE, "TextureFormat" },
	236	{ TIFFTAG_PIXAR_WRAPMODES, -1,-1, TIFF_ASCII, FIELD_WRAPMODES,
	237	TRUE, FALSE, "TextureWrapModes" },
	238	{ TIFFTAG_PIXAR_FOVCOT, 1, 1, TIFF_FLOAT, FIELD_FOVCOT,
	239	TRUE, FALSE, "FieldOfViewCotan" },
	240	{ TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN, 16,16, TIFF_FLOAT,
	241	FIELD_MATRIX_WORLDTOSCREEN, TRUE, FALSE, "MatrixWorldToScreen" },
	242	{ TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA, 16,16, TIFF_FLOAT,
	243	FIELD_MATRIX_WORLDTOCAMERA, TRUE, FALSE, "MatrixWorldToCamera" },
	244	{ TIFFTAG_COPYRIGHT, -1,-1, TIFF_ASCII, FIELD_COPYRIGHT,
	245	TRUE, FALSE, "Copyright" },
	246	/* end Pixar tags */
	247	#ifdef IPTC_SUPPORT
	248	#ifdef PHOTOSHOP_SUPPORT
	249	{ TIFFTAG_RICHTIFFIPTC, -1,-1, TIFF_LONG, FIELD_RICHTIFFIPTC,
	250	FALSE, TRUE, "RichTIFFIPTC" },
	251	#else
	252	{ TIFFTAG_RICHTIFFIPTC, -1,-3, TIFF_UNDEFINED, FIELD_RICHTIFFIPTC,
	253	FALSE, TRUE, "RichTIFFIPTC" },
	254	#endif
	255	#endif
	256	{ TIFFTAG_PHOTOSHOP, -1,-3, TIFF_BYTE, FIELD_PHOTOSHOP,
	257	FALSE, TRUE, "Photoshop" },
	258	{ TIFFTAG_ICCPROFILE, -1,-3, TIFF_UNDEFINED, FIELD_ICCPROFILE,
	259	FALSE, TRUE, "ICC Profile" },
	260	{ TIFFTAG_STONITS, 1, 1, TIFF_DOUBLE, FIELD_STONITS,
	261	FALSE, FALSE, "StoNits" },
	262	};
	263	#define N(a) (sizeof (a) / sizeof (a[0]))
	264
	265	void
	266	_TIFFSetupFieldInfo(TIFF* tif)
	267	{
	268	if (tif->tif_fieldinfo) {
	269	int i;
	270
	271	for (i = 0; i < tif->tif_nfields; i++)
	272	{
	273	TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
	274	if (fld->field_bit == FIELD_CUSTOM &&
	275	strncmp("Tag ", fld->field_name, 4) == 0)
	276	{
	277	_TIFFfree(fld->field_name);
	278	_TIFFfree(fld);
	279	}
	280	}
	281
	282	_TIFFfree(tif->tif_fieldinfo);
	283	tif->tif_nfields = 0;
	284	}
	285	_TIFFMergeFieldInfo(tif, tiffFieldInfo, N(tiffFieldInfo));
	286	}
	287
	288	static int
	289	tagCompare(const void* a, const void* b)
	290	{
	291	const TIFFFieldInfo* ta = (const TIFFFieldInfo*) a;
	292	const TIFFFieldInfo* tb = (const TIFFFieldInfo*) b;
	293	/* NB: be careful of return values for 16-bit platforms */
	294	if (ta->field_tag != tb->field_tag)
	295	return (ta->field_tag < tb->field_tag ? -1 : 1);
	296	else
	297	return ((int)tb->field_type - (int)ta->field_type);
	298	}
	299
	300	void
	301	_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
	302	{
	303	TIFFFieldInfo** tp;
	304	int i;
	305
	306	if (tif->tif_nfields > 0) {
	307	tif->tif_fieldinfo = (TIFFFieldInfo**)
	308	_TIFFrealloc(tif->tif_fieldinfo,
	309	(tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
	310	} else {
	311	tif->tif_fieldinfo = (TIFFFieldInfo**)
	312	_TIFFmalloc(n * sizeof (TIFFFieldInfo*));
	313	}
	314	assert(tif->tif_fieldinfo != NULL);
	315	tp = &tif->tif_fieldinfo[tif->tif_nfields];
	316	for (i = 0; i < n; i++)
	317	tp[i] = (TIFFFieldInfo) &info[i]; / XXX */
	318
	319	/* Sort the field info by tag number */
	320	qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n),
	321	sizeof (TIFFFieldInfo*), tagCompare);
	322	}
	323
	324	void
	325	_TIFFPrintFieldInfo(TIFF* tif, FILE* fd)
	326	{
	327	int i;
	328
	329	fprintf(fd, "%s: \n", tif->tif_name);
	330	for (i = 0; i < tif->tif_nfields; i++) {
	331	const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
	332	fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n"
	333	, i
	334	, (unsigned long) fip->field_tag
	335	, fip->field_readcount, fip->field_writecount
	336	, fip->field_type
	337	, fip->field_bit
	338	, fip->field_oktochange ? "TRUE" : "FALSE"
	339	, fip->field_passcount ? "TRUE" : "FALSE"
	340	, fip->field_name
	341	);
	342	}
	343	}
	344
	345	/*
	346	* Return size of TIFFDataType in bytes
	347	*/
	348	int
	349	TIFFDataWidth(TIFFDataType type)
	350	{
	351	switch(type)
	352	{
	353	case 0: /* nothing */
	354	case 1: /* TIFF_BYTE */
	355	case 2: /* TIFF_ASCII */
	356	case 6: /* TIFF_SBYTE */
	357	case 7: /* TIFF_UNDEFINED */
	358	return 1;
	359	case 3: /* TIFF_SHORT */
	360	case 8: /* TIFF_SSHORT */
	361	return 2;
	362	case 4: /* TIFF_LONG */
	363	case 9: /* TIFF_SLONG */
	364	case 11: /* TIFF_FLOAT */
	365	case 13: /* TIFF_IFD */
	366	return 4;
	367	case 5: /* TIFF_RATIONAL */
	368	case 10: /* TIFF_SRATIONAL */
	369	case 12: /* TIFF_DOUBLE */
	370	return 8;
	371	default:
	372	return 0; /* will return 0 for unknown types */
	373	}
	374	}
	375
	376	/*
	377	* Return nearest TIFFDataType to the sample type of an image.
	378	*/
	379	TIFFDataType
	380	_TIFFSampleToTagType(TIFF* tif)
	381	{
	382	uint32 bps = TIFFhowmany8(tif->tif_dir.td_bitspersample);
	383
	384	switch (tif->tif_dir.td_sampleformat) {
	385	case SAMPLEFORMAT_IEEEFP:
	386	return (bps == 4 ? TIFF_FLOAT : TIFF_DOUBLE);
	387	case SAMPLEFORMAT_INT:
	388	return (bps <= 1 ? TIFF_SBYTE :
	389	bps <= 2 ? TIFF_SSHORT : TIFF_SLONG);
	390	case SAMPLEFORMAT_UINT:
	391	return (bps <= 1 ? TIFF_BYTE :
	392	bps <= 2 ? TIFF_SHORT : TIFF_LONG);
	393	case SAMPLEFORMAT_VOID:
	394	return (TIFF_UNDEFINED);
	395	}
	396	/NOTREACHED/
	397	return (TIFF_UNDEFINED);
	398	}
	399
	400	const TIFFFieldInfo*
	401	_TIFFFindFieldInfo(TIFF* tif, ttag_t tag, TIFFDataType dt)
	402	{
	403	static const TIFFFieldInfo *last = NULL;
	404	int i, n;
	405
	406	if (last && last->field_tag == tag &&
	407	(dt == TIFF_ANY \|\| dt == last->field_type))
	408	return (last);
	409	/* NB: if table gets big, use sorted search (e.g. binary search) */
	410	if(dt != TIFF_ANY) {
	411	TIFFFieldInfo key = {0, 0, 0, 0, 0, 0, 0, 0};
	412	key.field_tag = tag;
	413	key.field_type = dt;
	414	return((const TIFFFieldInfo *) bsearch(&key,
	415	tif->tif_fieldinfo,
	416	tif->tif_nfields,
	417	sizeof(TIFFFieldInfo),
	418	tagCompare));
	419	} else for (i = 0, n = tif->tif_nfields; i < n; i++) {
	420	const TIFFFieldInfo* fip = tif->tif_fieldinfo[i];
	421	if (fip->field_tag == tag &&
	422	(dt == TIFF_ANY \|\| fip->field_type == dt))
	423	return (last = fip);
	424	}
	425	return ((const TIFFFieldInfo *)0);
	426	}
	427
	428	const TIFFFieldInfo*
	429	_TIFFFieldWithTag(TIFF* tif, ttag_t tag)
	430	{
	431	const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
	432	if (!fip) {
	433	TIFFError("TIFFFieldWithTag",
	434	"Internal error, unknown tag 0x%x", (u_int) tag);
	435	assert(fip != NULL);
	436	/NOTREACHED/
	437	}
	438	return (fip);
	439	}
	440
	441	const TIFFFieldInfo*
	442	_TIFFFindOrRegisterFieldInfo( TIFF *tif, ttag_t tag, TIFFDataType dt )
	443
	444	{
	445	const TIFFFieldInfo *fld;
	446
	447	fld = _TIFFFindFieldInfo( tif, tag, dt );
	448	if( fld == NULL )
	449	{
	450	fld = _TIFFCreateAnonFieldInfo( tif, tag, dt );
	451	_TIFFMergeFieldInfo( tif, fld, 1 );
	452	}
	453
	454	return fld;
	455	}
	456
	457	TIFFFieldInfo*
	458	_TIFFCreateAnonFieldInfo(TIFF *tif, ttag_t tag, TIFFDataType field_type)
	459	{
	460	TIFFFieldInfo *fld;
	461
	462	fld = (TIFFFieldInfo *) _TIFFmalloc(sizeof (TIFFFieldInfo));
	463	if (fld == NULL)
	464	return NULL;
	465	_TIFFmemset( fld, 0, sizeof(TIFFFieldInfo) );
	466
	467	fld->field_tag = tag;
	468	fld->field_readcount = TIFF_VARIABLE;
	469	fld->field_writecount = TIFF_VARIABLE;
	470	fld->field_type = field_type;
	471	fld->field_bit = FIELD_CUSTOM;
	472	fld->field_oktochange = TRUE;
	473	fld->field_passcount = TRUE;
	474	fld->field_name = (char *) _TIFFmalloc(32);
	475	if (fld->field_name == NULL) {
	476	_TIFFfree(fld);
	477	return NULL;
	478	}
	479
	480	/* note that this name is a special sign to TIFFClose() and
	481	* _TIFFSetupFieldInfo() to free the field
	482	*/
	483	sprintf(fld->field_name, "Tag %d", (int) tag);
	484
	485	return fld;
	486	}