Make filters use SkImage instead of SkBitmap

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "GrBitmapTextContext.h"
@@ skipping 1560 matching lines @@
                                        SkColor2GrColor(paint.getColor());
     SkPaint2GrPaintNoShader(this->context(), fRenderTarget, paint, paintColor, false, &grPaint);
 
     fContext->drawNonAARectToRect(fRenderTarget, fClip, grPaint, viewMatrix, dstRect,
                                   paintRect);
 }
 
 bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
                                 const SkImageFilter* filter,
                                 const SkImageFilter::Context& ctx,
-                                SkBitmap* result, SkIPoint* offset) {
+                                SkAutoTUnref<const SkImage>& result, SkIPoint* offset) {
     SkASSERT(filter);
 
     // FIXME: plumb actual surface props such that we don't have to lie about the flags here
     //        (https://code.google.com/p/skia/issues/detail?id=3148).
     SkDeviceImageFilterProxy proxy(this, SkSurfaceProps(0, getLeakyProperties().pixelGeometry()));
 
     if (filter->canFilterImageGPU()) {
         SkBitmap filterInput;
         wrap_surface(texture, &filterInput);
-        return filter->filterImageGPU(&proxy, filterInput, ctx, result, offset);
+        SkAutoTUnref<const SkImage> src(SkNewImageFromBitmapTexture(filterInput,
+                                                                    texture->desc().fSampleCnt,
+                                                                    SkSurface::kYes_Budgeted));
+        return filter->filterImageGPU(&proxy, src, ctx, result, offset);
     } else {
         return false;
     }
 }
 
 void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
                              int left, int top, const SkPaint& paint) {
     // drawSprite is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
 
@@ skipping 24 matching lines @@
     this->internalDrawSprite(draw, texture, left, top, image.width(), image.height(), paint);
 }
 
 void SkGpuDevice::internalDrawSprite(const SkDraw& draw, GrTexture* texture,
                                      int left, int top, int width, int height,
                                      const SkPaint& paint) {
 
     SkAutoTUnref<GrTexture> src(SkRef(texture));
     if (SkImageFilter* filter = paint.getImageFilter()) {
         // This bitmap will own the filtered result as a texture.
-        SkBitmap filteredBitmap;
+        SkAutoTUnref<const SkImage> filteredImage;
         SkIPoint offset = SkIPoint::Make(0, 0);
         SkMatrix matrix(*draw.fMatrix);
         matrix.postTranslate(SkIntToScalar(-left), SkIntToScalar(-top));
         SkIRect clipBounds = SkIRect::MakeWH(width, height);
         SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
         // This cache is transient, and is freed (along with all its contained
         // textures) when it goes out of scope.
         SkImageFilter::Context ctx(matrix, clipBounds, cache);
-        if (this->filterTexture(fContext, texture, filter, ctx, &filteredBitmap,
+        if (this->filterTexture(fContext, texture, filter, ctx, filteredImage,
                                 &offset)) {
-            src.reset(SkRef(filteredBitmap.getTexture()));
-            width = filteredBitmap.width();
-            height = filteredBitmap.height();
+            src.reset(SkRef(filteredImage->getTexture()));
+            width = filteredImage->width();
+            height = filteredImage->height();
             left += offset.x();
             top += offset.y();
         } else {
             return;
         }
     }
 
     GrPaint grPaint;
     grPaint.addColorTextureProcessor(src, SkMatrix::I());
 
@@ skipping 75 matching lines @@
     }
     GrTexture* devTex = devImage->getTexture();
     if (NULL == devTex) {
         return;
     }
 
     int w = devImage->width();
     int h = devImage->height();
 
     SkImageFilter* filter = paint.getImageFilter();
-    // This bitmap will own the filtered result as a texture.
-    SkBitmap filteredBitmap;
+    SkAutoTUnref<const SkImage> filteredImage;
 
     if (filter) {
         SkIPoint offset = SkIPoint::Make(0, 0);
         SkMatrix matrix(*draw.fMatrix);
         matrix.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
         SkIRect clipBounds = SkIRect::MakeWH(devTex->width(), devTex->height());
         // This cache is transient, and is freed (along with all its contained
         // textures) when it goes out of scope.
         SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
         SkImageFilter::Context ctx(matrix, clipBounds, cache);
-        if (this->filterTexture(fContext, devTex, filter, ctx, &filteredBitmap,
+        if (this->filterTexture(fContext, devTex, filter, ctx, filteredImage,
                                 &offset)) {
-            devTex = filteredBitmap.getTexture();
-            w = filteredBitmap.width();
-            h = filteredBitmap.height();
+            devTex = filteredImage->getTexture();
+            w = filteredImage->width();
+            h = filteredImage->height();
             x += offset.fX;
             y += offset.fY;
         } else {
             return;
         }
     }
     // drawDevice is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
@@ skipping 13 matching lines @@
                                     SK_Scalar1 * h / devTex->height());
 
     fContext->drawNonAARectToRect(fRenderTarget, fClip, grPaint, SkMatrix::I(), dstRect,
                                   srcRect);
 }
 
 bool SkGpuDevice::canHandleImageFilter(const SkImageFilter* filter) {
     return filter->canFilterImageGPU();
 }
 
-bool SkGpuDevice::filterImage(const SkImageFilter* filter, const SkBitmap& src,
+bool SkGpuDevice::filterImage(const SkImageFilter* filter, const SkImage* src,
                               const SkImageFilter::Context& ctx,
-                              SkBitmap* result, SkIPoint* offset) {
+                              SkAutoTUnref<const SkImage>& result, SkIPoint* offset) {
     // want explicitly our impl, so guard against a subclass of us overriding it
     if (!this->SkGpuDevice::canHandleImageFilter(filter)) {
         return false;
     }
 
-    SkAutoLockPixels alp(src, !src.getTexture());
-    if (!src.getTexture() && !src.readyToDraw()) {
-        return false;
-    }
+    //TODO: SkAutoLockPixels alp(src, !src.getTexture());
+    //TODO: if !src->readyToDraw()
 
     GrTexture* texture;
     // We assume here that the filter will not attempt to tile the src. Otherwise, this cache lookup
     // must be pushed upstack.
     AutoBitmapTexture abt(fContext, src, NULL, &texture);
+    if (!texture) {
+        return false;
+    }
 
     return this->filterTexture(fContext, texture, filter, ctx, result, offset);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // must be in SkCanvas::VertexMode order
 static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
     kTriangles_GrPrimitiveType,
     kTriangleStrip_GrPrimitiveType,
@@ skipping 291 matching lines @@
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif