Switch SkDisplacementImageFilter over to new onFilterImage interface

src/effects/SkDisplacementMapEffect.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 "SkDisplacementMapEffect.h"
-#include "SkDevice.h"
+
+#include "SkBitmap.h"
 #include "SkReadBuffer.h"
+#include "SkSpecialImage.h"
 #include "SkWriteBuffer.h"
 #include "SkUnPreMultiply.h"
 #include "SkColorPriv.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrCoordTransform.h"
 #include "GrInvariantOutput.h"
 #include "SkGr.h"
 #include "effects/GrTextureDomain.h"
@@ skipping 29 matching lines @@
 }
 
 template<> uint32_t getValue<SkDisplacementMapEffect::kA_ChannelSelectorType>(
     SkColor l, const SkUnPreMultiply::Scale*) {
     return SkGetPackedA32(l);
 }
 
 template<SkDisplacementMapEffect::ChannelSelectorType typeX,
          SkDisplacementMapEffect::ChannelSelectorType typeY>
 void computeDisplacement(const SkVector& scale, SkBitmap* dst,
-                         SkBitmap* displ, const SkIPoint& offset,
-                         SkBitmap* src,
-                         const SkIRect& bounds)
-{
+                         const SkPixmap& displ, const SkIPoint& offset,
+                         const SkPixmap& src,
+                         const SkIRect& bounds) {
     static const SkScalar Inv8bit = SkScalarInvert(255);
-    const int srcW = src->width();
-    const int srcH = src->height();
+    const int srcW = src.width();
+    const int srcH = src.height();
     const SkVector scaleForColor = SkVector::Make(SkScalarMul(scale.fX, Inv8bit),
                                                   SkScalarMul(scale.fY, Inv8bit));
     const SkVector scaleAdj = SkVector::Make(SK_ScalarHalf - SkScalarMul(scale.fX, SK_ScalarHalf),
                                              SK_ScalarHalf - SkScalarMul(scale.fY, SK_ScalarHalf));
     const SkUnPreMultiply::Scale* table = SkUnPreMultiply::GetScaleTable();
     SkPMColor* dstPtr = dst->getAddr32(0, 0);
     for (int y = bounds.top(); y < bounds.bottom(); ++y) {
-        const SkPMColor* displPtr = displ->getAddr32(bounds.left() + offset.fX,
-                                                     y + offset.fY);
+        const SkPMColor* displPtr = displ.addr32(bounds.left() + offset.fX, y + offset.fY);
         for (int x = bounds.left(); x < bounds.right(); ++x, ++displPtr) {
             const SkScalar displX = SkScalarMul(scaleForColor.fX,
                 SkIntToScalar(getValue<typeX>(*displPtr, table))) + scaleAdj.fX;
             const SkScalar displY = SkScalarMul(scaleForColor.fY,
                 SkIntToScalar(getValue<typeY>(*displPtr, table))) + scaleAdj.fY;
             // Truncate the displacement values
             const int srcX = x + SkScalarTruncToInt(displX);
             const int srcY = y + SkScalarTruncToInt(displY);
             *dstPtr++ = ((srcX < 0) || (srcX >= srcW) || (srcY < 0) || (srcY >= srcH)) ?
-                      0 : *(src->getAddr32(srcX, srcY));
+                      0 : *(src.addr32(srcX, srcY));
         }
     }
 }
 
 template<SkDisplacementMapEffect::ChannelSelectorType typeX>
 void computeDisplacement(SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
                          const SkVector& scale, SkBitmap* dst,
-                         SkBitmap* displ, const SkIPoint& offset,
-                         SkBitmap* src,
-                         const SkIRect& bounds)
-{
+                         const SkPixmap& displ, const SkIPoint& offset,
+                         const SkPixmap& src,
+                         const SkIRect& bounds) {
     switch (yChannelSelector) {
       case SkDisplacementMapEffect::kR_ChannelSelectorType:
         computeDisplacement<typeX, SkDisplacementMapEffect::kR_ChannelSelectorType>(
             scale, dst, displ, offset, src, bounds);
         break;
       case SkDisplacementMapEffect::kG_ChannelSelectorType:
         computeDisplacement<typeX, SkDisplacementMapEffect::kG_ChannelSelectorType>(
             scale, dst, displ, offset, src, bounds);
         break;
       case SkDisplacementMapEffect::kB_ChannelSelectorType:
         computeDisplacement<typeX, SkDisplacementMapEffect::kB_ChannelSelectorType>(
             scale, dst, displ, offset, src, bounds);
         break;
       case SkDisplacementMapEffect::kA_ChannelSelectorType:
         computeDisplacement<typeX, SkDisplacementMapEffect::kA_ChannelSelectorType>(
             scale, dst, displ, offset, src, bounds);
         break;
       case SkDisplacementMapEffect::kUnknown_ChannelSelectorType:
       default:
         SkDEBUGFAIL("Unknown Y channel selector");
     }
 }
 
 void computeDisplacement(SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
                          SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
                          const SkVector& scale, SkBitmap* dst,
-                         SkBitmap* displ, const SkIPoint& offset,
-                         SkBitmap* src,
-                         const SkIRect& bounds)
-{
+                         const SkPixmap& displ, const SkIPoint& offset,
+                         const SkPixmap& src,
+                         const SkIRect& bounds) {
     switch (xChannelSelector) {
       case SkDisplacementMapEffect::kR_ChannelSelectorType:
         computeDisplacement<SkDisplacementMapEffect::kR_ChannelSelectorType>(
             yChannelSelector, scale, dst, displ, offset, src, bounds);
         break;
       case SkDisplacementMapEffect::kG_ChannelSelectorType:
         computeDisplacement<SkDisplacementMapEffect::kG_ChannelSelectorType>(
             yChannelSelector, scale, dst, displ, offset, src, bounds);
         break;
       case SkDisplacementMapEffect::kB_ChannelSelectorType:
@@ skipping 41 matching lines @@
 
     SkImageFilter* inputs[2] = { displacement, color };
     return new SkDisplacementMapEffect(xChannelSelector, yChannelSelector, scale, inputs, cropRect);
 }
 
 SkDisplacementMapEffect::SkDisplacementMapEffect(ChannelSelectorType xChannelSelector,
                                                  ChannelSelectorType yChannelSelector,
                                                  SkScalar scale,
                                                  SkImageFilter* inputs[2],
                                                  const CropRect* cropRect)
-  : INHERITED(2, inputs, cropRect)
-  , fXChannelSelector(xChannelSelector)
-  , fYChannelSelector(yChannelSelector)
-  , fScale(scale)
-{
+    : INHERITED(2, inputs, cropRect)
+    , fXChannelSelector(xChannelSelector)
+    , fYChannelSelector(yChannelSelector)
+    , fScale(scale) {
 }
 
 SkDisplacementMapEffect::~SkDisplacementMapEffect() {
 }
 
 SkFlattenable* SkDisplacementMapEffect::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
     ChannelSelectorType xsel = (ChannelSelectorType)buffer.readInt();
     ChannelSelectorType ysel = (ChannelSelectorType)buffer.readInt();
     SkScalar scale = buffer.readScalar();
     return Create(xsel, ysel, scale,
                   common.getInput(0).get(), common.getInput(1).get(), &common.cropRect());
 }
 
 void SkDisplacementMapEffect::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt((int) fXChannelSelector);
     buffer.writeInt((int) fYChannelSelector);
     buffer.writeScalar(fScale);
 }
 
