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

//

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

//

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

#include <ImfTiledOutputFile.h>

#include <ImfTiledInputFile.h>

#include <ImfTiledInputPart.h>

#include <ImfInputFile.h>

#include <ImfInputPart.h>

#include <ImfTileDescriptionAttribute.h>

#include <ImfPreviewImageAttribute.h>

#include <ImfChannelList.h>

#include <ImfMisc.h>

#include <ImfTiledMisc.h>

#include <ImfStdIO.h>

#include <ImfCompressor.h>

#include "ImathBox.h"

#include <ImfArray.h>

#include <ImfXdr.h>

#include <ImfVersion.h>

#include <ImfTileOffsets.h>

#include <ImfThreading.h>

#include <ImfPartType.h>

#include "IlmThreadPool.h"

#include "IlmThreadSemaphore.h"

#include "IlmThreadMutex.h"

#include "ImfOutputStreamMutex.h"

#include "ImfOutputPartData.h"

#include "Iex.h"

#include <string>

#include <vector>

#include <fstream>

#include <assert.h>

#include <map>

#include <algorithm>

#include "ImfNamespace.h"

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

using IMATH_NAMESPACE::Box2i;

using IMATH_NAMESPACE::V2i;

using std::string;

using std::vector;

using std::ofstream;

using std::map;

using std::min;

using std::max;

using std::swap;

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 TOutSliceInfo

{

    PixelType		type;

    const char *	base;

    size_t		xStride;

    size_t		yStride;

    bool		zero;

    int                 xTileCoords;

    int                 yTileCoords;

    TOutSliceInfo (PixelType type = HALF,

	           const char *base = 0,

	           size_t xStride = 0,

	           size_t yStride = 0,

	           bool zero = false,

                   int xTileCoords = 0,

                   int yTileCoords = 0);

};

TOutSliceInfo::TOutSliceInfo (PixelType t,

		              const char *b,

			      size_t xs, size_t ys,

			      bool z,

                              int xtc,

                              int ytc)

:

    type (t),

    base (b),

    xStride (xs),

    yStride (ys),

    zero (z),

    xTileCoords (xtc),

    yTileCoords (ytc)

{

    // empty

}

struct TileCoord

{

    int		dx;

    int		dy;

    int		lx;

    int		ly;

    TileCoord (int xTile = 0, int yTile = 0,

	       int xLevel = 0, int yLevel = 0)

    :

        dx (xTile),  dy (yTile),

	lx (xLevel), ly (yLevel)

    {

        // empty

    }

    bool

    operator < (const TileCoord &other) const

    {

        return (ly < other.ly) ||

	       (ly == other.ly && lx < other.lx) ||

	       ((ly == other.ly && lx == other.lx) &&

		    ((dy < other.dy) || (dy == other.dy && dx < other.dx)));

    }

    bool

    operator == (const TileCoord &other) const

    {

        return lx == other.lx &&

	       ly == other.ly &&

	       dx == other.dx &&

	       dy == other.dy;

    }

};

struct BufferedTile

{

    char *	pixelData;

    int		pixelDataSize;

    BufferedTile (const char *data, int size):

	pixelData (0),

	pixelDataSize(size)

    {

	pixelData = new char[pixelDataSize];

	memcpy (pixelData, data, pixelDataSize);

    }

    ~BufferedTile()

    {

	delete [] pixelData;

    }

};

typedef map <TileCoord, BufferedTile *> TileMap;

struct TileBuffer

{

    Array<char>		buffer;

    const char *	dataPtr;

    int			dataSize;

    Compressor *	compressor;

    TileCoord		tileCoord;

    bool		hasException;

    string		exception;

     TileBuffer (Compressor *comp);

    ~TileBuffer ();

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

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

  protected:

    Semaphore		_sem;

};

TileBuffer::TileBuffer (Compressor *comp):

    dataPtr (0),

    dataSize (0),

    compressor (comp),

    hasException (false),

    exception (),

    _sem (1)

