mirror of
https://github.com/opencv/opencv.git
synced 2024-12-16 02:19:12 +08:00
2082 lines
60 KiB
C
2082 lines
60 KiB
C
/* $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:
|
|
*/
|