Make SkGpuBlurUtils::GaussianBlur more drawContext centric

src/effects/SkGpuBlurUtils.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuBlurUtils.h"
 
 #include "SkRect.h"
@@ skipping 145 matching lines @@
         // Draw right and left margins with bounds; middle without.
         convolve_gaussian_1d(drawContext, clip, leftRect, srcOffset, texture,
                              direction, radius, sigma, true, bounds);
         convolve_gaussian_1d(drawContext, clip, rightRect, srcOffset, texture,
                              direction, radius, sigma, true, bounds);
         convolve_gaussian_1d(drawContext, clip, midRect, srcOffset, texture,
                              direction, radius, sigma, false, bounds);
     }
 }
 
-GrTexture* GaussianBlur(GrContext* context,
-                        GrTexture* srcTexture,
-                        bool gammaCorrect,
-                        const SkRect& dstBounds,
-                        const SkRect* srcBounds,
-                        float sigmaX,
-                        float sigmaY) {
+sk_sp<GrDrawContext> GaussianBlur(GrContext* context,
+                                  GrTexture* origSrc,
+                                  bool gammaCorrect,
+                                  const SkRect& dstBounds,
+                                  const SkRect* srcBounds,
+                                  float sigmaX,
+                                  float sigmaY) {
     SkASSERT(context);
     SkIRect clearRect;
     int scaleFactorX, radiusX;
     int scaleFactorY, radiusY;
     int maxTextureSize = context->caps()->maxTextureSize();
     sigmaX = adjust_sigma(sigmaX, maxTextureSize, &scaleFactorX, &radiusX);
     sigmaY = adjust_sigma(sigmaY, maxTextureSize, &scaleFactorY, &radiusY);
 
     SkPoint srcOffset = SkPoint::Make(-dstBounds.x(), -dstBounds.y());
     SkRect localDstBounds = SkRect::MakeWH(dstBounds.width(), dstBounds.height());
     SkRect localSrcBounds;
     SkRect srcRect;
     if (srcBounds) {
         srcRect = localSrcBounds = *srcBounds;
         srcRect.offset(srcOffset);
         srcBounds = &localSrcBounds;
     } else {
         srcRect = localDstBounds;
     }
 
     scale_rect(&srcRect, 1.0f / scaleFactorX, 1.0f / scaleFactorY);
     srcRect.roundOut(&srcRect);
     scale_rect(&srcRect, static_cast<float>(scaleFactorX),
                          static_cast<float>(scaleFactorY));
 
     // setup new clip
     GrClip clip(localDstBounds);
 
+    sk_sp<GrTexture> srcTexture(sk_ref_sp(origSrc));
+
     SkASSERT(kBGRA_8888_GrPixelConfig == srcTexture->config() ||
              kRGBA_8888_GrPixelConfig == srcTexture->config() ||
              kSRGBA_8888_GrPixelConfig == srcTexture->config() ||
              kSBGRA_8888_GrPixelConfig == srcTexture->config() ||
              kAlpha_8_GrPixelConfig == srcTexture->config());
 
     const int width = SkScalarFloorToInt(dstBounds.width());
     const int height = SkScalarFloorToInt(dstBounds.height());
     const GrPixelConfig config = srcTexture->config();
 
     const SkSurfaceProps props(gammaCorrect ? SkSurfaceProps::kGammaCorrect_Flag : 0,
                                SkSurfaceProps::kLegacyFontHost_InitType);
 
+    sk_sp<GrDrawContext> dstDrawContext(context->newDrawContext(SkBackingFit::kApprox,
+                                                                width, height, config,
+                                                                0, kDefault_GrSurfaceOrigin,
+                                                                &props));
+    if (!dstDrawContext) {
+        return nullptr;
+    }
+
     // For really small blurs (certainly no wider than 5x5 on desktop gpus) it is faster to just
     // launch a single non separable kernel vs two launches
     if (sigmaX > 0.0f && sigmaY > 0.0f &&
             (2 * radiusX + 1) * (2 * radiusY + 1) <= MAX_KERNEL_SIZE) {
         // We shouldn't be scaling because this is a small size blur
         SkASSERT((1 == scaleFactorX) && (1 == scaleFactorY));
 
-        sk_sp<GrDrawContext> dstDrawContext(context->newDrawContext(SkBackingFit::kApprox,
-                                                                    width, height, config,
-                                                                    0, kDefault_GrSurfaceOrigin,
-                                                                    &props));
-        if (!dstDrawContext) {
-            return nullptr;
-        }
         convolve_gaussian_2d(dstDrawContext.get(), clip, localDstBounds, srcOffset,
-                             srcTexture, radiusX, radiusY, sigmaX, sigmaY, srcBounds);
+                             srcTexture.get(), radiusX, radiusY, sigmaX, sigmaY, srcBounds);
 
-        return dstDrawContext->asTexture().release();
+        return dstDrawContext;
     } 
 
-    GrSurfaceDesc desc;
-    desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = width;
-    desc.fHeight = height;
-    desc.fConfig = config;
-
-    GrTexture* dstTexture;
-    GrTexture* tempTexture;
-    SkAutoTUnref<GrTexture> temp1, temp2;
-
-    temp1.reset(context->textureProvider()->createApproxTexture(desc));
-    dstTexture = temp1.get();
-    temp2.reset(context->textureProvider()->createApproxTexture(desc));
-    tempTexture = temp2.get();
-
-    if (!dstTexture || !tempTexture) {
+    sk_sp<GrDrawContext> tmpDrawContext(context->newDrawContext(SkBackingFit::kApprox,
+                                                                width, height, config,
+                                                                0, kDefault_GrSurfaceOrigin,
+                                                                &props));
+    if (!tmpDrawContext) {
         return nullptr;
     }
 
     sk_sp<GrDrawContext> srcDrawContext;
 
     for (int i = 1; i < scaleFactorX || i < scaleFactorY; i *= 2) {
         GrPaint paint;
         paint.setGammaCorrect(gammaCorrect);
         SkMatrix matrix;
         matrix.setIDiv(srcTexture->width(), srcTexture->height());
         SkRect dstRect(srcRect);
         if (srcBounds && i == 1) {
             SkRect domain;
             matrix.mapRect(&domain, *srcBounds);
             domain.inset((i < scaleFactorX) ? SK_ScalarHalf / srcTexture->width() : 0.0f,
                          (i < scaleFactorY) ? SK_ScalarHalf / srcTexture->height() : 0.0f);
             sk_sp<const GrFragmentProcessor> fp(GrTextureDomainEffect::Create(
-                                                        srcTexture,
+                                                        srcTexture.get(),
                                                         matrix,
                                                         domain,
                                                         GrTextureDomain::kDecal_Mode,
                                                         GrTextureParams::kBilerp_FilterMode));
             paint.addColorFragmentProcessor(fp.get());
             srcRect.offset(-srcOffset);
             srcOffset.set(0, 0);
         } else {
             GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
-            paint.addColorTextureProcessor(srcTexture, matrix, params);
+            paint.addColorTextureProcessor(srcTexture.get(), matrix, params);
         }
         paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
         scale_rect(&dstRect, i < scaleFactorX ? 0.5f : 1.0f,
                              i < scaleFactorY ? 0.5f : 1.0f);
 
-        sk_sp<GrDrawContext> dstDrawContext(
-                                   context->drawContext(sk_ref_sp(dstTexture->asRenderTarget())));
-        if (!dstDrawContext) {
-            return nullptr;
-        }
         dstDrawContext->fillRectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
 
-        srcDrawContext.swap(dstDrawContext);
+        srcDrawContext = dstDrawContext;
         srcRect = dstRect;
-        srcTexture = dstTexture;
-        SkTSwap(dstTexture, tempTexture);
+        srcTexture = srcDrawContext->asTexture();
+        dstDrawContext.swap(tmpDrawContext);
         localSrcBounds = srcRect;
     }
 
     srcRect = localDstBounds;
 
     scale_rect(&srcRect, 1.0f / scaleFactorX, 1.0f / scaleFactorY);
     srcRect.roundOut(&srcRect);
     SkIRect srcIRect = srcRect.roundOut();
     if (sigmaX > 0.0f) {
         if (scaleFactorX > 1) {
-            // TODO: if we pass in the source draw context we don't need this here
-            if (!srcDrawContext) {
-                srcDrawContext = context->drawContext(sk_ref_sp(srcTexture->asRenderTarget()));
-                if (!srcDrawContext) {
-                    return nullptr;
-                }
-            }
+            SkASSERT(srcDrawContext);
 
             // Clear out a radius to the right of the srcRect to prevent the
             // X convolution from reading garbage.
             clearRect = SkIRect::MakeXYWH(srcIRect.fRight, srcIRect.fTop,
                                           radiusX, srcIRect.height());
             srcDrawContext->clear(&clearRect, 0x0, false);
         }
 
-        sk_sp<GrDrawContext> dstDrawContext(
-            context->drawContext(sk_ref_sp(dstTexture->asRenderTarget()), &props));
-        if (!dstDrawContext) {
-            return nullptr;
-        }
         convolve_gaussian(dstDrawContext.get(), clip, srcRect,
-                          srcTexture, Gr1DKernelEffect::kX_Direction, radiusX, sigmaX,
+                          srcTexture.get(), Gr1DKernelEffect::kX_Direction, radiusX, sigmaX,
                           srcBounds, srcOffset);
-        srcDrawContext.swap(dstDrawContext);
-        srcTexture = dstTexture;
+        srcDrawContext = dstDrawContext;
+        srcTexture = srcDrawContext->asTexture();
         srcRect.offsetTo(0, 0);
-        SkTSwap(dstTexture, tempTexture);
+        dstDrawContext.swap(tmpDrawContext);
         localSrcBounds = srcRect;
         srcOffset.set(0, 0);
     }
 
     if (sigmaY > 0.0f) {
         if (scaleFactorY > 1 || sigmaX > 0.0f) {
-            // TODO: if we pass in the source draw context we don't need this here
-            if (!srcDrawContext) {
-                srcDrawContext = context->drawContext(sk_ref_sp(srcTexture->asRenderTarget()));
-                if (!srcDrawContext) {
-                    return nullptr;
-                }
-            }
+            SkASSERT(srcDrawContext);
 
             // Clear out a radius below the srcRect to prevent the Y
             // convolution from reading garbage.
             clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom,
                                           srcIRect.width(), radiusY);
             srcDrawContext->clear(&clearRect, 0x0, false);
         }
 
-        sk_sp<GrDrawContext> dstDrawContext(
-            context->drawContext(sk_ref_sp(dstTexture->asRenderTarget()), &props));
-        if (!dstDrawContext) {
-            return nullptr;
-        }
         convolve_gaussian(dstDrawContext.get(), clip, srcRect,
-                          srcTexture, Gr1DKernelEffect::kY_Direction, radiusY, sigmaY,
+                          srcTexture.get(), Gr1DKernelEffect::kY_Direction, radiusY, sigmaY,
                           srcBounds, srcOffset);
 
-        srcDrawContext.swap(dstDrawContext);
-        srcTexture = dstTexture;
+        srcDrawContext = dstDrawContext;
         srcRect.offsetTo(0, 0);
-        SkTSwap(dstTexture, tempTexture);
+        dstDrawContext.swap(tmpDrawContext);
     }
 
+    SkASSERT(srcDrawContext);
+    srcTexture = nullptr;     // we don't use this from here on out
     srcIRect = srcRect.roundOut();
 
     if (scaleFactorX > 1 || scaleFactorY > 1) {
-        SkASSERT(srcDrawContext);
+        // Clear one pixel to the right and below, to accommodate bilinear upsampling.
+        clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom, srcIRect.width() + 1, 1);
+        srcDrawContext->clear(&clearRect, 0x0, false);
+        clearRect = SkIRect::MakeXYWH(srcIRect.fRight, srcIRect.fTop, 1, srcIRect.height());
+        srcDrawContext->clear(&clearRect, 0x0, false);
 
-        // Clear one pixel to the right and below, to accommodate bilinear
-        // upsampling.
-        clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom,
-                                      srcIRect.width() + 1, 1);
-        srcDrawContext->clear(&clearRect, 0x0, false);
-        clearRect = SkIRect::MakeXYWH(srcIRect.fRight, srcIRect.fTop,
-                                      1, srcIRect.height());
-        srcDrawContext->clear(&clearRect, 0x0, false);
         SkMatrix matrix;
