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

//

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

//

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

#include "ImfPizCompressor.h"

#include "ImfHeader.h"

#include "ImfChannelList.h"

#include "ImfHuf.h"

#include "ImfWav.h"

#include "ImfMisc.h"

#include "ImfCheckedArithmetic.h"

#include <ImathFun.h>

#include <ImathBox.h>

#include <Iex.h>

#include "ImfIO.h"

#include "ImfXdr.h"

#include "ImfAutoArray.h"

#include <string.h>

#include <assert.h>

#include "ImfNamespace.h"

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

using IMATH_NAMESPACE::divp;

using IMATH_NAMESPACE::modp;

using IMATH_NAMESPACE::Box2i;

using IMATH_NAMESPACE::V2i;

using IEX_NAMESPACE::InputExc;

namespace {

//

// Functions to compress the range of values in the pixel data

//

const int USHORT_RANGE = (1 << 16);

const int BITMAP_SIZE  = (USHORT_RANGE >> 3);

void

bitmapFromData (const unsigned short data[/*nData*/],

		int nData,

		unsigned char bitmap[BITMAP_SIZE],

		unsigned short &minNonZero,

		unsigned short &maxNonZero)

{

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

	bitmap[i] = 0;

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

	bitmap[data[i] >> 3] |= (1 << (data[i] & 7));

    bitmap[0] &= ~1;			// zero is not explicitly stored in

					// the bitmap; we assume that the

					// data always contain zeroes

    minNonZero = BITMAP_SIZE - 1;

    maxNonZero = 0;

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

    {

	if (bitmap[i])

	{

	    if (minNonZero > i)

		minNonZero = i;

	    if (maxNonZero < i)

		maxNonZero = i;

	}

    }

}

unsigned short

forwardLutFromBitmap (const unsigned char bitmap[BITMAP_SIZE],

		      unsigned short lut[USHORT_RANGE])

{

    int k = 0;

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

    {

	if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))

	    lut[i] = k++;

	else

	    lut[i] = 0;

    }

    return k - 1;	// maximum value stored in lut[],

}			// i.e. number of ones in bitmap minus 1

unsigned short

reverseLutFromBitmap (const unsigned char bitmap[BITMAP_SIZE],

		      unsigned short lut[USHORT_RANGE])

{

    int k = 0;

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

    {

	if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))

	    lut[k++] = i;

    }

    int n = k - 1;

    while (k < USHORT_RANGE)

	lut[k++] = 0;

    return n;		// maximum k where lut[k] is non-zero,

}			// i.e. number of ones in bitmap minus 1

void

applyLut (const unsigned short lut[USHORT_RANGE],

	  unsigned short data[/*nData*/],

	  int nData)

{

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

	data[i] = lut[data[i]];

}

} // namespace

struct PizCompressor::ChannelData

{

    unsigned short *	start;

    unsigned short *	end;

    int			nx;

    int			ny;

    int			ys;

    int			size;

};

PizCompressor::PizCompressor

    (const Header &hdr,

     size_t maxScanLineSize,

     size_t numScanLines)

:

    Compressor (hdr),

    _maxScanLineSize (maxScanLineSize),

    _format (XDR),

    _numScanLines (numScanLines),

    _tmpBuffer (0),

    _outBuffer (0),

    _numChans (0),

    _channels (hdr.channels()),

    _channelData (0)

{

    size_t tmpBufferSize =

                uiMult (maxScanLineSize, numScanLines) / 2;

    size_t outBufferSize =

                uiAdd (uiMult (maxScanLineSize, numScanLines),

                       size_t (65536 + 8192));

    _tmpBuffer = new unsigned short

            [checkArraySize (tmpBufferSize, sizeof (unsigned short))];

    _outBuffer = new char [outBufferSize];

    const ChannelList &channels = header().channels();

    bool onlyHalfChannels = true;

    for (ChannelList::ConstIterator c = channels.begin();

	 c != channels.end();

	 ++c)

    {

	_numChans++;

	assert (pixelTypeSize (c.channel().type) % pixelTypeSize (HALF) == 0);

	if (c.channel().type != HALF)

	    onlyHalfChannels = false;

    }

    _channelData = new ChannelData[_numChans];

    const Box2i &dataWindow = hdr.dataWindow();

    _minX = dataWindow.min.x;

    _maxX = dataWindow.max.x;

    _maxY = dataWindow.max.y;

    //

    // We can support uncompressed data in the machine's native format

    // if all image channels are of type HALF, and if the Xdr and the

    // native represenations of a half have the same size.

    //

    if (onlyHalfChannels && (sizeof (half) == pixelTypeSize (HALF)))

	_format = NATIVE;

}

PizCompressor::~PizCompressor ()

{

    delete [] _tmpBuffer;

    delete [] _outBuffer;

    delete [] _channelData;

}

int

PizCompressor::numScanLines () const

{

    return _numScanLines;

}

Compressor::Format

PizCompressor::format () const

{

    return _format;

}

int

PizCompressor::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

PizCompressor::compressTile (const char *inPtr,

			     int inSize,

			     IMATH_NAMESPACE::Box2i range,

			     const char *&outPtr)

{

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

}

int

PizCompressor::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

PizCompressor::uncompressTile (const char *inPtr,

			       int inSize,

			       IMATH_NAMESPACE::Box2i range,

			       const char *&outPtr)

{

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

}

int

PizCompressor::compress (const char *inPtr,

			 int inSize,

			 IMATH_NAMESPACE::Box2i range,

			 const char *&outPtr)

{

    //

    // This is the compress function which is used by both the tiled and

    // scanline compression routines.

    //

    //

    // Special case �- empty input buffer

    //

    if (inSize == 0)

    {

	outPtr = _outBuffer;

	return 0;

    }

    //

    // Rearrange the pixel data so that the wavelet

    // and Huffman encoders can process them easily.

    //

    // The wavelet and Huffman encoders both handle only

    // 16-bit data, so 32-bit data must be split into smaller

    // pieces.  We treat each 32-bit channel (UINT, FLOAT) as

    // two interleaved 16-bit channels.

    //

    int minX = range.min.x;

    int maxX = range.max.x;

    int minY = range.min.y;

    int maxY = range.max.y;

    if (maxY > _maxY)

        maxY = _maxY;

    if (maxX > _maxX)

        maxX = _maxX;

    unsigned short *tmpBufferEnd = _tmpBuffer;

    int i = 0;

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

	 c != _channels.end();

	 ++c, ++i)

    {

	ChannelData &cd = _channelData[i];

	cd.start = tmpBufferEnd;

	cd.end = cd.start;

	cd.nx = numSamples (c.channel().xSampling, minX, maxX);

	cd.ny = numSamples (c.channel().ySampling, minY, maxY);

	cd.ys = c.channel().ySampling;

	cd.size = pixelTypeSize (c.channel().type) / pixelTypeSize (HALF);

	tmpBufferEnd += cd.nx * cd.ny * cd.size;

    }

    if (_format == XDR)

    {

	//

	// Machine-independent (Xdr) data format

	//

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

	{

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

	    {

		ChannelData &cd = _channelData[i];

		if (modp (y, cd.ys) != 0)

		    continue;

		for (int x = cd.nx * cd.size; x > 0; --x)

		{

		    Xdr::read <CharPtrIO> (inPtr, *cd.end);

		    ++cd.end;

		}

	    }

	}

    }

    else

    {

	//

	// Native, machine-dependent data format

	//

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

	{

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

	    {

		ChannelData &cd = _channelData[i];

		if (modp (y, cd.ys) != 0)

		    continue;

		int n = cd.nx * cd.size;

		memcpy (cd.end, inPtr, n * sizeof (unsigned short));

		inPtr  += n * sizeof (unsigned short);

		cd.end += n;

	    }

	}

    }

    #if defined (DEBUG)

	for (int i = 1; i < _numChans; ++i)

	    assert (_channelData[i-1].end == _channelData[i].start);

	assert (_channelData[_numChans-1].end == tmpBufferEnd);

    #endif

    //

    // Compress the range of the pixel data

    //

    AutoArray <unsigned char, BITMAP_SIZE> bitmap;

    unsigned short minNonZero;

    unsigned short maxNonZero;

    bitmapFromData (_tmpBuffer,

		    tmpBufferEnd - _tmpBuffer,

		    bitmap,

		    minNonZero, maxNonZero);

    AutoArray <unsigned short, USHORT_RANGE> lut;

    unsigned short maxValue = forwardLutFromBitmap (bitmap, lut);

    applyLut (lut, _tmpBuffer, tmpBufferEnd - _tmpBuffer);

    //

    // Store range compression info in _outBuffer

    //

    char *buf = _outBuffer;

    Xdr::write <CharPtrIO> (buf, minNonZero);

    Xdr::write <CharPtrIO> (buf, maxNonZero);

    if (minNonZero <= maxNonZero)

    {

	Xdr::write <CharPtrIO> (buf, (char *) &bitmap[0] + minNonZero,

				maxNonZero - minNonZero + 1);

    }

    //

    // Apply wavelet encoding

    //

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

    {

	ChannelData &cd = _channelData[i];

	for (int j = 0; j < cd.size; ++j)

	{

	    wav2Encode (cd.start + j,

			cd.nx, cd.size,

			cd.ny, cd.nx * cd.size,

			maxValue);

	}

    }

    //

    // Apply Huffman encoding; append the result to _outBuffer

    //

    char *lengthPtr = buf;

    Xdr::write <CharPtrIO> (buf, int(0));

    int length = hufCompress (_tmpBuffer, tmpBufferEnd - _tmpBuffer, buf);

    Xdr::write <CharPtrIO> (lengthPtr, length);

    outPtr = _outBuffer;

    return buf - _outBuffer + length;

}

