bool
OpenEXRInput::read_native_tile (int x, int y, int z, void *data)
{
return read_native_tiles (x, x+m_spec.tile_width, y, y+m_spec.tile_height,
z, z+m_spec.tile_depth,
0, m_spec.nchannels, data);
}
bool
OpenEXRInput::read_native_tiles (int xbegin, int xend, int ybegin, int yend,
int zbegin, int zend, void *data)
{
return read_native_tiles (xbegin, xend, ybegin, yend, zbegin, zend,
0, m_spec.nchannels, data);
}
bool
ImageInput::read_native_tiles (int xbegin, int xend, int ybegin, int yend,
int zbegin, int zend,
int chbegin, int chend, void *data)
{
chend = clamp (chend, chbegin+1, m_spec.nchannels);
int nchans = chend - chbegin;
// All-channel case just reduces to the simpler read_native_scanlines.
if (chbegin == 0 && chend >= m_spec.nchannels)
return read_native_tiles (xbegin, xend, ybegin, yend,
zbegin, zend, data);
if (! m_spec.valid_tile_range (xbegin, xend, ybegin, yend, zbegin, zend))
return false;
// Base class implementation of read_native_tiles just repeatedly
// calls read_native_tile, which is supplied by every plugin that
// supports tiles. Only the hardcore ones will overload
// read_native_tiles with their own implementation.
stride_t native_pixel_bytes = (stride_t) m_spec.pixel_bytes (true);
stride_t native_tileystride = native_pixel_bytes * m_spec.tile_width;
stride_t native_tilezstride = native_tileystride * m_spec.tile_height;
size_t prefix_bytes = m_spec.pixel_bytes (0,chbegin,true);
size_t subset_bytes = m_spec.pixel_bytes (chbegin,chend,true);
stride_t subset_ystride = (xend-xbegin) * subset_bytes;
stride_t subset_zstride = (yend-ybegin) * subset_ystride;
boost::scoped_array<char> pels (new char [m_spec.tile_bytes(true)]);
for (int z = zbegin; z < zend; z += m_spec.tile_depth) {
for (int y = ybegin; y < yend; y += m_spec.tile_height) {
for (int x = xbegin; x < xend; x += m_spec.tile_width) {
bool ok = read_native_tile (x, y, z, &pels[0]);
if (! ok)
return false;
copy_image (nchans, m_spec.tile_width,
m_spec.tile_height, m_spec.tile_depth,
&pels[prefix_bytes], subset_bytes,
native_pixel_bytes, native_tileystride,
native_tilezstride,
(char *)data+ (z-zbegin)*subset_zstride +
(y-ybegin)*subset_ystride +
(x-xbegin)*subset_bytes,
subset_bytes, subset_ystride, subset_zstride);
}
}
}
return true;
}
bool
ImageInput::read_tiles (int xbegin, int xend, int ybegin, int yend,
int zbegin, int zend,
int firstchan, int nchans,
TypeDesc format, void *data,
stride_t xstride, stride_t ystride, stride_t zstride)
{
if (! m_spec.valid_tile_range (xbegin, xend, ybegin, yend, zbegin, zend))
return false;
nchans = std::min (nchans, m_spec.nchannels-firstchan);
// native_pixel_bytes is the size of a pixel in the FILE, including
// the per-channel format.
stride_t native_pixel_bytes = (stride_t) m_spec.pixel_bytes (firstchan, nchans, true);
// perchanfile is true if the file has different per-channel formats
bool perchanfile = m_spec.channelformats.size();
// native_data is true if the user asking for data in the native format
bool native_data = (format == TypeDesc::UNKNOWN ||
(format == m_spec.format && !perchanfile));
if (format == TypeDesc::UNKNOWN && xstride == AutoStride)
xstride = native_pixel_bytes;
m_spec.auto_stride (xstride, ystride, zstride, format, nchans,
xend-xbegin, yend-ybegin);
// Do the strides indicate that the data area is contiguous?
bool contiguous = (native_data && xstride == native_pixel_bytes) ||
(!native_data && xstride == (stride_t)m_spec.pixel_bytes(false));
contiguous &= (ystride == xstride*(xend-xbegin) &&
(zstride == ystride*(yend-ybegin) || (zend-zbegin) <= 1));
int nxtiles = (xend - xbegin + m_spec.tile_width - 1) / m_spec.tile_width;
int nytiles = (yend - ybegin + m_spec.tile_height - 1) / m_spec.tile_height;
int nztiles = (zend - zbegin + m_spec.tile_depth - 1) / m_spec.tile_depth;
// If user's format and strides are set up to accept the native data
// layout, and we're asking for a whole number of tiles (no partial
// tiles at the edges), then read the tile directly into the user's
// buffer.
if (native_data && contiguous &&
(xend-xbegin) == nxtiles*m_spec.tile_width &&
(yend-ybegin) == nytiles*m_spec.tile_height &&
(zend-zbegin) == nztiles*m_spec.tile_depth) {
if (firstchan == 0 && nchans == m_spec.nchannels)
return read_native_tiles (xbegin, xend, ybegin, yend, zbegin, zend,
data); // Simple case
else
return read_native_tiles (xbegin, xend, ybegin, yend, zbegin, zend,
firstchan, nchans, data);
}
// No such luck. Just punt and read tiles individually.
bool ok = true;
stride_t pixelsize = native_data ? native_pixel_bytes
: (format.size() * nchans);
stride_t full_pixelsize = native_data ? m_spec.pixel_bytes(true)
: (format.size() * m_spec.nchannels);
size_t prefix_bytes = m_spec.pixel_bytes (0,firstchan,true);
std::vector<char> buf;
for (int z = zbegin; z < zend; z += std::max(1,m_spec.tile_depth)) {
int zd = std::min (zend-z, m_spec.tile_depth);
for (int y = ybegin; y < yend; y += m_spec.tile_height) {
char *tilestart = ((char *)data + (z-zbegin)*zstride
+ (y-ybegin)*ystride);
int yh = std::min (yend-y, m_spec.tile_height);
for (int x = xbegin; ok && x < xend; x += m_spec.tile_width) {
int xw = std::min (xend-x, m_spec.tile_width);
// Full tiles are read directly into the user buffer,
// but partial tiles (such as at the image edge) or
// partial channel subsets are read into a buffer and
// then copied.
if (xw == m_spec.tile_width && yh == m_spec.tile_height &&
zd == m_spec.tile_depth &&
firstchan == 0 && nchans == m_spec.nchannels) {
ok &= read_tile (x, y, z, format, tilestart,
xstride, ystride, zstride);
} else {
buf.resize (m_spec.tile_bytes());
ok &= read_tile (x, y, z, format, &buf[0],
full_pixelsize,
full_pixelsize*m_spec.tile_width,
full_pixelsize*m_spec.tile_pixels());
if (ok)
copy_image (nchans, xw, yh, zd, &buf[prefix_bytes],
pixelsize, full_pixelsize,
full_pixelsize*m_spec.tile_width,
full_pixelsize*m_spec.tile_pixels(),
tilestart, xstride, ystride, zstride);
}
tilestart += m_spec.tile_width * xstride;
}
}
}
if (! ok)
error ("ImageInput::read_tiles : no support for format %s",
m_spec.format.c_str());
return ok;
}