{

    // empty

}

TileBuffer::~TileBuffer ()

{

    delete compressor;

}

} // namespace

struct TiledOutputFile::Data

{

    Header		header;			// the image header

    int			version;		// file format version

    bool                multipart;              // part came from a multipart file

    TileDescription	tileDesc;		// describes the tile layout

    FrameBuffer		frameBuffer;		// framebuffer to write into

    Int64		previewPosition;

    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

    int			numXLevels;		// number of x levels

    int			numYLevels;		// number of y levels

    int *		numXTiles;		// number of x tiles at a level

    int *		numYTiles;		// number of y tiles at a level

    TileOffsets		tileOffsets;		// stores offsets in file for

						// each tile

    Compressor::Format	format;			// compressor's data format

    vector<TOutSliceInfo> slices;		// info about channels in file

    size_t		maxBytesPerTileLine;	// combined size of a tile line

						// over all channels

    vector<TileBuffer*> tileBuffers;

    size_t		tileBufferSize;         // size of a tile buffer

    Int64		tileOffsetsPosition;	// position of the tile index

    TileMap		tileMap;

    TileCoord		nextTileToWrite;

    int                 partNumber;             // the output part number

     Data (int numThreads);

    ~Data ();

    inline TileBuffer *	getTileBuffer (int number);

    						// hash function from tile

						// buffer coords into our

						// vector of tile buffers

    TileCoord		nextTileCoord (const TileCoord &a);

};

TiledOutputFile::Data::Data (int numThreads):

    multipart(false),

    numXTiles(0),

    numYTiles(0),

    tileOffsetsPosition (0),

    partNumber(-1)

{

    //

    // We need at least one tileBuffer, but if threading is used,

    // to keep n threads busy we need 2*n tileBuffers

    //

    tileBuffers.resize (max (1, 2 * numThreads));

}

TiledOutputFile::Data::~Data ()

{

    delete [] numXTiles;

    delete [] numYTiles;

    //

    // Delete all the tile buffers, if any still happen to exist

    //

    for (TileMap::iterator i = tileMap.begin(); i != tileMap.end(); ++i)

	delete i->second;

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

        delete tileBuffers[i];

}

TileBuffer*

TiledOutputFile::Data::getTileBuffer (int number)

{

    return tileBuffers[number % tileBuffers.size()];

}

TileCoord

TiledOutputFile::Data::nextTileCoord (const TileCoord &a)

{

    TileCoord b = a;

    if (lineOrder == INCREASING_Y)

    {

        b.dx++;

        if (b.dx >= numXTiles[b.lx])

        {

            b.dx = 0;

            b.dy++;

            if (b.dy >= numYTiles[b.ly])

            {

		//

		// the next tile is in the next level

		//

                b.dy = 0;

                switch (tileDesc.mode)

                {

                  case ONE_LEVEL:

                  case MIPMAP_LEVELS:

                    b.lx++;

                    b.ly++;

                    break;

                  case RIPMAP_LEVELS:

                    b.lx++;

                    if (b.lx >= numXLevels)

                    {

                        b.lx = 0;

                        b.ly++;

			#ifdef DEBUG

			    assert (b.ly <= numYLevels);

			#endif

                    }

                    break;

                  case  NUM_LEVELMODES:

                      throw(IEX_NAMESPACE::ArgExc("Invalid tile description"));

                }

            }

        }

    }

    else if (lineOrder == DECREASING_Y)

    {

        b.dx++;

        if (b.dx >= numXTiles[b.lx])

        {

            b.dx = 0;

            b.dy--;

            if (b.dy < 0)

            {

		//

		// the next tile is in the next level

		//

                switch (tileDesc.mode)

                {

                  case ONE_LEVEL:

                  case MIPMAP_LEVELS:

                    b.lx++;

                    b.ly++;

                    break;

                  case RIPMAP_LEVELS:

                    b.lx++;

                    if (b.lx >= numXLevels)

                    {

                        b.lx = 0;

                        b.ly++;

			#ifdef DEBUG

			    assert (b.ly <= numYLevels);

			#endif

                    }

                    break;

                  case  NUM_LEVELMODES:

                      throw(IEX_NAMESPACE::ArgExc("Invalid tile description"));

                }

		if (b.ly < numYLevels)

		    b.dy = numYTiles[b.ly] - 1;

            }

        }

    }

    return b;   

}

