/* $Id: tif_pixarlog.c,v 1.54 2017-07-10 10:40:28 erouault Exp $ */

/*

 * Copyright (c) 1996-1997 Sam Leffler

 * Copyright (c) 1996 Pixar

 *

 * Permission to use, copy, modify, distribute, and sell this software and 

 * its documentation for any purpose is hereby granted without fee, provided

 * that (i) the above copyright notices and this permission notice appear in

 * all copies of the software and related documentation, and (ii) the names of

 * Pixar, Sam Leffler and Silicon Graphics may not be used in any advertising or

 * publicity relating to the software without the specific, prior written

 * permission of Pixar, Sam Leffler and Silicon Graphics.

 * 

 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 

 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 

 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  

 * 

 * IN NO EVENT SHALL PIXAR, SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR

 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,

 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 

 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 

 * OF THIS SOFTWARE.

 */

#include "tiffiop.h"

#ifdef PIXARLOG_SUPPORT

/*

 * TIFF Library.

 * PixarLog Compression Support

 *

 * Contributed by Dan McCoy.

 *

 * PixarLog film support uses the TIFF library to store companded

 * 11 bit values into a tiff file, which are compressed using the 

 * zip compressor.  

 *

 * The codec can take as input and produce as output 32-bit IEEE float values 

 * as well as 16-bit or 8-bit unsigned integer values.

 *

 * On writing any of the above are converted into the internal

 * 11-bit log format.   In the case of  8 and 16 bit values, the

 * input is assumed to be unsigned linear color values that represent

 * the range 0-1.  In the case of IEEE values, the 0-1 range is assumed to

 * be the normal linear color range, in addition over 1 values are

 * accepted up to a value of about 25.0 to encode "hot" highlights and such.

 * The encoding is lossless for 8-bit values, slightly lossy for the

 * other bit depths.  The actual color precision should be better

 * than the human eye can perceive with extra room to allow for

 * error introduced by further image computation.  As with any quantized

 * color format, it is possible to perform image calculations which

 * expose the quantization error. This format should certainly be less 

 * susceptible to such errors than standard 8-bit encodings, but more

 * susceptible than straight 16-bit or 32-bit encodings.

 *

 * On reading the internal format is converted to the desired output format.

 * The program can request which format it desires by setting the internal

 * pseudo tag TIFFTAG_PIXARLOGDATAFMT to one of these possible values:

 *  PIXARLOGDATAFMT_FLOAT     = provide IEEE float values.

 *  PIXARLOGDATAFMT_16BIT     = provide unsigned 16-bit integer values

 *  PIXARLOGDATAFMT_8BIT      = provide unsigned 8-bit integer values

 *

 * alternately PIXARLOGDATAFMT_8BITABGR provides unsigned 8-bit integer

 * values with the difference that if there are exactly three or four channels

 * (rgb or rgba) it swaps the channel order (bgr or abgr).

 *

 * PIXARLOGDATAFMT_11BITLOG provides the internal encoding directly

 * packed in 16-bit values.   However no tools are supplied for interpreting

 * these values.

 *

 * "hot" (over 1.0) areas written in floating point get clamped to

 * 1.0 in the integer data types.

 *

 * When the file is closed after writing, the bit depth and sample format

 * are set always to appear as if 8-bit data has been written into it.

 * That way a naive program unaware of the particulars of the encoding

 * gets the format it is most likely able to handle.

 *

 * The codec does it's own horizontal differencing step on the coded

 * values so the libraries predictor stuff should be turned off.

 * The codec also handle byte swapping the encoded values as necessary

 * since the library does not have the information necessary

 * to know the bit depth of the raw unencoded buffer.

 *

 * NOTE: This decoder does not appear to update tif_rawcp, and tif_rawcc.

 * This can cause problems with the implementation of CHUNKY_STRIP_READ_SUPPORT

 * as noted in http://trac.osgeo.org/gdal/ticket/3894.   FrankW - Jan'11

 */

#include "tif_predict.h"

#include "zlib.h"

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

/* Tables for converting to/from 11 bit coded values */

#define  TSIZE	 2048		/* decode table size (11-bit tokens) */

