/* Variant of TIFFReadEncodedTile() that does
* * if *buf == NULL, *buf = _TIFFmalloc(bufsizetoalloc) only after TIFFFillTile() has
* succeeded. This avoid excessive memory allocation in case of truncated
* file.
* * calls regular TIFFReadEncodedTile() if *buf != NULL
*/
tmsize_t
_TIFFReadEncodedTileAndAllocBuffer(TIFF* tif, uint32 tile,
void **buf, tmsize_t bufsizetoalloc,
tmsize_t size_to_read)
{
static const char module[] = "_TIFFReadEncodedTileAndAllocBuffer";
TIFFDirectory *td = &tif->tif_dir;
tmsize_t tilesize = tif->tif_tilesize;
if( *buf != NULL )
{
return TIFFReadEncodedTile(tif, tile, *buf, size_to_read);
}
if (!TIFFCheckRead(tif, 1))
return ((tmsize_t)(-1));
if (tile >= td->td_nstrips) {
TIFFErrorExt(tif->tif_clientdata, module,
"%lu: Tile out of range, max %lu",
(unsigned long) tile, (unsigned long) td->td_nstrips);
return ((tmsize_t)(-1));
}
if (!TIFFFillTile(tif,tile))
return((tmsize_t)(-1));
*buf = _TIFFmalloc(bufsizetoalloc);
if (*buf == NULL) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
"No space for tile buffer");
return((tmsize_t)(-1));
}
_TIFFmemset(*buf, 0, bufsizetoalloc);
if (size_to_read == (tmsize_t)(-1))
size_to_read = tilesize;
else if (size_to_read > tilesize)
size_to_read = tilesize;
if( (*tif->tif_decodetile)(tif,
(uint8*) *buf, size_to_read, (uint16)(tile/td->td_stripsperimage))) {
(*tif->tif_postdecode)(tif, (uint8*) *buf, size_to_read);
return (size_to_read);
} else
return ((tmsize_t)(-1));
}
int
main(int argc, char **argv)
{
TIFF *tif;
static const char *srcfilerel = "images/quad-tile.jpg.tiff";
char *srcdir = NULL;
char srcfile[1024];
unsigned short h, v;
int status;
unsigned char *buffer;
uint32 *rgba_buffer;
tsize_t sz, szout;
unsigned int pixel_status = 0;
(void) argc;
(void) argv;
if ((srcdir = getenv("srcdir")) == NULL) {
srcdir = ".";
}
if ((strlen(srcdir) + 1 + strlen(srcfilerel)) >= sizeof(srcfile)) {
fprintf( stderr, "srcdir too long %s\n", srcdir);
exit( 1 );
}
strcpy(srcfile,srcdir);
strcat(srcfile,"/");
strcat(srcfile,srcfilerel);
tif = TIFFOpen(srcfile,"r");
if ( tif == NULL ) {
fprintf( stderr, "Could not open %s\n", srcfile);
exit( 1 );
}
status = TIFFGetField(tif,TIFFTAG_YCBCRSUBSAMPLING, &h, &v);
if ( status == 0 || h != 2 || v != 2) {
fprintf( stderr, "Could not retrieve subsampling tag.\n" );
exit(1);
}
/*
* What is the appropriate size of a YCbCr encoded tile?
*/
sz = TIFFTileSize(tif);
if( sz != 24576) {
fprintf(stderr, "tiles are %d bytes\n", (int)sz);
exit(1);
}
buffer = (unsigned char *) malloc(sz);
/*
* Read a tile in decompressed form, but still YCbCr subsampled.
*/
szout = TIFFReadEncodedTile(tif,9,buffer,sz);
if (szout != sz) {
fprintf( stderr,
"Did not get expected result code from TIFFReadEncodedTile()(%d instead of %d)\n",
(int) szout, (int) sz );
return 1;
}
if( check_cluster( 0, buffer, cluster_0 )
|| check_cluster( 64, buffer, cluster_64 )
|| check_cluster( 128, buffer, cluster_128 ) ) {
exit(1);
}
free(buffer);
/*
* Read a tile using the built-in conversion to RGB format provided by the JPEG library.
*/
TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
sz = TIFFTileSize(tif);
if( sz != 128*128*3) {
fprintf(stderr, "tiles are %d bytes\n", (int)sz);
exit(1);
}
buffer = (unsigned char *) malloc(sz);
szout = TIFFReadEncodedTile(tif,9,buffer,sz);
if (szout != sz) {
fprintf( stderr,
"Did not get expected result code from TIFFReadEncodedTile()(%d instead of %d)\n",
(int) szout, (int) sz );
return 1;
}
#if JPEG_LIB_VERSION >= 70
pixel_status |= check_rgb_pixel( 0, 18, 0, 41, buffer );
pixel_status |= check_rgb_pixel( 64, 0, 0, 0, buffer );
pixel_status |= check_rgb_pixel( 512, 5, 34, 196, buffer );
#else
pixel_status |= check_rgb_pixel( 0, 15, 0, 18, buffer );
pixel_status |= check_rgb_pixel( 64, 0, 0, 2, buffer );
pixel_status |= check_rgb_pixel( 512, 6, 36, 182, buffer );
#endif
free( buffer );
TIFFClose(tif);
/*
* Reopen and test reading using the RGBA interface.
*/
tif = TIFFOpen(srcfile,"r");
sz = 128 * 128 * sizeof(uint32);
rgba_buffer = (uint32 *) malloc(sz);
if (!TIFFReadRGBATile( tif, 1*128, 2*128, rgba_buffer )) {
fprintf( stderr, "TIFFReadRGBATile() returned failure code.\n" );
return 1;
}
/*
* Currently TIFFReadRGBATile() just uses JPEGCOLORMODE_RGB so this
* trivally matches the last results. Eventually we should actually
* accomplish it from the YCbCr subsampled buffer ourselves in which
* case the results may be subtly different but similar.
*/
#if JPEG_LIB_VERSION >= 70
pixel_status |= check_rgba_pixel( 0, 18, 0, 41, 255, rgba_buffer );
pixel_status |= check_rgba_pixel( 64, 0, 0, 0, 255, rgba_buffer );
pixel_status |= check_rgba_pixel( 512, 5, 34, 196, 255, rgba_buffer );
#else
pixel_status |= check_rgba_pixel( 0, 15, 0, 18, 255, rgba_buffer );
pixel_status |= check_rgba_pixel( 64, 0, 0, 2, 255, rgba_buffer );
pixel_status |= check_rgba_pixel( 512, 6, 36, 182, 255, rgba_buffer );
#endif
free( rgba_buffer );
TIFFClose(tif);
if (pixel_status) {
exit(1);
}
exit( 0 );
}
bool TiffDecoder::readData( Mat& img )
{
bool result = false;
bool color = img.channels() > 1;
uchar* data = img.data;
int step = (int)img.step;
if( img.depth() != CV_8U && img.depth() != CV_16U && img.depth() != CV_32F && img.depth() != CV_64F )
return false;
if( m_tif && m_width && m_height )
{
TIFF* tif = (TIFF*)m_tif;
int tile_width0 = m_width, tile_height0 = 0;
int x, y, i;
int is_tiled = TIFFIsTiled(tif);
int photometric;
TIFFGetField( tif, TIFFTAG_PHOTOMETRIC, &photometric );
int bpp = 8, ncn = photometric > 1 ? 3 : 1;
TIFFGetField( tif, TIFFTAG_BITSPERSAMPLE, &bpp );
TIFFGetField( tif, TIFFTAG_SAMPLESPERPIXEL, &ncn );
const int bitsPerByte = 8;
int dst_bpp = (int)(img.elemSize1() * bitsPerByte);
if(dst_bpp == 8)
{
char errmsg[1024];
if(!TIFFRGBAImageOK( tif, errmsg ))
{
close();
return false;
}
}
if( (!is_tiled) ||
(is_tiled &&
TIFFGetField( tif, TIFFTAG_TILEWIDTH, &tile_width0 ) &&
TIFFGetField( tif, TIFFTAG_TILELENGTH, &tile_height0 )))
{
if(!is_tiled)
TIFFGetField( tif, TIFFTAG_ROWSPERSTRIP, &tile_height0 );
if( tile_width0 <= 0 )
tile_width0 = m_width;
if( tile_height0 <= 0 )
tile_height0 = m_height;
AutoBuffer<uchar> _buffer(tile_height0*tile_width0*8);
uchar* buffer = _buffer;
ushort* buffer16 = (ushort*)buffer;
float* buffer32 = (float*)buffer;
double* buffer64 = (double*)buffer;
int tileidx = 0;
for( y = 0; y < m_height; y += tile_height0, data += step*tile_height0 )
{
int tile_height = tile_height0;
if( y + tile_height > m_height )
tile_height = m_height - y;
for( x = 0; x < m_width; x += tile_width0, tileidx++ )
{
int tile_width = tile_width0, ok;
if( x + tile_width > m_width )
tile_width = m_width - x;
switch(dst_bpp)
{
case 8:
{
if( !is_tiled )
ok = TIFFReadRGBAStrip( tif, y, (uint32*)buffer );
else
ok = TIFFReadRGBATile( tif, x, y, (uint32*)buffer );
if( !ok )
{
close();
return false;
}
for( i = 0; i < tile_height; i++ )
if( color )
icvCvt_BGRA2BGR_8u_C4C3R( buffer + i*tile_width*4, 0,
data + x*3 + step*(tile_height - i - 1), 0,
cvSize(tile_width,1), 2 );
else
icvCvt_BGRA2Gray_8u_C4C1R( buffer + i*tile_width*4, 0,
data + x + step*(tile_height - i - 1), 0,
cvSize(tile_width,1), 2 );
break;
}
case 16:
{
if( !is_tiled )
ok = (int)TIFFReadEncodedStrip( tif, tileidx, (uint32*)buffer, (tsize_t)-1 ) >= 0;
else
ok = (int)TIFFReadEncodedTile( tif, tileidx, (uint32*)buffer, (tsize_t)-1 ) >= 0;
if( !ok )
{
close();
return false;
}
for( i = 0; i < tile_height; i++ )
{
if( color )
{
if( ncn == 1 )
{
icvCvt_Gray2BGR_16u_C1C3R(buffer16 + i*tile_width*ncn, 0,
(ushort*)(data + step*i) + x*3, 0,
cvSize(tile_width,1) );
}
else if( ncn == 3 )
{
icvCvt_RGB2BGR_16u_C3R(buffer16 + i*tile_width*ncn, 0,
(ushort*)(data + step*i) + x*3, 0,
cvSize(tile_width,1) );
}
else
{
icvCvt_BGRA2BGR_16u_C4C3R(buffer16 + i*tile_width*ncn, 0,
(ushort*)(data + step*i) + x*3, 0,
cvSize(tile_width,1), 2 );
}
}
else
{
if( ncn == 1 )
{
memcpy((ushort*)(data + step*i)+x,
buffer16 + i*tile_width*ncn,
tile_width*sizeof(buffer16[0]));
}
else
{
icvCvt_BGRA2Gray_16u_CnC1R(buffer16 + i*tile_width*ncn, 0,
(ushort*)(data + step*i) + x, 0,
cvSize(tile_width,1), ncn, 2 );
}
}
}
break;
}
case 32:
case 64:
{
if( !is_tiled )
ok = (int)TIFFReadEncodedStrip( tif, tileidx, buffer, (tsize_t)-1 ) >= 0;
else
ok = (int)TIFFReadEncodedTile( tif, tileidx, buffer, (tsize_t)-1 ) >= 0;
if( !ok || ncn != 1 )
{
close();
return false;
}
for( i = 0; i < tile_height; i++ )
{
if(dst_bpp == 32)
{
memcpy((float*)(data + step*i)+x,
buffer32 + i*tile_width*ncn,
tile_width*sizeof(buffer32[0]));
}
else
{
memcpy((double*)(data + step*i)+x,
buffer64 + i*tile_width*ncn,
tile_width*sizeof(buffer64[0]));
}
}
break;
}
default:
{
close();
return false;
}
}
}
}
result = true;
}
}
close();
return result;
}
/* Copy a TIFF file ... we know we wrote it, so just copy the tags we know
* we might have set.
*/
static int
write_copy_tiff( Write *write, TIFF *out, TIFF *in )
{
uint32 i32;
uint16 i16;
float f;
tdata_t buf;
ttile_t tile;
ttile_t n;
/* All the fields we might have set.
*/
CopyField( TIFFTAG_IMAGEWIDTH, i32 );
CopyField( TIFFTAG_IMAGELENGTH, i32 );
CopyField( TIFFTAG_PLANARCONFIG, i16 );
CopyField( TIFFTAG_ORIENTATION, i16 );
CopyField( TIFFTAG_XRESOLUTION, f );
CopyField( TIFFTAG_YRESOLUTION, f );
CopyField( TIFFTAG_RESOLUTIONUNIT, i16 );
CopyField( TIFFTAG_COMPRESSION, i16 );
CopyField( TIFFTAG_SAMPLESPERPIXEL, i16 );
CopyField( TIFFTAG_BITSPERSAMPLE, i16 );
CopyField( TIFFTAG_PHOTOMETRIC, i16 );
CopyField( TIFFTAG_ORIENTATION, i16 );
CopyField( TIFFTAG_TILEWIDTH, i32 );
CopyField( TIFFTAG_TILELENGTH, i32 );
CopyField( TIFFTAG_ROWSPERSTRIP, i32 );
CopyField( TIFFTAG_SUBFILETYPE, i32 );
if( write->predictor != VIPS_FOREIGN_TIFF_PREDICTOR_NONE )
TIFFSetField( out, TIFFTAG_PREDICTOR, write->predictor );
/* TIFFTAG_JPEGQUALITY is a pesudo-tag, so we can't copy it.
* Set explicitly from Write.
*/
if( write->compression == COMPRESSION_JPEG ) {
TIFFSetField( out, TIFFTAG_JPEGQUALITY, write->jpqual );
/* Only for three-band, 8-bit images.
*/
if( write->im->Bands == 3 &&
write->im->BandFmt == VIPS_FORMAT_UCHAR ) {
/* Enable rgb->ycbcr conversion in the jpeg write.
*/
if( !write->rgbjpeg &&
write->jpqual < 90 )
TIFFSetField( out,
TIFFTAG_JPEGCOLORMODE,
JPEGCOLORMODE_RGB );
/* And we want ycbcr expanded to rgb on read. Otherwise
* TIFFTileSize() will give us the size of a chrominance
* subsampled tile.
*/
TIFFSetField( in,
TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB );
}
}
/* We can't copy profiles or xmp :( Set again from Write.
*/
if( !write->strip )
if( write_embed_profile( write, out ) ||
write_embed_xmp( write, out ) ||
write_embed_ipct( write, out ) ||
write_embed_photoshop( write, out ) ||
write_embed_imagedescription( write, out ) )
return( -1 );
buf = vips_malloc( NULL, TIFFTileSize( in ) );
n = TIFFNumberOfTiles( in );
for( tile = 0; tile < n; tile++ ) {
tsize_t len;
/* It'd be good to use TIFFReadRawTile()/TIFFWriteRawTile()
* here to save compression/decompression, but sadly it seems
* not to work :-( investigate at some point.
*/
len = TIFFReadEncodedTile( in, tile, buf, -1 );
if( len < 0 ||
TIFFWriteEncodedTile( out, tile, buf, len ) < 0 ) {
vips_free( buf );
return( -1 );
}
}
vips_free( buf );
return( 0 );
}
int
main(int argc, char **argv)
{
TIFF *tif;
static const char *srcfilerel = "images/quad-tile.jpg.tiff";
char *srcdir = NULL;
char srcfile[1024];
unsigned short h, v;
int status;
unsigned char *buffer;
uint32 *rgba_buffer;
tsize_t sz, szout;
unsigned int pixel_status = 0;
(void) argc;
(void) argv;
if ((srcdir = getenv("srcdir")) == NULL) {
srcdir = ".";
}
printf("XXXXXXXX %s",srcdir);
if ((strlen(srcdir) + 1 + strlen(srcfilerel)) >= sizeof(srcfile)) {
fprintf( stderr, "srcdir too long %s\n", srcdir);
exit( 1 );
}
strcpy(srcfile,srcdir);
strcat(srcfile,"/");
strcat(srcfile,srcfilerel);
tif = TIFFOpen(srcfile,"r");
if ( tif == NULL ) {
fprintf( stderr, "Could not open %s\n", srcfile);
exit( 1 );
}
status = TIFFGetField(tif,TIFFTAG_YCBCRSUBSAMPLING, &h, &v);
if ( status == 0 || h != 2 || v != 2) {
fprintf( stderr, "Could not retrieve subsampling tag.\n" );
exit(1);
}
/*
* What is the appropriate size of a YCbCr encoded tile?
*/
sz = TIFFTileSize(tif);
if( sz != 24576) {
fprintf(stderr, "tiles are %d bytes\n", (int)sz);
exit(1);
}
buffer = (unsigned char *) malloc(sz);
/*
* Read a tile in decompressed form, but still YCbCr subsampled.
*/
szout = TIFFReadEncodedTile(tif,9,buffer,sz);
if (szout != sz) {
fprintf( stderr,
"Did not get expected result code from TIFFReadEncodedTile()(%d instead of %d)\n",
(int) szout, (int) sz );
return 1;
}
if( check_cluster( 0, buffer, cluster_0 )
|| check_cluster( 64, buffer, cluster_64 )
|| check_cluster( 128, buffer, cluster_128 ) ) {
exit(1);
}
free(buffer);
/*
* Read a tile using the built-in conversion to RGB format provided by the JPEG library.
*/
TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
sz = TIFFTileSize(tif);
if( sz != 128*128*3) {
fprintf(stderr, "tiles are %d bytes\n", (int)sz);
exit(1);
}
buffer = (unsigned char *) malloc(sz);
szout = TIFFReadEncodedTile(tif,9,buffer,sz);
if (szout != sz) {
fprintf( stderr,
"Did not get expected result code from TIFFReadEncodedTile()(%d instead of %d)\n",
(int) szout, (int) sz );
return 1;
}
/*
* JPEG decoding is inherently inexact, so we can't test for exact
* pixel values. (Well, if we knew exactly which libjpeg version
* we were using, and with what settings, we could expect specific
* values ... but it's not worth the trouble to keep track of.)
* Hence, use ranges of expected values. The ranges may need to be
* widened over time as more versions of libjpeg appear.
*/
pixel_status |= check_rgb_pixel( 0, 15, 18, 0, 0, 18, 41, buffer );
pixel_status |= check_rgb_pixel( 64, 0, 0, 0, 0, 0, 2, buffer );
pixel_status |= check_rgb_pixel( 512, 5, 6, 34, 36, 182, 196, buffer );
free( buffer );
TIFFClose(tif);
/*
* Reopen and test reading using the RGBA interface.
*/
tif = TIFFOpen(srcfile,"r");
sz = 128 * 128 * sizeof(uint32);
rgba_buffer = (uint32 *) malloc(sz);
if (!TIFFReadRGBATile( tif, 1*128, 2*128, rgba_buffer )) {
fprintf( stderr, "TIFFReadRGBATile() returned failure code.\n" );
return 1;
}
/*
* Currently TIFFReadRGBATile() just uses JPEGCOLORMODE_RGB so this
* trivally matches the last results. Eventually we should actually
* accomplish it from the YCbCr subsampled buffer ourselves in which
* case the results may be subtly different but similar.
*/
pixel_status |= check_rgba_pixel( 0, 15, 18, 0, 0, 18, 41, 255, 255,
rgba_buffer );
pixel_status |= check_rgba_pixel( 64, 0, 0, 0, 0, 0, 2, 255, 255,
rgba_buffer );
pixel_status |= check_rgba_pixel( 512, 5, 6, 34, 36, 182, 196, 255, 255,
rgba_buffer );
free( rgba_buffer );
TIFFClose(tif);
if (pixel_status) {
exit(1);
}
exit( 0 );
}
void TIFF_ProcessFullResBlock( TIFF *hTIFF, int nPlanarConfig,
int nOverviews, int * panOvList,
int nBitsPerPixel,
int nSamples, TIFFOvrCache ** papoRawBIs,
int nSXOff, int nSYOff,
unsigned char *pabySrcTile,
int nBlockXSize, int nBlockYSize,
int nSampleFormat, const char * pszResampling )
{
int iOverview, iSample;
for( iSample = 0; iSample < nSamples; iSample++ )
{
/*
* We have to read a tile/strip for each sample for
* PLANARCONFIG_SEPARATE. Otherwise, we just read all the samples
* at once when handling the first sample.
*/
if( nPlanarConfig == PLANARCONFIG_SEPARATE || iSample == 0 )
{
if( TIFFIsTiled(hTIFF) )
{
TIFFReadEncodedTile( hTIFF,
TIFFComputeTile(hTIFF, nSXOff, nSYOff,
0, iSample ),
pabySrcTile,
TIFFTileSize(hTIFF));
}
else
{
TIFFReadEncodedStrip( hTIFF,
TIFFComputeStrip(hTIFF, nSYOff, iSample),
pabySrcTile,
TIFFStripSize(hTIFF) );
}
}
/*
* Loop over destination overview layers
*/
for( iOverview = 0; iOverview < nOverviews; iOverview++ )
{
TIFFOvrCache *poRBI = papoRawBIs[iOverview];
unsigned char *pabyOTile;
int nTXOff, nTYOff, nOXOff, nOYOff, nOMult;
int nOBlockXSize = poRBI->nBlockXSize;
int nOBlockYSize = poRBI->nBlockYSize;
int nSkewBits, nSampleByteOffset;
/*
* Fetch the destination overview tile
*/
nOMult = panOvList[iOverview];
nOXOff = (nSXOff/nOMult) / nOBlockXSize;
nOYOff = (nSYOff/nOMult) / nOBlockYSize;
pabyOTile = TIFFGetOvrBlock( poRBI, nOXOff, nOYOff, iSample );
/*
* Establish the offset into this tile at which we should
* start placing data.
*/
nTXOff = (nSXOff - nOXOff*nOMult*nOBlockXSize) / nOMult;
nTYOff = (nSYOff - nOYOff*nOMult*nOBlockYSize) / nOMult;
/*
* Figure out the skew (extra space between ``our samples'') and
* the byte offset to the first sample.
*/
assert( (nBitsPerPixel % 8) == 0 );
if( nPlanarConfig == PLANARCONFIG_SEPARATE )
{
nSkewBits = 0;
nSampleByteOffset = 0;
}
else
{
nSkewBits = nBitsPerPixel * (nSamples-1);
nSampleByteOffset = (nBitsPerPixel/8) * iSample;
}
/*
* Perform the downsampling.
*/
#ifdef DBMALLOC
malloc_chain_check( 1 );
#endif
TIFF_DownSample( pabySrcTile + nSampleByteOffset,
nBlockXSize, nBlockYSize,
nSkewBits, nBitsPerPixel, pabyOTile,
poRBI->nBlockXSize, poRBI->nBlockYSize,
nTXOff, nTYOff,
nOMult, nSampleFormat, pszResampling );
#ifdef DBMALLOC
malloc_chain_check( 1 );
#endif
}
}
}
int
PS_Lvl2page(FILE* fd, TIFF* tif, uint32 w, uint32 h)
{
uint16 fillorder;
int use_rawdata, tiled_image, breaklen;
uint32 chunk_no, num_chunks, *bc;
unsigned char *buf_data, *cp;
tsize_t chunk_size, byte_count;
#if defined( EXP_ASCII85ENCODER )
int ascii85_l; /* Length, in bytes, of ascii85_p[] data */
uint8 * ascii85_p = 0; /* Holds ASCII85 encoded data */
#endif
PS_Lvl2colorspace(fd, tif);
use_rawdata = PS_Lvl2ImageDict(fd, tif, w, h);
fputs("%%BeginData:\n", fd);
fputs("exec\n", fd);
tiled_image = TIFFIsTiled(tif);
if (tiled_image) {
num_chunks = TIFFNumberOfTiles(tif);
TIFFGetField(tif, TIFFTAG_TILEBYTECOUNTS, &bc);
} else {
num_chunks = TIFFNumberOfStrips(tif);
TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &bc);
}
if (use_rawdata) {
chunk_size = bc[0];
for (chunk_no = 1; chunk_no < num_chunks; chunk_no++)
if (bc[chunk_no] > chunk_size)
chunk_size = bc[chunk_no];
} else {
if (tiled_image)
chunk_size = TIFFTileSize(tif);
else
chunk_size = TIFFStripSize(tif);
}
buf_data = (unsigned char *)_TIFFmalloc(chunk_size);
if (!buf_data) {
TIFFError(filename, "Can't alloc %u bytes for %s.",
chunk_size, tiled_image ? "tiles" : "strips");
return(FALSE);
}
#if defined( EXP_ASCII85ENCODER )
if ( ascii85 ) {
/*
* Allocate a buffer to hold the ASCII85 encoded data. Note
* that it is allocated with sufficient room to hold the
* encoded data (5*chunk_size/4) plus the EOD marker (+8)
* and formatting line breaks. The line breaks are more
* than taken care of by using 6*chunk_size/4 rather than
* 5*chunk_size/4.
*/
ascii85_p = _TIFFmalloc( (chunk_size+(chunk_size/2)) + 8 );
if ( !ascii85_p ) {
_TIFFfree( buf_data );
TIFFError( filename, "Cannot allocate ASCII85 encoding buffer." );
return ( FALSE );
}
}
#endif
TIFFGetFieldDefaulted(tif, TIFFTAG_FILLORDER, &fillorder);
for (chunk_no = 0; chunk_no < num_chunks; chunk_no++) {
if (ascii85)
Ascii85Init();
else
breaklen = 36;
if (use_rawdata) {
if (tiled_image)
byte_count = TIFFReadRawTile(tif, chunk_no,
buf_data, chunk_size);
else
byte_count = TIFFReadRawStrip(tif, chunk_no,
buf_data, chunk_size);
if (fillorder == FILLORDER_LSB2MSB)
TIFFReverseBits(buf_data, byte_count);
} else {
if (tiled_image)
byte_count = TIFFReadEncodedTile(tif,
chunk_no, buf_data,
chunk_size);
else
byte_count = TIFFReadEncodedStrip(tif,
chunk_no, buf_data,
chunk_size);
}
if (byte_count < 0) {
TIFFError(filename, "Can't read %s %d.",
tiled_image ? "tile" : "strip", chunk_no);
if (ascii85)
Ascii85Put('\0', fd);
}
if (ascii85) {
#if defined( EXP_ASCII85ENCODER )
ascii85_l = Ascii85EncodeBlock(ascii85_p, 1, buf_data, byte_count );
if ( ascii85_l > 0 )
fwrite( ascii85_p, ascii85_l, 1, fd );
#else
for (cp = buf_data; byte_count > 0; byte_count--)
Ascii85Put(*cp++, fd);
#endif
}
else
{
for (cp = buf_data; byte_count > 0; byte_count--) {
putc(hex[((*cp)>>4)&0xf], fd);
putc(hex[(*cp)&0xf], fd);
cp++;
if (--breaklen <= 0) {
putc('\n', fd);
breaklen = 36;
}
}
}
if ( !ascii85 ) {
if ( level2 )
putc( '>', fd );
putc('\n', fd);
}
#if !defined( EXP_ASCII85ENCODER )
else
Ascii85Flush(fd);
#endif
}
#if defined( EXP_ASCII85ENCODER )
if ( ascii85_p )
_TIFFfree( ascii85_p );
#endif
_TIFFfree(buf_data);
fputs("%%EndData\n", fd);
return(TRUE);
}
