bool
ImageInput::read_scanlines (int ybegin, int yend, int z,
TypeDesc format, void *data,
stride_t xstride, stride_t ystride)
{
return read_scanlines (ybegin, yend, z, 0, m_spec.nchannels,
format, data, xstride, ystride);
}
bool
ImageInput::read_image (TypeDesc format, void *data,
stride_t xstride, stride_t ystride, stride_t zstride,
ProgressCallback progress_callback,
void *progress_callback_data)
{
bool native = (format == TypeDesc::UNKNOWN);
stride_t pixel_bytes = native ? (stride_t) m_spec.pixel_bytes (native)
: (stride_t) (format.size()*m_spec.nchannels);
if (native && xstride == AutoStride)
xstride = pixel_bytes;
m_spec.auto_stride (xstride, ystride, zstride, format, m_spec.nchannels,
m_spec.width, m_spec.height);
bool ok = true;
if (progress_callback)
if (progress_callback (progress_callback_data, 0.0f))
return ok;
if (m_spec.tile_width) {
// Tiled image
for (int z = 0; z < m_spec.depth; z += m_spec.tile_depth) {
for (int y = 0; y < m_spec.height; y += m_spec.tile_height) {
ok &= read_tiles (m_spec.x, m_spec.x+m_spec.width,
y+m_spec.y, std::min (y+m_spec.y+m_spec.tile_height, m_spec.y+m_spec.height),
z+m_spec.z, std::min (z+m_spec.z+m_spec.tile_depth, m_spec.z+m_spec.depth),
format, (char *)data + z*zstride + y*ystride,
xstride, ystride, zstride);
if (progress_callback &&
progress_callback (progress_callback_data, (float)y/m_spec.height))
return ok;
}
}
} else {
// Scanline image -- rely on read_scanlines, in chunks of 64
const int chunk = 256;
for (int z = 0; z < m_spec.depth; ++z)
for (int y = 0; y < m_spec.height && ok; y += chunk) {
int yend = std::min (y+m_spec.y+chunk, m_spec.y+m_spec.height);
ok &= read_scanlines (y+m_spec.y, yend, z+m_spec.z, format,
(char *)data + z*zstride + y*ystride,
xstride, ystride);
if (progress_callback)
if (progress_callback (progress_callback_data, (float)y/m_spec.height))
return ok;
}
}
if (progress_callback)
progress_callback (progress_callback_data, 1.0f);
return ok;
}
static void read_tile_from_file(struct tiff_tile *t, char *filename, int tidx)
{
TIFF *tif = tiffopen_fancy(filename, "r");
if (!tif) fail("could not open TIFF file \"%s\" for reading", filename);
uint32_t w, h;
uint16_t spp, bps, fmt, planarity;
TIFFGetFieldDefaulted(tif, TIFFTAG_IMAGEWIDTH, &w);
TIFFGetFieldDefaulted(tif, TIFFTAG_IMAGELENGTH, &h);
TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &spp);
TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &bps);
TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLEFORMAT, &fmt);
TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarity);
t->spp = spp;
t->bps = bps;
t->fmt = fmt;
t->broken = false;
if (planarity != PLANARCONFIG_CONTIG)
fail("broken pixels not supported yet");
if (TIFFIsTiled(tif)) {
int nt = TIFFNumberOfTiles(tif);
if (tidx < 0 || tidx >= nt)
fail("bad tile index %d", tidx);
t->w = tiff_tilewidth(tif);;
t->h = tiff_tilelength(tif);
int ii[2];
tiff_tile_corner(ii, tif, tidx);
//int ii = tw*i;
//int jj = th*j;
int tbytes = TIFFTileSize(tif);
t->data = xmalloc(tbytes);
memset(t->data, 0, tbytes);
int r = my_readtile(tif, t->data, ii[0], ii[1], 0, 0);
if (r != tbytes) fail("could not read tile");
} else { // not tiled, read the whole image into 0th tile
read_scanlines(t, tif);
}
TIFFClose(tif);
}