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

//

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

//	class RgbaInputFile

//

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

#include <ImfRgbaFile.h>

#include <ImfOutputFile.h>

#include <ImfInputFile.h>

#include <ImfChannelList.h>

#include <ImfRgbaYca.h>

#include <ImfStandardAttributes.h>

#include <ImathFun.h>

#include <IlmThreadMutex.h>

#include <Iex.h>

#include <string.h>

#include <algorithm>

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

{

    ChannelList ch;

    if (rgbaChannels & (WRITE_Y | WRITE_C))

    {

	if (rgbaChannels & WRITE_Y)

	{

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

	}

	if (rgbaChannels & WRITE_C)

	{

	    ch.insert ("RY", Channel (HALF, 2, 2, true));

	    ch.insert ("BY", Channel (HALF, 2, 2, true));

	}

    }

    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;

    if (ch.findChannel (channelNamePrefix + "RY") ||

	ch.findChannel (channelNamePrefix + "BY"))

	i |= WRITE_C;

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

}

ptrdiff_t

cachePadding (ptrdiff_t size)

{

    //

    // Some of the buffers that are allocated by classes ToYca and

    // FromYca, below, may need to be padded to avoid cache thrashing.

    // If the difference between the buffer size and the nearest power

    // of two is less than CACHE_LINE_SIZE, then we add an appropriate

    // amount of padding.

    //

    // CACHE_LINE_SIZE must be a power of two, and it must be at

    // least as big as the true size of a cache line on the machine

    // we are running on.  (It is ok if CACHE_LINE_SIZE is larger

    // than a real cache line.)

    //

    static int LOG2_CACHE_LINE_SIZE = 8;

    static const ptrdiff_t CACHE_LINE_SIZE = (1 << LOG2_CACHE_LINE_SIZE);

    int i = LOG2_CACHE_LINE_SIZE + 2;

    while ((size >> i) > 1)

	++i;

    if (size > (1 << (i + 1)) - 64)

	return 64 + ((1 << (i + 1)) - size);

    if (size < (1 << i) + 64)

	return 64 + ((1 << i) - size);

    return 0;

}

} // namespace

class RgbaOutputFile::ToYca: public Mutex

{

  public:

     ToYca (OutputFile &outputFile, RgbaChannels rgbaChannels);

    ~ToYca ();

    void		setYCRounding (unsigned int roundY,

	    			       unsigned int roundC);

    void		setFrameBuffer (const Rgba *base,

					size_t xStride,

					size_t yStride);

    void		writePixels (int numScanLines);

    int			currentScanLine () const;

  private:

    void		padTmpBuf ();

    void		rotateBuffers ();

    void		duplicateLastBuffer ();

    void		duplicateSecondToLastBuffer ();

    void		decimateChromaVertAndWriteScanLine ();

    OutputFile &	_outputFile;

    bool		_writeY;

    bool		_writeC;

    bool		_writeA;

    int			_xMin;

    int			_width;

    int			_height;

    int			_linesConverted;

    LineOrder		_lineOrder;

    int			_currentScanLine;

    V3f			_yw;

    Rgba *		_bufBase;

    Rgba *		_buf[N];

    Rgba *		_tmpBuf;

    const Rgba *	_fbBase;

    size_t		_fbXStride;

    size_t		_fbYStride;

    int			_roundY;

    int			_roundC;

};

RgbaOutputFile::ToYca::ToYca (OutputFile &outputFile,

			      RgbaChannels rgbaChannels)

:

    _outputFile (outputFile)

{

    _writeY = (rgbaChannels & WRITE_Y)? true: false;

    _writeC = (rgbaChannels & WRITE_C)? true: false;

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

    const Box2i dw = _outputFile.header().dataWindow();

    _xMin = dw.min.x;

    _width  = dw.max.x - dw.min.x + 1;

    _height = dw.max.y - dw.min.y + 1;

    _linesConverted = 0;

    _lineOrder = _outputFile.header().lineOrder();

    if (_lineOrder == INCREASING_Y)

	_currentScanLine = dw.min.y;

    else

	_currentScanLine = dw.max.y;

    _yw = ywFromHeader (_outputFile.header());

    ptrdiff_t pad = cachePadding (_width * sizeof (Rgba)) / sizeof (Rgba);

    _bufBase = new Rgba[(_width + pad) * N];

    for (int i = 0; i < N; ++i)

	_buf[i] = _bufBase + (i * (_width + pad));

    _tmpBuf = new Rgba[_width + N - 1];

    _fbBase = 0;

    _fbXStride = 0;

    _fbYStride = 0;

    _roundY = 7;

    _roundC = 5;

}

RgbaOutputFile::ToYca::~ToYca ()

{

    delete [] _bufBase;

    delete [] _tmpBuf;

}

void

RgbaOutputFile::ToYca::setYCRounding (unsigned int roundY,

				      unsigned int roundC)

{

    _roundY = roundY;

    _roundC = roundC;

}

void

RgbaOutputFile::ToYca::setFrameBuffer (const Rgba *base,

				       size_t xStride,

				       size_t yStride)

{

    if (_fbBase == 0)

    {

	FrameBuffer fb;

	if (_writeY)

	{

	    fb.insert ("Y",

		       Slice (HALF,				// type

			      (char *) &_tmpBuf[-_xMin].g,	// base

			      sizeof (Rgba),			// xStride

			      0,				// yStride

			      1,				// xSampling

			      1));				// ySampling

	}

	if (_writeC)

	{

	    fb.insert ("RY",

		       Slice (HALF,				// type

			      (char *) &_tmpBuf[-_xMin].r,	// base

			      sizeof (Rgba) * 2,		// xStride

			      0,				// yStride

			      2,				// xSampling

			      2));				// ySampling

	    fb.insert ("BY",

		       Slice (HALF,				// type

			      (char *) &_tmpBuf[-_xMin].b,	// base

			      sizeof (Rgba) * 2,		// xStride

			      0,				// yStride

			      2,				// xSampling

			      2));				// ySampling

	}

	if (_writeA)

	{

	    fb.insert ("A",

		       Slice (HALF,				// type

			      (char *) &_tmpBuf[-_xMin].a,	// base

			      sizeof (Rgba),			// xStride

			      0,				// yStride

			      1,				// xSampling

			      1));				// ySampling

	}

	_outputFile.setFrameBuffer (fb);

    }

    _fbBase = base;

    _fbXStride = xStride;

    _fbYStride = yStride;

}

void

RgbaOutputFile::ToYca::writePixels (int numScanLines)

{

    if (_fbBase == 0)

    {

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

			    "pixel data source for image file "

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

    }

    if (_writeY && !_writeC)

    {

	//

	// We are writing only luminance; filtering

	// and subsampling are not necessary.

	//

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

	{

	    //

	    // Copy the next scan line from the caller's

	    // frame buffer into _tmpBuf.

	    //

	    for (int j = 0; j < _width; ++j)

	    {

		_tmpBuf[j] = _fbBase[_fbYStride * _currentScanLine +

				     _fbXStride * (j + _xMin)];

	    }

	    //

	    // Convert the scan line from RGB to luminance/chroma,

	    // and store the result in the output file.

	    //

	    RGBAtoYCA (_yw, _width, _writeA, _tmpBuf, _tmpBuf);

	    _outputFile.writePixels (1);

	    ++_linesConverted;

	    if (_lineOrder == INCREASING_Y)

		++_currentScanLine;

	    else

		--_currentScanLine;

	}

    }

    else

    {

	//

	// We are writing chroma; the pixels must be filtered and subsampled.

	//

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

	{

	    //

	    // Copy the next scan line from the caller's

	    // frame buffer into _tmpBuf.

	    //

	    for (int j = 0; j < _width; ++j)

	    {

		_tmpBuf[j + N2] = _fbBase[_fbYStride * _currentScanLine +

					  _fbXStride * (j + _xMin)];

	    }

	    //

	    // Convert the scan line from RGB to luminance/chroma.

	    //

	    RGBAtoYCA (_yw, _width, _writeA, _tmpBuf + N2, _tmpBuf + N2);

	    //

	    // Append N2 copies of the first and last pixel to the

	    // beginning and end of the scan line.

	    //

	    padTmpBuf ();

	    //

	    // Filter and subsample the scan line's chroma channels

	    // horizontally; store the result in _buf.

	    //

	    rotateBuffers();

	    decimateChromaHoriz (_width, _tmpBuf, _buf[N - 1]);

	    //

	    // If this is the first scan line in the image,

	    // store N2 more copies of the scan line in _buf.

	    //

	    if (_linesConverted == 0)

	    {

		for (int j = 0; j < N2; ++j)

		    duplicateLastBuffer();

	    }

	    ++_linesConverted;

	    //

	    // If we have have converted at least N2 scan lines from

	    // RGBA to luminance/chroma, then we can start to filter

	    // and subsample vertically, and store pixels in the

	    // output file.

	    //

	    if (_linesConverted > N2)

		decimateChromaVertAndWriteScanLine();

	    //

	    // If we have already converted the last scan line in

	    // the image to luminance/chroma, filter, subsample and

	    // store the remaining scan lines in _buf.

	    //

	    if (_linesConverted >= _height)

	    {

		for (int j = 0; j < N2 - _height; ++j)

		    duplicateLastBuffer();

		duplicateSecondToLastBuffer();

		++_linesConverted;

		decimateChromaVertAndWriteScanLine();

		for (int j = 1; j < min (_height, N2); ++j)

		{

		    duplicateLastBuffer();

		    ++_linesConverted;

		    decimateChromaVertAndWriteScanLine();

		}

	    }

	    if (_lineOrder == INCREASING_Y)

		++_currentScanLine;

	    else

		--_currentScanLine;

	}

    }

}

