Revert "Fix tile modes in SkGpuBlurUtils."

This reverts commit 9c4fa1e.

Reason for revert: breaking things, maybe?

Original change's description:
> Fix tile modes in SkGpuBlurUtils.
> 
> Expand direct GM testing of SkGpuBlurUtils.
> 
> Decimate in SkGpuBlurUtils using GrSurfaceContext::rescale.
> GrSurfaceContext::rescale() works on recording context and
> uses approximate textures (to avoid memory issues for blurs
> of many different sizes).
> 
> Don't preserve contents to the top/left of the source bounds
> in the rescaled image.
> 
> GrGaussianConvolutionFragmentProcessor applies wrap mode to
> both axes.
> 
> Rely on GrTextureEffect to omit subset enforcement in shader
> by providing a domain rect rather than turning off tiling in
> caller.
> 
> Change-Id: I73e09b4fcbcbed590dd3599091c38d5de65f48c4
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/285099
> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
> Commit-Queue: Brian Salomon <bsalomon@google.com>

TBR=bsalomon@google.com,michaelludwig@google.com

Change-Id: Ifdbfd9bdc67a082bf99e62371a7037e9544cf12a
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/288269
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Michael Ludwig <michaelludwig@google.com>

Author: bsalomon

gm/gpu_blur_utils.cpp

@@ -16,24 +16,8 @@
 #include "src/gpu/effects/GrXfermodeFragmentProcessor.h"
 #include "src/image/SkImage_Base.h"
 