#define  TSIZEP1 2049		/* Plus one for slop */

#define  ONE	 1250		/* token value of 1.0 exactly */

#define  RATIO	 1.004		/* nominal ratio for log part */

#define CODE_MASK 0x7ff         /* 11 bits. */

static float  Fltsize;

static float  LogK1, LogK2;

#define REPEAT(n, op)   { int i; i=n; do { i--; op; } while (i>0); }

static void

horizontalAccumulateF(uint16 *wp, int n, int stride, float *op,

	float *ToLinearF)

{

    register unsigned int  cr, cg, cb, ca, mask;

    register float  t0, t1, t2, t3;

    if (n >= stride) {

	mask = CODE_MASK;

	if (stride == 3) {

	    t0 = ToLinearF[cr = (wp[0] & mask)];

	    t1 = ToLinearF[cg = (wp[1] & mask)];

	    t2 = ToLinearF[cb = (wp[2] & mask)];

	    op[0] = t0;

	    op[1] = t1;

	    op[2] = t2;

	    n -= 3;

	    while (n > 0) {

		wp += 3;

		op += 3;

		n -= 3;

		t0 = ToLinearF[(cr += wp[0]) & mask];

		t1 = ToLinearF[(cg += wp[1]) & mask];

		t2 = ToLinearF[(cb += wp[2]) & mask];

		op[0] = t0;

		op[1] = t1;

		op[2] = t2;

	    }

	} else if (stride == 4) {

	    t0 = ToLinearF[cr = (wp[0] & mask)];

	    t1 = ToLinearF[cg = (wp[1] & mask)];

	    t2 = ToLinearF[cb = (wp[2] & mask)];

	    t3 = ToLinearF[ca = (wp[3] & mask)];

	    op[0] = t0;

	    op[1] = t1;

	    op[2] = t2;

	    op[3] = t3;

	    n -= 4;

	    while (n > 0) {

		wp += 4;

		op += 4;

		n -= 4;

		t0 = ToLinearF[(cr += wp[0]) & mask];

		t1 = ToLinearF[(cg += wp[1]) & mask];

		t2 = ToLinearF[(cb += wp[2]) & mask];

		t3 = ToLinearF[(ca += wp[3]) & mask];

		op[0] = t0;

		op[1] = t1;

		op[2] = t2;

		op[3] = t3;

	    }

	} else {

	    REPEAT(stride, *op = ToLinearF[*wp&mask]; wp++; op++)

	    n -= stride;

	    while (n > 0) {

		REPEAT(stride,

		    wp[stride] += *wp; *op = ToLinearF[*wp&mask]; wp++; op++)

		n -= stride;

	    }

	}

    }

}

static void

horizontalAccumulate12(uint16 *wp, int n, int stride, int16 *op,

	float *ToLinearF)

