TIFF*
TIFFClientOpen(
const char* name, const char* mode,
thandle_t clientdata,
TIFFReadWriteProc readproc,
TIFFReadWriteProc writeproc,
TIFFSeekProc seekproc,
TIFFCloseProc closeproc,
TIFFSizeProc sizeproc,
TIFFMapFileProc mapproc,
TIFFUnmapFileProc unmapproc
)
{
static const char module[] = "TIFFClientOpen";
TIFF *tif;
int m;
const char* cp;
m = _TIFFgetMode(mode, module);
if (m == -1)
goto bad2;
tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);
if (tif == NULL) {
TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name);
goto bad2;
}
_TIFFmemset(tif, 0, sizeof (*tif));
tif->tif_name = (char *)tif + sizeof (TIFF);
strcpy(tif->tif_name, name);
tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
tif->tif_curdir = (tdir_t) -1; /* non-existent directory */
tif->tif_curoff = 0;
tif->tif_curstrip = (tstrip_t) -1; /* invalid strip */
tif->tif_row = (uint32) -1; /* read/write pre-increment */
tif->tif_clientdata = clientdata;
if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
TIFFErrorExt(clientdata, module,
"One of the client procedures is NULL pointer.");
goto bad2;
}
tif->tif_readproc = readproc;
tif->tif_writeproc = writeproc;
tif->tif_seekproc = seekproc;
tif->tif_closeproc = closeproc;
tif->tif_sizeproc = sizeproc;
if (mapproc)
tif->tif_mapproc = mapproc;
else
tif->tif_mapproc = _tiffDummyMapProc;
if (unmapproc)
tif->tif_unmapproc = unmapproc;
else
tif->tif_unmapproc = _tiffDummyUnmapProc;
_TIFFSetDefaultCompressionState(tif); /* setup default state */
/*
* Default is to return data MSB2LSB and enable the
* use of memory-mapped files and strip chopping when
* a file is opened read-only.
*/
tif->tif_flags = FILLORDER_MSB2LSB;
if (m == O_RDONLY )
tif->tif_flags |= TIFF_MAPPED;
#ifdef STRIPCHOP_DEFAULT
if (m == O_RDONLY || m == O_RDWR)
tif->tif_flags |= STRIPCHOP_DEFAULT;
#endif
/*
* Process library-specific flags in the open mode string.
* The following flags may be used to control intrinsic library
* behaviour that may or may not be desirable (usually for
* compatibility with some application that claims to support
* TIFF but only supports some braindead idea of what the
* vendor thinks TIFF is):
*
* 'l' use little-endian byte order for creating a file
* 'b' use big-endian byte order for creating a file
* 'L' read/write information using LSB2MSB bit order
* 'B' read/write information using MSB2LSB bit order
* 'H' read/write information using host bit order
* 'M' enable use of memory-mapped files when supported
* 'm' disable use of memory-mapped files
* 'C' enable strip chopping support when reading
* 'c' disable strip chopping support
* 'h' read TIFF header only, do not load the first IFD
*
* The use of the 'l' and 'b' flags is strongly discouraged.
* These flags are provided solely because numerous vendors,
* typically on the PC, do not correctly support TIFF; they
* only support the Intel little-endian byte order. This
* support is not configured by default because it supports
* the violation of the TIFF spec that says that readers *MUST*
* support both byte orders. It is strongly recommended that
* you not use this feature except to deal with busted apps
* that write invalid TIFF. And even in those cases you should
* bang on the vendors to fix their software.
*
* The 'L', 'B', and 'H' flags are intended for applications
* that can optimize operations on data by using a particular
* bit order. By default the library returns data in MSB2LSB
* bit order for compatibiltiy with older versions of this
* library. Returning data in the bit order of the native cpu
* makes the most sense but also requires applications to check
* the value of the FillOrder tag; something they probably do
* not do right now.
*
* The 'M' and 'm' flags are provided because some virtual memory
* systems exhibit poor behaviour when large images are mapped.
* These options permit clients to control the use of memory-mapped
* files on a per-file basis.
*
* The 'C' and 'c' flags are provided because the library support
* for chopping up large strips into multiple smaller strips is not
* application-transparent and as such can cause problems. The 'c'
* option permits applications that only want to look at the tags,
* for example, to get the unadulterated TIFF tag information.
*/
for (cp = mode; *cp; cp++)
switch (*cp) {
case 'b':
#ifndef WORDS_BIGENDIAN
if (m&O_CREAT)
tif->tif_flags |= TIFF_SWAB;
#endif
break;
case 'l':
#ifdef WORDS_BIGENDIAN
if ((m&O_CREAT))
tif->tif_flags |= TIFF_SWAB;
#endif
break;
case 'B':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_MSB2LSB;
break;
case 'L':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_LSB2MSB;
break;
case 'H':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
HOST_FILLORDER;
break;
case 'M':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_MAPPED;
break;
case 'm':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_MAPPED;
break;
case 'C':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_STRIPCHOP;
break;
case 'c':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_STRIPCHOP;
break;
case 'h':
tif->tif_flags |= TIFF_HEADERONLY;
break;
}
/*
* Read in TIFF header.
*/
if (tif->tif_mode & O_TRUNC ||
!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
if (tif->tif_mode == O_RDONLY) {
TIFFErrorExt(tif->tif_clientdata, name,
"Cannot read TIFF header");
goto bad;
}
/*
* Setup header and write.
*/
#ifdef WORDS_BIGENDIAN
tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
#else
tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
#endif
tif->tif_header.tiff_version = TIFF_VERSION;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&tif->tif_header.tiff_version);
tif->tif_header.tiff_diroff = 0; /* filled in later */
/*
* The doc for "fopen" for some STD_C_LIBs says that if you
* open a file for modify ("+"), then you must fseek (or
* fflush?) between any freads and fwrites. This is not
* necessary on most systems, but has been shown to be needed
* on Solaris.
*/
TIFFSeekFile( tif, 0, SEEK_SET );
if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
TIFFErrorExt(tif->tif_clientdata, name,
"Error writing TIFF header");
goto bad;
}
/*
* Setup the byte order handling.
*/
TIFFInitOrder(tif, tif->tif_header.tiff_magic);
/*
* Setup default directory.
*/
if (!TIFFDefaultDirectory(tif))
goto bad;
tif->tif_diroff = 0;
tif->tif_dirlist = NULL;
tif->tif_dirlistsize = 0;
tif->tif_dirnumber = 0;
return (tif);
}
/*
* Setup the byte order handling.
*/
if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN
#if MDI_SUPPORT
&&
#if HOST_BIGENDIAN
tif->tif_header.tiff_magic != MDI_BIGENDIAN
#else
tif->tif_header.tiff_magic != MDI_LITTLEENDIAN
#endif
) {
TIFFErrorExt(tif->tif_clientdata, name,
"Not a TIFF or MDI file, bad magic number %d (0x%x)",
#else
) {
TIFFErrorExt(tif->tif_clientdata, name,
"Not a TIFF file, bad magic number %d (0x%x)",
#endif
tif->tif_header.tiff_magic,
tif->tif_header.tiff_magic);
goto bad;
}
TIFFInitOrder(tif, tif->tif_header.tiff_magic);
/*
* Swap header if required.
*/
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabShort(&tif->tif_header.tiff_version);
TIFFSwabLong(&tif->tif_header.tiff_diroff);
}
/*
* Now check version (if needed, it's been byte-swapped).
* Note that this isn't actually a version number, it's a
* magic number that doesn't change (stupid).
*/
if (tif->tif_header.tiff_version == TIFF_BIGTIFF_VERSION) {
TIFFErrorExt(tif->tif_clientdata, name,
"This is a BigTIFF file. This format not supported\n"
"by this version of libtiff." );
goto bad;
}
if (tif->tif_header.tiff_version != TIFF_VERSION) {
TIFFErrorExt(tif->tif_clientdata, name,
"Not a TIFF file, bad version number %d (0x%x)",
tif->tif_header.tiff_version,
tif->tif_header.tiff_version);
goto bad;
}
tif->tif_flags |= TIFF_MYBUFFER;
tif->tif_rawcp = tif->tif_rawdata = 0;
tif->tif_rawdatasize = 0;
/*
* Sometimes we do not want to read the first directory (for example,
* it may be broken) and want to proceed to other directories. I this
* case we use the TIFF_HEADERONLY flag to open file and return
* immediately after reading TIFF header.
*/
if (tif->tif_flags & TIFF_HEADERONLY)
return (tif);
/*
* Setup initial directory.
*/
switch (mode[0]) {
case 'r':
tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
/*
* Try to use a memory-mapped file if the client
* has not explicitly suppressed usage with the
* 'm' flag in the open mode (see above).
*/
if ((tif->tif_flags & TIFF_MAPPED) &&
!TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size))
tif->tif_flags &= ~TIFF_MAPPED;
if (TIFFReadDirectory(tif)) {
tif->tif_rawcc = -1;
tif->tif_flags |= TIFF_BUFFERSETUP;
return (tif);
}
break;
case 'a':
/*
* New directories are automatically append
* to the end of the directory chain when they
* are written out (see TIFFWriteDirectory).
*/
if (!TIFFDefaultDirectory(tif))
goto bad;
return (tif);
}
bad:
tif->tif_mode = O_RDONLY; /* XXX avoid flush */
TIFFCleanup(tif);
bad2:
return ((TIFF*)0);
}
/*
* Append the data to the specified strip.
*/
static int
TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc)
{
static const char module[] = "TIFFAppendToStrip";
TIFFDirectory *td = &tif->tif_dir;
uint64 m;
int64 old_byte_count = -1;
if (td->td_stripoffset[strip] == 0 || tif->tif_curoff == 0) {
assert(td->td_nstrips > 0);
if( td->td_stripbytecount[strip] != 0
&& td->td_stripoffset[strip] != 0
&& td->td_stripbytecount[strip] >= (uint64) cc )
{
/*
* There is already tile data on disk, and the new tile
* data we have will fit in the same space. The only
* aspect of this that is risky is that there could be
* more data to append to this strip before we are done
* depending on how we are getting called.
*/
if (!SeekOK(tif, td->td_stripoffset[strip])) {
TIFFErrorExt(tif->tif_clientdata, module,
"Seek error at scanline %lu",
(unsigned long)tif->tif_row);
return (0);
}
}
else
{
/*
* Seek to end of file, and set that as our location to
* write this strip.
*/
td->td_stripoffset[strip] = TIFFSeekFile(tif, 0, SEEK_END);
tif->tif_flags |= TIFF_DIRTYSTRIP;
}
tif->tif_curoff = td->td_stripoffset[strip];
/*
* We are starting a fresh strip/tile, so set the size to zero.
*/
old_byte_count = td->td_stripbytecount[strip];
td->td_stripbytecount[strip] = 0;
}
m = tif->tif_curoff+cc;
if (!(tif->tif_flags&TIFF_BIGTIFF))
m = (uint32)m;
if ((m<tif->tif_curoff)||(m<(uint64)cc))
{
TIFFErrorExt(tif->tif_clientdata, module, "Maximum TIFF file size exceeded");
return (0);
}
if (!WriteOK(tif, data, cc)) {
TIFFErrorExt(tif->tif_clientdata, module, "Write error at scanline %lu",
(unsigned long) tif->tif_row);
return (0);
}
tif->tif_curoff = m;
td->td_stripbytecount[strip] += cc;
if( (int64) td->td_stripbytecount[strip] != old_byte_count )
tif->tif_flags |= TIFF_DIRTYSTRIP;
return (1);
}
/*
* Link the current directory into the
* directory chain for the file.
*/
static int
TIFFLinkDirectory(TIFF* tif)
{
static const char module[] = "TIFFLinkDirectory";
uint32 nextdir;
uint32 diroff;
tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
diroff = (uint32) tif->tif_diroff;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&diroff);
#if SUBIFD_SUPPORT
if (tif->tif_flags & TIFF_INSUBIFD) {
(void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
TIFFError(module,
"%s: Error writing SubIFD directory link",
tif->tif_name);
return (0);
}
/*
* Advance to the next SubIFD or, if this is
* the last one configured, revert back to the
* normal directory linkage.
*/
if (--tif->tif_nsubifd)
tif->tif_subifdoff += sizeof (diroff);
else
tif->tif_flags &= ~TIFF_INSUBIFD;
return (1);
}
#endif
if (tif->tif_header.tiff_diroff == 0) {
/*
* First directory, overwrite offset in header.
*/
tif->tif_header.tiff_diroff = (uint32) tif->tif_diroff;
#define HDROFF(f) ((toff_t) &(((TIFFHeader*) 0)->f))
(void) TIFFSeekFile(tif, HDROFF(tiff_diroff), SEEK_SET);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
TIFFError(tif->tif_name, "Error writing TIFF header");
return (0);
}
return (1);
}
/*
* Not the first directory, search to the last and append.
*/
nextdir = tif->tif_header.tiff_diroff;
do {
uint16 dircount;
if (!SeekOK(tif, nextdir) ||
!ReadOK(tif, &dircount, sizeof (dircount))) {
TIFFError(module, "Error fetching directory count");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
(void) TIFFSeekFile(tif,
dircount * sizeof (TIFFDirEntry), SEEK_CUR);
if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
TIFFError(module, "Error fetching directory link");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&nextdir);
} while (nextdir != 0);
(void) TIFFSeekFile(tif, -(toff_t) sizeof (nextdir), SEEK_CUR);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
TIFFError(module, "Error writing directory link");
return (0);
}
return (1);
}
/*
* Append the data to the specified strip.
*/
static int
TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc) {
TIFFDirectory* td = &tif->tif_dir;
static const char module[] = "TIFFAppendToStrip";
if (td->td_stripoffset[strip] == 0 || tif->tif_curoff == 0) {
/*
* No current offset, set the current strip.
*/
assert(td->td_nstrips > 0);
if (td->td_stripoffset[strip] != 0) {
/*
* Prevent overlapping of the data chunks. We need
* this to enable in place updating of the compressed
* images. Larger blocks will be moved at the end of
* the file without any optimization of the spare
* space, so such scheme is not too much effective.
*/
if (td->td_stripbytecountsorted) {
if (strip == td->td_nstrips - 1
|| td->td_stripoffset[strip + 1] <
td->td_stripoffset[strip] + cc) {
td->td_stripoffset[strip] =
TIFFSeekFile(tif, (toff_t)0,
SEEK_END);
}
} else {
tstrip_t i;
for (i = 0; i < td->td_nstrips; i++) {
if (td->td_stripoffset[i] >
td->td_stripoffset[strip]
&& td->td_stripoffset[i] <
td->td_stripoffset[strip] + cc) {
td->td_stripoffset[strip] =
TIFFSeekFile(tif,
(toff_t)0,
SEEK_END);
}
}
}
if (!SeekOK(tif, td->td_stripoffset[strip])) {
TIFFError(module,
"%s: Seek error at scanline %lu",
tif->tif_name,
(unsigned long)tif->tif_row);
return (0);
}
} else
td->td_stripoffset[strip] =
TIFFSeekFile(tif, (toff_t) 0, SEEK_END);
tif->tif_curoff = td->td_stripoffset[strip];
}
if (!WriteOK(tif, data, cc)) {
TIFFError(module, "%s: Write error at scanline %lu",
tif->tif_name, (unsigned long) tif->tif_row);
return (0);
}
tif->tif_curoff += cc;
td->td_stripbytecount[strip] += cc;
return (1);
}
static int
_TIFFWriteCustomDirectory(TIFF* tif, toff_t *pdiroff)
{
uint16 dircount;
uint32 nfields;
tsize_t dirsize;
char* data;
TIFFDirEntry* dir;
TIFFDirectory* td;
unsigned long b, fields[FIELD_SETLONGS];
int fi, nfi;
if (tif->tif_mode == O_RDONLY)
return (1);
td = &tif->tif_dir;
/*
* Size the directory so that we can calculate
* offsets for the data items that aren't kept
* in-place in each field.
*/
nfields = 0;
for (b = 0; b <= FIELD_LAST; b++)
if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)
nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
nfields += td->td_customValueCount;
dirsize = nfields * sizeof (TIFFDirEntry);
data = (char*) _TIFFmalloc(dirsize);
if (data == NULL) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Cannot write directory, out of space");
return (0);
}
/*
* Put the directory at the end of the file.
*/
tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
tif->tif_dataoff = (toff_t)(
tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));
if (tif->tif_dataoff & 1)
tif->tif_dataoff++;
(void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
dir = (TIFFDirEntry*) data;
/*
* Setup external form of directory
* entries and write data items.
*/
_TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));
for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
/*
* For custom fields, we test to see if the custom field
* is set or not. For normal fields, we just use the
* FieldSet test.
*/
if( fip->field_bit == FIELD_CUSTOM )
{
int ci, is_set = FALSE;
for( ci = 0; ci < td->td_customValueCount; ci++ )
is_set |= (td->td_customValues[ci].info == fip);
if( !is_set )
continue;
}
else if (!FieldSet(fields, fip->field_bit))
continue;
if( fip->field_bit != FIELD_CUSTOM )
ResetFieldBit(fields, fip->field_bit);
}
/*
* Write directory.
*/
dircount = (uint16) nfields;
*pdiroff = (uint32) tif->tif_nextdiroff;
if (tif->tif_flags & TIFF_SWAB) {
/*
* The file's byte order is opposite to the
* native machine architecture. We overwrite
* the directory information with impunity
* because it'll be released below after we
* write it to the file. Note that all the
* other tag construction routines assume that
* we do this byte-swapping; i.e. they only
* byte-swap indirect data.
*/
for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {
TIFFSwabArrayOfShort(&dir->tdir_tag, 2);
TIFFSwabArrayOfLong(&dir->tdir_count, 2);
}
dircount = (uint16) nfields;
TIFFSwabShort(&dircount);
TIFFSwabLong(pdiroff);
}
(void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
if (!WriteOK(tif, &dircount, sizeof (dircount))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing directory count");
goto bad;
}
if (!WriteOK(tif, data, dirsize)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing directory contents");
goto bad;
}
if (!WriteOK(tif, pdiroff, sizeof (uint32))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing directory link");
goto bad;
}
_TIFFfree(data);
return (1);
bad:
_TIFFfree(data);
return (0);
}
/*
* Write the contents of the current directory
* to the specified file. This routine doesn't
* handle overwriting a directory with auxiliary
* storage that's been changed.
*/
int
TIFFWriteDirectory(TIFF* tif)
{
uint16 dircount;
uint32 diroff;
ttag_t tag;
uint32 nfields;
tsize_t dirsize;
char* data;
TIFFDirEntry* dir;
TIFFDirectory* td;
u_long b, fields[FIELD_SETLONGS];
int fi, nfi;
if (tif->tif_mode == O_RDONLY)
return (1);
/*
* Clear write state so that subsequent images with
* different characteristics get the right buffers
* setup for them.
*/
if (tif->tif_flags & TIFF_POSTENCODE) {
tif->tif_flags &= ~TIFF_POSTENCODE;
if (!(*tif->tif_postencode)(tif)) {
TIFFError(tif->tif_name,
"Error post-encoding before directory write");
return (0);
}
}
(*tif->tif_close)(tif); /* shutdown encoder */
/*
* Flush any data that might have been written
* by the compression close+cleanup routines.
*/
if (tif->tif_rawcc > 0 && !TIFFFlushData1(tif)) {
TIFFError(tif->tif_name,
"Error flushing data before directory write");
return (0);
}
if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
_TIFFfree(tif->tif_rawdata);
tif->tif_rawdata = NULL;
tif->tif_rawcc = 0;
}
tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);
td = &tif->tif_dir;
/*
* Size the directory so that we can calculate
* offsets for the data items that aren't kept
* in-place in each field.
*/
nfields = 0;
for (b = 0; b <= FIELD_LAST; b++)
if (TIFFFieldSet(tif, b))
nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
dirsize = nfields * sizeof (TIFFDirEntry);
data = (char*) _TIFFmalloc(dirsize);
if (data == NULL) {
TIFFError(tif->tif_name,
"Cannot write directory, out of space");
return (0);
}
/*
* Directory hasn't been placed yet, put
* it at the end of the file and link it
* into the existing directory structure.
*/
if (tif->tif_diroff == 0 && !TIFFLinkDirectory(tif))
goto bad;
tif->tif_dataoff = (toff_t)(
tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));
if (tif->tif_dataoff & 1)
tif->tif_dataoff++;
(void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
tif->tif_curdir++;
dir = (TIFFDirEntry*) data;
/*
* Setup external form of directory
* entries and write data items.
*/
_TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));
/*
* Write out ExtraSamples tag only if
* extra samples are present in the data.
*/
if (FieldSet(fields, FIELD_EXTRASAMPLES) && !td->td_extrasamples) {
ResetFieldBit(fields, FIELD_EXTRASAMPLES);
nfields--;
dirsize -= sizeof (TIFFDirEntry);
} /*XXX*/
for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
if (!FieldSet(fields, fip->field_bit))
continue;
switch (fip->field_bit) {
case FIELD_STRIPOFFSETS:
/*
* We use one field bit for both strip and tile
* offsets, and so must be careful in selecting
* the appropriate field descriptor (so that tags
* are written in sorted order).
*/
tag = isTiled(tif) ?
TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS;
if (tag != fip->field_tag)
continue;
if (!TIFFWriteLongArray(tif, TIFF_LONG, tag, dir,
(uint32) td->td_nstrips, td->td_stripoffset))
goto bad;
break;
case FIELD_STRIPBYTECOUNTS:
/*
* We use one field bit for both strip and tile
* byte counts, and so must be careful in selecting
* the appropriate field descriptor (so that tags
* are written in sorted order).
*/
tag = isTiled(tif) ?
TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS;
if (tag != fip->field_tag)
continue;
if (!TIFFWriteLongArray(tif, TIFF_LONG, tag, dir,
(uint32) td->td_nstrips, td->td_stripbytecount))
goto bad;
break;
case FIELD_ROWSPERSTRIP:
TIFFSetupShortLong(tif, TIFFTAG_ROWSPERSTRIP,
dir, td->td_rowsperstrip);
break;
case FIELD_COLORMAP:
if (!TIFFWriteShortTable(tif, TIFFTAG_COLORMAP, dir,
3, td->td_colormap))
goto bad;
break;
case FIELD_IMAGEDIMENSIONS:
TIFFSetupShortLong(tif, TIFFTAG_IMAGEWIDTH,
dir++, td->td_imagewidth);
TIFFSetupShortLong(tif, TIFFTAG_IMAGELENGTH,
dir, td->td_imagelength);
break;
case FIELD_TILEDIMENSIONS:
TIFFSetupShortLong(tif, TIFFTAG_TILEWIDTH,
dir++, td->td_tilewidth);
TIFFSetupShortLong(tif, TIFFTAG_TILELENGTH,
dir, td->td_tilelength);
break;
case FIELD_POSITION:
WriteRationalPair(TIFF_RATIONAL,
TIFFTAG_XPOSITION, td->td_xposition,
TIFFTAG_YPOSITION, td->td_yposition);
break;
case FIELD_RESOLUTION:
WriteRationalPair(TIFF_RATIONAL,
TIFFTAG_XRESOLUTION, td->td_xresolution,
TIFFTAG_YRESOLUTION, td->td_yresolution);
break;
case FIELD_BITSPERSAMPLE:
case FIELD_MINSAMPLEVALUE:
case FIELD_MAXSAMPLEVALUE:
case FIELD_SAMPLEFORMAT:
if (!TIFFWritePerSampleShorts(tif, fip->field_tag, dir))
goto bad;
break;
case FIELD_SMINSAMPLEVALUE:
case FIELD_SMAXSAMPLEVALUE:
if (!TIFFWritePerSampleAnys(tif,
_TIFFSampleToTagType(tif), fip->field_tag, dir))
goto bad;
break;
case FIELD_PAGENUMBER:
case FIELD_HALFTONEHINTS:
#ifdef YCBCR_SUPPORT
case FIELD_YCBCRSUBSAMPLING:
#endif
#ifdef CMYK_SUPPORT
case FIELD_DOTRANGE:
#endif
if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
goto bad;
break;
#ifdef CMYK_SUPPORT
case FIELD_INKNAMES:
if (!TIFFWriteInkNames(tif, dir))
goto bad;
break;
#endif
#ifdef COLORIMETRY_SUPPORT
case FIELD_TRANSFERFUNCTION:
if (!TIFFWriteTransferFunction(tif, dir))
goto bad;
break;
#endif
#if SUBIFD_SUPPORT
case FIELD_SUBIFD:
if (!TIFFWriteNormalTag(tif, dir, fip))
goto bad;
/*
* Total hack: if this directory includes a SubIFD
* tag then force the next <n> directories to be
* written as ``sub directories'' of this one. This
* is used to write things like thumbnails and
* image masks that one wants to keep out of the
* normal directory linkage access mechanism.
*/
if (dir->tdir_count > 0) {
tif->tif_flags |= TIFF_INSUBIFD;
tif->tif_nsubifd = (uint16) dir->tdir_count;
if (dir->tdir_count > 1)
tif->tif_subifdoff = dir->tdir_offset;
else
tif->tif_subifdoff = (uint32)(
tif->tif_diroff
+ sizeof (uint16)
+ ((char*)&dir->tdir_offset-data));
}
break;
#endif
default:
if (!TIFFWriteNormalTag(tif, dir, fip))
goto bad;
break;
}
dir++;
ResetFieldBit(fields, fip->field_bit);
}
/*
* Write directory.
*/
dircount = (uint16) nfields;
diroff = (uint32) tif->tif_nextdiroff;
if (tif->tif_flags & TIFF_SWAB) {
/*
* The file's byte order is opposite to the
* native machine architecture. We overwrite
* the directory information with impunity
* because it'll be released below after we
* write it to the file. Note that all the
* other tag construction routines assume that
* we do this byte-swapping; i.e. they only
* byte-swap indirect data.
*/
for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {
TIFFSwabArrayOfShort(&dir->tdir_tag, 2);
TIFFSwabArrayOfLong(&dir->tdir_count, 2);
}
dircount = (uint16) nfields;
TIFFSwabShort(&dircount);
TIFFSwabLong(&diroff);
}
(void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
if (!WriteOK(tif, &dircount, sizeof (dircount))) {
TIFFError(tif->tif_name, "Error writing directory count");
goto bad;
}
if (!WriteOK(tif, data, dirsize)) {
TIFFError(tif->tif_name, "Error writing directory contents");
goto bad;
}
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
TIFFError(tif->tif_name, "Error writing directory link");
goto bad;
}
TIFFFreeDirectory(tif);
_TIFFfree(data);
tif->tif_flags &= ~TIFF_DIRTYDIRECT;
(*tif->tif_cleanup)(tif);
/*
* Reset directory-related state for subsequent
* directories.
*/
TIFFDefaultDirectory(tif);
tif->tif_diroff = 0;
tif->tif_curoff = 0;
tif->tif_row = (uint32) -1;
tif->tif_curstrip = (tstrip_t) -1;
return (1);
bad:
_TIFFfree(data);
return (0);
}
int
TIFFRewriteDirectory( TIFF *tif )
{
static const char module[] = "TIFFRewriteDirectory";
/* We don't need to do anything special if it hasn't been written. */
if( tif->tif_diroff == 0 )
return TIFFWriteDirectory( tif );
/*
** Find and zero the pointer to this directory, so that TIFFLinkDirectory
** will cause it to be added after this directories current pre-link.
*/
/* Is it the first directory in the file? */
if (tif->tif_header.tiff_diroff == tif->tif_diroff)
{
tif->tif_header.tiff_diroff = 0;
tif->tif_diroff = 0;
TIFFSeekFile(tif, (toff_t)(TIFF_MAGIC_SIZE+TIFF_VERSION_SIZE),
SEEK_SET);
if (!WriteOK(tif, &(tif->tif_header.tiff_diroff),
sizeof (tif->tif_diroff)))
{
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error updating TIFF header");
return (0);
}
}
else
{
toff_t nextdir, off;
nextdir = tif->tif_header.tiff_diroff;
do {
uint16 dircount;
if (!SeekOK(tif, nextdir) ||
!ReadOK(tif, &dircount, sizeof (dircount))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error fetching directory count");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
(void) TIFFSeekFile(tif,
dircount * sizeof (TIFFDirEntry), SEEK_CUR);
if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error fetching directory link");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&nextdir);
} while (nextdir != tif->tif_diroff && nextdir != 0);
off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */
(void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET);
tif->tif_diroff = 0;
if (!WriteOK(tif, &(tif->tif_diroff), sizeof (nextdir))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error writing directory link");
return (0);
}
}
/*
** Now use TIFFWriteDirectory() normally.
*/
return TIFFWriteDirectory( tif );
}
/*
* Link the current directory into the directory chain for the file.
*/
static int
TIFFLinkDirectory(TIFF* tif)
{
static const char module[] = "TIFFLinkDirectory";
toff_t nextdir;
toff_t diroff, off;
tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
diroff = tif->tif_diroff;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&diroff);
/*
* Handle SubIFDs
*/
if (tif->tif_flags & TIFF_INSUBIFD) {
(void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Error writing SubIFD directory link",
tif->tif_name);
return (0);
}
/*
* Advance to the next SubIFD or, if this is
* the last one configured, revert back to the
* normal directory linkage.
*/
if (--tif->tif_nsubifd)
tif->tif_subifdoff += sizeof (diroff);
else
tif->tif_flags &= ~TIFF_INSUBIFD;
return (1);
}
if (tif->tif_header.tiff_diroff == 0) {
/*
* First directory, overwrite offset in header.
*/
tif->tif_header.tiff_diroff = tif->tif_diroff;
(void) TIFFSeekFile(tif,
(toff_t)(TIFF_MAGIC_SIZE+TIFF_VERSION_SIZE),
SEEK_SET);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing TIFF header");
return (0);
}
return (1);
}
/*
* Not the first directory, search to the last and append.
*/
nextdir = tif->tif_header.tiff_diroff;
do {
uint16 dircount;
if (!SeekOK(tif, nextdir) ||
!ReadOK(tif, &dircount, sizeof (dircount))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error fetching directory count");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
(void) TIFFSeekFile(tif,
dircount * sizeof (TIFFDirEntry), SEEK_CUR);
if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error fetching directory link");
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&nextdir);
} while (nextdir != 0);
off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */
(void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET);
if (!WriteOK(tif, &diroff, sizeof (diroff))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error writing directory link");
return (0);
}
return (1);
}
/*
* Append the data to the specified strip.
*/
static int
TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc)
{
TIFFDirectory *td = &tif->tif_dir;
static const char module[] = "TIFFAppendToStrip";
if (_TIFFGetOffset(tif, strip) == 0 || tif->tif_curoff == 0) {
/*
* No current offset, set the current strip.
*/
assert(td->td_nstrips > 0);
if (_TIFFGetOffset(tif, strip) != 0) {
/*
* Prevent overlapping of the data chunks. We need
* this to enable in place updating of the compressed
* images. Larger blocks will be moved at the end of
* the file without any optimization of the spare
* space, so such scheme is not too much effective.
*/
if (td->td_stripbytecountsorted) {
if (strip == td->td_nstrips - 1 ||
_TIFFGetOffset(tif, strip + 1) < _TIFFGetOffset(tif, strip) + cc) {
_TIFFSetOffset(tif, strip, TIFFSeekFile(tif, (toff_t)0, SEEK_END));
}
} else {
tstrip_t i;
for (i = 0; i < td->td_nstrips; i++) {
if (_TIFFGetOffset(tif, i) > _TIFFGetOffset(tif, strip) &&
_TIFFGetOffset(tif, i) < _TIFFGetOffset(tif, strip) + cc) {
_TIFFSetOffset(tif, strip, TIFFSeekFile(tif, (toff_t)0, SEEK_END));
break;
}
}
}
/* check if block will overlap offsets or bytes counts arrays */
if ((td->td_stripoffsoff &&
_TIFFGetOffset(tif, strip) < td->td_stripoffsoff &&
_TIFFGetOffset(tif, strip) + cc > td->td_stripoffsoff) ||
(td->td_stripbcsoff &&
_TIFFGetOffset(tif, strip) < td->td_stripbcsoff &&
_TIFFGetOffset(tif, strip) + cc > td->td_stripbcsoff))
_TIFFSetOffset(tif, strip, TIFFSeekFile(tif, (toff_t)0, SEEK_END));
if (!SeekOK(tif, _TIFFGetOffset(tif, strip))) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Seek error at scanline %lu",
tif->tif_name,
(unsigned long)tif->tif_row);
return (0);
}
} else
_TIFFSetOffset(tif, strip,
TIFFSeekFile(tif, (toff_t) 0, SEEK_END));
tif->tif_curoff = _TIFFGetOffset(tif, strip);
}
if (!WriteOK(tif, data, cc)) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Write error at scanline %lu (%d)",
tif->tif_name, (unsigned long) tif->tif_row, TIFFGetErrno(tif));
return (0);
}
tif->tif_curoff += cc;
_TIFFSetByteCount(tif, strip, _TIFFGetByteCount(tif, strip) + cc);
return (1);
}
/* This function will write an entire directory to the disk, and return the
offset value indicating where in the file it wrote the beginning of the
directory structure. This is NOT the same as the offset value before
calling this function, because some of the fields may have caused various
data items to be written out BEFORE writing the directory structure.
This code was basically written by ripping of the TIFFWriteDirectory()
code and generalizing it, using RPS's TIFFWritePliIfd() code for
inspiration. My original goal was to make this code general enough that
the original TIFFWriteDirectory() could be rewritten to just call this
function with the appropriate field and field-accessing arguments.
However, now I realize that there's a lot of code that gets executed for
the main, standard TIFF directories that does not apply to special
private subdirectories, so such a reimplementation for the sake of
eliminating redundant or duplicate code is probably not possible,
unless we also pass in a Main flag to indiciate which type of handling
to do, which would be kind of a hack. I've marked those places where I
changed or ripped out code which would have to be re-inserted to
generalize this function. If it can be done in a clean and graceful way,
it would be a great way to generalize the TIFF library. Otherwise, I'll
just leave this code here where it duplicates but remains on top of and
hopefully mostly independent of the main TIFF library.
The caller will probably want to free the sub directory structure after
returning from this call, since otherwise once written out, the user
is likely to forget about it and leave data lying around.
*/
toff_t
TIFFWritePrivateDataSubDirectory(TIFF* tif,
uint32 pdir_fieldsset[], int pdir_fields_last,
TIFFFieldInfo *field_info,
int (*getFieldFn)(TIFF *tif, ttag_t tag, ...))
{
uint16 dircount;
uint32 diroff, nextdiroff;
ttag_t tag;
uint32 nfields;
tsize_t dirsize;
char* data;
TIFFDirEntry* dir;
u_long b, *fields, fields_size;
toff_t directory_offset;
TIFFFieldInfo* fip;
/*
* Deleted out all of the encoder flushing and such code from here -
* not necessary for subdirectories.
*/
/* Finish writing out any image data. */
TIFFFlushData(tif);
/*
* Size the directory so that we can calculate
* offsets for the data items that aren't kept
* in-place in each field.
*/
nfields = 0;
for (b = 0; b <= pdir_fields_last; b++)
if (FieldSet(pdir_fieldsset, b))
/* Deleted code to make size of first 4 tags 2
instead of 1. */
nfields += 1;
dirsize = nfields * sizeof (TIFFDirEntry);
data = (char*) _TIFFmalloc(dirsize);
if (data == NULL) {
TIFFError(tif->tif_name,
"Cannot write private subdirectory, out of space");
return (0);
}
/*
* Place directory in data section of the file. If there isn't one
* yet, place it at the end of the file. The directory is treated as
* data, so we don't link it into the directory structure at all.
*/
if (tif->tif_dataoff == 0)
tif->tif_dataoff =(TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
diroff = tif->tif_dataoff;
tif->tif_dataoff = (toff_t)(
diroff + sizeof (uint16) + dirsize + sizeof (toff_t));
if (tif->tif_dataoff & 1)
tif->tif_dataoff++;
(void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
/*tif->tif_curdir++;*/
dir = (TIFFDirEntry*) data;
/*
* Setup external form of directory
* entries and write data items.
*/
/*
* We make a local copy of the fieldsset here so that we don't mess
* up the original one when we call ResetFieldBit(). But I'm not sure
* why the original code calls ResetFieldBit(), since we're already
* going through the fields in order...
*
* fields_size is the number of uint32's we will need to hold the
* bit-mask for all of the fields. If our highest field number is
* 100, then we'll need 100 / (8*4)+1 == 4 uint32's to hold the
* fieldset.
*
* Unlike the original code, we allocate fields dynamically based
* on the requested pdir_fields_last value, allowing private
* data subdirectories to contain more than the built-in code's limit
* of 95 tags in a directory.
*/
fields_size = pdir_fields_last / (8*sizeof(uint32)) + 1;
fields = _TIFFmalloc(fields_size*sizeof(uint32));
_TIFFmemcpy(fields, pdir_fieldsset, fields_size * sizeof(uint32));
/* Deleted "write out extra samples tag" code here. */
/* Deleted code for checking a billion little special cases for the
* standard TIFF tags. Should add a general mechanism for overloading
* write function for each field, just like Brian kept telling me!!!
*/
for (fip = field_info; fip->field_tag; fip++) {
/* Deleted code to check for FIELD_IGNORE!! */
if (/* fip->field_bit == FIELD_IGNORE || */
!FieldSet(fields, fip->field_bit))
continue;
if (!TIFFWriteNormalSubTag(tif, dir, fip, getFieldFn))
goto bad;
dir++;
ResetFieldBit(fields, fip->field_bit);
}
/* Now we've written all of the referenced data, and are about to
write the main directory structure, so grab the tif_dataoff value
now so we can remember where we wrote the directory. */
directory_offset = tif->tif_dataoff;
/*
* Write directory.
*/
dircount = (uint16) nfields;
/* Deleted code to link to the next directory - we set it to zero! */
nextdiroff = 0;
if (tif->tif_flags & TIFF_SWAB) {
/*
* The file's byte order is opposite to the
* native machine architecture. We overwrite
* the directory information with impunity
* because it'll be released below after we
* write it to the file. Note that all the
* other tag construction routines assume that
* we do this byte-swapping; i.e. they only
* byte-swap indirect data.
*/
for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {
TIFFSwabArrayOfShort(&dir->tdir_tag, 2);
TIFFSwabArrayOfLong(&dir->tdir_count, 2);
}
dircount = (uint16) nfields;
TIFFSwabShort(&dircount);
TIFFSwabLong(&nextdiroff);
}
(void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
if (!WriteOK(tif, &dircount, sizeof (dircount))) {
TIFFError(tif->tif_name, "Error writing private subdirectory count");
goto bad;
}
if (!WriteOK(tif, data, dirsize)) {
TIFFError(tif->tif_name, "Error writing private subdirectory contents");
goto bad;
}
if (!WriteOK(tif, &nextdiroff, sizeof (nextdiroff))) {
TIFFError(tif->tif_name, "Error writing private subdirectory link");
goto bad;
}
tif->tif_dataoff += sizeof(dircount) + dirsize + sizeof(nextdiroff);
_TIFFfree(data);
_TIFFfree(fields);
tif->tif_flags &= ~TIFF_DIRTYDIRECT;
#if (0)
/* This stuff commented out because I don't think we want it for
subdirectories, but I could be wrong. */
(*tif->tif_cleanup)(tif);
/*
* Reset directory-related state for subsequent
* directories.
*/
TIFFDefaultDirectory(tif);
tif->tif_curoff = 0;
tif->tif_row = (uint32) -1;
tif->tif_curstrip = (tstrip_t) -1;
#endif
return (directory_offset);
bad:
_TIFFfree(data);
_TIFFfree(fields);
return (0);
}
/*
* Write the contents of the current directory
* to the specified file. This routine doesn't
* handle overwriting a directory with auxiliary
* storage that's been changed.
*/
static int
_TIFFWriteDirectory(TIFF* tif, int done)
{
uint64 dircount; /* 16-bit or 64-bit directory entry count */
toff_t diroff; /* 32-bit or 64-bit directory offset */
ttag_t tag;
uint32 nfields;
tsize_t dirsize;
char* data;
TIFFDirEntry* dir;
TIFFDirectory* td;
unsigned long b, fields[FIELD_SETLONGS];
int fi, nfi;
if (tif->tif_mode == O_RDONLY)
return (1);
/*
* Clear write state so that subsequent images with
* different characteristics get the right buffers
* setup for them.
*/
if (done)
{
if (tif->tif_flags & TIFF_POSTENCODE) {
tif->tif_flags &= ~TIFF_POSTENCODE;
if (!(*tif->tif_postencode)(tif)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error post-encoding before directory write");
return (0);
}
}
(*tif->tif_close)(tif); /* shutdown encoder */
/*
* Flush any data that might have been written
* by the compression close+cleanup routines.
*/
if (tif->tif_rawcc > 0 && !TIFFFlushData1(tif)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error flushing data before directory write");
return (0);
}
if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
_TIFFfree(tif->tif_rawdata);
tif->tif_rawdata = NULL;
tif->tif_rawcc = 0;
tif->tif_rawdatasize = 0;
}
tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);
}
/*
* Loop to allow retry in case transition to BigTIFF required
*/
while (1) {
/*
* Directory hasn't been placed yet, put
* it at the end of the file and link it
* into the existing directory structure.
*/
if (tif->tif_diroff == 0 && !TIFFLinkDirectory(tif))
goto bad2;
td = &tif->tif_dir;
/*
* Size the directory so that we can calculate
* offsets for the data items that aren't kept
* in-place in each field.
*/
nfields = 0;
for (b = 0; b <= FIELD_LAST; b++)
if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)
nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
nfields += td->td_customValueCount;
dirsize = nfields * TDIREntryLen(tif);
data = (char*) _TIFFmalloc(dirsize);
if (data == NULL) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Cannot write directory, out of space");
goto bad2;
}
_TIFFmemset(data, 0, dirsize);
/*
* Setup external form of directory
* entries and write data items.
*/
_TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));
/*
* Write out ExtraSamples tag only if
* extra samples are present in the data.
*/
if (FieldSet(fields, FIELD_EXTRASAMPLES) && !td->td_extrasamples) {
ResetFieldBit(fields, FIELD_EXTRASAMPLES);
nfields--;
dirsize -= TDIREntryLen(tif);
} /*XXX*/
tif->tif_dataoff = tif->tif_diroff + TIFFDirCntLen(tif) + dirsize + TIFFDirOffLen(tif);
(void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
dir = (TIFFDirEntry*) data;
for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
/*
** For custom fields, we test to see if the custom field
** is set or not. For normal fields, we just use the
** FieldSet test.
*/
if( fip->field_bit == FIELD_CUSTOM )
{
int ci, is_set = FALSE;
for( ci = 0; ci < td->td_customValueCount; ci++ )
is_set |= (td->td_customValues[ci].info == fip);
if( !is_set )
continue;
}
else if (!FieldSet(fields, fip->field_bit))
continue;
/*
** Handle other fields.
*/
switch (fip->field_bit)
{
case FIELD_STRIPOFFSETS:
/*
* We use one field bit for both strip and tile
* offsets, and so must be careful in selecting
* the appropriate field descriptor (so that tags
* are written in sorted order).
*/
tag = (isTiled(tif) ? TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS);
if (tag != fip->field_tag)
continue;
dir->s.tdir_tag = (uint16) tag;
TDIRSetEntryCount(tif,dir, (uint32) td->td_nstrips);
/*
* If file is BigTIFF strip/tile offsets are written as 64-bit,
* else convert to array of 32-bit offsets.
*/
if (isBigTIFF(tif)) {
dir->s.tdir_type = (uint16) TIFF_LONG8;
if (!TIFFWriteLong8Array(tif, dir, td->td_stripoffset))
goto bad;
} else {
uint32 tdi;
int status;
uint32 *soff = _TIFFCheckMalloc(tif, td->td_nstrips,
sizeof(uint32), "32-bit offset array");
dir->s.tdir_type = (uint16) TIFF_LONG;
for (tdi = 0; tdi < td->td_nstrips; tdi++)
soff[tdi] = (uint32) td->td_stripoffset[tdi];
status = TIFFWriteLongArray(tif, dir, soff);
_TIFFfree(soff);
if (!status)
goto bad;
}
break;
case FIELD_STRIPBYTECOUNTS:
/*
* We use one field bit for both strip and tile
* byte counts, and so must be careful in selecting
* the appropriate field descriptor (so that tags
* are written in sorted order).
*/
tag = (isTiled(tif) ? TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS);
if (tag != fip->field_tag)
continue;
dir->s.tdir_tag = (uint16) tag;
dir->s.tdir_type = (uint16) TIFF_LONG;
TDIRSetEntryCount(tif,dir, (uint32) td->td_nstrips);
if (!TIFFWriteLongArray(tif, dir, td->td_stripbytecount))
goto bad;
break;
case FIELD_ROWSPERSTRIP:
TIFFSetupShortLong(tif, TIFFTAG_ROWSPERSTRIP,
dir, td->td_rowsperstrip);
break;
case FIELD_COLORMAP:
if (!TIFFWriteShortTable(tif, TIFFTAG_COLORMAP, dir,
3, td->td_colormap))
goto bad;
break;
case FIELD_IMAGEDIMENSIONS:
TIFFSetupShortLong(tif, TIFFTAG_IMAGEWIDTH,
dir, td->td_imagewidth);
TDIREntryNext(tif,dir);
TIFFSetupShortLong(tif, TIFFTAG_IMAGELENGTH,
dir, td->td_imagelength);
break;
case FIELD_TILEDIMENSIONS:
TIFFSetupShortLong(tif, TIFFTAG_TILEWIDTH,
dir, td->td_tilewidth);
TDIREntryNext(tif,dir);
TIFFSetupShortLong(tif, TIFFTAG_TILELENGTH,
dir, td->td_tilelength);
break;
case FIELD_COMPRESSION:
TIFFSetupShort(tif, TIFFTAG_COMPRESSION,
dir, td->td_compression);
break;
case FIELD_PHOTOMETRIC:
TIFFSetupShort(tif, TIFFTAG_PHOTOMETRIC,
dir, td->td_photometric);
break;
case FIELD_POSITION:
WriteRationalPair(TIFF_RATIONAL,
TIFFTAG_XPOSITION, td->td_xposition,
TIFFTAG_YPOSITION, td->td_yposition);
break;
case FIELD_RESOLUTION:
WriteRationalPair(TIFF_RATIONAL,
TIFFTAG_XRESOLUTION, td->td_xresolution,
TIFFTAG_YRESOLUTION, td->td_yresolution);
break;
case FIELD_BITSPERSAMPLE:
case FIELD_MINSAMPLEVALUE:
case FIELD_MAXSAMPLEVALUE:
case FIELD_SAMPLEFORMAT:
if (!TIFFWritePerSampleShorts(tif, fip->field_tag, dir))
goto bad;
break;
case FIELD_SMINSAMPLEVALUE:
case FIELD_SMAXSAMPLEVALUE:
if (!TIFFWritePerSampleAnys(tif,
_TIFFSampleToTagType(tif), fip->field_tag, dir))
goto bad;
break;
case FIELD_PAGENUMBER:
case FIELD_HALFTONEHINTS:
case FIELD_YCBCRSUBSAMPLING:
if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
goto bad;
break;
case FIELD_INKNAMES:
if (!TIFFWriteInkNames(tif, dir))
goto bad;
break;
case FIELD_TRANSFERFUNCTION:
if (!TIFFWriteTransferFunction(tif, dir))
goto bad;
break;
case FIELD_SUBIFD:
/*
* Total hack: if this directory includes a SubIFD
* tag then force the next <n> directories to be
* written as ``sub directories'' of this one. This
* is used to write things like thumbnails and
* image masks that one wants to keep out of the
* normal directory linkage access mechanism.
*
* If file is BigTIFF subdirectory offsets are written as 64-bit,
* else as array of 32-bit offsets. At this point the actual
* offset values are unknown (will be set in TIFFLinkDirectory).
*/
dir->s.tdir_tag = (uint16) fip->field_tag;
TDIRSetEntryCount(tif,dir, (uint32) td->td_nsubifd);
TDIRSetEntryOff(tif,dir, 0);
if (td->td_nsubifd > 0) {
tif->tif_flags |= TIFF_INSUBIFD;
if (isBigTIFF(tif)) {
toff_t *doff = _TIFFCheckMalloc(tif, td->td_nsubifd, sizeof(toff_t),
"Allocate SubIFD offset array");
if (!doff)
goto bad;
_TIFFmemset(doff, 0, td->td_nsubifd * sizeof(toff_t));
dir->b.tdir_type = TIFF_IFD8;
if (td->td_nsubifd > TIFFDirOffLen(tif) / sizeof(toff_t))
tif->tif_subifdoff = tif->tif_dataoff;
else
tif->tif_subifdoff = tif->tif_diroff + TIFFDirCntLen(tif) +
(char*) &dir->b.tdir_offset - data;
if (!TIFFWriteLong8Array(tif, dir, (toff_t*) doff))
goto bad;
_TIFFfree(doff);
} else {
uint32 *doff = _TIFFCheckMalloc(tif, td->td_nsubifd, sizeof(uint32),
"Allocate SubIFD offset array");
if (!doff)
goto bad;
_TIFFmemset(doff, 0, td->td_nsubifd * sizeof(uint32));
dir->b.tdir_type = TIFF_LONG;
if (td->td_nsubifd > TIFFDirOffLen(tif) / sizeof(uint32))
tif->tif_subifdoff = tif->tif_dataoff;
else
tif->tif_subifdoff = tif->tif_diroff + TIFFDirCntLen(tif) +
(char*) &dir->s.tdir_offset - data;
if (!TIFFWriteLongArray(tif, dir, doff))
goto bad;
_TIFFfree(doff);
}
}
break;
default:
/* XXX: Should be fixed and removed. */
if (fip->field_tag == TIFFTAG_DOTRANGE) {
if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
goto bad;
}
else if (!TIFFWriteNormalTag(tif, dir, fip))
goto bad;
break;
}
TDIREntryNext(tif,dir);
if( fip->field_bit != FIELD_CUSTOM )
ResetFieldBit(fields, fip->field_bit);
}
/*
* Check if BigTIFF now required based on data location. If so reset
* data offset to overwrite already-written data for directory, then
* convert file to BigTIFF and loop to recreate directory.
*/
if (isBigTIFF(tif) || !isBigOff(tif->tif_dataoff + sizeof(uint32)))
break;
_TIFFfree(data);
tif->tif_dataoff = tif->tif_diroff;
if (!TIFFMakeBigTIFF(tif))
goto bad2;
tif->tif_diroff = 0;
} /* bottom of BigTIFF retry loop */
/*
* Write directory.
*/
tif->tif_curdir++;
TIFFSetDirCnt(tif,dircount, (uint32) nfields);
TIFFSetDirOff(tif,diroff,tif->tif_nextdiroff);
if (tif->tif_flags & TIFF_SWAB) {
/*
* The file's byte order is opposite to the
* native machine architecture. We overwrite
* the directory information with impunity
* because it'll be released below after we
* write it to the file. Note that all the
* other tag construction routines assume that
* we do this byte-swapping; i.e. they only
* byte-swap indirect data.
*/
uint32 di;
for (dir = (TIFFDirEntry*) data, di = 0; di < nfields; TDIREntryNext(tif,dir), di++) {
TIFFSwabShort(&dir->s.tdir_tag);
TIFFSwabShort(&dir->s.tdir_type);
TDIRSwabEntryCount(tif,dir);
TDIRSwabEntryOff(tif,dir);
}
TIFFSwabDirCnt(tif,&dircount);
TIFFSwabDirOff(tif,&diroff);
}
(void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
if (!WriteOK(tif, &dircount, TIFFDirCntLen(tif))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing directory count (%d)", TIFFGetErrno(tif));
goto bad;
}
if (!WriteOK(tif, data, dirsize)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing directory contents (%d)", TIFFGetErrno(tif));
goto bad;
}
if (!WriteOK(tif, &diroff, TIFFDirOffLen(tif))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing directory link (%d)", TIFFGetErrno(tif));
goto bad;
}
if (done) {
TIFFFreeDirectory(tif);
tif->tif_flags &= ~TIFF_DIRTYDIRECT;
(*tif->tif_cleanup)(tif);
/*
* Reset directory-related state for subsequent
* directories.
*/
TIFFCreateDirectory(tif);
}
_TIFFfree(data);
return (1);
bad:
_TIFFfree(data);
bad2:
return (0);
}
/*
* Function to convert standard TIFF file to BigTIFF file. Loop through all directories in
* current file (including subdirectories linked via SubIFD arrays) and create corresponding
* new directories with 64-bit arrays. The old 32-bit directories are left in the file as
* dead space. The data for directory entries are reused by default. Some directory entries
* require new data with 64-bit offsets (e.g. stripe/tile offsets and SubIFD arrays).
*
* Returns 1 if successful, 0 if cannot convert to BigTIFF (TIFF_NOBIGTIFF set
* or 32-bit API called).
*/
static int
TIFFMakeBigTIFF(TIFF *tif)
{
uint32 dirlink = TIFF_HEADER_DIROFF_S,
diroff = tif->tif_header.s.tiff_diroff;
toff_t dirlinkB = TIFF_HEADER_DIROFF_B,
diroffB;
uint16 dircount, dirindex;
uint64 dircountB;
tsize_t dirsize, dirsizeB;
int issubifd = 0;
uint32 subifdcnt = 0;
uint32 subifdlink;
toff_t subifdlinkB;
char *data, *dataB;
TIFFDirEntry *dir, *dirB;
/*
* Update flags and file header
*/
if (noBigTIFF(tif)) {
TIFFErrorExt((tif)->tif_clientdata,
"TIFFCheckBigTIFF", "File > 2^32 and NO BigTIFF specified");
return (0);
}
tif->tif_flags |= TIFF_ISBIGTIFF;
tif->tif_header.b.tiff_version = TIFF_BIGTIFF_VERSION;
tif->tif_header.b.tiff_offsize = 8;
tif->tif_header.b.tiff_fill = 0;
tif->tif_header.b.tiff_diroff = 0;
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabShort(&tif->tif_header.b.tiff_version);
TIFFSwabShort(&tif->tif_header.b.tiff_offsize);
}
if (!SeekOK(tif, 0) ||
!WriteOK(tif, &tif->tif_header, sizeof(TIFFHeader))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error updating TIFF header (%d)", TIFFGetErrno(tif));
return (0);
}
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabShort(&tif->tif_header.b.tiff_version);
TIFFSwabShort(&tif->tif_header.b.tiff_offsize);
}
/*
* Loop through all directories and rewrite as BigTIFF with 64-bit offsets. This
* begins with main IFD chain but may divert to SubIFD arrays as needed.
*/
while (diroff != 0 && diroff != tif->tif_diroff) {
if (!SeekOK(tif, diroff) ||
!ReadOK(tif, &dircount, sizeof(dircount))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error reading TIFF directory (%d)", TIFFGetErrno(tif));
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
dircountB = dircount;
if (!(data = _TIFFmalloc(dirsize = dircount * TIFFDirEntryLenS)) ||
!(dataB = _TIFFmalloc(dirsizeB = dircount * TIFFDirEntryLenB))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error allocating space for directory");
return (0);
}
if (!SeekOK(tif, diroff + sizeof(dircount)) ||
!ReadOK(tif, data, dirsize)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error reading TIFF directory (%d)", TIFFGetErrno(tif));
goto error;
}
diroffB = tif->tif_dataoff;
tif->tif_dataoff += sizeof(dircountB) + dirsizeB + sizeof(toff_t);
for (dirindex = 0; dirindex < dircount; dirindex++) {
dir = (TIFFDirEntry*) (data + dirindex * TIFFDirEntryLenS);
dirB = (TIFFDirEntry*) (dataB + dirindex * TIFFDirEntryLenB);
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabShort(&dir->s.tdir_tag);
TIFFSwabShort(&dir->s.tdir_type);
TIFFSwabLong(&dir->s.tdir_count);
TIFFSwabLong(&dir->s.tdir_offset);
}
dirB->b.tdir_tag = dir->s.tdir_tag;
dirB->b.tdir_type = dir->s.tdir_type;
dirB->b.tdir_count = dir->s.tdir_count;
dirB->b.tdir_offset = 0;
/*
* If data are in directory entry itself, copy data, else (data are pointed
* to by directory entry) copy pointer. This is complicated by the fact that
* the old entry had 32-bits of space, and the new has 64-bits, so may have
* to read data pointed at by the old entry directly into the new entry.
*/
switch (dir->s.tdir_type) {
case TIFF_UNDEFINED:
case TIFF_BYTE:
case TIFF_SBYTE:
case TIFF_ASCII:
if (dir->s.tdir_count <= sizeof(dir->s.tdir_offset))
_TIFFmemcpy(&dirB->b.tdir_offset, &dir->s.tdir_offset, dir->s.tdir_count);
else if (dir->s.tdir_count <= sizeof(dirB->b.tdir_count)) {
TIFFSeekFile(tif, dir->s.tdir_offset, SEEK_SET);
TIFFReadFile(tif, &dirB->b.tdir_offset, dir->s.tdir_count);
} else
dirB->b.tdir_offset = dir->s.tdir_offset;
break;
case TIFF_SHORT:
case TIFF_SSHORT:
if (dir->s.tdir_count <= sizeof(dir->s.tdir_offset) / sizeof(uint16))
_TIFFmemcpy(&dirB->b.tdir_offset, &dir->s.tdir_offset, dir->s.tdir_count * sizeof(uint16));
else if (dir->s.tdir_count <= sizeof(dirB->b.tdir_count) / sizeof(uint16)) {
TIFFSeekFile(tif, dir->s.tdir_offset, SEEK_SET);
TIFFReadFile(tif, &dirB->b.tdir_offset, dir->s.tdir_count * sizeof(uint16));
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfShort((uint16*) &dirB->b.tdir_offset, dir->s.tdir_count);
} else
dirB->b.tdir_offset = dir->s.tdir_offset;
break;
case TIFF_LONG:
case TIFF_FLOAT:
case TIFF_IFD:
if (dir->s.tdir_count <= sizeof(dir->s.tdir_offset) / sizeof(uint32))
_TIFFmemcpy(&dirB->b.tdir_offset, &dir->s.tdir_offset, dir->s.tdir_count * sizeof(uint32));
else if (dir->s.tdir_count <= sizeof(dirB->b.tdir_count) / sizeof(uint32)) {
TIFFSeekFile(tif, dir->s.tdir_offset, SEEK_SET);
TIFFReadFile(tif, &dirB->b.tdir_offset, dir->s.tdir_count * sizeof(uint32));
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong((uint32*) &dirB->b.tdir_offset, dir->s.tdir_count);
} else
dirB->b.tdir_offset = dir->s.tdir_offset;
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
if (dir->s.tdir_count * 2 <= sizeof(dirB->b.tdir_offset) / sizeof(uint32)) {
TIFFSeekFile(tif, dir->s.tdir_offset, SEEK_SET);
TIFFReadFile(tif, &dirB->b.tdir_offset, dir->s.tdir_count * 2 * sizeof(uint32));
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong((uint32*) &dirB->b.tdir_offset, dir->s.tdir_count * 2);
} else
dirB->b.tdir_offset = dir->s.tdir_offset;
break;
default:
dirB->b.tdir_offset = dir->s.tdir_offset;
break;
}
/*
* Process special case of SUBIFD; must change data from 32-bit to 64-bit in
* case new 64-bit directory offsets need to be added.
*/
switch (dirB->b.tdir_tag) {
case TIFFTAG_SUBIFD:
dirB->b.tdir_type = TIFF_IFD8;
subifdcnt = dir->s.tdir_count;
/*
* Set pointer to existing SubIFD array
*/
if (subifdcnt <= sizeof(dir->s.tdir_offset) / sizeof(uint32))
subifdlink = diroff + sizeof(dircount) +
(char*) &dir->s.tdir_offset - (char*) dir;
else
subifdlink = dir->s.tdir_offset;
/*
* Initialize new SubIFD array, set pointer to it
*/
if (subifdcnt <= sizeof(dir->b.tdir_offset) / sizeof(toff_t)) {
dir->b.tdir_offset = 0;
subifdlinkB = diroffB + sizeof(dircountB) +
(char*) &dir->b.tdir_offset - (char*) dirB;
} else {
toff_t *offB;
if (!(offB = _TIFFmalloc(subifdcnt * sizeof(toff_t)))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error allocating space for 64-bit SubIFDs");
goto error;
}
_TIFFmemset(offB, 0, subifdcnt * sizeof(toff_t));
TIFFWriteLong8Array(tif, dirB, offB);
_TIFFfree(offB);
subifdlinkB = dirB->b.tdir_offset;
}
break;
}
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabShort(&dirB->b.tdir_tag);
TIFFSwabShort(&dirB->b.tdir_type);
TIFFSwabLong8(&dirB->b.tdir_count);
TIFFSwabLong8(&dirB->b.tdir_offset);
}
}
/*
* Write out new directory and chain to previous
*/
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong8(&dircountB);
if (!SeekOK(tif, diroffB) ||
!WriteOK(tif, &dircountB, sizeof(dircountB)) ||
!SeekOK(tif, diroffB + sizeof(dircountB)) ||
!WriteOK(tif, dataB, dirsizeB)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing TIFF directory (%d)", TIFFGetErrno(tif));
goto error;
}
/*
* If directory is SubIFD update array in host directory, else add to
* main directory chain
*/
if (tif->tif_nsubifd &&
tif->tif_subifdoff == subifdlink)
tif->tif_subifdoff = subifdlinkB;
if (!issubifd &&
dirlinkB == TIFF_HEADER_DIROFF_B)
tif->tif_header.b.tiff_diroff = diroffB;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong8(&diroffB);
if (!SeekOK(tif, (issubifd ? subifdlinkB++ : dirlinkB)) ||
!WriteOK(tif, &diroffB, sizeof(diroffB))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing directory link (%d)", TIFFGetErrno(tif));
goto error;
}
if (issubifd)
subifdcnt--;
else {
dirlink = diroff + sizeof(dircount) + dirsize;
dirlinkB = diroffB + sizeof(dircountB) + dirsizeB;
}
issubifd = (subifdcnt > 0);
if (!SeekOK(tif, (issubifd ? subifdlink++ : dirlink)) ||
!ReadOK(tif, &diroff, sizeof(diroff))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error reading directory link (%d)", TIFFGetErrno(tif));
goto error;
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&diroff);
_TIFFfree(dataB);
_TIFFfree(data);
}
/*
* Mark end of directory chain
*/
diroffB = 0;
if (dirlinkB == TIFF_HEADER_DIROFF_B)
tif->tif_header.b.tiff_diroff = diroffB;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong8(&diroffB);
if (!SeekOK(tif, dirlinkB) ||
!WriteOK(tif, &diroffB, sizeof(diroffB))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing directory link (%d)", TIFFGetErrno(tif));
goto error;
}
return (1);
error:
_TIFFfree(dataB);
_TIFFfree(data);
return (0);
}
/*
* Link the current directory into the
* directory chain for the file.
*/
static int
TIFFLinkDirectory(TIFF* tif)
{
static const char module[] = "TIFFLinkDirectory";
toff_t currdir, nextdir;
toff_t diroff, nextdiroff; /* 32-bit or 64-bit dir offsets */
/*
* New directory will go at end of file; if file not BigTIFF and
* size is beyond 2^32, convert to BigTIFF now.
*/
tif->tif_diroff = ((TIFFSeekFile(tif, 0, SEEK_END) + 1) & ~(toff_t) 1);
if (!isBigTIFF(tif) && isBigOff(tif->tif_diroff)) {
if (!TIFFMakeBigTIFF(tif))
return (0);
tif->tif_diroff = ((TIFFSeekFile(tif, 0, SEEK_END) + 1) & ~(toff_t) 1);
}
TIFFSetDirOff(tif,diroff,tif->tif_diroff);
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabDirOff(tif,&diroff);
/*
* Handle SubIFDs
*/
if (tif->tif_flags & TIFF_INSUBIFD) {
(void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
if (!WriteOK(tif, &diroff, TIFFDirOffLen(tif))) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Error writing SubIFD directory link (%d)",
tif->tif_name, TIFFGetErrno(tif));
return (0);
}
/*
* Advance to the next SubIFD or, if this is
* the last one configured, revert back to the
* normal directory linkage.
*/
if (--tif->tif_nsubifd)
tif->tif_subifdoff += TIFFDirOffLen(tif);
else
tif->tif_flags &= ~TIFF_INSUBIFD;
return (1);
}
/*
* First directory, overwrite offset in header.
*/
nextdir = TIFFGetHdrDirOff(tif,tif->tif_header);
if (nextdir == 0) {
TIFFSetHdrDirOff(tif,tif->tif_header, tif->tif_diroff);
if (!SeekOK(tif, 0) ||
!WriteOK(tif, &tif->tif_header, sizeof(TIFFHeader)) ) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error writing TIFF header (%d)", TIFFGetErrno(tif));
return (0);
}
return (1);
}
/*
* Not the first directory, search to the last and append.
*/
do {
uint64 dircount; /* 16-bit or 64-bit directory count */
if (!SeekOK(tif, nextdir) ||
!ReadOK(tif, &dircount, TIFFDirCntLen(tif))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error fetching directory count (%d)", TIFFGetErrno(tif));
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabDirCnt(tif,&dircount);
currdir = nextdir + TIFFDirCntLen(tif) + TIFFGetDirCnt(tif,dircount) * TDIREntryLen(tif);
TIFFSeekFile(tif, currdir, SEEK_SET);
if (!ReadOK(tif, &nextdiroff, TIFFDirOffLen(tif)) ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error fetching directory link (%d)", TIFFGetErrno(tif));
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabDirOff(tif,&nextdiroff);
nextdir = TIFFGetDirOff(tif,nextdiroff);
} while (nextdir != 0);
TIFFSeekFile(tif, currdir, SEEK_SET);
if (!WriteOK(tif, &diroff, TIFFDirOffLen(tif)) ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error writing directory link (%d)", TIFFGetErrno(tif));
return (0);
}
return (1);
}
/*
* Similar to TIFFWriteDirectory(), but if the directory has already
* been written once, it is relocated to the end of the file, in case it
* has changed in size. Note that this will result in the loss of the
* previously used directory space.
*/
int
TIFFRewriteDirectory( TIFF *tif )
{
static const char module[] = "TIFFRewriteDirectory";
/* We don't need to do anything special if it hasn't been written. */
if( tif->tif_diroff == 0 )
return TIFFWriteDirectory( tif );
/*
** Find and zero the pointer to this directory, so that TIFFLinkDirectory
** will cause it to be added after this directories current pre-link.
*/
/* Is it the first directory in the file? */
if (TIFFGetHdrDirOff(tif,tif->tif_header) == tif->tif_diroff)
{
TIFFSetHdrDirOff(tif,tif->tif_header,0);
tif->tif_diroff = 0;
if (!SeekOK(tif, 0) ||
!WriteOK(tif, &tif->tif_header, sizeof(TIFFHeader))) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Error updating TIFF header (%d)", TIFFGetErrno(tif));
return (0);
}
}
else
{
toff_t nextdir, off;
toff_t nextdiroff; /* 32-bit or 64-bit directory offset */
nextdir = TIFFGetHdrDirOff(tif,tif->tif_header);
do {
uint16 dircount;
if (!SeekOK(tif, nextdir) ||
!ReadOK(tif, &dircount, sizeof (dircount))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error fetching directory count (%d)", TIFFGetErrno(tif));
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
(void) TIFFSeekFile(tif, TIFFGetDirCnt(tif,dircount) * TDIREntryLen(tif), SEEK_CUR);
if (!ReadOK(tif, &nextdiroff, TIFFDirOffLen(tif))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error fetching directory link (%d)", TIFFGetErrno(tif));
return (0);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabDirOff(tif,&nextdiroff);
nextdir = TIFFGetDirOff(tif,nextdiroff);
} while (nextdir != tif->tif_diroff && nextdir != 0);
off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */
(void) TIFFSeekFile(tif, off - TIFFDirOffLen(tif), SEEK_SET);
tif->tif_diroff = 0;
if (!WriteOK(tif, &(tif->tif_diroff), TIFFDirOffLen(tif))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error writing directory link (%d)", TIFFGetErrno(tif));
return (0);
}
}
/*
** Now use TIFFWriteDirectory() normally.
*/
return TIFFWriteDirectory( tif );
}
TIFF*
TIFFClientOpen(
tdata_t lib,
const char* name, const char* mode,
thandle_t clientdata,
TIFFReadWriteProc readproc,
TIFFReadWriteProc writeproc,
TIFFSeekProc seekproc,
TIFFSizeProc sizeproc,
TIFFCloseProc closeproc,
TIFFMallocProc mallocproc,
TIFFReallocProc reallocproc,
TIFFFreeProc freeproc
)
{
static const char module[] = "TIFFClientOpen";
TIFF *tif, tmp, *t;
int m, bigendian;
const char* cp;
m = _TIFFgetMode(mode, module);
if (m == -1)
goto bad2;
if ( mallocproc ){
tmp.lib = lib;
tmp.tif_mallocproc = mallocproc;
t = &tmp;
tif = (TIFF *)TIFFMalloc ( t, sizeof (TIFF) + strlen(name) + 1 );
} else {
tif = (TIFF *)_TIFFmallocA(sizeof (TIFF) + strlen(name) + 1);
}
if (tif == NULL) {
TIFFError(module, "%s: Out of memory (TIFF structure)", name);
goto bad2;
}
_TIFFmemset(tif, 0, sizeof (*tif));
tif->tif_name = (char *)tif + sizeof (TIFF);
strcpy(tif->tif_name, name);
tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
tif->tif_curdir = (tdir_t) -1; /* non-existent directory */
tif->tif_curoff = 0;
tif->tif_curstrip = (tstrip_t) -1; /* invalid strip */
tif->tif_row = (uint32) -1; /* read/write pre-increment */
tif->tif_clientdata = clientdata;
tif->tif_readproc = readproc;
tif->tif_writeproc = writeproc;
tif->tif_seekproc = seekproc;
tif->tif_sizeproc = sizeproc;
tif->tif_closeproc = closeproc;
tif->tif_mallocproc = mallocproc;
tif->tif_reallocproc = reallocproc;
tif->tif_freeproc = freeproc;
tif->lib = lib;
_TIFFSetDefaultCompressionState(tif); /* setup default state */
/*
* Default is to return data MSB2LSB and enable the
* use of memory-mapped files and strip chopping when
* a file is opened read-only.
*/
tif->tif_flags = FILLORDER_MSB2LSB;
if (m == O_RDONLY )
tif->tif_flags |= TIFF_MAPPED;
#ifdef STRIPCHOP_DEFAULT
if (m == O_RDONLY || m == O_RDWR)
tif->tif_flags |= STRIPCHOP_DEFAULT;
#endif
{ union { int32 i; char c[4]; } u; u.i = 1; bigendian = u.c[0] == 0; }
/*
* Process library-specific flags in the open mode string.
* The following flags may be used to control intrinsic library
* behaviour that may or may not be desirable (usually for
* compatibility with some application that claims to support
* TIFF but only supports some braindead idea of what the
* vendor thinks TIFF is):
*
* 'l' use little-endian byte order for creating a file
* 'b' use big-endian byte order for creating a file
* 'L' read/write information using LSB2MSB bit order
* 'B' read/write information using MSB2LSB bit order
* 'H' read/write information using host bit order
* 'M' enable use of memory-mapped files when supported
* 'm' disable use of memory-mapped files
* 'C' enable strip chopping support when reading
* 'c' disable strip chopping support
*
* The use of the 'l' and 'b' flags is strongly discouraged.
* These flags are provided solely because numerous vendors,
* typically on the PC, do not correctly support TIFF; they
* only support the Intel little-endian byte order. This
* support is not configured by default because it supports
* the violation of the TIFF spec that says that readers *MUST*
* support both byte orders. It is strongly recommended that
* you not use this feature except to deal with busted apps
* that write invalid TIFF. And even in those cases you should
* bang on the vendors to fix their software.
*
* The 'L', 'B', and 'H' flags are intended for applications
* that can optimize operations on data by using a particular
* bit order. By default the library returns data in MSB2LSB
* bit order for compatibiltiy with older versions of this
* library. Returning data in the bit order of the native cpu
* makes the most sense but also requires applications to check
* the value of the FillOrder tag; something they probabyl do
* not do right now.
*
* The 'M' and 'm' flags are provided because some virtual memory
* systems exhibit poor behaviour when large images are mapped.
* These options permit clients to control the use of memory-mapped
* files on a per-file basis.
*
* The 'C' and 'c' flags are provided because the library support
* for chopping up large strips into multiple smaller strips is not
* application-transparent and as such can cause problems. The 'c'
* option permits applications that only want to look at the tags,
* for example, to get the unadulterated TIFF tag information.
*/
for (cp = mode; *cp; cp++)
switch (*cp) {
case 'b':
if ((m&O_CREAT) && !bigendian)
tif->tif_flags |= TIFF_SWAB;
break;
case 'l':
if ((m&O_CREAT) && bigendian)
tif->tif_flags |= TIFF_SWAB;
break;
case 'B':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_MSB2LSB;
break;
case 'L':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_LSB2MSB;
break;
case 'H':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
HOST_FILLORDER;
break;
case 'M':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_MAPPED;
break;
case 'm':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_MAPPED;
break;
case 'C':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_STRIPCHOP;
break;
case 'c':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_STRIPCHOP;
break;
}
/*
* Read in TIFF header.
*/
tif->tif_flags &= ~TIFF_MAPPED;
if (!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
if (tif->tif_mode == O_RDONLY) {
TIFFError(name, "Cannot read TIFF header");
goto bad;
}
/*
* Setup header and write.
*/
tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
? (bigendian ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN)
: (bigendian ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN);
tif->tif_header.tiff_version = TIFF_VERSION;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&tif->tif_header.tiff_version);
tif->tif_header.tiff_diroff = 0; /* filled in later */
/*
* This seek shouldn't be necessary, but I have had some
* crazy problems with a failed fseek() on Solaris leaving
* the current file pointer out of whack when an fwrite()
* is done.
*/
TIFFSeekFile( tif, 0, SEEK_SET );
if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
TIFFError(name, "Error writing TIFF header");
goto bad;
}
/*
* Setup the byte order handling.
*/
TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
/*
* Setup default directory.
*/
if (!TIFFDefaultDirectory(tif))
goto bad;
tif->tif_diroff = 0;
return (tif);
}
/*
* Setup the byte order handling.
*/
if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN) {
TIFFError(name, "Not a TIFF file, bad magic number %d (0x%x)",
tif->tif_header.tiff_magic,
tif->tif_header.tiff_magic);
goto bad;
}
TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
/*
* Swap header if required.
*/
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabShort(&tif->tif_header.tiff_version);
TIFFSwabLong(&tif->tif_header.tiff_diroff);
}
/*
* Now check version (if needed, it's been byte-swapped).
* Note that this isn't actually a version number, it's a
* magic number that doesn't change (stupid).
*/
if (tif->tif_header.tiff_version != TIFF_VERSION) {
TIFFError(name,
"Not a TIFF file, bad version number %d (0x%x)",
tif->tif_header.tiff_version,
tif->tif_header.tiff_version);
goto bad;
}
tif->tif_flags |= TIFF_MYBUFFER;
tif->tif_rawcp = tif->tif_rawdata = 0;
tif->tif_rawdatasize = 0;
/*
* Setup initial directory.
*/
switch (mode[0]) {
case 'r':
tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
/*
* Try to use a memory-mapped file if the client
* has not explicitly suppressed usage with the
* 'm' flag in the open mode (see above).
*/
if (TIFFReadDirectory(tif)) {
if( m != O_RDONLY
&& tif->tif_dir.td_compression != COMPRESSION_NONE )
{
TIFFError( name,
"Can't open a compressed TIFF file"
" with compression for update." );
goto bad;
}
tif->tif_rawcc = -1;
tif->tif_flags |= TIFF_BUFFERSETUP;
return (tif);
}
break;
case 'a':
/*
* New directories are automatically append
* to the end of the directory chain when they
* are written out (see TIFFWriteDirectory).
*/
if (!TIFFDefaultDirectory(tif))
goto bad;
return (tif);
}
bad:
tif->tif_mode = O_RDONLY; /* XXX avoid flush */
TIFFClose(tif);
return ((TIFF*)0);
bad2:
if ( closeproc )
(void) (*closeproc)(clientdata);
return ((TIFF*)0);
}
