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

//

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

//	class TiledRgbaInputFile

//

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

#include <ImfTiledRgbaFile.h>

#include <ImfRgbaFile.h>

#include <ImfTiledOutputFile.h>

#include <ImfTiledInputFile.h>

#include <ImfChannelList.h>

#include <ImfTileDescriptionAttribute.h>

#include <ImfStandardAttributes.h>

#include <ImfRgbaYca.h>

#include <ImfArray.h>

#include "IlmThreadMutex.h"

#include "Iex.h"

#include "ImfNamespace.h"

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

using namespace std;

using namespace IMATH_NAMESPACE;

using namespace RgbaYca;

using namespace ILMTHREAD_NAMESPACE;

namespace {

void

insertChannels (Header &header,

		RgbaChannels rgbaChannels,

		const char fileName[])

{

    ChannelList ch;

    if (rgbaChannels & (WRITE_Y | WRITE_C))

    {

	if (rgbaChannels & WRITE_Y)

	{

	    ch.insert ("Y", Channel (HALF, 1, 1));

	}

	if (rgbaChannels & WRITE_C)

	{

	    THROW (IEX_NAMESPACE::ArgExc, "Cannot open file \"" << fileName << "\" "

				"for writing.  Tiled image files do not "

				"support subsampled chroma channels.");

	}

    }

    else

    {

	if (rgbaChannels & WRITE_R)

	    ch.insert ("R", Channel (HALF, 1, 1));

	if (rgbaChannels & WRITE_G)

	    ch.insert ("G", Channel (HALF, 1, 1));

	if (rgbaChannels & WRITE_B)

	    ch.insert ("B", Channel (HALF, 1, 1));

    }

    if (rgbaChannels & WRITE_A)

	ch.insert ("A", Channel (HALF, 1, 1));

    header.channels() = ch;

}

RgbaChannels

rgbaChannels (const ChannelList &ch, const string &channelNamePrefix = "")

{

    int i = 0;

    if (ch.findChannel (channelNamePrefix + "R"))

	i |= WRITE_R;

    if (ch.findChannel (channelNamePrefix + "G"))

	i |= WRITE_G;

    if (ch.findChannel (channelNamePrefix + "B"))

	i |= WRITE_B;

    if (ch.findChannel (channelNamePrefix + "A"))

	i |= WRITE_A;

    if (ch.findChannel (channelNamePrefix + "Y"))

	i |= WRITE_Y;

    return RgbaChannels (i);

}

string

prefixFromLayerName (const string &layerName, const Header &header)

{

    if (layerName.empty())

	return "";

    if (hasMultiView (header) && multiView(header)[0] == layerName)

	return "";

    return layerName + ".";

}

V3f

ywFromHeader (const Header &header)

{

    Chromaticities cr;

    if (hasChromaticities (header))

	cr = chromaticities (header);

    return computeYw (cr);

}

} // namespace

class TiledRgbaOutputFile::ToYa: public Mutex

{

  public:

     ToYa (TiledOutputFile &outputFile, RgbaChannels rgbaChannels);

     void	setFrameBuffer (const Rgba *base,

				size_t xStride,

				size_t yStride);

     void	writeTile (int dx, int dy, int lx, int ly);

  private:

     TiledOutputFile &	_outputFile;

     bool		_writeA;

     unsigned int	_tileXSize;

     unsigned int	_tileYSize;

     V3f		_yw;

     Array2D <Rgba>	_buf;

     const Rgba *	_fbBase;

     size_t		_fbXStride;

     size_t		_fbYStride;

};

TiledRgbaOutputFile::ToYa::ToYa (TiledOutputFile &outputFile,

				 RgbaChannels rgbaChannels)

:

    _outputFile (outputFile)

{

    _writeA = (rgbaChannels & WRITE_A)? true: false;

    const TileDescription &td = outputFile.header().tileDescription();

    _tileXSize = td.xSize;

    _tileYSize = td.ySize;

    _yw = ywFromHeader (_outputFile.header());

    _buf.resizeErase (_tileYSize, _tileXSize);

    _fbBase = 0;

    _fbXStride = 0;

    _fbYStride = 0;

}

void

TiledRgbaOutputFile::ToYa::setFrameBuffer (const Rgba *base,

					   size_t xStride,

					   size_t yStride)

{

    _fbBase = base;

    _fbXStride = xStride;

    _fbYStride = yStride;

}

void

TiledRgbaOutputFile::ToYa::writeTile (int dx, int dy, int lx, int ly)

