sketch hooking into PNG_FILTER_OPTIMIZATIONS

src/codec/SkPngFilters.cpp

+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkPngFilters.h"
+#include "SkTypes.h"
+
+// Functions in this file look at most 3 pixels (a,b,c) to predict the fourth (d).
+// They're positioned like this:
+//     prev:  c b
+//     row:   a d
+// The Sub filter predicts d=a, Avg d=(a+b)/2,  and Paeth predicts d to be whichever
+// of a, b, or c is closest to p=a+b-c.  (Up also exists, predicting d=b.)
+
+#if defined(__SSE2__)
+
+    static __m128i load4(const void* p) {
+        return _mm_cvtsi32_si128(*(const uint32_t*)p);
+    }
+
+    static void store4(void* p, __m128i v) {
+        *(uint32_t*)p = _mm_cvtsi128_si32(v);
+    }
+
+    void sk_sub4_sse2(png_row_infop row_info, png_bytep row_u8, png_const_bytep) {
+        // The Sub filter predicts each pixel as the previous pixel, a.
+        auto row = (uint32_t*)row_u8;
+        int n = row_info->rowbytes / 4;
+
+        // There is no pixel to the left of the first pixel.  It's encoded directly.
+        // That works with our main loop if we just say that left pixel was zero.
+        __m128i a, d = _mm_setzero_si128();
+
+        while (n --> 0) {
+            a = d; d = load4(row);
+            d = _mm_add_epi8(d, a);
+            store4(row++, d);
+        }
+    }
+
+    void sk_avg4_sse2(png_row_infop row_info, png_bytep row_u8, png_const_bytep prev_u8) {
+        // The Avg filter predicts each pixel as the (truncated) average of a and b.
+        auto prev = (const uint32_t*)prev_u8;
+        auto row  = (uint32_t*)row_u8;
+        int n = row_info->rowbytes / 4;
+
+        // There's no pixel to the left of the first pixel.  Luckily, it's
+        // predicted to be half of the pixel above it.  So again, this works
+        // perfectly with our loop if we make sure a starts at zero.
+        const __m128i zero = _mm_setzero_si128();
+        __m128i    b;
+        __m128i a, d = zero;
+
+        while (n --> 0) {
+                   b = load4(prev++);
+            a = d; d = load4(row   );
+
+            // PNG requires a truncating average here, so sadly we can't just use _mm_avg_epu8...
+            __m128i avg = _mm_avg_epu8(a,b);
+            // ...but we can fix it up by subtracting off 1 if it rounded up.
+            avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b), _mm_set1_epi8(1)));
+
+            d = _mm_add_epi8(d, avg);
+            store4(row++, d);
+        }
+    }
+
+    // Returns bytewise |x-y|.
+    static __m128i absdiff_u8(__m128i x, __m128i y) {
+        // One of these two saturated subtractions will be the answer, the other zero.
+        return _mm_or_si128(_mm_subs_epu8(x,y), _mm_subs_epu8(y,x));
+    }
+
+    // Bytewise c ? t : e.
+    static __m128i if_then_else(__m128i c, __m128i t, __m128i e) {
+        // SSE 4.1+ would be: return _mm_blendv_epi8(e,t,c);

[msarett, 2016/01/27 20:56:10]

Why not add a #if here?

[mtklein, 2016/01/27 21:00:16]

Mostly because we won't have a bot to test it, though I do acknowledge that x86
Android might benefit.  Let's circle back once we see how this works / performs?

+        return _mm_or_si128(_mm_and_si128(c, t), _mm_andnot_si128(c, e));
+    }
+
+    void sk_paeth4_sse2(png_row_infop row_info, png_bytep row_u8, png_const_bytep prev_u8) {
+        auto prev = (const uint32_t*)prev_u8;
+        auto row  = (uint32_t*)row_u8;
+        int n = row_info->rowbytes / 4;
+
+        // Paeth tries to predict pixel d using the pixel to the left of it, a,
+        // and two pixels from the previous row, b and c:
+        //   prev: c b
+        //   row:  a d
+        // The Paeth function predicts d to be whichever of a, b, or c is nearest to p=a+b-c.
+
+        // The first pixel has no left context, and so uses an Up filter, p = b.
+        // This works naturally with our main loop's p = a+b-c if we force a and c to zero.
+        // Here we zero b and d, which become c and a respectively at the start of the loop.
+        __m128i c, b = _mm_setzero_si128(),
+                a, d = _mm_setzero_si128();
+
+        while (n --> 0) {
+            c = b; b = load4(prev++);
+            a = d; d = load4(row);
+
+            // We can't express p in 8 bits, but luckily we can use this faux p instead.
+            // (I have no deep insight here... I just proved this with brute force.)
+            __m128i min = _mm_min_epu8(a,b),
+                    max = _mm_max_epu8(a,b),
+                    faux_p = _mm_adds_epu8(min, _mm_subs_epu8(max, c));
+
+            // We could use faux_p for calculating all three of pa, pb, and pc,
+            // but it's a little quicker to calculate the correct pa and pb directly,
+            // and the predictor remains the same.  (Again, brute force.)
+            __m128i pa = absdiff_u8(b,c),             // |a+b-c - a| == |b-c|
+                    pb = absdiff_u8(a,c),             // |a+b-c - b| == |a-c|
+               faux_pc = absdiff_u8(faux_p, c);
+
+            // From here, things are straightforward.  Find the smallest distance to p...
+            __m128i smallest = _mm_min_epu8(_mm_min_epu8(pa, pb), faux_pc);
+
+            // ... then the predictor is the input corresponding to that smallest distance,
+            // breaking ties in favor of a over b over c.
+            __m128i nearest = if_then_else(_mm_cmpeq_epi8(smallest, pa), a,
+                              if_then_else(_mm_cmpeq_epi8(smallest, pb), b,
+                                                                         c));
+
+            // We've reconstructed d!  Leave it for next round to become a, and write it out.
+            d = _mm_add_epi8(d, nearest);
+            store4(row++, d);
+        }
+    }
+
+#endif