path: root/tif_pixarlog.c (plain)
blob: e58311704865b0e463cdac9ea7266c4b420a3b52

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
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 "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 = 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