{

    if (_fbBase == 0)

    {

	THROW (IEX_NAMESPACE::ArgExc, "No frame buffer was specified as the "

			    "pixel data source for image file "

			    "\"" << _outputFile.fileName() << "\".");

    }

    //

    // Copy the tile's RGBA pixels into _buf and convert

    // them to luminance/alpha format

    //

    Box2i dw = _outputFile.dataWindowForTile (dx, dy, lx, ly);

    int width = dw.max.x - dw.min.x + 1;

    for (int y = dw.min.y, y1 = 0; y <= dw.max.y; ++y, ++y1)

    {

	for (int x = dw.min.x, x1 = 0; x <= dw.max.x; ++x, ++x1)

	    _buf[y1][x1] = _fbBase[x * _fbXStride + y * _fbYStride];

	RGBAtoYCA (_yw, width, _writeA, _buf[y1], _buf[y1]);

    }

    //

    // Store the contents of _buf in the output file

    //

    FrameBuffer fb;

    fb.insert ("Y", Slice (HALF,				   // type

			   (char *) &_buf[-dw.min.y][-dw.min.x].g, // base

			   sizeof (Rgba),			   // xStride

			   sizeof (Rgba) * _tileXSize));	   // yStride

    fb.insert ("A", Slice (HALF,				   // type

			   (char *) &_buf[-dw.min.y][-dw.min.x].a, // base

			   sizeof (Rgba),			   // xStride

			   sizeof (Rgba) * _tileXSize));	   // yStride

    _outputFile.setFrameBuffer (fb);

    _outputFile.writeTile (dx, dy, lx, ly);

}

TiledRgbaOutputFile::TiledRgbaOutputFile

    (const char name[],

     const Header &header,

     RgbaChannels rgbaChannels,

     int tileXSize,

     int tileYSize,

     LevelMode mode,

     LevelRoundingMode rmode,

     int numThreads)

:

    _outputFile (0),

    _toYa (0)

{

    Header hd (header);

    insertChannels (hd, rgbaChannels, name);

    hd.setTileDescription (TileDescription (tileXSize, tileYSize, mode, rmode));

    _outputFile = new TiledOutputFile (name, hd, numThreads);

    if (rgbaChannels & WRITE_Y)

	_toYa = new ToYa (*_outputFile, rgbaChannels);

}

TiledRgbaOutputFile::TiledRgbaOutputFile

    (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,

     const Header &header,

     RgbaChannels rgbaChannels,

     int tileXSize,

     int tileYSize,

     LevelMode mode,

     LevelRoundingMode rmode,

     int numThreads)

:

    _outputFile (0),

    _toYa (0)

{

    Header hd (header);

    insertChannels (hd, rgbaChannels, os.fileName());

    hd.setTileDescription (TileDescription (tileXSize, tileYSize, mode, rmode));

    _outputFile = new TiledOutputFile (os, hd, numThreads);

    if (rgbaChannels & WRITE_Y)

	_toYa = new ToYa (*_outputFile, rgbaChannels);

}

TiledRgbaOutputFile::TiledRgbaOutputFile

    (const char name[],

     int tileXSize,

     int tileYSize,

     LevelMode mode,

     LevelRoundingMode rmode,

     const IMATH_NAMESPACE::Box2i &displayWindow,

     const IMATH_NAMESPACE::Box2i &dataWindow,

     RgbaChannels rgbaChannels,

     float pixelAspectRatio,

     const IMATH_NAMESPACE::V2f screenWindowCenter,

     float screenWindowWidth,

     LineOrder lineOrder,

     Compression compression,

     int numThreads)

:

    _outputFile (0),

    _toYa (0)

{

    Header hd (displayWindow,

	       dataWindow.isEmpty()? displayWindow: dataWindow,

	       pixelAspectRatio,

	       screenWindowCenter,

	       screenWindowWidth,

	       lineOrder,

	       compression);

    insertChannels (hd, rgbaChannels, name);

    hd.setTileDescription (TileDescription (tileXSize, tileYSize, mode, rmode));

    _outputFile = new TiledOutputFile (name, hd, numThreads);

    if (rgbaChannels & WRITE_Y)

	_toYa = new ToYa (*_outputFile, rgbaChannels);

}

