add applyFilter() to SkImage

src/image/SkImage_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapCache.h"
 #include "SkImage_Gpu.h"
 #include "GrCaps.h"
@@ skipping 20 matching lines @@
         SkNotifyBitmapGenIDIsStale(this->uniqueID());
     }
 }
 
 extern void SkTextureImageApplyBudgetedDecision(SkImage* image) {
     if (as_IB(image)->getTexture()) {
         ((SkImage_Gpu*)image)->applyBudgetDecision();
     }
 }
 
+static SkImageInfo make_info(int w, int h, bool isOpaque) {
+    return SkImageInfo::MakeN32(w, h, isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
+}
+
 bool SkImage_Gpu::getROPixels(SkBitmap* dst) const {
     if (SkBitmapCache::Find(this->uniqueID(), dst)) {
         SkASSERT(dst->getGenerationID() == this->uniqueID());
         SkASSERT(dst->isImmutable());
         SkASSERT(dst->getPixels());
         return true;
     }
 
-    SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-    if (!dst->tryAllocPixels(SkImageInfo::MakeN32(this->width(), this->height(), at))) {
+    if (!dst->tryAllocPixels(make_info(this->width(), this->height(), this->isOpaque()))) {
         return false;
     }
     if (!fTexture->readPixels(0, 0, dst->width(), dst->height(), kSkia8888_GrPixelConfig,
                               dst->getPixels(), dst->rowBytes())) {
         return false;
     }
 
     dst->pixelRef()->setImmutableWithID(this->uniqueID());
     SkBitmapCache::Add(this->uniqueID(), *dst);
     fAddedRasterVersionToCache.store(true);
@@ skipping 115 matching lines @@
     if (!subTx) {
         return nullptr;
     }
     ctx->copySurface(subTx, fTexture, subset, SkIPoint::Make(0, 0));
     return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, fAlphaType, subTx,
                            fBudgeted);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#include "SkBitmapDevice.h"
+#include "SkGrPixelRef.h"
+#include "SkImageFilter.h"
+
+class SkGpuImageFilterProxy : public SkImageFilter::Proxy {
+    GrContext* fCtx;
+
+public:
+    SkGpuImageFilterProxy(GrContext* ctx) : fCtx(ctx) {}
+
+    SkBaseDevice* createDevice(int width, int height) override {
+        GrSurfaceDesc desc;
+        desc.fConfig = kSkia8888_GrPixelConfig;
+        desc.fFlags = kRenderTarget_GrSurfaceFlag;
+        desc.fWidth = width;
+        desc.fHeight = height;
+        desc.fSampleCnt = 0;
+
+        SkAutoTUnref<GrTexture> texture(fCtx->textureProvider()->createTexture(desc, true));
+
+        if (texture) {
+            SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+            return SkGpuDevice::Create(texture->asRenderTarget(), width, height, &props,
+                                       SkGpuDevice::kClear_InitContents);
+        } else {
+            return nullptr;
+        }
+    }
+
+    bool filterImage(const SkImageFilter*, const SkBitmap&, const SkImageFilter::Context&,
+                     SkBitmap*, SkIPoint*) override {
+        return false;
+    }
+};
+
+SkImage* SkImage_Gpu::onApplyFilter(SkImageFilter* filter, SkIPoint* offsetResult,
+                                    bool forceResultToOriginalSize) const {
+    if (!forceResultToOriginalSize || !filter->canFilterImageGPU()) {
+        return this->INHERITED::onApplyFilter(filter, offsetResult, forceResultToOriginalSize);
+    }
+
+    const SkImageInfo info = make_info(this->width(), this->height(), this->isOpaque());
+    SkAutoTUnref<SkGrPixelRef> pr(new SkGrPixelRef(info, fTexture));
+    SkBitmap src;
+    src.setInfo(info);
+    src.setPixelRef(pr, 0, 0);
+
+    GrContext* context = fTexture->getContext();
+    SkGpuImageFilterProxy proxy(context);
+    SkImageFilter::Context ctx(SkMatrix::I(),
+                               SkIRect::MakeWH(this->width(), this->height()),
+                               SkImageFilter::Cache::Get());
+
+    SkBitmap dst;
+    if (filter->filterImageGPU(&proxy, src, ctx, &dst, offsetResult)) {

[Stephen White, 2015/10/14 19:22:23]

I'm not 100% certain, but I think if you call filter->filterImage() instead of
filterImageGPU() here, it should work for all cases, and you can remove the
canFilterImageGPU() check above. That'll give the proxy a chance at calling
filter->filterImageGPU() for you (via SkGpuDevice::filterImage()), and fall back
to the generic filter->filterImage() path if not.

+        return new SkImage_Gpu(dst.width(), dst.height(), kNeedNewImageUniqueID, info.alphaType(),
+                               dst.getTexture(), SkSurface::kNo_Budgeted);
+    }
+    return nullptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 static SkImage* new_wrapped_texture_common(GrContext* ctx, const GrBackendTextureDesc& desc,
                                            SkAlphaType at, GrWrapOwnership ownership,
                                            SkImage::TextureReleaseProc releaseProc,
                                            SkImage::ReleaseContext releaseCtx) {
     if (desc.fWidth <= 0 || desc.fHeight <= 0) {
         return nullptr;
     }
     SkAutoTUnref<GrTexture> tex(ctx->textureProvider()->wrapBackendTexture(desc, ownership));
     if (!tex) {
         return nullptr;
@@ skipping 127 matching lines @@
     if (!dst) {
         return nullptr;
     }
     
     const SkIRect srcR = SkIRect::MakeWH(desc.fWidth, desc.fHeight);
     const SkIPoint dstP = SkIPoint::Make(0, 0);
     ctx->copySurface(dst, src, srcR, dstP, GrContext::kFlushWrites_PixelOp);
     return dst;
 }