Drop support for 8-bit precision in bilinear filtering

The default has been 7-bit for a while now, and the quality
improvement with 8-bit precision is not enough to justify keeping the
code around as a compile-time option.

diff --git a/pixman/pixman-mmx.c b/pixman/pixman-mmx.c
index c94d282..a0f59ef 100644 (file)
--- a/pixman/pixman-mmx.c
+++ b/pixman/pixman-mmx.c
@@ -3561,7 +3561,6 @@ mmx_composite_over_reverse_n_8888 (pixman_implementation_t *imp,
 #define BILINEAR_DECLARE_VARIABLES                                             \
     const __m64 mm_wt = _mm_set_pi16 (wt, wt, wt, wt);                         \
     const __m64 mm_wb = _mm_set_pi16 (wb, wb, wb, wb);                         \
-    const __m64 mm_BSHIFT = _mm_set_pi16 (BSHIFT, BSHIFT, BSHIFT, BSHIFT);     \
     const __m64 mm_addc7 = _mm_set_pi16 (0, 1, 0, 1);                          \
     const __m64 mm_xorc7 = _mm_set_pi16 (0, BMSK, 0, BMSK);                    \
     const __m64 mm_ux = _mm_set_pi16 (unit_x, unit_x, unit_x, unit_x);         \
@@ -3581,35 +3580,15 @@ do {                                                                            \
     __m64 hi = _mm_add_pi16 (t_hi, b_hi);                                      \
     __m64 lo = _mm_add_pi16 (t_lo, b_lo);                                      \
     vx += unit_x;                                                              \
-    if (BILINEAR_INTERPOLATION_BITS < 8)                                       \
-    {                                                                          \
-       /* calculate horizontal weights */                                      \
-       __m64 mm_wh = _mm_add_pi16 (mm_addc7, _mm_xor_si64 (mm_xorc7,           \
+    /* calculate horizontal weights */                                         \
+    __m64 mm_wh = _mm_add_pi16 (mm_addc7, _mm_xor_si64 (mm_xorc7,              \
                          _mm_srli_pi16 (mm_x,                                  \
                                         16 - BILINEAR_INTERPOLATION_BITS)));   \
-       /* horizontal interpolation */                                          \
-       __m64 p = _mm_unpacklo_pi16 (lo, hi);                                   \
-       __m64 q = _mm_unpackhi_pi16 (lo, hi);                                   \
-       lo = _mm_madd_pi16 (p, mm_wh);                                          \
-       hi = _mm_madd_pi16 (q, mm_wh);                                          \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-       /* calculate horizontal weights */                                      \
-       __m64 mm_wh_lo = _mm_sub_pi16 (mm_BSHIFT, _mm_srli_pi16 (mm_x,          \
-                                       16 - BILINEAR_INTERPOLATION_BITS));     \
-       __m64 mm_wh_hi = _mm_srli_pi16 (mm_x,                                   \
-                                       16 - BILINEAR_INTERPOLATION_BITS);      \
-       /* horizontal interpolation */                                          \
-       __m64 mm_lo_lo = _mm_mullo_pi16 (lo, mm_wh_lo);                         \
-       __m64 mm_lo_hi = _mm_mullo_pi16 (hi, mm_wh_hi);                         \
-       __m64 mm_hi_lo = _mm_mulhi_pu16 (lo, mm_wh_lo);                         \
-       __m64 mm_hi_hi = _mm_mulhi_pu16 (hi, mm_wh_hi);                         \
-       lo = _mm_add_pi32 (_mm_unpacklo_pi16 (mm_lo_lo, mm_hi_lo),              \
-                          _mm_unpacklo_pi16 (mm_lo_hi, mm_hi_hi));             \
-       hi = _mm_add_pi32 (_mm_unpackhi_pi16 (mm_lo_lo, mm_hi_lo),              \
-                          _mm_unpackhi_pi16 (mm_lo_hi, mm_hi_hi));             \
-    }                                                                          \
+    /* horizontal interpolation */                                             \
+    __m64 p = _mm_unpacklo_pi16 (lo, hi);                                      \
+    __m64 q = _mm_unpackhi_pi16 (lo, hi);                                      \
+    lo = _mm_madd_pi16 (p, mm_wh);                                             \
+    hi = _mm_madd_pi16 (q, mm_wh);                                             \
     mm_x = _mm_add_pi16 (mm_x, mm_ux);                                         \
     /* shift and pack the result */                                            \
     hi = _mm_srli_pi32 (hi, BILINEAR_INTERPOLATION_BITS * 2);                  \

diff --git a/pixman/pixman-sse2.c b/pixman/pixman-sse2.c
index dde9235..a629565 100644 (file)
--- a/pixman/pixman-sse2.c
+++ b/pixman/pixman-sse2.c
@@ -5554,7 +5554,6 @@ FAST_NEAREST_MAINLOOP_COMMON (sse2_8888_n_8888_normal_OVER,
                              scaled_nearest_scanline_sse2_8888_n_8888_OVER,
                              uint32_t, uint32_t, uint32_t, NORMAL, TRUE, TRUE)
 
-#if BILINEAR_INTERPOLATION_BITS < 8
 # define BILINEAR_DECLARE_VARIABLES                                            \
     const __m128i xmm_wt = _mm_set_epi16 (wt, wt, wt, wt, wt, wt, wt, wt);     \
     const __m128i xmm_wb = _mm_set_epi16 (wb, wb, wb, wb, wb, wb, wb, wb);     \
@@ -5564,21 +5563,10 @@ FAST_NEAREST_MAINLOOP_COMMON (sse2_8888_n_8888_normal_OVER,
     const __m128i xmm_zero = _mm_setzero_si128 ();                             \
     __m128i xmm_x = _mm_set_epi16 (vx, -(vx + 1), vx, -(vx + 1),               \
                                   vx, -(vx + 1), vx, -(vx + 1))
-#else
-# define BILINEAR_DECLARE_VARIABLES                                            \
-    const __m128i xmm_wt = _mm_set_epi16 (wt, wt, wt, wt, wt, wt, wt, wt);     \
-    const __m128i xmm_wb = _mm_set_epi16 (wb, wb, wb, wb, wb, wb, wb, wb);     \
-    const __m128i xmm_addc = _mm_set_epi16 (0, 0, 0, 0, 1, 1, 1, 1);           \
-    const __m128i xmm_ux = _mm_set_epi16 (unit_x, unit_x, unit_x, unit_x,      \
-                                         -unit_x, -unit_x, -unit_x, -unit_x);  \
-    const __m128i xmm_zero = _mm_setzero_si128 ();                             \
-    __m128i xmm_x = _mm_set_epi16 (vx, vx, vx, vx,                             \
-                                  -(vx + 1), -(vx + 1), -(vx + 1), -(vx + 1))
-#endif
 
 #define BILINEAR_INTERPOLATE_ONE_PIXEL(pix)                                    \
 do {                                                                           \
-    __m128i xmm_wh, xmm_lo, xmm_hi, a;                                         \
+    __m128i xmm_wh, a;                                                         \
     /* fetch 2x2 pixel block into sse2 registers */                            \
     __m128i tltr = _mm_loadl_epi64 (                                           \
                            (__m128i *)&src_top[pixman_fixed_to_int (vx)]);     \
@@ -5590,28 +5578,13 @@ do {                                                                            \
                                        xmm_wt),                                \
                       _mm_mullo_epi16 (_mm_unpacklo_epi8 (blbr, xmm_zero),     \
                                        xmm_wb));                               \
-    if (BILINEAR_INTERPOLATION_BITS < 8)                                       \
-    {                                                                          \
-       /* calculate horizontal weights */                                      \
-       xmm_wh = _mm_add_epi16 (xmm_addc, _mm_srli_epi16 (xmm_x,                \
-                                       16 - BILINEAR_INTERPOLATION_BITS));     \
-       xmm_x = _mm_add_epi16 (xmm_x, xmm_ux);                                  \
-       /* horizontal interpolation */                                          \
-       a = _mm_madd_epi16 (_mm_unpackhi_epi16 (_mm_shuffle_epi32 (             \
-               a, _MM_SHUFFLE (1, 0, 3, 2)), a), xmm_wh);                      \
-    }                                                                          \
-    else                                                                       \
-    {                                                                          \
-       /* calculate horizontal weights */                                      \
-       xmm_wh = _mm_add_epi16 (xmm_addc, _mm_srli_epi16 (xmm_x,                \
-                                       16 - BILINEAR_INTERPOLATION_BITS));     \
-       xmm_x = _mm_add_epi16 (xmm_x, xmm_ux);                                  \
-       /* horizontal interpolation */                                          \
-       xmm_lo = _mm_mullo_epi16 (a, xmm_wh);                                   \
-       xmm_hi = _mm_mulhi_epu16 (a, xmm_wh);                                   \
-       a = _mm_add_epi32 (_mm_unpacklo_epi16 (xmm_lo, xmm_hi),                 \
-                          _mm_unpackhi_epi16 (xmm_lo, xmm_hi));                \
-    }                                                                          \
+    /* calculate horizontal weights */                                         \
+    xmm_wh = _mm_add_epi16 (xmm_addc, _mm_srli_epi16 (xmm_x,                   \
+                             16 - BILINEAR_INTERPOLATION_BITS));               \
+    xmm_x = _mm_add_epi16 (xmm_x, xmm_ux);                                     \
+    /* horizontal interpolation */                                             \
+    a = _mm_madd_epi16 (_mm_unpackhi_epi16 (_mm_shuffle_epi32 (                        \
+                              a, _MM_SHUFFLE (1, 0, 3, 2)), a), xmm_wh);       \
     /* shift and pack the result */                                            \
     a = _mm_srli_epi32 (a, BILINEAR_INTERPOLATION_BITS * 2);                   \
     a = _mm_packs_epi32 (a, a);                                                        \

diff --git a/test/affine-test.c b/test/affine-test.c
index 2506250..c1649ed 100644 (file)
--- a/test/affine-test.c
+++ b/test/affine-test.c
@@ -306,9 +306,7 @@ test_composite (int      testnum,
     return crc32;
 }
 
-#if BILINEAR_INTERPOLATION_BITS == 8
-#define CHECKSUM 0x2CDF1F07
-#elif BILINEAR_INTERPOLATION_BITS == 7
+#if BILINEAR_INTERPOLATION_BITS == 7
 #define CHECKSUM 0xBC00B1DF
 #elif BILINEAR_INTERPOLATION_BITS == 4
 #define CHECKSUM 0xA227306B

diff --git a/test/scaling-test.c b/test/scaling-test.c
index a8cb4c4..b4142a7 100644 (file)
--- a/test/scaling-test.c
+++ b/test/scaling-test.c
@@ -375,9 +375,7 @@ test_composite (int      testnum,
     return crc32;
 }
 
-#if BILINEAR_INTERPOLATION_BITS == 8
-#define CHECKSUM 0x9096E6B6
-#elif BILINEAR_INTERPOLATION_BITS == 7
+#if BILINEAR_INTERPOLATION_BITS == 7
 #define CHECKSUM 0xCE8EC6BA
 #elif BILINEAR_INTERPOLATION_BITS == 4
 #define CHECKSUM 0xAB1D39BE