bool
ImageOutputWrap::write_scanlines_bt (int ybegin, int yend, int z,
TypeDesc::BASETYPE format,
object &buffer, stride_t xstride)
{
return write_scanlines (ybegin, yend, z, format, buffer, xstride);
}
bool
PNGOutput::close ()
{
if (! m_file) { // already closed
init ();
return true;
}
bool ok = true;
if (m_spec.tile_width) {
// Handle tile emulation -- output the buffered pixels
ASSERT (m_tilebuffer.size());
ok &= write_scanlines (m_spec.y, m_spec.y+m_spec.height, 0,
m_spec.format, &m_tilebuffer[0]);
std::vector<unsigned char>().swap (m_tilebuffer);
}
if (m_png)
PNG_pvt::finish_image (m_png);
PNG_pvt::destroy_write_struct (m_png, m_info);
fclose (m_file);
m_file = NULL;
init (); // re-initialize
return ok;
}
bool
WebpOutput::close()
{
if (! m_file)
return true; // already closed
bool ok = true;
if (m_spec.tile_width) {
// We've been emulating tiles; now dump as scanlines.
ASSERT (m_uncompressed_image.size());
ok &= write_scanlines (m_spec.y, m_spec.y+m_spec.height, 0,
m_spec.format, &m_uncompressed_image[0]);
std::vector<uint8_t>().swap (m_uncompressed_image);
}
WebPPictureFree(&m_webp_picture);
fclose(m_file);
m_file = NULL;
return true;
}
bool
SgiOutput::close()
{
if (!m_fd) { // already closed
init();
return true;
}
bool ok = true;
if (m_spec.tile_width) {
// Handle tile emulation -- output the buffered pixels
ASSERT(m_tilebuffer.size());
ok &= write_scanlines(m_spec.y, m_spec.y + m_spec.height, 0,
m_spec.format, &m_tilebuffer[0]);
std::vector<unsigned char>().swap(m_tilebuffer);
}
fclose(m_fd);
init();
return ok;
}
bool
DPXOutput::close ()
{
if (! m_stream) { // already closed
init ();
return true;
}
bool ok = true;
if (m_spec.tile_width) {
// Handle tile emulation -- output the buffered pixels
ASSERT (m_tilebuffer.size());
ok &= write_scanlines (m_spec.y, m_spec.y+m_spec.height, 0,
m_spec.format, &m_tilebuffer[0]);
std::vector<unsigned char>().swap (m_tilebuffer);
}
ok &= write_buffer ();
m_dpx.Finish ();
init(); // Reset to initial state
return ok;
}
bool
HdrOutput::close ()
{
if (! m_fd) { // already closed
init ();
return true;
}
bool ok = true;
if (m_spec.tile_width) {
// We've been emulating tiles; now dump as scanlines.
ASSERT (m_tilebuffer.size());
ok &= write_scanlines (m_spec.y, m_spec.y+m_spec.height, 0,
m_spec.format, &m_tilebuffer[0]);
std::vector<unsigned char>().swap (m_tilebuffer);
}
fclose (m_fd);
m_fd = NULL;
init();
return ok;
}
bool
ZfileOutput::close ()
{
bool ok = true;
if (m_spec.tile_width) {
// We've been emulating tiles; now dump as scanlines.
ASSERT (m_tilebuffer.size());
ok &= write_scanlines (m_spec.y, m_spec.y+m_spec.height, 0,
m_spec.format, &m_tilebuffer[0]);
std::vector<unsigned char>().swap (m_tilebuffer);
}
if (m_gz) {
gzclose (m_gz);
m_gz = 0;
}
if (m_file) {
fclose (m_file);
m_file = NULL;
}
init (); // re-initialize
return ok;
}
bool
ImageOutput::write_image (TypeDesc format, const 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)
: format.size() * m_spec.nchannels;
if (xstride == AutoStride)
xstride = pixel_bytes;
m_spec.auto_stride (xstride, ystride, zstride, format,
m_spec.nchannels, m_spec.width, m_spec.height);
if (supports ("rectangles")) {
// Use a rectangle if we can
return write_rectangle (0, m_spec.width, 0, m_spec.height, 0, m_spec.depth,
format, data, xstride, ystride, zstride);
}
bool ok = true;
if (progress_callback && progress_callback (progress_callback_data, 0.0f))
return ok;
if (m_spec.tile_width && supports ("tiles")) {
// Tiled image
for (int z = 0; z < m_spec.depth; z += m_spec.tile_depth) {
int zend = std::min (z+m_spec.z+m_spec.tile_depth,
m_spec.z+m_spec.depth);
for (int y = 0; y < m_spec.height; y += m_spec.tile_height) {
int yend = std::min (y+m_spec.y+m_spec.tile_height,
m_spec.y+m_spec.height);
const char *d = (const char *)data + z*zstride + y*ystride;
ok &= write_tiles (m_spec.x, m_spec.x+m_spec.width,
y+m_spec.y, yend, z+m_spec.z, zend,
format, d, xstride, ystride, zstride);
if (progress_callback &&
progress_callback (progress_callback_data,
(float)(z*m_spec.height+y)/(m_spec.height*m_spec.depth)))
return ok;
}
}
} else {
// Scanline image
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);
const char *d = (const char *)data + z*zstride + y*ystride;
ok &= write_scanlines (y+m_spec.y, yend, z+m_spec.z,
format, d, xstride, ystride);
if (progress_callback &&
progress_callback (progress_callback_data,
(float)(z*m_spec.height+y)/(m_spec.height*m_spec.depth)))
return ok;
}
}
if (progress_callback)
progress_callback (progress_callback_data, 1.0f);
return ok;
}
