ReactOS 0.4.15-dev-8339-g4028de8
tif_luv.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 1997 Greg Ward Larson
3 * Copyright (c) 1997 Silicon Graphics, Inc.
4 *
5 * Permission to use, copy, modify, distribute, and sell this software and
6 * its documentation for any purpose is hereby granted without fee, provided
7 * that (i) the above copyright notices and this permission notice appear in
8 * all copies of the software and related documentation, and (ii) the names of
9 * Sam Leffler, Greg Larson and Silicon Graphics may not be used in any
10 * advertising or publicity relating to the software without the specific,
11 * prior written permission of Sam Leffler, Greg Larson and Silicon Graphics.
12 *
13 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
14 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
15 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
16 *
17 * IN NO EVENT SHALL SAM LEFFLER, GREG LARSON OR SILICON GRAPHICS BE LIABLE
18 * FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
19 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
21 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22 * OF THIS SOFTWARE.
23 */
24
25#include <precomp.h>
26#ifdef LOGLUV_SUPPORT
27
28/*
29 * TIFF Library.
30 * LogLuv compression support for high dynamic range images.
31 *
32 * Contributed by Greg Larson.
33 *
34 * LogLuv image support uses the TIFF library to store 16 or 10-bit
35 * log luminance values with 8 bits each of u and v or a 14-bit index.
36 *
37 * The codec can take as input and produce as output 32-bit IEEE float values
38 * as well as 16-bit integer values. A 16-bit luminance is interpreted
39 * as a sign bit followed by a 15-bit integer that is converted
40 * to and from a linear magnitude using the transformation:
41 *
42 * L = 2^( (Le+.5)/256 - 64 ) # real from 15-bit
43 *
44 * Le = floor( 256*(log2(L) + 64) ) # 15-bit from real
45 *
46 * The actual conversion to world luminance units in candelas per sq. meter
47 * requires an additional multiplier, which is stored in the TIFFTAG_STONITS.
48 * This value is usually set such that a reasonable exposure comes from
49 * clamping decoded luminances above 1 to 1 in the displayed image.
50 *
51 * The 16-bit values for u and v may be converted to real values by dividing
52 * each by 32768. (This allows for negative values, which aren't useful as
53 * far as we know, but are left in case of future improvements in human
54 * color vision.)
55 *
56 * Conversion from (u,v), which is actually the CIE (u',v') system for
57 * you color scientists, is accomplished by the following transformation:
58 *
59 * u = 4*x / (-2*x + 12*y + 3)
60 * v = 9*y / (-2*x + 12*y + 3)
61 *
62 * x = 9*u / (6*u - 16*v + 12)
63 * y = 4*v / (6*u - 16*v + 12)
64 *
65 * This process is greatly simplified by passing 32-bit IEEE floats
66 * for each of three CIE XYZ coordinates. The codec then takes care
67 * of conversion to and from LogLuv, though the application is still
68 * responsible for interpreting the TIFFTAG_STONITS calibration factor.
69 *
70 * By definition, a CIE XYZ vector of [1 1 1] corresponds to a neutral white
71 * point of (x,y)=(1/3,1/3). However, most color systems assume some other
72 * white point, such as D65, and an absolute color conversion to XYZ then
73 * to another color space with a different white point may introduce an
74 * unwanted color cast to the image. It is often desirable, therefore, to
75 * perform a white point conversion that maps the input white to [1 1 1]
76 * in XYZ, then record the original white point using the TIFFTAG_WHITEPOINT
77 * tag value. A decoder that demands absolute color calibration may use
78 * this white point tag to get back the original colors, but usually it
79 * will be ignored and the new white point will be used instead that
80 * matches the output color space.
81 *
82 * Pixel information is compressed into one of two basic encodings, depending
83 * on the setting of the compression tag, which is one of COMPRESSION_SGILOG
84 * or COMPRESSION_SGILOG24. For COMPRESSION_SGILOG, greyscale data is
85 * stored as:
86 *
87 * 1 15
88 * |-+---------------|
89 *
90 * COMPRESSION_SGILOG color data is stored as:
91 *
92 * 1 15 8 8
93 * |-+---------------|--------+--------|
94 * S Le ue ve
95 *
96 * For the 24-bit COMPRESSION_SGILOG24 color format, the data is stored as:
97 *
98 * 10 14
99 * |----------|--------------|
100 * Le' Ce
101 *
102 * There is no sign bit in the 24-bit case, and the (u,v) chromaticity is
103 * encoded as an index for optimal color resolution. The 10 log bits are
104 * defined by the following conversions:
105 *
106 * L = 2^((Le'+.5)/64 - 12) # real from 10-bit
107 *
108 * Le' = floor( 64*(log2(L) + 12) ) # 10-bit from real
109 *
110 * The 10 bits of the smaller format may be converted into the 15 bits of
111 * the larger format by multiplying by 4 and adding 13314. Obviously,
112 * a smaller range of magnitudes is covered (about 5 orders of magnitude
113 * instead of 38), and the lack of a sign bit means that negative luminances
114 * are not allowed. (Well, they aren't allowed in the real world, either,
115 * but they are useful for certain types of image processing.)
116 *
117 * The desired user format is controlled by the setting the internal
118 * pseudo tag TIFFTAG_SGILOGDATAFMT to one of:
119 * SGILOGDATAFMT_FLOAT = IEEE 32-bit float XYZ values
120 * SGILOGDATAFMT_16BIT = 16-bit integer encodings of logL, u and v
121 * Raw data i/o is also possible using:
122 * SGILOGDATAFMT_RAW = 32-bit unsigned integer with encoded pixel
123 * In addition, the following decoding is provided for ease of display:
124 * SGILOGDATAFMT_8BIT = 8-bit default RGB gamma-corrected values
125 *
126 * For grayscale images, we provide the following data formats:
127 * SGILOGDATAFMT_FLOAT = IEEE 32-bit float Y values
128 * SGILOGDATAFMT_16BIT = 16-bit integer w/ encoded luminance
129 * SGILOGDATAFMT_8BIT = 8-bit gray monitor values
130 *
131 * Note that the COMPRESSION_SGILOG applies a simple run-length encoding
132 * scheme by separating the logL, u and v bytes for each row and applying
133 * a PackBits type of compression. Since the 24-bit encoding is not
134 * adaptive, the 32-bit color format takes less space in many cases.
135 *
136 * Further control is provided over the conversion from higher-resolution
137 * formats to final encoded values through the pseudo tag
138 * TIFFTAG_SGILOGENCODE:
139 * SGILOGENCODE_NODITHER = do not dither encoded values
140 * SGILOGENCODE_RANDITHER = apply random dithering during encoding
141 *
142 * The default value of this tag is SGILOGENCODE_NODITHER for
143 * COMPRESSION_SGILOG to maximize run-length encoding and
144 * SGILOGENCODE_RANDITHER for COMPRESSION_SGILOG24 to turn
145 * quantization errors into noise.
146 */
147
148#include <stdio.h>
149#include <stdlib.h>
150#include <math.h>
151
152/*
153 * State block for each open TIFF
154 * file using LogLuv compression/decompression.
155 */
156typedef struct logLuvState LogLuvState;
157
158struct logLuvState {
159 int encoder_state; /* 1 if encoder correctly initialized */
160 int user_datafmt; /* user data format */
161 int encode_meth; /* encoding method */
162 int pixel_size; /* bytes per pixel */
163
164 uint8* tbuf; /* translation buffer */
165 tmsize_t tbuflen; /* buffer length */
166 void (*tfunc)(LogLuvState*, uint8*, tmsize_t);
167
168 TIFFVSetMethod vgetparent; /* super-class method */
169 TIFFVSetMethod vsetparent; /* super-class method */
170};
171
172#define DecoderState(tif) ((LogLuvState*) (tif)->tif_data)
173#define EncoderState(tif) ((LogLuvState*) (tif)->tif_data)
174
175#define SGILOGDATAFMT_UNKNOWN -1
176
177#define MINRUN 4 /* minimum run length */
178
179/*
180 * Decode a string of 16-bit gray pixels.
181 */
182static int
183LogL16Decode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
184{
185 static const char module[] = "LogL16Decode";
186 LogLuvState* sp = DecoderState(tif);
187 int shft;
188 tmsize_t i;
189 tmsize_t npixels;
190 unsigned char* bp;
191 int16* tp;
192 int16 b;
193 tmsize_t cc;
194 int rc;
195
196 assert(s == 0);
197 assert(sp != NULL);
198
199 npixels = occ / sp->pixel_size;
200
201 if (sp->user_datafmt == SGILOGDATAFMT_16BIT)
202 tp = (int16*) op;
203 else {
204 if(sp->tbuflen < npixels) {
206 "Translation buffer too short");
207 return (0);
208 }
209 tp = (int16*) sp->tbuf;
210 }
211 _TIFFmemset((void*) tp, 0, npixels*sizeof (tp[0]));
212
213 bp = (unsigned char*) tif->tif_rawcp;
214 cc = tif->tif_rawcc;
215 /* get each byte string */
216 for (shft = 8; shft >= 0; shft -=8) {
217 for (i = 0; i < npixels && cc > 0; ) {
218 if (*bp >= 128) { /* run */
219 if( cc < 2 )
220 break;
221 rc = *bp++ + (2-128);
222 b = (int16)(*bp++ << shft);
223 cc -= 2;
224 while (rc-- && i < npixels)
225 tp[i++] |= b;
226 } else { /* non-run */
227 rc = *bp++; /* nul is noop */
228 while (--cc && rc-- && i < npixels)
229 tp[i++] |= (int16)*bp++ << shft;
230 }
231 }
232 if (i != npixels) {
233#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
235 "Not enough data at row %lu (short %I64d pixels)",
236 (unsigned long) tif->tif_row,
237 (unsigned __int64) (npixels - i));
238#else
240 "Not enough data at row %lu (short %llu pixels)",
241 (unsigned long) tif->tif_row,
242 (unsigned long long) (npixels - i));
243#endif
244 tif->tif_rawcp = (uint8*) bp;
245 tif->tif_rawcc = cc;
246 return (0);
247 }
248 }
249 (*sp->tfunc)(sp, op, npixels);
250 tif->tif_rawcp = (uint8*) bp;
251 tif->tif_rawcc = cc;
252 return (1);
253}
254
255/*
256 * Decode a string of 24-bit pixels.
257 */
258static int
259LogLuvDecode24(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
260{
261 static const char module[] = "LogLuvDecode24";
262 LogLuvState* sp = DecoderState(tif);
263 tmsize_t cc;
264 tmsize_t i;
265 tmsize_t npixels;
266 unsigned char* bp;
267 uint32* tp;
268
269 assert(s == 0);
270 assert(sp != NULL);
271
272 npixels = occ / sp->pixel_size;
273
274 if (sp->user_datafmt == SGILOGDATAFMT_RAW)
275 tp = (uint32 *)op;
276 else {
277 if(sp->tbuflen < npixels) {
279 "Translation buffer too short");
280 return (0);
281 }
282 tp = (uint32 *) sp->tbuf;
283 }
284 /* copy to array of uint32 */
285 bp = (unsigned char*) tif->tif_rawcp;
286 cc = tif->tif_rawcc;
287 for (i = 0; i < npixels && cc >= 3; i++) {
288 tp[i] = bp[0] << 16 | bp[1] << 8 | bp[2];
289 bp += 3;
290 cc -= 3;
291 }
292 tif->tif_rawcp = (uint8*) bp;
293 tif->tif_rawcc = cc;
294 if (i != npixels) {
295#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
297 "Not enough data at row %lu (short %I64d pixels)",
298 (unsigned long) tif->tif_row,
299 (unsigned __int64) (npixels - i));
300#else
302 "Not enough data at row %lu (short %llu pixels)",
303 (unsigned long) tif->tif_row,
304 (unsigned long long) (npixels - i));
305#endif
306 return (0);
307 }
308 (*sp->tfunc)(sp, op, npixels);
309 return (1);
310}
311
312/*
313 * Decode a string of 32-bit pixels.
314 */
315static int
316LogLuvDecode32(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
317{
318 static const char module[] = "LogLuvDecode32";
319 LogLuvState* sp;
320 int shft;
321 tmsize_t i;
322 tmsize_t npixels;
323 unsigned char* bp;
324 uint32* tp;
325 uint32 b;
326 tmsize_t cc;
327 int rc;
328
329 assert(s == 0);
330 sp = DecoderState(tif);
331 assert(sp != NULL);
332
333 npixels = occ / sp->pixel_size;
334
335 if (sp->user_datafmt == SGILOGDATAFMT_RAW)
336 tp = (uint32*) op;
337 else {
338 if(sp->tbuflen < npixels) {
340 "Translation buffer too short");
341 return (0);
342 }
343 tp = (uint32*) sp->tbuf;
344 }
345 _TIFFmemset((void*) tp, 0, npixels*sizeof (tp[0]));
346
347 bp = (unsigned char*) tif->tif_rawcp;
348 cc = tif->tif_rawcc;
349 /* get each byte string */
350 for (shft = 24; shft >= 0; shft -=8) {
351 for (i = 0; i < npixels && cc > 0; ) {
352 if (*bp >= 128) { /* run */
353 if( cc < 2 )
354 break;
355 rc = *bp++ + (2-128);
356 b = (uint32)*bp++ << shft;
357 cc -= 2;
358 while (rc-- && i < npixels)
359 tp[i++] |= b;
360 } else { /* non-run */
361 rc = *bp++; /* nul is noop */
362 while (--cc && rc-- && i < npixels)
363 tp[i++] |= (uint32)*bp++ << shft;
364 }
365 }
366 if (i != npixels) {
367#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
369 "Not enough data at row %lu (short %I64d pixels)",
370 (unsigned long) tif->tif_row,
371 (unsigned __int64) (npixels - i));
372#else
374 "Not enough data at row %lu (short %llu pixels)",
375 (unsigned long) tif->tif_row,
376 (unsigned long long) (npixels - i));
377#endif
378 tif->tif_rawcp = (uint8*) bp;
379 tif->tif_rawcc = cc;
380 return (0);
381 }
382 }
383 (*sp->tfunc)(sp, op, npixels);
384 tif->tif_rawcp = (uint8*) bp;
385 tif->tif_rawcc = cc;
386 return (1);
387}
388
389/*
390 * Decode a strip of pixels. We break it into rows to
391 * maintain synchrony with the encode algorithm, which
392 * is row by row.
393 */
394static int
395LogLuvDecodeStrip(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
396{
397 tmsize_t rowlen = TIFFScanlineSize(tif);
398
399 if (rowlen == 0)
400 return 0;
401
402 assert(cc%rowlen == 0);
403 while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s)) {
404 bp += rowlen;
405 cc -= rowlen;
406 }
407 return (cc == 0);
408}
409
410/*
411 * Decode a tile of pixels. We break it into rows to
412 * maintain synchrony with the encode algorithm, which
413 * is row by row.
414 */
415static int
416LogLuvDecodeTile(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
417{
418 tmsize_t rowlen = TIFFTileRowSize(tif);
419
420 if (rowlen == 0)
421 return 0;
422
423 assert(cc%rowlen == 0);
424 while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s)) {
425 bp += rowlen;
426 cc -= rowlen;
427 }
428 return (cc == 0);
429}
430
431/*
432 * Encode a row of 16-bit pixels.
433 */
434static int
435LogL16Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
436{
437 static const char module[] = "LogL16Encode";
438 LogLuvState* sp = EncoderState(tif);
439 int shft;
440 tmsize_t i;
441 tmsize_t j;
442 tmsize_t npixels;
443 uint8* op;
444 int16* tp;
445 int16 b;
446 tmsize_t occ;
447 int rc=0, mask;
448 tmsize_t beg;
449
450 assert(s == 0);
451 assert(sp != NULL);
452 npixels = cc / sp->pixel_size;
453
454 if (sp->user_datafmt == SGILOGDATAFMT_16BIT)
455 tp = (int16*) bp;
456 else {
457 tp = (int16*) sp->tbuf;
458 if(sp->tbuflen < npixels) {
460 "Translation buffer too short");
461 return (0);
462 }
463 (*sp->tfunc)(sp, bp, npixels);
464 }
465 /* compress each byte string */
466 op = tif->tif_rawcp;
467 occ = tif->tif_rawdatasize - tif->tif_rawcc;
468 for (shft = 8; shft >= 0; shft -=8) {
469 for (i = 0; i < npixels; i += rc) {
470 if (occ < 4) {
471 tif->tif_rawcp = op;
472 tif->tif_rawcc = tif->tif_rawdatasize - occ;
473 if (!TIFFFlushData1(tif))
474 return (0);
475 op = tif->tif_rawcp;
476 occ = tif->tif_rawdatasize - tif->tif_rawcc;
477 }
478 mask = 0xff << shft; /* find next run */
479 for (beg = i; beg < npixels; beg += rc) {
480 b = (int16) (tp[beg] & mask);
481 rc = 1;
482 while (rc < 127+2 && beg+rc < npixels &&
483 (tp[beg+rc] & mask) == b)
484 rc++;
485 if (rc >= MINRUN)
486 break; /* long enough */
487 }
488 if (beg-i > 1 && beg-i < MINRUN) {
489 b = (int16) (tp[i] & mask);/*check short run */
490 j = i+1;
491 while ((tp[j++] & mask) == b)
492 if (j == beg) {
493 *op++ = (uint8)(128-2+j-i);
494 *op++ = (uint8)(b >> shft);
495 occ -= 2;
496 i = beg;
497 break;
498 }
499 }
500 while (i < beg) { /* write out non-run */
501 if ((j = beg-i) > 127) j = 127;
502 if (occ < j+3) {
503 tif->tif_rawcp = op;
504 tif->tif_rawcc = tif->tif_rawdatasize - occ;
505 if (!TIFFFlushData1(tif))
506 return (0);
507 op = tif->tif_rawcp;
508 occ = tif->tif_rawdatasize - tif->tif_rawcc;
509 }
510 *op++ = (uint8) j; occ--;
511 while (j--) {
512 *op++ = (uint8) (tp[i++] >> shft & 0xff);
513 occ--;
514 }
515 }
516 if (rc >= MINRUN) { /* write out run */
517 *op++ = (uint8) (128-2+rc);
518 *op++ = (uint8) (tp[beg] >> shft & 0xff);
519 occ -= 2;
520 } else
521 rc = 0;
522 }
523 }
524 tif->tif_rawcp = op;
525 tif->tif_rawcc = tif->tif_rawdatasize - occ;
526
527 return (1);
528}
529
530/*
531 * Encode a row of 24-bit pixels.
532 */
533static int
534LogLuvEncode24(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
535{
536 static const char module[] = "LogLuvEncode24";
537 LogLuvState* sp = EncoderState(tif);
538 tmsize_t i;
539 tmsize_t npixels;
540 tmsize_t occ;
541 uint8* op;
542 uint32* tp;
543
544 assert(s == 0);
545 assert(sp != NULL);
546 npixels = cc / sp->pixel_size;
547
548 if (sp->user_datafmt == SGILOGDATAFMT_RAW)
549 tp = (uint32*) bp;
550 else {
551 tp = (uint32*) sp->tbuf;
552 if(sp->tbuflen < npixels) {
554 "Translation buffer too short");
555 return (0);
556 }
557 (*sp->tfunc)(sp, bp, npixels);
558 }
559 /* write out encoded pixels */
560 op = tif->tif_rawcp;
561 occ = tif->tif_rawdatasize - tif->tif_rawcc;
562 for (i = npixels; i--; ) {
563 if (occ < 3) {
564 tif->tif_rawcp = op;
565 tif->tif_rawcc = tif->tif_rawdatasize - occ;
566 if (!TIFFFlushData1(tif))
567 return (0);
568 op = tif->tif_rawcp;
569 occ = tif->tif_rawdatasize - tif->tif_rawcc;
570 }
571 *op++ = (uint8)(*tp >> 16);
572 *op++ = (uint8)(*tp >> 8 & 0xff);
573 *op++ = (uint8)(*tp++ & 0xff);
574 occ -= 3;
575 }
576 tif->tif_rawcp = op;
577 tif->tif_rawcc = tif->tif_rawdatasize - occ;
578
579 return (1);
580}
581
582/*
583 * Encode a row of 32-bit pixels.
584 */
585static int
586LogLuvEncode32(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
587{
588 static const char module[] = "LogLuvEncode32";
589 LogLuvState* sp = EncoderState(tif);
590 int shft;
591 tmsize_t i;
592 tmsize_t j;
593 tmsize_t npixels;
594 uint8* op;
595 uint32* tp;
596 uint32 b;
597 tmsize_t occ;
598 int rc=0, mask;
599 tmsize_t beg;
600
601 assert(s == 0);
602 assert(sp != NULL);
603
604 npixels = cc / sp->pixel_size;
605
606 if (sp->user_datafmt == SGILOGDATAFMT_RAW)
607 tp = (uint32*) bp;
608 else {
609 tp = (uint32*) sp->tbuf;
610 if(sp->tbuflen < npixels) {
612 "Translation buffer too short");
613 return (0);
614 }
615 (*sp->tfunc)(sp, bp, npixels);
616 }
617 /* compress each byte string */
618 op = tif->tif_rawcp;
619 occ = tif->tif_rawdatasize - tif->tif_rawcc;
620 for (shft = 24; shft >= 0; shft -=8) {
621 for (i = 0; i < npixels; i += rc) {
622 if (occ < 4) {
623 tif->tif_rawcp = op;
624 tif->tif_rawcc = tif->tif_rawdatasize - occ;
625 if (!TIFFFlushData1(tif))
626 return (0);
627 op = tif->tif_rawcp;
628 occ = tif->tif_rawdatasize - tif->tif_rawcc;
629 }
630 mask = 0xff << shft; /* find next run */
631 for (beg = i; beg < npixels; beg += rc) {
632 b = tp[beg] & mask;
633 rc = 1;
634 while (rc < 127+2 && beg+rc < npixels &&
635 (tp[beg+rc] & mask) == b)
636 rc++;
637 if (rc >= MINRUN)
638 break; /* long enough */
639 }
640 if (beg-i > 1 && beg-i < MINRUN) {
641 b = tp[i] & mask; /* check short run */
642 j = i+1;
643 while ((tp[j++] & mask) == b)
644 if (j == beg) {
645 *op++ = (uint8)(128-2+j-i);
646 *op++ = (uint8)(b >> shft);
647 occ -= 2;
648 i = beg;
649 break;
650 }
651 }
652 while (i < beg) { /* write out non-run */
653 if ((j = beg-i) > 127) j = 127;
654 if (occ < j+3) {
655 tif->tif_rawcp = op;
656 tif->tif_rawcc = tif->tif_rawdatasize - occ;
657 if (!TIFFFlushData1(tif))
658 return (0);
659 op = tif->tif_rawcp;
660 occ = tif->tif_rawdatasize - tif->tif_rawcc;
661 }
662 *op++ = (uint8) j; occ--;
663 while (j--) {
664 *op++ = (uint8)(tp[i++] >> shft & 0xff);
665 occ--;
666 }
667 }
668 if (rc >= MINRUN) { /* write out run */
669 *op++ = (uint8) (128-2+rc);
670 *op++ = (uint8)(tp[beg] >> shft & 0xff);
671 occ -= 2;
672 } else
673 rc = 0;
674 }
675 }
676 tif->tif_rawcp = op;
677 tif->tif_rawcc = tif->tif_rawdatasize - occ;
678
679 return (1);
680}
681
682/*
683 * Encode a strip of pixels. We break it into rows to
684 * avoid encoding runs across row boundaries.
685 */
686static int
687LogLuvEncodeStrip(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
688{
689 tmsize_t rowlen = TIFFScanlineSize(tif);
690
691 if (rowlen == 0)
692 return 0;
693
694 assert(cc%rowlen == 0);
695 while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1) {
696 bp += rowlen;
697 cc -= rowlen;
698 }
699 return (cc == 0);
700}
701
702/*
703 * Encode a tile of pixels. We break it into rows to
704 * avoid encoding runs across row boundaries.
705 */
706static int
707LogLuvEncodeTile(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
708{
709 tmsize_t rowlen = TIFFTileRowSize(tif);
710
711 if (rowlen == 0)
712 return 0;
713
714 assert(cc%rowlen == 0);
715 while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1) {
716 bp += rowlen;
717 cc -= rowlen;
718 }
719 return (cc == 0);
720}
721
722/*
723 * Encode/Decode functions for converting to and from user formats.
724 */
725
726#include "uvcode.h"
727
728#ifndef UVSCALE
729#define U_NEU 0.210526316
730#define V_NEU 0.473684211
731#define UVSCALE 410.
732#endif
733
734#ifndef M_LN2
735#define M_LN2 0.69314718055994530942
736#endif
737#ifndef M_PI
738#define M_PI 3.14159265358979323846
739#endif
740#undef log2 /* Conflict with C'99 function */
741#define log2(x) ((1./M_LN2)*log(x))
742#undef exp2 /* Conflict with C'99 function */
743#define exp2(x) exp(M_LN2*(x))
744
745static int itrunc(double x, int m)
746{
747 if( m == SGILOGENCODE_NODITHER )
748 return (int)x;
749 /* Silence CoverityScan warning about bad crypto function */
750 /* coverity[dont_call] */
751 return (int)(x + rand()*(1./RAND_MAX) - .5);
752}
753
754#if !LOGLUV_PUBLIC
755static
756#endif
757double
758LogL16toY(int p16) /* compute luminance from 16-bit LogL */
759{
760 int Le = p16 & 0x7fff;
761 double Y;
762
763 if (!Le)
764 return (0.);
765 Y = exp(M_LN2/256.*(Le+.5) - M_LN2*64.);
766 return (!(p16 & 0x8000) ? Y : -Y);
767}
768
769#if !LOGLUV_PUBLIC
770static
771#endif
772int
773LogL16fromY(double Y, int em) /* get 16-bit LogL from Y */
774{
775 if (Y >= 1.8371976e19)
776 return (0x7fff);
777 if (Y <= -1.8371976e19)
778 return (0xffff);
779 if (Y > 5.4136769e-20)
780 return itrunc(256.*(log2(Y) + 64.), em);
781 if (Y < -5.4136769e-20)
782 return (~0x7fff | itrunc(256.*(log2(-Y) + 64.), em));
783 return (0);
784}
785
786static void
787L16toY(LogLuvState* sp, uint8* op, tmsize_t n)
788{
789 int16* l16 = (int16*) sp->tbuf;
790 float* yp = (float*) op;
791
792 while (n-- > 0)
793 *yp++ = (float)LogL16toY(*l16++);
794}
795
796static void
797L16toGry(LogLuvState* sp, uint8* op, tmsize_t n)
798{
799 int16* l16 = (int16*) sp->tbuf;
800 uint8* gp = (uint8*) op;
801
802 while (n-- > 0) {
803 double Y = LogL16toY(*l16++);
804 *gp++ = (uint8) ((Y <= 0.) ? 0 : (Y >= 1.) ? 255 : (int)(256.*sqrt(Y)));
805 }
806}
807
808static void
809L16fromY(LogLuvState* sp, uint8* op, tmsize_t n)
810{
811 int16* l16 = (int16*) sp->tbuf;
812 float* yp = (float*) op;
813
814 while (n-- > 0)
815 *l16++ = (int16) (LogL16fromY(*yp++, sp->encode_meth));
816}
817
818#if !LOGLUV_PUBLIC
819static
820#endif
821void
822XYZtoRGB24(float xyz[3], uint8 rgb[3])
823{
824 double r, g, b;
825 /* assume CCIR-709 primaries */
826 r = 2.690*xyz[0] + -1.276*xyz[1] + -0.414*xyz[2];
827 g = -1.022*xyz[0] + 1.978*xyz[1] + 0.044*xyz[2];
828 b = 0.061*xyz[0] + -0.224*xyz[1] + 1.163*xyz[2];
829 /* assume 2.0 gamma for speed */
830 /* could use integer sqrt approx., but this is probably faster */
831 rgb[0] = (uint8)((r<=0.) ? 0 : (r >= 1.) ? 255 : (int)(256.*sqrt(r)));
832 rgb[1] = (uint8)((g<=0.) ? 0 : (g >= 1.) ? 255 : (int)(256.*sqrt(g)));
833 rgb[2] = (uint8)((b<=0.) ? 0 : (b >= 1.) ? 255 : (int)(256.*sqrt(b)));
834}
835
836#if !LOGLUV_PUBLIC
837static
838#endif
839double
840LogL10toY(int p10) /* compute luminance from 10-bit LogL */
841{
842 if (p10 == 0)
843 return (0.);
844 return (exp(M_LN2/64.*(p10+.5) - M_LN2*12.));
845}
846
847#if !LOGLUV_PUBLIC
848static
849#endif
850int
851LogL10fromY(double Y, int em) /* get 10-bit LogL from Y */
852{
853 if (Y >= 15.742)
854 return (0x3ff);
855 else if (Y <= .00024283)
856 return (0);
857 else
858 return itrunc(64.*(log2(Y) + 12.), em);
859}
860
861#define NANGLES 100
862#define uv2ang(u, v) ( (NANGLES*.499999999/M_PI) \
863 * atan2((v)-V_NEU,(u)-U_NEU) + .5*NANGLES )
864
865static int
866oog_encode(double u, double v) /* encode out-of-gamut chroma */
867{
868 static int oog_table[NANGLES];
869 static int initialized = 0;
870 register int i;
871
872 if (!initialized) { /* set up perimeter table */
873 double eps[NANGLES], ua, va, ang, epsa;
874 int ui, vi, ustep;
875 for (i = NANGLES; i--; )
876 eps[i] = 2.;
877 for (vi = UV_NVS; vi--; ) {
878 va = UV_VSTART + (vi+.5)*UV_SQSIZ;
879 ustep = uv_row[vi].nus-1;
880 if (vi == UV_NVS-1 || vi == 0 || ustep <= 0)
881 ustep = 1;
882 for (ui = uv_row[vi].nus-1; ui >= 0; ui -= ustep) {
883 ua = uv_row[vi].ustart + (ui+.5)*UV_SQSIZ;
884 ang = uv2ang(ua, va);
885 i = (int) ang;
886 epsa = fabs(ang - (i+.5));
887 if (epsa < eps[i]) {
888 oog_table[i] = uv_row[vi].ncum + ui;
889 eps[i] = epsa;
890 }
891 }
892 }
893 for (i = NANGLES; i--; ) /* fill any holes */
894 if (eps[i] > 1.5) {
895 int i1, i2;
896 for (i1 = 1; i1 < NANGLES/2; i1++)
897 if (eps[(i+i1)%NANGLES] < 1.5)
898 break;
899 for (i2 = 1; i2 < NANGLES/2; i2++)
900 if (eps[(i+NANGLES-i2)%NANGLES] < 1.5)
901 break;
902 if (i1 < i2)
903 oog_table[i] =
904 oog_table[(i+i1)%NANGLES];
905 else
906 oog_table[i] =
907 oog_table[(i+NANGLES-i2)%NANGLES];
908 }
909 initialized = 1;
910 }
911 i = (int) uv2ang(u, v); /* look up hue angle */
912 return (oog_table[i]);
913}
914
915#undef uv2ang
916#undef NANGLES
917
918#if !LOGLUV_PUBLIC
919static
920#endif
921int
922uv_encode(double u, double v, int em) /* encode (u',v') coordinates */
923{
924 register int vi, ui;
925
926 if (v < UV_VSTART)
927 return oog_encode(u, v);
928 vi = itrunc((v - UV_VSTART)*(1./UV_SQSIZ), em);
929 if (vi >= UV_NVS)
930 return oog_encode(u, v);
931 if (u < uv_row[vi].ustart)
932 return oog_encode(u, v);
933 ui = itrunc((u - uv_row[vi].ustart)*(1./UV_SQSIZ), em);
934 if (ui >= uv_row[vi].nus)
935 return oog_encode(u, v);
936
937 return (uv_row[vi].ncum + ui);
938}
939
940#if !LOGLUV_PUBLIC
941static
942#endif
943int
944uv_decode(double *up, double *vp, int c) /* decode (u',v') index */
945{
946 int upper, lower;
947 register int ui, vi;
948
949 if (c < 0 || c >= UV_NDIVS)
950 return (-1);
951 lower = 0; /* binary search */
952 upper = UV_NVS;
953 while (upper - lower > 1) {
954 vi = (lower + upper) >> 1;
955 ui = c - uv_row[vi].ncum;
956 if (ui > 0)
957 lower = vi;
958 else if (ui < 0)
959 upper = vi;
960 else {
961 lower = vi;
962 break;
963 }
964 }
965 vi = lower;
966 ui = c - uv_row[vi].ncum;
967 *up = uv_row[vi].ustart + (ui+.5)*UV_SQSIZ;
968 *vp = UV_VSTART + (vi+.5)*UV_SQSIZ;
969 return (0);
970}
971
972#if !LOGLUV_PUBLIC
973static
974#endif
975void
976LogLuv24toXYZ(uint32 p, float XYZ[3])
977{
978 int Ce;
979 double L, u, v, s, x, y;
980 /* decode luminance */
981 L = LogL10toY(p>>14 & 0x3ff);
982 if (L <= 0.) {
983 XYZ[0] = XYZ[1] = XYZ[2] = 0.;
984 return;
985 }
986 /* decode color */
987 Ce = p & 0x3fff;
988 if (uv_decode(&u, &v, Ce) < 0) {
989 u = U_NEU; v = V_NEU;
990 }
991 s = 1./(6.*u - 16.*v + 12.);
992 x = 9.*u * s;
993 y = 4.*v * s;
994 /* convert to XYZ */
995 XYZ[0] = (float)(x/y * L);
996 XYZ[1] = (float)L;
997 XYZ[2] = (float)((1.-x-y)/y * L);
998}
999
1000#if !LOGLUV_PUBLIC
1001static
1002#endif
1003uint32
1004LogLuv24fromXYZ(float XYZ[3], int em)
1005{
1006 int Le, Ce;
1007 double u, v, s;
1008 /* encode luminance */
1009 Le = LogL10fromY(XYZ[1], em);
1010 /* encode color */
1011 s = XYZ[0] + 15.*XYZ[1] + 3.*XYZ[2];
1012 if (!Le || s <= 0.) {
1013 u = U_NEU;
1014 v = V_NEU;
1015 } else {
1016 u = 4.*XYZ[0] / s;
1017 v = 9.*XYZ[1] / s;
1018 }
1019 Ce = uv_encode(u, v, em);
1020 if (Ce < 0) /* never happens */
1022 /* combine encodings */
1023 return (Le << 14 | Ce);
1024}
1025
1026static void
1027Luv24toXYZ(LogLuvState* sp, uint8* op, tmsize_t n)
1028{
1029 uint32* luv = (uint32*) sp->tbuf;
1030 float* xyz = (float*) op;
1031
1032 while (n-- > 0) {
1033 LogLuv24toXYZ(*luv, xyz);
1034 xyz += 3;
1035 luv++;
1036 }
1037}
1038
1039static void
1040Luv24toLuv48(LogLuvState* sp, uint8* op, tmsize_t n)
1041{
1042 uint32* luv = (uint32*) sp->tbuf;
1043 int16* luv3 = (int16*) op;
1044
1045 while (n-- > 0) {
1046 double u, v;
1047
1048 *luv3++ = (int16)((*luv >> 12 & 0xffd) + 13314);
1049 if (uv_decode(&u, &v, *luv&0x3fff) < 0) {
1050 u = U_NEU;
1051 v = V_NEU;
1052 }
1053 *luv3++ = (int16)(u * (1L<<15));
1054 *luv3++ = (int16)(v * (1L<<15));
1055 luv++;
1056 }
1057}
1058
1059static void
1060Luv24toRGB(LogLuvState* sp, uint8* op, tmsize_t n)
1061{
1062 uint32* luv = (uint32*) sp->tbuf;
1063 uint8* rgb = (uint8*) op;
1064
1065 while (n-- > 0) {
1066 float xyz[3];
1067
1068 LogLuv24toXYZ(*luv++, xyz);
1069 XYZtoRGB24(xyz, rgb);
1070 rgb += 3;
1071 }
1072}
1073
1074static void
1075Luv24fromXYZ(LogLuvState* sp, uint8* op, tmsize_t n)
1076{
1077 uint32* luv = (uint32*) sp->tbuf;
1078 float* xyz = (float*) op;
1079
1080 while (n-- > 0) {
1081 *luv++ = LogLuv24fromXYZ(xyz, sp->encode_meth);
1082 xyz += 3;
1083 }
1084}
1085
1086static void
1087Luv24fromLuv48(LogLuvState* sp, uint8* op, tmsize_t n)
1088{
1089 uint32* luv = (uint32*) sp->tbuf;
1090 int16* luv3 = (int16*) op;
1091
1092 while (n-- > 0) {
1093 int Le, Ce;
1094
1095 if (luv3[0] <= 0)
1096 Le = 0;
1097 else if (luv3[0] >= (1<<12)+3314)
1098 Le = (1<<10) - 1;
1099 else if (sp->encode_meth == SGILOGENCODE_NODITHER)
1100 Le = (luv3[0]-3314) >> 2;
1101 else
1102 Le = itrunc(.25*(luv3[0]-3314.), sp->encode_meth);
1103
1104 Ce = uv_encode((luv3[1]+.5)/(1<<15), (luv3[2]+.5)/(1<<15),
1105 sp->encode_meth);
1106 if (Ce < 0) /* never happens */
1108 *luv++ = (uint32)Le << 14 | Ce;
1109 luv3 += 3;
1110 }
1111}
1112
1113#if !LOGLUV_PUBLIC
1114static
1115#endif
1116void
1117LogLuv32toXYZ(uint32 p, float XYZ[3])
1118{
1119 double L, u, v, s, x, y;
1120 /* decode luminance */
1121 L = LogL16toY((int)p >> 16);
1122 if (L <= 0.) {
1123 XYZ[0] = XYZ[1] = XYZ[2] = 0.;
1124 return;
1125 }
1126 /* decode color */
1127 u = 1./UVSCALE * ((p>>8 & 0xff) + .5);
1128 v = 1./UVSCALE * ((p & 0xff) + .5);
1129 s = 1./(6.*u - 16.*v + 12.);
1130 x = 9.*u * s;
1131 y = 4.*v * s;
1132 /* convert to XYZ */
1133 XYZ[0] = (float)(x/y * L);
1134 XYZ[1] = (float)L;
1135 XYZ[2] = (float)((1.-x-y)/y * L);
1136}
1137
1138#if !LOGLUV_PUBLIC
1139static
1140#endif
1141uint32
1142LogLuv32fromXYZ(float XYZ[3], int em)
1143{
1144 unsigned int Le, ue, ve;
1145 double u, v, s;
1146 /* encode luminance */
1147 Le = (unsigned int)LogL16fromY(XYZ[1], em);
1148 /* encode color */
1149 s = XYZ[0] + 15.*XYZ[1] + 3.*XYZ[2];
1150 if (!Le || s <= 0.) {
1151 u = U_NEU;
1152 v = V_NEU;
1153 } else {
1154 u = 4.*XYZ[0] / s;
1155 v = 9.*XYZ[1] / s;
1156 }
1157 if (u <= 0.) ue = 0;
1158 else ue = itrunc(UVSCALE*u, em);
1159 if (ue > 255) ue = 255;
1160 if (v <= 0.) ve = 0;
1161 else ve = itrunc(UVSCALE*v, em);
1162 if (ve > 255) ve = 255;
1163 /* combine encodings */
1164 return (Le << 16 | ue << 8 | ve);
1165}
1166
1167static void
1168Luv32toXYZ(LogLuvState* sp, uint8* op, tmsize_t n)
1169{
1170 uint32* luv = (uint32*) sp->tbuf;
1171 float* xyz = (float*) op;
1172
1173 while (n-- > 0) {
1174 LogLuv32toXYZ(*luv++, xyz);
1175 xyz += 3;
1176 }
1177}
1178
1179static void
1180Luv32toLuv48(LogLuvState* sp, uint8* op, tmsize_t n)
1181{
1182 uint32* luv = (uint32*) sp->tbuf;
1183 int16* luv3 = (int16*) op;
1184
1185 while (n-- > 0) {
1186 double u, v;
1187
1188 *luv3++ = (int16)(*luv >> 16);
1189 u = 1./UVSCALE * ((*luv>>8 & 0xff) + .5);
1190 v = 1./UVSCALE * ((*luv & 0xff) + .5);
1191 *luv3++ = (int16)(u * (1L<<15));
1192 *luv3++ = (int16)(v * (1L<<15));
1193 luv++;
1194 }
1195}
1196
1197static void
1198Luv32toRGB(LogLuvState* sp, uint8* op, tmsize_t n)
1199{
1200 uint32* luv = (uint32*) sp->tbuf;
1201 uint8* rgb = (uint8*) op;
1202
1203 while (n-- > 0) {
1204 float xyz[3];
1205
1206 LogLuv32toXYZ(*luv++, xyz);
1207 XYZtoRGB24(xyz, rgb);
1208 rgb += 3;
1209 }
1210}
1211
1212static void
1213Luv32fromXYZ(LogLuvState* sp, uint8* op, tmsize_t n)
1214{
1215 uint32* luv = (uint32*) sp->tbuf;
1216 float* xyz = (float*) op;
1217
1218 while (n-- > 0) {
1219 *luv++ = LogLuv32fromXYZ(xyz, sp->encode_meth);
1220 xyz += 3;
1221 }
1222}
1223
1224static void
1225Luv32fromLuv48(LogLuvState* sp, uint8* op, tmsize_t n)
1226{
1227 uint32* luv = (uint32*) sp->tbuf;
1228 int16* luv3 = (int16*) op;
1229
1230 if (sp->encode_meth == SGILOGENCODE_NODITHER) {
1231 while (n-- > 0) {
1232 *luv++ = (uint32)luv3[0] << 16 |
1233 (luv3[1]*(uint32)(UVSCALE+.5) >> 7 & 0xff00) |
1234 (luv3[2]*(uint32)(UVSCALE+.5) >> 15 & 0xff);
1235 luv3 += 3;
1236 }
1237 return;
1238 }
1239 while (n-- > 0) {
1240 *luv++ = (uint32)luv3[0] << 16 |
1241 (itrunc(luv3[1]*(UVSCALE/(1<<15)), sp->encode_meth) << 8 & 0xff00) |
1242 (itrunc(luv3[2]*(UVSCALE/(1<<15)), sp->encode_meth) & 0xff);
1243 luv3 += 3;
1244 }
1245}
1246
1247static void
1248_logLuvNop(LogLuvState* sp, uint8* op, tmsize_t n)
1249{
1250 (void) sp; (void) op; (void) n;
1251}
1252
1253static int
1254LogL16GuessDataFmt(TIFFDirectory *td)
1255{
1256#define PACK(s,b,f) (((b)<<6)|((s)<<3)|(f))
1258 case PACK(1, 32, SAMPLEFORMAT_IEEEFP):
1260 case PACK(1, 16, SAMPLEFORMAT_VOID):
1261 case PACK(1, 16, SAMPLEFORMAT_INT):
1262 case PACK(1, 16, SAMPLEFORMAT_UINT):
1264 case PACK(1, 8, SAMPLEFORMAT_VOID):
1265 case PACK(1, 8, SAMPLEFORMAT_UINT):
1267 }
1268#undef PACK
1269 return (SGILOGDATAFMT_UNKNOWN);
1270}
1271
1272static tmsize_t
1273multiply_ms(tmsize_t m1, tmsize_t m2)
1274{
1275 return _TIFFMultiplySSize(NULL, m1, m2, NULL);
1276}
1277
1278static int
1279LogL16InitState(TIFF* tif)
1280{
1281 static const char module[] = "LogL16InitState";
1282 TIFFDirectory *td = &tif->tif_dir;
1283 LogLuvState* sp = DecoderState(tif);
1284
1285 assert(sp != NULL);
1287
1288 if( td->td_samplesperpixel != 1 )
1289 {
1291 "Sorry, can not handle LogL image with %s=%d",
1292 "Samples/pixel", td->td_samplesperpixel);
1293 return 0;
1294 }
1295
1296 /* for some reason, we can't do this in TIFFInitLogL16 */
1297 if (sp->user_datafmt == SGILOGDATAFMT_UNKNOWN)
1298 sp->user_datafmt = LogL16GuessDataFmt(td);
1299 switch (sp->user_datafmt) {
1301 sp->pixel_size = sizeof (float);
1302 break;
1304 sp->pixel_size = sizeof (int16);
1305 break;
1306 case SGILOGDATAFMT_8BIT:
1307 sp->pixel_size = sizeof (uint8);
1308 break;
1309 default:
1311 "No support for converting user data format to LogL");
1312 return (0);
1313 }
1314 if( isTiled(tif) )
1315 sp->tbuflen = multiply_ms(td->td_tilewidth, td->td_tilelength);
1316 else if( td->td_rowsperstrip < td->td_imagelength )
1317 sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_rowsperstrip);
1318 else
1319 sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_imagelength);
1320 if (multiply_ms(sp->tbuflen, sizeof (int16)) == 0 ||
1321 (sp->tbuf = (uint8*) _TIFFmalloc(sp->tbuflen * sizeof (int16))) == NULL) {
1322 TIFFErrorExt(tif->tif_clientdata, module, "No space for SGILog translation buffer");
1323 return (0);
1324 }
1325 return (1);
1326}
1327
1328static int
1329LogLuvGuessDataFmt(TIFFDirectory *td)
1330{
1331 int guess;
1332
1333 /*
1334 * If the user didn't tell us their datafmt,
1335 * take our best guess from the bitspersample.
1336 */
1337#define PACK(a,b) (((a)<<3)|(b))
1338 switch (PACK(td->td_bitspersample, td->td_sampleformat)) {
1339 case PACK(32, SAMPLEFORMAT_IEEEFP):
1340 guess = SGILOGDATAFMT_FLOAT;
1341 break;
1342 case PACK(32, SAMPLEFORMAT_VOID):
1343 case PACK(32, SAMPLEFORMAT_UINT):
1344 case PACK(32, SAMPLEFORMAT_INT):
1345 guess = SGILOGDATAFMT_RAW;
1346 break;
1347 case PACK(16, SAMPLEFORMAT_VOID):
1348 case PACK(16, SAMPLEFORMAT_INT):
1349 case PACK(16, SAMPLEFORMAT_UINT):
1350 guess = SGILOGDATAFMT_16BIT;
1351 break;
1352 case PACK( 8, SAMPLEFORMAT_VOID):
1353 case PACK( 8, SAMPLEFORMAT_UINT):
1354 guess = SGILOGDATAFMT_8BIT;
1355 break;
1356 default:
1357 guess = SGILOGDATAFMT_UNKNOWN;
1358 break;
1359#undef PACK
1360 }
1361 /*
1362 * Double-check samples per pixel.
1363 */
1364 switch (td->td_samplesperpixel) {
1365 case 1:
1366 if (guess != SGILOGDATAFMT_RAW)
1367 guess = SGILOGDATAFMT_UNKNOWN;
1368 break;
1369 case 3:
1370 if (guess == SGILOGDATAFMT_RAW)
1371 guess = SGILOGDATAFMT_UNKNOWN;
1372 break;
1373 default:
1374 guess = SGILOGDATAFMT_UNKNOWN;
1375 break;
1376 }
1377 return (guess);
1378}
1379
1380static int
1381LogLuvInitState(TIFF* tif)
1382{
1383 static const char module[] = "LogLuvInitState";
1384 TIFFDirectory* td = &tif->tif_dir;
1385 LogLuvState* sp = DecoderState(tif);
1386
1387 assert(sp != NULL);
1389
1390 /* for some reason, we can't do this in TIFFInitLogLuv */
1393 "SGILog compression cannot handle non-contiguous data");
1394 return (0);
1395 }
1396 if (sp->user_datafmt == SGILOGDATAFMT_UNKNOWN)
1397 sp->user_datafmt = LogLuvGuessDataFmt(td);
1398 switch (sp->user_datafmt) {
1400 sp->pixel_size = 3*sizeof (float);
1401 break;
1403 sp->pixel_size = 3*sizeof (int16);
1404 break;
1405 case SGILOGDATAFMT_RAW:
1406 sp->pixel_size = sizeof (uint32);
1407 break;
1408 case SGILOGDATAFMT_8BIT:
1409 sp->pixel_size = 3*sizeof (uint8);
1410 break;
1411 default:
1413 "No support for converting user data format to LogLuv");
1414 return (0);
1415 }
1416 if( isTiled(tif) )
1417 sp->tbuflen = multiply_ms(td->td_tilewidth, td->td_tilelength);
1418 else if( td->td_rowsperstrip < td->td_imagelength )
1419 sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_rowsperstrip);
1420 else
1421 sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_imagelength);
1422 if (multiply_ms(sp->tbuflen, sizeof (uint32)) == 0 ||
1423 (sp->tbuf = (uint8*) _TIFFmalloc(sp->tbuflen * sizeof (uint32))) == NULL) {
1424 TIFFErrorExt(tif->tif_clientdata, module, "No space for SGILog translation buffer");
1425 return (0);
1426 }
1427 return (1);
1428}
1429
1430static int
1431LogLuvFixupTags(TIFF* tif)
1432{
1433 (void) tif;
1434 return (1);
1435}
1436
1437static int
1438LogLuvSetupDecode(TIFF* tif)
1439{
1440 static const char module[] = "LogLuvSetupDecode";
1441 LogLuvState* sp = DecoderState(tif);
1442 TIFFDirectory* td = &tif->tif_dir;
1443
1445 switch (td->td_photometric) {
1446 case PHOTOMETRIC_LOGLUV:
1447 if (!LogLuvInitState(tif))
1448 break;
1450 tif->tif_decoderow = LogLuvDecode24;
1451 switch (sp->user_datafmt) {
1453 sp->tfunc = Luv24toXYZ;
1454 break;
1456 sp->tfunc = Luv24toLuv48;
1457 break;
1458 case SGILOGDATAFMT_8BIT:
1459 sp->tfunc = Luv24toRGB;
1460 break;
1461 }
1462 } else {
1463 tif->tif_decoderow = LogLuvDecode32;
1464 switch (sp->user_datafmt) {
1466 sp->tfunc = Luv32toXYZ;
1467 break;
1469 sp->tfunc = Luv32toLuv48;
1470 break;
1471 case SGILOGDATAFMT_8BIT:
1472 sp->tfunc = Luv32toRGB;
1473 break;
1474 }
1475 }
1476 return (1);
1477 case PHOTOMETRIC_LOGL:
1478 if (!LogL16InitState(tif))
1479 break;
1480 tif->tif_decoderow = LogL16Decode;
1481 switch (sp->user_datafmt) {
1483 sp->tfunc = L16toY;
1484 break;
1485 case SGILOGDATAFMT_8BIT:
1486 sp->tfunc = L16toGry;
1487 break;
1488 }
1489 return (1);
1490 default:
1492 "Inappropriate photometric interpretation %d for SGILog compression; %s",
1493 td->td_photometric, "must be either LogLUV or LogL");
1494 break;
1495 }
1496 return (0);
1497}
1498
1499static int
1500LogLuvSetupEncode(TIFF* tif)
1501{
1502 static const char module[] = "LogLuvSetupEncode";
1503 LogLuvState* sp = EncoderState(tif);
1504 TIFFDirectory* td = &tif->tif_dir;
1505
1506 switch (td->td_photometric) {
1507 case PHOTOMETRIC_LOGLUV:
1508 if (!LogLuvInitState(tif))
1509 return (0);
1511 tif->tif_encoderow = LogLuvEncode24;
1512 switch (sp->user_datafmt) {
1514 sp->tfunc = Luv24fromXYZ;
1515 break;
1517 sp->tfunc = Luv24fromLuv48;
1518 break;
1519 case SGILOGDATAFMT_RAW:
1520 break;
1521 default:
1522 goto notsupported;
1523 }
1524 } else {
1525 tif->tif_encoderow = LogLuvEncode32;
1526 switch (sp->user_datafmt) {
1528 sp->tfunc = Luv32fromXYZ;
1529 break;
1531 sp->tfunc = Luv32fromLuv48;
1532 break;
1533 case SGILOGDATAFMT_RAW:
1534 break;
1535 default:
1536 goto notsupported;
1537 }
1538 }
1539 break;
1540 case PHOTOMETRIC_LOGL:
1541 if (!LogL16InitState(tif))
1542 return (0);
1543 tif->tif_encoderow = LogL16Encode;
1544 switch (sp->user_datafmt) {
1546 sp->tfunc = L16fromY;
1547 break;
1549 break;
1550 default:
1551 goto notsupported;
1552 }
1553 break;
1554 default:
1556 "Inappropriate photometric interpretation %d for SGILog compression; %s",
1557 td->td_photometric, "must be either LogLUV or LogL");
1558 return (0);
1559 }
1560 sp->encoder_state = 1;
1561 return (1);
1562notsupported:
1564 "SGILog compression supported only for %s, or raw data",
1565 td->td_photometric == PHOTOMETRIC_LOGL ? "Y, L" : "XYZ, Luv");
1566 return (0);
1567}
1568
1569static void
1570LogLuvClose(TIFF* tif)
1571{
1572 LogLuvState* sp = (LogLuvState*) tif->tif_data;
1573 TIFFDirectory *td = &tif->tif_dir;
1574
1575 assert(sp != 0);
1576 /*
1577 * For consistency, we always want to write out the same
1578 * bitspersample and sampleformat for our TIFF file,
1579 * regardless of the data format being used by the application.
1580 * Since this routine is called after tags have been set but
1581 * before they have been recorded in the file, we reset them here.
1582 * Note: this is really a nasty approach. See PixarLogClose
1583 */
1584 if( sp->encoder_state )
1585 {
1586 /* See PixarLogClose. Might avoid issues with tags whose size depends
1587 * on those below, but not completely sure this is enough. */
1588 td->td_samplesperpixel =
1589 (td->td_photometric == PHOTOMETRIC_LOGL) ? 1 : 3;
1590 td->td_bitspersample = 16;
1592 }
1593}
1594
1595static void
1596LogLuvCleanup(TIFF* tif)
1597{
1598 LogLuvState* sp = (LogLuvState *)tif->tif_data;
1599
1600 assert(sp != 0);
1601
1602 tif->tif_tagmethods.vgetfield = sp->vgetparent;
1603 tif->tif_tagmethods.vsetfield = sp->vsetparent;
1604
1605 if (sp->tbuf)
1606 _TIFFfree(sp->tbuf);
1607 _TIFFfree(sp);
1608 tif->tif_data = NULL;
1609
1611}
1612
1613static int
1614LogLuvVSetField(TIFF* tif, uint32 tag, va_list ap)
1615{
1616 static const char module[] = "LogLuvVSetField";
1617 LogLuvState* sp = DecoderState(tif);
1618 int bps, fmt;
1619
1620 switch (tag) {
1622 sp->user_datafmt = (int) va_arg(ap, int);
1623 /*
1624 * Tweak the TIFF header so that the rest of libtiff knows what
1625 * size of data will be passed between app and library, and
1626 * assume that the app knows what it is doing and is not
1627 * confused by these header manipulations...
1628 */
1629 switch (sp->user_datafmt) {
1631 bps = 32;
1633 break;
1635 bps = 16;
1637 break;
1638 case SGILOGDATAFMT_RAW:
1639 bps = 32;
1642 break;
1643 case SGILOGDATAFMT_8BIT:
1644 bps = 8;
1646 break;
1647 default:
1649 "Unknown data format %d for LogLuv compression",
1650 sp->user_datafmt);
1651 return (0);
1652 }
1655 /*
1656 * Must recalculate sizes should bits/sample change.
1657 */
1658 tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t) -1;
1660 return (1);
1662 sp->encode_meth = (int) va_arg(ap, int);
1663 if (sp->encode_meth != SGILOGENCODE_NODITHER &&
1664 sp->encode_meth != SGILOGENCODE_RANDITHER) {
1666 "Unknown encoding %d for LogLuv compression",
1667 sp->encode_meth);
1668 return (0);
1669 }
1670 return (1);
1671 default:
1672 return (*sp->vsetparent)(tif, tag, ap);
1673 }
1674}
1675
1676static int
1677LogLuvVGetField(TIFF* tif, uint32 tag, va_list ap)
1678{
1679 LogLuvState *sp = (LogLuvState *)tif->tif_data;
1680
1681 switch (tag) {
1683 *va_arg(ap, int*) = sp->user_datafmt;
1684 return (1);
1685 default:
1686 return (*sp->vgetparent)(tif, tag, ap);
1687 }
1688}
1689
1690static const TIFFField LogLuvFields[] = {
1693};
1694
1695int
1696TIFFInitSGILog(TIFF* tif, int scheme)
1697{
1698 static const char module[] = "TIFFInitSGILog";
1699 LogLuvState* sp;
1700
1702
1703 /*
1704 * Merge codec-specific tag information.
1705 */
1706 if (!_TIFFMergeFields(tif, LogLuvFields,
1707 TIFFArrayCount(LogLuvFields))) {
1709 "Merging SGILog codec-specific tags failed");
1710 return 0;
1711 }
1712
1713 /*
1714 * Allocate state block so tag methods have storage to record values.
1715 */
1716 tif->tif_data = (uint8*) _TIFFmalloc(sizeof (LogLuvState));
1717 if (tif->tif_data == NULL)
1718 goto bad;
1719 sp = (LogLuvState*) tif->tif_data;
1720 _TIFFmemset((void*)sp, 0, sizeof (*sp));
1721 sp->user_datafmt = SGILOGDATAFMT_UNKNOWN;
1722 sp->encode_meth = (scheme == COMPRESSION_SGILOG24) ?
1724 sp->tfunc = _logLuvNop;
1725
1726 /*
1727 * Install codec methods.
1728 * NB: tif_decoderow & tif_encoderow are filled
1729 * in at setup time.
1730 */
1731 tif->tif_fixuptags = LogLuvFixupTags;
1732 tif->tif_setupdecode = LogLuvSetupDecode;
1733 tif->tif_decodestrip = LogLuvDecodeStrip;
1734 tif->tif_decodetile = LogLuvDecodeTile;
1735 tif->tif_setupencode = LogLuvSetupEncode;
1736 tif->tif_encodestrip = LogLuvEncodeStrip;
1737 tif->tif_encodetile = LogLuvEncodeTile;
1738 tif->tif_close = LogLuvClose;
1739 tif->tif_cleanup = LogLuvCleanup;
1740
1741 /*
1742 * Override parent get/set field methods.
1743 */
1744 sp->vgetparent = tif->tif_tagmethods.vgetfield;
1745 tif->tif_tagmethods.vgetfield = LogLuvVGetField; /* hook for codec tags */
1746 sp->vsetparent = tif->tif_tagmethods.vsetfield;
1747 tif->tif_tagmethods.vsetfield = LogLuvVSetField; /* hook for codec tags */
1748
1749 return (1);
1750bad:
1752 "%s: No space for LogLuv state block", tif->tif_name);
1753 return (0);
1754}
1755#endif /* LOGLUV_SUPPORT */
1756
1757/* vim: set ts=8 sts=8 sw=8 noet: */
1758/*
1759 * Local Variables:
1760 * mode: c
1761 * c-basic-offset: 8
1762 * fill-column: 78
1763 * End:
1764 */
_STLP_DECLSPEC complex< float > _STLP_CALL sqrt(const complex< float > &)
Definition: complex.cpp:188
char * va_list
Definition: acmsvcex.h:78
#define va_arg(ap, T)
Definition: acmsvcex.h:89
unsigned short uint16
Definition: types.h:30
unsigned int uint32
Definition: types.h:32
unsigned char uint8
Definition: types.h:28
#define __int64
Definition: basetyps.h:16
return
Definition: dirsup.c:529
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
UINT op
Definition: effect.c:236
#define Y(I)
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define assert(x)
Definition: debug.h:53
_In_ uint64_t _In_ uint64_t _In_ uint64_t _In_opt_ traverse_ptr * tp
Definition: btrfs.c:2996
switch(r->id)
Definition: btrfs.c:3046
short int16
Definition: platform.h:11
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
const GLdouble * v
Definition: gl.h:2040
GLdouble s
Definition: gl.h:2039
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLdouble n
Definition: glext.h:7729
const GLubyte * c
Definition: glext.h:8905
GLenum GLint GLuint mask
Definition: glext.h:6028
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean g
Definition: glext.h:6204
GLfloat GLfloat p
Definition: glext.h:8902
const GLfloat * m
Definition: glext.h:10848
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define up(mutex)
Definition: glue.h:30
_Check_return_ _CRT_JIT_INTRINSIC double __cdecl fabs(_In_ double x)
Definition: fabs.c:17
_Check_return_ __CRT_INLINE double log2(_In_ double x)
Definition: math.h:301
#define RAND_MAX
Definition: stdlib.h:87
_Check_return_ int __cdecl rand(void)
Definition: rand.c:10
uint32_t cc
Definition: isohybrid.c:75
uint16_t ve[16]
Definition: isohybrid.c:73
#define b
Definition: ke_i.h:79
struct msdos_volume_info vi
Definition: mkdosfs.c:440
#define for
Definition: utility.h:88
static const WCHAR sp[]
Definition: suminfo.c:287
static float(__cdecl *square_half_float)(float x
DWORD exp
Definition: msg.c:16058
static VOID CALLBACK tfunc(HWND hwnd, UINT uMsg, UINT_PTR id, DWORD dwTime)
Definition: msg.c:10213
#define L(x)
Definition: ntvdm.h:50
UINT ui
Definition: oleauto.h:49
DWORD scheme
uint16 td_sampleformat
Definition: tif_dir.h:76
uint16 td_samplesperpixel
Definition: tif_dir.h:82
uint16 td_bitspersample
Definition: tif_dir.h:75
uint32 td_imagewidth
Definition: tif_dir.h:72
uint32 td_rowsperstrip
Definition: tif_dir.h:83
uint16 td_photometric
Definition: tif_dir.h:78
uint16 td_planarconfig
Definition: tif_dir.h:89
uint32 td_tilelength
Definition: tif_dir.h:73
uint16 td_compression
Definition: tif_dir.h:77
uint32 td_tilewidth
Definition: tif_dir.h:73
uint32 td_imagelength
Definition: tif_dir.h:72
TIFFVGetMethod vgetfield
Definition: tiffio.h:334
TIFFVSetMethod vsetfield
Definition: tiffio.h:333
Definition: dsound.c:943
Definition: ecma_167.h:138
Definition: tiffiop.h:115
TIFFCodeMethod tif_encodestrip
Definition: tiffiop.h:183
TIFFCodeMethod tif_encodetile
Definition: tiffiop.h:185
TIFFTagMethods tif_tagmethods
Definition: tiffiop.h:219
tmsize_t tif_scanlinesize
Definition: tiffiop.h:193
TIFFBoolMethod tif_fixuptags
Definition: tiffiop.h:173
tmsize_t tif_rawcc
Definition: tiffiop.h:200
TIFFCodeMethod tif_decodestrip
Definition: tiffiop.h:182
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:214
thandle_t tif_clientdata
Definition: tiffiop.h:207
char * tif_name
Definition: tiffiop.h:116
TIFFCodeMethod tif_decoderow
Definition: tiffiop.h:180
TIFFBoolMethod tif_setupencode
Definition: tiffiop.h:176
TIFFDirectory tif_dir
Definition: tiffiop.h:151
uint8 * tif_data
Definition: tiffiop.h:191
TIFFCodeMethod tif_encoderow
Definition: tiffiop.h:181
TIFFVoidMethod tif_close
Definition: tiffiop.h:186
TIFFVoidMethod tif_cleanup
Definition: tiffiop.h:188
uint32 tif_row
Definition: tiffiop.h:159
TIFFBoolMethod tif_setupdecode
Definition: tiffiop.h:174
tmsize_t tif_rawdatasize
Definition: tiffiop.h:196
tmsize_t tif_tilesize
Definition: tiffiop.h:170
uint8 * tif_rawcp
Definition: tiffiop.h:199
TIFFCodeMethod tif_decodetile
Definition: tiffiop.h:184
static BOOL initialized
Definition: syslog.c:39
tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second, const char *where)
Definition: tif_aux.c:59
#define TIFFInitSGILog
Definition: tif_codec.c:69
void _TIFFSetDefaultCompressionState(TIFF *tif)
Definition: tif_compress.c:135
int TIFFSetField(TIFF *tif, uint32 tag,...)
Definition: tif_dir.c:807
#define FIELD_PSEUDO
Definition: tif_dir.h:190
@ TIFF_SETGET_UNDEFINED
Definition: tif_dir.h:204
@ TIFF_SETGET_INT
Definition: tif_dir.h:217
int _TIFFMergeFields(TIFF *tif, const TIFFField info[], uint32 n)
Definition: tif_dirinfo.c:369
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
#define PACK(r, g, b)
void _TIFFNoPostDecode(TIFF *tif, uint8 *buf, tmsize_t cc)
Definition: tif_read.c:1603
tmsize_t TIFFScanlineSize(TIFF *tif)
Definition: tif_strip.c:314
tmsize_t TIFFTileSize(TIFF *tif)
Definition: tif_tile.c:257
tmsize_t TIFFTileRowSize(TIFF *tif)
Definition: tif_tile.c:180
void _TIFFfree(void *p)
Definition: tif_unix.c:326
void _TIFFmemset(void *p, int v, tmsize_t c)
Definition: tif_unix.c:338
void * _TIFFmalloc(tmsize_t s)
Definition: tif_unix.c:309
int TIFFFlushData1(TIFF *tif)
Definition: tif_write.c:803
#define SGILOGDATAFMT_RAW
Definition: tiff.h:560
#define TIFFTAG_BITSPERSAMPLE
Definition: tiff.h:156
#define TIFFTAG_SGILOGENCODE
Definition: tiff.h:562
#define TIFFTAG_SAMPLESPERPIXEL
Definition: tiff.h:231
#define PHOTOMETRIC_LOGL
Definition: tiff.h:206
#define COMPRESSION_SGILOG
Definition: tiff.h:186
#define SAMPLEFORMAT_UINT
Definition: tiff.h:308
@ TIFF_SHORT
Definition: tiff.h:127
#define SGILOGENCODE_RANDITHER
Definition: tiff.h:564
#define PHOTOMETRIC_LOGLUV
Definition: tiff.h:207
#define SAMPLEFORMAT_IEEEFP
Definition: tiff.h:310
#define SGILOGDATAFMT_8BIT
Definition: tiff.h:561
#define SGILOGDATAFMT_FLOAT
Definition: tiff.h:558
#define TIFFTAG_SGILOGDATAFMT
Definition: tiff.h:557
#define COMPRESSION_SGILOG24
Definition: tiff.h:187
#define SGILOGENCODE_NODITHER
Definition: tiff.h:563
#define TIFFTAG_SAMPLEFORMAT
Definition: tiff.h:307
#define SAMPLEFORMAT_VOID
Definition: tiff.h:311
#define SAMPLEFORMAT_INT
Definition: tiff.h:309
#define SGILOGDATAFMT_16BIT
Definition: tiff.h:559
#define PLANARCONFIG_CONTIG
Definition: tiff.h:239
#define U_NEU
Definition: tiffio.h:502
void LogLuv32toXYZ(uint32, float *)
#define UVSCALE
Definition: tiffio.h:504
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
int LogL16fromY(double, int)
void LogLuv24toXYZ(uint32, float *)
#define V_NEU
Definition: tiffio.h:503
double LogL16toY(int)
uint32 LogLuv24fromXYZ(float *, int)
double LogL10toY(int)
uint32 LogLuv32fromXYZ(float *, int)
int uv_decode(double *, double *, int)
int uv_encode(double, double, int)
void XYZtoRGB24(float *, uint8 *)
int LogL10fromY(double, int)
int(* TIFFVSetMethod)(TIFF *, uint32, va_list)
Definition: tiffio.h:328
#define isTiled(tif)
Definition: tiffiop.h:229
#define TIFFArrayCount(a)
Definition: tiffiop.h:283
#define UV_VSTART
Definition: uvcode.h:4
static const struct @3481 uv_row[UV_NVS]
short ncum
Definition: uvcode.h:8
short nus
Definition: uvcode.h:8
#define UV_NVS
Definition: uvcode.h:5
#define UV_NDIVS
Definition: uvcode.h:3
#define UV_SQSIZ
Definition: uvcode.h:2
float ustart
Definition: uvcode.h:7
_In_ ULONG _In_ ULONG rgb
Definition: winddi.h:3521
#define eps
void int int ULONGLONG int va_list * ap
Definition: winesup.h:36
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList