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

//

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