-static GrSurfaceProxyView blur(GrContext* ctx,
-                               GrSurfaceProxyView src,
-                               SkIRect dstB,
-                               SkIRect srcB,
-                               float sigmaX,
-                               float sigmaY,
-                               SkTileMode mode) {
-    auto resultRTC =
-            SkGpuBlurUtils::GaussianBlur(ctx, src, GrColorType::kRGBA_8888, kPremul_SkAlphaType,
-                                         nullptr, dstB, srcB, sigmaX, sigmaY, mode);
-    if (!resultRTC) {
-        return {};
-    }
-    return resultRTC->readSurfaceView();
-};
-
-static void run(GrContext* ctx, GrRenderTargetContext* rtc, bool subsetSrc, bool ref) {
-    auto srcII = SkImageInfo::Make(60, 60, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
+DEF_SIMPLE_GPU_GM(gpu_blur_utils, ctx, rtc, canvas, 985, 740) {
+    auto srcII = SkImageInfo::Make(80, 80, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
     auto surf = SkSurface::MakeRenderTarget(ctx, SkBudgeted::kYes, srcII);
     GrSurfaceProxyView src;
     if (surf) {
@@ -73,117 +57,57 @@ static void run(GrContext* ctx, GrRenderTargetContext* rtc, bool subsetSrc, bool
     if (!src) {
         return;
     }
+    auto blur = [&](SkIRect dstB, SkIRect srcB, SkTileMode mode) -> GrSurfaceProxyView {
+        const SkScalar sigmaX = src.width() /10.f;
+        const SkScalar sigmaY = src.height()/10.f;
+        auto resultRTC =
+                SkGpuBlurUtils::GaussianBlur(ctx, src, GrColorType::kRGBA_8888, kPremul_SkAlphaType,
+                                             nullptr, dstB, srcB, sigmaX, sigmaY, mode);
+        if (!resultRTC) {
+            return {};
+        }
+        return resultRTC->readSurfaceView();
+    };
 
-    SkIRect srcRect = SkIRect::MakeSize(src.dimensions());
-    if (subsetSrc) {
-        srcRect = SkIRect::MakeXYWH(2.f*srcRect.width() /8.f,
-                                    1.f*srcRect.height()/8.f,
-                                    5.f*srcRect.width() /8.f,
-                                    6.f*srcRect.height()/8.f);
-    }
-    int srcW = srcRect.width();
-    int srcH = srcRect.height();
-    // Each set of rects is drawn in one test area so they probably should not abut or overlap
-    // to visualize the blurs separately.
-    const std::vector<SkIRect> dstRectSets[] = {
-            {
-                    srcRect.makeOutset(srcW/5, srcH/5)
-            },
-
-            {
-                    SkIRect::MakeXYWH(srcRect.x(), srcRect.y() + 3*srcH/4, srcW, srcH),
-                    SkIRect::MakeXYWH(srcRect.x(), srcRect.y() - 3*srcH/4, srcW, srcH)
-            },
-
-            {
-                    srcRect.makeOffset(    0,  srcH),
-                    srcRect.makeOffset( srcW,     0),
-                    srcRect.makeOffset(    0, -srcH),
-                    srcRect.makeOffset(-srcW,     0),
-            },
+    SkVector trans = {};
+    rtc->clear(SK_PMColor4fWHITE);
+    const SkIRect dstRects[] = {
+            SkIRect::MakeSize(src.dimensions()).makeOutset(src.width()/5, src.height()/5),
+            SkIRect::MakeXYWH(0, 3*src.height()/4, src.width(), src.height()),
+            SkIRect::MakeXYWH(0, src.height(), src.width(), src.height())
+    };
 
-            {
-                    SkIRect::MakeXYWH(-6.f*srcW/8.f, -7.f*srcH/8.f,  4.f*srcW/8.f, 20.f*srcH/8.f)
-                            .makeOffset(srcRect.topLeft()),
-                    SkIRect::MakeXYWH(-1.f*srcW/8.f, -7.f*srcH/8.f, 16.f*srcW/8.f,  2.f*srcH/8.f)
-                            .makeOffset(srcRect.topLeft()),
-                    SkIRect::MakeXYWH(10.f*srcW/8.f, -3.f*srcH/8.f,  4.f*srcW/8.f, 16.f*srcH/8.f)
-                            .makeOffset(srcRect.topLeft()),
-                    SkIRect::MakeXYWH(-7.f*srcW/8.f, 14.f*srcH/8.f, 18.f*srcW/8.f,  1.f*srcH/8.f)
-                            .makeOffset(srcRect.topLeft()),
-            },
+    const SkIRect srcRects[] = {
+            SkIRect::MakeSize(src.dimensions()),
     };
 
     const auto& caps = *ctx->priv().caps();
-
-    static constexpr SkScalar kPad = 10;
-    SkVector trans = {kPad, kPad};
-
-    rtc->clear(SK_PMColor4fWHITE);
-
-    SkIRect testArea = srcRect;
-    testArea.outset(testArea.width(), testArea.height());
-    for (const auto& dstRectSet : dstRectSets) {
-        for (int t = 0; t < kSkTileModeCount; ++t) {
-            auto mode = static_cast<SkTileMode>(t);
-            GrSamplerState sampler(SkTileModeToWrapMode(mode), GrSamplerState::Filter::kNearest);
-            SkMatrix m = SkMatrix::MakeTrans(trans.x() - testArea.x(), trans.y() - testArea.y());
-            // Draw the src subset in the tile mode faded as a reference before drawing the blur
-            // on top.
-            {
-                auto fp = GrTextureEffect::MakeSubset(src, kPremul_SkAlphaType, SkMatrix::I(),
-                                                      sampler, SkRect::Make(srcRect), caps);
-                GrPaint paint;
-                paint.addColorFragmentProcessor(std::move(fp));
-                static constexpr float kAlpha = 0.2f;
-                paint.setColor4f({kAlpha, kAlpha, kAlpha, kAlpha});
-                rtc->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, m, SkRect::Make(testArea));
-            }
-            // If we're in ref mode we will create a temp image that has the original image
-            // tiled into it and then do a clamp blur with adjusted params that should produce
-            // the same result as the original params.
-            std::unique_ptr<GrRenderTargetContext> refSrc;
-            SkIRect refRect;
-            if (ref) {
-                // Blow up testArea into a much larger rect so that our clamp blur will not
-                // reach anywhere near the edge of our temp surface.
-                refRect = testArea.makeOutset(testArea.width(), testArea.height());
-                refSrc = GrRenderTargetContext::Make(ctx, GrColorType::kRGBA_8888, nullptr,
-                                                     SkBackingFit::kApprox, refRect.size());
-                refSrc->clear(SK_PMColor4fWHITE);
-                // Setup an effect to put the original src rect at the correct logical place
-                // in the temp where the temp's origin is at the top left of refRect.
-                SkMatrix tm = SkMatrix::MakeTrans(refRect.left(), refRect.top());
-                auto fp = GrTextureEffect::MakeSubset(src, kPremul_SkAlphaType, tm, sampler,
-                                                      SkRect::Make(srcRect), caps);
-                GrPaint paint;
-                paint.addColorFragmentProcessor(std::move(fp));
-                refSrc->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(),
-                                 SkRect::Make(refRect.size()));
-            }
-            // Do a blur for each dstRect in the set over our testArea-sized background.
-            for (const auto& dstRect : dstRectSet) {
-                // Setup the normal blur args.
-                const SkScalar sigmaX = src.width()  / 10.f;
-                const SkScalar sigmaY = src.height() / 10.f;
-                auto blurSrc = src;
-                auto blurMode = mode;
-                auto blurDstRect = dstRect;
-                auto blurSrcRect = srcRect;
-                if (ref) {
-                    // Move the dst rect to be relative to our temp surface.
-                    blurDstRect = dstRect.makeOffset(-refRect.topLeft());
-                    // Our new src is the entire temp containing the tiled original.
-                    blurSrcRect = SkIRect::MakeSize(refRect.size());
-                    // This shouldn't really matter because we should have made a large enough
-                    // temp that the edges don't come into play. But this puts us on a simpler
-                    // path through SkGpuBlurUtils.
-                    blurMode = SkTileMode::kClamp;
-                    blurSrc = refSrc->readSurfaceView();
+    static constexpr SkScalar kPad = 5;
+
+    for (const auto& srcRect : srcRects) {
+        SkIRect testArea = SkIRect::MakeSize(srcRect.size());
+        testArea.outset(testArea.width(), testArea.height());
+        for (const auto& dstRect : dstRects) {
+            for (int t = 0; t < kSkTileModeCount; ++t) {
+                auto mode = static_cast<SkTileMode>(t);
+                GrSamplerState sampler(SkTileModeToWrapMode(mode),
+                                       GrSamplerState::Filter::kNearest);
+                SkMatrix m = SkMatrix::MakeTrans(trans.x() - testArea.x(),
+                                                 trans.y() - testArea.y());
+                // Draw the src subset in the tile mode faded as a reference before drawing the blur
+                // on top
+                {
+                    auto fp = GrTextureEffect::MakeSubset(src, kPremul_SkAlphaType, SkMatrix::I(),
+                                                          sampler, SkRect::Make(srcRect), caps);
+                    GrPaint paint;
+                    paint.addColorFragmentProcessor(std::move(fp));
+                    static constexpr float kAlpha = 0.2f;
+                    paint.setColor4f({kAlpha, kAlpha, kAlpha, kAlpha});
+                    rtc->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, m,
+                                  SkRect::Make(testArea));
                 }
                 // Blur using the rect and draw on top.
-                if (auto blurView = blur(ctx, blurSrc, blurDstRect, blurSrcRect, sigmaX, sigmaY,
-                                         blurMode)) {
+                if (auto blurView = blur(dstRect, srcRect, mode)) {
                     auto fp = GrTextureEffect::Make(blurView, kPremul_SkAlphaType, SkMatrix::I(),
                                                     sampler, caps);
                     GrPaint paint;
@@ -196,6 +120,18 @@ static void run(GrContext* ctx, GrRenderTargetContext* rtc, bool subsetSrc, bool
                     rtc->fillRectToRect(GrNoClip(), std::move(paint), GrAA::kNo, m,
                                         SkRect::Make(dstRect), SkRect::Make(blurView.dimensions()));
                 }
+                // Show the rect that's being blurred.
+                {
+                    GrPaint paint;
+                    static constexpr float kAlpha = 0.3f;
+                    paint.setColor4f({0, 0, 0, kAlpha});
+                    SkPaint stroke;
+                    stroke.setStyle(SkPaint::kStroke_Style);
+                    stroke.setStrokeWidth(1.f);
+                    GrStyle style(stroke);
+                    auto srcR = SkRect::Make(srcRect).makeOutset(0.5f, 0.5f);
+                    rtc->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, m, srcR, &style);
+                }
                 // Show the outline of the dst rect. Mostly for kDecal but also allows visual
                 // confirmation that the resulting blur is the right size and in the right place.
                 {
@@ -209,34 +145,10 @@ static void run(GrContext* ctx, GrRenderTargetContext* rtc, bool subsetSrc, bool
                     auto dstR = SkRect::Make(dstRect).makeOutset(0.5f, 0.5f);
                     rtc->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, m, dstR, &style);
                 }
+                trans.fX += testArea.width() + kPad;
             }
-            // Show the rect that's being blurred.
-            {
-                GrPaint paint;
-                static constexpr float kAlpha = 0.3f;
-                paint.setColor4f({0, 0, 0, kAlpha});
-                SkPaint stroke;
-                stroke.setStyle(SkPaint::kStroke_Style);
-                stroke.setStrokeWidth(1.f);
-                GrStyle style(stroke);
-                auto srcR = SkRect::Make(srcRect).makeOutset(0.5f, 0.5f);
-                rtc->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, m, srcR, &style);
-            }
-            trans.fX += testArea.width() + kPad;
+            trans.fX = 0;
+            trans.fY += testArea.height() + kPad;
         }
-        trans.fX = kPad;
-        trans.fY += testArea.height() + kPad;
     }
 }
-
-DEF_SIMPLE_GPU_GM(gpu_blur_utils, ctx, rtc, canvas, 765, 765) { run(ctx, rtc, false, false); }
-
-DEF_SIMPLE_GPU_GM(gpu_blur_utils_ref, ctx, rtc, canvas, 765, 765) { run(ctx, rtc, false, true); }
-
-DEF_SIMPLE_GPU_GM(gpu_blur_utils_subset_rect, ctx, rtc, canvas, 765, 765) {
-    run(ctx, rtc, true, false);
-}
-
-DEF_SIMPLE_GPU_GM(gpu_blur_utils_subset_ref, ctx, rtc, canvas, 765, 765) {
-    run(ctx, rtc, true, true);
-}

gn/core.gni

@@ -236,7 +236,6 @@ skia_core_sources = [
   "$_src/core/SkImageInfo.cpp",
   "$_src/core/SkLatticeIter.cpp",
   "$_src/core/SkLatticeIter.h",
-  "$_src/core/SkLegacyGpuBlurUtils.cpp",
   "$_src/core/SkLineClipper.cpp",
   "$_src/core/SkLocalMatrixImageFilter.cpp",
   "$_src/core/SkLocalMatrixImageFilter.h",