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

//

// Copyright (c) 2004, Pixar Animation Studios

//

// 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 Pixar Animation Studios 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 Pxr24Compressor

//

//	This compressor is based on source code that was contributed to

//	OpenEXR by Pixar Animation Studios.  The compression method was

//	developed by Loren Carpenter.

//

//	The compressor preprocesses the pixel data to reduce entropy,

//	and then calls zlib.

//

//	Compression of HALF and UINT channels is lossless, but compressing

//	FLOAT channels is lossy: 32-bit floating-point numbers are converted

//	to 24 bits by rounding the significand to 15 bits.

//

//	When the compressor is invoked, the caller has already arranged

//	the pixel data so that the values for each channel appear in a

//	contiguous block of memory.  The compressor converts the pixel

//	values to unsigned integers: For UINT, this is a no-op.  HALF

//	values are simply re-interpreted as 16-bit integers.  FLOAT

//	values are converted to 24 bits, and the resulting bit patterns

//	are interpreted as integers.  The compressor then replaces each

//	value with the difference between the value and its left neighbor.

//	This turns flat fields in the image into zeroes, and ramps into

//	strings of similar values.  Next, each difference is split into

//	2, 3 or 4 bytes, and the bytes are transposed so that all the

//	most significant bytes end up in a contiguous block, followed

//	by the second most significant bytes, and so on.  The resulting

//	string of bytes is compressed with zlib.

//

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

#include "ImfPxr24Compressor.h"

#include "ImfHeader.h"

#include "ImfChannelList.h"

#include "ImfMisc.h"

#include "ImfCheckedArithmetic.h"

#include "ImfNamespace.h"

#include <ImathFun.h>

#include <Iex.h>

#include <half.h>

#include <zlib.h>

#include <assert.h>

#include <algorithm>

using namespace std;

using namespace IMATH_NAMESPACE;

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

namespace {

//

// Conversion from 32-bit to 24-bit floating-point numbers.

// Conversion back to 32 bits is simply an 8-bit shift to the left.

//

inline unsigned int

floatToFloat24 (float f)

{

    union

    {

	float		f;

	unsigned int	i;

    } u;

    u.f = f;

    //

    // Disassemble the 32-bit floating point number, f,

    // into sign, s, exponent, e, and significand, m.

    //

    unsigned int s = u.i & 0x80000000;

    unsigned int e = u.i & 0x7f800000;

    unsigned int m = u.i & 0x007fffff;

    unsigned int i;

    if (e == 0x7f800000)

    {

	if (m)

	{

	    //

	    // F is a NAN; we preserve the sign bit and

	    // the 15 leftmost bits of the significand,

	    // with one exception: If the 15 leftmost

	    // bits are all zero, the NAN would turn

	    // into an infinity, so we have to set at

	    // least one bit in the significand.

	    //

	    m >>= 8;

	    i = (e >> 8) | m | (m == 0);

	}

	else

	{

	    //

	    // F is an infinity.

	    //

	    i = e >> 8;

	}

    }

    else

    {

	//

	// F is finite, round the significand to 15 bits.

	//

	i = ((e | m) + (m & 0x00000080)) >> 8;

	if (i >= 0x7f8000)

	{

	    //

	    // F was close to FLT_MAX, and the significand was

	    // rounded up, resulting in an exponent overflow.

	    // Avoid the overflow by truncating the significand

	    // instead of rounding it.

	    //

	    i = (e | m) >> 8;

	}

    }

    return (s >> 8) | i;

}

void

notEnoughData ()

{

    throw IEX_NAMESPACE::InputExc ("Error decompressing data "

			 "(input data are shorter than expected).");

}

void

tooMuchData ()

{

    throw IEX_NAMESPACE::InputExc ("Error decompressing data "

			 "(input data are longer than expected).");

}

} // namespace

Pxr24Compressor::Pxr24Compressor (const Header &hdr,

				  size_t maxScanLineSize,

				  size_t numScanLines)

:

    Compressor (hdr),

    _maxScanLineSize (maxScanLineSize),

    _numScanLines (numScanLines),

    _tmpBuffer (0),

    _outBuffer (0),

    _channels (hdr.channels())

{

    size_t maxInBytes =

        uiMult (maxScanLineSize, numScanLines);

    size_t maxOutBytes =

        uiAdd (uiAdd (maxInBytes,

                      size_t (ceil (maxInBytes * 0.01))),

               size_t (100));

    _tmpBuffer = new unsigned char [maxInBytes];

    _outBuffer = new char [maxOutBytes];

    const Box2i &dataWindow = hdr.dataWindow();

    _minX = dataWindow.min.x;

    _maxX = dataWindow.max.x;

    _maxY = dataWindow.max.y;

}

Pxr24Compressor::~Pxr24Compressor ()

{

    delete [] _tmpBuffer;

    delete [] _outBuffer;

}

int

Pxr24Compressor::numScanLines () const

{

    return _numScanLines;

}

Compressor::Format

Pxr24Compressor::format () const

{

    return NATIVE;

}

int

Pxr24Compressor::compress (const char *inPtr,

			   int inSize,

			   int minY,

			   const char *&outPtr)

{

    return compress (inPtr,

	             inSize,

		     Box2i (V2i (_minX, minY),

			    V2i (_maxX, minY + _numScanLines - 1)),

		     outPtr);

}

int

Pxr24Compressor::compressTile (const char *inPtr,

			       int inSize,

			       Box2i range,

			       const char *&outPtr)

{

    return compress (inPtr, inSize, range, outPtr);

}

int

Pxr24Compressor::uncompress (const char *inPtr,

			     int inSize,

			     int minY,

			     const char *&outPtr)

{

    return uncompress (inPtr,

	               inSize,

		       Box2i (V2i (_minX, minY),

			      V2i (_maxX, minY + _numScanLines - 1)),

		       outPtr);

}

int

Pxr24Compressor::uncompressTile (const char *inPtr,

				 int inSize,

				 Box2i range,

				 const char *&outPtr)

{

    return uncompress (inPtr, inSize, range, outPtr);

}

int

Pxr24Compressor::compress (const char *inPtr,

			   int inSize,

			   Box2i range,

			   const char *&outPtr)

{

    if (inSize == 0)

    {

	outPtr = _outBuffer;

	return 0;

    }

    int minX = range.min.x;

    int maxX = min (range.max.x, _maxX);

    int minY = range.min.y;

    int maxY = min (range.max.y, _maxY);

    unsigned char *tmpBufferEnd = _tmpBuffer;

    for (int y = minY; y <= maxY; ++y)

    {

	for (ChannelList::ConstIterator i = _channels.begin();

	     i != _channels.end();

	     ++i)

	{

	    const Channel &c = i.channel();

	    if (modp (y, c.ySampling) != 0)

		continue;

	    int n = numSamples (c.xSampling, minX, maxX);

	    unsigned char *ptr[4];

	    unsigned int previousPixel = 0;

	    switch (c.type)

	    {

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

		ptr[0] = tmpBufferEnd;

		ptr[1] = ptr[0] + n;

		ptr[2] = ptr[1] + n;

		ptr[3] = ptr[2] + n;

		tmpBufferEnd = ptr[3] + n;

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

		{

		    unsigned int pixel;

		    char *pPtr = (char *) &pixel;

		    for (size_t k = 0; k < sizeof (pixel); ++k)

			*pPtr++ = *inPtr++;

		    unsigned int diff = pixel - previousPixel;

		    previousPixel = pixel;

		    *(ptr[0]++) = diff >> 24;

		    *(ptr[1]++) = diff >> 16;

		    *(ptr[2]++) = diff >> 8;

		    *(ptr[3]++) = diff;

		}

		break;

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

		ptr[0] = tmpBufferEnd;

		ptr[1] = ptr[0] + n;

		tmpBufferEnd = ptr[1] + n;

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

		{

		    half pixel;

		    pixel = *(const half *) inPtr;

		    inPtr += sizeof (half);

		    unsigned int diff = pixel.bits() - previousPixel;

		    previousPixel = pixel.bits();

		    *(ptr[0]++) = diff >> 8;

		    *(ptr[1]++) = diff;

		}

		break;

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

		ptr[0] = tmpBufferEnd;

		ptr[1] = ptr[0] + n;

		ptr[2] = ptr[1] + n;

		tmpBufferEnd = ptr[2] + n;

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

		{

		    float pixel;

		    char *pPtr = (char *) &pixel;

		    for (size_t k = 0; k < sizeof (pixel); ++k)

			*pPtr++ = *inPtr++;

		    unsigned int pixel24 = floatToFloat24 (pixel);

		    unsigned int diff = pixel24 - previousPixel;

		    previousPixel = pixel24;

		    *(ptr[0]++) = diff >> 16;

		    *(ptr[1]++) = diff >> 8;

		    *(ptr[2]++) = diff;

		}

		break;

	      default:

		assert (false);

	    }

	}

    }

    uLongf outSize = int (ceil ((tmpBufferEnd - _tmpBuffer) * 1.01)) + 100;

    if (Z_OK != ::compress ((Bytef *) _outBuffer,

			    &outSize,

			    (const Bytef *) _tmpBuffer,

			    tmpBufferEnd - _tmpBuffer))

    {

	throw IEX_NAMESPACE::BaseExc ("Data compression (zlib) failed.");

    }

    outPtr = _outBuffer;

    return outSize;

}

int		

Pxr24Compressor::uncompress (const char *inPtr,

			     int inSize,

			     Box2i range,

			     const char *&outPtr)

{

    if (inSize == 0)

    {

	outPtr = _outBuffer;

	return 0;

    }

    uLongf tmpSize = _maxScanLineSize * _numScanLines;

    if (Z_OK != ::uncompress ((Bytef *)_tmpBuffer,

			      &tmpSize,

			      (const Bytef *) inPtr,

			      inSize))

    {

	throw IEX_NAMESPACE::InputExc ("Data decompression (zlib) failed.");

    }

    int minX = range.min.x;

    int maxX = min (range.max.x, _maxX);

    int minY = range.min.y;

    int maxY = min (range.max.y, _maxY);

    const unsigned char *tmpBufferEnd = _tmpBuffer;

    char *writePtr = _outBuffer;

    for (int y = minY; y <= maxY; ++y)

    {

	for (ChannelList::ConstIterator i = _channels.begin();

	     i != _channels.end();

	     ++i)

	{

	    const Channel &c = i.channel();

	    if (modp (y, c.ySampling) != 0)

		continue;

	    int n = numSamples (c.xSampling, minX, maxX);

	    const unsigned char *ptr[4];

	    unsigned int pixel = 0;

	    switch (c.type)

	    {

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

		ptr[0] = tmpBufferEnd;

		ptr[1] = ptr[0] + n;

		ptr[2] = ptr[1] + n;

		ptr[3] = ptr[2] + n;

		tmpBufferEnd = ptr[3] + n;

		if ( (uLongf)(tmpBufferEnd - _tmpBuffer) > tmpSize)

		    notEnoughData();

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

		{

		    unsigned int diff = (*(ptr[0]++) << 24) |

					(*(ptr[1]++) << 16) |

					(*(ptr[2]++) <<  8) |

					 *(ptr[3]++);

		    pixel += diff;

		    char *pPtr = (char *) &pixel;

		    for (size_t k = 0; k < sizeof (pixel); ++k)

			*writePtr++ = *pPtr++;

		}

		break;

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

		ptr[0] = tmpBufferEnd;

		ptr[1] = ptr[0] + n;

		tmpBufferEnd = ptr[1] + n;

        if ( (uLongf)(tmpBufferEnd - _tmpBuffer) > tmpSize)

		    notEnoughData();

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

		{

		    unsigned int diff = (*(ptr[0]++) << 8) |

					 *(ptr[1]++);

		    pixel += diff;

		    half * hPtr = (half *) writePtr;

		    hPtr->setBits ((unsigned short) pixel);

		    writePtr += sizeof (half);

		}

		break;

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

		ptr[0] = tmpBufferEnd;

		ptr[1] = ptr[0] + n;

		ptr[2] = ptr[1] + n;

		tmpBufferEnd = ptr[2] + n;

        if ( (uLongf) (tmpBufferEnd - _tmpBuffer) > tmpSize)

		    notEnoughData();

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

		{

		    unsigned int diff = (*(ptr[0]++) << 24) |

					(*(ptr[1]++) << 16) |

					(*(ptr[2]++) <<  8);

		    pixel += diff;

		    char *pPtr = (char *) &pixel;

		    for (size_t k = 0; k < sizeof (pixel); ++k)

			*writePtr++ = *pPtr++;

		}

		break;

	      default:

		assert (false);

	    }

	}

    }

    if ((uLongf) (tmpBufferEnd - _tmpBuffer) < tmpSize)

	tooMuchData();

    outPtr = _outBuffer;

    return writePtr - _outBuffer;

}

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT