//

///\todo: version needs fixing!

//

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

//

// Copyright (c) 2004, 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 OutputFile

//

//-----------------------------------------------------------------------------

#include <ImfOutputFile.h>

#include <ImfInputFile.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 "IlmThreadPool.h"

#include "ImfOutputStreamMutex.h"

#include "IlmThreadSemaphore.h"

#include "IlmThreadMutex.h"

#include "Iex.h"

#include "ImfInputPart.h"

#include "ImfNamespace.h"

#include "ImfOutputPartData.h"

#include <string>

#include <vector>

#include <fstream>

#include <assert.h>

#include <algorithm>

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;

    size_t    xStride;

    size_t    yStride;

    int     xSampling;

    int     ySampling;

    bool    zero;

    OutSliceInfo (PixelType type = HALF,

            const char *base = 0,

            size_t xStride = 0,

            size_t yStride = 0,

            int xSampling = 1,

            int ySampling = 1,

            bool zero = false);

};

OutSliceInfo::OutSliceInfo (PixelType t,

                const char *b,

                size_t xs, size_t ys,

                int xsm, int ysm,

                bool z)

:

    type (t),

    base (b),

    xStride (xs),

    yStride (ys),

    xSampling (xsm),

    ySampling (ysm),

    zero (z)

{

    // empty

}

struct LineBuffer

{

    Array<char>   buffer;

    const char *  dataPtr;

    int     dataSize;

    char *    endOfLineBufferData;

    int     minY;

    int     maxY;

    int     scanLineMin;

    int     scanLineMax;

    Compressor *  compressor;

    bool    partiallyFull;        // has incomplete data

    bool    hasException;

    string    exception;

    LineBuffer (Compressor *comp);

    ~LineBuffer ();

    void    wait () {_sem.wait();}

    void    post () {_sem.post();}

  private:

    Semaphore   _sem;

};

LineBuffer::LineBuffer (Compressor *comp) :

    dataPtr (0),

    dataSize (0),

    compressor (comp),

    partiallyFull (false),

    hasException (false),

    exception (),

    _sem (1)

{

    // empty

}

LineBuffer::~LineBuffer ()

{

    delete compressor;

}

} // namespace

struct OutputFile::Data

{

    Header     header;    // the image header

    bool                 multiPart;   // is the file multipart?

    int      version;               // version attribute \todo NOT BEING WRITTEN PROPERLY

    Int64    previewPosition;       // file position for preview

    FrameBuffer    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

    vector<size_t>   offsetInLineBuffer;    // offset for each scanline in

                                                // its linebuffer

    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

    size_t     lineBufferSize;        // size of the line buffer

    int                  partNumber;            // the output part number

    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

};

OutputFile::Data::Data (int numThreads):

    lineOffsetsPosition (0),

    partNumber (-1),

    _streamData(0),

    _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));

}

OutputFile::Data::~Data ()

{

    for (size_t i = 0; i < lineBuffers.size(); i++)

        delete lineBuffers[i];

}

LineBuffer*

OutputFile::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++)

  Xdr::write<StreamIO> (os, lineOffsets[i]);

    return pos;

}

void

writePixelData (OutputStreamMutex *filedata,

                OutputFile::Data *partdata,

                int lineBufferMinY,

                const char pixelData[],

                int pixelDataSize)

{

    //

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

    if (partdata->multiPart)

    {

        OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*filedata->os, partdata->partNumber);

    }

    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*filedata->os, lineBufferMinY);

    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*filedata->os, pixelDataSize);

    filedata->os->write (pixelData, pixelDataSize);

    filedata->currentPosition = currentPosition +

                           Xdr::size<int>() +

                           Xdr::size<int>() +

                           pixelDataSize;

    if (partdata->multiPart)

    {

        filedata->currentPosition += Xdr::size<int>();

    }

}

inline void

writePixelData (OutputStreamMutex* filedata,

                OutputFile::Data *partdata,

                const LineBuffer *lineBuffer)

{

    writePixelData (filedata, partdata,

                    lineBuffer->minY,

                    lineBuffer->dataPtr,

                    lineBuffer->dataSize);

}

void

convertToXdr (OutputFile::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 dMinX = divp (ofd->minX, slice.xSampling);

            int dMaxX = divp (ofd->maxX, slice.xSampling);

      //

            // Convert the samples in place.

      //

            convertInPlace (writePtr, readPtr, slice.type, dMaxX - dMinX + 1);

        }

    }

}

//

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

                    OutputFile::Data *ofd,

        int number,

                    int scanLineMin,

        int scanLineMax);

    virtual ~LineBufferTask (); 

    virtual void  execute ();

  private:

    OutputFile::Data *  _ofd;

    LineBuffer *  _lineBuffer;

};

LineBufferTask::LineBufferTask

    (TaskGroup *group,

     OutputFile::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->endOfLineBufferData = _lineBuffer->buffer;

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

        }

  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 +

                             _ofd->offsetInLineBuffer[y - _ofd->minY];

            //

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

                //

                // Find the x coordinates of the leftmost and rightmost

                // sampled pixels (i.e. pixels within the data window

                // for which x % xSampling == 0).

                //

                int dMinX = divp (_ofd->minX, slice.xSampling);

                int dMaxX = divp (_ofd->maxX, slice.xSampling);

                //

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

                                           dMaxX - dMinX + 1);

                }

                else

                {

                    //

                    // If necessary, convert the pixel data to Xdr format.

        // Then store the pixel data in _ofd->lineBuffer.

                    //

                    const char *linePtr = slice.base +

                                          divp (y, slice.ySampling) *

                                          slice.yStride;

                    const char *readPtr = linePtr + dMinX * slice.xStride;

                    const char *endPtr  = linePtr + dMaxX * slice.xStride;

                    copyFromFrameBuffer (writePtr, readPtr, endPtr,

                                         slice.xStride, _ofd->format,

                                         slice.type);

                }

            }

            if (_lineBuffer->endOfLineBufferData < writePtr)

                _lineBuffer->endOfLineBufferData = writePtr;

            #ifdef DEBUG

                assert (writePtr - (_lineBuffer->buffer +

                        _ofd->offsetInLineBuffer[y - _ofd->minY]) ==

                        (int) _ofd->bytesPerLine[y - _ofd->minY]);

            #endif

        }

        //

        // If the next scanline isn't past the bounds of the lineBuffer

        // then we are done, otherwise compress the linebuffer

        //

        if (y >= _lineBuffer->minY && y <= _lineBuffer->maxY)

            return;

        _lineBuffer->dataPtr = _lineBuffer->buffer;

        _lineBuffer->dataSize = _lineBuffer->endOfLineBufferData -

                                _lineBuffer->buffer;

  //

        // Compress the data

  //

        Compressor *compressor = _lineBuffer->compressor;

        if (compressor)

        {

            const char *compPtr;

            int 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->buffer, _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

OutputFile::OutputFile

    (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);

        _data->multiPart=false; // only one header, not multipart

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

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        // ~OutputFile will not run, so free memory here

        if (_data)

        {

            if (_data->_streamData)

            {

                delete _data->_streamData->os;

                delete _data->_streamData;

            }

            delete _data;

        }

  REPLACE_EXC (e, "Cannot open image file "

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

  throw;

    }

    catch (...)

    {

        // ~OutputFile will not run, so free memory here

        if (_data)

        {

            if (_data->_streamData)

            {

                delete _data->_streamData->os;

                delete _data->_streamData;

            }

            delete _data;

        }

        throw;

    }

}

OutputFile::OutputFile

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

        _data->multiPart=false;

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

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        // ~OutputFile will not run, so free memory here

        if (_data)

        {

            if (_data->_streamData)

                delete _data->_streamData;

            delete _data;

        }

        REPLACE_EXC (e, "Cannot open image file "

                     "\"" << os.fileName() << "\". " << e.what());

        throw;

    }

    catch (...)

    {

        // ~OutputFile will not run, so free memory here

        if (_data)

        {

            if (_data->_streamData)

                delete _data->_streamData;

            delete _data;

        }

        throw;

    }

}

OutputFile::OutputFile(const OutputPartData* part) : _data(NULL)

{

    try

    {

        if (part->header.type() != SCANLINEIMAGE)

            throw IEX_NAMESPACE::ArgExc("Can't build a OutputFile from a type-mismatched part.");

        _data = new Data (part->numThreads);

        _data->_streamData = part->mutex;

        _data->_deleteStream=false;

        _data->multiPart=part->multipart;

        initialize (part->header);

        _data->partNumber = part->partNumber;

        _data->lineOffsetsPosition = part->chunkOffsetTablePosition;

        _data->previewPosition = part->previewPosition;

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        if (_data) delete _data;

        REPLACE_EXC (e, "Cannot initialize output part "

                     "\"" << part->partNumber << "\". " << e.what());

        throw;

    }

    catch (...)

    {

        if (_data) delete _data;

        throw;

    }

}

void

OutputFile::initialize (const Header &header)

{

    _data->header = header;

    // "fix" the type if it happens to be set incorrectly

    // (attribute is optional, but ensure it is correct if it exists)

    if(_data->header.hasType())

    {

        _data->header.setType(SCANLINEIMAGE);

    }

    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;

    size_t maxBytesPerLine = bytesPerLineTable (_data->header,

            _data->bytesPerLine);

    for (size_t i = 0; i < _data->lineBuffers.size(); ++i)

    {

        _data->lineBuffers[i] =

      new LineBuffer (newCompressor (_data->header.compression(),

             maxBytesPerLine,

             _data->header));

    }

    LineBuffer *lineBuffer = _data->lineBuffers[0];

    _data->format = defaultFormat (lineBuffer->compressor);

    _data->linesInBuffer = numLinesInBuffer (lineBuffer->compressor);

    _data->lineBufferSize = maxBytesPerLine * _data->linesInBuffer;

    for (size_t i = 0; i < _data->lineBuffers.size(); i++)

        _data->lineBuffers[i]->buffer.resizeErase(_data->lineBufferSize);

    int lineOffsetSize = (dataWindow.max.y - dataWindow.min.y +

        _data->linesInBuffer) / _data->linesInBuffer;

    _data->lineOffsets.resize (lineOffsetSize);

    offsetInLineBufferTable (_data->bytesPerLine,

           _data->linesInBuffer,

           _data->offsetInLineBuffer);

}

OutputFile::~OutputFile ()

{

    if (_data)

    {

        {

            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 && _data->_streamData)

            delete _data->_streamData->os;

        if (_data->partNumber == -1 && _data->_streamData)

            delete _data->_streamData;

  delete _data;

    }

}

const char *

OutputFile::fileName () const

{

    return _data->_streamData->os->fileName();

}

const Header &

OutputFile::header () const

{

    return _data->header;

}

void  

OutputFile::setFrameBuffer (const FrameBuffer &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)

    {

  FrameBuffer::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.");

  }

    }

    //

    // Initialize slice table for writePixels().

    //

    vector<OutSliceInfo> slices;

    for (ChannelList::ConstIterator i = channels.begin();

   i != channels.end();

   ++i)

    {

  FrameBuffer::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 (OutSliceInfo (i.channel().type,

              0, // base

              0, // xStride,

              0, // yStride,