namespace {

void

writeTileData (OutputStreamMutex *streamData,

               TiledOutputFile::Data *ofd,

               int dx, int dy,

	       int lx, int ly, 

               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 = streamData->currentPosition;

    streamData->currentPosition = 0;

    if (currentPosition == 0)

        currentPosition = streamData->os->tellp();

    ofd->tileOffsets (dx, dy, lx, ly) = currentPosition;

    #ifdef DEBUG

	assert (streamData->os->tellp() == currentPosition);

    #endif

    //

    // Write the tile header.

    //

    if (ofd->multipart)

    {

        Xdr::write <StreamIO> (*streamData->os, ofd->partNumber);

    }

    Xdr::write <StreamIO> (*streamData->os, dx);

    Xdr::write <StreamIO> (*streamData->os, dy);

    Xdr::write <StreamIO> (*streamData->os, lx);

    Xdr::write <StreamIO> (*streamData->os, ly);

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

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

    //

    // Keep current position in the file so that we can avoid 

    // redundant seekg() operations (seekg() can be fairly expensive).

    //

    streamData->currentPosition = currentPosition +

                           5 * Xdr::size<int>() +

                           pixelDataSize;

    if (ofd->multipart)

    {

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

    }

}

void

bufferedTileWrite (OutputStreamMutex *streamData,

                   TiledOutputFile::Data *ofd,

                   int dx, int dy,

		   int lx, int ly, 

                   const char pixelData[],

                   int pixelDataSize)

{

    //

    // Check if a tile with coordinates (dx,dy,lx,ly) has already been written.

    //

    if (ofd->tileOffsets (dx, dy, lx, ly))

    {

	THROW (IEX_NAMESPACE::ArgExc,

	       "Attempt to write tile "

	       "(" << dx << ", " << dy << ", " << lx << ", " << ly << ") "

	       "more than once.");

    }

    //

    // If tiles can be written in random order, then don't buffer anything.

    //

    if (ofd->lineOrder == RANDOM_Y)

    {

        writeTileData (streamData, ofd, dx, dy, lx, ly, pixelData, pixelDataSize);

        return;

    }

    //

    // If the tiles cannot be written in random order, then check if a

    // tile with coordinates (dx,dy,lx,ly) has already been buffered.

    //

    TileCoord currentTile = TileCoord(dx, dy, lx, ly);

    if (ofd->tileMap.find (currentTile) != ofd->tileMap.end())

    {

	THROW (IEX_NAMESPACE::ArgExc,

	       "Attempt to write tile "

	       "(" << dx << ", " << dy << ", " << lx << ", " << ly << ") "

	       "more than once.");

    }

    //

    // If all the tiles before this one have already been written to the file,

    // then write this tile immediately and check if we have buffered tiles

    // that can be written after this tile.

    //

    // Otherwise, buffer the tile so it can be written to file later.

    //

    if (ofd->nextTileToWrite == currentTile)

    {

        writeTileData (streamData, ofd, dx, dy, lx, ly, pixelData, pixelDataSize);

        ofd->nextTileToWrite = ofd->nextTileCoord (ofd->nextTileToWrite);

        TileMap::iterator i = ofd->tileMap.find (ofd->nextTileToWrite);

        //

        // Step through the tiles and write all successive buffered tiles after

        // the current one.

        //

        while(i != ofd->tileMap.end())

        {

            //

            // Write the tile, and then delete the tile's buffered data

            //

            writeTileData (streamData,

                           ofd,

			   i->first.dx, i->first.dy,

			   i->first.lx, i->first.ly,

			   i->second->pixelData,

			   i->second->pixelDataSize);

            delete i->second;

            ofd->tileMap.erase (i);

            //

            // Proceed to the next tile

            //

            ofd->nextTileToWrite = ofd->nextTileCoord (ofd->nextTileToWrite);

            i = ofd->tileMap.find (ofd->nextTileToWrite);

        }

    }

    else

    {

        //

        // Create a new BufferedTile, copy the pixelData into it, and

        // insert it into the tileMap.

        //

	ofd->tileMap[currentTile] =

	    new BufferedTile ((const char *)pixelData, pixelDataSize);

    }

}

void

convertToXdr (TiledOutputFile::Data *ofd,

              Array<char>& tileBuffer,

	      int numScanLines,

	      int numPixelsPerScanLine)

{

    //

    // Convert the contents of a TiledOutputFile's tileBuffer from the 

    // machine's native representation to Xdr format. This function is called

    // by writeTile(), 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.

    //

    //

    // Set these to point to the start of the tile.

    // We will write to toPtr, and read from fromPtr.

    //

    char *writePtr = tileBuffer;

    const char *readPtr = writePtr;

    //

    // Iterate over all scan lines in the tile.

    //

    for (int y = 0; y < numScanLines; ++y)

    {

	//

	// Iterate over all slices in the file.

	//

	for (unsigned int i = 0; i < ofd->slices.size(); ++i)

	{

	    const TOutSliceInfo &slice = ofd->slices[i];

	    //

	    // Convert the samples in place.

	    //

            convertInPlace (writePtr, readPtr, slice.type,

                            numPixelsPerScanLine);

	}

    }

    #ifdef DEBUG

	assert (writePtr == readPtr);

    #endif

}

//

// A TileBufferTask encapsulates the task of copying a tile from

// the user's framebuffer into a LineBuffer and compressing the data

// if necessary.

//

class TileBufferTask: public Task

{

  public:

    TileBufferTask (TaskGroup *group,

                    TiledOutputFile::Data *ofd,

                    int number,

		    int dx, int dy,

		    int lx, int ly);

    virtual ~TileBufferTask ();

    virtual void		execute ();

  private:

    TiledOutputFile::Data *	_ofd;

    TileBuffer *		_tileBuffer;

};

TileBufferTask::TileBufferTask

    (TaskGroup *group,

     TiledOutputFile::Data *ofd,

     int number,

     int dx, int dy,

     int lx, int ly)

:

    Task (group),

    _ofd (ofd),

    _tileBuffer (_ofd->getTileBuffer (number))

{

    //

    // Wait for the tileBuffer to become available

    //

    _tileBuffer->wait ();

    _tileBuffer->tileCoord = TileCoord (dx, dy, lx, ly);

}

TileBufferTask::~TileBufferTask ()

{

    //

    // Signal that the tile buffer is now free

    //

    _tileBuffer->post ();

}

void

TileBufferTask::execute ()

{

    try

    {

        //

        // First copy the pixel data from the frame buffer

	// into the tile buffer

        //

        // Convert one tile's worth of pixel data to

        // a machine-independent representation, and store

        // the result in _tileBuffer->buffer.

        //

        char *writePtr = _tileBuffer->buffer;

        Box2i tileRange = dataWindowForTile (_ofd->tileDesc,

                                                  _ofd->minX, _ofd->maxX,

                                                  _ofd->minY, _ofd->maxY,

                                                  _tileBuffer->tileCoord.dx,

                                                  _tileBuffer->tileCoord.dy,

                                                  _tileBuffer->tileCoord.lx,

                                                  _tileBuffer->tileCoord.ly);

        int numScanLines = tileRange.max.y - tileRange.min.y + 1;

        int numPixelsPerScanLine = tileRange.max.x - tileRange.min.x + 1;

        //

        // Iterate over the scan lines in the tile.

        //

        for (int y = tileRange.min.y; y <= tileRange.max.y; ++y)

        {

            //

            // Iterate over all image channels.

            //

            for (unsigned int i = 0; i < _ofd->slices.size(); ++i)

            {

                const TOutSliceInfo &slice = _ofd->slices[i];

                //

                // These offsets are used to facilitate both absolute

                // and tile-relative pixel coordinates.

                //

                int xOffset = slice.xTileCoords * tileRange.min.x;

                int yOffset = slice.yTileCoords * tileRange.min.y;

		//

		// Fill the tile buffer with pixel data.

		//

                if (slice.zero)

                {

                    //

                    // The frame buffer contains no data for this channel.

                    // Store zeroes in _data->tileBuffer.

                    //

                    fillChannelWithZeroes (writePtr, _ofd->format, slice.type,

                                           numPixelsPerScanLine);

                }

                else

                {

                    //

                    // The frame buffer contains data for this channel.

                    //

                    const char *readPtr = slice.base +

                                          (y - yOffset) * slice.yStride +

                                          (tileRange.min.x - xOffset) *

                                          slice.xStride;

                    const char *endPtr  = readPtr +

                                          (numPixelsPerScanLine - 1) *

                                          slice.xStride;

                    copyFromFrameBuffer (writePtr, readPtr, endPtr,

                                         slice.xStride, _ofd->format,

                                         slice.type);

                }

            }

        }

        //

        // Compress the contents of the tileBuffer, 

        // and store the compressed data in the output file.

        //

        _tileBuffer->dataSize = writePtr - _tileBuffer->buffer;

        _tileBuffer->dataPtr = _tileBuffer->buffer;

        if (_tileBuffer->compressor)

        {

            const char *compPtr;

            int compSize = _tileBuffer->compressor->compressTile

                                                (_tileBuffer->dataPtr,

                                                 _tileBuffer->dataSize,

                                                 tileRange, compPtr);

            if (compSize < _tileBuffer->dataSize)

            {

                _tileBuffer->dataSize = compSize;

                _tileBuffer->dataPtr = compPtr;

            }

            else if (_ofd->format == Compressor::NATIVE)

            {

                //

                // The data did not shrink during compression, but

                // we cannot write to the file using native format,

                // so we need to convert the lineBuffer to Xdr.

                //

                convertToXdr (_ofd, _tileBuffer->buffer, numScanLines,

                              numPixelsPerScanLine);

            }

        }

    }

    catch (std::exception &e)

    {

        if (!_tileBuffer->hasException)

        {

            _tileBuffer->exception = e.what ();

            _tileBuffer->hasException = true;

        }

    }

    catch (...)

    {

        if (!_tileBuffer->hasException)

        {

            _tileBuffer->exception = "unrecognized exception";

            _tileBuffer->hasException = true;

        }

    }

}

} // namespace

TiledOutputFile::TiledOutputFile

    (const char fileName[],

     const Header &header,

     int numThreads)

:

    _data (new Data (numThreads)),

    _streamData (new OutputStreamMutex()),

    _deleteStream (true)

{

    try

    {

	header.sanityCheck (true);

	_streamData->os = new StdOFStream (fileName);

        _data->multipart=false; // since we opened with one header we can't be multipart        

	initialize (header);

	_streamData->currentPosition = _streamData->os->tellp();

	// Write header and empty offset table to the file.

        writeMagicNumberAndVersionField(*_streamData->os, _data->header);

	_data->previewPosition = _data->header.writeTo (*_streamData->os, true);

        _data->tileOffsetsPosition = _data->tileOffsets.writeTo (*_streamData->os);

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        delete _streamData;

	delete _data;