int

RgbaOutputFile::ToYca::currentScanLine () const

{

    return _currentScanLine;

}

void

RgbaOutputFile::ToYca::padTmpBuf ()

{

    for (int i = 0; i < N2; ++i)

    {

	_tmpBuf[i] = _tmpBuf[N2];

	_tmpBuf[_width + N2 + i] = _tmpBuf[_width + N2 - 2];

    }

}

void

RgbaOutputFile::ToYca::rotateBuffers ()

{

    Rgba *tmp = _buf[0];

    for (int i = 0; i < N - 1; ++i)

	_buf[i] = _buf[i + 1];

    _buf[N - 1] = tmp;

}

void

RgbaOutputFile::ToYca::duplicateLastBuffer ()

{

    rotateBuffers();

    memcpy (_buf[N - 1], _buf[N - 2], _width * sizeof (Rgba));

}

void

RgbaOutputFile::ToYca::duplicateSecondToLastBuffer ()

{

    rotateBuffers();

    memcpy (_buf[N - 1], _buf[N - 3], _width * sizeof (Rgba));

}

void

RgbaOutputFile::ToYca::decimateChromaVertAndWriteScanLine ()

{

    if (_linesConverted & 1)

	memcpy (_tmpBuf, _buf[N2], _width * sizeof (Rgba));

    else

	decimateChromaVert (_width, _buf, _tmpBuf);

    if (_writeY && _writeC)

	roundYCA (_width, _roundY, _roundC, _tmpBuf, _tmpBuf);

    _outputFile.writePixels (1);

}

RgbaOutputFile::RgbaOutputFile (const char name[],

				const Header &header,

				RgbaChannels rgbaChannels,

                                int numThreads):

    _outputFile (0),

    _toYca (0)

{

    Header hd (header);

    insertChannels (hd, rgbaChannels);

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

    if (rgbaChannels & (WRITE_Y | WRITE_C))

	_toYca = new ToYca (*_outputFile, rgbaChannels);

}

RgbaOutputFile::RgbaOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,

				const Header &header,

				RgbaChannels rgbaChannels,

                                int numThreads):

    _outputFile (0),

    _toYca (0)

{

    Header hd (header);

    insertChannels (hd, rgbaChannels);

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

    if (rgbaChannels & (WRITE_Y | WRITE_C))

	_toYca = new ToYca (*_outputFile, rgbaChannels);

}