int

PizCompressor::uncompress (const char *inPtr,

			   int inSize,

			   IMATH_NAMESPACE::Box2i range,

			   const char *&outPtr)

{

    //

    // This is the cunompress function which is used by both the tiled and

    // scanline decompression routines.

    //

    //

    // Special case - empty input buffer

    //

    if (inSize == 0)

    {

	outPtr = _outBuffer;

	return 0;

    }

    //

    // Determine the layout of the compressed pixel data

    //

    int minX = range.min.x;

    int maxX = range.max.x;

    int minY = range.min.y;

    int maxY = range.max.y;

    if (maxY > _maxY)

        maxY = _maxY;

    if (maxX > _maxX)

        maxX = _maxX;

    unsigned short *tmpBufferEnd = _tmpBuffer;

    int i = 0;

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

	 c != _channels.end();

	 ++c, ++i)

    {

	ChannelData &cd = _channelData[i];

	cd.start = tmpBufferEnd;

	cd.end = cd.start;

	cd.nx = numSamples (c.channel().xSampling, minX, maxX);

	cd.ny = numSamples (c.channel().ySampling, minY, maxY);

	cd.ys = c.channel().ySampling;

	cd.size = pixelTypeSize (c.channel().type) / pixelTypeSize (HALF);

	tmpBufferEnd += cd.nx * cd.ny * cd.size;

    }

    //

    // Read range compression data

    //

    unsigned short minNonZero;

    unsigned short maxNonZero;

    AutoArray <unsigned char, BITMAP_SIZE> bitmap;

    memset (bitmap, 0, sizeof (unsigned char) * BITMAP_SIZE);

    Xdr::read <CharPtrIO> (inPtr, minNonZero);

    Xdr::read <CharPtrIO> (inPtr, maxNonZero);

    if (maxNonZero >= BITMAP_SIZE)

    {

	throw InputExc ("Error in header for PIZ-compressed data "

			"(invalid bitmap size).");

    }

    if (minNonZero <= maxNonZero)

    {

	Xdr::read <CharPtrIO> (inPtr, (char *) &bitmap[0] + minNonZero,

			       maxNonZero - minNonZero + 1);

    }

    AutoArray <unsigned short, USHORT_RANGE> lut;

    unsigned short maxValue = reverseLutFromBitmap (bitmap, lut);

    //

    // Huffman decoding

    //

    int length;

    Xdr::read <CharPtrIO> (inPtr, length);

    hufUncompress (inPtr, length, _tmpBuffer, tmpBufferEnd - _tmpBuffer);

    //

    // Wavelet decoding

    //

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

    {

	ChannelData &cd = _channelData[i];

	for (int j = 0; j < cd.size; ++j)

	{

	    wav2Decode (cd.start + j,

			cd.nx, cd.size,

			cd.ny, cd.nx * cd.size,

			maxValue);

	}

    }

    //

    // Expand the pixel data to their original range

    //

    applyLut (lut, _tmpBuffer, tmpBufferEnd - _tmpBuffer);

    //

    // Rearrange the pixel data into the format expected by the caller.

    //

    char *outEnd = _outBuffer;

    if (_format == XDR)

    {

	//

	// Machine-independent (Xdr) data format

	//

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

	{

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

	    {

		ChannelData &cd = _channelData[i];

		if (modp (y, cd.ys) != 0)

		    continue;

		for (int x = cd.nx * cd.size; x > 0; --x)

		{

		    Xdr::write <CharPtrIO> (outEnd, *cd.end);

		    ++cd.end;

		}

	    }

	}

    }

    else

    {

	//

	// Native, machine-dependent data format

	//

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

	{

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

	    {

		ChannelData &cd = _channelData[i];

		if (modp (y, cd.ys) != 0)

		    continue;

		int n = cd.nx * cd.size;

		memcpy (outEnd, cd.end, n * sizeof (unsigned short));

		outEnd += n * sizeof (unsigned short);

		cd.end += n;

	    }

	}

    }

    #if defined (DEBUG)

	for (int i = 1; i < _numChans; ++i)

	    assert (_channelData[i-1].end == _channelData[i].start);

	assert (_channelData[_numChans-1].end == tmpBufferEnd);

    #endif

    outPtr = _outBuffer;

    return outEnd - _outBuffer;

}

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT