const void *
ImageOutput::to_native_scanline (TypeDesc format,
const void *data, stride_t xstride,
std::vector<unsigned char> &scratch)
{
return to_native_rectangle (0, m_spec.width, 0, 1, 0, 1, format, data,
xstride, 0, 0, scratch);
}
const void *
ImageOutput::to_native_tile (TypeDesc format, const void *data,
stride_t xstride, stride_t ystride, stride_t zstride,
std::vector<unsigned char> &scratch)
{
return to_native_rectangle (0, m_spec.tile_width, 0, m_spec.tile_height,
0, std::max(1,m_spec.tile_depth), format, data,
xstride, ystride, zstride, scratch);
}
bool
OpenEXROutput::write_tiles (int xbegin, int xend, int ybegin, int yend,
int zbegin, int zend, TypeDesc format,
const void *data, stride_t xstride,
stride_t ystride, stride_t zstride)
{
// std::cerr << "exr::write_tiles " << xbegin << ' ' << xend
// << ' ' << ybegin << ' ' << yend << "\n";
if (! m_output_tiled ||
! m_spec.valid_tile_range (xbegin, xend, ybegin, yend, zbegin, zend))
return false;
// Compute where OpenEXR needs to think the full buffers starts.
// OpenImageIO requires that 'data' points to where the client wants
// to put the pixels being read, but OpenEXR's frameBuffer.insert()
// wants where the address of the "virtual framebuffer" for the
// whole image.
bool native = (format == TypeDesc::UNKNOWN);
size_t user_pixelbytes = m_spec.pixel_bytes (native);
size_t pixelbytes = m_spec.pixel_bytes (true);
if (native && xstride == AutoStride)
xstride = (stride_t) user_pixelbytes;
m_spec.auto_stride (xstride, ystride, zstride, format, spec().nchannels,
(xend-xbegin), (yend-ybegin));
data = to_native_rectangle (xbegin, xend, ybegin, yend, zbegin, zend,
format, data, xstride, ystride, zstride,
m_scratch);
// clamp to the image edge
xend = std::min (xend, m_spec.x+m_spec.width);
yend = std::min (yend, m_spec.y+m_spec.height);
zend = std::min (zend, m_spec.z+m_spec.depth);
int firstxtile = (xbegin-m_spec.x) / m_spec.tile_width;
int firstytile = (ybegin-m_spec.y) / m_spec.tile_height;
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;
std::vector<char> padded;
int width = nxtiles*m_spec.tile_width;
int height = nytiles*m_spec.tile_height;
stride_t widthbytes = width * pixelbytes;
if (width != (xend-xbegin) || height != (yend-ybegin)) {
// If the image region is not an even multiple of the tile size,
// we need to copy and add padding.
padded.resize (pixelbytes * width * height, 0);
OIIO::copy_image (m_spec.nchannels, xend-xbegin,
yend-ybegin, 1, data, pixelbytes,
pixelbytes, (xend-xbegin)*pixelbytes,
(xend-xbegin)*(yend-ybegin)*pixelbytes,
&padded[0], pixelbytes, widthbytes,
height*widthbytes);
data = &padded[0];
}
char *buf = (char *)data
- xbegin * pixelbytes
- ybegin * widthbytes;
try {
Imf::FrameBuffer frameBuffer;
size_t chanoffset = 0;
for (int c = 0; c < m_spec.nchannels; ++c) {
size_t chanbytes = m_spec.channelformats.size()
? m_spec.channelformats[c].size()
: m_spec.format.size();
frameBuffer.insert (m_spec.channelnames[c].c_str(),
Imf::Slice (m_pixeltype[c],
buf + chanoffset, pixelbytes,
widthbytes));
chanoffset += chanbytes;
}
m_output_tiled->setFrameBuffer (frameBuffer);
m_output_tiled->writeTiles (firstxtile, firstxtile+nxtiles-1,
firstytile, firstytile+nytiles-1,
m_miplevel, m_miplevel);
}
catch (const std::exception &e) {
error ("Failed OpenEXR write: %s", e.what());
return false;
}
return true;
}
bool
OpenEXROutput::write_scanlines (int ybegin, int yend, int z,
TypeDesc format, const void *data,
stride_t xstride, stride_t ystride)
{
yend = std::min (yend, spec().y+spec().height);
bool native = (format == TypeDesc::UNKNOWN);
imagesize_t scanlinebytes = spec().scanline_bytes(native);
size_t pixel_bytes = m_spec.pixel_bytes (native);
if (native && xstride == AutoStride)
xstride = (stride_t) pixel_bytes;
stride_t zstride = AutoStride;
m_spec.auto_stride (xstride, ystride, zstride, format, m_spec.nchannels,
m_spec.width, m_spec.height);
const imagesize_t limit = 16*1024*1024; // Allocate 16 MB, or 1 scanline
int chunk = std::max (1, int(limit / scanlinebytes));
bool ok = true;
for ( ; ok && ybegin < yend; ybegin += chunk) {
int y1 = std::min (ybegin+chunk, yend);
int nscanlines = y1 - ybegin;
const void *d = to_native_rectangle (m_spec.x, m_spec.x+m_spec.width,
ybegin, y1, z, z+1, format, data,
xstride, ystride, zstride,
m_scratch);
// Compute where OpenEXR needs to think the full buffers starts.
// OpenImageIO requires that 'data' points to where the client wants
// to put the pixels being read, but OpenEXR's frameBuffer.insert()
// wants where the address of the "virtual framebuffer" for the
// whole image.
char *buf = (char *)d
- m_spec.x * pixel_bytes
- ybegin * scanlinebytes;
try {
Imf::FrameBuffer frameBuffer;
size_t chanoffset = 0;
for (int c = 0; c < m_spec.nchannels; ++c) {
size_t chanbytes = m_spec.channelformats.size()
? m_spec.channelformats[c].size()
: m_spec.format.size();
frameBuffer.insert (m_spec.channelnames[c].c_str(),
Imf::Slice (m_pixeltype[c],
buf + chanoffset,
pixel_bytes, scanlinebytes));
chanoffset += chanbytes;
}
m_output_scanline->setFrameBuffer (frameBuffer);
m_output_scanline->writePixels (nscanlines);
}
catch (const std::exception &e) {
error ("Failed OpenEXR write: %s", e.what());
return false;
}
data = (const char *)data + ystride*nscanlines;
}
// If we allocated more than 1M, free the memory. It's not wasteful,
// because it means we're writing big chunks at a time, and therefore
// there will be few allocations and deletions.
if (m_scratch.size() > 1*1024*1024) {
std::vector<unsigned char> dummy;
std::swap (m_scratch, dummy);
}
return true;
}
