/*
* Grow the strip data structures by delta strips.
*/
static int
TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module)
{
TIFFDirectory *td = &tif->tif_dir;
uint64* new_stripoffset;
uint64* new_stripbytecount;
assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
new_stripoffset = (uint64*)_TIFFrealloc(td->td_stripoffset,
(td->td_nstrips + delta) * sizeof (uint64));
new_stripbytecount = (uint64*)_TIFFrealloc(td->td_stripbytecount,
(td->td_nstrips + delta) * sizeof (uint64));
if (new_stripoffset == NULL || new_stripbytecount == NULL) {
if (new_stripoffset)
_TIFFfree(new_stripoffset);
if (new_stripbytecount)
_TIFFfree(new_stripbytecount);
td->td_nstrips = 0;
TIFFErrorExt(tif->tif_clientdata, module, "No space to expand strip arrays");
return (0);
}
td->td_stripoffset = new_stripoffset;
td->td_stripbytecount = new_stripbytecount;
_TIFFmemset(td->td_stripoffset + td->td_nstrips,
0, delta*sizeof (uint64));
_TIFFmemset(td->td_stripbytecount + td->td_nstrips,
0, delta*sizeof (uint64));
td->td_nstrips += delta;
tif->tif_flags |= TIFF_DIRTYDIRECT;
return (1);
}
/*
* Grow the strip data structures by delta strips.
*/
static int
TIFFGrowStrips(TIFF* tif, int delta, const char* module) {
TIFFDirectory* td = &tif->tif_dir;
uint32* new_stripoffset, *new_stripbytecount;
assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
new_stripoffset = (uint32*)_TIFFrealloc(td->td_stripoffset,
(td->td_nstrips + delta) * sizeof(uint32));
new_stripbytecount = (uint32*)_TIFFrealloc(td->td_stripbytecount,
(td->td_nstrips + delta) * sizeof(uint32));
if (new_stripoffset == NULL || new_stripbytecount == NULL) {
if (new_stripoffset) {
_TIFFfree(new_stripoffset);
}
if (new_stripbytecount) {
_TIFFfree(new_stripbytecount);
}
td->td_nstrips = 0;
TIFFError(module, "%s: No space to expand strip arrays",
tif->tif_name);
return (0);
}
td->td_stripoffset = new_stripoffset;
td->td_stripbytecount = new_stripbytecount;
_TIFFmemset(td->td_stripoffset + td->td_nstrips,
0, delta * sizeof(uint32));
_TIFFmemset(td->td_stripbytecount + td->td_nstrips,
0, delta * sizeof(uint32));
td->td_nstrips += delta;
return (1);
}
/*
* Grow the strip data structures by delta strips. This routine assumes entire
* offsets / byte counts arrays are in memory.
*/
static int
TIFFGrowStrips(TIFF* tif, int delta, const char* module)
{
TIFFDirectory *td = &tif->tif_dir;
toff_t *new_stripoffs;
uint32 *new_stripbcs;
assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
/* failure if have already placed offsets array in file */
if (td->td_stripoffsoff) {
td->td_nstrips = 0;
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Can't expand strip array", tif->tif_name);
return (0);
}
new_stripoffs = (toff_t*)_TIFFrealloc(td->td_stripoffsbuf,
(td->td_nstrips + delta) * sizeof (toff_t));
new_stripbcs = (uint32*)_TIFFrealloc(td->td_stripbcsbuf,
(td->td_nstrips + delta) * sizeof (uint32));
if (new_stripoffs == NULL || new_stripbcs == NULL) {
_TIFFfree(new_stripoffs);
_TIFFfree(new_stripbcs);
td->td_nstrips = 0;
TIFFErrorExt(tif->tif_clientdata, module,
"%s: No space to expand strip arrays", tif->tif_name);
return (0);
}
td->td_stripoffsbuf = new_stripoffs;
td->td_stripbcsbuf = new_stripbcs;
_TIFFmemset(td->td_stripoffsbuf + td->td_nstrips, 0, delta * sizeof(toff_t));
_TIFFmemset(td->td_stripbcsbuf + td->td_nstrips, 0, delta * sizeof(uint32));
td->td_nstrips += delta;
td->td_stripbufmax = TIFFmax(td->td_stripbufmax, td->td_nstrips);
return (1);
}
static int
cpTiles(TIFF* in, TIFF* out)
{
tmsize_t bufsize = TIFFTileSize(in);
unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
if (buf) {
ttile_t t, nt = TIFFNumberOfTiles(in);
uint64 *bytecounts;
TIFFGetField(in, TIFFTAG_TILEBYTECOUNTS, &bytecounts);
for (t = 0; t < nt; t++) {
if (bytecounts[t] > (uint64) bufsize) {
buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[t]);
if (!buf)
return (0);
bufsize = (tmsize_t)bytecounts[t];
}
if (TIFFReadRawTile(in, t, buf, (tmsize_t)bytecounts[t]) < 0 ||
TIFFWriteRawTile(out, t, buf, (tmsize_t)bytecounts[t]) < 0) {
_TIFFfree(buf);
return (0);
}
}
_TIFFfree(buf);
return (1);
}
return (0);
}
static int
cpStrips(TIFF* in, TIFF* out)
{
tmsize_t bufsize = TIFFStripSize(in);
unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
if (buf) {
tstrip_t s, ns = TIFFNumberOfStrips(in);
uint64 *bytecounts;
TIFFGetField(in, TIFFTAG_STRIPBYTECOUNTS, &bytecounts);
for (s = 0; s < ns; s++) {
if (bytecounts[s] > (uint64)bufsize) {
buf = (unsigned char *)_TIFFrealloc(buf, (tmsize_t)bytecounts[s]);
if (!buf)
return (0);
bufsize = (tmsize_t)bytecounts[s];
}
if (TIFFReadRawStrip(in, s, buf, (tmsize_t)bytecounts[s]) < 0 ||
TIFFWriteRawStrip(out, s, buf, (tmsize_t)bytecounts[s]) < 0) {
_TIFFfree(buf);
return (0);
}
}
_TIFFfree(buf);
return (1);
}
return (0);
}
static int
cpTiles(TIFF* in, TIFF* out)
{
tsize_t bufsize = TIFFTileSize(in);
unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
if (buf) {
ttile_t t, nt = TIFFNumberOfTiles(in);
uint32 *bytecounts;
if (!TIFFGetField(in, TIFFTAG_TILEBYTECOUNTS, &bytecounts)) {
fprintf(stderr, "tiffsplit: tile byte counts are missing\n");
return (0);
}
for (t = 0; t < nt; t++) {
if (bytecounts[t] > (uint32) bufsize) {
buf = (unsigned char *)_TIFFrealloc(buf, bytecounts[t]);
if (!buf)
return (0);
bufsize = bytecounts[t];
}
if (TIFFReadRawTile(in, t, buf, bytecounts[t]) < 0 ||
TIFFWriteRawTile(out, t, buf, bytecounts[t]) < 0) {
_TIFFfree(buf);
return (0);
}
}
_TIFFfree(buf);
return (1);
}
return (0);
}
static int
cpStrips(TIFF* in, TIFF* out)
{
tsize_t bufsize = TIFFStripSize(in);
unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
if (buf) {
tstrip_t s, ns = TIFFNumberOfStrips(in);
uint32 *bytecounts;
if (!TIFFGetField(in, TIFFTAG_STRIPBYTECOUNTS, &bytecounts)) {
fprintf(stderr, "tiffsplit: strip byte counts are missing\n");
return (0);
}
for (s = 0; s < ns; s++) {
if (bytecounts[s] > (uint32)bufsize) {
buf = (unsigned char *)_TIFFrealloc(buf, bytecounts[s]);
if (!buf)
return (0);
bufsize = bytecounts[s];
}
if (TIFFReadRawStrip(in, s, buf, bytecounts[s]) < 0 ||
TIFFWriteRawStrip(out, s, buf, bytecounts[s]) < 0) {
_TIFFfree(buf);
return (0);
}
}
_TIFFfree(buf);
return (1);
}
return (0);
}
void
_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
{
TIFFFieldInfo** tp;
int i;
if (tif->tif_nfields > 0) {
tif->tif_fieldinfo = (TIFFFieldInfo**)
_TIFFrealloc(tif->tif_fieldinfo,
(tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
} else {
tif->tif_fieldinfo = (TIFFFieldInfo**)
_TIFFmalloc(n * sizeof (TIFFFieldInfo*));
}
tp = &tif->tif_fieldinfo[tif->tif_nfields];
for (i = 0; i < n; i++)
tp[i] = (TIFFFieldInfo*) &info[i]; /* XXX */
/*
* NB: the core tags are presumed sorted correctly.
*/
if (tif->tif_nfields > 0)
qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n),
sizeof (TIFFFieldInfo*), tagCompare);
else
tif->tif_nfields += n;
}
static int
cpTiles(TIFF* in, TIFF* out)
{
tsize_t bufsize = TIFFTileSize(in);
unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
if (buf) {
ttile_t t, nt = TIFFNumberOfTiles(in);
tsize_t *bytecounts;
TIFFGetField(in, TIFFTAG_TILEBYTECOUNTS, &bytecounts);
for (t = 0; t < nt; t++) {
if (bytecounts[t] > bufsize) {
buf = (unsigned char *)_TIFFrealloc(buf, bytecounts[t]);
if (!buf)
goto bad;
bufsize = bytecounts[t];
}
if (TIFFReadRawTile(in, t, buf, bytecounts[t]) < 0 ||
TIFFWriteRawTile(out, t, buf, bytecounts[t]) < 0) {
_TIFFfree(buf);
return 0;
}
}
_TIFFfree(buf);
return 1;
}
bad:
TIFFError(TIFFFileName(in),
"Can't allocate space for tile buffer.");
return (0);
}
void
_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
{
TIFFFieldInfo** tp;
int i;
tif->tif_foundfield = NULL;
if (tif->tif_nfields > 0) {
tif->tif_fieldinfo = (TIFFFieldInfo**)
_TIFFrealloc(tif->tif_fieldinfo,
(tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
} else {
tif->tif_fieldinfo = (TIFFFieldInfo**)
_TIFFmalloc(n * sizeof (TIFFFieldInfo*));
}
assert(tif->tif_fieldinfo != NULL);
tp = tif->tif_fieldinfo + tif->tif_nfields;
for (i = 0; i < n; i++)
*tp++ = (TIFFFieldInfo*) (info + i); /* XXX */
/* Sort the field info by tag number */
qsort(tif->tif_fieldinfo, tif->tif_nfields += n,
sizeof (TIFFFieldInfo*), tagCompare);
}
static int
cpStrips(TIFF* in, TIFF* out)
{
tsize_t bufsize = TIFFStripSize(in);
unsigned char *buf = (unsigned char *)_TIFFmalloc(bufsize);
if (buf) {
tstrip_t s, ns = TIFFNumberOfStrips(in);
tsize_t *bytecounts;
TIFFGetField(in, TIFFTAG_STRIPBYTECOUNTS, &bytecounts);
for (s = 0; s < ns; s++) {
if (bytecounts[s] > bufsize) {
buf = (unsigned char *)_TIFFrealloc(buf, bytecounts[s]);
if (!buf)
goto bad;
bufsize = bytecounts[s];
}
if (TIFFReadRawStrip(in, s, buf, bytecounts[s]) < 0 ||
TIFFWriteRawStrip(out, s, buf, bytecounts[s]) < 0) {
_TIFFfree(buf);
return 0;
}
}
_TIFFfree(buf);
return 1;
}
bad:
TIFFError(TIFFFileName(in),
"Can't allocate space for strip buffer.");
return 0;
}
TIFFCodec*
TIFFGetConfiguredCODECs()
{
int i = 1;
codec_t *cd;
const TIFFCodec* c;
TIFFCodec* codecs = NULL;
TIFFCodec* new_codecs;
for (cd = registeredCODECS; cd; cd = cd->next) {
new_codecs = (TIFFCodec *)
_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
if (!new_codecs) {
_TIFFfree (codecs);
return NULL;
}
codecs = new_codecs;
_TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec));
i++;
}
for (c = _TIFFBuiltinCODECS; c->name; c++) {
if (TIFFIsCODECConfigured(c->scheme)) {
new_codecs = (TIFFCodec *)
_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
if (!new_codecs) {
_TIFFfree (codecs);
return NULL;
}
codecs = new_codecs;
_TIFFmemcpy(codecs + i - 1, (const void*)c, sizeof(TIFFCodec));
i++;
}
}
new_codecs = (TIFFCodec *) _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
if (!new_codecs) {
_TIFFfree (codecs);
return NULL;
}
codecs = new_codecs;
_TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
return codecs;
}
tdata_t
_TIFFCheckRealloc(TIFF* tif, tdata_t buffer,
size_t nmemb, size_t elem_size, const char* what)
{
tdata_t cp = NULL;
tsize_t bytes = nmemb * elem_size;
/*
* XXX: Check for integer overflow.
*/
if (nmemb && elem_size && bytes / elem_size == nmemb)
cp = _TIFFrealloc(buffer, bytes);
if (cp == NULL)
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"No space %s", what);
return cp;
}
TDimTiffIFDs readAllTiffIFDs (TIFF *tif) {
TDimTiffIFDs ifds;
TDimTiffIFD newIFD;
ifds.count = 1;
ifds.ifds = (TDimTiffIFD *) _TIFFmalloc( sizeof(TDimTiffIFD) );
ifds.ifds[0] = readFirstTiffIFD ( tif );
newIFD = ifds.ifds[0];
while (newIFD.next != 0) {
ifds.count++;
newIFD = readTiffIFD ( tif, newIFD.next);
ifds.ifds = (TDimTiffIFD *) _TIFFrealloc(ifds.ifds, sizeof(TDimTiffIFD) * ifds.count );
if (ifds.ifds == NULL) return ifds;
ifds.ifds[ifds.count-1] = newIFD;
}
return ifds;
}
tdata_t
_TIFFCheckRealloc(TIFF* tif, tdata_t buffer,
size_t nmemb, size_t elem_size, const char* what)
{
tdata_t cp = NULL;
tsize_t bytes = nmemb * elem_size;
/*
* XXX: Check for integer overflow.
*/
if (nmemb && elem_size && bytes / elem_size == nmemb)
cp = _TIFFrealloc(buffer, bytes);
if (cp == NULL)
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Failed to allocate memory for %s "
"(%ld elements of %ld bytes each)",
what,(long) nmemb, (long) elem_size);
return cp;
}
void*
_TIFFCheckRealloc(TIFF* tif, void* buffer,
tmsize_t nmemb, tmsize_t elem_size, const char* what)
{
void* cp = NULL;
tmsize_t bytes = nmemb * elem_size;
/*
* XXX: Check for integer overflow.
*/
if (nmemb && elem_size && !_TIFFIfMultiplicationOverflow(nmemb, elem_size))
cp = _TIFFrealloc(buffer, bytes);
if (cp == NULL) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Failed to allocate memory for %s "
"(%ld elements of %ld bytes each)",
what,(long) nmemb, (long) elem_size);
}
return cp;
}
void
_TIFFMergeFieldInfo(TIFF* tif, const TIFFFieldInfo info[], int n)
{
TIFFFieldInfo** tp;
int i;
if (tif->tif_nfields > 0) {
tif->tif_fieldinfo = (TIFFFieldInfo**)
_TIFFrealloc(tif->tif_fieldinfo,
(tif->tif_nfields+n) * sizeof (TIFFFieldInfo*));
} else {
tif->tif_fieldinfo = (TIFFFieldInfo**)
_TIFFmalloc(n * sizeof (TIFFFieldInfo*));
}
assert(tif->tif_fieldinfo != NULL);
tp = &tif->tif_fieldinfo[tif->tif_nfields];
for (i = 0; i < n; i++)
tp[i] = (TIFFFieldInfo*) &info[i]; /* XXX */
/* Sort the field info by tag number */
qsort(tif->tif_fieldinfo, (size_t) (tif->tif_nfields += n),
sizeof (TIFFFieldInfo*), tagCompare);
}
gdata_t _GTIFrealloc(gdata_t ptr, gsize_t size)
{
return _TIFFrealloc((tdata_t)ptr, (tsize_t) size);
}
/* Read 'size' bytes in tif_rawdata buffer starting at offset 'rawdata_offset'
* Returns 1 in case of success, 0 otherwise. */
static int TIFFReadAndRealloc( TIFF* tif, tmsize_t size,
tmsize_t rawdata_offset,
int is_strip, uint32 strip_or_tile,
const char* module )
{
#if SIZEOF_SIZE_T == 8
tmsize_t threshold = INITIAL_THRESHOLD;
#endif
tmsize_t already_read = 0;
/* On 64 bit processes, read first a maximum of 1 MB, then 10 MB, etc */
/* so as to avoid allocating too much memory in case the file is too */
/* short. We could ask for the file size, but this might be */
/* expensive with some I/O layers (think of reading a gzipped file) */
/* Restrict to 64 bit processes, so as to avoid reallocs() */
/* on 32 bit processes where virtual memory is scarce. */
while( already_read < size )
{
tmsize_t bytes_read;
tmsize_t to_read = size - already_read;
#if SIZEOF_SIZE_T == 8
if( to_read >= threshold && threshold < MAX_THRESHOLD &&
already_read + to_read + rawdata_offset > tif->tif_rawdatasize )
{
to_read = threshold;
threshold *= THRESHOLD_MULTIPLIER;
}
#endif
if (already_read + to_read + rawdata_offset > tif->tif_rawdatasize) {
uint8* new_rawdata;
assert((tif->tif_flags & TIFF_MYBUFFER) != 0);
tif->tif_rawdatasize = (tmsize_t)TIFFroundup_64(
(uint64)already_read + to_read + rawdata_offset, 1024);
if (tif->tif_rawdatasize==0) {
TIFFErrorExt(tif->tif_clientdata, module,
"Invalid buffer size");
return 0;
}
new_rawdata = (uint8*) _TIFFrealloc(
tif->tif_rawdata, tif->tif_rawdatasize);
if( new_rawdata == 0 )
{
TIFFErrorExt(tif->tif_clientdata, module,
"No space for data buffer at scanline %lu",
(unsigned long) tif->tif_row);
_TIFFfree(tif->tif_rawdata);
tif->tif_rawdata = 0;
tif->tif_rawdatasize = 0;
return 0;
}
tif->tif_rawdata = new_rawdata;
}
bytes_read = TIFFReadFile(tif,
tif->tif_rawdata + rawdata_offset + already_read, to_read);
already_read += bytes_read;
if (bytes_read != to_read) {
memset( tif->tif_rawdata + rawdata_offset + already_read, 0,
tif->tif_rawdatasize - rawdata_offset - already_read );
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
if( is_strip )
{
TIFFErrorExt(tif->tif_clientdata, module,
"Read error at scanline %lu; got %I64u bytes, "
"expected %I64u",
(unsigned long) tif->tif_row,
(unsigned __int64) already_read,
(unsigned __int64) size);
}
else
{
TIFFErrorExt(tif->tif_clientdata, module,
"Read error at row %lu, col %lu, tile %lu; "
"got %I64u bytes, expected %I64u",
(unsigned long) tif->tif_row,
(unsigned long) tif->tif_col,
(unsigned long) strip_or_tile,
(unsigned __int64) already_read,
(unsigned __int64) size);
}
#else
if( is_strip )
{
TIFFErrorExt(tif->tif_clientdata, module,
"Read error at scanline %lu; got %llu bytes, "
"expected %llu",
(unsigned long) tif->tif_row,
(unsigned long long) already_read,
(unsigned long long) size);
}
else
{
TIFFErrorExt(tif->tif_clientdata, module,
"Read error at row %lu, col %lu, tile %lu; "
"got %llu bytes, expected %llu",
(unsigned long) tif->tif_row,
(unsigned long) tif->tif_col,
(unsigned long) strip_or_tile,
(unsigned long long) already_read,
(unsigned long long) size);
}
#endif
return 0;
}
}
return 1;
}
