summaryrefslogtreecommitdiff
path: root/tiff/libtiff/tif_dirread.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2015-05-02 10:09:28 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2015-05-02 10:09:28 +0200
commitda4a717ddcd6ba5b5b0819aabbe49fcd5f77ae4d (patch)
tree86a75831be5de12584225fdd94bec47a73a455a8 /tiff/libtiff/tif_dirread.c
parent63128e407a6ee7afd31e013dc55d5dcbfab0f6a9 (diff)
remove unused sources
Diffstat (limited to 'tiff/libtiff/tif_dirread.c')
-rw-r--r--tiff/libtiff/tif_dirread.c2081
1 files changed, 0 insertions, 2081 deletions
diff --git a/tiff/libtiff/tif_dirread.c b/tiff/libtiff/tif_dirread.c
deleted file mode 100644
index 907b531..0000000
--- a/tiff/libtiff/tif_dirread.c
+++ /dev/null
@@ -1,2081 +0,0 @@
-/* $Id: tif_dirread.c,v 1.92.2.9 2010-06-14 00:21:46 fwarmerdam Exp $ */
-
-/*
- * 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.
- *
- * Directory Read Support Routines.
- */
-#include "tiffiop.h"
-
-#define IGNORE 0 /* tag placeholder used below */
-
-#ifdef HAVE_IEEEFP
-# define TIFFCvtIEEEFloatToNative(tif, n, fp)
-# define TIFFCvtIEEEDoubleToNative(tif, n, dp)
-#else
-extern void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*);
-extern void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*);
-#endif
-
-static TIFFDirEntry* TIFFReadDirectoryFind(TIFFDirEntry* dir,
- uint16 dircount, uint16 tagid);
-static int EstimateStripByteCounts(TIFF*, TIFFDirEntry*, uint16);
-static void MissingRequired(TIFF*, const char*);
-static int TIFFCheckDirOffset(TIFF*, toff_t);
-static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32);
-static uint16 TIFFFetchDirectory(TIFF*, toff_t, TIFFDirEntry**, toff_t *);
-static tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*);
-static tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*);
-static float TIFFFetchRational(TIFF*, TIFFDirEntry*);
-static int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*);
-static int TIFFFetchPerSampleShorts(TIFF*, TIFFDirEntry*, uint16*);
-static int TIFFFetchPerSampleLongs(TIFF*, TIFFDirEntry*, uint32*);
-static int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*);
-static int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*);
-static int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**);
-static int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*);
-static int TIFFFetchSubjectDistance(TIFF*, TIFFDirEntry*);
-static float TIFFFetchFloat(TIFF*, TIFFDirEntry*);
-static int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*);
-static int TIFFFetchDoubleArray(TIFF*, TIFFDirEntry*, double*);
-static int TIFFFetchAnyArray(TIFF*, TIFFDirEntry*, double*);
-static int TIFFFetchShortPair(TIFF*, TIFFDirEntry*);
-static void ChopUpSingleUncompressedStrip(TIFF*);
-
-/*
- * Read the next TIFF directory from a file and convert it to the internal
- * format. We read directories sequentially.
- */
-int
-TIFFReadDirectory(TIFF* tif)
-{
- static const char module[] = "TIFFReadDirectory";
-
- int n;
- TIFFDirectory* td;
- TIFFDirEntry *dp, *dir = NULL;
- uint16 iv;
- uint32 v;
- const TIFFFieldInfo* fip;
- size_t fix;
- uint16 dircount;
- int diroutoforderwarning = 0, compressionknown = 0;
- int haveunknowntags = 0;
-
- tif->tif_diroff = tif->tif_nextdiroff;
- /*
- * Check whether we have the last offset or bad offset (IFD looping).
- */
- if (!TIFFCheckDirOffset(tif, tif->tif_nextdiroff))
- return 0;
- /*
- * Cleanup any previous compression state.
- */
- (*tif->tif_cleanup)(tif);
- tif->tif_curdir++;
- dircount = TIFFFetchDirectory(tif, tif->tif_nextdiroff,
- &dir, &tif->tif_nextdiroff);
- if (!dircount) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Failed to read directory at offset %u",
- tif->tif_name, tif->tif_nextdiroff);
- return 0;
- }
-
- tif->tif_flags &= ~TIFF_BEENWRITING; /* reset before new dir */
- /*
- * Setup default value and then make a pass over
- * the fields to check type and tag information,
- * and to extract info required to size data
- * structures. A second pass is made afterwards
- * to read in everthing not taken in the first pass.
- */
- td = &tif->tif_dir;
- /* free any old stuff and reinit */
- TIFFFreeDirectory(tif);
- TIFFDefaultDirectory(tif);
- /*
- * Electronic Arts writes gray-scale TIFF files
- * without a PlanarConfiguration directory entry.
- * Thus we setup a default value here, even though
- * the TIFF spec says there is no default value.
- */
- TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
-
- /*
- * Sigh, we must make a separate pass through the
- * directory for the following reason:
- *
- * We must process the Compression tag in the first pass
- * in order to merge in codec-private tag definitions (otherwise
- * we may get complaints about unknown tags). However, the
- * Compression tag may be dependent on the SamplesPerPixel
- * tag value because older TIFF specs permited Compression
- * to be written as a SamplesPerPixel-count tag entry.
- * Thus if we don't first figure out the correct SamplesPerPixel
- * tag value then we may end up ignoring the Compression tag
- * value because it has an incorrect count value (if the
- * true value of SamplesPerPixel is not 1).
- *
- * It sure would have been nice if Aldus had really thought
- * this stuff through carefully.
- */
- for (dp = dir, n = dircount; n > 0; n--, dp++) {
- if (tif->tif_flags & TIFF_SWAB) {
- TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
- TIFFSwabArrayOfLong(&dp->tdir_count, 2);
- }
- if (dp->tdir_tag == TIFFTAG_SAMPLESPERPIXEL) {
- if (!TIFFFetchNormalTag(tif, dp))
- goto bad;
- dp->tdir_tag = IGNORE;
- }
- }
- /*
- * First real pass over the directory.
- */
- fix = 0;
- for (dp = dir, n = dircount; n > 0; n--, dp++) {
-
- if (dp->tdir_tag == IGNORE)
- continue;
- if (fix >= tif->tif_nfields)
- fix = 0;
-
- /*
- * Silicon Beach (at least) writes unordered
- * directory tags (violating the spec). Handle
- * it here, but be obnoxious (maybe they'll fix it?).
- */
- if (dp->tdir_tag < tif->tif_fieldinfo[fix]->field_tag) {
- if (!diroutoforderwarning) {
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: invalid TIFF directory; tags are not sorted in ascending order",
- tif->tif_name);
- diroutoforderwarning = 1;
- }
- fix = 0; /* O(n^2) */
- }
- while (fix < tif->tif_nfields &&
- tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
- fix++;
- if (fix >= tif->tif_nfields ||
- tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) {
- /* Unknown tag ... we'll deal with it below */
- haveunknowntags = 1;
- continue;
- }
- /*
- * Null out old tags that we ignore.
- */
- if (tif->tif_fieldinfo[fix]->field_bit == FIELD_IGNORE) {
- ignore:
- dp->tdir_tag = IGNORE;
- continue;
- }
- /*
- * Check data type.
- */
- fip = tif->tif_fieldinfo[fix];
- while (dp->tdir_type != (unsigned short) fip->field_type
- && fix < tif->tif_nfields) {
- if (fip->field_type == TIFF_ANY) /* wildcard */
- break;
- fip = tif->tif_fieldinfo[++fix];
- if (fix >= tif->tif_nfields ||
- fip->field_tag != dp->tdir_tag) {
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: wrong data type %d for \"%s\"; tag ignored",
- tif->tif_name, dp->tdir_type,
- tif->tif_fieldinfo[fix-1]->field_name);
- goto ignore;
- }
- }
- /*
- * Check count if known in advance.
- */
- if (fip->field_readcount != TIFF_VARIABLE
- && fip->field_readcount != TIFF_VARIABLE2) {
- uint32 expected = (fip->field_readcount == TIFF_SPP) ?
- (uint32) td->td_samplesperpixel :
- (uint32) fip->field_readcount;
- if (!CheckDirCount(tif, dp, expected))
- goto ignore;
- }
-
- switch (dp->tdir_tag) {
- case TIFFTAG_COMPRESSION:
- /*
- * The 5.0 spec says the Compression tag has
- * one value, while earlier specs say it has
- * one value per sample. Because of this, we
- * accept the tag if one value is supplied.
- */
- if (dp->tdir_count == 1) {
- v = TIFFExtractData(tif,
- dp->tdir_type, dp->tdir_offset);
- if (!TIFFSetField(tif, dp->tdir_tag, (uint16)v))
- goto bad;
- else
- compressionknown = 1;
- break;
- /* XXX: workaround for broken TIFFs */
- } else if (dp->tdir_type == TIFF_LONG) {
- if (!TIFFFetchPerSampleLongs(tif, dp, &v) ||
- !TIFFSetField(tif, dp->tdir_tag, (uint16)v))
- goto bad;
- } else {
- if (!TIFFFetchPerSampleShorts(tif, dp, &iv)
- || !TIFFSetField(tif, dp->tdir_tag, iv))
- goto bad;
- }
- dp->tdir_tag = IGNORE;
- break;
- case TIFFTAG_STRIPOFFSETS:
- case TIFFTAG_STRIPBYTECOUNTS:
- case TIFFTAG_TILEOFFSETS:
- case TIFFTAG_TILEBYTECOUNTS:
- TIFFSetFieldBit(tif, fip->field_bit);
- break;
- case TIFFTAG_IMAGEWIDTH:
- case TIFFTAG_IMAGELENGTH:
- case TIFFTAG_IMAGEDEPTH:
- case TIFFTAG_TILELENGTH:
- case TIFFTAG_TILEWIDTH:
- case TIFFTAG_TILEDEPTH:
- case TIFFTAG_PLANARCONFIG:
- case TIFFTAG_ROWSPERSTRIP:
- case TIFFTAG_EXTRASAMPLES:
- if (!TIFFFetchNormalTag(tif, dp))
- goto bad;
- dp->tdir_tag = IGNORE;
- break;
- }
- }
-
- /*
- * If we saw any unknown tags, make an extra pass over the directory
- * to deal with them. This must be done separately because the tags
- * could have become known when we registered a codec after finding
- * the Compression tag. In a correctly-sorted directory there's
- * no problem because Compression will come before any codec-private
- * tags, but if the sorting is wrong that might not hold.
- */
- if (haveunknowntags) {
- fix = 0;
- for (dp = dir, n = dircount; n > 0; n--, dp++) {
- if (dp->tdir_tag == IGNORE)
- continue;
- if (fix >= tif->tif_nfields ||
- dp->tdir_tag < tif->tif_fieldinfo[fix]->field_tag)
- fix = 0; /* O(n^2) */
- while (fix < tif->tif_nfields &&
- tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
- fix++;
- if (fix >= tif->tif_nfields ||
- tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) {
-
- TIFFWarningExt(tif->tif_clientdata,
- module,
- "%s: unknown field with tag %d (0x%x) encountered",
- tif->tif_name,
- dp->tdir_tag,
- dp->tdir_tag);
-
- if (!_TIFFMergeFieldInfo(tif,
- _TIFFCreateAnonFieldInfo(tif,
- dp->tdir_tag,
- (TIFFDataType) dp->tdir_type),
- 1))
- {
- TIFFWarningExt(tif->tif_clientdata,
- module,
- "Registering anonymous field with tag %d (0x%x) failed",
- dp->tdir_tag,
- dp->tdir_tag);
- dp->tdir_tag = IGNORE;
- continue;
- }
- fix = 0;
- while (fix < tif->tif_nfields &&
- tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
- fix++;
- }
- /*
- * Check data type.
- */
- fip = tif->tif_fieldinfo[fix];
- while (dp->tdir_type != (unsigned short) fip->field_type
- && fix < tif->tif_nfields) {
- if (fip->field_type == TIFF_ANY) /* wildcard */
- break;
- fip = tif->tif_fieldinfo[++fix];
- if (fix >= tif->tif_nfields ||
- fip->field_tag != dp->tdir_tag) {
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: wrong data type %d for \"%s\"; tag ignored",
- tif->tif_name, dp->tdir_type,
- tif->tif_fieldinfo[fix-1]->field_name);
- dp->tdir_tag = IGNORE;
- break;
- }
- }
- }
- }
-
- /*
- * XXX: OJPEG hack.
- * If a) compression is OJPEG, b) planarconfig tag says it's separate,
- * c) strip offsets/bytecounts tag are both present and
- * d) both contain exactly one value, then we consistently find
- * that the buggy implementation of the buggy compression scheme
- * matches contig planarconfig best. So we 'fix-up' the tag here
- */
- if ((td->td_compression==COMPRESSION_OJPEG) &&
- (td->td_planarconfig==PLANARCONFIG_SEPARATE)) {
- dp = TIFFReadDirectoryFind(dir,dircount,TIFFTAG_STRIPOFFSETS);
- if ((dp!=0) && (dp->tdir_count==1)) {
- dp = TIFFReadDirectoryFind(dir, dircount,
- TIFFTAG_STRIPBYTECOUNTS);
- if ((dp!=0) && (dp->tdir_count==1)) {
- td->td_planarconfig=PLANARCONFIG_CONTIG;
- TIFFWarningExt(tif->tif_clientdata,
- "TIFFReadDirectory",
- "Planarconfig tag value assumed incorrect, "
- "assuming data is contig instead of chunky");
- }
- }
- }
-
- /*
- * Allocate directory structure and setup defaults.
- */
- if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
- MissingRequired(tif, "ImageLength");
- goto bad;
- }
- /*
- * Setup appropriate structures (by strip or by tile)
- */
- if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
- td->td_nstrips = TIFFNumberOfStrips(tif);
- td->td_tilewidth = td->td_imagewidth;
- td->td_tilelength = td->td_rowsperstrip;
- td->td_tiledepth = td->td_imagedepth;
- tif->tif_flags &= ~TIFF_ISTILED;
- } else {
- td->td_nstrips = TIFFNumberOfTiles(tif);
- tif->tif_flags |= TIFF_ISTILED;
- }
- if (!td->td_nstrips) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: cannot handle zero number of %s",
- tif->tif_name, isTiled(tif) ? "tiles" : "strips");
- goto bad;
- }
- td->td_stripsperimage = td->td_nstrips;
- if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
- td->td_stripsperimage /= td->td_samplesperpixel;
- if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) {
- if ((td->td_compression==COMPRESSION_OJPEG) &&
- (isTiled(tif)==0) &&
- (td->td_nstrips==1)) {
- /*
- * XXX: OJPEG hack.
- * If a) compression is OJPEG, b) it's not a tiled TIFF,
- * and c) the number of strips is 1,
- * then we tolerate the absence of stripoffsets tag,
- * because, presumably, all required data is in the
- * JpegInterchangeFormat stream.
- */
- TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
- } else {
- MissingRequired(tif,
- isTiled(tif) ? "TileOffsets" : "StripOffsets");
- goto bad;
- }
- }
-
- /*
- * Second pass: extract other information.
- */
- for (dp = dir, n = dircount; n > 0; n--, dp++) {
- if (dp->tdir_tag == IGNORE)
- continue;
- switch (dp->tdir_tag) {
- case TIFFTAG_MINSAMPLEVALUE:
- case TIFFTAG_MAXSAMPLEVALUE:
- case TIFFTAG_BITSPERSAMPLE:
- case TIFFTAG_DATATYPE:
- case TIFFTAG_SAMPLEFORMAT:
- /*
- * The 5.0 spec says the Compression tag has
- * one value, while earlier specs say it has
- * one value per sample. Because of this, we
- * accept the tag if one value is supplied.
- *
- * The MinSampleValue, MaxSampleValue, BitsPerSample
- * DataType and SampleFormat tags are supposed to be
- * written as one value/sample, but some vendors
- * incorrectly write one value only -- so we accept
- * that as well (yech). Other vendors write correct
- * value for NumberOfSamples, but incorrect one for
- * BitsPerSample and friends, and we will read this
- * too.
- */
- if (dp->tdir_count == 1) {
- v = TIFFExtractData(tif,
- dp->tdir_type, dp->tdir_offset);
- if (!TIFFSetField(tif, dp->tdir_tag, (uint16)v))
- goto bad;
- /* XXX: workaround for broken TIFFs */
- } else if (dp->tdir_tag == TIFFTAG_BITSPERSAMPLE
- && dp->tdir_type == TIFF_LONG) {
- if (!TIFFFetchPerSampleLongs(tif, dp, &v) ||
- !TIFFSetField(tif, dp->tdir_tag, (uint16)v))
- goto bad;
- } else {
- if (!TIFFFetchPerSampleShorts(tif, dp, &iv) ||
- !TIFFSetField(tif, dp->tdir_tag, iv))
- goto bad;
- }
- break;
- case TIFFTAG_SMINSAMPLEVALUE:
- case TIFFTAG_SMAXSAMPLEVALUE:
- {
- double dv = 0.0;
- if (!TIFFFetchPerSampleAnys(tif, dp, &dv) ||
- !TIFFSetField(tif, dp->tdir_tag, dv))
- goto bad;
- }
- break;
- case TIFFTAG_STRIPOFFSETS:
- case TIFFTAG_TILEOFFSETS:
- if (!TIFFFetchStripThing(tif, dp,
- td->td_nstrips, &td->td_stripoffset))
- goto bad;
- break;
- case TIFFTAG_STRIPBYTECOUNTS:
- case TIFFTAG_TILEBYTECOUNTS:
- if (!TIFFFetchStripThing(tif, dp,
- td->td_nstrips, &td->td_stripbytecount))
- goto bad;
- break;
- case TIFFTAG_COLORMAP:
- case TIFFTAG_TRANSFERFUNCTION:
- {
- char* cp;
- /*
- * TransferFunction can have either 1x or 3x
- * data values; Colormap can have only 3x
- * items.
- */
- v = 1L<<td->td_bitspersample;
- if (dp->tdir_tag == TIFFTAG_COLORMAP ||
- dp->tdir_count != v) {
- if (!CheckDirCount(tif, dp, 3 * v))
- break;
- }
- v *= sizeof(uint16);
- cp = (char *)_TIFFCheckMalloc(tif,
- dp->tdir_count,
- sizeof (uint16),
- "to read \"TransferFunction\" tag");
- if (cp != NULL) {
- if (TIFFFetchData(tif, dp, cp)) {
- /*
- * This deals with there being
- * only one array to apply to
- * all samples.
- */
- uint32 c = 1L << td->td_bitspersample;
- if (dp->tdir_count == c)
- v = 0L;
- TIFFSetField(tif, dp->tdir_tag,
- cp, cp+v, cp+2*v);
- }
- _TIFFfree(cp);
- }
- break;
- }
- case TIFFTAG_PAGENUMBER:
- case TIFFTAG_HALFTONEHINTS:
- case TIFFTAG_YCBCRSUBSAMPLING:
- case TIFFTAG_DOTRANGE:
- (void) TIFFFetchShortPair(tif, dp);
- break;
- case TIFFTAG_REFERENCEBLACKWHITE:
- (void) TIFFFetchRefBlackWhite(tif, dp);
- break;
-/* BEGIN REV 4.0 COMPATIBILITY */
- case TIFFTAG_OSUBFILETYPE:
- v = 0L;
- switch (TIFFExtractData(tif, dp->tdir_type,
- dp->tdir_offset)) {
- case OFILETYPE_REDUCEDIMAGE:
- v = FILETYPE_REDUCEDIMAGE;
- break;
- case OFILETYPE_PAGE:
- v = FILETYPE_PAGE;
- break;
- }
- if (v)
- TIFFSetField(tif, TIFFTAG_SUBFILETYPE, v);
- break;
-/* END REV 4.0 COMPATIBILITY */
- default:
- (void) TIFFFetchNormalTag(tif, dp);
- break;
- }
- }
- /*
- * OJPEG hack:
- * - If a) compression is OJPEG, and b) photometric tag is missing,
- * then we consistently find that photometric should be YCbCr
- * - If a) compression is OJPEG, and b) photometric tag says it's RGB,
- * then we consistently find that the buggy implementation of the
- * buggy compression scheme matches photometric YCbCr instead.
- * - If a) compression is OJPEG, and b) bitspersample tag is missing,
- * then we consistently find bitspersample should be 8.
- * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
- * and c) photometric is RGB or YCbCr, then we consistently find
- * samplesperpixel should be 3
- * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
- * and c) photometric is MINISWHITE or MINISBLACK, then we consistently
- * find samplesperpixel should be 3
- */
- if (td->td_compression==COMPRESSION_OJPEG)
- {
- if (!TIFFFieldSet(tif,FIELD_PHOTOMETRIC))
- {
- TIFFWarningExt(tif->tif_clientdata, "TIFFReadDirectory",
- "Photometric tag is missing, assuming data is YCbCr");
- if (!TIFFSetField(tif,TIFFTAG_PHOTOMETRIC,PHOTOMETRIC_YCBCR))
- goto bad;
- }
- else if (td->td_photometric==PHOTOMETRIC_RGB)
- {
- td->td_photometric=PHOTOMETRIC_YCBCR;
- TIFFWarningExt(tif->tif_clientdata, "TIFFReadDirectory",
- "Photometric tag value assumed incorrect, "
- "assuming data is YCbCr instead of RGB");
- }
- if (!TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
- {
- TIFFWarningExt(tif->tif_clientdata,"TIFFReadDirectory",
- "BitsPerSample tag is missing, assuming 8 bits per sample");
- if (!TIFFSetField(tif,TIFFTAG_BITSPERSAMPLE,8))
- goto bad;
- }
- if (!TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
- {
- if ((td->td_photometric==PHOTOMETRIC_RGB)
- || (td->td_photometric==PHOTOMETRIC_YCBCR))
- {
- TIFFWarningExt(tif->tif_clientdata,
- "TIFFReadDirectory",
- "SamplesPerPixel tag is missing, "
- "assuming correct SamplesPerPixel value is 3");
- if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3))
- goto bad;
- }
- else if ((td->td_photometric==PHOTOMETRIC_MINISWHITE)
- || (td->td_photometric==PHOTOMETRIC_MINISBLACK))
- {
- TIFFWarningExt(tif->tif_clientdata,
- "TIFFReadDirectory",
- "SamplesPerPixel tag is missing, "
- "assuming correct SamplesPerPixel value is 1");
- if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,1))
- goto bad;
- }
- }
- }
- /*
- * Verify Palette image has a Colormap.
- */
- if (td->td_photometric == PHOTOMETRIC_PALETTE &&
- !TIFFFieldSet(tif, FIELD_COLORMAP)) {
- MissingRequired(tif, "Colormap");
- goto bad;
- }
- /*
- * OJPEG hack:
- * We do no further messing with strip/tile offsets/bytecounts in OJPEG
- * TIFFs
- */
- if (td->td_compression!=COMPRESSION_OJPEG)
- {
- /*
- * Attempt to deal with a missing StripByteCounts tag.
- */
- if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) {
- /*
- * Some manufacturers violate the spec by not giving
- * the size of the strips. In this case, assume there
- * is one uncompressed strip of data.
- */
- if ((td->td_planarconfig == PLANARCONFIG_CONTIG &&
- td->td_nstrips > 1) ||
- (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
- td->td_nstrips != td->td_samplesperpixel)) {
- MissingRequired(tif, "StripByteCounts");
- goto bad;
- }
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: TIFF directory is missing required "
- "\"%s\" field, calculating from imagelength",
- tif->tif_name,
- _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
- if (EstimateStripByteCounts(tif, dir, dircount) < 0)
- goto bad;
- /*
- * Assume we have wrong StripByteCount value (in case
- * of single strip) in following cases:
- * - it is equal to zero along with StripOffset;
- * - it is larger than file itself (in case of uncompressed
- * image);
- * - it is smaller than the size of the bytes per row
- * multiplied on the number of rows. The last case should
- * not be checked in the case of writing new image,
- * because we may do not know the exact strip size
- * until the whole image will be written and directory
- * dumped out.
- */
- #define BYTECOUNTLOOKSBAD \
- ( (td->td_stripbytecount[0] == 0 && td->td_stripoffset[0] != 0) || \
- (td->td_compression == COMPRESSION_NONE && \
- td->td_stripbytecount[0] > TIFFGetFileSize(tif) - td->td_stripoffset[0]) || \
- (tif->tif_mode == O_RDONLY && \
- td->td_compression == COMPRESSION_NONE && \
- td->td_stripbytecount[0] < TIFFScanlineSize(tif) * td->td_imagelength) )
-
- } else if (td->td_nstrips == 1
- && td->td_stripoffset[0] != 0
- && BYTECOUNTLOOKSBAD) {
- /*
- * XXX: Plexus (and others) sometimes give a value of
- * zero for a tag when they don't know what the
- * correct value is! Try and handle the simple case
- * of estimating the size of a one strip image.
- */
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: Bogus \"%s\" field, ignoring and calculating from imagelength",
- tif->tif_name,
- _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
- if(EstimateStripByteCounts(tif, dir, dircount) < 0)
- goto bad;
- } else if (td->td_planarconfig == PLANARCONFIG_CONTIG
- && td->td_nstrips > 2
- && td->td_compression == COMPRESSION_NONE
- && td->td_stripbytecount[0] != td->td_stripbytecount[1]
- && td->td_stripbytecount[0] != 0
- && td->td_stripbytecount[1] != 0 ) {
- /*
- * XXX: Some vendors fill StripByteCount array with
- * absolutely wrong values (it can be equal to
- * StripOffset array, for example). Catch this case
- * here.
- */
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: Wrong \"%s\" field, ignoring and calculating from imagelength",
- tif->tif_name,
- _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
- if (EstimateStripByteCounts(tif, dir, dircount) < 0)
- goto bad;
- }
- }
- if (dir) {
- _TIFFfree((char *)dir);
- dir = NULL;
- }
- if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
- td->td_maxsamplevalue = (uint16)((1L<<td->td_bitspersample)-1);
- /*
- * Setup default compression scheme.
- */
-
- /*
- * XXX: We can optimize checking for the strip bounds using the sorted
- * bytecounts array. See also comments for TIFFAppendToStrip()
- * function in tif_write.c.
- */
- if (td->td_nstrips > 1) {
- tstrip_t strip;
-
- td->td_stripbytecountsorted = 1;
- for (strip = 1; strip < td->td_nstrips; strip++) {
- if (td->td_stripoffset[strip - 1] >
- td->td_stripoffset[strip]) {
- td->td_stripbytecountsorted = 0;
- break;
- }
- }
- }
-
- if (!TIFFFieldSet(tif, FIELD_COMPRESSION))
- TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
- /*
- * Some manufacturers make life difficult by writing
- * large amounts of uncompressed data as a single strip.
- * This is contrary to the recommendations of the spec.
- * The following makes an attempt at breaking such images
- * into strips closer to the recommended 8k bytes. A
- * side effect, however, is that the RowsPerStrip tag
- * value may be changed.
- */
- if (td->td_nstrips == 1 && td->td_compression == COMPRESSION_NONE &&
- (tif->tif_flags & (TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP)
- ChopUpSingleUncompressedStrip(tif);
-
- /*
- * Reinitialize i/o since we are starting on a new directory.
- */
- tif->tif_row = (uint32) -1;
- tif->tif_curstrip = (tstrip_t) -1;
- tif->tif_col = (uint32) -1;
- tif->tif_curtile = (ttile_t) -1;
- tif->tif_tilesize = (tsize_t) -1;
-
- tif->tif_scanlinesize = TIFFScanlineSize(tif);
- if (!tif->tif_scanlinesize) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: cannot handle zero scanline size",
- tif->tif_name);
- return (0);
- }
-
- if (isTiled(tif)) {
- tif->tif_tilesize = TIFFTileSize(tif);
- if (!tif->tif_tilesize) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: cannot handle zero tile size",
- tif->tif_name);
- return (0);
- }
- } else {
- if (!TIFFStripSize(tif)) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: cannot handle zero strip size",
- tif->tif_name);
- return (0);
- }
- }
- return (1);
-bad:
- if (dir)
- _TIFFfree(dir);
- return (0);
-}
-
-static TIFFDirEntry*
-TIFFReadDirectoryFind(TIFFDirEntry* dir, uint16 dircount, uint16 tagid)
-{
- TIFFDirEntry* m;
- uint16 n;
- for (m=dir, n=0; n<dircount; m++, n++)
- {
- if (m->tdir_tag==tagid)
- return(m);
- }
- return(0);
-}
-
-/*
- * Read custom directory from the arbitarry offset.
- * The code is very similar to TIFFReadDirectory().
- */
-int
-TIFFReadCustomDirectory(TIFF* tif, toff_t diroff,
- const TIFFFieldInfo info[], size_t n)
-{
- static const char module[] = "TIFFReadCustomDirectory";
-
- TIFFDirectory* td = &tif->tif_dir;
- TIFFDirEntry *dp, *dir = NULL;
- const TIFFFieldInfo* fip;
- size_t fix;
- uint16 i, dircount;
-
- _TIFFSetupFieldInfo(tif, info, n);
-
- dircount = TIFFFetchDirectory(tif, diroff, &dir, NULL);
- if (!dircount) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Failed to read custom directory at offset %u",
- tif->tif_name, diroff);
- return 0;
- }
-
- TIFFFreeDirectory(tif);
- _TIFFmemset(&tif->tif_dir, 0, sizeof(TIFFDirectory));
-
- fix = 0;
- for (dp = dir, i = dircount; i > 0; i--, dp++) {
- if (tif->tif_flags & TIFF_SWAB) {
- TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
- TIFFSwabArrayOfLong(&dp->tdir_count, 2);
- }
-
- if (fix >= tif->tif_nfields || dp->tdir_tag == IGNORE)
- continue;
-
- while (fix < tif->tif_nfields &&
- tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
- fix++;
-
- if (fix >= tif->tif_nfields ||
- tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) {
-
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: unknown field with tag %d (0x%x) encountered",
- tif->tif_name, dp->tdir_tag, dp->tdir_tag);
- if (!_TIFFMergeFieldInfo(tif,
- _TIFFCreateAnonFieldInfo(tif,
- dp->tdir_tag,
- (TIFFDataType) dp->tdir_type),
- 1))
- {
- TIFFWarningExt(tif->tif_clientdata, module,
- "Registering anonymous field with tag %d (0x%x) failed",
- dp->tdir_tag, dp->tdir_tag);
- goto ignore;
- }
-
- fix = 0;
- while (fix < tif->tif_nfields &&
- tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
- fix++;
- }
- /*
- * Null out old tags that we ignore.
- */
- if (tif->tif_fieldinfo[fix]->field_bit == FIELD_IGNORE) {
- ignore:
- dp->tdir_tag = IGNORE;
- continue;
- }
- /*
- * Check data type.
- */
- fip = tif->tif_fieldinfo[fix];
- while (dp->tdir_type != (unsigned short) fip->field_type
- && fix < tif->tif_nfields) {
- if (fip->field_type == TIFF_ANY) /* wildcard */
- break;
- fip = tif->tif_fieldinfo[++fix];
- if (fix >= tif->tif_nfields ||
- fip->field_tag != dp->tdir_tag) {
- TIFFWarningExt(tif->tif_clientdata, module,
- "%s: wrong data type %d for \"%s\"; tag ignored",
- tif->tif_name, dp->tdir_type,
- tif->tif_fieldinfo[fix-1]->field_name);
- goto ignore;
- }
- }
- /*
- * Check count if known in advance.
- */
- if (fip->field_readcount != TIFF_VARIABLE
- && fip->field_readcount != TIFF_VARIABLE2) {
- uint32 expected = (fip->field_readcount == TIFF_SPP) ?
- (uint32) td->td_samplesperpixel :
- (uint32) fip->field_readcount;
- if (!CheckDirCount(tif, dp, expected))
- goto ignore;
- }
-
- /*
- * EXIF tags which need to be specifically processed.
- */
- switch (dp->tdir_tag) {
- case EXIFTAG_SUBJECTDISTANCE:
- (void) TIFFFetchSubjectDistance(tif, dp);
- break;
- default:
- (void) TIFFFetchNormalTag(tif, dp);
- break;
- }
- }
-
- if (dir)
- _TIFFfree(dir);
- return 1;
-}
-
-/*
- * EXIF is important special case of custom IFD, so we have a special
- * function to read it.
- */
-int
-TIFFReadEXIFDirectory(TIFF* tif, toff_t diroff)
-{
- size_t exifFieldInfoCount;
- const TIFFFieldInfo *exifFieldInfo =
- _TIFFGetExifFieldInfo(&exifFieldInfoCount);
- return TIFFReadCustomDirectory(tif, diroff, exifFieldInfo,
- exifFieldInfoCount);
-}
-
-static int
-EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)
-{
- static const char module[] = "EstimateStripByteCounts";
-
- TIFFDirEntry *dp;
- TIFFDirectory *td = &tif->tif_dir;
- uint32 strip;
-
- if (td->td_stripbytecount)
- _TIFFfree(td->td_stripbytecount);
- td->td_stripbytecount = (uint32*)
- _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint32),
- "for \"StripByteCounts\" array");
- if( td->td_stripbytecount == NULL )
- return -1;
-
- if (td->td_compression != COMPRESSION_NONE) {
- uint32 space = (uint32)(sizeof (TIFFHeader)
- + sizeof (uint16)
- + (dircount * sizeof (TIFFDirEntry))
- + sizeof (uint32));
- toff_t filesize = TIFFGetFileSize(tif);
- uint16 n;
-
- /* calculate amount of space used by indirect values */
- for (dp = dir, n = dircount; n > 0; n--, dp++)
- {
- uint32 cc = TIFFDataWidth((TIFFDataType) dp->tdir_type);
- if (cc == 0) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Cannot determine size of unknown tag type %d",
- tif->tif_name, dp->tdir_type);
- return -1;
- }
- cc = cc * dp->tdir_count;
- if (cc > sizeof (uint32))
- space += cc;
- }
- space = filesize - space;
- if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
- space /= td->td_samplesperpixel;
- for (strip = 0; strip < td->td_nstrips; strip++)
- td->td_stripbytecount[strip] = space;
- /*
- * This gross hack handles the case were the offset to
- * the last strip is past the place where we think the strip
- * should begin. Since a strip of data must be contiguous,
- * it's safe to assume that we've overestimated the amount
- * of data in the strip and trim this number back accordingly.
- */
- strip--;
- if (((toff_t)(td->td_stripoffset[strip]+
- td->td_stripbytecount[strip])) > filesize)
- td->td_stripbytecount[strip] =
- filesize - td->td_stripoffset[strip];
- } else if (isTiled(tif)) {
- uint32 bytespertile = TIFFTileSize(tif);
-
- for (strip = 0; strip < td->td_nstrips; strip++)
- td->td_stripbytecount[strip] = bytespertile;
- } else {
- uint32 rowbytes = TIFFScanlineSize(tif);
- uint32 rowsperstrip = td->td_imagelength/td->td_stripsperimage;
- for (strip = 0; strip < td->td_nstrips; strip++)
- td->td_stripbytecount[strip] = rowbytes * rowsperstrip;
- }
- TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
- if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
- td->td_rowsperstrip = td->td_imagelength;
- return 1;
-}
-
-static void
-MissingRequired(TIFF* tif, const char* tagname)
-{
- static const char module[] = "MissingRequired";
-
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: TIFF directory is missing required \"%s\" field",
- tif->tif_name, tagname);
-}
-
-/*
- * Check the directory offset against the list of already seen directory
- * offsets. This is a trick to prevent IFD looping. The one can create TIFF
- * file with looped directory pointers. We will maintain a list of already
- * seen directories and check every IFD offset against that list.
- */
-static int
-TIFFCheckDirOffset(TIFF* tif, toff_t diroff)
-{
- uint16 n;
-
- if (diroff == 0) /* no more directories */
- return 0;
-
- for (n = 0; n < tif->tif_dirnumber && tif->tif_dirlist; n++) {
- if (tif->tif_dirlist[n] == diroff)
- return 0;
- }
-
- tif->tif_dirnumber++;
-
- if (tif->tif_dirnumber > tif->tif_dirlistsize) {
- toff_t* new_dirlist;
-
- /*
- * XXX: Reduce memory allocation granularity of the dirlist
- * array.
- */
- new_dirlist = (toff_t *)_TIFFCheckRealloc(tif,
- tif->tif_dirlist,
- tif->tif_dirnumber,
- 2 * sizeof(toff_t),
- "for IFD list");
- if (!new_dirlist)
- return 0;
- tif->tif_dirlistsize = 2 * tif->tif_dirnumber;
- tif->tif_dirlist = new_dirlist;
- }
-
- tif->tif_dirlist[tif->tif_dirnumber - 1] = diroff;
-
- return 1;
-}
-
-/*
- * Check the count field of a directory entry against a known value. The
- * caller is expected to skip/ignore the tag if there is a mismatch.
- */
-static int
-CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
-{
- if (count > dir->tdir_count) {
- TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "incorrect count for field \"%s\" (%u, expecting %u); tag ignored",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
- dir->tdir_count, count);
- return (0);
- } else if (count < dir->tdir_count) {
- TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "incorrect count for field \"%s\" (%u, expecting %u); tag trimmed",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
- dir->tdir_count, count);
- return (1);
- }
- return (1);
-}
-
-/*
- * Read IFD structure from the specified offset. If the pointer to
- * nextdiroff variable has been specified, read it too. Function returns a
- * number of fields in the directory or 0 if failed.
- */
-static uint16
-TIFFFetchDirectory(TIFF* tif, toff_t diroff, TIFFDirEntry **pdir,
- toff_t *nextdiroff)
-{
- static const char module[] = "TIFFFetchDirectory";
-
- TIFFDirEntry *dir;
- uint16 dircount;
-
- assert(pdir);
-
- tif->tif_diroff = diroff;
- if (nextdiroff)
- *nextdiroff = 0;
- if (!isMapped(tif)) {
- if (!SeekOK(tif, tif->tif_diroff)) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Seek error accessing TIFF directory",
- tif->tif_name);
- return 0;
- }
- if (!ReadOK(tif, &dircount, sizeof (uint16))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Can not read TIFF directory count",
- tif->tif_name);
- return 0;
- }
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabShort(&dircount);
- dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
- sizeof (TIFFDirEntry),
- "to read TIFF directory");
- if (dir == NULL)
- return 0;
- if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%.100s: Can not read TIFF directory",
- tif->tif_name);
- _TIFFfree(dir);
- return 0;
- }
- /*
- * Read offset to next directory for sequential scans if
- * needed.
- */
- if (nextdiroff)
- (void) ReadOK(tif, nextdiroff, sizeof(uint32));
- } else {
- toff_t off = tif->tif_diroff;
-
- /*
- * Check for integer overflow when validating the dir_off,
- * otherwise a very high offset may cause an OOB read and
- * crash the client. Make two comparisons instead of
- *
- * off + sizeof(uint16) > tif->tif_size
- *
- * to avoid overflow.
- */
- if (tif->tif_size < sizeof (uint16) ||
- off > tif->tif_size - sizeof(uint16)) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Can not read TIFF directory count",
- tif->tif_name);
- return 0;
- } else {
- _TIFFmemcpy(&dircount, tif->tif_base + off,
- sizeof(uint16));
- }
- off += sizeof (uint16);
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabShort(&dircount);
- dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
- sizeof(TIFFDirEntry),
- "to read TIFF directory");
- if (dir == NULL)
- return 0;
- if (off + dircount * sizeof (TIFFDirEntry) > tif->tif_size) {
- TIFFErrorExt(tif->tif_clientdata, module,
- "%s: Can not read TIFF directory",
- tif->tif_name);
- _TIFFfree(dir);
- return 0;
- } else {
- _TIFFmemcpy(dir, tif->tif_base + off,
- dircount * sizeof(TIFFDirEntry));
- }
- if (nextdiroff) {
- off += dircount * sizeof (TIFFDirEntry);
- if (off + sizeof (uint32) <= tif->tif_size) {
- _TIFFmemcpy(nextdiroff, tif->tif_base + off,
- sizeof (uint32));
- }
- }
- }
- if (nextdiroff && tif->tif_flags & TIFF_SWAB)
- TIFFSwabLong(nextdiroff);
- *pdir = dir;
- return dircount;
-}
-
-/*
- * Fetch a contiguous directory item.
- */
-static tsize_t
-TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp)
-{
- uint32 w = TIFFDataWidth((TIFFDataType) dir->tdir_type);
- /*
- * FIXME: butecount should have tsize_t type, but for now libtiff
- * defines tsize_t as a signed 32-bit integer and we are losing
- * ability to read arrays larger than 2^31 bytes. So we are using
- * uint32 instead of tsize_t here.
- */
- uint32 cc = dir->tdir_count * w;
-
- /* Check for overflow. */
- if (!dir->tdir_count || !w || cc / w != dir->tdir_count)
- goto bad;
-
- if (!isMapped(tif)) {
- if (!SeekOK(tif, dir->tdir_offset))
- goto bad;
- if (!ReadOK(tif, cp, cc))
- goto bad;
- } else {
- /* Check for overflow. */
- if (dir->tdir_offset + cc < dir->tdir_offset
- || dir->tdir_offset + cc < cc
- || dir->tdir_offset + cc > tif->tif_size)
- goto bad;
- _TIFFmemcpy(cp, tif->tif_base + dir->tdir_offset, cc);
- }
- if (tif->tif_flags & TIFF_SWAB) {
- switch (dir->tdir_type) {
- case TIFF_SHORT:
- case TIFF_SSHORT:
- TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count);
- break;
- case TIFF_LONG:
- case TIFF_SLONG:
- case TIFF_FLOAT:
- TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);
- break;
- case TIFF_RATIONAL:
- case TIFF_SRATIONAL:
- TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);
- break;
- case TIFF_DOUBLE:
- TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count);
- break;
- }
- }
- return (cc);
-bad:
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Error fetching data for field \"%s\"",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
- return (tsize_t) 0;
-}
-
-/*
- * Fetch an ASCII item from the file.
- */
-static tsize_t
-TIFFFetchString(TIFF* tif, TIFFDirEntry* dir, char* cp)
-{
- if (dir->tdir_count <= 4) {
- uint32 l = dir->tdir_offset;
- if (tif->tif_flags & TIFF_SWAB)
- TIFFSwabLong(&l);
- _TIFFmemcpy(cp, &l, dir->tdir_count);
- return (1);
- }
- return (TIFFFetchData(tif, dir, cp));
-}
-
-/*
- * Convert numerator+denominator to float.
- */
-static int
-cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv)
-{
- if (denom == 0) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "%s: Rational with zero denominator (num = %u)",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, num);
- return (0);
- } else {
- if (dir->tdir_type == TIFF_RATIONAL)
- *rv = ((float)num / (float)denom);
- else
- *rv = ((float)(int32)num / (float)(int32)denom);
- return (1);
- }
-}
-
-/*
- * Fetch a rational item from the file at offset off and return the value as a
- * floating point number.
- */
-static float
-TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir)
-{
- uint32 l[2];
- float v;
-
- return (!TIFFFetchData(tif, dir, (char *)l) ||
- !cvtRational(tif, dir, l[0], l[1], &v) ? 1.0f : v);
-}
-
-/*
- * Fetch a single floating point value from the offset field and return it as
- * a native float.
- */
-static float
-TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir)
-{
- float v;
- int32 l = TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);
- _TIFFmemcpy(&v, &l, sizeof(float));
- TIFFCvtIEEEFloatToNative(tif, 1, &v);
- return (v);
-}
-
-/*
- * Fetch an array of BYTE or SBYTE values.
- */
-static int
-TIFFFetchByteArray(TIFF* tif, TIFFDirEntry* dir, uint8* v)
-{
- if (dir->tdir_count <= 4) {
- /*
- * Extract data from offset field.
- */
- if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
- if (dir->tdir_type == TIFF_SBYTE)
- switch (dir->tdir_count) {
- case 4: v[3] = dir->tdir_offset & 0xff;
- case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;
- case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;
- case 1: v[0] = dir->tdir_offset >> 24;
- }
- else
- switch (dir->tdir_count) {
- case 4: v[3] = dir->tdir_offset & 0xff;
- case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;
- case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;
- case 1: v[0] = dir->tdir_offset >> 24;
- }
- } else {
- if (dir->tdir_type == TIFF_SBYTE)
- switch (dir->tdir_count) {
- case 4: v[3] = dir->tdir_offset >> 24;
- case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;
- case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;
- case 1: v[0] = dir->tdir_offset & 0xff;
- }
- else
- switch (dir->tdir_count) {
- case 4: v[3] = dir->tdir_offset >> 24;
- case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;
- case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;
- case 1: v[0] = dir->tdir_offset & 0xff;
- }
- }
- return (1);
- } else
- return (TIFFFetchData(tif, dir, (char*) v) != 0); /* XXX */
-}
-
-/*
- * Fetch an array of SHORT or SSHORT values.
- */
-static int
-TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
-{
- if (dir->tdir_count <= 2) {
- if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
- switch (dir->tdir_count) {
- case 2: v[1] = (uint16) (dir->tdir_offset & 0xffff);
- case 1: v[0] = (uint16) (dir->tdir_offset >> 16);
- }
- } else {
- switch (dir->tdir_count) {
- case 2: v[1] = (uint16) (dir->tdir_offset >> 16);
- case 1: v[0] = (uint16) (dir->tdir_offset & 0xffff);
- }
- }
- return (1);
- } else
- return (TIFFFetchData(tif, dir, (char *)v) != 0);
-}
-
-/*
- * Fetch a pair of SHORT or BYTE values. Some tags may have either BYTE
- * or SHORT type and this function works with both ones.
- */
-static int
-TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir)
-{
- /*
- * Prevent overflowing the v stack arrays below by performing a sanity
- * check on tdir_count, this should never be greater than two.
- */
- if (dir->tdir_count > 2) {
- TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "unexpected count for field \"%s\", %u, expected 2; ignored",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
- dir->tdir_count);
- return 0;
- }
-
- switch (dir->tdir_type) {
- case TIFF_BYTE:
- case TIFF_SBYTE:
- {
- uint8 v[4];
- return TIFFFetchByteArray(tif, dir, v)
- && TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
- }
- case TIFF_SHORT:
- case TIFF_SSHORT:
- {
- uint16 v[2];
- return TIFFFetchShortArray(tif, dir, v)
- && TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
- }
- default:
- return 0;
- }
-}
-
-/*
- * Fetch an array of LONG or SLONG values.
- */
-static int
-TIFFFetchLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v)
-{
- if (dir->tdir_count == 1) {
- v[0] = dir->tdir_offset;
- return (1);
- } else
- return (TIFFFetchData(tif, dir, (char*) v) != 0);
-}
-
-/*
- * Fetch an array of RATIONAL or SRATIONAL values.
- */
-static int
-TIFFFetchRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
-{
- int ok = 0;
- uint32* l;
-
- l = (uint32*)_TIFFCheckMalloc(tif,
- dir->tdir_count, TIFFDataWidth((TIFFDataType) dir->tdir_type),
- "to fetch array of rationals");
- if (l) {
- if (TIFFFetchData(tif, dir, (char *)l)) {
- uint32 i;
- for (i = 0; i < dir->tdir_count; i++) {
- ok = cvtRational(tif, dir,
- l[2*i+0], l[2*i+1], &v[i]);
- if (!ok)
- break;
- }
- }
- _TIFFfree((char *)l);
- }
- return (ok);
-}
-
-/*
- * Fetch an array of FLOAT values.
- */
-static int
-TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)
-{
-
- if (dir->tdir_count == 1) {
- union
- {
- float f;
- uint32 i;
- } float_union;
-
- float_union.i=dir->tdir_offset;
- v[0]=float_union.f;
- TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
- return (1);
- } else if (TIFFFetchData(tif, dir, (char*) v)) {
- TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
- return (1);
- } else
- return (0);
-}
-
-/*
- * Fetch an array of DOUBLE values.
- */
-static int
-TIFFFetchDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v)
-{
- if (TIFFFetchData(tif, dir, (char*) v)) {
- TIFFCvtIEEEDoubleToNative(tif, dir->tdir_count, v);
- return (1);
- } else
- return (0);
-}
-
-/*
- * Fetch an array of ANY values. The actual values are returned as doubles
- * which should be able hold all the types. Yes, there really should be an
- * tany_t to avoid this potential non-portability ... Note in particular that
- * we assume that the double return value vector is large enough to read in
- * any fundamental type. We use that vector as a buffer to read in the base
- * type vector and then convert it in place to double (from end to front of
- * course).
- */
-static int
-TIFFFetchAnyArray(TIFF* tif, TIFFDirEntry* dir, double* v)
-{
- int i;
-
- switch (dir->tdir_type) {
- case TIFF_BYTE:
- case TIFF_SBYTE:
- if (!TIFFFetchByteArray(tif, dir, (uint8*) v))
- return (0);
- if (dir->tdir_type == TIFF_BYTE) {
- uint8* vp = (uint8*) v;
- for (i = dir->tdir_count-1; i >= 0; i--)
- v[i] = vp[i];
- } else {
- int8* vp = (int8*) v;
- for (i = dir->tdir_count-1; i >= 0; i--)
- v[i] = vp[i];
- }
- break;
- case TIFF_SHORT:
- case TIFF_SSHORT:
- if (!TIFFFetchShortArray(tif, dir, (uint16*) v))
- return (0);
- if (dir->tdir_type == TIFF_SHORT) {
- uint16* vp = (uint16*) v;
- for (i = dir->tdir_count-1; i >= 0; i--)
- v[i] = vp[i];
- } else {
- int16* vp = (int16*) v;
- for (i = dir->tdir_count-1; i >= 0; i--)
- v[i] = vp[i];
- }
- break;
- case TIFF_LONG:
- case TIFF_SLONG:
- if (!TIFFFetchLongArray(tif, dir, (uint32*) v))
- return (0);
- if (dir->tdir_type == TIFF_LONG) {
- uint32* vp = (uint32*) v;
- for (i = dir->tdir_count-1; i >= 0; i--)
- v[i] = vp[i];
- } else {
- int32* vp = (int32*) v;
- for (i = dir->tdir_count-1; i >= 0; i--)
- v[i] = vp[i];
- }
- break;
- case TIFF_RATIONAL:
- case TIFF_SRATIONAL:
- if (!TIFFFetchRationalArray(tif, dir, (float*) v))
- return (0);
- { float* vp = (float*) v;
- for (i = dir->tdir_count-1; i >= 0; i--)
- v[i] = vp[i];
- }
- break;
- case TIFF_FLOAT:
- if (!TIFFFetchFloatArray(tif, dir, (float*) v))
- return (0);
- { float* vp = (float*) v;
- for (i = dir->tdir_count-1; i >= 0; i--)
- v[i] = vp[i];
- }
- break;
- case TIFF_DOUBLE:
- return (TIFFFetchDoubleArray(tif, dir, (double*) v));
- default:
- /* TIFF_NOTYPE */
- /* TIFF_ASCII */
- /* TIFF_UNDEFINED */
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "cannot read TIFF_ANY type %d for field \"%s\"",
- dir->tdir_type,
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
- return (0);
- }
- return (1);
-}
-
-/*
- * Fetch a tag that is not handled by special case code.
- */
-static int
-TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp)
-{
- static const char mesg[] = "to fetch tag value";
- int ok = 0;
- const TIFFFieldInfo* fip = _TIFFFieldWithTag(tif, dp->tdir_tag);
-
- if (dp->tdir_count > 1) { /* array of values */
- char* cp = NULL;
-
- switch (dp->tdir_type) {
- case TIFF_BYTE:
- case TIFF_SBYTE:
- cp = (char *)_TIFFCheckMalloc(tif,
- dp->tdir_count, sizeof (uint8), mesg);
- ok = cp && TIFFFetchByteArray(tif, dp, (uint8*) cp);
- break;
- case TIFF_SHORT:
- case TIFF_SSHORT:
- cp = (char *)_TIFFCheckMalloc(tif,
- dp->tdir_count, sizeof (uint16), mesg);
- ok = cp && TIFFFetchShortArray(tif, dp, (uint16*) cp);
- break;
- case TIFF_LONG:
- case TIFF_SLONG:
- cp = (char *)_TIFFCheckMalloc(tif,
- dp->tdir_count, sizeof (uint32), mesg);
- ok = cp && TIFFFetchLongArray(tif, dp, (uint32*) cp);
- break;
- case TIFF_RATIONAL:
- case TIFF_SRATIONAL:
- cp = (char *)_TIFFCheckMalloc(tif,
- dp->tdir_count, sizeof (float), mesg);
- ok = cp && TIFFFetchRationalArray(tif, dp, (float*) cp);
- break;
- case TIFF_FLOAT:
- cp = (char *)_TIFFCheckMalloc(tif,
- dp->tdir_count, sizeof (float), mesg);
- ok = cp && TIFFFetchFloatArray(tif, dp, (float*) cp);
- break;
- case TIFF_DOUBLE:
- cp = (char *)_TIFFCheckMalloc(tif,
- dp->tdir_count, sizeof (double), mesg);
- ok = cp && TIFFFetchDoubleArray(tif, dp, (double*) cp);
- break;
- case TIFF_ASCII:
- case TIFF_UNDEFINED: /* bit of a cheat... */
- /*
- * Some vendors write strings w/o the trailing
- * NULL byte, so always append one just in case.
- */
- cp = (char *)_TIFFCheckMalloc(tif, dp->tdir_count + 1,
- 1, mesg);
- if( (ok = (cp && TIFFFetchString(tif, dp, cp))) != 0 )
- cp[dp->tdir_count] = '\0'; /* XXX */
- break;
- }
- if (ok) {
- ok = (fip->field_passcount ?
- TIFFSetField(tif, dp->tdir_tag, dp->tdir_count, cp)
- : TIFFSetField(tif, dp->tdir_tag, cp));
- }
- if (cp != NULL)
- _TIFFfree(cp);
- } else if (CheckDirCount(tif, dp, 1)) { /* singleton value */
- switch (dp->tdir_type) {
- case TIFF_BYTE:
- case TIFF_SBYTE:
- case TIFF_SHORT:
- case TIFF_SSHORT:
- /*
- * If the tag is also acceptable as a LONG or SLONG
- * then TIFFSetField will expect an uint32 parameter
- * passed to it (through varargs). Thus, for machines
- * where sizeof (int) != sizeof (uint32) we must do
- * a careful check here. It's hard to say if this
- * is worth optimizing.
- *
- * NB: We use TIFFFieldWithTag here knowing that
- * it returns us the first entry in the table
- * for the tag and that that entry is for the
- * widest potential data type the tag may have.
- */
- { TIFFDataType type = fip->field_type;
- if (type != TIFF_LONG && type != TIFF_SLONG) {
- uint16 v = (uint16)
- TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
- ok = (fip->field_passcount ?
- TIFFSetField(tif, dp->tdir_tag, 1, &v)
- : TIFFSetField(tif, dp->tdir_tag, v));
- break;
- }
- }
- /* fall thru... */
- case TIFF_LONG:
- case TIFF_SLONG:
- { uint32 v32 =
- TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
- ok = (fip->field_passcount ?
- TIFFSetField(tif, dp->tdir_tag, 1, &v32)
- : TIFFSetField(tif, dp->tdir_tag, v32));
- }
- break;
- case TIFF_RATIONAL:
- case TIFF_SRATIONAL:
- case TIFF_FLOAT:
- { float v = (dp->tdir_type == TIFF_FLOAT ?
- TIFFFetchFloat(tif, dp)
- : TIFFFetchRational(tif, dp));
- ok = (fip->field_passcount ?
- TIFFSetField(tif, dp->tdir_tag, 1, &v)
- : TIFFSetField(tif, dp->tdir_tag, v));
- }
- break;
- case TIFF_DOUBLE:
- { double v;
- ok = (TIFFFetchDoubleArray(tif, dp, &v) &&
- (fip->field_passcount ?
- TIFFSetField(tif, dp->tdir_tag, 1, &v)
- : TIFFSetField(tif, dp->tdir_tag, v))
- );
- }
- break;
- case TIFF_ASCII:
- case TIFF_UNDEFINED: /* bit of a cheat... */
- { char c[2];
- if( (ok = (TIFFFetchString(tif, dp, c) != 0)) != 0 ) {
- c[1] = '\0'; /* XXX paranoid */
- ok = (fip->field_passcount ?
- TIFFSetField(tif, dp->tdir_tag, 1, c)
- : TIFFSetField(tif, dp->tdir_tag, c));
- }
- }
- break;
- }
- }
- return (ok);
-}
-
-#define NITEMS(x) (sizeof (x) / sizeof (x[0]))
-/*
- * Fetch samples/pixel short values for
- * the specified tag and verify that
- * all values are the same.
- */
-static int
-TIFFFetchPerSampleShorts(TIFF* tif, TIFFDirEntry* dir, uint16* pl)
-{
- uint16 samples = tif->tif_dir.td_samplesperpixel;
- int status = 0;
-
- if (CheckDirCount(tif, dir, (uint32) samples)) {
- uint16 buf[10];
- uint16* v = buf;
-
- if (dir->tdir_count > NITEMS(buf))
- v = (uint16*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof(uint16),
- "to fetch per-sample values");
- if (v && TIFFFetchShortArray(tif, dir, v)) {
- uint16 i;
- int check_count = dir->tdir_count;
- if( samples < check_count )
- check_count = samples;
-
- for (i = 1; i < check_count; i++)
- if (v[i] != v[0]) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Cannot handle different per-sample values for field \"%s\"",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
- goto bad;
- }
- *pl = v[0];
- status = 1;
- }
- bad:
- if (v && v != buf)
- _TIFFfree(v);
- }
- return (status);
-}
-
-/*
- * Fetch samples/pixel long values for
- * the specified tag and verify that
- * all values are the same.
- */
-static int
-TIFFFetchPerSampleLongs(TIFF* tif, TIFFDirEntry* dir, uint32* pl)
-{
- uint16 samples = tif->tif_dir.td_samplesperpixel;
- int status = 0;
-
- if (CheckDirCount(tif, dir, (uint32) samples)) {
- uint32 buf[10];
- uint32* v = buf;
-
- if (dir->tdir_count > NITEMS(buf))
- v = (uint32*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof(uint32),
- "to fetch per-sample values");
- if (v && TIFFFetchLongArray(tif, dir, v)) {
- uint16 i;
- int check_count = dir->tdir_count;
-
- if( samples < check_count )
- check_count = samples;
- for (i = 1; i < check_count; i++)
- if (v[i] != v[0]) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Cannot handle different per-sample values for field \"%s\"",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
- goto bad;
- }
- *pl = v[0];
- status = 1;
- }
- bad:
- if (v && v != buf)
- _TIFFfree(v);
- }
- return (status);
-}
-
-/*
- * Fetch samples/pixel ANY values for the specified tag and verify that all
- * values are the same.
- */
-static int
-TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* pl)
-{
- uint16 samples = tif->tif_dir.td_samplesperpixel;
- int status = 0;
-
- if (CheckDirCount(tif, dir, (uint32) samples)) {
- double buf[10];
- double* v = buf;
-
- if (dir->tdir_count > NITEMS(buf))
- v = (double*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof (double),
- "to fetch per-sample values");
- if (v && TIFFFetchAnyArray(tif, dir, v)) {
- uint16 i;
- int check_count = dir->tdir_count;
- if( samples < check_count )
- check_count = samples;
-
- for (i = 1; i < check_count; i++)
- if (v[i] != v[0]) {
- TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
- "Cannot handle different per-sample values for field \"%s\"",
- _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
- goto bad;
- }
- *pl = v[0];
- status = 1;
- }
- bad:
- if (v && v != buf)
- _TIFFfree(v);
- }
- return (status);
-}
-#undef NITEMS
-
-/*
- * Fetch a set of offsets or lengths.
- * While this routine says "strips", in fact it's also used for tiles.
- */
-static int
-TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, long nstrips, uint32** lpp)
-{
- register uint32* lp;
- int status;
-
- CheckDirCount(tif, dir, (uint32) nstrips);
-
- /*
- * Allocate space for strip information.
- */
- if (*lpp == NULL &&
- (*lpp = (uint32 *)_TIFFCheckMalloc(tif,
- nstrips, sizeof (uint32), "for strip array")) == NULL)
- return (0);
- lp = *lpp;
- _TIFFmemset( lp, 0, sizeof(uint32) * nstrips );
-
- if (dir->tdir_type == (int)TIFF_SHORT) {
- /*
- * Handle uint16->uint32 expansion.
- */
- uint16* dp = (uint16*) _TIFFCheckMalloc(tif,
- dir->tdir_count, sizeof (uint16), "to fetch strip tag");
- if (dp == NULL)
- return (0);
- if( (status = TIFFFetchShortArray(tif, dir, dp)) != 0 ) {
- int i;
-
- for( i = 0; i < nstrips && i < (int) dir->tdir_count; i++ )
- {
- lp[i] = dp[i];
- }
- }
- _TIFFfree((char*) dp);
-
- } else if( nstrips != (int) dir->tdir_count ) {
- /* Special case to correct length */
-
- uint32* dp = (uint32*) _TIFFCheckMalloc(tif,
- dir->tdir_count, sizeof (uint32), "to fetch strip tag");
- if (dp == NULL)
- return (0);
-
- status = TIFFFetchLongArray(tif, dir, dp);
- if( status != 0 ) {
- int i;
-
- for( i = 0; i < nstrips && i < (int) dir->tdir_count; i++ )
- {
- lp[i] = dp[i];
- }
- }
-
- _TIFFfree( (char *) dp );
- } else
- status = TIFFFetchLongArray(tif, dir, lp);
-
- return (status);
-}
-
-/*
- * Fetch and set the RefBlackWhite tag.
- */
-static int
-TIFFFetchRefBlackWhite(TIFF* tif, TIFFDirEntry* dir)
-{
- static const char mesg[] = "for \"ReferenceBlackWhite\" array";
- char* cp;
- int ok;
-
- if (dir->tdir_type == TIFF_RATIONAL)
- return (TIFFFetchNormalTag(tif, dir));
- /*
- * Handle LONG's for backward compatibility.
- */
- cp = (char *)_TIFFCheckMalloc(tif, dir->tdir_count,
- sizeof (uint32), mesg);
- if( (ok = (cp && TIFFFetchLongArray(tif, dir, (uint32*) cp))) != 0) {
- float* fp = (float*)
- _TIFFCheckMalloc(tif, dir->tdir_count, sizeof (float), mesg);
- if( (ok = (fp != NULL)) != 0 ) {
- uint32 i;
- for (i = 0; i < dir->tdir_count; i++)
- fp[i] = (float)((uint32*) cp)[i];
- ok = TIFFSetField(tif, dir->tdir_tag, fp);
- _TIFFfree((char*) fp);
- }
- }
- if (cp)
- _TIFFfree(cp);
- return (ok);
-}
-
-/*
- * Fetch and set the SubjectDistance EXIF tag.
- */
-static int
-TIFFFetchSubjectDistance(TIFF* tif, TIFFDirEntry* dir)
-{
- uint32 l[2];
- float v;
- int ok = 0;
-
- if( dir->tdir_count != 1 || dir->tdir_type != TIFF_RATIONAL )
- {
- TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
- "incorrect count or type for SubjectDistance, tag ignored" );
- return (0);
- }
-
- if (TIFFFetchData(tif, dir, (char *)l)
- && cvtRational(tif, dir, l[0], l[1], &v)) {
- /*
- * XXX: Numerator 0xFFFFFFFF means that we have infinite
- * distance. Indicate that with a negative floating point
- * SubjectDistance value.
- */
- ok = TIFFSetField(tif, dir->tdir_tag,
- (l[0] != 0xFFFFFFFF) ? v : -v);
- }
-
- return ok;
-}
-
-/*
- * Replace a single strip (tile) of uncompressed data by multiple strips
- * (tiles), each approximately STRIP_SIZE_DEFAULT bytes. This is useful for
- * dealing with large images or for dealing with machines with a limited
- * amount memory.
- */
-static void
-ChopUpSingleUncompressedStrip(TIFF* tif)
-{
- register TIFFDirectory *td = &tif->tif_dir;
- uint32 bytecount = td->td_stripbytecount[0];
- uint32 offset = td->td_stripoffset[0];
- tsize_t rowbytes = TIFFVTileSize(tif, 1), stripbytes;
- tstrip_t strip, nstrips, rowsperstrip;
- uint32* newcounts;
- uint32* newoffsets;
-
- /*
- * Make the rows hold at least one scanline, but fill specified amount
- * of data if possible.
- */
- if (rowbytes > STRIP_SIZE_DEFAULT) {
- stripbytes = rowbytes;
- rowsperstrip = 1;
- } else if (rowbytes > 0 ) {
- rowsperstrip = STRIP_SIZE_DEFAULT / rowbytes;
- stripbytes = rowbytes * rowsperstrip;
- }
- else
- return;
-
- /*
- * never increase the number of strips in an image
- */
- if (rowsperstrip >= td->td_rowsperstrip)
- return;
- nstrips = (tstrip_t) TIFFhowmany(bytecount, stripbytes);
- if( nstrips == 0 ) /* something is wonky, do nothing. */
- return;
-
- newcounts = (uint32*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint32),
- "for chopped \"StripByteCounts\" array");
- newoffsets = (uint32*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint32),
- "for chopped \"StripOffsets\" array");
- if (newcounts == NULL || newoffsets == NULL) {
- /*
- * Unable to allocate new strip information, give up and use
- * the original one strip information.
- */
- if (newcounts != NULL)
- _TIFFfree(newcounts);
- if (newoffsets != NULL)
- _TIFFfree(newoffsets);
- return;
- }
- /*
- * Fill the strip information arrays with new bytecounts and offsets
- * that reflect the broken-up format.
- */
- for (strip = 0; strip < nstrips; strip++) {
- if ((uint32)stripbytes > bytecount)
- stripbytes = bytecount;
- newcounts[strip] = stripbytes;
- newoffsets[strip] = offset;
- offset += stripbytes;
- bytecount -= stripbytes;
- }
- /*
- * Replace old single strip info with multi-strip info.
- */
- td->td_stripsperimage = td->td_nstrips = nstrips;
- TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
-
- _TIFFfree(td->td_stripbytecount);
- _TIFFfree(td->td_stripoffset);
- td->td_stripbytecount = newcounts;
- td->td_stripoffset = newoffsets;
- td->td_stripbytecountsorted = 1;
-}
-
-/* vim: set ts=8 sts=8 sw=8 noet: */
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 8
- * fill-column: 78
- * End:
- */