{

    register unsigned int  cr, cg, cb, ca, mask;

    register float  t0, t1, t2, t3;

#define SCALE12 2048.0F

#define CLAMP12(t) (((t) < 3071) ? (uint16) (t) : 3071)

    if (n >= stride) {

	mask = CODE_MASK;

	if (stride == 3) {

	    t0 = ToLinearF[cr = (wp[0] & mask)] * SCALE12;

	    t1 = ToLinearF[cg = (wp[1] & mask)] * SCALE12;

	    t2 = ToLinearF[cb = (wp[2] & mask)] * SCALE12;

	    op[0] = CLAMP12(t0);

	    op[1] = CLAMP12(t1);

	    op[2] = CLAMP12(t2);

	    n -= 3;

	    while (n > 0) {

		wp += 3;

		op += 3;

		n -= 3;

		t0 = ToLinearF[(cr += wp[0]) & mask] * SCALE12;

		t1 = ToLinearF[(cg += wp[1]) & mask] * SCALE12;

		t2 = ToLinearF[(cb += wp[2]) & mask] * SCALE12;

		op[0] = CLAMP12(t0);

		op[1] = CLAMP12(t1);

		op[2] = CLAMP12(t2);

	    }

	} else if (stride == 4) {

	    t0 = ToLinearF[cr = (wp[0] & mask)] * SCALE12;

	    t1 = ToLinearF[cg = (wp[1] & mask)] * SCALE12;

	    t2 = ToLinearF[cb = (wp[2] & mask)] * SCALE12;

	    t3 = ToLinearF[ca = (wp[3] & mask)] * SCALE12;

	    op[0] = CLAMP12(t0);

	    op[1] = CLAMP12(t1);

	    op[2] = CLAMP12(t2);

	    op[3] = CLAMP12(t3);

	    n -= 4;

	    while (n > 0) {

		wp += 4;

		op += 4;

		n -= 4;

		t0 = ToLinearF[(cr += wp[0]) & mask] * SCALE12;

		t1 = ToLinearF[(cg += wp[1]) & mask] * SCALE12;

		t2 = ToLinearF[(cb += wp[2]) & mask] * SCALE12;

		t3 = ToLinearF[(ca += wp[3]) & mask] * SCALE12;

		op[0] = CLAMP12(t0);

		op[1] = CLAMP12(t1);

		op[2] = CLAMP12(t2);

		op[3] = CLAMP12(t3);

	    }

	} else {

	    REPEAT(stride, t0 = ToLinearF[*wp&mask] * SCALE12;

                           *op = CLAMP12(t0); wp++; op++)

	    n -= stride;

	    while (n > 0) {

		REPEAT(stride,

		    wp[stride] += *wp; t0 = ToLinearF[wp[stride]&mask]*SCALE12;

		    *op = CLAMP12(t0);  wp++; op++)

		n -= stride;

	    }

	}

    }

}

static void

horizontalAccumulate16(uint16 *wp, int n, int stride, uint16 *op,

	uint16 *ToLinear16)

{

    register unsigned int  cr, cg, cb, ca, mask;

    if (n >= stride) {

	mask = CODE_MASK;

	if (stride == 3) {

	    op[0] = ToLinear16[cr = (wp[0] & mask)];

	    op[1] = ToLinear16[cg = (wp[1] & mask)];

	    op[2] = ToLinear16[cb = (wp[2] & mask)];

	    n -= 3;

	    while (n > 0) {

		wp += 3;

		op += 3;

		n -= 3;

		op[0] = ToLinear16[(cr += wp[0]) & mask];

		op[1] = ToLinear16[(cg += wp[1]) & mask];

		op[2] = ToLinear16[(cb += wp[2]) & mask];

	    }

	} else if (stride == 4) {

	    op[0] = ToLinear16[cr = (wp[0] & mask)];

	    op[1] = ToLinear16[cg = (wp[1] & mask)];

	    op[2] = ToLinear16[cb = (wp[2] & mask)];

	    op[3] = ToLinear16[ca = (wp[3] & mask)];

	    n -= 4;

	    while (n > 0) {

		wp += 4;

		op += 4;

		n -= 4;

		op[0] = ToLinear16[(cr += wp[0]) & mask];

		op[1] = ToLinear16[(cg += wp[1]) & mask];

		op[2] = ToLinear16[(cb += wp[2]) & mask];

		op[3] = ToLinear16[(ca += wp[3]) & mask];

	    }

	} else {

	    REPEAT(stride, *op = ToLinear16[*wp&mask]; wp++; op++)

	    n -= stride;

	    while (n > 0) {

		REPEAT(stride,

		    wp[stride] += *wp; *op = ToLinear16[*wp&mask]; wp++; op++)

		n -= stride;

	    }

	}

    }

}

/* 

 * Returns the log encoded 11-bit values with the horizontal

 * differencing undone.

 */

static void

horizontalAccumulate11(uint16 *wp, int n, int stride, uint16 *op)

