1 /* $Id: tif_pixarlog.c,v 1.37 2012-05-24 23:21:45 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)); 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