RgbaOutputFile::RgbaOutputFile (const char name[],

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

    _toYca (0)

{

    Header hd (displayWindow,

	       dataWindow.isEmpty()? displayWindow: dataWindow,

	       pixelAspectRatio,

	       screenWindowCenter,

	       screenWindowWidth,

	       lineOrder,

	       compression);

    insertChannels (hd, rgbaChannels);

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

    if (rgbaChannels & (WRITE_Y | WRITE_C))

	_toYca = new ToYca (*_outputFile, rgbaChannels);

}

RgbaOutputFile::RgbaOutputFile (const char name[],

				int width,

				int height,

				RgbaChannels rgbaChannels,

				float pixelAspectRatio,

				const IMATH_NAMESPACE::V2f screenWindowCenter,

				float screenWindowWidth,

				LineOrder lineOrder,

				Compression compression,

                                int numThreads):

    _outputFile (0),

    _toYca (0)

{

    Header hd (width,

	       height,

	       pixelAspectRatio,

	       screenWindowCenter,

	       screenWindowWidth,

	       lineOrder,

	       compression);

    insertChannels (hd, rgbaChannels);

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

    if (rgbaChannels & (WRITE_Y | WRITE_C))

	_toYca = new ToYca (*_outputFile, rgbaChannels);

}

RgbaOutputFile::~RgbaOutputFile ()

{

    delete _toYca;

    delete _outputFile;

}

void

RgbaOutputFile::setFrameBuffer (const Rgba *base,

				size_t xStride,

				size_t yStride)

{

    if (_toYca)

    {

	Lock lock (*_toYca);

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

    }

}

void	

RgbaOutputFile::writePixels (int numScanLines)

{

    if (_toYca)

    {

	Lock lock (*_toYca);

	_toYca->writePixels (numScanLines);

    }

    else

    {

	_outputFile->writePixels (numScanLines);

    }

}

int	

RgbaOutputFile::currentScanLine () const

{

    if (_toYca)

    {

	Lock lock (*_toYca);

	return _toYca->currentScanLine();

    }

    else

    {

	return _outputFile->currentScanLine();

    }

}

const Header &

RgbaOutputFile::header () const

{

    return _outputFile->header();

}

const FrameBuffer &

RgbaOutputFile::frameBuffer () const

{

    return _outputFile->frameBuffer();

}

const IMATH_NAMESPACE::Box2i &

RgbaOutputFile::displayWindow () const

{

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

}

const IMATH_NAMESPACE::Box2i &

RgbaOutputFile::dataWindow () const

{

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

}

float	

RgbaOutputFile::pixelAspectRatio () const

{

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

}

const IMATH_NAMESPACE::V2f

RgbaOutputFile::screenWindowCenter () const

{

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

}

float	

RgbaOutputFile::screenWindowWidth () const

{

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

}

LineOrder

RgbaOutputFile::lineOrder () const

{

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

}

Compression

RgbaOutputFile::compression () const

{

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

}

RgbaChannels

RgbaOutputFile::channels () const

{

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

}

void		

RgbaOutputFile::updatePreviewImage (const PreviewRgba newPixels[])

{

    _outputFile->updatePreviewImage (newPixels);

}

void		

RgbaOutputFile::setYCRounding (unsigned int roundY, unsigned int roundC)

{

    if (_toYca)

    {

	Lock lock (*_toYca);

	_toYca->setYCRounding (roundY, roundC);

    }

}

void	

RgbaOutputFile::breakScanLine  (int y, int offset, int length, char c)

{

    _outputFile->breakScanLine (y, offset, length, c);

}

class RgbaInputFile::FromYca: public Mutex

{

  public:

     FromYca (InputFile &inputFile, RgbaChannels rgbaChannels);

    ~FromYca ();

    void		setFrameBuffer (Rgba *base,

					size_t xStride,

					size_t yStride,

					const string &channelNamePrefix);

    void		readPixels (int scanLine1, int scanLine2);

  private:

    void		readPixels (int scanLine);

    void		rotateBuf1 (int d);

    void		rotateBuf2 (int d);

    void		readYCAScanLine (int y, Rgba buf[]);

    void		padTmpBuf ();

    InputFile &		_inputFile;

    bool		_readC;

    int			_xMin;

    int			_yMin;

    int 		_yMax;

    int			_width;

    int			_height;

    int			_currentScanLine;

    LineOrder		_lineOrder;

    V3f			_yw;

    Rgba *		_bufBase;

    Rgba *		_buf1[N + 2];

    Rgba *		_buf2[3];

    Rgba *		_tmpBuf;

    Rgba *		_fbBase;

    size_t		_fbXStride;

    size_t		_fbYStride;

};

RgbaInputFile::FromYca::FromYca (InputFile &inputFile,

				 RgbaChannels rgbaChannels)

:

    _inputFile (inputFile)

{

    _readC = (rgbaChannels & WRITE_C)? true: false;

    const Box2i dw = _inputFile.header().dataWindow();

    _xMin = dw.min.x;

    _yMin = dw.min.y;

    _yMax = dw.max.y;

    _width  = dw.max.x - dw.min.x + 1;

    _height = dw.max.y - dw.min.y + 1;

    _currentScanLine = dw.min.y - N - 2;

    _lineOrder = _inputFile.header().lineOrder();

    _yw = ywFromHeader (_inputFile.header());

    ptrdiff_t pad = cachePadding (_width * sizeof (Rgba)) / sizeof (Rgba);

    _bufBase = new Rgba[(_width + pad) * (N + 2 + 3)];

    for (int i = 0; i < N + 2; ++i)

	_buf1[i] = _bufBase + (i * (_width + pad));

    for (int i = 0; i < 3; ++i)

	_buf2[i] = _bufBase + ((i + N + 2) * (_width + pad));

    _tmpBuf = new Rgba[_width + N - 1];

    _fbBase = 0;

    _fbXStride = 0;