-        matrix.setIDiv(srcTexture->width(), srcTexture->height());
+        matrix.setIDiv(srcDrawContext->width(), srcDrawContext->height());
 
         GrPaint paint;
         paint.setGammaCorrect(gammaCorrect);
         // FIXME:  this should be mitchell, not bilinear.
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
-        paint.addColorTextureProcessor(srcTexture, matrix, params);
+        sk_sp<GrTexture> tex(srcDrawContext->asTexture());
+        paint.addColorTextureProcessor(tex.get(), matrix, params);
         paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
 
         SkRect dstRect(srcRect);
         scale_rect(&dstRect, (float) scaleFactorX, (float) scaleFactorY);
 
-        sk_sp<GrDrawContext> dstDrawContext(
-                                context->drawContext(sk_ref_sp(dstTexture->asRenderTarget())));
-        if (!dstDrawContext) {
-            return nullptr;
-        }
         dstDrawContext->fillRectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect);
 
-        srcDrawContext.swap(dstDrawContext);
+        srcDrawContext = dstDrawContext;
         srcRect = dstRect;
-        srcTexture = dstTexture;
-        SkTSwap(dstTexture, tempTexture);
+        dstDrawContext.swap(tmpDrawContext);
     }
 
-    return SkRef(srcTexture);
+    return srcDrawContext;
 }
 #endif
 
 }