rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfRgbaYca.h

@@ -0,0 +1,259 @@
+#ifndef INCLUDED_IMF_RGBA_YCA_H
+#define INCLUDED_IMF_RGBA_YCA_H
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2004, Industrial Light & Magic, a division of Lucasfilm
+// Entertainment Company Ltd.  Portions contributed and copyright held by
+// others as indicated.  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
+//       any other contributors to this software 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//-----------------------------------------------------------------------------
+//
+//	Conversion between RGBA (red, green, blue alpha)
+//	and YCA (luminance, subsampled chroma, alpha) data:
+//
+//	Luminance, Y, is computed as a weighted sum of R, G, and B:
+//
+//		Y = yw.x * R + yw.y * G + yw.z * B
+//
+//	Function computeYw() computes a set of RGB-to-Y weights, yw,
+//	from a set of primary and white point chromaticities.
+//
+//	Chroma, C, consists of two components, RY and BY:
+//
+//		RY = (R - Y) / Y
+//		BY = (B - Y) / Y
+//
+//	For efficiency, the x and y subsampling rates for chroma are
+//	hardwired to 2, and the chroma subsampling and reconstruction
+//	filters are fixed 27-pixel wide windowed sinc functions.
+//
+//	Starting with an image that has RGBA data for all pixels,
+//
+//		RGBA RGBA RGBA RGBA ... RGBA RGBA
+//		RGBA RGBA RGBA RGBA ... RGBA RGBA
+//		RGBA RGBA RGBA RGBA ... RGBA RGBA
+//		RGBA RGBA RGBA RGBA ... RGBA RGBA
+//		...
+//		RGBA RGBA RGBA RGBA ... RGBA RGBA
+//		RGBA RGBA RGBA RGBA ... RGBA RGBA
+//
+//	function RGBAtoYCA() converts the pixels to YCA format:
+//
+//		YCA  YCA  YCA  YCA  ... YCA  YCA
+//		YCA  YCA  YCA  YCA  ... YCA  YCA
+//		YCA  YCA  YCA  YCA  ... YCA  YCA
+//		YCA  YCA  YCA  YCA  ... YCA  YCA
+//		...
+//		YCA  YCA  YCA  YCA  ... YCA  YCA
+//		YCA  YCA  YCA  YCA  ... YCA  YCA
+//
+//	Next, decimateChomaHoriz() eliminates the chroma values from
+//	the odd-numbered pixels in every scan line:
+//
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//		...
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//
+//	decimateChromaVert() eliminates all chroma values from the
+//	odd-numbered scan lines:
+//
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//		YA   YA   YA   YA   ... YA   YA  
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//		YA   YA   YA   YA   ... YA   YA  
+//		...
+//		YCA  YA   YCA  YA   ... YCA  YA  
+//		YA   YA   YA   YA   ... YA   YA  
+//
+//	Finally, roundYCA() reduces the precision of the luminance
+//	and chroma values so that the pixel data shrink more when
+//	they are saved in a compressed file.
+//
+//	The output of roundYCA() can be converted back to a set
+//	of RGBA pixel data that is visually very similar to the
+//	original RGBA image, by calling reconstructChromaHoriz(),
+//	reconstructChromaVert(), YCAtoRGBA(), and finally
+//	fixSaturation().
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfRgba.h"
+#include "ImfChromaticities.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+namespace RgbaYca {
+
+
+//
+// Width of the chroma subsampling and reconstruction filters
+//
+
+static const int N = 27;
+static const int N2 = N / 2;
+
+
+//
+// Convert a set of primary chromaticities into a set of weighting
+// factors for computing a pixels's luminance, Y, from R, G and B
+//
+ 
+IMF_EXPORT
+IMATH_NAMESPACE::V3f computeYw (const Chromaticities &cr);
+
+
+//
+// Convert an array of n RGBA pixels, rgbaIn, to YCA (luminance/chroma/alpha):
+//
+//	ycaOut[i].g = Y (rgbaIn[i]);
+//	ycaOut[i].r = RY (rgbaIn[i]);
+//	ycaOut[i].b = BY (rgbaIn[i]);
+//	ycaOut[i].a = aIsValid? rgbaIn[i].a: 1
+//
+// yw is a set of RGB-to-Y weighting factors, as computed by computeYw().
+//
+
+IMF_EXPORT
+void RGBAtoYCA (const IMATH_NAMESPACE::V3f &yw,
+		int n,
+	        bool aIsValid,
+		const Rgba rgbaIn[/*n*/],
+		Rgba ycaOut[/*n*/]);
+
+//
+// Perform horizontal low-pass filtering and subsampling of
+// the chroma channels of an array of n pixels.  In order
+// to avoid indexing off the ends of the input array during
+// low-pass filtering, ycaIn must have N2 extra pixels at
+// both ends.  Before calling decimateChromaHoriz(), the extra
+// pixels should be filled with copies of the first and last
+// "real" input pixel.
+//
+
+IMF_EXPORT
+void decimateChromaHoriz (int n,
+			  const Rgba ycaIn[/*n+N-1*/],
+			  Rgba ycaOut[/*n*/]);
+
+//
+// Perform vertical chroma channel low-pass filtering and subsampling.
+// N scan lines of input pixels are combined into a single scan line
+// of output pixels.
+//
+
+IMF_EXPORT
+void decimateChromaVert (int n,
+			 const Rgba * const ycaIn[N],
+			 Rgba ycaOut[/*n*/]);
+
+//
+// Round the luminance and chroma channels of an array of YCA
+// pixels that has already been filtered and subsampled.
+// The signifcands of the pixels' luminance and chroma values
+// are rounded to roundY and roundC bits respectively.
+//
+
+IMF_EXPORT
+void roundYCA (int n,
+	       unsigned int roundY,
+	       unsigned int roundC,
+	       const Rgba ycaIn[/*n*/],
+	       Rgba ycaOut[/*n*/]);
+
+//
+// For a scan line that has valid chroma data only for every other pixel,
+// reconstruct the missing chroma values.
+//
+
+IMF_EXPORT
+void reconstructChromaHoriz (int n,
+			     const Rgba ycaIn[/*n+N-1*/],
+			     Rgba ycaOut[/*n*/]);
+
+//
+// For a scan line that has only luminance and no valid chroma data,
+// reconstruct chroma from the surronding N scan lines.
+//
+
+IMF_EXPORT
+void reconstructChromaVert (int n,
+			    const Rgba * const ycaIn[N],
+			    Rgba ycaOut[/*n*/]);
+			 
+//
+// Convert an array of n YCA (luminance/chroma/alpha) pixels to RGBA.
+// This function is the inverse of RGBAtoYCA().
+// yw is a set of RGB-to-Y weighting factors, as computed by computeYw().
+//
+
+IMF_EXPORT
+void YCAtoRGBA (const IMATH_NAMESPACE::V3f &yw,
+		int n,
+		const Rgba ycaIn[/*n*/],
+		Rgba rgbaOut[/*n*/]);
+			 
+//
+// Eliminate super-saturated pixels:
+//
+// Converting an image from RGBA to YCA, low-pass filtering chroma,
+// and converting the result back to RGBA can produce pixels with
+// super-saturated colors, where one or two of the RGB components
+// become zero or negative.  (The low-pass and reconstruction filters
+// introduce some amount of ringing into the chroma components.
+// This can lead to negative RGB values near high-contrast edges.)
+//
+// The fixSaturation() function finds super-saturated pixels and
+// corrects them by desaturating their colors while maintaining
+// their luminance.  fixSaturation() takes three adjacent input
+// scan lines, rgbaIn[0], rgbaIn[1], rgbaIn[2], adjusts the
+// saturation of rgbaIn[1], and stores the result in rgbaOut.
+//
+
+IMF_EXPORT
+void fixSaturation (const IMATH_NAMESPACE::V3f &yw,
+		    int n,
+		    const Rgba * const rgbaIn[3],
+		    Rgba rgbaOut[/*n*/]);
+
+} // namespace RgbaYca
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

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

@@ -0,0 +1,157 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include <string.h>
+#include "ImfRle.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+namespace {
+
+const int MIN_RUN_LENGTH = 3;
+const int MAX_RUN_LENGTH = 127;
+
+}
+
+//
+// Compress an array of bytes, using run-length encoding,
+// and return the length of the compressed data.
+//
+
+int
+rleCompress (int inLength, const char in[], signed char out[])
+{
+    const char *inEnd = in + inLength;
+    const char *runStart = in;
+    const char *runEnd = in + 1;
+    signed char *outWrite = out;
+
+    while (runStart < inEnd)
+    {
+	while (runEnd < inEnd &&
+	       *runStart == *runEnd &&
+	       runEnd - runStart - 1 < MAX_RUN_LENGTH)
+	{
+	    ++runEnd;
+	}
+
+	if (runEnd - runStart >= MIN_RUN_LENGTH)
+	{
+	    //
+	    // Compressable run
+	    //
+
+	    *outWrite++ = (runEnd - runStart) - 1;
+	    *outWrite++ = *(signed char *) runStart;
+	    runStart = runEnd;
+	}
+	else
+	{
+	    //
+	    // Uncompressable run
+	    //
+
+	    while (runEnd < inEnd &&
+		   ((runEnd + 1 >= inEnd ||
+		     *runEnd != *(runEnd + 1)) ||
+		    (runEnd + 2 >= inEnd ||
+		     *(runEnd + 1) != *(runEnd + 2))) &&
+		   runEnd - runStart < MAX_RUN_LENGTH)
+	    {
+		++runEnd;
+	    }
+
+	    *outWrite++ = runStart - runEnd;
+
+	    while (runStart < runEnd)
+	    {
+		*outWrite++ = *(signed char *) (runStart++);
+	    }
+	}
+
+	++runEnd;
+    }
+
+    return outWrite - out;
+}
+
+
+//
+// Uncompress an array of bytes compressed with rleCompress().
+// Returns the length of the oncompressed data, or 0 if the
+// length of the uncompressed data would be more than maxLength.
+//
+
+int
+rleUncompress (int inLength, int maxLength, const signed char in[], char out[])
+{
+    char *outStart = out;
+
+    while (inLength > 0)
+    {
+	if (*in < 0)
+	{
+	    int count = -((int)*in++);
+	    inLength -= count + 1;
+
+	    if (0 > (maxLength -= count))
+		return 0;
+
+        memcpy(out, in, count);
+        out += count;
+        in  += count;
+	}
+	else
+	{
+	    int count = *in++;
+	    inLength -= 2;
+
+	    if (0 > (maxLength -= count + 1))
+		return 0;
+
+        memset(out, *(char*)in, count+1);
+        out += count+1;
+
+	    in++;
+	}
+    }
+
+    return out - outStart;
+}
+
+
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfRle.h

@@ -0,0 +1,63 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IMF_RLE_H_
+#define INCLUDED_IMF_RLE_H_
+
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+//
+// Compress an array of bytes, using run-length encoding,
+// and return the length of the compressed data.
+//
+
+IMF_EXPORT
+int rleCompress (int inLength, const char in[], signed char out[]);
+
+//
+// Uncompress an array of bytes compressed with rleCompress().
+// Returns the length of the uncompressed data, or 0 if the
+// length of the uncompressed data would be more than maxLength.
+//
+
+IMF_EXPORT
+int rleUncompress (int inLength, int maxLength,
+                                 const signed char in[], char out[]);
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

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

@@ -0,0 +1,220 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002, 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 RleCompressor
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfRleCompressor.h"
+#include "ImfCheckedArithmetic.h"
+#include "ImfRle.h"
+#include "Iex.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+RleCompressor::RleCompressor (const Header &hdr, size_t maxScanLineSize):
+    Compressor (hdr),
+    _maxScanLineSize (maxScanLineSize),
+    _tmpBuffer (0),
+    _outBuffer (0)
+{
+    _tmpBuffer = new char [maxScanLineSize];
+    _outBuffer = new char [uiMult (maxScanLineSize, size_t (3)) / 2];
+}
+
+
+RleCompressor::~RleCompressor ()
+{
+    delete [] _tmpBuffer;
+    delete [] _outBuffer;
+}
+
+
+int
+RleCompressor::numScanLines () const
+{
+    //
+    // This compressor compresses individual scan lines.
+    //
+
+    return 1;
+}
+
+
+int
+RleCompressor::compress (const char *inPtr,
+			 int inSize,
+			 int minY,
+			 const char *&outPtr)
+{
+    //
+    // Special case �- empty input buffer
+    //
+
+    if (inSize == 0)
+    {
+	outPtr = _outBuffer;
+	return 0;
+    }
+
+    //
+    // Reorder the pixel data.
+    //
+
+    {
+	char *t1 = _tmpBuffer;
+	char *t2 = _tmpBuffer + (inSize + 1) / 2;
+	const char *stop = inPtr + inSize;
+
+	while (true)
+	{
+	    if (inPtr < stop)
+		*(t1++) = *(inPtr++);
+	    else
+		break;
+
+	    if (inPtr < stop)
+		*(t2++) = *(inPtr++);
+	    else
+		break;
+	}
+    }
+
+    //
+    // Predictor.
+    //
+
+    {
+	unsigned char *t = (unsigned char *) _tmpBuffer + 1;
+	unsigned char *stop = (unsigned char *) _tmpBuffer + inSize;
+	int p = t[-1];
+
+	while (t < stop)
+	{
+	    int d = int (t[0]) - p + (128 + 256);
+	    p = t[0];
+	    t[0] = d;
+	    ++t;
+	}
+    }
+
+    //
+    // Run-length encode the data.
+    //
+
+    outPtr = _outBuffer;
+    return rleCompress (inSize, _tmpBuffer, (signed char *) _outBuffer);
+}
+
+
+int
+RleCompressor::uncompress (const char *inPtr,
+			   int inSize,
+			   int minY,
+			   const char *&outPtr)
+{
+    //
+    // Special case �- empty input buffer
+    //
+
+    if (inSize == 0)
+    {
+	outPtr = _outBuffer;
+	return 0;
+    }
+
+    //
+    // Decode the run-length encoded data
+    //
+
+    int outSize;
+
+    if (0 == (outSize = rleUncompress (inSize, _maxScanLineSize,
+				       (const signed char *) inPtr,
+				       _tmpBuffer)))
+    {
+	throw IEX_NAMESPACE::InputExc ("Data decoding (rle) failed.");
+    }
+
+    //
+    // Predictor.
+    //
+
+    {
+	unsigned char *t = (unsigned char *) _tmpBuffer + 1;
+	unsigned char *stop = (unsigned char *) _tmpBuffer + outSize;
+
+	while (t < stop)
+	{
+	    int d = int (t[-1]) + int (t[0]) - 128;
+	    t[0] = d;
+	    ++t;
+	}
+    }
+
+    //
+    // Reorder the pixel data.
+    //
+
+    {
+	const char *t1 = _tmpBuffer;
+	const char *t2 = _tmpBuffer + (outSize + 1) / 2;
+	char *s = _outBuffer;
+	char *stop = s + outSize;
+
+	while (true)
+	{
+	    if (s < stop)
+		*(s++) = *(t1++);
+	    else
+		break;
+
+	    if (s < stop)
+		*(s++) = *(t2++);
+	    else
+		break;
+	}
+    }
+
+    outPtr = _outBuffer;
+    return outSize;
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT