XFA: Upgrade to libtiff 4.0.6.

third_party/libtiff/tif_predict.c

-/* $Id: tif_predict.c,v 1.32 2010-03-10 18:56:49 bfriesen Exp $ */
+/* $Id: tif_predict.c,v 1.35 2015-08-31 15:05:57 erouault Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  *
  * Permission to use, copy, modify, distribute, and sell this software and 
  * its documentation for any purpose is hereby granted without fee, provided
  * that (i) the above copyright notices and this permission notice appear in
  * all copies of the software and related documentation, and (ii) the names of
  * Sam Leffler and Silicon Graphics may not be used in any advertising or
@@ skipping 23 matching lines @@
 #define PredictorState(tif)     ((TIFFPredictorState*) (tif)->tif_data)
 
 static void horAcc8(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void horAcc16(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void horAcc32(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void swabHorAcc16(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void swabHorAcc32(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void horDiff8(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void horDiff16(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void horDiff32(TIFF* tif, uint8* cp0, tmsize_t cc);
+static void swabHorDiff16(TIFF* tif, uint8* cp0, tmsize_t cc);
+static void swabHorDiff32(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void fpAcc(TIFF* tif, uint8* cp0, tmsize_t cc);
 static void fpDiff(TIFF* tif, uint8* cp0, tmsize_t cc);
 static int PredictorDecodeRow(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s);
 static int PredictorDecodeTile(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s);
 static int PredictorEncodeRow(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
 static int PredictorEncodeTile(TIFF* tif, uint8* bp0, tmsize_t cc0, uint16 s);
 
 static int
 PredictorSetup(TIFF* tif)
 {
@@ skipping 145 matching lines @@
                  */
                 if( tif->tif_encoderow != PredictorEncodeRow )
                 {
                     sp->encoderow = tif->tif_encoderow;
                     tif->tif_encoderow = PredictorEncodeRow;
                     sp->encodestrip = tif->tif_encodestrip;
                     tif->tif_encodestrip = PredictorEncodeTile;
                     sp->encodetile = tif->tif_encodetile;
                     tif->tif_encodetile = PredictorEncodeTile;
                 }
-        }
+
+                /*
+                 * If the data is horizontally differenced 16-bit data that
+                 * requires byte-swapping, then it must be byte swapped after
+                 * the differenciation step.  We do this with a special-purpose
+                 * routine and override the normal post decoding logic that
+                 * the library setup when the directory was read.
+                 */
+                if (tif->tif_flags & TIFF_SWAB) {
+                    if (sp->encodepfunc == horDiff16) {
+                            sp->encodepfunc = swabHorDiff16;
+                            tif->tif_postdecode = _TIFFNoPostDecode;
+                    } else if (sp->encodepfunc == horDiff32) {
+                            sp->encodepfunc = swabHorDiff32;
+                            tif->tif_postdecode = _TIFFNoPostDecode;
+                    }
+                }
+        }
 
         else if (sp->predictor == 3) {
                 sp->encodepfunc = fpDiff;
                 /*
                  * Override default encoding method with one that does the
                  * predictor stuff.
                  */
                 if( tif->tif_encoderow != PredictorEncodeRow )
                 {
                     sp->encoderow = tif->tif_encoderow;
@@ skipping 11 matching lines @@
 #define REPEAT4(n, op)          \
     switch (n) {                \
     default: { tmsize_t i; for (i = n-4; i > 0; i--) { op; } } \
     case 4:  op;                \
     case 3:  op;                \
     case 2:  op;                \
     case 1:  op;                \
     case 0:  ;                  \
     }
 
+/* Remarks related to C standard compliance in all below functions : */
+/* - to avoid any undefined behaviour, we only operate on unsigned types */
+/*   since the behaviour of "overflows" is defined (wrap over) */
+/* - when storing into the byte stream, we explicitly mask with 0xff so */
+/*   as to make icc -check=conversions happy (not necessary by the standard) */
+
 static void
 horAcc8(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
-        /*
-         * compare v4.0.3 with v3.9.5, 
-         * we find that horAcc8 uses while loop in the v4.0.3 and uses do while loop in the v3.9.5.
-         * times of do while loop are less than while loop, so we use v3.9.5 instead of v4.0.3.
-         */
-#if 0
         tmsize_t stride = PredictorState(tif)->stride;
 
-        char* cp = (char*) cp0;
+        unsigned char* cp = (unsigned char*) cp0;
         assert((cc%stride)==0);
         if (cc > stride) {
                 /*
                  * Pipeline the most common cases.
                  */
                 if (stride == 3)  {
                         unsigned int cr = cp[0];
                         unsigned int cg = cp[1];
                         unsigned int cb = cp[2];
                         cc -= 3;
                         cp += 3;
                         while (cc>0) {
-                                cp[0] = (char) (cr += cp[0]);
-                                cp[1] = (char) (cg += cp[1]);
-                                cp[2] = (char) (cb += cp[2]);
+                                cp[0] = (unsigned char) ((cr += cp[0]) & 0xff);
+                                cp[1] = (unsigned char) ((cg += cp[1]) & 0xff);
+                                cp[2] = (unsigned char) ((cb += cp[2]) & 0xff);
                                 cc -= 3;
                                 cp += 3;
                         }
                 } else if (stride == 4)  {
                         unsigned int cr = cp[0];
                         unsigned int cg = cp[1];
                         unsigned int cb = cp[2];
                         unsigned int ca = cp[3];
                         cc -= 4;
                         cp += 4;
                         while (cc>0) {
-                                cp[0] = (char) (cr += cp[0]);
-                                cp[1] = (char) (cg += cp[1]);
-                                cp[2] = (char) (cb += cp[2]);
-                                cp[3] = (char) (ca += cp[3]);
+                                cp[0] = (unsigned char) ((cr += cp[0]) & 0xff);
+                                cp[1] = (unsigned char) ((cg += cp[1]) & 0xff);
+                                cp[2] = (unsigned char) ((cb += cp[2]) & 0xff);
+                                cp[3] = (unsigned char) ((ca += cp[3]) & 0xff);
                                 cc -= 4;
                                 cp += 4;
                         }
                 } else  {
                         cc -= stride;
                         do {
                                 REPEAT4(stride, cp[stride] =
-                                        (char) (cp[stride] + *cp); cp++)
+                                        (unsigned char) ((cp[stride] + *cp) & 0xff); cp++)
                                 cc -= stride;
                         } while (cc>0);
                 }
         }
-#else
-        tsize_t stride = PredictorState(tif)->stride;
-
-        char* cp = (char*) cp0;
-        if (cc > stride) {
-                cc -= stride;
-                /*
-                 * Pipeline the most common cases.
-                 */
-                if (stride == 3)  {
-                        unsigned int cr = cp[0];
-                        unsigned int cg = cp[1];
-                        unsigned int cb = cp[2];
-                        do {
-                                cc -= 3, cp += 3;
-                                cp[0] = (char) (cr += cp[0]);
-                                cp[1] = (char) (cg += cp[1]);
-                                cp[2] = (char) (cb += cp[2]);
-                        } while ((int32) cc > 0);
-                } else if (stride == 4)  {
-                        unsigned int cr = cp[0];
-                        unsigned int cg = cp[1];
-                        unsigned int cb = cp[2];
-                        unsigned int ca = cp[3];
-                        do {
-                                cc -= 4, cp += 4;
-                                cp[0] = (char) (cr += cp[0]);
-                                cp[1] = (char) (cg += cp[1]);
-                                cp[2] = (char) (cb += cp[2]);
-                                cp[3] = (char) (ca += cp[3]);
-                        } while ((int32) cc > 0);
-                } else  {
-                        do {
-                                REPEAT4(stride, cp[stride] =
-                                        (char) (cp[stride] + *cp); cp++)
-                                cc -= stride;
-                        } while ((int32) cc > 0);
-                }
-        }
-#endif
 }
 
 static void
 swabHorAcc16(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
-        tmsize_t stride = PredictorState(tif)->stride;
         uint16* wp = (uint16*) cp0;
         tmsize_t wc = cc / 2;
 
-        assert((cc%(2*stride))==0);
-
-        if (wc > stride) {
-                TIFFSwabArrayOfShort(wp, wc);
-                wc -= stride;
-                do {
-                        REPEAT4(stride, wp[stride] += wp[0]; wp++)
-                        wc -= stride;
-                } while (wc > 0);
-        }
+        TIFFSwabArrayOfShort(wp, wc);
+        horAcc16(tif, cp0, cc);
 }
 
 static void
 horAcc16(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
         tmsize_t stride = PredictorState(tif)->stride;
         uint16* wp = (uint16*) cp0;
         tmsize_t wc = cc / 2;
 
         assert((cc%(2*stride))==0);
 
         if (wc > stride) {
                 wc -= stride;
                 do {
-                        REPEAT4(stride, wp[stride] += wp[0]; wp++)
+                        REPEAT4(stride, wp[stride] = (uint16)(((unsigned int)wp[stride] + (unsigned int)wp[0]) & 0xffff); wp++)
                         wc -= stride;
                 } while (wc > 0);
         }
 }
 
 static void
 swabHorAcc32(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
-        tmsize_t stride = PredictorState(tif)->stride;
         uint32* wp = (uint32*) cp0;
         tmsize_t wc = cc / 4;
 
-        assert((cc%(4*stride))==0);
-
-        if (wc > stride) {
-                TIFFSwabArrayOfLong(wp, wc);
-                wc -= stride;
-                do {
-                        REPEAT4(stride, wp[stride] += wp[0]; wp++)
-                        wc -= stride;
-                } while (wc > 0);
-        }
+        TIFFSwabArrayOfLong(wp, wc);
+        horAcc32(tif, cp0, cc);
 }
 
 static void
 horAcc32(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
         tmsize_t stride = PredictorState(tif)->stride;
         uint32* wp = (uint32*) cp0;
         tmsize_t wc = cc / 4;
 
         assert((cc%(4*stride))==0);
@@ skipping 19 matching lines @@
         tmsize_t count = cc;
         uint8 *cp = (uint8 *) cp0;
         uint8 *tmp = (uint8 *)_TIFFmalloc(cc);
 
         assert((cc%(bps*stride))==0);
 
         if (!tmp)
                 return;
 
         while (count > stride) {
-                REPEAT4(stride, cp[stride] += cp[0]; cp++)
+                REPEAT4(stride, cp[stride] =
+                        (unsigned char) ((cp[stride] + cp[0]) & 0xff); cp++)
                 count -= stride;
         }
 
         _TIFFmemcpy(tmp, cp0, cc);
         cp = (uint8 *) cp0;
         for (count = 0; count < wc; count++) {
                 uint32 byte;
                 for (byte = 0; byte < bps; byte++) {
                         #if WORDS_BIGENDIAN
                         cp[bps * count + byte] = tmp[byte * wc + count];
@@ skipping 53 matching lines @@
                 return 1;
         } else
                 return 0;
 }
 
 static void
 horDiff8(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
         TIFFPredictorState* sp = PredictorState(tif);
         tmsize_t stride = sp->stride;
-        char* cp = (char*) cp0;
+        unsigned char* cp = (unsigned char*) cp0;
 
         assert((cc%stride)==0);
 
         if (cc > stride) {
                 cc -= stride;
                 /*
                  * Pipeline the most common cases.
                  */
                 if (stride == 3) {
-                        int r1, g1, b1;
-                        int r2 = cp[0];
-                        int g2 = cp[1];
-                        int b2 = cp[2];
+                        unsigned int r1, g1, b1;
+                        unsigned int r2 = cp[0];
+                        unsigned int g2 = cp[1];
+                        unsigned  int b2 = cp[2];
                         do {
-                                r1 = cp[3]; cp[3] = r1-r2; r2 = r1;
-                                g1 = cp[4]; cp[4] = g1-g2; g2 = g1;
-                                b1 = cp[5]; cp[5] = b1-b2; b2 = b1;
+                                r1 = cp[3]; cp[3] = (unsigned char)((r1-r2)&0xff); r2 = r1;
+                                g1 = cp[4]; cp[4] = (unsigned char)((g1-g2)&0xff); g2 = g1;
+                                b1 = cp[5]; cp[5] = (unsigned char)((b1-b2)&0xff); b2 = b1;
                                 cp += 3;
                         } while ((cc -= 3) > 0);
                 } else if (stride == 4) {
-                        int r1, g1, b1, a1;
-                        int r2 = cp[0];
-                        int g2 = cp[1];
-                        int b2 = cp[2];
-                        int a2 = cp[3];
+                        unsigned int r1, g1, b1, a1;
+                        unsigned int r2 = cp[0];
+                        unsigned int g2 = cp[1];
+                        unsigned int b2 = cp[2];
+                        unsigned int a2 = cp[3];
                         do {
-                                r1 = cp[4]; cp[4] = r1-r2; r2 = r1;
-                                g1 = cp[5]; cp[5] = g1-g2; g2 = g1;
-                                b1 = cp[6]; cp[6] = b1-b2; b2 = b1;
-                                a1 = cp[7]; cp[7] = a1-a2; a2 = a1;
+                                r1 = cp[4]; cp[4] = (unsigned char)((r1-r2)&0xff); r2 = r1;
+                                g1 = cp[5]; cp[5] = (unsigned char)((g1-g2)&0xff); g2 = g1;
+                                b1 = cp[6]; cp[6] = (unsigned char)((b1-b2)&0xff); b2 = b1;
+                                a1 = cp[7]; cp[7] = (unsigned char)((a1-a2)&0xff); a2 = a1;
                                 cp += 4;
                         } while ((cc -= 4) > 0);
                 } else {
                         cp += cc - 1;
                         do {
-                                REPEAT4(stride, cp[stride] -= cp[0]; cp--)
+                                REPEAT4(stride, cp[stride] = (unsigned char)((cp[stride] - cp[0])&0xff); cp--)
                         } while ((cc -= stride) > 0);
                 }
         }
 }
 
 static void
 horDiff16(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
         TIFFPredictorState* sp = PredictorState(tif);
         tmsize_t stride = sp->stride;
-        int16 *wp = (int16*) cp0;
+        uint16 *wp = (uint16*) cp0;
         tmsize_t wc = cc/2;
 
         assert((cc%(2*stride))==0);
 
         if (wc > stride) {
                 wc -= stride;
                 wp += wc - 1;
                 do {
-                        REPEAT4(stride, wp[stride] -= wp[0]; wp--)
+                        REPEAT4(stride, wp[stride] = (uint16)(((unsigned int)wp[stride] - (unsigned int)wp[0]) & 0xffff); wp--)
                         wc -= stride;
                 } while (wc > 0);
         }
 }
 
 static void
+swabHorDiff16(TIFF* tif, uint8* cp0, tmsize_t cc)
+{
+    uint16* wp = (uint16*) cp0;
+    tmsize_t wc = cc / 2;
+
+    horDiff16(tif, cp0, cc);
+
+    TIFFSwabArrayOfShort(wp, wc);
+}
+
+static void
 horDiff32(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
         TIFFPredictorState* sp = PredictorState(tif);
         tmsize_t stride = sp->stride;
-        int32 *wp = (int32*) cp0;
+        uint32 *wp = (uint32*) cp0;
         tmsize_t wc = cc/4;
 
         assert((cc%(4*stride))==0);
 
         if (wc > stride) {
                 wc -= stride;
                 wp += wc - 1;
                 do {
                         REPEAT4(stride, wp[stride] -= wp[0]; wp--)
                         wc -= stride;
                 } while (wc > 0);
         }
 }
 
+static void
+swabHorDiff32(TIFF* tif, uint8* cp0, tmsize_t cc)
+{
+    uint32* wp = (uint32*) cp0;
+    tmsize_t wc = cc / 4;
+
+    horDiff32(tif, cp0, cc);
+
+    TIFFSwabArrayOfLong(wp, wc);
+}
+
 /*
  * Floating point predictor differencing routine.
  */
 static void
 fpDiff(TIFF* tif, uint8* cp0, tmsize_t cc)
 {
         tmsize_t stride = PredictorState(tif)->stride;
         uint32 bps = tif->tif_dir.td_bitspersample / 8;
         tmsize_t wc = cc / bps;
         tmsize_t count;
@@ skipping 15 matching lines @@
                         cp[(bps - byte - 1) * wc + count] =
                                 tmp[bps * count + byte];
                         #endif
                 }
         }
         _TIFFfree(tmp);
 
         cp = (uint8 *) cp0;
         cp += cc - stride - 1;
         for (count = cc; count > stride; count -= stride)
-                REPEAT4(stride, cp[stride] -= cp[0]; cp--)
+                REPEAT4(stride, cp[stride] = (unsigned char)((cp[stride] - cp[0])&0xff); cp--)
 }
 
 static int
 PredictorEncodeRow(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 {
         TIFFPredictorState *sp = PredictorState(tif);
 
         assert(sp != NULL);
         assert(sp->encodepfunc != NULL);
         assert(sp->encoderow != NULL);
@@ skipping 168 matching lines @@
 }
 
 /* vim: set ts=8 sts=8 sw=8 noet: */
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 8
  * fill-column: 78
  * End:
  */
-