ReactOS 0.4.16-dev-2617-g01a0906
tif_predict.c File Reference
#include "tif_predict.h"
#include "tiffiop.h"
Include dependency graph for tif_predict.c:

Go to the source code of this file.

Macros

#define PredictorState(tif)   ((TIFFPredictorState *)(tif)->tif_data)
 
#define REPEAT4(n, op)
 
#define OP
 
#define FIELD_PREDICTOR   (FIELD_CODEC + 0) /* XXX */
 

Functions

static int horAcc8 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int horAcc16 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int horAcc32 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int horAcc64 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int swabHorAcc16 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int swabHorAcc32 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int swabHorAcc64 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int horDiff8 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int horDiff16 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int horDiff32 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int horDiff64 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int swabHorDiff16 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int swabHorDiff32 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int swabHorDiff64 (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int fpAcc (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int fpDiff (TIFF *tif, uint8_t *cp0, tmsize_t cc)
 
static int PredictorDecodeRow (TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
 
static int PredictorDecodeTile (TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
 
static int PredictorEncodeRow (TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
 
static int PredictorEncodeTile (TIFF *tif, uint8_t *bp0, tmsize_t cc0, uint16_t s)
 
static int PredictorSetup (TIFF *tif)
 
static int PredictorSetupDecode (TIFF *tif)
 
static int PredictorSetupEncode (TIFF *tif)
 
static int PredictorVSetField (TIFF *tif, uint32_t tag, va_list ap)
 
static int PredictorVGetField (TIFF *tif, uint32_t tag, va_list ap)
 
static void PredictorPrintDir (TIFF *tif, FILE *fd, long flags)
 
int TIFFPredictorInit (TIFF *tif)
 
int TIFFPredictorCleanup (TIFF *tif)
 

Variables

static const TIFFField predictFields []
 

Macro Definition Documentation

◆ FIELD_PREDICTOR

#define FIELD_PREDICTOR   (FIELD_CODEC + 0) /* XXX */

Definition at line 1037 of file tif_predict.c.

◆ OP

Value:
do \
{ \
cp[1] = (uint8_t)((cp[1] + cp[0]) & 0xff); \
++cp; \
} while (0)
POINT cp
Definition: magnifier.c:59
#define uint8_t
Definition: nsiface.idl:59

◆ PredictorState

#define PredictorState (   tif)    ((TIFFPredictorState *)(tif)->tif_data)

Definition at line 37 of file tif_predict.c.

◆ REPEAT4

#define REPEAT4 (   n,
  op 
)
Value:
switch (n) \
{ \
default: \
{ \
for (i = n - 4; i > 0; i--) \
{ \
op; \
} \
} /*-fallthrough*/ \
case 4: \
op; /*-fallthrough*/ \
case 3: \
op; /*-fallthrough*/ \
case 2: \
op; /*-fallthrough*/ \
case 1: \
op; /*-fallthrough*/ \
case 0:; \
}
UINT op
Definition: effect.c:236
GLdouble n
Definition: glext.h:7729
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:67

Definition at line 322 of file tif_predict.c.

Function Documentation

◆ fpAcc()

static int fpAcc ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 534 of file tif_predict.c.

535{
536 tmsize_t stride = PredictorState(tif)->stride;
537 uint32_t bps = tif->tif_dir.td_bitspersample / 8;
538 tmsize_t wc = cc / bps;
539 tmsize_t count = cc;
540 uint8_t *cp = cp0;
541 uint8_t *tmp;
542
543 if (cc % (bps * stride) != 0)
544 {
545 TIFFErrorExtR(tif, "fpAcc", "%s", "cc%(bps*stride))!=0");
546 return 0;
547 }
548
549 tmp = (uint8_t *)_TIFFmallocExt(tif, cc);
550 if (!tmp)
551 return 0;
552
553 if (stride == 1)
554 {
555 /* Optimization of general case */
556#define OP \
557 do \
558 { \
559 cp[1] = (uint8_t)((cp[1] + cp[0]) & 0xff); \
560 ++cp; \
561 } while (0)
562 for (; count > 8; count -= 8)
563 {
564 OP;
565 OP;
566 OP;
567 OP;
568 OP;
569 OP;
570 OP;
571 OP;
572 }
573 for (; count > 1; count -= 1)
574 {
575 OP;
576 }
577#undef OP
578 }
579 else
580 {
581 while (count > stride)
582 {
583 REPEAT4(stride, cp[stride] = (uint8_t)((cp[stride] + cp[0]) & 0xff);
584 cp++)
585 count -= stride;
586 }
587 }
588
589 _TIFFmemcpy(tmp, cp0, cc);
590 cp = (uint8_t *)cp0;
591 count = 0;
592
593#if (defined(__x86_64__) || defined(_M_X64)) && !defined(__arm64ec__)
594 if (bps == 4)
595 {
596 /* Optimization of general case */
597 for (; count + 15 < wc; count += 16)
598 {
599 /* Interlace 4*16 byte values */
600
601 __m128i xmm0 =
602 _mm_loadu_si128((const __m128i *)(tmp + count + 3 * wc));
603 __m128i xmm1 =
604 _mm_loadu_si128((const __m128i *)(tmp + count + 2 * wc));
605 __m128i xmm2 =
606 _mm_loadu_si128((const __m128i *)(tmp + count + 1 * wc));
607 __m128i xmm3 =
608 _mm_loadu_si128((const __m128i *)(tmp + count + 0 * wc));
609 /* (xmm0_0, xmm1_0, xmm0_1, xmm1_1, xmm0_2, xmm1_2, ...) */
610 __m128i tmp0 = _mm_unpacklo_epi8(xmm0, xmm1);
611 /* (xmm0_8, xmm1_8, xmm0_9, xmm1_9, xmm0_10, xmm1_10, ...) */
612 __m128i tmp1 = _mm_unpackhi_epi8(xmm0, xmm1);
613 /* (xmm2_0, xmm3_0, xmm2_1, xmm3_1, xmm2_2, xmm3_2, ...) */
614 __m128i tmp2 = _mm_unpacklo_epi8(xmm2, xmm3);
615 /* (xmm2_8, xmm3_8, xmm2_9, xmm3_9, xmm2_10, xmm3_10, ...) */
616 __m128i tmp3 = _mm_unpackhi_epi8(xmm2, xmm3);
617 /* (xmm0_0, xmm1_0, xmm2_0, xmm3_0, xmm0_1, xmm1_1, xmm2_1, xmm3_1,
618 * ...) */
619 __m128i tmp2_0 = _mm_unpacklo_epi16(tmp0, tmp2);
620 __m128i tmp2_1 = _mm_unpackhi_epi16(tmp0, tmp2);
621 __m128i tmp2_2 = _mm_unpacklo_epi16(tmp1, tmp3);
622 __m128i tmp2_3 = _mm_unpackhi_epi16(tmp1, tmp3);
623 _mm_storeu_si128((__m128i *)(cp + 4 * count + 0 * 16), tmp2_0);
624 _mm_storeu_si128((__m128i *)(cp + 4 * count + 1 * 16), tmp2_1);
625 _mm_storeu_si128((__m128i *)(cp + 4 * count + 2 * 16), tmp2_2);
626 _mm_storeu_si128((__m128i *)(cp + 4 * count + 3 * 16), tmp2_3);
627 }
628 }
629#endif
630
631 for (; count < wc; count++)
632 {
634 for (byte = 0; byte < bps; byte++)
635 {
636#if WORDS_BIGENDIAN
637 cp[bps * count + byte] = tmp[byte * wc + count];
638#else
639 cp[bps * count + byte] = tmp[(bps - byte - 1) * wc + count];
640#endif
641 }
642 }
643 _TIFFfreeExt(tif, tmp);
644 return 1;
645}
UINT32 uint32_t
Definition: types.h:75
unsigned char uint8_t
Definition: stdint.h:33
#define byte(x, n)
Definition: tomcrypt.h:118
void _mm_storeu_si128(__m128i_u *p, __m128i b)
Definition: emmintrin.h:1684
__m128i _mm_unpackhi_epi16(__m128i a, __m128i b)
Definition: emmintrin.h:1813
__m128i _mm_unpackhi_epi8(__m128i a, __m128i b)
Definition: emmintrin.h:1802
__m128i _mm_unpacklo_epi16(__m128i a, __m128i b)
Definition: emmintrin.h:1853
__m128i _mm_unpacklo_epi8(__m128i a, __m128i b)
Definition: emmintrin.h:1842
__m128i _mm_loadu_si128(__m128i_u const *p)
Definition: emmintrin.h:1561
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizei stride
Definition: glext.h:5848
uint32_t cc
Definition: isohybrid.c:75
uint16_t td_bitspersample
Definition: tif_dir.h:86
TIFFDirectory tif_dir
Definition: tiffiop.h:157
void TIFFErrorExtR(TIFF *tif, const char *module, const char *fmt,...)
Definition: tif_error.c:107
void _TIFFfreeExt(TIFF *tif, void *p)
Definition: tif_open.c:275
void * _TIFFmallocExt(TIFF *tif, tmsize_t s)
Definition: tif_open.c:173
#define PredictorState(tif)
Definition: tif_predict.c:37
#define REPEAT4(n, op)
Definition: tif_predict.c:322
#define OP
void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
Definition: tif_unix.c:355

Referenced by PredictorSetupDecode().

◆ fpDiff()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int fpDiff ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 908 of file tif_predict.c.

909{
910 tmsize_t stride = PredictorState(tif)->stride;
911 uint32_t bps = tif->tif_dir.td_bitspersample / 8;
912 tmsize_t wc = cc / bps;
914 uint8_t *cp = (uint8_t *)cp0;
915 uint8_t *tmp;
916
917 if ((cc % (bps * stride)) != 0)
918 {
919 TIFFErrorExtR(tif, "fpDiff", "%s", "(cc%(bps*stride))!=0");
920 return 0;
921 }
922
923 tmp = (uint8_t *)_TIFFmallocExt(tif, cc);
924 if (!tmp)
925 return 0;
926
927 _TIFFmemcpy(tmp, cp0, cc);
928 for (count = 0; count < wc; count++)
929 {
931 for (byte = 0; byte < bps; byte++)
932 {
933#if WORDS_BIGENDIAN
934 cp[byte * wc + count] = tmp[bps * count + byte];
935#else
936 cp[(bps - byte - 1) * wc + count] = tmp[bps * count + byte];
937#endif
938 }
939 }
940 _TIFFfreeExt(tif, tmp);
941
942 cp = (uint8_t *)cp0;
943 cp += cc - stride - 1;
944 for (count = cc; count > stride; count -= stride)
946 cp[stride] = (unsigned char)((cp[stride] - cp[0]) & 0xff);
947 cp--)
948 return 1;
949}

Referenced by PredictorSetupEncode().

◆ horAcc16()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int horAcc16 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 436 of file tif_predict.c.

437{
438 tmsize_t stride = PredictorState(tif)->stride;
439 uint16_t *wp = (uint16_t *)cp0;
440 tmsize_t wc = cc / 2;
441
442 if ((cc % (2 * stride)) != 0)
443 {
444 TIFFErrorExtR(tif, "horAcc16", "%s", "cc%(2*stride))!=0");
445 return 0;
446 }
447
448 if (wc > stride)
449 {
450 wc -= stride;
451 do
452 {
453 REPEAT4(stride, wp[stride] = (uint16_t)(((unsigned int)wp[stride] +
454 (unsigned int)wp[0]) &
455 0xffff);
456 wp++)
457 wc -= stride;
458 } while (wc > 0);
459 }
460 return 1;
461}
unsigned short uint16_t
Definition: stdint.h:35

Referenced by PredictorSetupDecode(), and swabHorAcc16().

◆ horAcc32()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int horAcc32 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 473 of file tif_predict.c.

474{
475 tmsize_t stride = PredictorState(tif)->stride;
476 uint32_t *wp = (uint32_t *)cp0;
477 tmsize_t wc = cc / 4;
478
479 if ((cc % (4 * stride)) != 0)
480 {
481 TIFFErrorExtR(tif, "horAcc32", "%s", "cc%(4*stride))!=0");
482 return 0;
483 }
484
485 if (wc > stride)
486 {
487 wc -= stride;
488 do
489 {
490 REPEAT4(stride, wp[stride] += wp[0]; wp++)
491 wc -= stride;
492 } while (wc > 0);
493 }
494 return 1;
495}

Referenced by PredictorSetupDecode(), and swabHorAcc32().

◆ horAcc64()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int horAcc64 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 507 of file tif_predict.c.

508{
509 tmsize_t stride = PredictorState(tif)->stride;
510 uint64_t *wp = (uint64_t *)cp0;
511 tmsize_t wc = cc / 8;
512
513 if ((cc % (8 * stride)) != 0)
514 {
515 TIFFErrorExtR(tif, "horAcc64", "%s", "cc%(8*stride))!=0");
516 return 0;
517 }
518
519 if (wc > stride)
520 {
521 wc -= stride;
522 do
523 {
524 REPEAT4(stride, wp[stride] += wp[0]; wp++)
525 wc -= stride;
526 } while (wc > 0);
527 }
528 return 1;
529}
UINT64 uint64_t
Definition: types.h:77

Referenced by PredictorSetupDecode(), and swabHorAcc64().

◆ horAcc8()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int horAcc8 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 351 of file tif_predict.c.

352{
353 tmsize_t stride = PredictorState(tif)->stride;
354
355 uint8_t *cp = cp0;
356 if ((cc % stride) != 0)
357 {
358 TIFFErrorExtR(tif, "horAcc8", "%s", "(cc%stride)!=0");
359 return 0;
360 }
361
362 if (cc > stride)
363 {
364 /*
365 * Pipeline the most common cases.
366 */
367 if (stride == 1)
368 {
369 uint32_t acc = cp[0];
370 tmsize_t i = stride;
371 for (; i < cc - 3; i += 4)
372 {
373 cp[i + 0] = (uint8_t)((acc += cp[i + 0]) & 0xff);
374 cp[i + 1] = (uint8_t)((acc += cp[i + 1]) & 0xff);
375 cp[i + 2] = (uint8_t)((acc += cp[i + 2]) & 0xff);
376 cp[i + 3] = (uint8_t)((acc += cp[i + 3]) & 0xff);
377 }
378 for (; i < cc; i++)
379 {
380 cp[i + 0] = (uint8_t)((acc += cp[i + 0]) & 0xff);
381 }
382 }
383 else if (stride == 3)
384 {
385 uint32_t cr = cp[0];
386 uint32_t cg = cp[1];
387 uint32_t cb = cp[2];
388 tmsize_t i = stride;
389 for (; i < cc; i += stride)
390 {
391 cp[i + 0] = (uint8_t)((cr += cp[i + 0]) & 0xff);
392 cp[i + 1] = (uint8_t)((cg += cp[i + 1]) & 0xff);
393 cp[i + 2] = (uint8_t)((cb += cp[i + 2]) & 0xff);
394 }
395 }
396 else if (stride == 4)
397 {
398 uint32_t cr = cp[0];
399 uint32_t cg = cp[1];
400 uint32_t cb = cp[2];
401 uint32_t ca = cp[3];
402 tmsize_t i = stride;
403 for (; i < cc; i += stride)
404 {
405 cp[i + 0] = (uint8_t)((cr += cp[i + 0]) & 0xff);
406 cp[i + 1] = (uint8_t)((cg += cp[i + 1]) & 0xff);
407 cp[i + 2] = (uint8_t)((cb += cp[i + 2]) & 0xff);
408 cp[i + 3] = (uint8_t)((ca += cp[i + 3]) & 0xff);
409 }
410 }
411 else
412 {
413 cc -= stride;
414 do
415 {
417 cp[stride] = (uint8_t)((cp[stride] + *cp) & 0xff);
418 cp++)
419 cc -= stride;
420 } while (cc > 0);
421 }
422 }
423 return 1;
424}
static const WCHAR ca[]
Definition: main.c:457
static MonoProfilerRuntimeShutdownBeginCallback cb
Definition: metahost.c:118

Referenced by PredictorSetupDecode().

◆ horDiff16()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int horDiff16 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 785 of file tif_predict.c.

786{
788 tmsize_t stride = sp->stride;
789 uint16_t *wp = (uint16_t *)cp0;
790 tmsize_t wc = cc / 2;
791
792 if ((cc % (2 * stride)) != 0)
793 {
794 TIFFErrorExtR(tif, "horDiff8", "%s", "(cc%(2*stride))!=0");
795 return 0;
796 }
797
798 if (wc > stride)
799 {
800 wc -= stride;
801 wp += wc - 1;
802 do
803 {
804 REPEAT4(stride, wp[stride] = (uint16_t)(((unsigned int)wp[stride] -
805 (unsigned int)wp[0]) &
806 0xffff);
807 wp--)
808 wc -= stride;
809 } while (wc > 0);
810 }
811 return 1;
812}
static const WCHAR sp[]
Definition: suminfo.c:287

Referenced by PredictorSetupEncode(), and swabHorDiff16().

◆ horDiff32()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int horDiff32 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 827 of file tif_predict.c.

828{
830 tmsize_t stride = sp->stride;
831 uint32_t *wp = (uint32_t *)cp0;
832 tmsize_t wc = cc / 4;
833
834 if ((cc % (4 * stride)) != 0)
835 {
836 TIFFErrorExtR(tif, "horDiff32", "%s", "(cc%(4*stride))!=0");
837 return 0;
838 }
839
840 if (wc > stride)
841 {
842 wc -= stride;
843 wp += wc - 1;
844 do
845 {
846 REPEAT4(stride, wp[stride] -= wp[0]; wp--)
847 wc -= stride;
848 } while (wc > 0);
849 }
850 return 1;
851}

Referenced by PredictorSetupEncode(), and swabHorDiff32().

◆ horDiff64()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int horDiff64 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 866 of file tif_predict.c.

867{
869 tmsize_t stride = sp->stride;
870 uint64_t *wp = (uint64_t *)cp0;
871 tmsize_t wc = cc / 8;
872
873 if ((cc % (8 * stride)) != 0)
874 {
875 TIFFErrorExtR(tif, "horDiff64", "%s", "(cc%(8*stride))!=0");
876 return 0;
877 }
878
879 if (wc > stride)
880 {
881 wc -= stride;
882 wp += wc - 1;
883 do
884 {
885 REPEAT4(stride, wp[stride] -= wp[0]; wp--)
886 wc -= stride;
887 } while (wc > 0);
888 }
889 return 1;
890}

Referenced by PredictorSetupEncode(), and swabHorDiff64().

◆ horDiff8()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW int horDiff8 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 707 of file tif_predict.c.

708{
710 tmsize_t stride = sp->stride;
711 unsigned char *cp = (unsigned char *)cp0;
712
713 if ((cc % stride) != 0)
714 {
715 TIFFErrorExtR(tif, "horDiff8", "%s", "(cc%stride)!=0");
716 return 0;
717 }
718
719 if (cc > stride)
720 {
721 cc -= stride;
722 /*
723 * Pipeline the most common cases.
724 */
725 if (stride == 3)
726 {
727 unsigned int r1, g1, b1;
728 unsigned int r2 = cp[0];
729 unsigned int g2 = cp[1];
730 unsigned int b2 = cp[2];
731 do
732 {
733 r1 = cp[3];
734 cp[3] = (unsigned char)((r1 - r2) & 0xff);
735 r2 = r1;
736 g1 = cp[4];
737 cp[4] = (unsigned char)((g1 - g2) & 0xff);
738 g2 = g1;
739 b1 = cp[5];
740 cp[5] = (unsigned char)((b1 - b2) & 0xff);
741 b2 = b1;
742 cp += 3;
743 } while ((cc -= 3) > 0);
744 }
745 else if (stride == 4)
746 {
747 unsigned int r1, g1, b1, a1;
748 unsigned int r2 = cp[0];
749 unsigned int g2 = cp[1];
750 unsigned int b2 = cp[2];
751 unsigned int a2 = cp[3];
752 do
753 {
754 r1 = cp[4];
755 cp[4] = (unsigned char)((r1 - r2) & 0xff);
756 r2 = r1;
757 g1 = cp[5];
758 cp[5] = (unsigned char)((g1 - g2) & 0xff);
759 g2 = g1;
760 b1 = cp[6];
761 cp[6] = (unsigned char)((b1 - b2) & 0xff);
762 b2 = b1;
763 a1 = cp[7];
764 cp[7] = (unsigned char)((a1 - a2) & 0xff);
765 a2 = a1;
766 cp += 4;
767 } while ((cc -= 4) > 0);
768 }
769 else
770 {
771 cp += cc - 1;
772 do
773 {
775 cp[stride] =
776 (unsigned char)((cp[stride] - cp[0]) & 0xff);
777 cp--)
778 } while ((cc -= stride) > 0);
779 }
780 }
781 return 1;
782}
unsigned char
Definition: typeof.h:29
static const struct update_accum a1
Definition: msg.c:534
static const struct update_accum a2
Definition: msg.c:542
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:538
static CRYPT_DATA_BLOB b1[]
Definition: msg.c:529
static DNS_RECORDW r1
Definition: record.c:37
static DNS_RECORDW r2
Definition: record.c:38

Referenced by PredictorSetupEncode().

◆ PredictorDecodeRow()

static int PredictorDecodeRow ( TIFF tif,
uint8_t op0,
tmsize_t  occ0,
uint16_t  s 
)
static

Definition at line 650 of file tif_predict.c.

652{
654
655 assert(sp != NULL);
656 assert(sp->decoderow != NULL);
657 assert(sp->decodepfunc != NULL);
658
659 if ((*sp->decoderow)(tif, op0, occ0, s))
660 {
661 return (*sp->decodepfunc)(tif, op0, occ0);
662 }
663 else
664 return 0;
665}
#define NULL
Definition: types.h:112
#define assert(_expr)
Definition: assert.h:32
GLdouble s
Definition: gl.h:2039

Referenced by PredictorSetupDecode().

◆ PredictorDecodeTile()

static int PredictorDecodeTile ( TIFF tif,
uint8_t op0,
tmsize_t  occ0,
uint16_t  s 
)
static

Definition at line 674 of file tif_predict.c.

676{
678
679 assert(sp != NULL);
680 assert(sp->decodetile != NULL);
681
682 if ((*sp->decodetile)(tif, op0, occ0, s))
683 {
684 tmsize_t rowsize = sp->rowsize;
685 assert(rowsize > 0);
686 if ((occ0 % rowsize) != 0)
687 {
688 TIFFErrorExtR(tif, "PredictorDecodeTile", "%s",
689 "occ0%rowsize != 0");
690 return 0;
691 }
692 assert(sp->decodepfunc != NULL);
693 while (occ0 > 0)
694 {
695 if (!(*sp->decodepfunc)(tif, op0, rowsize))
696 return 0;
697 occ0 -= rowsize;
698 op0 += rowsize;
699 }
700 return 1;
701 }
702 else
703 return 0;
704}

Referenced by PredictorSetupDecode().

◆ PredictorEncodeRow()

static int PredictorEncodeRow ( TIFF tif,
uint8_t bp,
tmsize_t  cc,
uint16_t  s 
)
static

Definition at line 951 of file tif_predict.c.

952{
953 static const char module[] = "PredictorEncodeRow";
955 uint8_t *working_copy;
956 int result_code;
957
958 assert(sp != NULL);
959 assert(sp->encodepfunc != NULL);
960 assert(sp->encoderow != NULL);
961
962 /*
963 * Do predictor manipulation in a working buffer to avoid altering
964 * the callers buffer, like for PredictorEncodeTile().
965 * https://gitlab.com/libtiff/libtiff/-/issues/5
966 */
967 working_copy = (uint8_t *)_TIFFmallocExt(tif, cc);
968 if (working_copy == NULL)
969 {
971 "Out of memory allocating %" PRId64 " byte temp buffer.",
972 (int64_t)cc);
973 return 0;
974 }
975 memcpy(working_copy, bp, cc);
976
977 if (!(*sp->encodepfunc)(tif, working_copy, cc))
978 {
979 _TIFFfreeExt(tif, working_copy);
980 return 0;
981 }
982 result_code = (*sp->encoderow)(tif, working_copy, cc, s);
983 _TIFFfreeExt(tif, working_copy);
984 return result_code;
985}
INT64 int64_t
Definition: types.h:72
#define PRId64
Definition: inttypes.h:25
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878

Referenced by PredictorSetupEncode().

◆ PredictorEncodeTile()

static int PredictorEncodeTile ( TIFF tif,
uint8_t bp0,
tmsize_t  cc0,
uint16_t  s 
)
static

Definition at line 987 of file tif_predict.c.

989{
990 static const char module[] = "PredictorEncodeTile";
992 uint8_t *working_copy;
993 tmsize_t cc = cc0, rowsize;
994 unsigned char *bp;
995 int result_code;
996
997 assert(sp != NULL);
998 assert(sp->encodepfunc != NULL);
999 assert(sp->encodetile != NULL);
1000
1001 /*
1002 * Do predictor manipulation in a working buffer to avoid altering
1003 * the callers buffer. http://trac.osgeo.org/gdal/ticket/1965
1004 */
1005 working_copy = (uint8_t *)_TIFFmallocExt(tif, cc0);
1006 if (working_copy == NULL)
1007 {
1008 TIFFErrorExtR(tif, module,
1009 "Out of memory allocating %" PRId64 " byte temp buffer.",
1010 (int64_t)cc0);
1011 return 0;
1012 }
1013 memcpy(working_copy, bp0, cc0);
1014 bp = working_copy;
1015
1016 rowsize = sp->rowsize;
1017 assert(rowsize > 0);
1018 if ((cc0 % rowsize) != 0)
1019 {
1020 TIFFErrorExtR(tif, "PredictorEncodeTile", "%s", "(cc0%rowsize)!=0");
1021 _TIFFfreeExt(tif, working_copy);
1022 return 0;
1023 }
1024 while (cc > 0)
1025 {
1026 (*sp->encodepfunc)(tif, bp, rowsize);
1027 cc -= rowsize;
1028 bp += rowsize;
1029 }
1030 result_code = (*sp->encodetile)(tif, working_copy, cc0, s);
1031
1032 _TIFFfreeExt(tif, working_copy);
1033
1034 return result_code;
1035}

