rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfRgbaFile.cpp

@@ -0,0 +1,1405 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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;
+    _fbYStride = 0;
+}
+
+
+RgbaInputFile::FromYca::~FromYca ()
+{
+    delete [] _bufBase;
+    delete [] _tmpBuf;
+}
+
+
+void
+RgbaInputFile::FromYca::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 *) &_tmpBuf[N2 - _xMin].g,	// base
+			  sizeof (Rgba),			// xStride
+			  0,					// yStride
+			  1,					// xSampling
+			  1,					// ySampling
+			  0.5));				// fillValue
+
+	if (_readC)
+	{
+	    fb.insert (channelNamePrefix + "RY",
+		       Slice (HALF,				// type
+			      (char *) &_tmpBuf[N2 - _xMin].r,	// base
+			      sizeof (Rgba) * 2,		// xStride
+			      0,				// yStride
+			      2,				// xSampling
+			      2,				// ySampling
+			      0.0));				// fillValue
+
+	    fb.insert (channelNamePrefix + "BY",
+		       Slice (HALF,				// type
+			      (char *) &_tmpBuf[N2 - _xMin].b,	// base
+			      sizeof (Rgba) * 2,		// xStride
+			      0,				// yStride
+			      2,				// xSampling
+			      2,				// ySampling
+			      0.0));				// fillValue
+	}
+
+	fb.insert (channelNamePrefix + "A",
+		   Slice (HALF,					// type
+			  (char *) &_tmpBuf[N2 - _xMin].a,	// base
+			  sizeof (Rgba),			// xStride
+			  0,					// yStride
+			  1,					// xSampling
+			  1,					// ySampling
+			  1.0));				// fillValue
+
+	_inputFile.setFrameBuffer (fb);
+    }
+
+    _fbBase = base;
+    _fbXStride = xStride;
+    _fbYStride = yStride;
+}
+
+
+void	
+RgbaInputFile::FromYca::readPixels (int scanLine1, int scanLine2)
+{
+    int minY = min (scanLine1, scanLine2);
+    int maxY = max (scanLine1, scanLine2);
+
+    if (_lineOrder == INCREASING_Y)
+    {
+	for (int y = minY; y <= maxY; ++y)
+	    readPixels (y);
+    }
+    else
+    {
+	for (int y = maxY; y >= minY; --y)
+	    readPixels (y);
+    }
+}
+
+
+void	
+RgbaInputFile::FromYca::readPixels (int scanLine)
+{
+    if (_fbBase == 0)
+    {
+	THROW (IEX_NAMESPACE::ArgExc, "No frame buffer was specified as the "
+			    "pixel data destination for image file "
+			    "\"" << _inputFile.fileName() << "\".");
+    }
+
+    //
+    // In order to convert one scan line to RGB format, we need that
+    // scan line plus N2+1 extra scan lines above and N2+1 scan lines
+    // below in luminance/chroma format.
+    //
+    // We allow random access to scan lines, but we buffer partially
+    // processed luminance/chroma data in order to make reading pixels
+    // in increasing y or decreasing y order reasonably efficient:
+    //
+    //	_currentScanLine	holds the y coordinate of the scan line
+    //				that was most recently read.
+    //
+    //	_buf1			contains scan lines _currentScanLine-N2-1
+    //				through _currentScanLine+N2+1 in
+    //				luminance/chroma format.  Odd-numbered
+    //				lines contain no chroma data.  Even-numbered
+    //				lines have valid chroma data for all pixels.
+    //
+    //  _buf2			contains scan lines _currentScanLine-1
+    //  			through _currentScanLine+1, in RGB format.
+    //				Super-saturated pixels (see ImfRgbaYca.h)
+    //				have not yet been eliminated.
+    //
+    // If the scan line we are trying to read now is close enough to
+    // _currentScanLine, we don't have to recompute the contents of _buf1
+    // and _buf2 from scratch.  We can rotate _buf1 and _buf2, and fill
+    // in the missing data.
+    //
+
+    int dy = scanLine - _currentScanLine;
+
+    if (abs (dy) < N + 2)
+	rotateBuf1 (dy);
+
+    if (abs (dy) < 3)
+	rotateBuf2 (dy);
+
+    if (dy < 0)
+    {
+	{
+	    int n = min (-dy, N + 2);
+	    int yMin = scanLine - N2 - 1;
+
+	    for (int i = n - 1; i >= 0; --i)
+		readYCAScanLine (yMin + i, _buf1[i]);
+	}
+
+	{
+	    int n = min (-dy, 3);
+
+	    for (int i = 0; i < n; ++i)
+	    {
+		if ((scanLine + i) & 1)
+		{
+		    YCAtoRGBA (_yw, _width, _buf1[N2 + i], _buf2[i]);
+		}
+		else
+		{
+		    reconstructChromaVert (_width, _buf1 + i, _buf2[i]);
+		    YCAtoRGBA (_yw, _width, _buf2[i], _buf2[i]);
+		}
+	    }
+	}
+    }
+    else
+    {
+	{
+	    int n = min (dy, N + 2);
+	    int yMax = scanLine + N2 + 1;
+
+	    for (int i = n - 1; i >= 0; --i)
+		readYCAScanLine (yMax - i, _buf1[N + 1 - i]);
+	}
+
+	{
+	    int n = min (dy, 3);
+
+	    for (int i = 2; i > 2 - n; --i)
+	    {
+		if ((scanLine + i) & 1)
+		{
+		    YCAtoRGBA (_yw, _width, _buf1[N2 + i], _buf2[i]);
+		}
+		else
+		{
+		    reconstructChromaVert (_width, _buf1 + i, _buf2[i]);
+		    YCAtoRGBA (_yw, _width, _buf2[i], _buf2[i]);
+		}
+	    }
+	}
+    }
+
+    fixSaturation (_yw, _width, _buf2, _tmpBuf);
+
+    for (int i = 0; i < _width; ++i)
+	_fbBase[_fbYStride * scanLine + _fbXStride * (i + _xMin)] = _tmpBuf[i];
+
+    _currentScanLine = scanLine;
+}
+
+
+void
+RgbaInputFile::FromYca::rotateBuf1 (int d)
+{
+    d = modp (d, N + 2);
+
+    Rgba *tmp[N + 2];
+
+    for (int i = 0; i < N + 2; ++i)
+	tmp[i] = _buf1[i];
+
+    for (int i = 0; i < N + 2; ++i)
+	_buf1[i] = tmp[(i + d) % (N + 2)];
+}
+
+
+void
+RgbaInputFile::FromYca::rotateBuf2 (int d)
+{
+    d = modp (d, 3);
+
+    Rgba *tmp[3];
+
+    for (int i = 0; i < 3; ++i)
+	tmp[i] = _buf2[i];
+
+    for (int i = 0; i < 3; ++i)
+	_buf2[i] = tmp[(i + d) % 3];
+}
+
+
+void
+RgbaInputFile::FromYca::readYCAScanLine (int y, Rgba *buf)
+{
+    //
+    // Clamp y.
+    //
+
+    if (y < _yMin)
+	y = _yMin;
+    else if (y > _yMax)
+	y = _yMax - 1;
+
+    //
+    // Read scan line y into _tmpBuf.
+    //
+
+    _inputFile.readPixels (y);
+
+    //
+    // Reconstruct missing chroma samples and copy
+    // the scan line into buf.
+    //
+
+    if (!_readC)
+    {
+	for (int i = 0; i < _width; ++i)
+	{
+	    _tmpBuf[i + N2].r = 0;
+	    _tmpBuf[i + N2].b = 0;
+	}
+    }
+
+    if (y & 1)
+    {
+	memcpy (buf, _tmpBuf + N2, _width * sizeof (Rgba));
+    }
+    else
+    {
+	padTmpBuf();
+	reconstructChromaHoriz (_width, _tmpBuf, buf);
+    }
+}
+
+
+void
+RgbaInputFile::FromYca::padTmpBuf ()
+{
+    for (int i = 0; i < N2; ++i)
+    {
+	_tmpBuf[i] = _tmpBuf[N2];
+	_tmpBuf[_width + N2 + i] = _tmpBuf[_width + N2 - 2];
+    }
+}
+
+
+RgbaInputFile::RgbaInputFile (const char name[], int numThreads):
+    _inputFile (new InputFile (name, numThreads)),
+    _fromYca (0),
+    _channelNamePrefix ("")
+{
+    RgbaChannels rgbaChannels = channels();
+
+    if (rgbaChannels & (WRITE_Y | WRITE_C))
+	_fromYca = new FromYca (*_inputFile, rgbaChannels);
+}
+
+
+RgbaInputFile::RgbaInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads):
+    _inputFile (new InputFile (is, numThreads)),
+    _fromYca (0),
+    _channelNamePrefix ("")
+{
+    RgbaChannels rgbaChannels = channels();
+
+    if (rgbaChannels & (WRITE_Y | WRITE_C))
+	_fromYca = new FromYca (*_inputFile, rgbaChannels);
+}
+
+
+RgbaInputFile::RgbaInputFile (const char name[],
+			      const string &layerName,
+			      int numThreads)
+:
+    _inputFile (new InputFile (name, numThreads)),
+    _fromYca (0),
+    _channelNamePrefix (prefixFromLayerName (layerName, _inputFile->header()))
+{
+    RgbaChannels rgbaChannels = channels();
+
+    if (rgbaChannels & (WRITE_Y | WRITE_C))
+	_fromYca = new FromYca (*_inputFile, rgbaChannels);
+}
+
+
+RgbaInputFile::RgbaInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,
+			      const string &layerName,
+			      int numThreads)
+:
+    _inputFile (new InputFile (is, numThreads)),
+    _fromYca (0),
+    _channelNamePrefix (prefixFromLayerName (layerName, _inputFile->header()))
+{
+    RgbaChannels rgbaChannels = channels();
+
+    if (rgbaChannels & (WRITE_Y | WRITE_C))
+	_fromYca = new FromYca (*_inputFile, rgbaChannels);
+}
+
+
+RgbaInputFile::~RgbaInputFile ()
+{
+    delete _inputFile;
+    delete _fromYca;
+}
+
+
+void	
+RgbaInputFile::setFrameBuffer (Rgba *base, size_t xStride, size_t yStride)
+{
+    if (_fromYca)
+    {
+	Lock lock (*_fromYca);
+	_fromYca->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
+RgbaInputFile::setLayerName (const string &layerName)
+{
+    delete _fromYca;
+    _fromYca = 0;
+
+    _channelNamePrefix = prefixFromLayerName (layerName, _inputFile->header());
+
+    RgbaChannels rgbaChannels = channels();
+
+    if (rgbaChannels & (WRITE_Y | WRITE_C))
+	_fromYca = new FromYca (*_inputFile, rgbaChannels);
+
+    FrameBuffer fb;
+    _inputFile->setFrameBuffer (fb);
+}
+
+
+void	
+RgbaInputFile::readPixels (int scanLine1, int scanLine2)
+{
+    if (_fromYca)
+    {
+	Lock lock (*_fromYca);
+	_fromYca->readPixels (scanLine1, scanLine2);
+    }
+    else
+    {
+	_inputFile->readPixels (scanLine1, scanLine2);
+    }
+}
+
+
+void	
+RgbaInputFile::readPixels (int scanLine)
+{
+    readPixels (scanLine, scanLine);
+}
+
+
+bool
+RgbaInputFile::isComplete () const
+{
+    return _inputFile->isComplete();
+}
+
+
+const Header &
+RgbaInputFile::header () const
+{
+    return _inputFile->header();
+}
+
+
+const char *
+RgbaInputFile::fileName () const
+{
+    return _inputFile->fileName();
+}
+
+
+const FrameBuffer &	
+RgbaInputFile::frameBuffer () const
+{
+    return _inputFile->frameBuffer();
+}
+
+
+const IMATH_NAMESPACE::Box2i &
+RgbaInputFile::displayWindow () const
+{
+    return _inputFile->header().displayWindow();
+}
+
+
+const IMATH_NAMESPACE::Box2i &
+RgbaInputFile::dataWindow () const
+{
+    return _inputFile->header().dataWindow();
+}
+
+
+float	
+RgbaInputFile::pixelAspectRatio () const
+{
+    return _inputFile->header().pixelAspectRatio();
+}
+
+
+const IMATH_NAMESPACE::V2f	
+RgbaInputFile::screenWindowCenter () const
+{
+    return _inputFile->header().screenWindowCenter();
+}
+
+
+float	
+RgbaInputFile::screenWindowWidth () const
+{
+    return _inputFile->header().screenWindowWidth();
+}
+
+
+LineOrder
+RgbaInputFile::lineOrder () const
+{
+    return _inputFile->header().lineOrder();
+}
+
+
+Compression
+RgbaInputFile::compression () const
+{
+    return _inputFile->header().compression();
+}
+
+
+RgbaChannels	
+RgbaInputFile::channels () const
+{
+    return rgbaChannels (_inputFile->header().channels(), _channelNamePrefix);
+}
+
+
+int
+RgbaInputFile::version () const
+{
+    return _inputFile->version();
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT