Image filters: implement SkImage::makeWithFilter().

src/image/SkImage.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 "SkBitmap.h"
 #include "SkBitmapCache.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageEncoder.h"
+#include "SkImageFilter.h"
 #include "SkImageGenerator.h"
 #include "SkImagePriv.h"
 #include "SkImageShader.h"
 #include "SkImage_Base.h"
 #include "SkNextID.h"
 #include "SkPicture.h"
 #include "SkPixelRef.h"
 #include "SkPixelSerializer.h"
 #include "SkReadPixelsRec.h"
+#include "SkSpecialImage.h"
 #include "SkString.h"
 #include "SkSurface.h"
 
 #if SK_SUPPORT_GPU
 #include "GrTexture.h"
 #include "GrContext.h"
 #include "SkImage_Gpu.h"
 #endif
 
 SkImage::SkImage(int width, int height, uint32_t uniqueID)
@@ skipping 303 matching lines @@
 
 sk_sp<SkImage> SkImage::MakeFromPicture(sk_sp<SkPicture> picture, const SkISize& dimensions,
                                         const SkMatrix* matrix, const SkPaint* paint) {
     if (!picture) {
         return nullptr;
     }
     return MakeFromGenerator(SkImageGenerator::NewFromPicture(dimensions, picture.get(),
                                                               matrix, paint));
 }
 
+sk_sp<SkImage> SkImage::makeWithFilter(const SkImageFilter* filter, const SkIRect& subset,
+                                       const SkIRect& clipBounds, SkIRect* outSubset,
+                                       SkIPoint* offset) const {
+  if (!filter || !outSubset || !offset || !this->bounds().contains(subset)) {
+      return nullptr;
+  }
+  sk_sp<SkSpecialImage> srcSpecialImage = SkSpecialImage::MakeFromImage(
+      subset, sk_ref_sp(const_cast<SkImage*>(this)));
+  if (!srcSpecialImage) {
+      return nullptr;
+  }
+
+  // FIXME: build a cache here.
+  SkImageFilter::Context context(SkMatrix::I(), clipBounds, nullptr);
+  sk_sp<SkSpecialImage> result =
+      filter->filterImage(srcSpecialImage.get(), context, offset);
+
+  if (!result) {
+      return nullptr;
+  }
+
+  SkIRect fullSize = SkIRect::MakeWH(result->width(), result->height());
+#if SK_SUPPORT_GPU
+  if (result->isTextureBacked()) {
+    GrContext* context = result->getContext();
+    sk_sp<GrTexture> texture = result->asTextureRef(context);
+    fullSize = SkIRect::MakeWH(texture->width(), texture->height());
+  }
+#endif
+  *outSubset = SkIRect::MakeWH(result->width(), result->height());
+  if (!outSubset->intersect(clipBounds.makeOffset(-offset->x(), -offset->y()))) {
+      return nullptr;
+  }
+  offset->fX += outSubset->x();
+  offset->fY += outSubset->y();
+  // This isn't really a "tight" subset, but includes any texture padding.
+  return result->makeTightSubset(fullSize);
+}
+
 bool SkImage::isLazyGenerated() const {
     return as_IB(this)->onIsLazyGenerated();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 #if !SK_SUPPORT_GPU
 
 sk_sp<SkImage> SkImage::MakeTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted) {
     return nullptr;
@@ skipping 96 matching lines @@
 
 SkImage* SkImage::NewTextureFromPixmap(GrContext* ctx, const SkPixmap& pmap, SkBudgeted budgeted) {
     return MakeTextureFromPixmap(ctx, pmap, budgeted).release();
 }
 
 SkImage* SkImage::NewFromDeferredTextureImageData(GrContext* ctx, const void* data,
                                                   SkBudgeted budgeted) {
     return MakeFromDeferredTextureImageData(ctx, data, budgeted).release();
 }
 #endif