1 /* $Id: tif_predict.c,v 1.35 2015-08-31 15:05:57 erouault Exp $ */ 2 3 /* 4 * Copyright (c) 1988-1997 Sam Leffler 5 * Copyright (c) 1991-1997 Silicon Graphics, Inc. 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 * 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 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 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 /* 28 * TIFF Library. 29 * 30 * Predictor Tag Support (used by multiple codecs). 31 */ 32 #include "tiffiop.h" 33 #include "tif_predict.h" 34 35 #define PredictorState(tif) ((TIFFPredictorState*) (tif)->tif_data) 36 37 static void horAcc8(TIFF* tif, uint8* cp0, tmsize_t cc); 38 static void horAcc16(TIFF* tif, uint8* cp0, tmsize_t cc); 39 static void horAcc32(TIFF* tif, uint8* cp0, tmsize_t cc); 40 static void swabHorAcc16(TIFF* tif, uint8* cp0, tmsize_t cc); 41 static void swabHorAcc32(TIFF* tif, uint8* cp0, tmsize_t cc); 42 static void horDiff8(TIFF* tif, uint8* cp0, tmsize_t cc); 43 static void horDiff16(TIFF* tif, uint8* cp0, tmsize_t cc); 44 static void horDiff32(TIFF* tif, uint8* cp0, tmsize_t cc); 45 static void swabHorDiff16(TIFF* tif, uint8* cp0, tmsize_t cc); 46 static void swabHorDiff32(TIFF* tif, uint8* cp0, tmsize_t cc); 47 static void fpAcc(TIFF* tif, uint8* cp0, tmsize_t cc); 48 static void fpDiff(TIFF* tif, uint8* cp0, tmsize_t cc); 49 static int PredictorDecodeRow(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s); 50 static int PredictorDecodeTile(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s); 51 static int PredictorEncodeRow(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); 52 static int PredictorEncodeTile(TIFF* tif, uint8* bp0, tmsize_t cc0, uint16 s); 53 54 static int 55 PredictorSetup(TIFF* tif) 56 { 57 static const char module[] = "PredictorSetup"; 58 59 TIFFPredictorState* sp = PredictorState(tif); 60 TIFFDirectory* td = &tif->tif_dir; 61 62 switch (sp->predictor) /* no differencing */ 63 { 64 case PREDICTOR_NONE: 65 return 1; 66 case PREDICTOR_HORIZONTAL: 67 if (td->td_bitspersample != 8 68 && td->td_bitspersample != 16 69 && td->td_bitspersample != 32) { 70 TIFFErrorExt(tif->tif_clientdata, module, 71 "Horizontal differencing \"Predictor\" not supported with %d-bit samples", 72 td->td_bitspersample); 73 return 0; 74 } 75 break; 76 case PREDICTOR_FLOATINGPOINT: 77 if (td->td_sampleformat != SAMPLEFORMAT_IEEEFP) { 78 TIFFErrorExt(tif->tif_clientdata, module, 79 "Floating point \"Predictor\" not supported with %d data format", 80 td->td_sampleformat); 81 return 0; 82 } 83 break; 84 default: 85 TIFFErrorExt(tif->tif_clientdata, module, 86 "\"Predictor\" value %d not supported", 87 sp->predictor); 88 return 0; 89 } 90 sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ? 91 td->td_samplesperpixel : 1); 92 /* 93 * Calculate the scanline/tile-width size in bytes. 94 */ 95 if (isTiled(tif)) 96 sp->rowsize = TIFFTileRowSize(tif); 97 else 98 sp->rowsize = TIFFScanlineSize(tif); 99 if (sp->rowsize == 0) 100 return 0; 101 102 return 1; 103 } 104 105 static int 106 PredictorSetupDecode(TIFF* tif) 107 { 108 TIFFPredictorState* sp = PredictorState(tif); 109 TIFFDirectory* td = &tif->tif_dir; 110 111 if (!(*sp->setupdecode)(tif) || !PredictorSetup(tif)) 112 return 0; 113 114 if (sp->predictor == 2) { 115 switch (td->td_bitspersample) { 116 case 8: sp->decodepfunc = horAcc8; break; 117 case 16: sp->decodepfunc = horAcc16; break; 118 case 32: sp->decodepfunc = horAcc32; break; 119 } 120 /* 121 * Override default decoding method with one that does the 122 * predictor stuff. 123 */ 124 if( tif->tif_decoderow != PredictorDecodeRow ) 125 { 126 sp->decoderow = tif->tif_decoderow; 127 tif->tif_decoderow = PredictorDecodeRow; 128 sp->decodestrip = tif->tif_decodestrip; 129 tif->tif_decodestrip = PredictorDecodeTile; 130 sp->decodetile = tif->tif_decodetile; 131 tif->tif_decodetile = PredictorDecodeTile; 132 } 133 134 /* 135 * If the data is horizontally differenced 16-bit data that 136 * requires byte-swapping, then it must be byte swapped before 137 * the accumulation step. We do this with a special-purpose 138 * routine and override the normal post decoding logic that 139 * the library setup when the directory was read. 140 */ 141 if (tif->tif_flags & TIFF_SWAB) { 142 if (sp->decodepfunc == horAcc16) { 143 sp->decodepfunc = swabHorAcc16; 144 tif->tif_postdecode = _TIFFNoPostDecode; 145 } else if (sp->decodepfunc == horAcc32) { 146 sp->decodepfunc = swabHorAcc32; 147 tif->tif_postdecode = _TIFFNoPostDecode; 148 } 149 } 150 } 151 152 else if (sp->predictor == 3) { 153 sp->decodepfunc = fpAcc; 154 /* 155 * Override default decoding method with one that does the 156 * predictor stuff. 157 */ 158 if( tif->tif_decoderow != PredictorDecodeRow ) 159 { 160 sp->decoderow = tif->tif_decoderow; 161 tif->tif_decoderow = PredictorDecodeRow; 162 sp->decodestrip = tif->tif_decodestrip; 163 tif->tif_decodestrip = PredictorDecodeTile; 164 sp->decodetile = tif->tif_decodetile; 165 tif->tif_decodetile = PredictorDecodeTile; 166 } 167 /* 168 * The data should not be swapped outside of the floating 169 * point predictor, the accumulation routine should return 170 * byres in the native order. 171 */ 172 if (tif->tif_flags & TIFF_SWAB) { 173 tif->tif_postdecode = _TIFFNoPostDecode; 174 } 175 /* 176 * Allocate buffer to keep the decoded bytes before 177 * rearranging in the ight order 178 */ 179 } 180 181 return 1; 182 } 183 184 static int 185 PredictorSetupEncode(TIFF* tif) 186 { 187 TIFFPredictorState* sp = PredictorState(tif); 188 TIFFDirectory* td = &tif->tif_dir; 189 190 if (!(*sp->setupencode)(tif) || !PredictorSetup(tif)) 191 return 0; 192 193 if (sp->predictor == 2) { 194 switch (td->td_bitspersample) { 195 case 8: sp->encodepfunc = horDiff8; break; 196 case 16: sp->encodepfunc = horDiff16; break; 197 case 32: sp->encodepfunc = horDiff32; break; 198 } 199 /* 200 * Override default encoding method with one that does the 201 * predictor stuff. 202 */ 203 if( tif->tif_encoderow != PredictorEncodeRow ) 204 { 205 sp->encoderow = tif->tif_encoderow; 206 tif->tif_encoderow = PredictorEncodeRow; 207 sp->encodestrip = tif->tif_encodestrip; 208 tif->tif_encodestrip = PredictorEncodeTile; 209 sp->encodetile = tif->tif_encodetile; 210 tif->tif_encodetile = PredictorEncodeTile; 211 } 212 213 /* 214 * If the data is horizontally differenced 16-bit data that 215 * requires byte-swapping, then it must be byte swapped after 216 * the differenciation step. We do this with a special-purpose 217 * routine and override the normal post decoding logic that 218 * the library setup when the directory was read. 219 */ 220 if (tif->tif_flags & TIFF_SWAB) { 221 if (sp->encodepfunc == horDiff16) { 222 sp->encodepfunc = swabHorDiff16; 223 tif->tif_postdecode = _TIFFNoPostDecode; 224 } else if (sp->encodepfunc == horDiff32) { 225 sp->encodepfunc = swabHorDiff32; 226 tif->tif_postdecode = _TIFFNoPostDecode; 227 } 228 } 229 } 230 231 else if (sp->predictor == 3) { 232 sp->encodepfunc = fpDiff; 233 /* 234 * Override default encoding method with one that does the 235 * predictor stuff. 236 */ 237 if( tif->tif_encoderow != PredictorEncodeRow ) 238 { 239 sp->encoderow = tif->tif_encoderow; 240 tif->tif_encoderow = PredictorEncodeRow; 241 sp->encodestrip = tif->tif_encodestrip; 242 tif->tif_encodestrip = PredictorEncodeTile; 243 sp->encodetile = tif->tif_encodetile; 244 tif->tif_encodetile = PredictorEncodeTile; 245 } 246 } 247 248 return 1; 249 } 250 251 #define REPEAT4(n, op) \ 252 switch (n) { \ 253 default: { tmsize_t i; for (i = n-4; i > 0; i--) { op; } } \ 254 case 4: op; \ 255 case 3: op; \ 256 case 2: op; \ 257 case 1: op; \ 258 case 0: ; \ 259 } 260 261 /* Remarks related to C standard compliance in all below functions : */ 262 /* - to avoid any undefined behaviour, we only operate on unsigned types */ 263 /* since the behaviour of "overflows" is defined (wrap over) */ 264 /* - when storing into the byte stream, we explicitly mask with 0xff so */ 265 /* as to make icc -check=conversions happy (not necessary by the standard) */ 266 267 static void 268 horAcc8(TIFF* tif, uint8* cp0, tmsize_t cc) 269 { 270 tmsize_t stride = PredictorState(tif)->stride; 271 272 unsigned char* cp = (unsigned char*) cp0; 273 assert((cc%stride)==0); 274 if (cc > stride) { 275 /* 276 * Pipeline the most common cases. 277 */ 278 if (stride == 3) { 279 unsigned int cr = cp[0]; 280 unsigned int cg = cp[1]; 281 unsigned int cb = cp[2]; 282 cc -= 3; 283 cp += 3; 284 while (cc>0) { 285 cp[0] = (unsigned char) ((cr += cp[0]) & 0xff); 286 cp[1] = (unsigned char) ((cg += cp[1]) & 0xff); 287 cp[2] = (unsigned char) ((cb += cp[2]) & 0xff); 288 cc -= 3; 289 cp += 3; 290 } 291 } else if (stride == 4) { 292 unsigned int cr = cp[0]; 293 unsigned int cg = cp[1]; 294 unsigned int cb = cp[2]; 295 unsigned int ca = cp[3]; 296 cc -= 4; 297 cp += 4; 298 while (cc>0) { 299 cp[0] = (unsigned char) ((cr += cp[0]) & 0xff); 300 cp[1] = (unsigned char) ((cg += cp[1]) & 0xff); 301 cp[2] = (unsigned char) ((cb += cp[2]) & 0xff); 302 cp[3] = (unsigned char) ((ca += cp[3]) & 0xff); 303 cc -= 4; 304 cp += 4; 305 } 306 } else { 307 cc -= stride; 308 do { 309 REPEAT4(stride, cp[stride] = 310 (unsigned char) ((cp[stride] + *cp) & 0xff); cp++) 311 cc -= stride; 312 } while (cc>0); 313 } 314 } 315 } 316 317 static void 318 swabHorAcc16(TIFF* tif, uint8* cp0, tmsize_t cc) 319 { 320 uint16* wp = (uint16*) cp0; 321 tmsize_t wc = cc / 2; 322 323 TIFFSwabArrayOfShort(wp, wc); 324 horAcc16(tif, cp0, cc); 325 } 326 327 static void 328 horAcc16(TIFF* tif, uint8* cp0, tmsize_t cc) 329 { 330 tmsize_t stride = PredictorState(tif)->stride; 331 uint16* wp = (uint16*) cp0; 332 tmsize_t wc = cc / 2; 333 334 assert((cc%(2*stride))==0); 335 336 if (wc > stride) { 337 wc -= stride; 338 do { 339 REPEAT4(stride, wp[stride] = (uint16)(((unsigned int)wp[stride] + (unsigned int)wp[0]) & 0xffff); wp++) 340 wc -= stride; 341 } while (wc > 0); 342 } 343 } 344 345 static void 346 swabHorAcc32(TIFF* tif, uint8* cp0, tmsize_t cc) 347 { 348 uint32* wp = (uint32*) cp0; 349 tmsize_t wc = cc / 4; 350 351 TIFFSwabArrayOfLong(wp, wc); 352 horAcc32(tif, cp0, cc); 353 } 354 355 static void 356 horAcc32(TIFF* tif, uint8* cp0, tmsize_t cc) 357 { 358 tmsize_t stride = PredictorState(tif)->stride; 359 uint32* wp = (uint32*) cp0; 360 tmsize_t wc = cc / 4; 361 362 assert((cc%(4*stride))==0); 363 364 if (wc > stride) { 365 wc -= stride; 366 do { 367 REPEAT4(stride, wp[stride] += wp[0]; wp++) 368 wc -= stride; 369 } while (wc > 0); 370 } 371 } 372 373 /* 374 * Floating point predictor accumulation routine. 375 */ 376 static void 377 fpAcc(TIFF* tif, uint8* cp0, tmsize_t cc) 378 { 379 tmsize_t stride = PredictorState(tif)->stride; 380 uint32 bps = tif->tif_dir.td_bitspersample / 8; 381 tmsize_t wc = cc / bps; 382 tmsize_t count = cc; 383 uint8 *cp = (uint8 *) cp0; 384 uint8 *tmp = (uint8 *)_TIFFmalloc(cc); 385 386 assert((cc%(bps*stride))==0); 387 388 if (!tmp) 389 return; 390 391 while (count > stride) { 392 REPEAT4(stride, cp[stride] = 393 (unsigned char) ((cp[stride] + cp[0]) & 0xff); cp++) 394 count -= stride; 395 } 396 397 _TIFFmemcpy(tmp, cp0, cc); 398 cp = (uint8 *) cp0; 399 for (count = 0; count < wc; count++) { 400 uint32 byte; 401 for (byte = 0; byte < bps; byte++) { 402 #if WORDS_BIGENDIAN 403 cp[bps * count + byte] = tmp[byte * wc + count]; 404 #else 405 cp[bps * count + byte] = 406 tmp[(bps - byte - 1) * wc + count]; 407 #endif 408 } 409 } 410 _TIFFfree(tmp); 411 } 412 413 /* 414 * Decode a scanline and apply the predictor routine. 415 */ 416 static int 417 PredictorDecodeRow(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s) 418 { 419 TIFFPredictorState *sp = PredictorState(tif); 420 421 assert(sp != NULL); 422 assert(sp->decoderow != NULL); 423 assert(sp->decodepfunc != NULL); 424 425 if ((*sp->decoderow)(tif, op0, occ0, s)) { 426 (*sp->decodepfunc)(tif, op0, occ0); 427 return 1; 428 } else 429 return 0; 430 } 431 432 /* 433 * Decode a tile/strip and apply the predictor routine. 434 * Note that horizontal differencing must be done on a 435 * row-by-row basis. The width of a "row" has already 436 * been calculated at pre-decode time according to the 437 * strip/tile dimensions. 438 */ 439 static int 440 PredictorDecodeTile(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s) 441 { 442 TIFFPredictorState *sp = PredictorState(tif); 443 444 assert(sp != NULL); 445 assert(sp->decodetile != NULL); 446 447 if ((*sp->decodetile)(tif, op0, occ0, s)) { 448 tmsize_t rowsize = sp->rowsize; 449 assert(rowsize > 0); 450 assert((occ0%rowsize)==0); 451 assert(sp->decodepfunc != NULL); 452 while (occ0 > 0) { 453 (*sp->decodepfunc)(tif, op0, rowsize); 454 occ0 -= rowsize; 455 op0 += rowsize; 456 } 457 return 1; 458 } else 459 return 0; 460 } 461 462 static void 463 horDiff8(TIFF* tif, uint8* cp0, tmsize_t cc) 464 { 465 TIFFPredictorState* sp = PredictorState(tif); 466 tmsize_t stride = sp->stride; 467 unsigned char* cp = (unsigned char*) cp0; 468 469 assert((cc%stride)==0); 470 471 if (cc > stride) { 472 cc -= stride; 473 /* 474 * Pipeline the most common cases. 475 */ 476 if (stride == 3) { 477 unsigned int r1, g1, b1; 478 unsigned int r2 = cp[0]; 479 unsigned int g2 = cp[1]; 480 unsigned int b2 = cp[2]; 481 do { 482 r1 = cp[3]; cp[3] = (unsigned char)((r1-r2)&0xff); r2 = r1; 483 g1 = cp[4]; cp[4] = (unsigned char)((g1-g2)&0xff); g2 = g1; 484 b1 = cp[5]; cp[5] = (unsigned char)((b1-b2)&0xff); b2 = b1; 485 cp += 3; 486 } while ((cc -= 3) > 0); 487 } else if (stride == 4) { 488 unsigned int r1, g1, b1, a1; 489 unsigned int r2 = cp[0]; 490 unsigned int g2 = cp[1]; 491 unsigned int b2 = cp[2]; 492 unsigned int a2 = cp[3]; 493 do { 494 r1 = cp[4]; cp[4] = (unsigned char)((r1-r2)&0xff); r2 = r1; 495 g1 = cp[5]; cp[5] = (unsigned char)((g1-g2)&0xff); g2 = g1; 496 b1 = cp[6]; cp[6] = (unsigned char)((b1-b2)&0xff); b2 = b1; 497 a1 = cp[7]; cp[7] = (unsigned char)((a1-a2)&0xff); a2 = a1; 498 cp += 4; 499 } while ((cc -= 4) > 0); 500 } else { 501 cp += cc - 1; 502 do { 503 REPEAT4(stride, cp[stride] = (unsigned char)((cp[stride] - cp[0])&0xff); cp--) 504 } while ((cc -= stride) > 0); 505 } 506 } 507 } 508 509 static void 510 horDiff16(TIFF* tif, uint8* cp0, tmsize_t cc) 511 { 512 TIFFPredictorState* sp = PredictorState(tif); 513 tmsize_t stride = sp->stride; 514 uint16 *wp = (uint16*) cp0; 515 tmsize_t wc = cc/2; 516 517 assert((cc%(2*stride))==0); 518 519 if (wc > stride) { 520 wc -= stride; 521 wp += wc - 1; 522 do { 523 REPEAT4(stride, wp[stride] = (uint16)(((unsigned int)wp[stride] - (unsigned int)wp[0]) & 0xffff); wp--) 524 wc -= stride; 525 } while (wc > 0); 526 } 527 } 528 529 static void 530 swabHorDiff16(TIFF* tif, uint8* cp0, tmsize_t cc) 531 { 532 uint16* wp = (uint16*) cp0; 533 tmsize_t wc = cc / 2; 534 535 horDiff16(tif, cp0, cc); 536 537 TIFFSwabArrayOfShort(wp, wc); 538 } 539 540 static void 541 horDiff32(TIFF* tif, uint8* cp0, tmsize_t cc) 542 { 543 TIFFPredictorState* sp = PredictorState(tif); 544 tmsize_t stride = sp->stride; 545 uint32 *wp = (uint32*) cp0; 546 tmsize_t wc = cc/4; 547 548 assert((cc%(4*stride))==0); 549 550 if (wc > stride) { 551 wc -= stride; 552 wp += wc - 1; 553 do { 554 REPEAT4(stride, wp[stride] -= wp[0]; wp--) 555 wc -= stride; 556 } while (wc > 0); 557 } 558 } 559 560 static void 561 swabHorDiff32(TIFF* tif, uint8* cp0, tmsize_t cc) 562 { 563 uint32* wp = (uint32*) cp0; 564 tmsize_t wc = cc / 4; 565 566 horDiff32(tif, cp0, cc); 567 568 TIFFSwabArrayOfLong(wp, wc); 569 } 570 571 /* 572 * Floating point predictor differencing routine. 573 */ 574 static void 575 fpDiff(TIFF* tif, uint8* cp0, tmsize_t cc) 576 { 577 tmsize_t stride = PredictorState(tif)->stride; 578 uint32 bps = tif->tif_dir.td_bitspersample / 8; 579 tmsize_t wc = cc / bps; 580 tmsize_t count; 581 uint8 *cp = (uint8 *) cp0; 582 uint8 *tmp = (uint8 *)_TIFFmalloc(cc); 583 584 assert((cc%(bps*stride))==0); 585 586 if (!tmp) 587 return; 588 589 _TIFFmemcpy(tmp, cp0, cc); 590 for (count = 0; count < wc; count++) { 591 uint32 byte; 592 for (byte = 0; byte < bps; byte++) { 593 #if WORDS_BIGENDIAN 594 cp[byte * wc + count] = tmp[bps * count + byte]; 595 #else 596 cp[(bps - byte - 1) * wc + count] = 597 tmp[bps * count + byte]; 598 #endif 599 } 600 } 601 _TIFFfree(tmp); 602 603 cp = (uint8 *) cp0; 604 cp += cc - stride - 1; 605 for (count = cc; count > stride; count -= stride) 606 REPEAT4(stride, cp[stride] = (unsigned char)((cp[stride] - cp[0])&0xff); cp--) 607 } 608 609 static int 610 PredictorEncodeRow(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) 611 { 612 TIFFPredictorState *sp = PredictorState(tif); 613 614 assert(sp != NULL); 615 assert(sp->encodepfunc != NULL); 616 assert(sp->encoderow != NULL); 617 618 /* XXX horizontal differencing alters user's data XXX */ 619 (*sp->encodepfunc)(tif, bp, cc); 620 return (*sp->encoderow)(tif, bp, cc, s); 621 } 622 623 static int 624 PredictorEncodeTile(TIFF* tif, uint8* bp0, tmsize_t cc0, uint16 s) 625 { 626 static const char module[] = "PredictorEncodeTile"; 627 TIFFPredictorState *sp = PredictorState(tif); 628 uint8 *working_copy; 629 tmsize_t cc = cc0, rowsize; 630 unsigned char* bp; 631 int result_code; 632 633 assert(sp != NULL); 634 assert(sp->encodepfunc != NULL); 635 assert(sp->encodetile != NULL); 636 637 /* 638 * Do predictor manipulation in a working buffer to avoid altering 639 * the callers buffer. http://trac.osgeo.org/gdal/ticket/1965 640 */ 641 working_copy = (uint8*) _TIFFmalloc(cc0); 642 if( working_copy == NULL ) 643 { 644 TIFFErrorExt(tif->tif_clientdata, module, 645 "Out of memory allocating " TIFF_SSIZE_FORMAT " byte temp buffer.", 646 cc0 ); 647 return 0; 648 } 649 memcpy( working_copy, bp0, cc0 ); 650 bp = working_copy; 651 652 rowsize = sp->rowsize; 653 assert(rowsize > 0); 654 assert((cc0%rowsize)==0); 655 while (cc > 0) { 656 (*sp->encodepfunc)(tif, bp, rowsize); 657 cc -= rowsize; 658 bp += rowsize; 659 } 660 result_code = (*sp->encodetile)(tif, working_copy, cc0, s); 661 662 _TIFFfree( working_copy ); 663 664 return result_code; 665 } 666 667 #define FIELD_PREDICTOR (FIELD_CODEC+0) /* XXX */ 668 669 static const TIFFField predictFields[] = { 670 { TIFFTAG_PREDICTOR, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UINT16, FIELD_PREDICTOR, FALSE, FALSE, "Predictor", NULL }, 671 }; 672 673 static int 674 PredictorVSetField(TIFF* tif, uint32 tag, va_list ap) 675 { 676 TIFFPredictorState *sp = PredictorState(tif); 677 678 assert(sp != NULL); 679 assert(sp->vsetparent != NULL); 680 681 switch (tag) { 682 case TIFFTAG_PREDICTOR: 683 sp->predictor = (uint16) va_arg(ap, uint16_vap); 684 TIFFSetFieldBit(tif, FIELD_PREDICTOR); 685 break; 686 default: 687 return (*sp->vsetparent)(tif, tag, ap); 688 } 689 tif->tif_flags |= TIFF_DIRTYDIRECT; 690 return 1; 691 } 692 693 static int 694 PredictorVGetField(TIFF* tif, uint32 tag, va_list ap) 695 { 696 TIFFPredictorState *sp = PredictorState(tif); 697 698 assert(sp != NULL); 699 assert(sp->vgetparent != NULL); 700 701 switch (tag) { 702 case TIFFTAG_PREDICTOR: 703 *va_arg(ap, uint16*) = sp->predictor; 704 break; 705 default: 706 return (*sp->vgetparent)(tif, tag, ap); 707 } 708 return 1; 709 } 710 711 static void 712 PredictorPrintDir(TIFF* tif, FILE* fd, long flags) 713 { 714 TIFFPredictorState* sp = PredictorState(tif); 715 716 (void) flags; 717 if (TIFFFieldSet(tif,FIELD_PREDICTOR)) { 718 fprintf(fd, " Predictor: "); 719 switch (sp->predictor) { 720 case 1: fprintf(fd, "none "); break; 721 case 2: fprintf(fd, "horizontal differencing "); break; 722 case 3: fprintf(fd, "floating point predictor "); break; 723 } 724 fprintf(fd, "%u (0x%x)\n", sp->predictor, sp->predictor); 725 } 726 if (sp->printdir) 727 (*sp->printdir)(tif, fd, flags); 728 } 729 730 int 731 TIFFPredictorInit(TIFF* tif) 732 { 733 TIFFPredictorState* sp = PredictorState(tif); 734 735 assert(sp != 0); 736 737 /* 738 * Merge codec-specific tag information. 739 */ 740 if (!_TIFFMergeFields(tif, predictFields, 741 TIFFArrayCount(predictFields))) { 742 TIFFErrorExt(tif->tif_clientdata, "TIFFPredictorInit", 743 "Merging Predictor codec-specific tags failed"); 744 return 0; 745 } 746 747 /* 748 * Override parent get/set field methods. 749 */ 750 sp->vgetparent = tif->tif_tagmethods.vgetfield; 751 tif->tif_tagmethods.vgetfield = 752 PredictorVGetField;/* hook for predictor tag */ 753 sp->vsetparent = tif->tif_tagmethods.vsetfield; 754 tif->tif_tagmethods.vsetfield = 755 PredictorVSetField;/* hook for predictor tag */ 756 sp->printdir = tif->tif_tagmethods.printdir; 757 tif->tif_tagmethods.printdir = 758 PredictorPrintDir; /* hook for predictor tag */ 759 760 sp->setupdecode = tif->tif_setupdecode; 761 tif->tif_setupdecode = PredictorSetupDecode; 762 sp->setupencode = tif->tif_setupencode; 763 tif->tif_setupencode = PredictorSetupEncode; 764 765 sp->predictor = 1; /* default value */ 766 sp->encodepfunc = NULL; /* no predictor routine */ 767 sp->decodepfunc = NULL; /* no predictor routine */ 768 return 1; 769 } 770 771 int 772 TIFFPredictorCleanup(TIFF* tif) 773 { 774 TIFFPredictorState* sp = PredictorState(tif); 775 776 assert(sp != 0); 777 778 tif->tif_tagmethods.vgetfield = sp->vgetparent; 779 tif->tif_tagmethods.vsetfield = sp->vsetparent; 780 tif->tif_tagmethods.printdir = sp->printdir; 781 tif->tif_setupdecode = sp->setupdecode; 782 tif->tif_setupencode = sp->setupencode; 783 784 return 1; 785 } 786 787 /* vim: set ts=8 sts=8 sw=8 noet: */ 788 /* 789 * Local Variables: 790 * mode: c 791 * c-basic-offset: 8 792 * fill-column: 78 793 * End: 794 */ 795
