1555 lines
49 KiB
C++
1555 lines
49 KiB
C++
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 2011, Industrial Light & Magic, a division of Lucas
|
|
// Digital Ltd. LLC
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Industrial Light & Magic nor the names of
|
|
// its contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// class DeepScanLineOutputFile
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include <ImfDeepScanLineOutputFile.h>
|
|
#include <ImfDeepScanLineInputFile.h>
|
|
#include <ImfDeepScanLineInputPart.h>
|
|
#include <ImfChannelList.h>
|
|
#include <ImfMisc.h>
|
|
#include <ImfStdIO.h>
|
|
#include <ImfCompressor.h>
|
|
#include "ImathBox.h"
|
|
#include "ImathFun.h"
|
|
#include <ImfArray.h>
|
|
#include <ImfXdr.h>
|
|
#include <ImfPreviewImageAttribute.h>
|
|
#include <ImfPartType.h>
|
|
#include "ImfDeepFrameBuffer.h"
|
|
#include "ImfOutputStreamMutex.h"
|
|
#include "ImfOutputPartData.h"
|
|
|
|
#include "IlmThreadPool.h"
|
|
#include "IlmThreadSemaphore.h"
|
|
#include "IlmThreadMutex.h"
|
|
#include "Iex.h"
|
|
#include <string>
|
|
#include <vector>
|
|
#include <fstream>
|
|
#include <assert.h>
|
|
#include <algorithm>
|
|
|
|
#include "ImfNamespace.h"
|
|
|
|
OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
|
|
|
|
using IMATH_NAMESPACE::Box2i;
|
|
using IMATH_NAMESPACE::divp;
|
|
using IMATH_NAMESPACE::modp;
|
|
using std::string;
|
|
using std::vector;
|
|
using std::ofstream;
|
|
using std::min;
|
|
using std::max;
|
|
using ILMTHREAD_NAMESPACE::Mutex;
|
|
using ILMTHREAD_NAMESPACE::Lock;
|
|
using ILMTHREAD_NAMESPACE::Semaphore;
|
|
using ILMTHREAD_NAMESPACE::Task;
|
|
using ILMTHREAD_NAMESPACE::TaskGroup;
|
|
using ILMTHREAD_NAMESPACE::ThreadPool;
|
|
|
|
namespace {
|
|
|
|
|
|
struct OutSliceInfo
|
|
{
|
|
PixelType type;
|
|
const char * base;
|
|
ptrdiff_t sampleStride;
|
|
ptrdiff_t xStride;
|
|
ptrdiff_t yStride;
|
|
int xSampling;
|
|
int ySampling;
|
|
bool zero;
|
|
|
|
OutSliceInfo (PixelType type = HALF,
|
|
const char * base =NULL,
|
|
ptrdiff_t sampleStride = 0,
|
|
ptrdiff_t xStride = 0,
|
|
ptrdiff_t yStride =0,
|
|
int xSampling = 1,
|
|
int ySampling = 1,
|
|
bool zero = false);
|
|
};
|
|
|
|
|
|
OutSliceInfo::OutSliceInfo (PixelType t,
|
|
const char * base,
|
|
ptrdiff_t spstride,
|
|
ptrdiff_t xst,
|
|
ptrdiff_t yst,
|
|
int xsm, int ysm,
|
|
bool z)
|
|
:
|
|
type (t),
|
|
base (base),
|
|
sampleStride (spstride),
|
|
xStride(xst),
|
|
yStride(yst),
|
|
xSampling (xsm),
|
|
ySampling (ysm),
|
|
zero (z)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
|
|
struct LineBuffer
|
|
{
|
|
Array< Array<char> > buffer;
|
|
Array<char> consecutiveBuffer;
|
|
const char * dataPtr;
|
|
Int64 uncompressedDataSize;
|
|
Int64 dataSize;
|
|
Array<char> sampleCountTableBuffer;
|
|
const char * sampleCountTablePtr;
|
|
Int64 sampleCountTableSize;
|
|
Compressor* sampleCountTableCompressor;
|
|
int minY; // the min y scanline stored
|
|
int maxY; // the max y scanline stored
|
|
int scanLineMin; // the min y scanline writing out
|
|
int scanLineMax; // the max y scanline writing out
|
|
Compressor * compressor;
|
|
bool partiallyFull; // has incomplete data
|
|
bool hasException;
|
|
string exception;
|
|
|
|
LineBuffer (int linesInBuffer);
|
|
~LineBuffer ();
|
|
|
|
void wait () {_sem.wait();}
|
|
void post () {_sem.post();}
|
|
|
|
private:
|
|
|
|
Semaphore _sem;
|
|
};
|
|
|
|
|
|
LineBuffer::LineBuffer (int linesInBuffer) :
|
|
dataPtr (0),
|
|
dataSize (0),
|
|
sampleCountTablePtr (0),
|
|
sampleCountTableCompressor (0),
|
|
compressor (0),
|
|
partiallyFull (false),
|
|
hasException (false),
|
|
exception (),
|
|
_sem (1)
|
|
{
|
|
buffer.resizeErase(linesInBuffer);
|
|
}
|
|
|
|
|
|
LineBuffer::~LineBuffer ()
|
|
{
|
|
if (compressor != 0)
|
|
delete compressor;
|
|
|
|
if (sampleCountTableCompressor != 0)
|
|
delete sampleCountTableCompressor;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
struct DeepScanLineOutputFile::Data
|
|
{
|
|
Header header; // the image header
|
|
int version; // file format version
|
|
bool multipart; // from a multipart file
|
|
Int64 previewPosition; // file position for preview
|
|
DeepFrameBuffer frameBuffer; // framebuffer to write into
|
|
int currentScanLine; // next scanline to be written
|
|
int missingScanLines; // number of lines to write
|
|
LineOrder lineOrder; // the file's lineorder
|
|
int minX; // data window's min x coord
|
|
int maxX; // data window's max x coord
|
|
int minY; // data window's min y coord
|
|
int maxY; // data window's max x coord
|
|
vector<Int64> lineOffsets; // stores offsets in file for
|
|
// each scanline
|
|
vector<size_t> bytesPerLine; // combined size of a line over
|
|
// all channels
|
|
Compressor::Format format; // compressor's data format
|
|
vector<OutSliceInfo*> slices; // info about channels in file
|
|
Int64 lineOffsetsPosition; // file position for line
|
|
// offset table
|
|
|
|
vector<LineBuffer*> lineBuffers; // each holds one line buffer
|
|
int linesInBuffer; // number of scanlines each
|
|
// buffer holds
|
|
int partNumber; // the output part number
|
|
|
|
char* sampleCountSliceBase; // the pointer to the number
|
|
// of samples in each pixel
|
|
int sampleCountXStride; // the x stride for sampleCountSliceBase
|
|
int sampleCountYStride; // the y stride for sampleCountSliceBase
|
|
|
|
Array<unsigned int> lineSampleCount; // the number of samples
|
|
// in each line
|
|
|
|
Int64 maxSampleCountTableSize;
|
|
// the max size in bytes for a pixel
|
|
// sample count table
|
|
OutputStreamMutex* _streamData;
|
|
bool _deleteStream;
|
|
|
|
Data (int numThreads);
|
|
~Data ();
|
|
|
|
|
|
inline LineBuffer * getLineBuffer (int number);// hash function from line
|
|
// buffer indices into our
|
|
// vector of line buffers
|
|
|
|
inline int& getSampleCount(int x, int y); // get the number of samples
|
|
// in each pixel
|
|
};
|
|
|
|
|
|
DeepScanLineOutputFile::Data::Data (int numThreads):
|
|
lineOffsetsPosition (0),
|
|
partNumber (-1) ,
|
|
_streamData(NULL),
|
|
_deleteStream(false)
|
|
{
|
|
//
|
|
// We need at least one lineBuffer, but if threading is used,
|
|
// to keep n threads busy we need 2*n lineBuffers.
|
|
//
|
|
|
|
lineBuffers.resize (max (1, 2 * numThreads));
|
|
for (size_t i = 0; i < lineBuffers.size(); i++)
|
|
lineBuffers[i] = 0;
|
|
}
|
|
|
|
|
|
DeepScanLineOutputFile::Data::~Data ()
|
|
{
|
|
for (size_t i = 0; i < lineBuffers.size(); i++)
|
|
if (lineBuffers[i] != 0)
|
|
delete lineBuffers[i];
|
|
|
|
for (size_t i = 0; i < slices.size(); i++)
|
|
delete slices[i];
|
|
}
|
|
|
|
|
|
int&
|
|
DeepScanLineOutputFile::Data::getSampleCount(int x, int y)
|
|
{
|
|
return sampleCount(sampleCountSliceBase,
|
|
sampleCountXStride,
|
|
sampleCountYStride,
|
|
x, y);
|
|
}
|
|
|
|
|
|
LineBuffer*
|
|
DeepScanLineOutputFile::Data::getLineBuffer (int number)
|
|
{
|
|
return lineBuffers[number % lineBuffers.size()];
|
|
}
|
|
|
|
|
|
namespace {
|
|
|
|
Int64
|
|
writeLineOffsets (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const vector<Int64> &lineOffsets)
|
|
{
|
|
Int64 pos = os.tellp();
|
|
|
|
if (pos == -1)
|
|
IEX_NAMESPACE::throwErrnoExc ("Cannot determine current file position (%T).");
|
|
|
|
for (unsigned int i = 0; i < lineOffsets.size(); i++)
|
|
OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, lineOffsets[i]);
|
|
|
|
return pos;
|
|
}
|
|
|
|
|
|
void
|
|
writePixelData (OutputStreamMutex *filedata,
|
|
DeepScanLineOutputFile::Data *partdata,
|
|
int lineBufferMinY,
|
|
const char pixelData[],
|
|
Int64 packedDataSize,
|
|
Int64 unpackedDataSize,
|
|
const char sampleCountTableData[],
|
|
Int64 sampleCountTableSize)
|
|
{
|
|
//
|
|
// Store a block of pixel data in the output file, and try
|
|
// to keep track of the current writing position the file
|
|
// without calling tellp() (tellp() can be fairly expensive).
|
|
//
|
|
|
|
Int64 currentPosition = filedata->currentPosition;
|
|
filedata->currentPosition = 0;
|
|
|
|
if (currentPosition == 0)
|
|
currentPosition = filedata->os->tellp();
|
|
|
|
partdata->lineOffsets[(partdata->currentScanLine - partdata->minY) / partdata->linesInBuffer] =
|
|
currentPosition;
|
|
|
|
#ifdef DEBUG
|
|
|
|
assert (filedata->os->tellp() == currentPosition);
|
|
|
|
#endif
|
|
|
|
//
|
|
// Write the optional part number.
|
|
//
|
|
|
|
if (partdata->multipart)
|
|
{
|
|
OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*filedata->os, partdata->partNumber);
|
|
}
|
|
|
|
//
|
|
// Write the y coordinate of the first scanline in the chunk.
|
|
//
|
|
|
|
OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*filedata->os, lineBufferMinY);
|
|
|
|
//
|
|
// Write the packed size of the pixel sample count table.
|
|
//
|
|
|
|
OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*filedata->os, sampleCountTableSize);
|
|
|
|
//
|
|
// Write the packed pixel data size.
|
|
//
|
|
|
|
OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*filedata->os, packedDataSize);
|
|
|
|
//
|
|
// Write the unpacked pixel data size.
|
|
//
|
|
|
|
OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*filedata->os, unpackedDataSize);
|
|
|
|
//
|
|
// Write the packed pixel sample count table.
|
|
//
|
|
|
|
filedata->os->write (sampleCountTableData, sampleCountTableSize);
|
|
|
|
//
|
|
// Write the compressed data.
|
|
//
|
|
|
|
filedata->os->write (pixelData, packedDataSize);
|
|
|
|
//
|
|
// Update stream position.
|
|
//
|
|
|
|
filedata->currentPosition = currentPosition +
|
|
Xdr::size<int>() + // y coordinate
|
|
Xdr::size<Int64>() + // packed sample count table size
|
|
Xdr::size<Int64>() + // packed data size
|
|
Xdr::size<Int64>() + // unpacked data size
|
|
sampleCountTableSize + // pixel sample count table
|
|
packedDataSize; // pixel data
|
|
|
|
if (partdata->multipart)
|
|
{
|
|
filedata->currentPosition += Xdr::size<int>(); // optional part number
|
|
}
|
|
}
|
|
|
|
|
|
inline void
|
|
writePixelData (OutputStreamMutex* filedata,
|
|
DeepScanLineOutputFile::Data *partdata,
|
|
const LineBuffer *lineBuffer)
|
|
{
|
|
writePixelData (filedata, partdata,
|
|
lineBuffer->minY,
|
|
lineBuffer->dataPtr,
|
|
lineBuffer->dataSize,
|
|
lineBuffer->uncompressedDataSize,
|
|
lineBuffer->sampleCountTablePtr,
|
|
lineBuffer->sampleCountTableSize);
|
|
}
|
|
|
|
|
|
void
|
|
convertToXdr (DeepScanLineOutputFile::Data *ofd,
|
|
Array<char> &lineBuffer,
|
|
int lineBufferMinY,
|
|
int lineBufferMaxY,
|
|
int inSize)
|
|
{
|
|
//
|
|
// Convert the contents of a lineBuffer from the machine's native
|
|
// representation to Xdr format. This function is called by
|
|
// CompressLineBuffer::execute(), below, if the compressor wanted
|
|
// its input pixel data in the machine's native format, but then
|
|
// failed to compress the data (most compressors will expand rather
|
|
// than compress random input data).
|
|
//
|
|
// Note that this routine assumes that the machine's native
|
|
// representation of the pixel data has the same size as the
|
|
// Xdr representation. This makes it possible to convert the
|
|
// pixel data in place, without an intermediate temporary buffer.
|
|
//
|
|
|
|
//
|
|
// Iterate over all scanlines in the lineBuffer to convert.
|
|
//
|
|
|
|
char* writePtr = &lineBuffer[0];
|
|
for (int y = lineBufferMinY; y <= lineBufferMaxY; y++)
|
|
{
|
|
//
|
|
// Set these to point to the start of line y.
|
|
// We will write to writePtr from readPtr.
|
|
//
|
|
|
|
const char *readPtr = writePtr;
|
|
|
|
//
|
|
// Iterate over all slices in the file.
|
|
//
|
|
|
|
for (unsigned int i = 0; i < ofd->slices.size(); ++i)
|
|
{
|
|
//
|
|
// Test if scan line y of this channel is
|
|
// contains any data (the scan line contains
|
|
// data only if y % ySampling == 0).
|
|
//
|
|
|
|
const OutSliceInfo &slice = *ofd->slices[i];
|
|
|
|
if (modp (y, slice.ySampling) != 0)
|
|
continue;
|
|
|
|
//
|
|
// Find the number of sampled pixels, dMaxX-dMinX+1, for
|
|
// slice i in scan line y (i.e. pixels within the data window
|
|
// for which x % xSampling == 0).
|
|
//
|
|
|
|
int xSampleCount = ofd->lineSampleCount[y - ofd->minY];
|
|
|
|
//
|
|
// Convert the samples in place.
|
|
//
|
|
|
|
convertInPlace (writePtr, readPtr, slice.type, xSampleCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// A LineBufferTask encapsulates the task of copying a set of scanlines
|
|
// from the user's frame buffer into a LineBuffer object, compressing
|
|
// the data if necessary.
|
|
//
|
|
|
|
class LineBufferTask: public Task
|
|
{
|
|
public:
|
|
|
|
LineBufferTask (TaskGroup *group,
|
|
DeepScanLineOutputFile::Data *ofd,
|
|
int number,
|
|
int scanLineMin,
|
|
int scanLineMax);
|
|
|
|
virtual ~LineBufferTask ();
|
|
|
|
virtual void execute ();
|
|
|
|
private:
|
|
|
|
DeepScanLineOutputFile::Data * _ofd;
|
|
LineBuffer * _lineBuffer;
|
|
};
|
|
|
|
|
|
LineBufferTask::LineBufferTask
|
|
(TaskGroup *group,
|
|
DeepScanLineOutputFile::Data *ofd,
|
|
int number,
|
|
int scanLineMin,
|
|
int scanLineMax)
|
|
:
|
|
Task (group),
|
|
_ofd (ofd),
|
|
_lineBuffer (_ofd->getLineBuffer(number))
|
|
{
|
|
//
|
|
// Wait for the lineBuffer to become available
|
|
//
|
|
|
|
_lineBuffer->wait ();
|
|
|
|
//
|
|
// Initialize the lineBuffer data if necessary
|
|
//
|
|
|
|
if (!_lineBuffer->partiallyFull)
|
|
{
|
|
|
|
_lineBuffer->minY = _ofd->minY + number * _ofd->linesInBuffer;
|
|
|
|
_lineBuffer->maxY = min (_lineBuffer->minY + _ofd->linesInBuffer - 1,
|
|
_ofd->maxY);
|
|
|
|
_lineBuffer->partiallyFull = true;
|
|
}
|
|
|
|
_lineBuffer->scanLineMin = max (_lineBuffer->minY, scanLineMin);
|
|
_lineBuffer->scanLineMax = min (_lineBuffer->maxY, scanLineMax);
|
|
}
|
|
|
|
|
|
LineBufferTask::~LineBufferTask ()
|
|
{
|
|
//
|
|
// Signal that the line buffer is now free
|
|
//
|
|
|
|
_lineBuffer->post ();
|
|
}
|
|
|
|
|
|
void
|
|
LineBufferTask::execute ()
|
|
{
|
|
try
|
|
{
|
|
//
|
|
// First copy the pixel data from the
|
|
// frame buffer into the line buffer
|
|
//
|
|
|
|
int yStart, yStop, dy;
|
|
|
|
if (_ofd->lineOrder == INCREASING_Y)
|
|
{
|
|
yStart = _lineBuffer->scanLineMin;
|
|
yStop = _lineBuffer->scanLineMax + 1;
|
|
dy = 1;
|
|
}
|
|
else
|
|
{
|
|
yStart = _lineBuffer->scanLineMax;
|
|
yStop = _lineBuffer->scanLineMin - 1;
|
|
dy = -1;
|
|
}
|
|
|
|
//
|
|
// Allocate buffers for scanlines.
|
|
// And calculate the sample counts for each line.
|
|
//
|
|
|
|
bytesPerDeepLineTable (_ofd->header,
|
|
_lineBuffer->scanLineMin,
|
|
_lineBuffer->scanLineMax,
|
|
_ofd->sampleCountSliceBase,
|
|
_ofd->sampleCountXStride,
|
|
_ofd->sampleCountYStride,
|
|
_ofd->bytesPerLine);
|
|
for (int i = _lineBuffer->scanLineMin; i <= _lineBuffer->scanLineMax; i++)
|
|
{
|
|
// (TODO) don't do this all the time.
|
|
_lineBuffer->buffer[i - _lineBuffer->minY].resizeErase(
|
|
_ofd->bytesPerLine[i - _ofd->minY]);
|
|
|
|
for (int j = _ofd->minX; j <= _ofd->maxX; j++)
|
|
_ofd->lineSampleCount[i - _ofd->minY] += _ofd->getSampleCount(j, i);
|
|
}
|
|
|
|
//
|
|
// Copy data from frame buffer to line buffer.
|
|
//
|
|
|
|
int y;
|
|
|
|
for (y = yStart; y != yStop; y += dy)
|
|
{
|
|
//
|
|
// Gather one scan line's worth of pixel data and store
|
|
// them in _ofd->lineBuffer.
|
|
//
|
|
|
|
char *writePtr = &_lineBuffer->buffer[y - _lineBuffer->minY][0];
|
|
//
|
|
// Iterate over all image channels.
|
|
//
|
|
|
|
for (unsigned int i = 0; i < _ofd->slices.size(); ++i)
|
|
{
|
|
//
|
|
// Test if scan line y of this channel contains any data
|
|
// (the scan line contains data only if y % ySampling == 0).
|
|
//
|
|
|
|
const OutSliceInfo &slice = *_ofd->slices[i];
|
|
|
|
if (modp (y, slice.ySampling) != 0)
|
|
continue;
|
|
|
|
//
|
|
// Fill the line buffer with with pixel data.
|
|
//
|
|
|
|
if (slice.zero)
|
|
{
|
|
//
|
|
// The frame buffer contains no data for this channel.
|
|
// Store zeroes in _lineBuffer->buffer.
|
|
//
|
|
|
|
fillChannelWithZeroes (writePtr, _ofd->format, slice.type,
|
|
_ofd->lineSampleCount[y - _ofd->minY]);
|
|
}
|
|
else
|
|
{
|
|
|
|
copyFromDeepFrameBuffer (writePtr, slice.base,
|
|
_ofd->sampleCountSliceBase,
|
|
_ofd->sampleCountXStride,
|
|
_ofd->sampleCountYStride,
|
|
y, _ofd->minX, _ofd->maxX,
|
|
0, 0,//offsets for samplecount
|
|
0, 0,//offsets for data
|
|
slice.sampleStride,
|
|
slice.xStride,
|
|
slice.yStride,
|
|
_ofd->format,
|
|
slice.type);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If the next scanline isn't past the bounds of the lineBuffer
|
|
// then we have partially filled the linebuffer,
|
|
// otherwise the whole linebuffer is filled and then
|
|
// we compress the linebuffer and write it out.
|
|
//
|
|
|
|
if (y >= _lineBuffer->minY && y <= _lineBuffer->maxY)
|
|
return;
|
|
|
|
//
|
|
// Copy all data into a consecutive buffer.
|
|
//
|
|
|
|
Int64 totalBytes = 0;
|
|
Int64 maxBytesPerLine = 0;
|
|
for (int i = 0; i < _lineBuffer->maxY - _lineBuffer->minY + 1; i++)
|
|
{
|
|
totalBytes += _lineBuffer->buffer[i].size();
|
|
if (Int64(_lineBuffer->buffer[i].size()) > maxBytesPerLine)
|
|
maxBytesPerLine = _lineBuffer->buffer[i].size();
|
|
}
|
|
_lineBuffer->consecutiveBuffer.resizeErase(totalBytes);
|
|
|
|
int pos = 0;
|
|
for (int i = 0; i < _lineBuffer->maxY - _lineBuffer->minY + 1; i++)
|
|
{
|
|
memcpy(_lineBuffer->consecutiveBuffer + pos,
|
|
&_lineBuffer->buffer[i][0],
|
|
_lineBuffer->buffer[i].size());
|
|
pos += _lineBuffer->buffer[i].size();
|
|
}
|
|
|
|
_lineBuffer->dataPtr = _lineBuffer->consecutiveBuffer;
|
|
|
|
_lineBuffer->dataSize = totalBytes;
|
|
_lineBuffer->uncompressedDataSize = _lineBuffer->dataSize;
|
|
|
|
//
|
|
// Compress the pixel sample count table.
|
|
//
|
|
|
|
char* ptr = _lineBuffer->sampleCountTableBuffer;
|
|
Int64 tableDataSize = 0;
|
|
for (int i = _lineBuffer->minY; i <= _lineBuffer->maxY; i++)
|
|
{
|
|
int count = 0;
|
|
for (int j = _ofd->minX; j <= _ofd->maxX; j++)
|
|
{
|
|
count += _ofd->getSampleCount(j, i);
|
|
Xdr::write <CharPtrIO> (ptr, count);
|
|
tableDataSize += sizeof (int);
|
|
}
|
|
}
|
|
|
|
if(_lineBuffer->sampleCountTableCompressor)
|
|
{
|
|
_lineBuffer->sampleCountTableSize =
|
|
_lineBuffer->sampleCountTableCompressor->compress (
|
|
_lineBuffer->sampleCountTableBuffer,
|
|
tableDataSize,
|
|
_lineBuffer->minY,
|
|
_lineBuffer->sampleCountTablePtr);
|
|
}
|
|
|
|
//
|
|
// If we can't make data shrink (or we weren't compressing), then just use the raw data.
|
|
//
|
|
|
|
if (!_lineBuffer->sampleCountTableCompressor ||
|
|
_lineBuffer->sampleCountTableSize >= tableDataSize)
|
|
{
|
|
_lineBuffer->sampleCountTableSize = tableDataSize;
|
|
_lineBuffer->sampleCountTablePtr = _lineBuffer->sampleCountTableBuffer;
|
|
}
|
|
|
|
//
|
|
// Compress the sample data
|
|
//
|
|
|
|
// (TODO) don't do this all the time.
|
|
if (_lineBuffer->compressor != 0)
|
|
delete _lineBuffer->compressor;
|
|
_lineBuffer->compressor = newCompressor (_ofd->header.compression(),
|
|
maxBytesPerLine,
|
|
_ofd->header);
|
|
|
|
Compressor *compressor = _lineBuffer->compressor;
|
|
|
|
if (compressor)
|
|
{
|
|
const char *compPtr;
|
|
|
|
Int64 compSize = compressor->compress (_lineBuffer->dataPtr,
|
|
_lineBuffer->dataSize,
|
|
_lineBuffer->minY, compPtr);
|
|
|
|
if (compSize < _lineBuffer->dataSize)
|
|
{
|
|
_lineBuffer->dataSize = compSize;
|
|
_lineBuffer->dataPtr = compPtr;
|
|
}
|
|
else if (_ofd->format == Compressor::NATIVE)
|
|
{
|
|
//
|
|
// The data did not shrink during compression, but
|
|
// we cannot write to the file using the machine's
|
|
// native format, so we need to convert the lineBuffer
|
|
// to Xdr.
|
|
//
|
|
|
|
convertToXdr (_ofd, _lineBuffer->consecutiveBuffer, _lineBuffer->minY,
|
|
_lineBuffer->maxY, _lineBuffer->dataSize);
|
|
}
|
|
}
|
|
|
|
_lineBuffer->partiallyFull = false;
|
|
}
|
|
catch (std::exception &e)
|
|
{
|
|
if (!_lineBuffer->hasException)
|
|
{
|
|
_lineBuffer->exception = e.what ();
|
|
_lineBuffer->hasException = true;
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
if (!_lineBuffer->hasException)
|
|
{
|
|
_lineBuffer->exception = "unrecognized exception";
|
|
_lineBuffer->hasException = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
DeepScanLineOutputFile::DeepScanLineOutputFile
|
|
(const char fileName[],
|
|
const Header &header,
|
|
int numThreads)
|
|
:
|
|
_data (new Data (numThreads))
|
|
{
|
|
_data->_streamData=new OutputStreamMutex ();
|
|
_data->_deleteStream=true;
|
|
try
|
|
{
|
|
header.sanityCheck();
|
|
_data->_streamData->os = new StdOFStream (fileName);
|
|
initialize (header);
|
|
_data->_streamData->currentPosition = _data->_streamData->os->tellp();
|
|
|
|
// Write header and empty offset table to the file.
|
|
writeMagicNumberAndVersionField(*_data->_streamData->os, _data->header);
|
|
_data->previewPosition =
|
|
_data->header.writeTo (*_data->_streamData->os);
|
|
_data->lineOffsetsPosition =
|
|
writeLineOffsets (*_data->_streamData->os, _data->lineOffsets);
|
|
_data->multipart=false;// not multipart; only one header
|
|
}
|
|
catch (IEX_NAMESPACE::BaseExc &e)
|
|
{
|
|
delete _data->_streamData->os;
|
|
delete _data->_streamData;
|
|
delete _data;
|
|
|
|
REPLACE_EXC (e, "Cannot open image file "
|
|
"\"" << fileName << "\". " << e.what());
|
|
throw;
|
|
}
|
|
catch (...)
|
|
{
|
|
delete _data->_streamData->os;
|
|
delete _data->_streamData;
|
|
delete _data;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
DeepScanLineOutputFile::DeepScanLineOutputFile
|
|
(OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
|
|
const Header &header,
|
|
int numThreads)
|
|
:
|
|
_data (new Data (numThreads))
|
|
|
|
{
|
|
_data->_streamData = new OutputStreamMutex ();
|
|
_data->_deleteStream = false;
|
|
try
|
|
{
|
|
header.sanityCheck();
|
|
_data->_streamData->os = &os;
|
|
initialize (header);
|
|
_data->_streamData->currentPosition = _data->_streamData->os->tellp();
|
|
|
|
// Write header and empty offset table to the file.
|
|
writeMagicNumberAndVersionField(*_data->_streamData->os, _data->header);
|
|
_data->previewPosition =
|
|
_data->header.writeTo (*_data->_streamData->os);
|
|
_data->lineOffsetsPosition =
|
|
writeLineOffsets (*_data->_streamData->os, _data->lineOffsets);
|
|
_data->multipart=false;
|
|
}
|
|
catch (IEX_NAMESPACE::BaseExc &e)
|
|
{
|
|
delete _data->_streamData;
|
|
delete _data;
|
|
|
|
REPLACE_EXC (e, "Cannot open image file "
|
|
"\"" << os.fileName() << "\". " << e.what());
|
|
throw;
|
|
}
|
|
catch (...)
|
|
{
|
|
delete _data->_streamData;
|
|
delete _data;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
DeepScanLineOutputFile::DeepScanLineOutputFile(const OutputPartData* part)
|
|
{
|
|
try
|
|
{
|
|
if (part->header.type() != DEEPSCANLINE)
|
|
throw IEX_NAMESPACE::ArgExc("Can't build a DeepScanLineOutputFile from a type-mismatched part.");
|
|
|
|
_data = new Data (part->numThreads);
|
|
_data->_streamData = part->mutex;
|
|
_data->_deleteStream=false;
|
|
initialize (part->header);
|
|
_data->partNumber = part->partNumber;
|
|
_data->lineOffsetsPosition = part->chunkOffsetTablePosition;
|
|
_data->previewPosition = part->previewPosition;
|
|
_data->multipart=part->multipart;
|
|
}
|
|
catch (IEX_NAMESPACE::BaseExc &e)
|
|
{
|
|
delete _data;
|
|
|
|
REPLACE_EXC (e, "Cannot initialize output part "
|
|
"\"" << part->partNumber << "\". " << e.what());
|
|
throw;
|
|
}
|
|
catch (...)
|
|
{
|
|
delete _data;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void
|
|
DeepScanLineOutputFile::initialize (const Header &header)
|
|
{
|
|
_data->header = header;
|
|
|
|
_data->header.setType(DEEPSCANLINE);
|
|
|
|
const Box2i &dataWindow = header.dataWindow();
|
|
|
|
_data->currentScanLine = (header.lineOrder() == INCREASING_Y)?
|
|
dataWindow.min.y: dataWindow.max.y;
|
|
|
|
_data->missingScanLines = dataWindow.max.y - dataWindow.min.y + 1;
|
|
_data->lineOrder = header.lineOrder();
|
|
_data->minX = dataWindow.min.x;
|
|
_data->maxX = dataWindow.max.x;
|
|
_data->minY = dataWindow.min.y;
|
|
_data->maxY = dataWindow.max.y;
|
|
|
|
_data->lineSampleCount.resizeErase(_data->maxY - _data->minY + 1);
|
|
|
|
Compressor* compressor = newCompressor (_data->header.compression(),
|
|
0,
|
|
_data->header);
|
|
_data->format = defaultFormat (compressor);
|
|
_data->linesInBuffer = numLinesInBuffer (compressor);
|
|
if (compressor != 0)
|
|
delete compressor;
|
|
|
|
int lineOffsetSize = (_data->maxY - _data->minY +
|
|
_data->linesInBuffer) / _data->linesInBuffer;
|
|
|
|
|
|
_data->header.setChunkCount(lineOffsetSize);
|
|
|
|
_data->lineOffsets.resize (lineOffsetSize);
|
|
|
|
_data->bytesPerLine.resize (_data->maxY - _data->minY + 1);
|
|
|
|
_data->maxSampleCountTableSize = min(_data->linesInBuffer, _data->maxY - _data->minY + 1) *
|
|
(_data->maxX - _data->minX + 1) *
|
|
sizeof(unsigned int);
|
|
|
|
for (size_t i = 0; i < _data->lineBuffers.size(); ++i)
|
|
{
|
|
_data->lineBuffers[i] = new LineBuffer (_data->linesInBuffer);
|
|
_data->lineBuffers[i]->sampleCountTableBuffer.resizeErase(_data->maxSampleCountTableSize);
|
|
|
|
_data->lineBuffers[i]->sampleCountTableCompressor =
|
|
newCompressor (_data->header.compression(),
|
|
_data->maxSampleCountTableSize,
|
|
_data->header);
|
|
}
|
|
}
|
|
|
|
|
|
DeepScanLineOutputFile::~DeepScanLineOutputFile ()
|
|
{
|
|
{
|
|
Lock lock(*_data->_streamData);
|
|
Int64 originalPosition = _data->_streamData->os->tellp();
|
|
|
|
if (_data->lineOffsetsPosition > 0)
|
|
{
|
|
try
|
|
{
|
|
_data->_streamData->os->seekp (_data->lineOffsetsPosition);
|
|
writeLineOffsets (*_data->_streamData->os, _data->lineOffsets);
|
|
|
|
//
|
|
// Restore the original position.
|
|
//
|
|
_data->_streamData->os->seekp (originalPosition);
|
|
}
|
|
catch (...)
|
|
{
|
|
//
|
|
// We cannot safely throw any exceptions from here.
|
|
// This destructor may have been called because the
|
|
// stack is currently being unwound for another
|
|
// exception.
|
|
//
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_data->_deleteStream)
|
|
delete _data->_streamData->os;
|
|
|
|
//
|
|
// (TODO) we should have a way to tell if the stream data is owned by this file or
|
|
// by a parent multipart file.
|
|
//
|
|
|
|
if (_data->partNumber == -1)
|
|
delete _data->_streamData;
|
|
|
|
delete _data;
|
|
}
|
|
|
|
|
|
const char *
|
|
DeepScanLineOutputFile::fileName () const
|
|
{
|
|
return _data->_streamData->os->fileName();
|
|
}
|
|
|
|
|
|
const Header &
|
|
DeepScanLineOutputFile::header () const
|
|
{
|
|
return _data->header;
|
|
}
|
|
|
|
|
|
void
|
|
DeepScanLineOutputFile::setFrameBuffer (const DeepFrameBuffer &frameBuffer)
|
|
{
|
|
Lock lock (*_data->_streamData);
|
|
|
|
//
|
|
// Check if the new frame buffer descriptor
|
|
// is compatible with the image file header.
|
|
//
|
|
|
|
const ChannelList &channels = _data->header.channels();
|
|
|
|
for (ChannelList::ConstIterator i = channels.begin();
|
|
i != channels.end();
|
|
++i)
|
|
{
|
|
DeepFrameBuffer::ConstIterator j = frameBuffer.find (i.name());
|
|
|
|
if (j == frameBuffer.end())
|
|
continue;
|
|
|
|
if (i.channel().type != j.slice().type)
|
|
{
|
|
THROW (IEX_NAMESPACE::ArgExc, "Pixel type of \"" << i.name() << "\" channel "
|
|
"of output file \"" << fileName() << "\" is "
|
|
"not compatible with the frame buffer's "
|
|
"pixel type.");
|
|
}
|
|
|
|
if (i.channel().xSampling != j.slice().xSampling ||
|
|
i.channel().ySampling != j.slice().ySampling)
|
|
{
|
|
THROW (IEX_NAMESPACE::ArgExc, "X and/or y subsampling factors "
|
|
"of \"" << i.name() << "\" channel "
|
|
"of output file \"" << fileName() << "\" are "
|
|
"not compatible with the frame buffer's "
|
|
"subsampling factors.");
|
|
}
|
|
}
|
|
|
|
//
|
|
// Store the pixel sample count table.
|
|
// (TODO) Support for different sampling rates?
|
|
//
|
|
|
|
const Slice& sampleCountSlice = frameBuffer.getSampleCountSlice();
|
|
if (sampleCountSlice.base == 0)
|
|
{
|
|
throw IEX_NAMESPACE::ArgExc ("Invalid base pointer, please set a proper sample count slice.");
|
|
}
|
|
else
|
|
{
|
|
_data->sampleCountSliceBase = sampleCountSlice.base;
|
|
_data->sampleCountXStride = sampleCountSlice.xStride;
|
|
_data->sampleCountYStride = sampleCountSlice.yStride;
|
|
}
|
|
|
|
//
|
|
// Initialize slice table for writePixels().
|
|
// Pixel sample count slice is not presented in the header,
|
|
// so it wouldn't be added here.
|
|
// Store the pixel base pointer table.
|
|
// (TODO) Support for different sampling rates?
|
|
//
|
|
|
|
vector<OutSliceInfo*> slices;
|
|
|
|
for (ChannelList::ConstIterator i = channels.begin();
|
|
i != channels.end();
|
|
++i)
|
|
{
|
|
DeepFrameBuffer::ConstIterator j = frameBuffer.find (i.name());
|
|
|
|
if (j == frameBuffer.end())
|
|
{
|
|
//
|
|
// Channel i is not present in the frame buffer.
|
|
// In the file, channel i will contain only zeroes.
|
|
//
|
|
|
|
slices.push_back (new OutSliceInfo (i.channel().type,
|
|
NULL,// base
|
|
0,// sampleStride,
|
|
0,// xStride
|
|
0,// yStride
|
|
i.channel().xSampling,
|
|
i.channel().ySampling,
|
|
true)); // zero
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Channel i is present in the frame buffer.
|
|
//
|
|
|
|
slices.push_back (new OutSliceInfo (j.slice().type,
|
|
j.slice().base,
|
|
j.slice().sampleStride,
|
|
j.slice().xStride,
|
|
j.slice().yStride,
|
|
j.slice().xSampling,
|
|
j.slice().ySampling,
|
|
false)); // zero
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Store the new frame buffer.
|
|
//
|
|
|
|
_data->frameBuffer = frameBuffer;
|
|
|
|
for (size_t i = 0; i < _data->slices.size(); i++)
|
|
delete _data->slices[i];
|
|
_data->slices = slices;
|
|
}
|
|
|
|
|
|
const DeepFrameBuffer &
|
|
DeepScanLineOutputFile::frameBuffer () const
|
|
{
|
|
Lock lock (*_data->_streamData);
|
|
return _data->frameBuffer;
|
|
}
|
|
|
|
|
|
void
|
|
DeepScanLineOutputFile::writePixels (int numScanLines)
|
|
{
|
|
try
|
|
{
|
|
Lock lock (*_data->_streamData);
|
|
|
|
if (_data->slices.size() == 0)
|
|
throw IEX_NAMESPACE::ArgExc ("No frame buffer specified "
|
|
"as pixel data source.");
|
|
|
|
//
|
|
// Maintain two iterators:
|
|
// nextWriteBuffer: next linebuffer to be written to the file
|
|
// nextCompressBuffer: next linebuffer to compress
|
|
//
|
|
|
|
int first = (_data->currentScanLine - _data->minY) /
|
|
_data->linesInBuffer;
|
|
|
|
int nextWriteBuffer = first;
|
|
int nextCompressBuffer;
|
|
int stop;
|
|
int step;
|
|
int scanLineMin;
|
|
int scanLineMax;
|
|
|
|
{
|
|
//
|
|
// Create a task group for all line buffer tasks. When the
|
|
// taskgroup goes out of scope, the destructor waits until
|
|
// all tasks are complete.
|
|
//
|
|
|
|
TaskGroup taskGroup;
|
|
|
|
//
|
|
// Determine the range of lineBuffers that intersect the scan
|
|
// line range. Then add the initial compression tasks to the
|
|
// thread pool. We always add in at least one task but the
|
|
// individual task might not do anything if numScanLines == 0.
|
|
//
|
|
|
|
if (_data->lineOrder == INCREASING_Y)
|
|
{
|
|
int last = (_data->currentScanLine + (numScanLines - 1) -
|
|
_data->minY) / _data->linesInBuffer;
|
|
|
|
scanLineMin = _data->currentScanLine;
|
|
scanLineMax = _data->currentScanLine + numScanLines - 1;
|
|
|
|
int numTasks = max (min ((int)_data->lineBuffers.size(),
|
|
last - first + 1),
|
|
1);
|
|
|
|
for (int i = 0; i < numTasks; i++)
|
|
{
|
|
ThreadPool::addGlobalTask
|
|
(new LineBufferTask (&taskGroup, _data, first + i,
|
|
scanLineMin, scanLineMax));
|
|
}
|
|
|
|
nextCompressBuffer = first + numTasks;
|
|
stop = last + 1;
|
|
step = 1;
|
|
}
|
|
else
|
|
{
|
|
int last = (_data->currentScanLine - (numScanLines - 1) -
|
|
_data->minY) / _data->linesInBuffer;
|
|
|
|
scanLineMax = _data->currentScanLine;
|
|
scanLineMin = _data->currentScanLine - numScanLines + 1;
|
|
|
|
int numTasks = max (min ((int)_data->lineBuffers.size(),
|
|
first - last + 1),
|
|
1);
|
|
|
|
for (int i = 0; i < numTasks; i++)
|
|
{
|
|
ThreadPool::addGlobalTask
|
|
(new LineBufferTask (&taskGroup, _data, first - i,
|
|
scanLineMin, scanLineMax));
|
|
}
|
|
|
|
nextCompressBuffer = first - numTasks;
|
|
stop = last - 1;
|
|
step = -1;
|
|
}
|
|
|
|
while (true)
|
|
{
|
|
if (_data->missingScanLines <= 0)
|
|
{
|
|
throw IEX_NAMESPACE::ArgExc ("Tried to write more scan lines "
|
|
"than specified by the data window.");
|
|
}
|
|
|
|
//
|
|
// Wait until the next line buffer is ready to be written
|
|
//
|
|
|
|
LineBuffer *writeBuffer =
|
|
_data->getLineBuffer (nextWriteBuffer);
|
|
|
|
writeBuffer->wait();
|
|
|
|
int numLines = writeBuffer->scanLineMax -
|
|
writeBuffer->scanLineMin + 1;
|
|
|
|
_data->missingScanLines -= numLines;
|
|
|
|
//
|
|
// If the line buffer is only partially full, then it is
|
|
// not complete and we cannot write it to disk yet.
|
|
//
|
|
|
|
if (writeBuffer->partiallyFull)
|
|
{
|
|
_data->currentScanLine = _data->currentScanLine +
|
|
step * numLines;
|
|
writeBuffer->post();
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Write the line buffer
|
|
//
|
|
|
|
writePixelData (_data->_streamData, _data, writeBuffer);
|
|
nextWriteBuffer += step;
|
|
|
|
_data->currentScanLine = _data->currentScanLine +
|
|
step * numLines;
|
|
|
|
#ifdef DEBUG
|
|
|
|
assert (_data->currentScanLine ==
|
|
((_data->lineOrder == INCREASING_Y) ?
|
|
writeBuffer->scanLineMax + 1:
|
|
writeBuffer->scanLineMin - 1));
|
|
|
|
#endif
|
|
|
|
//
|
|
// Release the lock on the line buffer
|
|
//
|
|
|
|
writeBuffer->post();
|
|
|
|
//
|
|
// If this was the last line buffer in the scanline range
|
|
//
|
|
|
|
if (nextWriteBuffer == stop)
|
|
break;
|
|
|
|
//
|
|
// If there are no more line buffers to compress,
|
|
// then only continue to write out remaining lineBuffers
|
|
//
|
|
|
|
if (nextCompressBuffer == stop)
|
|
continue;
|
|
|
|
//
|
|
// Add nextCompressBuffer as a compression task
|
|
//
|
|
|
|
ThreadPool::addGlobalTask
|
|
(new LineBufferTask (&taskGroup, _data, nextCompressBuffer,
|
|
scanLineMin, scanLineMax));
|
|
|
|
//
|
|
// Update the next line buffer we need to compress
|
|
//
|
|
|
|
nextCompressBuffer += step;
|
|
}
|
|
|
|
//
|
|
// Finish all tasks
|
|
//
|
|
}
|
|
|
|
//
|
|
// Exeption handling:
|
|
//
|
|
// LineBufferTask::execute() may have encountered exceptions, but
|
|
// those exceptions occurred in another thread, not in the thread
|
|
// that is executing this call to OutputFile::writePixels().
|
|
// LineBufferTask::execute() has caught all exceptions and stored
|
|
// the exceptions' what() strings in the line buffers.
|
|
// Now we check if any line buffer contains a stored exception; if
|
|
// this is the case then we re-throw the exception in this thread.
|
|
// (It is possible that multiple line buffers contain stored
|
|
// exceptions. We re-throw the first exception we find and
|
|
// ignore all others.)
|
|
//
|
|
|
|
const string *exception = 0;
|
|
|
|
for (size_t i = 0; i < _data->lineBuffers.size(); ++i)
|
|
{
|
|
LineBuffer *lineBuffer = _data->lineBuffers[i];
|
|
|
|
if (lineBuffer->hasException && !exception)
|
|
exception = &lineBuffer->exception;
|
|
|
|
lineBuffer->hasException = false;
|
|
}
|
|
|
|
if (exception)
|
|
throw IEX_NAMESPACE::IoExc (*exception);
|
|
}
|
|
catch (IEX_NAMESPACE::BaseExc &e)
|
|
{
|
|
REPLACE_EXC (e, "Failed to write pixel data to image "
|
|
"file \"" << fileName() << "\". " << e.what());
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
DeepScanLineOutputFile::currentScanLine () const
|
|
{
|
|
Lock lock (*_data->_streamData);
|
|
return _data->currentScanLine;
|
|
}
|
|
|
|
|
|
void
|
|
DeepScanLineOutputFile::copyPixels (DeepScanLineInputPart &in)
|
|
{
|
|
copyPixels(*in.file);
|
|
}
|
|
|
|
void
|
|
DeepScanLineOutputFile::copyPixels (DeepScanLineInputFile &in)
|
|
{
|
|
|
|
Lock lock (*_data->_streamData);
|
|
|
|
//
|
|
// Check if this file's and and the InputFile's
|
|
// headers are compatible.
|
|
//
|
|
|
|
const Header &hdr = _data->header;
|
|
const Header &inHdr = in.header();
|
|
|
|
if(!inHdr.hasType() || inHdr.type()!=DEEPSCANLINE)
|
|
{
|
|
THROW (IEX_NAMESPACE::ArgExc, "Cannot copy pixels from image "
|
|
"file \"" << in.fileName() << "\" to image "
|
|
"file \"" << fileName() << "\": the input needs to be a deep scanline image");
|
|
}
|
|
if (!(hdr.dataWindow() == inHdr.dataWindow()))
|
|
THROW (IEX_NAMESPACE::ArgExc, "Cannot copy pixels from image "
|
|
"file \"" << in.fileName() << "\" to image "
|
|
"file \"" << fileName() << "\". "
|
|
"The files have different data windows.");
|
|
|
|
if (!(hdr.lineOrder() == inHdr.lineOrder()))
|
|
THROW (IEX_NAMESPACE::ArgExc, "Quick pixel copy from image "
|
|
"file \"" << in.fileName() << "\" to image "
|
|
"file \"" << fileName() << "\" failed. "
|
|
"The files have different line orders.");
|
|
|
|
if (!(hdr.compression() == inHdr.compression()))
|
|
THROW (IEX_NAMESPACE::ArgExc, "Quick pixel copy from image "
|
|
"file \"" << in.fileName() << "\" to image "
|
|
"file \"" << fileName() << "\" failed. "
|
|
"The files use different compression methods.");
|
|
|
|
if (!(hdr.channels() == inHdr.channels()))
|
|
THROW (IEX_NAMESPACE::ArgExc, "Quick pixel copy from image "
|
|
"file \"" << in.fileName() << "\" to image "
|
|
"file \"" << fileName() << "\" failed. "
|
|
"The files have different channel lists.");
|
|
|
|
//
|
|
// Verify that no pixel data have been written to this file yet.
|
|
//
|
|
|
|
const Box2i &dataWindow = hdr.dataWindow();
|
|
|
|
if (_data->missingScanLines != dataWindow.max.y - dataWindow.min.y + 1)
|
|
THROW (IEX_NAMESPACE::LogicExc, "Quick pixel copy from image "
|
|
"file \"" << in.fileName() << "\" to image "
|
|
"file \"" << fileName() << "\" failed. "
|
|
"\"" << fileName() << "\" already contains "
|
|
"pixel data.");
|
|
|
|
//
|
|
// Copy the pixel data.
|
|
//
|
|
|
|
vector<char> data(4096);
|
|
|
|
while (_data->missingScanLines > 0)
|
|
{
|
|
Int64 dataSize = (Int64) data.size();
|
|
in.rawPixelData(_data->currentScanLine, &data[0], dataSize);
|
|
if(dataSize > data.size())
|
|
{
|
|
// block wasn't big enough - go again with enough memory this time
|
|
data.resize(dataSize);
|
|
in.rawPixelData(_data->currentScanLine, &data[0], dataSize);
|
|
}
|
|
|
|
// extract header from block to pass to writePixelData
|
|
|
|
Int64 packedSampleCountSize = *(Int64 *) (&data[4]);
|
|
Int64 packedDataSize = *(Int64 *) (&data[12]);
|
|
Int64 unpackedDataSize = *(Int64 *) (&data[20]);
|
|
const char * sampleCountTable = &data[0]+28;
|
|
const char * pixelData = sampleCountTable + packedSampleCountSize;
|
|
|
|
|
|
writePixelData (_data->_streamData, _data, lineBufferMinY (_data->currentScanLine,
|
|
_data->minY,
|
|
_data->linesInBuffer),
|
|
pixelData, packedDataSize, unpackedDataSize,sampleCountTable,packedSampleCountSize);
|
|
|
|
_data->currentScanLine += (_data->lineOrder == INCREASING_Y)?
|
|
_data->linesInBuffer: -_data->linesInBuffer;
|
|
|
|
_data->missingScanLines -= _data->linesInBuffer;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
DeepScanLineOutputFile::updatePreviewImage (const PreviewRgba newPixels[])
|
|
{
|
|
Lock lock (*_data->_streamData);
|
|
|
|
if (_data->previewPosition <= 0)
|
|
THROW (IEX_NAMESPACE::LogicExc, "Cannot update preview image pixels. "
|
|
"File \"" << fileName() << "\" does not "
|
|
"contain a preview image.");
|
|
|
|
//
|
|
// Store the new pixels in the header's preview image attribute.
|
|
//
|
|
|
|
PreviewImageAttribute &pia =
|
|
_data->header.typedAttribute <PreviewImageAttribute> ("preview");
|
|
|
|
PreviewImage &pi = pia.value();
|
|
PreviewRgba *pixels = pi.pixels();
|
|
int numPixels = pi.width() * pi.height();
|
|
|
|
for (int i = 0; i < numPixels; ++i)
|
|
pixels[i] = newPixels[i];
|
|
|
|
//
|
|
// Save the current file position, jump to the position in
|
|
// the file where the preview image starts, store the new
|
|
// preview image, and jump back to the saved file position.
|
|
//
|
|
|
|
Int64 savedPosition = _data->_streamData->os->tellp();
|
|
|
|
try
|
|
{
|
|
_data->_streamData->os->seekp (_data->previewPosition);
|
|
pia.writeValueTo (*_data->_streamData->os, _data->version);
|
|
_data->_streamData->os->seekp (savedPosition);
|
|
}
|
|
catch (IEX_NAMESPACE::BaseExc &e)
|
|
{
|
|
REPLACE_EXC (e, "Cannot update preview image pixels for "
|
|
"file \"" << fileName() << "\". " << e.what());
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT
|