dll/3rdparty/libtiff/tif_predict.c

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