Referenced by PredictorSetupEncode().

◆ PredictorPrintDir()

static void PredictorPrintDir ( TIFF tif,
FILE fd,
long  flags 
)
static

Definition at line 1082 of file tif_predict.c.

1083{
1085
1086 (void)flags;
1087 if (TIFFFieldSet(tif, FIELD_PREDICTOR))
1088 {
1089 fprintf(fd, " Predictor: ");
1090 switch (sp->predictor)
1091 {
1092 case 1:
1093 fprintf(fd, "none ");
1094 break;
1095 case 2:
1096 fprintf(fd, "horizontal differencing ");
1097 break;
1098 case 3:
1099 fprintf(fd, "floating point predictor ");
1100 break;
1101 }
1102 fprintf(fd, "%d (0x%x)\n", sp->predictor, sp->predictor);
1103 }
1104 if (sp->printdir)
1105 (*sp->printdir)(tif, fd, flags);
1106}
int WINAPIV fprintf(FILE *file, const char *format,...)
Definition: file.c:5549
GLbitfield flags
Definition: glext.h:7161
static int fd
Definition: io.c:51
#define TIFFFieldSet(tif, field)
Definition: tif_dir.h:236
#define FIELD_PREDICTOR
Definition: tif_predict.c:1037

Referenced by TIFFPredictorInit().

◆ PredictorSetup()

static int PredictorSetup ( TIFF tif)
static

Definition at line 63 of file tif_predict.c.

64{
65 static const char module[] = "PredictorSetup";
66
68 TIFFDirectory *td = &tif->tif_dir;
69
70 switch (sp->predictor) /* no differencing */
71 {
72 case PREDICTOR_NONE:
73 return 1;
75 if (td->td_bitspersample != 8 && td->td_bitspersample != 16 &&
76 td->td_bitspersample != 32 && td->td_bitspersample != 64)
77 {
79 "Horizontal differencing \"Predictor\" not "
80 "supported with %" PRIu16 "-bit samples",
82 return 0;
83 }
84 break;
87 {
89 tif, module,
90 "Floating point \"Predictor\" not supported with %" PRIu16
91 " data format",
92 td->td_sampleformat);
93 return 0;
94 }
95 if (td->td_bitspersample != 16 && td->td_bitspersample != 24 &&
96 td->td_bitspersample != 32 && td->td_bitspersample != 64)
97 { /* Should 64 be allowed? */
99 tif, module,
100 "Floating point \"Predictor\" not supported with %" PRIu16
101 "-bit samples",
102 td->td_bitspersample);
103 return 0;
104 }
105 break;
106 default:
107 TIFFErrorExtR(tif, module, "\"Predictor\" value %d not supported",
108 sp->predictor);
109 return 0;
110 }
111 sp->stride =
113 : 1);
114 /*
115 * Calculate the scanline/tile-width size in bytes.
116 */
117 if (isTiled(tif))
118 sp->rowsize = TIFFTileRowSize(tif);
119 else
120 sp->rowsize = TIFFScanlineSize(tif);
121 if (sp->rowsize == 0)
122 return 0;
123
124 return 1;
125}
#define PRIu16
Definition: inttypes.h:83
uint16_t td_planarconfig
Definition: tif_dir.h:100
uint16_t td_sampleformat
Definition: tif_dir.h:87
uint16_t td_samplesperpixel
Definition: tif_dir.h:93
tmsize_t TIFFScanlineSize(TIFF *tif)
Definition: tif_strip.c:343
tmsize_t TIFFTileRowSize(TIFF *tif)
Definition: tif_tile.c:177
#define PREDICTOR_NONE
Definition: tiff.h:304
#define PREDICTOR_FLOATINGPOINT
Definition: tiff.h:306
#define SAMPLEFORMAT_IEEEFP
Definition: tiff.h:336
#define PREDICTOR_HORIZONTAL
Definition: tiff.h:305
#define PLANARCONFIG_CONTIG
Definition: tiff.h:265
#define isTiled(tif)
Definition: tiffiop.h:274