-bool SkDisplacementMapEffect::onFilterImageDeprecated(Proxy* proxy,
-                                                      const SkBitmap& src,
-                                                      const Context& ctx,
-                                                      SkBitmap* dst,
-                                                      SkIPoint* offset) const {
-    SkBitmap displ = src, color = src;
-    SkIPoint colorOffset = SkIPoint::Make(0, 0), displOffset = SkIPoint::Make(0, 0);
-    if (!this->filterInputDeprecated(1, proxy, src, ctx, &color, &colorOffset) ||
-        !this->filterInputDeprecated(0, proxy, src, ctx, &displ, &displOffset)) {
-        return false;
-    }
-    if ((displ.colorType() != kN32_SkColorType) ||
-        (color.colorType() != kN32_SkColorType)) {
-        return false;
-    }
-    SkIRect bounds;
-    // Since computeDisplacement does bounds checking on color pixel access, we don't need to pad
-    // the color bitmap to bounds here.
-    SkIRect srcBounds = color.bounds();
-    srcBounds.offset(colorOffset);
-    if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
-        return false;
-    }
-    SkIRect displBounds;
-    if (!this->applyCropRectDeprecated(ctx, proxy, displ, &displOffset, &displBounds, &displ)) {
-        return false;
-    }
-    if (!bounds.intersect(displBounds)) {
-        return false;
-    }
-    SkAutoLockPixels alp_displacement(displ), alp_color(color);
-    if (!displ.getPixels() || !color.getPixels()) {
-        return false;
+sk_sp<SkSpecialImage> SkDisplacementMapEffect::onFilterImage(SkSpecialImage* source,
+                                                             const Context& ctx,
+                                                             SkIPoint* offset) const {
+    SkIPoint colorOffset = SkIPoint::Make(0, 0);
+    sk_sp<SkSpecialImage> color(this->filterInput(1, source, ctx, &colorOffset));
+    if (!color) {
+        return nullptr;
     }
 
-    SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
-    if (!device) {
-        return false;
+    SkIPoint displOffset = SkIPoint::Make(0, 0);
+    sk_sp<SkSpecialImage> displ(this->filterInput(0, source, ctx, &displOffset));
+    if (!displ) {
+        return nullptr;
     }
-    *dst = device->accessBitmap(false);
-    SkAutoLockPixels alp_dst(*dst);
+
+    const SkIRect srcBounds = SkIRect::MakeXYWH(colorOffset.x(), colorOffset.y(),
+                                                color->width(), color->height());
+
+    // Both paths do bounds checking on color pixel access, we don't need to
+    // pad the color bitmap to bounds here.
+    SkIRect bounds;
+    if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
+        return nullptr;
+    }
+
+    SkIRect displBounds;
+    displ = this->applyCropRect(ctx, displ.get(), &displOffset, &displBounds);
+    if (!displ) {
+        return nullptr;
+    }
+
+    if (!bounds.intersect(displBounds)) {
+        return nullptr;
+    }
+
+    const SkIRect colorBounds = bounds.makeOffset(-colorOffset.x(), -colorOffset.y());
 
     SkVector scale = SkVector::Make(fScale, fScale);
     ctx.ctm().mapVectors(&scale, 1);
-    SkIRect colorBounds = bounds;
-    colorBounds.offset(-colorOffset);
 
-    computeDisplacement(fXChannelSelector, fYChannelSelector, scale, dst,
-                        &displ, colorOffset - displOffset, &color, colorBounds);
+#if SK_SUPPORT_GPU
+    if (color->peekTexture()) {

[Stephen White, 2016/04/04 16:55:14]

Nit: I didn't notice that you were using color->peekTexture() to switch to the
GPU path (hence my confusion). I wonder if we should use source->peekTexture()
instead (in all filters)? That should always be the case, since it's the
infrastructure which sets up the source primitive. Then we could assert that all
inputs have textures.

[robertphillips, 2016/04/04 17:58:37]

Done - here. I will post a separate patch to switch over the other ImageFilters.

+        GrTexture* colorTexture = color->peekTexture();
+        GrTexture* displTexture = displ->peekTexture();
+
+        // If color is texture-backed, displ should also be texture-backed or
+        // filterInput should've returned nullptr
+        SkASSERT(colorTexture && displTexture);
+
+        GrContext* context = colorTexture->getContext();
+
+        GrSurfaceDesc desc;
+        desc.fFlags = kRenderTarget_GrSurfaceFlag;
+        desc.fWidth = bounds.width();
+        desc.fHeight = bounds.height();
+        desc.fConfig = kSkia8888_GrPixelConfig;
+
+        SkAutoTUnref<GrTexture> dst(context->textureProvider()->createApproxTexture(desc));
+        if (!dst) {
+            return nullptr;
+        }
+
+        GrPaint paint;
+        SkMatrix offsetMatrix = GrCoordTransform::MakeDivByTextureWHMatrix(displTexture);
+        offsetMatrix.preTranslate(SkIntToScalar(colorOffset.fX - displOffset.fX),
+                                  SkIntToScalar(colorOffset.fY - displOffset.fY));
+
+        paint.addColorFragmentProcessor(
+            GrDisplacementMapEffect::Create(fXChannelSelector,
+                                            fYChannelSelector,
+                                            scale,
+                                            displTexture,
+                                            offsetMatrix,
+                                            colorTexture,
+                                            SkISize::Make(color->width(),
+                                                          color->height())))->unref();
+        paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
+        SkMatrix matrix;
+        matrix.setTranslate(-SkIntToScalar(colorBounds.x()), -SkIntToScalar(colorBounds.y()));
+
+        SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(dst->asRenderTarget()));
+        if (!drawContext) {
+            return nullptr;
+        }
+
+        drawContext->drawRect(GrClip::WideOpen(), paint, matrix, SkRect::Make(colorBounds));
+
+        offset->fX = bounds.left();
+        offset->fY = bounds.top();
+        return SkSpecialImage::MakeFromGpu(source->internal_getProxy(),
+                                           SkIRect::MakeWH(bounds.width(), bounds.height()),
+                                           kNeedNewImageUniqueID_SpecialImage,
+                                           dst);
+    }
+#endif
+
+    SkPixmap colorPixmap, displPixmap;
+
+    if (!color->peekPixels(&colorPixmap) || !displ->peekPixels(&displPixmap)) {
+        return nullptr;
+    }
+
+    if ((colorPixmap.colorType() != kN32_SkColorType) ||
+        (displPixmap.colorType() != kN32_SkColorType)) {
+        return nullptr;
+    }
+
+    SkImageInfo info = SkImageInfo::MakeN32(bounds.width(), bounds.height(),
+                                            colorPixmap.alphaType());
+
+    SkBitmap dst2;

[Stephen White, 2016/04/04 16:56:55]

Nit: "dst2" could be "dst"

[robertphillips, 2016/04/04 17:58:37]

Done.

+    if (!dst2.tryAllocPixels(info)) {
+        return nullptr;
+    }
+
+    SkAutoLockPixels dstLock(dst2);
+
+    computeDisplacement(fXChannelSelector, fYChannelSelector, scale, &dst2,
+                        displPixmap, colorOffset - displOffset, colorPixmap, colorBounds);
 
     offset->fX = bounds.left();
     offset->fY = bounds.top();
-    return true;
+    return SkSpecialImage::MakeFromRaster(source->internal_getProxy(),
+                                          SkIRect::MakeWH(bounds.width(), bounds.height()),
+                                          dst2);
 }
 
 SkRect SkDisplacementMapEffect::computeFastBounds(const SkRect& src) const {
     SkRect bounds = this->getColorInput() ? this->getColorInput()->computeFastBounds(src) : src;
     bounds.outset(SkScalarAbs(fScale) * SK_ScalarHalf, SkScalarAbs(fScale) * SK_ScalarHalf);
     return bounds;
 }
 
 SkIRect SkDisplacementMapEffect::onFilterNodeBounds(const SkIRect& src, const SkMatrix& ctm,
                                                     MapDirection) const {
@@ skipping 55 matching lines @@
             SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
             SkDisplacementMapEffect::ChannelSelectorType yChannelSelector, SkVector scale,
             GrTexture* displacement, const SkMatrix& offsetMatrix, GrTexture* color,
             const SkISize& colorDimensions) {
         return new GrDisplacementMapEffect(xChannelSelector, yChannelSelector, scale, displacement,
                                            offsetMatrix, color, colorDimensions);
     }
 
     virtual ~GrDisplacementMapEffect();
 
-    SkDisplacementMapEffect::ChannelSelectorType xChannelSelector() const
-        { return fXChannelSelector; }
-    SkDisplacementMapEffect::ChannelSelectorType yChannelSelector() const
-        { return fYChannelSelector; }
+    SkDisplacementMapEffect::ChannelSelectorType xChannelSelector() const {
+        return fXChannelSelector;
+    }
+    SkDisplacementMapEffect::ChannelSelectorType yChannelSelector() const {
+        return fYChannelSelector;
+    }
     const SkVector& scale() const { return fScale; }
 
     const char* name() const override { return "DisplacementMap"; }
     const GrTextureDomain& domain() const { return fDomain; }
 
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
         return new GrGLDisplacementMapEffect;
     }
 
@@ skipping 19 matching lines @@
     GrCoordTransform            fColorTransform;
     GrTextureDomain             fDomain;
     GrTextureAccess             fColorAccess;
     SkDisplacementMapEffect::ChannelSelectorType fXChannelSelector;
     SkDisplacementMapEffect::ChannelSelectorType fYChannelSelector;
     SkVector fScale;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
-bool SkDisplacementMapEffect::filterImageGPUDeprecated(Proxy* proxy, const SkBitmap& src,
-                                                       const Context& ctx,
-                                                       SkBitmap* result, SkIPoint* offset) const {
-    SkBitmap colorBM = src;
-    SkIPoint colorOffset = SkIPoint::Make(0, 0);
-    if (!this->filterInputGPUDeprecated(1, proxy, src, ctx, &colorBM, &colorOffset)) {
-        return false;
-    }
-    SkBitmap displacementBM = src;
-    SkIPoint displacementOffset = SkIPoint::Make(0, 0);
-    if (!this->filterInputGPUDeprecated(0, proxy, src, ctx, &displacementBM, &displacementOffset)) {
-        return false;
-    }
-    SkIRect srcBounds = colorBM.bounds();
-    srcBounds.offset(colorOffset);
-    SkIRect bounds;
-    // Since GrDisplacementMapEffect does bounds checking on color pixel access, we don't need to
-    // pad the color bitmap to bounds here.
-    if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
-        return false;
-    }
-    SkIRect displBounds;
-    if (!this->applyCropRectDeprecated(ctx, proxy, displacementBM,
-                                       &displacementOffset, &displBounds, &displacementBM)) {
-        return false;
-    }
-    if (!bounds.intersect(displBounds)) {
-        return false;
-    }
-    GrTexture* color = colorBM.getTexture();
-    GrTexture* displacement = displacementBM.getTexture();
-    GrContext* context = color->getContext();
-
-    GrSurfaceDesc desc;
-    desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = bounds.width();
-    desc.fHeight = bounds.height();
-    desc.fConfig = kSkia8888_GrPixelConfig;
-
-    SkAutoTUnref<GrTexture> dst(context->textureProvider()->createApproxTexture(desc));
-
-    if (!dst) {
-        return false;
-    }
-
-    SkVector scale = SkVector::Make(fScale, fScale);
-    ctx.ctm().mapVectors(&scale, 1);
-
-    GrPaint paint;
-    SkMatrix offsetMatrix = GrCoordTransform::MakeDivByTextureWHMatrix(displacement);
-    offsetMatrix.preTranslate(SkIntToScalar(colorOffset.fX - displacementOffset.fX),
-                              SkIntToScalar(colorOffset.fY - displacementOffset.fY));
-
-    paint.addColorFragmentProcessor(
-        GrDisplacementMapEffect::Create(fXChannelSelector,
-                                        fYChannelSelector,
-                                        scale,
-                                        displacement,
-                                        offsetMatrix,
-                                        color,
-                                        colorBM.dimensions()))->unref();
-    paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
-    SkIRect colorBounds = bounds;
-    colorBounds.offset(-colorOffset);
-    SkMatrix matrix;
-    matrix.setTranslate(-SkIntToScalar(colorBounds.x()),
-                        -SkIntToScalar(colorBounds.y()));
-
-    SkAutoTUnref<GrDrawContext> drawContext(context->drawContext(dst->asRenderTarget()));
-    if (!drawContext) {
-        return false;
-    }
-
-    drawContext->drawRect(GrClip::WideOpen(), paint, matrix, SkRect::Make(colorBounds));
-    offset->fX = bounds.left();
-    offset->fY = bounds.top();
-    GrWrapTextureInBitmap(dst, bounds.width(), bounds.height(), false, result);
-    return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 GrDisplacementMapEffect::GrDisplacementMapEffect(
                              SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
                              SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
                              const SkVector& scale,
                              GrTexture* displacement,
                              const SkMatrix& offsetMatrix,
                              GrTexture* color,
                              const SkISize& colorDimensions)
     : fDisplacementTransform(kLocal_GrCoordSet, offsetMatrix, displacement,
                              GrTextureParams::kNone_FilterMode)
@@ skipping 148 matching lines @@
 void GrGLDisplacementMapEffect::GenKey(const GrProcessor& proc,
                                        const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     const GrDisplacementMapEffect& displacementMap = proc.cast<GrDisplacementMapEffect>();
 
     uint32_t xKey = displacementMap.xChannelSelector();
     uint32_t yKey = displacementMap.yChannelSelector() << kChannelSelectorKeyBits;
 
     b->add32(xKey | yKey);
 }
 #endif