Merge XFA to PDFium master at 4dc95e7 on 10/28/2014
[pdfium.git] / core / src / fxcodec / fx_tiff / tiff_v403 / tif_pixarlog.c
1 /* $Id: tif_pixarlog.c,v 1.38 2012-06-21 01:01:53 fwarmerdam Exp $ */
2
3 /*
4  * Copyright (c) 1996-1997 Sam Leffler
5  * Copyright (c) 1996 Pixar
6  *
7  * Permission to use, copy, modify, distribute, and sell this software and 
8  * its documentation for any purpose is hereby granted without fee, provided
9  * that (i) the above copyright notices and this permission notice appear in
10  * all copies of the software and related documentation, and (ii) the names of
11  * Pixar, Sam Leffler and Silicon Graphics may not be used in any advertising or
12  * publicity relating to the software without the specific, prior written
13  * permission of Pixar, Sam Leffler and Silicon Graphics.
14  * 
15  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
16  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
17  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
18  * 
19  * IN NO EVENT SHALL PIXAR, SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
20  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
23  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
24  * OF THIS SOFTWARE.
25  */
26 #if (!defined(_FPDFAPI_MINI_) || defined(_TIFF_DECODER_)) && !defined(_USE_ADDIN_) && !defined _FX_NO_ANSIC_ && !defined(_FX_EMB_NOUSE_DECODER_)
27 #include "tiffiop.h"
28 #ifdef PIXARLOG_SUPPORT
29
30 /*
31  * TIFF Library.
32  * PixarLog Compression Support
33  *
34  * Contributed by Dan McCoy.
35  *
36  * PixarLog film support uses the TIFF library to store companded
37  * 11 bit values into a tiff file, which are compressed using the 
38  * zip compressor.  
39  *
40  * The codec can take as input and produce as output 32-bit IEEE float values 
41  * as well as 16-bit or 8-bit unsigned integer values.
42  *
43  * On writing any of the above are converted into the internal
44  * 11-bit log format.   In the case of  8 and 16 bit values, the
45  * input is assumed to be unsigned linear color values that represent
46  * the range 0-1.  In the case of IEEE values, the 0-1 range is assumed to
47  * be the normal linear color range, in addition over 1 values are
48  * accepted up to a value of about 25.0 to encode "hot" hightlights and such.
49  * The encoding is lossless for 8-bit values, slightly lossy for the
50  * other bit depths.  The actual color precision should be better
51  * than the human eye can perceive with extra room to allow for
52  * error introduced by further image computation.  As with any quantized
53  * color format, it is possible to perform image calculations which
54  * expose the quantization error. This format should certainly be less 
55  * susceptable to such errors than standard 8-bit encodings, but more
56  * susceptable than straight 16-bit or 32-bit encodings.
57  *
58  * On reading the internal format is converted to the desired output format.
59  * The program can request which format it desires by setting the internal
60  * pseudo tag TIFFTAG_PIXARLOGDATAFMT to one of these possible values:
61  *  PIXARLOGDATAFMT_FLOAT     = provide IEEE float values.
62  *  PIXARLOGDATAFMT_16BIT     = provide unsigned 16-bit integer values
63  *  PIXARLOGDATAFMT_8BIT      = provide unsigned 8-bit integer values
64  *
65  * alternately PIXARLOGDATAFMT_8BITABGR provides unsigned 8-bit integer
66  * values with the difference that if there are exactly three or four channels
67  * (rgb or rgba) it swaps the channel order (bgr or abgr).
68  *
69  * PIXARLOGDATAFMT_11BITLOG provides the internal encoding directly
70  * packed in 16-bit values.   However no tools are supplied for interpreting
71  * these values.
72  *
73  * "hot" (over 1.0) areas written in floating point get clamped to
74  * 1.0 in the integer data types.
75  *
76  * When the file is closed after writing, the bit depth and sample format
77  * are set always to appear as if 8-bit data has been written into it.
78  * That way a naive program unaware of the particulars of the encoding
79  * gets the format it is most likely able to handle.
80  *
81  * The codec does it's own horizontal differencing step on the coded
82  * values so the libraries predictor stuff should be turned off.
83  * The codec also handle byte swapping the encoded values as necessary
84  * since the library does not have the information necessary
85  * to know the bit depth of the raw unencoded buffer.
86  *
87  * NOTE: This decoder does not appear to update tif_rawcp, and tif_rawcc.
88  * This can cause problems with the implementation of CHUNKY_STRIP_READ_SUPPORT
89  * as noted in http://trac.osgeo.org/gdal/ticket/3894.   FrankW - Jan'11
90  */
91
92 #include "tif_predict.h"
93 #include "../../fx_zlib/include/fx_zlib.h"
94
95 #include <stdio.h>
96 #include <stdlib.h>
97 #include <math.h>
98
99 /* Tables for converting to/from 11 bit coded values */
100
101 #define  TSIZE   2048           /* decode table size (11-bit tokens) */
102 #define  TSIZEP1 2049           /* Plus one for slop */
103 #define  ONE     1250           /* token value of 1.0 exactly */
104 #define  RATIO   1.004          /* nominal ratio for log part */
105
106 #define CODE_MASK 0x7ff         /* 11 bits. */
107
108 static float  Fltsize;
109 static float  LogK1, LogK2;
110
111 #define REPEAT(n, op)   { int i; i=n; do { i--; op; } while (i>0); }
112
113 static void
114 horizontalAccumulateF(uint16 *wp, int n, int stride, float *op,
115         float *ToLinearF)
116 {
117     register unsigned int  cr, cg, cb, ca, mask;
118     register float  t0, t1, t2, t3;
119
120     if (n >= stride) {
121         mask = CODE_MASK;
122         if (stride == 3) {
123             t0 = ToLinearF[cr = (wp[0] & mask)];
124             t1 = ToLinearF[cg = (wp[1] & mask)];
125             t2 = ToLinearF[cb = (wp[2] & mask)];
126             op[0] = t0;
127             op[1] = t1;
128             op[2] = t2;
129             n -= 3;
130             while (n > 0) {
131                 wp += 3;
132                 op += 3;
133                 n -= 3;
134                 t0 = ToLinearF[(cr += wp[0]) & mask];
135                 t1 = ToLinearF[(cg += wp[1]) & mask];
136                 t2 = ToLinearF[(cb += wp[2]) & mask];
137                 op[0] = t0;
138                 op[1] = t1;
139                 op[2] = t2;
140             }
141         } else if (stride == 4) {
142             t0 = ToLinearF[cr = (wp[0] & mask)];
143             t1 = ToLinearF[cg = (wp[1] & mask)];
144             t2 = ToLinearF[cb = (wp[2] & mask)];
145             t3 = ToLinearF[ca = (wp[3] & mask)];
146             op[0] = t0;
147             op[1] = t1;
148             op[2] = t2;
149             op[3] = t3;
150             n -= 4;
151             while (n > 0) {
152                 wp += 4;
153                 op += 4;
154                 n -= 4;
155                 t0 = ToLinearF[(cr += wp[0]) & mask];
156                 t1 = ToLinearF[(cg += wp[1]) & mask];
157                 t2 = ToLinearF[(cb += wp[2]) & mask];
158                 t3 = ToLinearF[(ca += wp[3]) & mask];
159                 op[0] = t0;
160                 op[1] = t1;
161                 op[2] = t2;
162                 op[3] = t3;
163             }
164         } else {
165             REPEAT(stride, *op = ToLinearF[*wp&mask]; wp++; op++)
166             n -= stride;
167             while (n > 0) {
168                 REPEAT(stride,
169                     wp[stride] += *wp; *op = ToLinearF[*wp&mask]; wp++; op++)
170                 n -= stride;
171             }
172         }
173     }
174 }
175
176 static void
177 horizontalAccumulate12(uint16 *wp, int n, int stride, int16 *op,
178         float *ToLinearF)
179 {
180     register unsigned int  cr, cg, cb, ca, mask;
181     register float  t0, t1, t2, t3;
182
183 #define SCALE12 2048.0F
184 #define CLAMP12(t) (((t) < 3071) ? (uint16) (t) : 3071)
185
186     if (n >= stride) {
187         mask = CODE_MASK;
188         if (stride == 3) {
189             t0 = ToLinearF[cr = (wp[0] & mask)] * SCALE12;
190             t1 = ToLinearF[cg = (wp[1] & mask)] * SCALE12;
191             t2 = ToLinearF[cb = (wp[2] & mask)] * SCALE12;
192             op[0] = CLAMP12(t0);
193             op[1] = CLAMP12(t1);
194             op[2] = CLAMP12(t2);
195             n -= 3;
196             while (n > 0) {
197                 wp += 3;
198                 op += 3;
199                 n -= 3;
200                 t0 = ToLinearF[(cr += wp[0]) & mask] * SCALE12;
201                 t1 = ToLinearF[(cg += wp[1]) & mask] * SCALE12;
202                 t2 = ToLinearF[(cb += wp[2]) & mask] * SCALE12;
203                 op[0] = CLAMP12(t0);
204                 op[1] = CLAMP12(t1);
205                 op[2] = CLAMP12(t2);
206             }
207         } else if (stride == 4) {
208             t0 = ToLinearF[cr = (wp[0] & mask)] * SCALE12;
209             t1 = ToLinearF[cg = (wp[1] & mask)] * SCALE12;
210             t2 = ToLinearF[cb = (wp[2] & mask)] * SCALE12;
211             t3 = ToLinearF[ca = (wp[3] & mask)] * SCALE12;
212             op[0] = CLAMP12(t0);
213             op[1] = CLAMP12(t1);
214             op[2] = CLAMP12(t2);
215             op[3] = CLAMP12(t3);
216             n -= 4;
217             while (n > 0) {
218                 wp += 4;
219                 op += 4;
220                 n -= 4;
221                 t0 = ToLinearF[(cr += wp[0]) & mask] * SCALE12;
222                 t1 = ToLinearF[(cg += wp[1]) & mask] * SCALE12;
223                 t2 = ToLinearF[(cb += wp[2]) & mask] * SCALE12;
224                 t3 = ToLinearF[(ca += wp[3]) & mask] * SCALE12;
225                 op[0] = CLAMP12(t0);
226                 op[1] = CLAMP12(t1);
227                 op[2] = CLAMP12(t2);
228                 op[3] = CLAMP12(t3);
229             }
230         } else {
231             REPEAT(stride, t0 = ToLinearF[*wp&mask] * SCALE12;
232                            *op = CLAMP12(t0); wp++; op++)
233             n -= stride;
234             while (n > 0) {
235                 REPEAT(stride,
236                     wp[stride] += *wp; t0 = ToLinearF[wp[stride]&mask]*SCALE12;
237                     *op = CLAMP12(t0);  wp++; op++)
238                 n -= stride;
239             }
240         }
241     }
242 }
243
244 static void
245 horizontalAccumulate16(uint16 *wp, int n, int stride, uint16 *op,
246         uint16 *ToLinear16)
247 {
248     register unsigned int  cr, cg, cb, ca, mask;
249
250     if (n >= stride) {
251         mask = CODE_MASK;
252         if (stride == 3) {
253             op[0] = ToLinear16[cr = (wp[0] & mask)];
254             op[1] = ToLinear16[cg = (wp[1] & mask)];
255             op[2] = ToLinear16[cb = (wp[2] & mask)];
256             n -= 3;
257             while (n > 0) {
258                 wp += 3;
259                 op += 3;
260                 n -= 3;
261                 op[0] = ToLinear16[(cr += wp[0]) & mask];
262                 op[1] = ToLinear16[(cg += wp[1]) & mask];
263                 op[2] = ToLinear16[(cb += wp[2]) & mask];
264             }
265         } else if (stride == 4) {
266             op[0] = ToLinear16[cr = (wp[0] & mask)];
267             op[1] = ToLinear16[cg = (wp[1] & mask)];
268             op[2] = ToLinear16[cb = (wp[2] & mask)];
269             op[3] = ToLinear16[ca = (wp[3] & mask)];
270             n -= 4;
271             while (n > 0) {
272                 wp += 4;
273                 op += 4;
274                 n -= 4;
275                 op[0] = ToLinear16[(cr += wp[0]) & mask];
276                 op[1] = ToLinear16[(cg += wp[1]) & mask];
277                 op[2] = ToLinear16[(cb += wp[2]) & mask];
278                 op[3] = ToLinear16[(ca += wp[3]) & mask];
279             }
280         } else {
281             REPEAT(stride, *op = ToLinear16[*wp&mask]; wp++; op++)
282             n -= stride;
283             while (n > 0) {
284                 REPEAT(stride,
285                     wp[stride] += *wp; *op = ToLinear16[*wp&mask]; wp++; op++)
286                 n -= stride;
287             }
288         }
289     }
290 }
291
292 /* 
293  * Returns the log encoded 11-bit values with the horizontal
294  * differencing undone.
295  */
296 static void
297 horizontalAccumulate11(uint16 *wp, int n, int stride, uint16 *op)
298 {
299     register unsigned int  cr, cg, cb, ca, mask;
300
301     if (n >= stride) {
302         mask = CODE_MASK;
303         if (stride == 3) {
304             op[0] = cr = wp[0];  op[1] = cg = wp[1];  op[2] = cb = wp[2];
305             n -= 3;
306             while (n > 0) {
307                 wp += 3;
308                 op += 3;
309                 n -= 3;
310                 op[0] = (cr += wp[0]) & mask;
311                 op[1] = (cg += wp[1]) & mask;
312                 op[2] = (cb += wp[2]) & mask;
313             }
314         } else if (stride == 4) {
315             op[0] = cr = wp[0];  op[1] = cg = wp[1];
316             op[2] = cb = wp[2];  op[3] = ca = wp[3];
317             n -= 4;
318             while (n > 0) {
319                 wp += 4;
320                 op += 4;
321                 n -= 4;
322                 op[0] = (cr += wp[0]) & mask;
323                 op[1] = (cg += wp[1]) & mask;
324                 op[2] = (cb += wp[2]) & mask;
325                 op[3] = (ca += wp[3]) & mask;
326             } 
327         } else {
328             REPEAT(stride, *op = *wp&mask; wp++; op++)
329             n -= stride;
330             while (n > 0) {
331                 REPEAT(stride,
332                     wp[stride] += *wp; *op = *wp&mask; wp++; op++)
333                 n -= stride;
334             }
335         }
336     }
337 }
338
339 static void
340 horizontalAccumulate8(uint16 *wp, int n, int stride, unsigned char *op,
341         unsigned char *ToLinear8)
342 {
343     register unsigned int  cr, cg, cb, ca, mask;
344
345     if (n >= stride) {
346         mask = CODE_MASK;
347         if (stride == 3) {
348             op[0] = ToLinear8[cr = (wp[0] & mask)];
349             op[1] = ToLinear8[cg = (wp[1] & mask)];
350             op[2] = ToLinear8[cb = (wp[2] & mask)];
351             n -= 3;
352             while (n > 0) {
353                 n -= 3;
354                 wp += 3;
355                 op += 3;
356                 op[0] = ToLinear8[(cr += wp[0]) & mask];
357                 op[1] = ToLinear8[(cg += wp[1]) & mask];
358                 op[2] = ToLinear8[(cb += wp[2]) & mask];
359             }
360         } else if (stride == 4) {
361             op[0] = ToLinear8[cr = (wp[0] & mask)];
362             op[1] = ToLinear8[cg = (wp[1] & mask)];
363             op[2] = ToLinear8[cb = (wp[2] & mask)];
364             op[3] = ToLinear8[ca = (wp[3] & mask)];
365             n -= 4;
366             while (n > 0) {
367                 n -= 4;
368                 wp += 4;
369                 op += 4;
370                 op[0] = ToLinear8[(cr += wp[0]) & mask];
371                 op[1] = ToLinear8[(cg += wp[1]) & mask];
372                 op[2] = ToLinear8[(cb += wp[2]) & mask];
373                 op[3] = ToLinear8[(ca += wp[3]) & mask];
374             }
375         } else {
376             REPEAT(stride, *op = ToLinear8[*wp&mask]; wp++; op++)
377             n -= stride;
378             while (n > 0) {
379                 REPEAT(stride,
380                     wp[stride] += *wp; *op = ToLinear8[*wp&mask]; wp++; op++)
381                 n -= stride;
382             }
383         }
384     }
385 }
386
387
388 static void
389 horizontalAccumulate8abgr(uint16 *wp, int n, int stride, unsigned char *op,
390         unsigned char *ToLinear8)
391 {
392     register unsigned int  cr, cg, cb, ca, mask;
393     register unsigned char  t0, t1, t2, t3;
394
395     if (n >= stride) {
396         mask = CODE_MASK;
397         if (stride == 3) {
398             op[0] = 0;
399             t1 = ToLinear8[cb = (wp[2] & mask)];
400             t2 = ToLinear8[cg = (wp[1] & mask)];
401             t3 = ToLinear8[cr = (wp[0] & mask)];
402             op[1] = t1;
403             op[2] = t2;
404             op[3] = t3;
405             n -= 3;
406             while (n > 0) {
407                 n -= 3;
408                 wp += 3;
409                 op += 4;
410                 op[0] = 0;
411                 t1 = ToLinear8[(cb += wp[2]) & mask];
412                 t2 = ToLinear8[(cg += wp[1]) & mask];
413                 t3 = ToLinear8[(cr += wp[0]) & mask];
414                 op[1] = t1;
415                 op[2] = t2;
416                 op[3] = t3;
417             }
418         } else if (stride == 4) {
419             t0 = ToLinear8[ca = (wp[3] & mask)];
420             t1 = ToLinear8[cb = (wp[2] & mask)];
421             t2 = ToLinear8[cg = (wp[1] & mask)];
422             t3 = ToLinear8[cr = (wp[0] & mask)];
423             op[0] = t0;
424             op[1] = t1;
425             op[2] = t2;
426             op[3] = t3;
427             n -= 4;
428             while (n > 0) {
429                 n -= 4;
430                 wp += 4;
431                 op += 4;
432                 t0 = ToLinear8[(ca += wp[3]) & mask];
433                 t1 = ToLinear8[(cb += wp[2]) & mask];
434                 t2 = ToLinear8[(cg += wp[1]) & mask];
435                 t3 = ToLinear8[(cr += wp[0]) & mask];
436                 op[0] = t0;
437                 op[1] = t1;
438                 op[2] = t2;
439                 op[3] = t3;
440             }
441         } else {
442             REPEAT(stride, *op = ToLinear8[*wp&mask]; wp++; op++)
443             n -= stride;
444             while (n > 0) {
445                 REPEAT(stride,
446                     wp[stride] += *wp; *op = ToLinear8[*wp&mask]; wp++; op++)
447                 n -= stride;
448             }
449         }
450     }
451 }
452
453 /*
454  * State block for each open TIFF
455  * file using PixarLog compression/decompression.
456  */
457 typedef struct {
458         TIFFPredictorState      predict;
459         z_stream                stream;
460         uint16                  *tbuf; 
461         uint16                  stride;
462         int                     state;
463         int                     user_datafmt;
464         int                     quality;
465 #define PLSTATE_INIT 1
466
467         TIFFVSetMethod          vgetparent;     /* super-class method */
468         TIFFVSetMethod          vsetparent;     /* super-class method */
469
470         float *ToLinearF;
471         uint16 *ToLinear16;
472         unsigned char *ToLinear8;
473         uint16  *FromLT2;
474         uint16  *From14; /* Really for 16-bit data, but we shift down 2 */
475         uint16  *From8;
476         
477 } PixarLogState;
478
479 static int
480 PixarLogMakeTables(PixarLogState *sp)
481 {
482
483 /*
484  *    We make several tables here to convert between various external
485  *    representations (float, 16-bit, and 8-bit) and the internal
486  *    11-bit companded representation.  The 11-bit representation has two
487  *    distinct regions.  A linear bottom end up through .018316 in steps
488  *    of about .000073, and a region of constant ratio up to about 25.
489  *    These floating point numbers are stored in the main table ToLinearF. 
490  *    All other tables are derived from this one.  The tables (and the
491  *    ratios) are continuous at the internal seam.
492  */
493
494     int  nlin, lt2size;
495     int  i, j;
496     double  b, c, linstep, v;
497     float *ToLinearF;
498     uint16 *ToLinear16;
499     unsigned char *ToLinear8;
500     uint16  *FromLT2;
501     uint16  *From14; /* Really for 16-bit data, but we shift down 2 */
502     uint16  *From8;
503
504     c = log(RATIO);     
505     nlin = (int)(1./c); /* nlin must be an integer */
506     c = 1./nlin;
507     b = exp(-c*ONE);    /* multiplicative scale factor [b*exp(c*ONE) = 1] */
508     linstep = b*c*exp(1.);
509
510     LogK1 = (float)(1./c);      /* if (v >= 2)  token = k1*log(v*k2) */
511     LogK2 = (float)(1./b);
512     lt2size = (int)(2./linstep) + 1;
513     FromLT2 = (uint16 *)_TIFFmalloc(lt2size*sizeof(uint16));
514     From14 = (uint16 *)_TIFFmalloc(16384*sizeof(uint16));
515     From8 = (uint16 *)_TIFFmalloc(256*sizeof(uint16));
516     ToLinearF = (float *)_TIFFmalloc(TSIZEP1 * sizeof(float));
517     ToLinear16 = (uint16 *)_TIFFmalloc(TSIZEP1 * sizeof(uint16));
518     ToLinear8 = (unsigned char *)_TIFFmalloc(TSIZEP1 * sizeof(unsigned char));
519     if (FromLT2 == NULL || From14  == NULL || From8   == NULL ||
520          ToLinearF == NULL || ToLinear16 == NULL || ToLinear8 == NULL) {
521         if (FromLT2) _TIFFfree(FromLT2);
522         if (From14) _TIFFfree(From14);
523         if (From8) _TIFFfree(From8);
524         if (ToLinearF) _TIFFfree(ToLinearF);
525         if (ToLinear16) _TIFFfree(ToLinear16);
526         if (ToLinear8) _TIFFfree(ToLinear8);
527         sp->FromLT2 = NULL;
528         sp->From14 = NULL;
529         sp->From8 = NULL;
530         sp->ToLinearF = NULL;
531         sp->ToLinear16 = NULL;
532         sp->ToLinear8 = NULL;
533         return 0;
534     }
535
536     j = 0;
537
538     for (i = 0; i < nlin; i++)  {
539         v = i * linstep;
540         ToLinearF[j++] = (float)v;
541     }
542
543     for (i = nlin; i < TSIZE; i++)
544         ToLinearF[j++] = (float)(b*exp(c*i));
545
546     ToLinearF[2048] = ToLinearF[2047];
547
548     for (i = 0; i < TSIZEP1; i++)  {
549         v = ToLinearF[i]*65535.0 + 0.5;
550         ToLinear16[i] = (v > 65535.0) ? 65535 : (uint16)v;
551         v = ToLinearF[i]*255.0  + 0.5;
552         ToLinear8[i]  = (v > 255.0) ? 255 : (unsigned char)v;
553     }
554
555     j = 0;
556     for (i = 0; i < lt2size; i++)  {
557         if ((i*linstep)*(i*linstep) > ToLinearF[j]*ToLinearF[j+1])
558             j++;
559         FromLT2[i] = j;
560     }
561
562     /*
563      * Since we lose info anyway on 16-bit data, we set up a 14-bit
564      * table and shift 16-bit values down two bits on input.
565      * saves a little table space.
566      */
567     j = 0;
568     for (i = 0; i < 16384; i++)  {
569         while ((i/16383.)*(i/16383.) > ToLinearF[j]*ToLinearF[j+1])
570             j++;
571         From14[i] = j;
572     }
573
574     j = 0;
575     for (i = 0; i < 256; i++)  {
576         while ((i/255.)*(i/255.) > ToLinearF[j]*ToLinearF[j+1])
577             j++;
578         From8[i] = j;
579     }
580
581     Fltsize = (float)(lt2size/2);
582
583     sp->ToLinearF = ToLinearF;
584     sp->ToLinear16 = ToLinear16;
585     sp->ToLinear8 = ToLinear8;
586     sp->FromLT2 = FromLT2;
587     sp->From14 = From14;
588     sp->From8 = From8;
589
590     return 1;
591 }
592
593 #define DecoderState(tif)       ((PixarLogState*) (tif)->tif_data)
594 #define EncoderState(tif)       ((PixarLogState*) (tif)->tif_data)
595
596 static int PixarLogEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
597 static int PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s);
598
599 #define PIXARLOGDATAFMT_UNKNOWN -1
600
601 static int
602 PixarLogGuessDataFmt(TIFFDirectory *td)
603 {
604         int guess = PIXARLOGDATAFMT_UNKNOWN;
605         int format = td->td_sampleformat;
606
607         /* If the user didn't tell us his datafmt,
608          * take our best guess from the bitspersample.
609          */
610         switch (td->td_bitspersample) {
611          case 32:
612                 if (format == SAMPLEFORMAT_IEEEFP)
613                         guess = PIXARLOGDATAFMT_FLOAT;
614                 break;
615          case 16:
616                 if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT)
617                         guess = PIXARLOGDATAFMT_16BIT;
618                 break;
619          case 12:
620                 if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_INT)
621                         guess = PIXARLOGDATAFMT_12BITPICIO;
622                 break;
623          case 11:
624                 if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT)
625                         guess = PIXARLOGDATAFMT_11BITLOG;
626                 break;
627          case 8:
628                 if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT)
629                         guess = PIXARLOGDATAFMT_8BIT;
630                 break;
631         }
632
633         return guess;
634 }
635
636 static tmsize_t
637 multiply_ms(tmsize_t m1, tmsize_t m2)
638 {
639         tmsize_t bytes = m1 * m2;
640
641         if (m1 && bytes / m1 != m2)
642                 bytes = 0;
643
644         return bytes;
645 }
646
647 static int
648 PixarLogFixupTags(TIFF* tif)
649 {
650         (void) tif;
651         return (1);
652 }
653
654 static int
655 PixarLogSetupDecode(TIFF* tif)
656 {
657         static const char module[] = "PixarLogSetupDecode";
658         TIFFDirectory *td = &tif->tif_dir;
659         PixarLogState* sp = DecoderState(tif);
660         tmsize_t tbuf_size;
661
662         assert(sp != NULL);
663
664         /* Make sure no byte swapping happens on the data
665          * after decompression. */
666         tif->tif_postdecode = _TIFFNoPostDecode;  
667
668         /* for some reason, we can't do this in TIFFInitPixarLog */
669
670         sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ?
671             td->td_samplesperpixel : 1);
672         tbuf_size = multiply_ms(multiply_ms(multiply_ms(sp->stride, td->td_imagewidth),
673                                       td->td_rowsperstrip), sizeof(uint16));
674         if (tbuf_size == 0)
675                 return (0);   /* TODO: this is an error return without error report through TIFFErrorExt */
676         sp->tbuf = (uint16 *) _TIFFmalloc(tbuf_size+sizeof(uint16)*sp->stride);
677         if (sp->tbuf == NULL)
678                 return (0);
679         if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN)
680                 sp->user_datafmt = PixarLogGuessDataFmt(td);
681         if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN) {
682                 TIFFErrorExt(tif->tif_clientdata, module,
683                         "PixarLog compression can't handle bits depth/data format combination (depth: %d)", 
684                         td->td_bitspersample);
685                 return (0);
686         }
687
688         if (inflateInit(&sp->stream) != Z_OK) {
689                 TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg);
690                 return (0);
691         } else {
692                 sp->state |= PLSTATE_INIT;
693                 return (1);
694         }
695 }
696
697 /*
698  * Setup state for decoding a strip.
699  */
700 static int
701 PixarLogPreDecode(TIFF* tif, uint16 s)
702 {
703         static const char module[] = "PixarLogPreDecode";
704         PixarLogState* sp = DecoderState(tif);
705
706         (void) s;
707         assert(sp != NULL);
708         sp->stream.next_in = tif->tif_rawdata;
709         assert(sizeof(sp->stream.avail_in)==4);  /* if this assert gets raised,
710             we need to simplify this code to reflect a ZLib that is likely updated
711             to deal with 8byte memory sizes, though this code will respond
712             apropriately even before we simplify it */
713         sp->stream.avail_in = (uInt) tif->tif_rawcc;
714         if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc)
715         {
716                 TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
717                 return (0);
718         }
719         return (inflateReset(&sp->stream) == Z_OK);
720 }
721
722 static int
723 PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
724 {
725         static const char module[] = "PixarLogDecode";
726         TIFFDirectory *td = &tif->tif_dir;
727         PixarLogState* sp = DecoderState(tif);
728         tmsize_t i;
729         tmsize_t nsamples;
730         int llen;
731         uint16 *up;
732
733         switch (sp->user_datafmt) {
734         case PIXARLOGDATAFMT_FLOAT:
735                 nsamples = occ / sizeof(float); /* XXX float == 32 bits */
736                 break;
737         case PIXARLOGDATAFMT_16BIT:
738         case PIXARLOGDATAFMT_12BITPICIO:
739         case PIXARLOGDATAFMT_11BITLOG:
740                 nsamples = occ / sizeof(uint16); /* XXX uint16 == 16 bits */
741                 break;
742         case PIXARLOGDATAFMT_8BIT:
743         case PIXARLOGDATAFMT_8BITABGR:
744                 nsamples = occ;
745                 break;
746         default:
747                 TIFFErrorExt(tif->tif_clientdata, module,
748                         "%d bit input not supported in PixarLog",
749                         td->td_bitspersample);
750                 return 0;
751         }
752
753         llen = sp->stride * td->td_imagewidth;
754
755         (void) s;
756         assert(sp != NULL);
757         sp->stream.next_out = (unsigned char *) sp->tbuf;
758         assert(sizeof(sp->stream.avail_out)==4);  /* if this assert gets raised,
759             we need to simplify this code to reflect a ZLib that is likely updated
760             to deal with 8byte memory sizes, though this code will respond
761             apropriately even before we simplify it */
762         sp->stream.avail_out = (uInt) (nsamples * sizeof(uint16));
763         if (sp->stream.avail_out != nsamples * sizeof(uint16))
764         {
765                 TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
766                 return (0);
767         }
768         do {
769                 int state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
770                 if (state == Z_STREAM_END) {
771                         break;                  /* XXX */
772                 }
773                 if (state == Z_DATA_ERROR) {
774                         TIFFErrorExt(tif->tif_clientdata, module,
775                             "Decoding error at scanline %lu, %s",
776                             (unsigned long) tif->tif_row, sp->stream.msg);
777                         if (inflateSync(&sp->stream) != Z_OK)
778                                 return (0);
779                         continue;
780                 }
781                 if (state != Z_OK) {
782                         TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
783                             sp->stream.msg);
784                         return (0);
785                 }
786         } while (sp->stream.avail_out > 0);
787
788         /* hopefully, we got all the bytes we needed */
789         if (sp->stream.avail_out != 0) {
790                 TIFFErrorExt(tif->tif_clientdata, module,
791                     "Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)",
792                     (unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out);
793                 return (0);
794         }
795
796         up = sp->tbuf;
797         /* Swap bytes in the data if from a different endian machine. */
798         if (tif->tif_flags & TIFF_SWAB)
799                 TIFFSwabArrayOfShort(up, nsamples);
800
801         /*
802          * if llen is not an exact multiple of nsamples, the decode operation
803          * may overflow the output buffer, so truncate it enough to prevent
804          * that but still salvage as much data as possible.
805          */
806         if (nsamples % llen) { 
807                 TIFFWarningExt(tif->tif_clientdata, module,
808                         "stride %lu is not a multiple of sample count, "
809                         "%lu, data truncated.", (unsigned long) llen, (unsigned long) nsamples);
810                 nsamples -= nsamples % llen;
811         }
812
813         for (i = 0; i < nsamples; i += llen, up += llen) {
814                 switch (sp->user_datafmt)  {
815                 case PIXARLOGDATAFMT_FLOAT:
816                         horizontalAccumulateF(up, llen, sp->stride,
817                                         (float *)op, sp->ToLinearF);
818                         op += llen * sizeof(float);
819                         break;
820                 case PIXARLOGDATAFMT_16BIT:
821                         horizontalAccumulate16(up, llen, sp->stride,
822                                         (uint16 *)op, sp->ToLinear16);
823                         op += llen * sizeof(uint16);
824                         break;
825                 case PIXARLOGDATAFMT_12BITPICIO:
826                         horizontalAccumulate12(up, llen, sp->stride,
827                                         (int16 *)op, sp->ToLinearF);
828                         op += llen * sizeof(int16);
829                         break;
830                 case PIXARLOGDATAFMT_11BITLOG:
831                         horizontalAccumulate11(up, llen, sp->stride,
832                                         (uint16 *)op);
833                         op += llen * sizeof(uint16);
834                         break;
835                 case PIXARLOGDATAFMT_8BIT:
836                         horizontalAccumulate8(up, llen, sp->stride,
837                                         (unsigned char *)op, sp->ToLinear8);
838                         op += llen * sizeof(unsigned char);
839                         break;
840                 case PIXARLOGDATAFMT_8BITABGR:
841                         horizontalAccumulate8abgr(up, llen, sp->stride,
842                                         (unsigned char *)op, sp->ToLinear8);
843                         op += llen * sizeof(unsigned char);
844                         break;
845                 default:
846                         TIFFErrorExt(tif->tif_clientdata, module,
847                                   "Unsupported bits/sample: %d",
848                                   td->td_bitspersample);
849                         return (0);
850                 }
851         }
852
853         return (1);
854 }
855
856 static int
857 PixarLogSetupEncode(TIFF* tif)
858 {
859         static const char module[] = "PixarLogSetupEncode";
860         TIFFDirectory *td = &tif->tif_dir;
861         PixarLogState* sp = EncoderState(tif);
862         tmsize_t tbuf_size;
863
864         assert(sp != NULL);
865
866         /* for some reason, we can't do this in TIFFInitPixarLog */
867
868         sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ?
869             td->td_samplesperpixel : 1);
870         tbuf_size = multiply_ms(multiply_ms(multiply_ms(sp->stride, td->td_imagewidth),
871                                       td->td_rowsperstrip), sizeof(uint16));
872         if (tbuf_size == 0)
873                 return (0);  /* TODO: this is an error return without error report through TIFFErrorExt */
874         sp->tbuf = (uint16 *) _TIFFmalloc(tbuf_size);
875         if (sp->tbuf == NULL)
876                 return (0);
877         if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN)
878                 sp->user_datafmt = PixarLogGuessDataFmt(td);
879         if (sp->user_datafmt == PIXARLOGDATAFMT_UNKNOWN) {
880                 TIFFErrorExt(tif->tif_clientdata, module, "PixarLog compression can't handle %d bit linear encodings", td->td_bitspersample);
881                 return (0);
882         }
883
884         if (deflateInit(&sp->stream, sp->quality) != Z_OK) {
885                 TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg);
886                 return (0);
887         } else {
888                 sp->state |= PLSTATE_INIT;
889                 return (1);
890         }
891 }
892
893 /*
894  * Reset encoding state at the start of a strip.
895  */
896 static int
897 PixarLogPreEncode(TIFF* tif, uint16 s)
898 {
899         static const char module[] = "PixarLogPreEncode";
900         PixarLogState *sp = EncoderState(tif);
901
902         (void) s;
903         assert(sp != NULL);
904         sp->stream.next_out = tif->tif_rawdata;
905         assert(sizeof(sp->stream.avail_out)==4);  /* if this assert gets raised,
906             we need to simplify this code to reflect a ZLib that is likely updated
907             to deal with 8byte memory sizes, though this code will respond
908             apropriately even before we simplify it */
909         sp->stream.avail_out = (uInt)tif->tif_rawdatasize;
910         if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
911         {
912                 TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
913                 return (0);
914         }
915         return (deflateReset(&sp->stream) == Z_OK);
916 }
917
918 static void
919 horizontalDifferenceF(float *ip, int n, int stride, uint16 *wp, uint16 *FromLT2)
920 {
921     int32 r1, g1, b1, a1, r2, g2, b2, a2, mask;
922     float fltsize = Fltsize;
923
924 #define  CLAMP(v) ( (v<(float)0.)   ? 0                         \
925                   : (v<(float)2.)   ? FromLT2[(int)(v*fltsize)] \
926                   : (v>(float)24.2) ? 2047                      \
927                   : LogK1*log(v*LogK2) + 0.5 )
928
929     mask = CODE_MASK;
930     if (n >= stride) {
931         if (stride == 3) {
932             r2 = wp[0] = (uint16) CLAMP(ip[0]);
933             g2 = wp[1] = (uint16) CLAMP(ip[1]);
934             b2 = wp[2] = (uint16) CLAMP(ip[2]);
935             n -= 3;
936             while (n > 0) {
937                 n -= 3;
938                 wp += 3;
939                 ip += 3;
940                 r1 = (int32) CLAMP(ip[0]); wp[0] = (r1-r2) & mask; r2 = r1;
941                 g1 = (int32) CLAMP(ip[1]); wp[1] = (g1-g2) & mask; g2 = g1;
942                 b1 = (int32) CLAMP(ip[2]); wp[2] = (b1-b2) & mask; b2 = b1;
943             }
944         } else if (stride == 4) {
945             r2 = wp[0] = (uint16) CLAMP(ip[0]);
946             g2 = wp[1] = (uint16) CLAMP(ip[1]);
947             b2 = wp[2] = (uint16) CLAMP(ip[2]);
948             a2 = wp[3] = (uint16) CLAMP(ip[3]);
949             n -= 4;
950             while (n > 0) {
951                 n -= 4;
952                 wp += 4;
953                 ip += 4;
954                 r1 = (int32) CLAMP(ip[0]); wp[0] = (r1-r2) & mask; r2 = r1;
955                 g1 = (int32) CLAMP(ip[1]); wp[1] = (g1-g2) & mask; g2 = g1;
956                 b1 = (int32) CLAMP(ip[2]); wp[2] = (b1-b2) & mask; b2 = b1;
957                 a1 = (int32) CLAMP(ip[3]); wp[3] = (a1-a2) & mask; a2 = a1;
958             }
959         } else {
960             ip += n - 1;        /* point to last one */
961             wp += n - 1;        /* point to last one */
962             n -= stride;
963             while (n > 0) {
964                 REPEAT(stride, wp[0] = (uint16) CLAMP(ip[0]);
965                                 wp[stride] -= wp[0];
966                                 wp[stride] &= mask;
967                                 wp--; ip--)
968                 n -= stride;
969             }
970             REPEAT(stride, wp[0] = (uint16) CLAMP(ip[0]); wp--; ip--)
971         }
972     }
973 }
974
975 static void
976 horizontalDifference16(unsigned short *ip, int n, int stride, 
977         unsigned short *wp, uint16 *From14)
978 {
979     register int  r1, g1, b1, a1, r2, g2, b2, a2, mask;
980
981 /* assumption is unsigned pixel values */
982 #undef   CLAMP
983 #define  CLAMP(v) From14[(v) >> 2]
984
985     mask = CODE_MASK;
986     if (n >= stride) {
987         if (stride == 3) {
988             r2 = wp[0] = CLAMP(ip[0]);  g2 = wp[1] = CLAMP(ip[1]);
989             b2 = wp[2] = CLAMP(ip[2]);
990             n -= 3;
991             while (n > 0) {
992                 n -= 3;
993                 wp += 3;
994                 ip += 3;
995                 r1 = CLAMP(ip[0]); wp[0] = (r1-r2) & mask; r2 = r1;
996                 g1 = CLAMP(ip[1]); wp[1] = (g1-g2) & mask; g2 = g1;
997                 b1 = CLAMP(ip[2]); wp[2] = (b1-b2) & mask; b2 = b1;
998             }
999         } else if (stride == 4) {
1000             r2 = wp[0] = CLAMP(ip[0]);  g2 = wp[1] = CLAMP(ip[1]);
1001             b2 = wp[2] = CLAMP(ip[2]);  a2 = wp[3] = CLAMP(ip[3]);
1002             n -= 4;
1003             while (n > 0) {
1004                 n -= 4;
1005                 wp += 4;
1006                 ip += 4;
1007                 r1 = CLAMP(ip[0]); wp[0] = (r1-r2) & mask; r2 = r1;
1008                 g1 = CLAMP(ip[1]); wp[1] = (g1-g2) & mask; g2 = g1;
1009                 b1 = CLAMP(ip[2]); wp[2] = (b1-b2) & mask; b2 = b1;
1010                 a1 = CLAMP(ip[3]); wp[3] = (a1-a2) & mask; a2 = a1;
1011             }
1012         } else {
1013             ip += n - 1;        /* point to last one */
1014             wp += n - 1;        /* point to last one */
1015             n -= stride;
1016             while (n > 0) {
1017                 REPEAT(stride, wp[0] = CLAMP(ip[0]);
1018                                 wp[stride] -= wp[0];
1019                                 wp[stride] &= mask;
1020                                 wp--; ip--)
1021                 n -= stride;
1022             }
1023             REPEAT(stride, wp[0] = CLAMP(ip[0]); wp--; ip--)
1024         }
1025     }
1026 }
1027
1028
1029 static void
1030 horizontalDifference8(unsigned char *ip, int n, int stride, 
1031         unsigned short *wp, uint16 *From8)
1032 {
1033     register int  r1, g1, b1, a1, r2, g2, b2, a2, mask;
1034
1035 #undef   CLAMP
1036 #define  CLAMP(v) (From8[(v)])
1037
1038     mask = CODE_MASK;
1039     if (n >= stride) {
1040         if (stride == 3) {
1041             r2 = wp[0] = CLAMP(ip[0]);  g2 = wp[1] = CLAMP(ip[1]);
1042             b2 = wp[2] = CLAMP(ip[2]);
1043             n -= 3;
1044             while (n > 0) {
1045                 n -= 3;
1046                 r1 = CLAMP(ip[3]); wp[3] = (r1-r2) & mask; r2 = r1;
1047                 g1 = CLAMP(ip[4]); wp[4] = (g1-g2) & mask; g2 = g1;
1048                 b1 = CLAMP(ip[5]); wp[5] = (b1-b2) & mask; b2 = b1;
1049                 wp += 3;
1050                 ip += 3;
1051             }
1052         } else if (stride == 4) {
1053             r2 = wp[0] = CLAMP(ip[0]);  g2 = wp[1] = CLAMP(ip[1]);
1054             b2 = wp[2] = CLAMP(ip[2]);  a2 = wp[3] = CLAMP(ip[3]);
1055             n -= 4;
1056             while (n > 0) {
1057                 n -= 4;
1058                 r1 = CLAMP(ip[4]); wp[4] = (r1-r2) & mask; r2 = r1;
1059                 g1 = CLAMP(ip[5]); wp[5] = (g1-g2) & mask; g2 = g1;
1060                 b1 = CLAMP(ip[6]); wp[6] = (b1-b2) & mask; b2 = b1;
1061                 a1 = CLAMP(ip[7]); wp[7] = (a1-a2) & mask; a2 = a1;
1062                 wp += 4;
1063                 ip += 4;
1064             }
1065         } else {
1066             wp += n + stride - 1;       /* point to last one */
1067             ip += n + stride - 1;       /* point to last one */
1068             n -= stride;
1069             while (n > 0) {
1070                 REPEAT(stride, wp[0] = CLAMP(ip[0]);
1071                                 wp[stride] -= wp[0];
1072                                 wp[stride] &= mask;
1073                                 wp--; ip--)
1074                 n -= stride;
1075             }
1076             REPEAT(stride, wp[0] = CLAMP(ip[0]); wp--; ip--)
1077         }
1078     }
1079 }
1080
1081 /*
1082  * Encode a chunk of pixels.
1083  */
1084 static int
1085 PixarLogEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
1086 {
1087         static const char module[] = "PixarLogEncode";
1088         TIFFDirectory *td = &tif->tif_dir;
1089         PixarLogState *sp = EncoderState(tif);
1090         tmsize_t i;
1091         tmsize_t n;
1092         int llen;
1093         unsigned short * up;
1094
1095         (void) s;
1096
1097         switch (sp->user_datafmt) {
1098         case PIXARLOGDATAFMT_FLOAT:
1099                 n = cc / sizeof(float);         /* XXX float == 32 bits */
1100                 break;
1101         case PIXARLOGDATAFMT_16BIT:
1102         case PIXARLOGDATAFMT_12BITPICIO:
1103         case PIXARLOGDATAFMT_11BITLOG:
1104                 n = cc / sizeof(uint16);        /* XXX uint16 == 16 bits */
1105                 break;
1106         case PIXARLOGDATAFMT_8BIT:
1107         case PIXARLOGDATAFMT_8BITABGR:
1108                 n = cc;
1109                 break;
1110         default:
1111                 TIFFErrorExt(tif->tif_clientdata, module,
1112                         "%d bit input not supported in PixarLog",
1113                         td->td_bitspersample);
1114                 return 0;
1115         }
1116
1117         llen = sp->stride * td->td_imagewidth;
1118
1119         for (i = 0, up = sp->tbuf; i < n; i += llen, up += llen) {
1120                 switch (sp->user_datafmt)  {
1121                 case PIXARLOGDATAFMT_FLOAT:
1122                         horizontalDifferenceF((float *)bp, llen, 
1123                                 sp->stride, up, sp->FromLT2);
1124                         bp += llen * sizeof(float);
1125                         break;
1126                 case PIXARLOGDATAFMT_16BIT:
1127                         horizontalDifference16((uint16 *)bp, llen, 
1128                                 sp->stride, up, sp->From14);
1129                         bp += llen * sizeof(uint16);
1130                         break;
1131                 case PIXARLOGDATAFMT_8BIT:
1132                         horizontalDifference8((unsigned char *)bp, llen, 
1133                                 sp->stride, up, sp->From8);
1134                         bp += llen * sizeof(unsigned char);
1135                         break;
1136                 default:
1137                         TIFFErrorExt(tif->tif_clientdata, module,
1138                                 "%d bit input not supported in PixarLog",
1139                                 td->td_bitspersample);
1140                         return 0;
1141                 }
1142         }
1143  
1144         sp->stream.next_in = (unsigned char *) sp->tbuf;
1145         assert(sizeof(sp->stream.avail_in)==4);  /* if this assert gets raised,
1146             we need to simplify this code to reflect a ZLib that is likely updated
1147             to deal with 8byte memory sizes, though this code will respond
1148             apropriately even before we simplify it */
1149         sp->stream.avail_in = (uInt) (n * sizeof(uint16));
1150         if ((sp->stream.avail_in / sizeof(uint16)) != (uInt) n)
1151         {
1152                 TIFFErrorExt(tif->tif_clientdata, module,
1153                              "ZLib cannot deal with buffers this size");
1154                 return (0);
1155         }
1156
1157         do {
1158                 if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) {
1159                         TIFFErrorExt(tif->tif_clientdata, module, "Encoder error: %s",
1160                             sp->stream.msg);
1161                         return (0);
1162                 }
1163                 if (sp->stream.avail_out == 0) {
1164                         tif->tif_rawcc = tif->tif_rawdatasize;
1165                         TIFFFlushData1(tif);
1166                         sp->stream.next_out = tif->tif_rawdata;
1167                         sp->stream.avail_out = (uInt) tif->tif_rawdatasize;  /* this is a safe typecast, as check is made already in PixarLogPreEncode */
1168                 }
1169         } while (sp->stream.avail_in > 0);
1170         return (1);
1171 }
1172
1173 /*
1174  * Finish off an encoded strip by flushing the last
1175  * string and tacking on an End Of Information code.
1176  */
1177
1178 static int
1179 PixarLogPostEncode(TIFF* tif)
1180 {
1181         static const char module[] = "PixarLogPostEncode";
1182         PixarLogState *sp = EncoderState(tif);
1183         int state;
1184
1185         sp->stream.avail_in = 0;
1186
1187         do {
1188                 state = deflate(&sp->stream, Z_FINISH);
1189                 switch (state) {
1190                 case Z_STREAM_END:
1191                 case Z_OK:
1192                     if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) {
1193                             tif->tif_rawcc =
1194                                 tif->tif_rawdatasize - sp->stream.avail_out;
1195                             TIFFFlushData1(tif);
1196                             sp->stream.next_out = tif->tif_rawdata;
1197                             sp->stream.avail_out = (uInt) tif->tif_rawdatasize;  /* this is a safe typecast, as check is made already in PixarLogPreEncode */
1198                     }
1199                     break;
1200                 default:
1201                         TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
1202                         sp->stream.msg);
1203                     return (0);
1204                 }
1205         } while (state != Z_STREAM_END);
1206         return (1);
1207 }
1208
1209 static void
1210 PixarLogClose(TIFF* tif)
1211 {
1212         TIFFDirectory *td = &tif->tif_dir;
1213
1214         /* In a really sneaky (and really incorrect, and untruthfull, and
1215          * troublesome, and error-prone) maneuver that completely goes against
1216          * the spirit of TIFF, and breaks TIFF, on close, we covertly
1217          * modify both bitspersample and sampleformat in the directory to
1218          * indicate 8-bit linear.  This way, the decode "just works" even for
1219          * readers that don't know about PixarLog, or how to set
1220          * the PIXARLOGDATFMT pseudo-tag.
1221          */
1222         td->td_bitspersample = 8;
1223         td->td_sampleformat = SAMPLEFORMAT_UINT;
1224 }
1225
1226 static void
1227 PixarLogCleanup(TIFF* tif)
1228 {
1229         PixarLogState* sp = (PixarLogState*) tif->tif_data;
1230
1231         assert(sp != 0);
1232
1233         (void)TIFFPredictorCleanup(tif);
1234
1235         tif->tif_tagmethods.vgetfield = sp->vgetparent;
1236         tif->tif_tagmethods.vsetfield = sp->vsetparent;
1237
1238         if (sp->FromLT2) _TIFFfree(sp->FromLT2);
1239         if (sp->From14) _TIFFfree(sp->From14);
1240         if (sp->From8) _TIFFfree(sp->From8);
1241         if (sp->ToLinearF) _TIFFfree(sp->ToLinearF);
1242         if (sp->ToLinear16) _TIFFfree(sp->ToLinear16);
1243         if (sp->ToLinear8) _TIFFfree(sp->ToLinear8);
1244         if (sp->state&PLSTATE_INIT) {
1245                 if (tif->tif_mode == O_RDONLY)
1246                         inflateEnd(&sp->stream);
1247                 else
1248                         deflateEnd(&sp->stream);
1249         }
1250         if (sp->tbuf)
1251                 _TIFFfree(sp->tbuf);
1252         _TIFFfree(sp);
1253         tif->tif_data = NULL;
1254
1255         _TIFFSetDefaultCompressionState(tif);
1256 }
1257
1258 static int
1259 PixarLogVSetField(TIFF* tif, uint32 tag, va_list ap)
1260 {
1261     static const char module[] = "PixarLogVSetField";
1262     PixarLogState *sp = (PixarLogState *)tif->tif_data;
1263     int result;
1264
1265     switch (tag) {
1266      case TIFFTAG_PIXARLOGQUALITY:
1267                 sp->quality = (int) va_arg(ap, int);
1268                 if (tif->tif_mode != O_RDONLY && (sp->state&PLSTATE_INIT)) {
1269                         if (deflateParams(&sp->stream,
1270                             sp->quality, Z_DEFAULT_STRATEGY) != Z_OK) {
1271                                 TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
1272                                         sp->stream.msg);
1273                                 return (0);
1274                         }
1275                 }
1276                 return (1);
1277      case TIFFTAG_PIXARLOGDATAFMT:
1278         sp->user_datafmt = (int) va_arg(ap, int);
1279         /* Tweak the TIFF header so that the rest of libtiff knows what
1280          * size of data will be passed between app and library, and
1281          * assume that the app knows what it is doing and is not
1282          * confused by these header manipulations...
1283          */
1284         switch (sp->user_datafmt) {
1285          case PIXARLOGDATAFMT_8BIT:
1286          case PIXARLOGDATAFMT_8BITABGR:
1287             TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
1288             TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1289             break;
1290          case PIXARLOGDATAFMT_11BITLOG:
1291             TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16);
1292             TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1293             break;
1294          case PIXARLOGDATAFMT_12BITPICIO:
1295             TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16);
1296             TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
1297             break;
1298          case PIXARLOGDATAFMT_16BIT:
1299             TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16);
1300             TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
1301             break;
1302          case PIXARLOGDATAFMT_FLOAT:
1303             TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 32);
1304             TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
1305             break;
1306         }
1307         /*
1308          * Must recalculate sizes should bits/sample change.
1309          */
1310         tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1);
1311         tif->tif_scanlinesize = TIFFScanlineSize(tif);
1312         result = 1;             /* NB: pseudo tag */
1313         break;
1314      default:
1315         result = (*sp->vsetparent)(tif, tag, ap);
1316     }
1317     return (result);
1318 }
1319
1320 static int
1321 PixarLogVGetField(TIFF* tif, uint32 tag, va_list ap)
1322 {
1323     PixarLogState *sp = (PixarLogState *)tif->tif_data;
1324
1325     switch (tag) {
1326      case TIFFTAG_PIXARLOGQUALITY:
1327         *va_arg(ap, int*) = sp->quality;
1328         break;
1329      case TIFFTAG_PIXARLOGDATAFMT:
1330         *va_arg(ap, int*) = sp->user_datafmt;
1331         break;
1332      default:
1333         return (*sp->vgetparent)(tif, tag, ap);
1334     }
1335     return (1);
1336 }
1337
1338 static const TIFFField pixarlogFields[] = {
1339     {TIFFTAG_PIXARLOGDATAFMT, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL},
1340     {TIFFTAG_PIXARLOGQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL}
1341 };
1342
1343 int
1344 TIFFInitPixarLog(TIFF* tif, int scheme)
1345 {
1346         static const char module[] = "TIFFInitPixarLog";
1347
1348         PixarLogState* sp;
1349
1350         assert(scheme == COMPRESSION_PIXARLOG);
1351
1352         /*
1353          * Merge codec-specific tag information.
1354          */
1355         if (!_TIFFMergeFields(tif, pixarlogFields,
1356                               TIFFArrayCount(pixarlogFields))) {
1357                 TIFFErrorExt(tif->tif_clientdata, module,
1358                              "Merging PixarLog codec-specific tags failed");
1359                 return 0;
1360         }
1361
1362         /*
1363          * Allocate state block so tag methods have storage to record values.
1364          */
1365         tif->tif_data = (uint8*) _TIFFmalloc(sizeof (PixarLogState));
1366         if (tif->tif_data == NULL)
1367                 goto bad;
1368         sp = (PixarLogState*) tif->tif_data;
1369         _TIFFmemset(sp, 0, sizeof (*sp));
1370         sp->stream.data_type = Z_BINARY;
1371         sp->user_datafmt = PIXARLOGDATAFMT_UNKNOWN;
1372
1373         /*
1374          * Install codec methods.
1375          */
1376         tif->tif_fixuptags = PixarLogFixupTags; 
1377         tif->tif_setupdecode = PixarLogSetupDecode;
1378         tif->tif_predecode = PixarLogPreDecode;
1379         tif->tif_decoderow = PixarLogDecode;
1380         tif->tif_decodestrip = PixarLogDecode;  
1381         tif->tif_decodetile = PixarLogDecode;
1382         tif->tif_setupencode = PixarLogSetupEncode;
1383         tif->tif_preencode = PixarLogPreEncode;
1384         tif->tif_postencode = PixarLogPostEncode;
1385         tif->tif_encoderow = PixarLogEncode;  
1386         tif->tif_encodestrip = PixarLogEncode;
1387         tif->tif_encodetile = PixarLogEncode;  
1388         tif->tif_close = PixarLogClose;
1389         tif->tif_cleanup = PixarLogCleanup;
1390
1391         /* Override SetField so we can handle our private pseudo-tag */
1392         sp->vgetparent = tif->tif_tagmethods.vgetfield;
1393         tif->tif_tagmethods.vgetfield = PixarLogVGetField;   /* hook for codec tags */
1394         sp->vsetparent = tif->tif_tagmethods.vsetfield;
1395         tif->tif_tagmethods.vsetfield = PixarLogVSetField;   /* hook for codec tags */
1396
1397         /* Default values for codec-specific fields */
1398         sp->quality = Z_DEFAULT_COMPRESSION; /* default comp. level */
1399         sp->state = 0;
1400
1401         /* we don't wish to use the predictor, 
1402          * the default is none, which predictor value 1
1403          */
1404         (void) TIFFPredictorInit(tif);
1405
1406         /*
1407          * build the companding tables 
1408          */
1409         PixarLogMakeTables(sp);
1410
1411         return (1);
1412 bad:
1413         TIFFErrorExt(tif->tif_clientdata, module,
1414                      "No space for PixarLog state block");
1415         return (0);
1416 }
1417 #endif /* PIXARLOG_SUPPORT */
1418
1419 /* vim: set ts=8 sts=8 sw=8 noet: */
1420 /*
1421  * Local Variables:
1422  * mode: c
1423  * c-basic-offset: 8
1424  * fill-column: 78
1425  * End:
1426  */
1427 #endif
1428