Revert "Revert of create shaderproc for nofilter-opaque-dx (patchset #7 id:120001...

This reverts commit 430b795cc8a1cdbddd8fdc5511a3a523348937f7 and adds suppressions.

BUG=skia:

Review URL: https://codereview.chromium.org/673023002

diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp
index efd6d96..da2e829 100644 (file)
--- a/bench/BitmapBench.cpp
+++ b/bench/BitmapBench.cpp
@@ -75,6 +75,7 @@ class BitmapBench : public Benchmark {
     const SkAlphaType   fAlphaType;
     const bool          fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache
     const bool          fIsVolatile;
+    const bool          fDoScale;
 
     SkBitmap            fBitmap;
     SkPaint             fPaint;
@@ -83,11 +84,12 @@ class BitmapBench : public Benchmark {
     enum { W = 128 };
     enum { H = 128 };
 public:
-    BitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate = false, bool isVolatile = false)
+    BitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate, bool isVolatile, bool doScale)
         : fColorType(ct)
         , fAlphaType(at)
         , fForceUpdate(forceUpdate)
         , fIsVolatile(isVolatile)
+        , fDoScale(doScale)
     {}
 
 protected:
@@ -95,10 +97,15 @@ protected:
         fName.set("bitmap");
         fName.appendf("_%s%s", sk_tool_utils::colortype_name(fColorType),
                       kOpaque_SkAlphaType == fAlphaType ? "" : "_A");
-        if (fForceUpdate)
+        if (fDoScale) {
+            fName.append("_scale");
+        }
+        if (fForceUpdate) {
             fName.append("_update");
-        if (fIsVolatile)
+        }
+        if (fIsVolatile) {
             fName.append("_volatile");
+        }
 
         return fName.c_str();
     }
@@ -125,6 +132,9 @@ protected:
     }
 
     virtual void onDraw(const int loops, SkCanvas* canvas) {
+        if (fDoScale) {
+            canvas->scale(.99f, .99f);
+        }
         SkIPoint dim = this->getSize();
         SkRandom rand;
 
@@ -193,7 +203,7 @@ class FilterBitmapBench : public BitmapBench {
 public:
     FilterBitmapBench(SkColorType ct, SkAlphaType at,
                       bool forceUpdate, bool isVolitile, uint32_t flags)
-        : INHERITED(ct, at, forceUpdate, isVolitile)
+        : INHERITED(ct, at, forceUpdate, isVolitile, false)
         , fFlags(flags) {
     }
 
@@ -272,7 +282,7 @@ private:
 public:
     SourceAlphaBitmapBench(SourceAlpha alpha, SkColorType ct,
                 bool forceUpdate = false, bool bitmapVolatile = false)
-        : INHERITED(ct, kPremul_SkAlphaType, forceUpdate, bitmapVolatile)
+        : INHERITED(ct, kPremul_SkAlphaType, forceUpdate, bitmapVolatile, false)
         , fSourceAlpha(alpha) {
     }
 
@@ -349,13 +359,14 @@ private:
     typedef BitmapBench INHERITED;
 };
 
-DEF_BENCH( return new BitmapBench(kN32_SkColorType, kPremul_SkAlphaType); )
-DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType); )
-DEF_BENCH( return new BitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType); )
-DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kPremul_SkAlphaType); )
-DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kOpaque_SkAlphaType); )
-DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true); )
-DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, false); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false, false); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false, true); )
+DEF_BENCH( return new BitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType, false, false, false); )
+DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kPremul_SkAlphaType, false, false, false); )
+DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kOpaque_SkAlphaType, false, false, false); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true, false); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false, false); )
 
 // scale filter -> S32_opaque_D32_filter_DX_{SSE2,SSSE3} and Fact9 is also for S32_D16_filter_DX_SSE2
 DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kBilerp_Flag); )

diff --git a/expectations/gm/ignored-tests.txt b/expectations/gm/ignored-tests.txt
index 976a2a8..ad1f7a3 100644 (file)
--- a/expectations/gm/ignored-tests.txt
+++ b/expectations/gm/ignored-tests.txt
@@ -58,3 +58,21 @@ dftext
 megalooper_0x0
 megalooper_1x4
 megalooper_4x1
+
+#mtklein/reed: slight image resize fixes
+bitmaprecttest
+bitmapshaders
+downsamplebitmap_checkerboard_none_512_256
+downsamplebitmap_image_none_mandrill_512.png
+downsamplebitmap_text_none_72.00pt
+filterbitmap_checkerboard_192_192
+filterbitmap_image_mandrill_128.png
+filterbitmap_image_mandrill_256.png
+filterbitmap_image_mandrill_512.png
+filterbitmap_image_mandrill_64.png
+filterbitmap_text_10.00pt
+filterbitmap_text_7.00pt
+image-surface
+scaled_tilemode_bitmap
+tilemode_bitmap
+verylargebitmap

diff --git a/src/core/SkBitmapProcState.cpp b/src/core/SkBitmapProcState.cpp
index 2a449d6..b1b50b0 100644 (file)
--- a/src/core/SkBitmapProcState.cpp
+++ b/src/core/SkBitmapProcState.cpp
@@ -30,6 +30,8 @@ extern void  SI8_opaque_D32_filter_DX_shaderproc_neon(const SkBitmapProcState&,
 extern void  Clamp_SI8_opaque_D32_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint32_t*, int);
 #endif
 
+extern void Clamp_S32_opaque_D32_nofilter_DX_shaderproc(const SkBitmapProcState&, int, int, uint32_t*, int);
+
 #define   NAME_WRAP(x)  x
 #include "SkBitmapProcState_filter.h"
 #include "SkBitmapProcState_procs.h"
@@ -589,6 +591,8 @@ bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
             }
         } else if (SK_ARM_NEON_WRAP(SI8_opaque_D32_filter_DX) == fSampleProc32 && clampClamp) {
             fShaderProc32 = SK_ARM_NEON_WRAP(Clamp_SI8_opaque_D32_filter_DX_shaderproc);
+        } else if (S32_opaque_D32_nofilter_DX == fSampleProc32 && clampClamp) {
+            fShaderProc32 = Clamp_S32_opaque_D32_nofilter_DX_shaderproc;
         }
 
         if (NULL == fShaderProc32) {
@@ -1019,3 +1023,58 @@ int SkBitmapProcState::maxCountForBufferSize(size_t bufferSize) const {
 
     return size;
 }
+
+///////////////////////
+
+void  Clamp_S32_opaque_D32_nofilter_DX_shaderproc(const SkBitmapProcState& s, int x, int y,
+                                                  SkPMColor* SK_RESTRICT dst, int count) {
+    SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
+                             SkMatrix::kScale_Mask)) == 0);
+
+    const unsigned maxX = s.fBitmap->width() - 1;
+    SkFractionalInt fx;
+    int dstY;
+    {
+        SkPoint pt;
+        s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, SkIntToScalar(y) + SK_ScalarHalf,
+                   &pt);
+        fx = SkScalarToFractionalInt(pt.fY);
+        const unsigned maxY = s.fBitmap->height() - 1;
+        dstY = SkClampMax(SkFractionalIntToInt(fx), maxY);
+        fx = SkScalarToFractionalInt(pt.fX);
+    }
+
+    const SkPMColor* SK_RESTRICT src = s.fBitmap->getAddr32(0, dstY);
+    const SkFractionalInt dx = s.fInvSxFractionalInt;
+
+    // Check if we're safely inside [0...maxX] so no need to clamp each computed index.
+    //
+    if ((uint64_t)SkFractionalIntToInt(fx) <= maxX &&
+        (uint64_t)SkFractionalIntToInt(fx + dx * (count - 1)) <= maxX)
+    {
+        int count4 = count >> 2;
+        for (int i = 0; i < count4; ++i) {
+            SkPMColor src0 = src[SkFractionalIntToInt(fx)]; fx += dx;
+            SkPMColor src1 = src[SkFractionalIntToInt(fx)]; fx += dx;
+            SkPMColor src2 = src[SkFractionalIntToInt(fx)]; fx += dx;
+            SkPMColor src3 = src[SkFractionalIntToInt(fx)]; fx += dx;
+            dst[0] = src0;
+            dst[1] = src1;
+            dst[2] = src2;
+            dst[3] = src3;
+            dst += 4;
+        }
+        for (int i = (count4 << 2); i < count; ++i) {
+            unsigned index = SkFractionalIntToInt(fx);
+            SkASSERT(index <= maxX);
+            *dst++ = src[index];
+            fx += dx;
+        }
+    } else {
+        for (int i = 0; i < count; ++i) {
+            dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
+            fx += dx;
+        }
+    }
+}
+