]> git.saurik.com Git - wxWidgets.git/blob - src/tiff/libtiff/tif_predict.c
projects / wxWidgets.git / blob
? search:


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