Referenced by PredictorSetupDecode(), and PredictorSetupEncode().

◆ PredictorSetupDecode()

static int PredictorSetupDecode ( TIFF tif)
static

Definition at line 127 of file tif_predict.c.

128{
130 TIFFDirectory *td = &tif->tif_dir;
131
132 /* Note: when PredictorSetup() fails, the effets of setupdecode() */
133 /* will not be "canceled" so setupdecode() might be robust to */
134 /* be called several times. */
135 if (!(*sp->setupdecode)(tif) || !PredictorSetup(tif))
136 return 0;
137
138 if (sp->predictor == 2)
139 {
140 switch (td->td_bitspersample)
141 {
142 case 8:
143 sp->decodepfunc = horAcc8;
144 break;
145 case 16:
146 sp->decodepfunc = horAcc16;
147 break;
148 case 32:
149 sp->decodepfunc = horAcc32;
150 break;
151 case 64:
152 sp->decodepfunc = horAcc64;
153 break;
154 }
155 /*
156 * Override default decoding method with one that does the
157 * predictor stuff.
158 */
160 {
161 sp->decoderow = tif->tif_decoderow;
163 sp->decodestrip = tif->tif_decodestrip;
165 sp->decodetile = tif->tif_decodetile;
167 }
168
169 /*
170 * If the data is horizontally differenced 16-bit data that
171 * requires byte-swapping, then it must be byte swapped before
172 * the accumulation step. We do this with a special-purpose
173 * routine and override the normal post decoding logic that
174 * the library setup when the directory was read.
175 */
176 if (tif->tif_flags & TIFF_SWAB)
177 {
178 if (sp->decodepfunc == horAcc16)
179 {
180 sp->decodepfunc = swabHorAcc16;
182 }
183 else if (sp->decodepfunc == horAcc32)
184 {
185 sp->decodepfunc = swabHorAcc32;
187 }
188 else if (sp->decodepfunc == horAcc64)
189 {
190 sp->decodepfunc = swabHorAcc64;
192 }
193 }
194 }
195
196 else if (sp->predictor == 3)
197 {
198 sp->decodepfunc = fpAcc;
199 /*
200 * Override default decoding method with one that does the
201 * predictor stuff.
202 */
204 {
205 sp->decoderow = tif->tif_decoderow;
207 sp->decodestrip = tif->tif_decodestrip;
209 sp->decodetile = tif->tif_decodetile;
211 }
212 /*
213 * The data should not be swapped outside of the floating
214 * point predictor, the accumulation routine should return
215 * bytes in the native order.
216 */
217 if (tif->tif_flags & TIFF_SWAB)
218 {
220 }
221 }
222
223 return 1;
224}
TIFFCodeMethod tif_decodestrip
Definition: tiffiop.h:207
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:239
TIFFCodeMethod tif_decoderow
Definition: tiffiop.h:205
uint32_t tif_flags
Definition: tiffiop.h:117
TIFFCodeMethod tif_decodetile
Definition: tiffiop.h:209
static int horAcc16(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:436
static int PredictorDecodeRow(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
Definition: tif_predict.c:650
static int swabHorAcc64(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:497
static int horAcc64(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:507
static int swabHorAcc16(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:426
static int fpAcc(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:534
static int horAcc8(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:351
static int swabHorAcc32(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:463
static int PredictorSetup(TIFF *tif)
Definition: tif_predict.c:63
static int horAcc32(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:473
static int PredictorDecodeTile(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
Definition: tif_predict.c:674
void _TIFFNoPostDecode(TIFF *tif, uint8_t *buf, tmsize_t cc)
Definition: tif_read.c:1648
#define TIFF_SWAB
Definition: tiffiop.h:124

Referenced by TIFFPredictorInit().

◆ PredictorSetupEncode()

static int PredictorSetupEncode ( TIFF tif)
static

Definition at line 226 of file tif_predict.c.

227{
229 TIFFDirectory *td = &tif->tif_dir;
230
231 if (!(*sp->setupencode)(tif) || !PredictorSetup(tif))
232 return 0;
233
234 if (sp->predictor == 2)
235 {
236 switch (td->td_bitspersample)
237 {
238 case 8:
239 sp->encodepfunc = horDiff8;
240 break;
241 case 16:
242 sp->encodepfunc = horDiff16;
243 break;
244 case 32:
245 sp->encodepfunc = horDiff32;
246 break;
247 case 64:
248 sp->encodepfunc = horDiff64;
249 break;
250 }
251 /*
252 * Override default encoding method with one that does the
253 * predictor stuff.
254 */
256 {
257 sp->encoderow = tif->tif_encoderow;
259 sp->encodestrip = tif->tif_encodestrip;
261 sp->encodetile = tif->tif_encodetile;
263 }
264
265 /*
266 * If the data is horizontally differenced 16-bit data that
267 * requires byte-swapping, then it must be byte swapped after
268 * the differentiation step. We do this with a special-purpose
269 * routine and override the normal post decoding logic that
270 * the library setup when the directory was read.
271 */
272 if (tif->tif_flags & TIFF_SWAB)
273 {
274 if (sp->encodepfunc == horDiff16)
275 {
276 sp->encodepfunc = swabHorDiff16;
278 }
279 else if (sp->encodepfunc == horDiff32)
280 {
281 sp->encodepfunc = swabHorDiff32;
283 }
284 else if (sp->encodepfunc == horDiff64)
285 {
286 sp->encodepfunc = swabHorDiff64;
288 }
289 }
290 }
291
292 else if (sp->predictor == 3)
293 {
294 sp->encodepfunc = fpDiff;
295 /*
296 * Override default encoding method with one that does the
297 * predictor stuff.
298 */
300 {
301 sp->encoderow = tif->tif_encoderow;
303 sp->encodestrip = tif->tif_encodestrip;
305 sp->encodetile = tif->tif_encodetile;
307 }
308 /*
309 * The data should not be swapped outside of the floating
310 * point predictor, the differentiation routine should return
311 * bytes in the native order.
312 */
313 if (tif->tif_flags & TIFF_SWAB)
314 {
316 }
317 }
318
319 return 1;
320}
TIFFCodeMethod tif_encodestrip
Definition: tiffiop.h:208
TIFFCodeMethod tif_encodetile
Definition: tiffiop.h:210
TIFFCodeMethod tif_encoderow
Definition: tiffiop.h:206
static int swabHorDiff16(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:814
static int horDiff16(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:785
static int horDiff32(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:827
static int fpDiff(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:908
static int horDiff64(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:866
static int horDiff8(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:707
static int swabHorDiff64(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:892
static int PredictorEncodeRow(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
Definition: tif_predict.c:951
static int swabHorDiff32(TIFF *tif, uint8_t *cp0, tmsize_t cc)
Definition: tif_predict.c:853
static int PredictorEncodeTile(TIFF *tif, uint8_t *bp0, tmsize_t cc0, uint16_t s)
Definition: tif_predict.c:987

Referenced by TIFFPredictorInit().

◆ PredictorVGetField()

static int PredictorVGetField ( TIFF tif,
uint32_t  tag,
va_list  ap 
)
static

Definition at line 1064 of file tif_predict.c.

1065{
1067
1068 assert(sp != NULL);
1069 assert(sp->vgetparent != NULL);
1070
1071 switch (tag)
1072 {
1073 case TIFFTAG_PREDICTOR:
1074 *va_arg(ap, uint16_t *) = (uint16_t)sp->predictor;
1075 break;
1076 default:
1077 return (*sp->vgetparent)(tif, tag, ap);
1078 }
1079 return 1;
1080}
return
Definition: dirsup.c:529
#define va_arg(v, l)
Definition: stdarg.h:27
#define uint16_t
Definition: nsiface.idl:60
Definition: ecma_167.h:138
#define TIFFTAG_PREDICTOR
Definition: tiff.h:303
void int int ULONGLONG int va_list * ap
Definition: winesup.h:36

Referenced by TIFFPredictorInit().

◆ PredictorVSetField()

static int PredictorVSetField ( TIFF tif,
uint32_t  tag,
va_list  ap 
)
static

Definition at line 1044 of file tif_predict.c.

1045{
1047
1048 assert(sp != NULL);
1049 assert(sp->vsetparent != NULL);
1050
1051 switch (tag)
1052 {
1053 case TIFFTAG_PREDICTOR:
1054 sp->predictor = (uint16_t)va_arg(ap, uint16_vap);
1056 break;
1057 default:
1058 return (*sp->vsetparent)(tif, tag, ap);
1059 }
1061 return 1;
1062}
#define TIFFSetFieldBit(tif, field)
Definition: tif_dir.h:237
int uint16_vap
Definition: tiff.h:100
#define TIFF_DIRTYDIRECT
Definition: tiffiop.h:120

Referenced by TIFFPredictorInit().

◆ swabHorAcc16()

static int swabHorAcc16 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 426 of file tif_predict.c.

427{
428 uint16_t *wp = (uint16_t *)cp0;
429 tmsize_t wc = cc / 2;
430
431 TIFFSwabArrayOfShort(wp, wc);
432 return horAcc16(tif, cp0, cc);
433}
void TIFFSwabArrayOfShort(register uint16_t *wp, tmsize_t n)
Definition: tif_swab.c:81

Referenced by PredictorSetupDecode().

◆ swabHorAcc32()

static int swabHorAcc32 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 463 of file tif_predict.c.

464{
465 uint32_t *wp = (uint32_t *)cp0;
466 tmsize_t wc = cc / 4;
467
468 TIFFSwabArrayOfLong(wp, wc);
469 return horAcc32(tif, cp0, cc);
470}
void TIFFSwabArrayOfLong(register uint32_t *lp, tmsize_t n)
Definition: tif_swab.c:117

Referenced by PredictorSetupDecode().

◆ swabHorAcc64()

static int swabHorAcc64 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 497 of file tif_predict.c.

498{
499 uint64_t *wp = (uint64_t *)cp0;
500 tmsize_t wc = cc / 8;
501
502 TIFFSwabArrayOfLong8(wp, wc);
503 return horAcc64(tif, cp0, cc);
504}
void TIFFSwabArrayOfLong8(register uint64_t *lp, tmsize_t n)
Definition: tif_swab.c:138

Referenced by PredictorSetupDecode().

◆ swabHorDiff16()

static int swabHorDiff16 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 814 of file tif_predict.c.

815{
816 uint16_t *wp = (uint16_t *)cp0;
817 tmsize_t wc = cc / 2;
818
819 if (!horDiff16(tif, cp0, cc))
820 return 0;
821
822 TIFFSwabArrayOfShort(wp, wc);
823 return 1;
824}

Referenced by PredictorSetupEncode().

◆ swabHorDiff32()

static int swabHorDiff32 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 853 of file tif_predict.c.

854{
855 uint32_t *wp = (uint32_t *)cp0;
856 tmsize_t wc = cc / 4;
857
858 if (!horDiff32(tif, cp0, cc))
859 return 0;
860
861 TIFFSwabArrayOfLong(wp, wc);
862 return 1;
863}

Referenced by PredictorSetupEncode().

◆ swabHorDiff64()

static int swabHorDiff64 ( TIFF tif,
uint8_t cp0,
tmsize_t  cc 
)
static

Definition at line 892 of file tif_predict.c.

893{
894 uint64_t *wp = (uint64_t *)cp0;
895 tmsize_t wc = cc / 8;
896
897 if (!horDiff64(tif, cp0, cc))
898 return 0;
899
900 TIFFSwabArrayOfLong8(wp, wc);
901 return 1;
902}

Referenced by PredictorSetupEncode().

◆ TIFFPredictorCleanup()

int TIFFPredictorCleanup ( TIFF tif)

Definition at line 1148 of file tif_predict.c.

1149{
1151
1152 assert(sp != 0);
1153
1154 tif->tif_tagmethods.vgetfield = sp->vgetparent;
1155 tif->tif_tagmethods.vsetfield = sp->vsetparent;
1156 tif->tif_tagmethods.printdir = sp->printdir;
1157 tif->tif_setupdecode = sp->setupdecode;
1158 tif->tif_setupencode = sp->setupencode;
1159
1160 return 1;
1161}
TIFFVGetMethod vgetfield
Definition: tiffio.h:376
TIFFVSetMethod vsetfield
Definition: tiffio.h:375
TIFFPrintMethod printdir
Definition: tiffio.h:377
TIFFTagMethods tif_tagmethods
Definition: tiffiop.h:244
TIFFBoolMethod tif_setupencode
Definition: tiffiop.h:201
TIFFBoolMethod tif_setupdecode
Definition: tiffiop.h:199

◆ TIFFPredictorInit()

int TIFFPredictorInit ( TIFF tif)

Definition at line 1108 of file tif_predict.c.

1109{
1111
1112 assert(sp != 0);
1113
1114 /*
1115 * Merge codec-specific tag information.
1116 */
1118 {
1119 TIFFErrorExtR(tif, "TIFFPredictorInit",
1120 "Merging Predictor codec-specific tags failed");
1121 return 0;
1122 }
1123
1124 /*
1125 * Override parent get/set field methods.
1126 */
1127 sp->vgetparent = tif->tif_tagmethods.vgetfield;
1129 PredictorVGetField; /* hook for predictor tag */
1130 sp->vsetparent = tif->tif_tagmethods.vsetfield;
1132 PredictorVSetField; /* hook for predictor tag */
1133 sp->printdir = tif->tif_tagmethods.printdir;
1135 PredictorPrintDir; /* hook for predictor tag */
1136
1137 sp->setupdecode = tif->tif_setupdecode;
1139 sp->setupencode = tif->tif_setupencode;
1141
1142 sp->predictor = 1; /* default value */
1143 sp->encodepfunc = NULL; /* no predictor routine */
1144 sp->decodepfunc = NULL; /* no predictor routine */
1145 return 1;
1146}
int _TIFFMergeFields(TIFF *tif, const TIFFField info[], uint32_t n)
Definition: tif_dirinfo.c:573
static void PredictorPrintDir(TIFF *tif, FILE *fd, long flags)
Definition: tif_predict.c:1082
static int PredictorSetupDecode(TIFF *tif)
Definition: tif_predict.c:127
static int PredictorSetupEncode(TIFF *tif)
Definition: tif_predict.c:226
static const TIFFField predictFields[]
Definition: tif_predict.c:1039
static int PredictorVGetField(TIFF *tif, uint32_t tag, va_list ap)
Definition: tif_predict.c:1064
static int PredictorVSetField(TIFF *tif, uint32_t tag, va_list ap)
Definition: tif_predict.c:1044
#define TIFFArrayCount(a)
Definition: tiffiop.h:333

Variable Documentation

◆ predictFields

const TIFFField predictFields[]
static
Initial value:
= {
FIELD_PREDICTOR, FALSE, FALSE, "Predictor", NULL},
}
#define FALSE
Definition: types.h:117
@ TIFF_SETGET_UINT16
Definition: tif_dir.h:249
@ TIFF_SHORT
Definition: tiff.h:150

Definition at line 1039 of file tif_predict.c.

Referenced by TIFFPredictorInit().