{

    register unsigned int cr, cg, cb, ca, mask;

    if (n >= stride) {

	mask = CODE_MASK;

	if (stride == 3) {

	    op[0] = wp[0];  op[1] = wp[1];  op[2] = wp[2];

            cr = wp[0];  cg = wp[1];  cb = wp[2];

	    n -= 3;

	    while (n > 0) {

		wp += 3;

		op += 3;

		n -= 3;

		op[0] = (uint16)((cr += wp[0]) & mask);

		op[1] = (uint16)((cg += wp[1]) & mask);

		op[2] = (uint16)((cb += wp[2]) & mask);

	    }

	} else if (stride == 4) {

	    op[0] = wp[0];  op[1] = wp[1];

	    op[2] = wp[2];  op[3] = wp[3];

            cr = wp[0]; cg = wp[1]; cb = wp[2]; ca = wp[3];

	    n -= 4;

	    while (n > 0) {

		wp += 4;

		op += 4;

		n -= 4;

		op[0] = (uint16)((cr += wp[0]) & mask);

		op[1] = (uint16)((cg += wp[1]) & mask);

		op[2] = (uint16)((cb += wp[2]) & mask);

		op[3] = (uint16)((ca += wp[3]) & mask);

	    } 

	} else {

	    REPEAT(stride, *op = *wp&mas;; wp++; op++)

	    n -= stride;

	    while (n > 0) {

		REPEAT(stride,

		    wp[stride] += *wp; *op = *wp&mas;; wp++; op++)

		n -= stride;

	    }

	}

    }

}

static void

horizontalAccumulate8(uint16 *wp, int n, int stride, unsigned char *op,

	unsigned char *ToLinear8)

{

    register unsigned int  cr, cg, cb, ca, mask;

    if (n >= stride) {

	mask = CODE_MASK;

	if (stride == 3) {

	    op[0] = ToLinear8[cr = (wp[0] & mask)];

	    op[1] = ToLinear8[cg = (wp[1] & mask)];

	    op[2] = ToLinear8[cb = (wp[2] & mask)];

	    n -= 3;

	    while (n > 0) {

		n -= 3;

		wp += 3;

		op += 3;

		op[0] = ToLinear8[(cr += wp[0]) & mask];

		op[1] = ToLinear8[(cg += wp[1]) & mask];

		op[2] = ToLinear8[(cb += wp[2]) & mask];

	    }

	} else if (stride == 4) {

	    op[0] = ToLinear8[cr = (wp[0] & mask)];

	    op[1] = ToLinear8[cg = (wp[1] & mask)];

	    op[2] = ToLinear8[cb = (wp[2] & mask)];

	    op[3] = ToLinear8[ca = (wp[3] & mask)];

	    n -= 4;

	    while (n > 0) {

		n -= 4;

		wp += 4;

		op += 4;

		op[0] = ToLinear8[(cr += wp[0]) & mask];

		op[1] = ToLinear8[(cg += wp[1]) & mask];

		op[2] = ToLinear8[(cb += wp[2]) & mask];

		op[3] = ToLinear8[(ca += wp[3]) & mask];

	    }

	} else {

	    REPEAT(stride, *op = ToLinear8[*wp&mask]; wp++; op++)

	    n -= stride;

	    while (n > 0) {

		REPEAT(stride,

		    wp[stride] += *wp; *op = ToLinear8[*wp&mask]; wp++; op++)

		n -= stride;

	    }

	}

    }

}

static void

horizontalAccumulate8abgr(uint16 *wp, int n, int stride, unsigned char *op,

	unsigned char *ToLinear8)