TiledRgbaOutputFile::TiledRgbaOutputFile

    (const char name[],

     int width,

     int height,

     int tileXSize,

     int tileYSize,

     LevelMode mode,

     LevelRoundingMode rmode,

     RgbaChannels rgbaChannels,

     float pixelAspectRatio,

     const IMATH_NAMESPACE::V2f screenWindowCenter,

     float screenWindowWidth,

     LineOrder lineOrder,

     Compression compression,

     int numThreads)

:

    _outputFile (0),

    _toYa (0)

{

    Header hd (width,

	       height,

	       pixelAspectRatio,

	       screenWindowCenter,

	       screenWindowWidth,

	       lineOrder,

	       compression);

    insertChannels (hd, rgbaChannels, name);

    hd.setTileDescription (TileDescription (tileXSize, tileYSize, mode, rmode));

    _outputFile = new TiledOutputFile (name, hd, numThreads);

    if (rgbaChannels & WRITE_Y)

	_toYa = new ToYa (*_outputFile, rgbaChannels);

}

TiledRgbaOutputFile::~TiledRgbaOutputFile ()

{

    delete _outputFile;

    delete _toYa;

}

void

TiledRgbaOutputFile::setFrameBuffer (const Rgba *base,

				     size_t xStride,

				     size_t yStride)

{

    if (_toYa)

    {

	Lock lock (*_toYa);

	_toYa->setFrameBuffer (base, xStride, yStride);

    }

    else

    {

	size_t xs = xStride * sizeof (Rgba);

	size_t ys = yStride * sizeof (Rgba);

	FrameBuffer fb;

	fb.insert ("R", Slice (HALF, (char *) &base[0].r, xs, ys));

	fb.insert ("G", Slice (HALF, (char *) &base[0].g, xs, ys));

	fb.insert ("B", Slice (HALF, (char *) &base[0].b, xs, ys));

	fb.insert ("A", Slice (HALF, (char *) &base[0].a, xs, ys));

	_outputFile->setFrameBuffer (fb);

    }

}

const Header &

TiledRgbaOutputFile::header () const

{

    return _outputFile->header();

}

const FrameBuffer &

TiledRgbaOutputFile::frameBuffer () const

{

    return _outputFile->frameBuffer();

}

const IMATH_NAMESPACE::Box2i &

TiledRgbaOutputFile::displayWindow () const

{

    return _outputFile->header().displayWindow();

}

const IMATH_NAMESPACE::Box2i &

TiledRgbaOutputFile::dataWindow () const

{

    return _outputFile->header().dataWindow();

}

float	

TiledRgbaOutputFile::pixelAspectRatio () const

{

    return _outputFile->header().pixelAspectRatio();

}

const IMATH_NAMESPACE::V2f

TiledRgbaOutputFile::screenWindowCenter () const

{

    return _outputFile->header().screenWindowCenter();

}

float	

TiledRgbaOutputFile::screenWindowWidth () const

{

    return _outputFile->header().screenWindowWidth();

}

LineOrder

TiledRgbaOutputFile::lineOrder () const

{

    return _outputFile->header().lineOrder();

}

Compression

TiledRgbaOutputFile::compression () const

{

    return _outputFile->header().compression();

}

RgbaChannels

TiledRgbaOutputFile::channels () const

{

    return rgbaChannels (_outputFile->header().channels());

}

unsigned int

TiledRgbaOutputFile::tileXSize () const

{

     return _outputFile->tileXSize();

}

unsigned int

TiledRgbaOutputFile::tileYSize () const

{

     return _outputFile->tileYSize();

}

LevelMode

TiledRgbaOutputFile::levelMode () const

{

     return _outputFile->levelMode();

}

LevelRoundingMode

TiledRgbaOutputFile::levelRoundingMode () const

{

     return _outputFile->levelRoundingMode();

}

int

TiledRgbaOutputFile::numLevels () const

{

     return _outputFile->numLevels();

}

int

TiledRgbaOutputFile::numXLevels () const

{

     return _outputFile->numXLevels();

}

int

TiledRgbaOutputFile::numYLevels () const

{

     return _outputFile->numYLevels();

}

bool

TiledRgbaOutputFile::isValidLevel (int lx, int ly) const

{

    return _outputFile->isValidLevel (lx, ly);

}

int

TiledRgbaOutputFile::levelWidth (int lx) const

{

     return _outputFile->levelWidth (lx);

}

int

TiledRgbaOutputFile::levelHeight (int ly) const

{

     return _outputFile->levelHeight (ly);

}

int

TiledRgbaOutputFile::numXTiles (int lx) const

{

     return _outputFile->numXTiles (lx);

}

int

TiledRgbaOutputFile::numYTiles (int ly) const

{

     return _outputFile->numYTiles (ly);

}

IMATH_NAMESPACE::Box2i

TiledRgbaOutputFile::dataWindowForLevel (int l) const

{

     return _outputFile->dataWindowForLevel (l);

}

IMATH_NAMESPACE::Box2i

TiledRgbaOutputFile::dataWindowForLevel (int lx, int ly) const

{

     return _outputFile->dataWindowForLevel (lx, ly);

}

IMATH_NAMESPACE::Box2i

TiledRgbaOutputFile::dataWindowForTile (int dx, int dy, int l) const

{

     return _outputFile->dataWindowForTile (dx, dy, l);

}

IMATH_NAMESPACE::Box2i

TiledRgbaOutputFile::dataWindowForTile (int dx, int dy, int lx, int ly) const

{

     return _outputFile->dataWindowForTile (dx, dy, lx, ly);

}

void

TiledRgbaOutputFile::writeTile (int dx, int dy, int l)

{

    if (_toYa)

    {

	Lock lock (*_toYa);

	_toYa->writeTile (dx, dy, l, l);

    }

    else

    {

	 _outputFile->writeTile (dx, dy, l);

    }

}

void

TiledRgbaOutputFile::writeTile (int dx, int dy, int lx, int ly)

{

    if (_toYa)

    {

	Lock lock (*_toYa);

	_toYa->writeTile (dx, dy, lx, ly);

    }

    else

    {

	 _outputFile->writeTile (dx, dy, lx, ly);

    }

}

void	

TiledRgbaOutputFile::writeTiles

    (int dxMin, int dxMax, int dyMin, int dyMax, int lx, int ly)

{

    if (_toYa)

    {

	Lock lock (*_toYa);

        for (int dy = dyMin; dy <= dyMax; dy++)

            for (int dx = dxMin; dx <= dxMax; dx++)

	        _toYa->writeTile (dx, dy, lx, ly);

    }

    else

    {

        _outputFile->writeTiles (dxMin, dxMax, dyMin, dyMax, lx, ly);

    }

}

void	

TiledRgbaOutputFile::writeTiles

    (int dxMin, int dxMax, int dyMin, int dyMax, int l)

{

    writeTiles (dxMin, dxMax, dyMin, dyMax, l, l);

}

class TiledRgbaInputFile::FromYa: public Mutex

{

  public:

     FromYa (TiledInputFile &inputFile);

     void	setFrameBuffer (Rgba *base,

				size_t xStride,

				size_t yStride,

				const string &channelNamePrefix);

     void	readTile (int dx, int dy, int lx, int ly);

  private:

     TiledInputFile &	_inputFile;

     unsigned int	_tileXSize;

     unsigned int	_tileYSize;

     V3f		_yw;

     Array2D <Rgba>	_buf;

     Rgba *		_fbBase;

     size_t		_fbXStride;

     size_t		_fbYStride;

};

TiledRgbaInputFile::FromYa::FromYa (TiledInputFile &inputFile)

:

    _inputFile (inputFile)

{

    const TileDescription &td = inputFile.header().tileDescription();

    _tileXSize = td.xSize;

    _tileYSize = td.ySize;

    _yw = ywFromHeader (_inputFile.header());

    _buf.resizeErase (_tileYSize, _tileXSize);

    _fbBase = 0;

    _fbXStride = 0;

    _fbYStride = 0;

}

void

TiledRgbaInputFile::FromYa::setFrameBuffer (Rgba *base,

					    size_t xStride,

					    size_t yStride,

					    const string &channelNamePrefix)

{

    if (_fbBase == 0)

{

	FrameBuffer fb;

	fb.insert (channelNamePrefix + "Y",

		   Slice (HALF,				// type

			  (char *) &_buf[0][0].g,	// base

			  sizeof (Rgba),		// xStride

			  sizeof (Rgba) * _tileXSize,	// yStride

			  1, 1,				// sampling

			  0.0,				// fillValue

			  true, true));			// tileCoordinates

	fb.insert (channelNamePrefix + "A",

		   Slice (HALF,				// type

			  (char *) &_buf[0][0].a,	// base

			  sizeof (Rgba),		// xStride

			  sizeof (Rgba) * _tileXSize,	// yStride

			  1, 1,				// sampling

			  1.0,				// fillValue

			  true, true));			// tileCoordinates

	_inputFile.setFrameBuffer (fb);

    }

    _fbBase = base;

    _fbXStride = xStride;

    _fbYStride = yStride;

}

void

TiledRgbaInputFile::FromYa::readTile (int dx, int dy, int lx, int ly)

{

    if (_fbBase == 0)

    {

	THROW (IEX_NAMESPACE::ArgExc, "No frame buffer was specified as the "

			    "pixel data destination for image file "

			    "\"" << _inputFile.fileName() << "\".");

    }

    //

    // Read the tile requested by the caller into _buf.

    //

    _inputFile.readTile (dx, dy, lx, ly);

    //

    // Convert the luminance/alpha pixels to RGBA

    // and copy them into the caller's frame buffer.

    //

    Box2i dw = _inputFile.dataWindowForTile (dx, dy, lx, ly);

    int width = dw.max.x - dw.min.x + 1;

    for (int y = dw.min.y, y1 = 0; y <= dw.max.y; ++y, ++y1)

    {

	for (int x1 = 0; x1 < width; ++x1)

	{

	    _buf[y1][x1].r = 0;

	    _buf[y1][x1].b = 0;

	}

	YCAtoRGBA (_yw, width, _buf[y1], _buf[y1]);

	for (int x = dw.min.x, x1 = 0; x <= dw.max.x; ++x, ++x1)

	{

	    _fbBase[x * _fbXStride + y * _fbYStride] = _buf[y1][x1];

	}

    }

}

TiledRgbaInputFile::TiledRgbaInputFile (const char name[], int numThreads):

    _inputFile (new TiledInputFile (name, numThreads)),

    _fromYa (0),

    _channelNamePrefix ("")

{

    if (channels() & WRITE_Y)

	_fromYa = new FromYa (*_inputFile);

}

TiledRgbaInputFile::TiledRgbaInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads):

    _inputFile (new TiledInputFile (is, numThreads)),

    _fromYa (0),

    _channelNamePrefix ("")

{

    if (channels() & WRITE_Y)

	_fromYa = new FromYa (*_inputFile);

}

TiledRgbaInputFile::TiledRgbaInputFile (const char name[],

					const string &layerName,

					int numThreads)

:

    _inputFile (new TiledInputFile (name, numThreads)),

    _fromYa (0),

    _channelNamePrefix (prefixFromLayerName (layerName, _inputFile->header()))

{

    if (channels() & WRITE_Y)

	_fromYa = new FromYa (*_inputFile);

}

TiledRgbaInputFile::TiledRgbaInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,

					const string &layerName,

					int numThreads)

:

    _inputFile (new TiledInputFile (is, numThreads)),

    _fromYa (0),

    _channelNamePrefix (prefixFromLayerName (layerName, _inputFile->header()))

{

    if (channels() & WRITE_Y)

	_fromYa = new FromYa (*_inputFile);

}

TiledRgbaInputFile::~TiledRgbaInputFile ()

{

    delete _inputFile;

    delete _fromYa;

}

void	

TiledRgbaInputFile::setFrameBuffer (Rgba *base, size_t xStride, size_t yStride)

{

    if (_fromYa)

    {

	Lock lock (*_fromYa);

	_fromYa->setFrameBuffer (base, xStride, yStride, _channelNamePrefix);

    }

    else

    {

	size_t xs = xStride * sizeof (Rgba);

	size_t ys = yStride * sizeof (Rgba);

	FrameBuffer fb;

	fb.insert (_channelNamePrefix + "R",

		   Slice (HALF,

			       (char *) &base[0].r,

			       xs, ys,

			       1, 1,	// xSampling, ySampling

			       0.0));	// fillValue

	fb.insert (_channelNamePrefix + "G",

		   Slice (HALF,

			       (char *) &base[0].g,

			       xs, ys,

			       1, 1,	// xSampling, ySampling

			       0.0));	// fillValue

	fb.insert (_channelNamePrefix + "B",

		   Slice (HALF,

			       (char *) &base[0].b,

			       xs, ys,

			       1, 1,	// xSampling, ySampling

			       0.0));	// fillValue

	fb.insert (_channelNamePrefix + "A",

		   Slice (HALF,

			       (char *) &base[0].a,

			       xs, ys,

			       1, 1,	// xSampling, ySampling

			       1.0));	// fillValue

	_inputFile->setFrameBuffer (fb);

    }

}

void		

TiledRgbaInputFile::setLayerName (const std::string &layerName)

{

    delete _fromYa;

    _fromYa = 0;

    _channelNamePrefix = prefixFromLayerName (layerName, _inputFile->header());