///////////////////////////////////////////////////////////////////////////

//

// 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;

        delete _data;

        REPLACE_EXC (e, "Cannot open image file "

                        "\"" << fileName << "\". " << e);

        throw;

    }

    catch (...)

    {

        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)