{

    register unsigned int  cr, cg, cb, ca, mask;

    register unsigned char  t0, t1, t2, t3;

    if (n >= stride) {

	mask = CODE_MASK;

	if (stride == 3) {

	    op[0] = 0;

	    t1 = ToLinear8[cb = (wp[2] & mask)];

	    t2 = ToLinear8[cg = (wp[1] & mask)];

	    t3 = ToLinear8[cr = (wp[0] & mask)];

	    op[1] = t1;

	    op[2] = t2;

	    op[3] = t3;

	    n -= 3;

	    while (n > 0) {

		n -= 3;

		wp += 3;

		op += 4;

		op[0] = 0;

		t1 = ToLinear8[(cb += wp[2]) & mask];

		t2 = ToLinear8[(cg += wp[1]) & mask];

		t3 = ToLinear8[(cr += wp[0]) & mask];

		op[1] = t1;

		op[2] = t2;

		op[3] = t3;

	    }

	} else if (stride == 4) {

	    t0 = ToLinear8[ca = (wp[3] & mask)];

	    t1 = ToLinear8[cb = (wp[2] & mask)];

	    t2 = ToLinear8[cg = (wp[1] & mask)];

	    t3 = ToLinear8[cr = (wp[0] & mask)];

	    op[0] = t0;

	    op[1] = t1;

	    op[2] = t2;

	    op[3] = t3;

	    n -= 4;

	    while (n > 0) {

		n -= 4;

		wp += 4;

		op += 4;

		t0 = ToLinear8[(ca += wp[3]) & mask];

		t1 = ToLinear8[(cb += wp[2]) & mask];

		t2 = ToLinear8[(cg += wp[1]) & mask];

		t3 = ToLinear8[(cr += wp[0]) & mask];

		op[0] = t0;

		op[1] = t1;

		op[2] = t2;

		op[3] = t3;

	    }

	} else {

	    REPEAT(stride, *op = ToLinear8[*wp&mask]; wp++; op++)

	    n -= stride;

	    while (n > 0) {

		REPEAT(stride,

		    wp[stride] += *wp; *op = ToLinear8[*wp&mask]; wp++; op++)

		n -= stride;

	    }

	}

    }

}

/*

 * State block for each open TIFF

 * file using PixarLog compression/decompression.

 */

typedef	struct {

	TIFFPredictorState	predict;

	z_stream		stream;

	tmsize_t		tbuf_size; /* only set/used on reading for now */

	uint16			*tbuf; 

	uint16			stride;

	int			state;

	int			user_datafmt;

	int			quality;

#define PLSTATE_INIT 1

	TIFFVSetMethod		vgetparent;	/* super-class method */

	TIFFVSetMethod		vsetparent;	/* super-class method */

	float *ToLinearF;

	uint16 *ToLinear16;

	unsigned char *ToLinear8;

	uint16  *FromLT2;

	uint16  *From14; /* Really for 16-bit data, but we shift down 2 */

	uint16  *From8;

} PixarLogState;

static int

PixarLogMakeTables(PixarLogState *sp)

{

/*

 *    We make several tables here to convert between various external

 *    representations (float, 16-bit, and 8-bit) and the internal

 *    11-bit companded representation.  The 11-bit representation has two

 *    distinct regions.  A linear bottom end up through .018316 in steps

 *    of about .000073, and a region of constant ratio up to about 25.

 *    These floating point numbers are stored in the main table ToLinearF. 

 *    All other tables are derived from this one.  The tables (and the

 *    ratios) are continuous at the internal seam.

 */

    int  nlin, lt2size;

    int  i, j;

    double  b, c, linstep, v;

    float *ToLinearF;

    uint16 *ToLinear16;

    unsigned char *ToLinear8;

    uint16  *FromLT2;

    uint16  *From14; /* Really for 16-bit data, but we shift down 2 */

    uint16  *From8;

    c = log(RATIO);	

    nlin = (int)(1./c);	/* nlin must be an integer */

    c = 1./nlin;

    b = exp(-c*ONE);	/* multiplicative scale factor [b*exp(c*ONE) = 1] */

    linstep = b*c*exp(1.);

    LogK1 = (float)(1./c);	/* if (v >= 2)  token = k1*log(v*k2) */

    LogK2 = (float)(1./b);

    lt2size = (int)(2./linstep) + 1;

    FromLT2 = (uint16 *)_TIFFmalloc(lt2size*sizeof(uint16));

    From14 = (uint16 *)_TIFFmalloc(16384*sizeof(uint16));

    From8 = (uint16 *)_TIFFmalloc(256*sizeof(uint16));

    ToLinearF = (float *)_TIFFmalloc(TSIZEP1 * sizeof(float));

    ToLinear16 = (uint16 *)_TIFFmalloc(TSIZEP1 * sizeof(uint16));

    ToLinear8 = (unsigned char *)_TIFFmalloc(TSIZEP1 * sizeof(unsigned char));

    if (FromLT2 == NULL || From14  == NULL || From8   == NULL ||

	 ToLinearF == NULL || ToLinear16 == NULL || ToLinear8 == NULL) {

	if (FromLT2) _TIFFfree(FromLT2);

	if (From14) _TIFFfree(From14);

	if (From8) _TIFFfree(From8);

	if (ToLinearF) _TIFFfree(ToLinearF);

	if (ToLinear16) _TIFFfree(ToLinear16);

	if (ToLinear8) _TIFFfree(ToLinear8);

	sp->FromLT2 = NULL;

	sp->From14 = NULL;

	sp->From8 = NULL;

	sp->ToLinearF = NULL;

	sp->ToLinear16 = NULL;

	sp->ToLinear8 = NULL;

	return 0;

    }

    j = 0;

    for (i = 0; i < nlin; i++)  {

	v = i * linstep;

	ToLinearF[j++] = (float)v;

    }

    for (i = nlin; i < TSIZE; i++)

	ToLinearF[j++] = (float)(b*exp(c*i));

    ToLinearF[2048] = ToLinearF[2047];

    for (i = 0; i < TSIZEP1; i++)  {

	v = ToLinearF[i]*65535.0 + 0.5;

	ToLinear16[i] = (v > 65535.0) ? 65535 : (uint16)v;

	v = ToLinearF[i]*255.0  + 0.5;

	ToLinear8[i]  = (v > 255.0) ? 255 : (unsigned char)v;

    }

    j = 0;

    for (i = 0; i < lt2size; i++)  {

	if ((i*linstep)*(i*linstep) > ToLinearF[j]*ToLinearF[j+1])

	    j++;

	FromLT2[i] = (uint16)j;

    }

    /*

     * Since we lose info anyway on 16-bit data, we set up a 14-bit

     * table and shift 16-bit values down two bits on input.

     * saves a little table space.

     */

    j = 0;

    for (i = 0; i < 16384; i++)  {

	while ((i/16383.)*(i/16383.) > ToLinearF[j]*ToLinearF[j+1])

	    j++;

	From14[i] = (uint16)j;

    }

    j = 0;

    for (i = 0; i < 256; i++)  {

	while ((i/255.)*(i/255.) > ToLinearF[j]*ToLinearF[j+1])

	    j++;

	From8[i] = (uint16)j;

    }

    Fltsize = (float)(lt2size/2);

    sp->ToLinearF = ToLinearF;

    sp->ToLinear16 = ToLinear16;

    sp->ToLinear8 = ToLinear8;

    sp->FromLT2 = FromLT2;

    sp->From14 = From14;

    sp->From8 = From8;

    return 1;

}

#define DecoderState(tif)	((PixarLogState*) (tif)->tif_data)

#define EncoderState(tif)	((PixarLogState*) (tif)->tif_data)

static int PixarLogEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);

static int PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s);

#define PIXARLOGDATAFMT_UNKNOWN	-1

static int

PixarLogGuessDataFmt(TIFFDirectory *td)

{

	int guess = PIXARLOGDATAFMT_UNKNOWN;

	int format = td->td_sampleformat;

	/* If the user didn't tell us his datafmt,

	 * take our best guess from the bitspersample.

	 */

	switch (td->td_bitspersample) {

	 case 32:

		if (format == SAMPLEFORMAT_IEEEFP)

			guess = PIXARLOGDATAFMT_FLOAT;

		break;

	 case 16:

		if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT)

			guess = PIXARLOGDATAFMT_16BIT;

		break;

	 case 12:

		if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_INT)

			guess = PIXARLOGDATAFMT_12BITPICIO;

		break;

	 case 11:

		if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT)

			guess = PIXARLOGDATAFMT_11BITLOG;

		break;

	 case 8:

		if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT)

			guess = PIXARLOGDATAFMT_8BIT;

		break;

	}

	return guess;

}

#define TIFF_SIZE_T_MAX ((size_t) ~ ((size_t)0))

#define TIFF_TMSIZE_T_MAX (tmsize_t)(TIFF_SIZE_T_MAX >> 1)

static tmsize_t

multiply_ms(tmsize_t m1, tmsize_t m2)

{

        if( m1 == 0 || m2 > TIFF_TMSIZE_T_MAX / m1 )

            return 0;

        return m1 * m2;

}

static tmsize_t

add_ms(tmsize_t m1, tmsize_t m2)

{

	/* if either input is zero, assume overflow already occurred */

	if (m1 == 0 || m2 == 0)

		return 0;

	else if (m1 > TIFF_TMSIZE_T_MAX - m2)

		return 0;

	return m1 + m2;

}

static int

PixarLogFixupTags(TIFF* tif)

{

	(void) tif;

	return (1);

}

static int

PixarLogSetupDecode(TIFF* tif)

{

	static const char module[] = "PixarLogSetupDecode";

	TIFFDirectory *td = &tif->tif_dir;

	PixarLogState* sp = DecoderState(tif);

	tmsize_t tbuf_size;

        uint32 strip_height;

	assert(sp != NULL);

	/* This function can possibly be called several times by */

	/* PredictorSetupDecode() if this function succeeds but */

	/* PredictorSetup() fails */

	if( (sp->state & PLSTATE_INIT) != 0 )

		return 1;

        strip_height = td->td_rowsperstrip;

        if( strip_height > td->td_imagelength )

            strip_height = td->td_imagelength;

	/* Make sure no byte swapping happens on the data

	 * after decompression. */

	tif->tif_postdecode = _TIFFNoPostDecode;  

	/* for some reason, we can't do this in TIFFInitPixarLog */

	sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ?

	    td->td_samplesperpixel : 1);

	tbuf_size = multiply_ms(multiply_ms(multiply_ms(sp->stride, td->td_imagewidth),

				      strip_height), sizeof(uint16));

	/* add one more stride in case input ends mid-stride */

	tbuf_size = add_ms(tbuf_size, sizeof(uint16) * sp->stride);

	if (tbuf_size == 0)

		return (0);   /* TODO: this is an error return without error report through TIFFErrorExt */

	sp->tbuf = (uint16 *) _TIFFmalloc(tbuf_size);

	if (sp->tbuf == NULL)

		return (0);

	sp->tbuf_size = tbuf_size;

	if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN)

		sp->user_datafmt = PixarLogGuessDataFmt(td);

	if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN) {

                _TIFFfree(sp->tbuf);

                sp->tbuf = NULL;

                sp->tbuf_size = 0;

		TIFFErrorExt(tif->tif_clientdata, module,

			"PixarLog compression can't handle bits depth/data format combination (depth: %d)", 

			td->td_bitspersample);

		return (0);

	}

	if (inflateInit(&sp->stream) != Z_OK) {

                _TIFFfree(sp->tbuf);

                sp->tbuf = NULL;

                sp->tbuf_size = 0;

		TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg ? sp->stream.msg : "(null)");

		return (0);

	} else {

		sp->state |= PLSTATE_INIT;

		return (1);

	}

}

/*

 * Setup state for decoding a strip.

 */

static int

PixarLogPreDecode(TIFF* tif, uint16 s)

{

	static const char module[] = "PixarLogPreDecode";

	PixarLogState* sp = DecoderState(tif);

	(void) s;

	assert(sp != NULL);

	sp->stream.next_in = tif->tif_rawdata;

	assert(sizeof(sp->stream.avail_in)==4);  /* if this assert gets raised,

	    we need to simplify this code to reflect a ZLib that is likely updated

	    to deal with 8byte memory sizes, though this code will respond

	    appropriately even before we simplify it */

	sp->stream.avail_in = (uInt) tif->tif_rawcc;

	if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc)

	{

		TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");

		return (0);

	}

	return (inflateReset(&sp->stream) == Z_OK);

}

static int

PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)

{

	static const char module[] = "PixarLogDecode";

	TIFFDirectory *td = &tif->tif_dir;

	PixarLogState* sp = DecoderState(tif);

	tmsize_t i;

	tmsize_t nsamples;

	int llen;

	uint16 *up;

	switch (sp->user_datafmt) {

	case PIXARLOGDATAFMT_FLOAT:

		nsamples = occ / sizeof(float);	/* XXX float == 32 bits */

		break;

	case PIXARLOGDATAFMT_16BIT:

	case PIXARLOGDATAFMT_12BITPICIO:

	case PIXARLOGDATAFMT_11BITLOG:

		nsamples = occ / sizeof(uint16); /* XXX uint16 == 16 bits */

		break;

	case PIXARLOGDATAFMT_8BIT:

	case PIXARLOGDATAFMT_8BITABGR:

		nsamples = occ;

		break;

	default:

		TIFFErrorExt(tif->tif_clientdata, module,

			"%d bit input not supported in PixarLog",

			td->td_bitspersample);

		return 0;

	}

	llen = sp->stride * td->td_imagewidth;

	(void) s;

	assert(sp != NULL);

        sp->stream.next_in = tif->tif_rawcp;

	sp->stream.avail_in = (uInt) tif->tif_rawcc;

	sp->stream.next_out = (unsigned char *) sp->tbuf;

	assert(sizeof(sp->stream.avail_out)==4);  /* if this assert gets raised,

	    we need to simplify this code to reflect a ZLib that is likely updated

	    to deal with 8byte memory sizes, though this code will respond

	    appropriately even before we simplify it */

	sp->stream.avail_out = (uInt) (nsamples * sizeof(uint16));

	if (sp->stream.avail_out != nsamples * sizeof(uint16))

	{

		TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");

		return (0);

	}

	/* Check that we will not fill more than what was allocated */

	if ((tmsize_t)sp->stream.avail_out > sp->tbuf_size)

	{

		TIFFErrorExt(tif->tif_clientdata, module, "sp->stream.avail_out > sp->tbuf_size");

		return (0);

	}

	do {

		int state = inflate(&sp->stream, Z_PARTIAL_FLUSH);

		if (state == Z_STREAM_END) {

			break;			/* XXX */

		}

		if (state == Z_DATA_ERROR) {

			TIFFErrorExt(tif->tif_clientdata, module,

			    "Decoding error at scanline %lu, %s",

			    (unsigned long) tif->tif_row, sp->stream.msg ? sp->stream.msg : "(null)");

			if (inflateSync(&sp->stream) != Z_OK)

				return (0);

			continue;

		}

		if (state != Z_OK) {

			TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",

			    sp->stream.msg ? sp->stream.msg : "(null)");

			return (0);

		}

	} while (sp->stream.avail_out > 0);

	/* hopefully, we got all the bytes we needed */

	if (sp->stream.avail_out != 0) {

		TIFFErrorExt(tif->tif_clientdata, module,

		    "Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)",

		    (unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out);

		return (0);

	}

        tif->tif_rawcp = sp->stream.next_in;

        tif->tif_rawcc = sp->stream.avail_in;

	up = sp->tbuf;

	/* Swap bytes in the data if from a different endian machine. */

	if (tif->tif_flags & TIFF_SWAB)

		TIFFSwabArrayOfShort(up, nsamples);

	/*

	 * if llen is not an exact multiple of nsamples, the decode operation

	 * may overflow the output buffer, so truncate it enough to prevent

	 * that but still salvage as much data as possible.

	 */

	if (nsamples % llen) { 

		TIFFWarningExt(tif->tif_clientdata, module,

			"stride %lu is not a multiple of sample count, "

			"%lu, data truncated.", (unsigned long) llen, (unsigned long) nsamples);

		nsamples -= nsamples % llen;

	}

	for (i = 0; i < nsamples; i += llen, up += llen) {

		switch (sp->user_datafmt)  {

		case PIXARLOGDATAFMT_FLOAT:

			horizontalAccumulateF(up, llen, sp->stride,

					(float *)op, sp->ToLinearF);

			op += llen * sizeof(float);

			break;

		case PIXARLOGDATAFMT_16BIT:

			horizontalAccumulate16(up, llen, sp->stride,

					(uint16 *)op, sp->ToLinear16);

			op += llen * sizeof(uint16);

			break;

		case PIXARLOGDATAFMT_12BITPICIO:

			horizontalAccumulate12(up, llen, sp->stride,

					(int16 *)op, sp->ToLinearF);

			op += llen * sizeof(int16);

			break;

		case PIXARLOGDATAFMT_11BITLOG:

			horizontalAccumulate11(up, llen, sp->stride,

					(uint16 *)op);