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 "effects/GrBicubicEffect.h"
@@ skipping 25 matching lines @@
 #include "SkPictureData.h"
 #include "SkRecord.h"
 #include "SkRRect.h"
 #include "SkStroke.h"
 #include "SkSurface.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkVertState.h"
 #include "SkXfermode.h"
 #include "SkErrorInternals.h"
+#include "SkImage_Base.h"
+#include "SkImagePriv.h"
 
 #if SK_SUPPORT_GPU
 
 enum { kDefaultImageFilterCacheSize = 32 * 1024 * 1024 };
 
 #if 0
     extern bool (*gShouldDrawProc)();
     #define CHECK_SHOULD_DRAW(draw)                             \
         do {                                                    \
             if (gShouldDrawProc && !gShouldDrawProc()) return;  \
@@ skipping 30 matching lines @@
     AutoBitmapTexture() {}
 
     AutoBitmapTexture(GrContext* context,
                       const SkBitmap& bitmap,
                       const GrTextureParams* params,
                       GrTexture** texture) {
         SkASSERT(texture);
         *texture = this->set(context, bitmap, params);
     }
 
+    AutoBitmapTexture(GrContext* context,
+                      SkImage& image,
+                      const GrTextureParams* params,
+                      GrTexture** texture) {
+        SkASSERT(texture);
+        *texture = this->set(context, image, params);
+    }
+
     GrTexture* set(GrContext* context,
                    const SkBitmap& bitmap,
                    const GrTextureParams* params) {
         // Either get the texture directly from the bitmap, or else use the cache and
         // remember to unref it.
         if (GrTexture* bmpTexture = bitmap.getTexture()) {
             fTexture.reset(NULL);
             return bmpTexture;
         } else {
             fTexture.reset(GrRefCachedBitmapTexture(context, bitmap, params));
             return fTexture.get();
         }
     }
 
+    GrTexture* set(GrContext* context,
+                   SkImage& image,
+                   const GrTextureParams* params) {
+        if (GrTexture* bmpTexture = image.getTexture()) {
+            fTexture.reset(NULL);
+            return bmpTexture;
+        } else {
+            SkBitmap bitmap;
+            as_IB(&image)->getROPixels(&bitmap);
+            fTexture.reset(GrRefCachedBitmapTexture(context, bitmap, params));
+            return fTexture.get();
+        }
+    }
+
 private:
     SkAutoTUnref<GrTexture> fTexture;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 struct GrSkDrawProcs : public SkDrawProcs {
 public:
     GrContext* fContext;
     GrTextContext* fTextContext;
@@ skipping 568 matching lines @@
         tempPaint.setPorterDuffXPFactory(kOne_GrBlendCoeff, kISC_GrBlendCoeff);
     }
 
     // Draw the mask into maskTexture with the path's top-left at the origin using tempPaint.
     SkMatrix translate;
     translate.setTranslate(-maskRect.fLeft, -maskRect.fTop);
     context->drawPath(tempPaint, translate, devPath, strokeInfo);
     return mask;
 }
 
-SkBitmap wrap_texture(GrTexture* texture) {
+static SkImage* wrap_texture(GrTexture* texture) {
     SkBitmap result;
     result.setInfo(texture->surfacePriv().info());
     result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (result.info(), texture)))->unref();
-    return result;
+    return SkNewImageFromBitmapTexture(result, texture->desc().fSampleCnt,
+                                       SkSurface::kYes_Budgeted);
 }
 
 };
 
 void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
                            const SkPaint& paint, const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPath", fContext);
@@ skipping 689 matching lines @@
     GrColor paintColor = (alphaOnly) ? SkColor2GrColorJustAlpha(paint.getColor()) :
                                        SkColor2GrColor(paint.getColor());
     SkPaint2GrPaintNoShader(this->context(), paint, paintColor, false, &grPaint);
 
     fContext->drawNonAARectToRect(grPaint, viewMatrix, dstRect, paintRect);
 }
 
 bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
                                 const SkImageFilter* filter,
                                 const SkImageFilter::Context& ctx,
-                                SkBitmap* result, SkIPoint* offset) {
+                                SkAutoTUnref<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()) {
         // Save the render target and set it to NULL, so we don't accidentally draw to it in the
         // filter.  Also set the clip wide open and the matrix to identity.
         GrContext::AutoWideOpenIdentityDraw awo(context, NULL);
-        return filter->filterImageGPU(&proxy, wrap_texture(texture), ctx, result, offset);
+        SkAutoTUnref<SkImage> src(wrap_texture(texture));
+        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);
 
     SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
     if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
         return;
     }
 
     int w = bitmap.width();
     int h = bitmap.height();
 
     GrTexture* texture;
     // draw sprite uses the default texture params
     AutoBitmapTexture abt(fContext, bitmap, NULL, &texture);
 
     SkImageFilter* filter = paint.getImageFilter();
     // This bitmap will own the filtered result as a texture.
-    SkBitmap filteredBitmap;
+    SkAutoTUnref<SkImage> filteredImage;
 
     if (filter) {
         SkIPoint offset = SkIPoint::Make(0, 0);
         SkMatrix matrix(*draw.fMatrix);
         matrix.postTranslate(SkIntToScalar(-left), SkIntToScalar(-top));
         SkIRect clipBounds = SkIRect::MakeWH(bitmap.width(), bitmap.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)) {
-            texture = (GrTexture*) filteredBitmap.getTexture();
-            w = filteredBitmap.width();
-            h = filteredBitmap.height();
+            texture = filteredImage->getTexture();
+            w = filteredImage->width();
+            h = filteredImage->height();
             left += offset.x();
             top += offset.y();
         } else {
             return;
         }
     }
 
     GrPaint grPaint;
     grPaint.addColorTextureProcessor(texture, SkMatrix::I());
 
     SkPaint2GrPaintNoShader(this->context(), paint, SkColor2GrColorJustAlpha(paint.getColor()),
                             false, &grPaint);
 
     fContext->drawNonAARectToRect(grPaint,
                                   SkMatrix::I(),
                                   SkRect::MakeXYWH(SkIntToScalar(left),
                                                    SkIntToScalar(top),
                                                    SkIntToScalar(w),
                                                    SkIntToScalar(h)),
                                   SkRect::MakeXYWH(0,
                                                    0,
                                                    SK_Scalar1 * w / texture->width(),
                                                    SK_Scalar1 * h / texture->height()));
 }
 
+void SkGpuDevice::drawImage(const SkDraw& draw, const SkImage& image,
+                            int left, int top, const SkPaint& paint) {
+
+    GrTexture* texture = image.getTexture();
+    if (NULL == texture) {
+        INHERITED::drawImage(draw, image, left, top, paint);
+        return;
+    }
+
+    CHECK_SHOULD_DRAW(draw);
+    int w = image.width();
+    int h = image.height();
+
+    GrPaint grPaint;
+    grPaint.addColorTextureProcessor(texture, SkMatrix::I());
+
+    SkPaint2GrPaintNoShader(this->context(), paint, SkColor2GrColorJustAlpha(paint.getColor()),
+                            false, &grPaint);
+
+    fContext->drawNonAARectToRect(grPaint,
+                                  SkMatrix::I(),
+                                  SkRect::MakeXYWH(SkIntToScalar(left),
+                                                   SkIntToScalar(top),
+                                                   SkIntToScalar(w),
+                                                   SkIntToScalar(h)),
+                                  SkRect::MakeXYWH(0,
+                                                   0,
+                                                   SK_Scalar1 * w / texture->width(),
+                                                   SK_Scalar1 * h / texture->height()));
+
+}
+
+
 void SkGpuDevice::drawBitmapRect(const SkDraw& origDraw, const SkBitmap& bitmap,
                                  const SkRect* src, const SkRect& dst,
                                  const SkPaint& paint,
                                  SkCanvas::DrawBitmapRectFlags flags) {
     SkMatrix    matrix;
     SkRect      bitmapBounds, tmpSrc;
 
     bitmapBounds.set(0, 0,
                      SkIntToScalar(bitmap.width()),
                      SkIntToScalar(bitmap.height()));
@@ skipping 50 matching lines @@
     GrTexture* devTex;
     if (NULL == (devTex = devRT->asTexture())) {
         return;
     }
 
     const SkImageInfo ii = dev->imageInfo();
     int w = ii.width();
     int h = ii.height();
 
     SkImageFilter* filter = paint.getImageFilter();
-    // This bitmap will own the filtered result as a texture.
-    SkBitmap filteredBitmap;
+    SkAutoTUnref<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;
         }
     }
 
     GrPaint grPaint;
     grPaint.addColorTextureProcessor(devTex, SkMatrix::I());
 
@@ skipping 10 matching lines @@
     SkRect srcRect = SkRect::MakeWH(SK_Scalar1 * w / devTex->width(),
                                     SK_Scalar1 * h / devTex->height());
 
     fContext->drawNonAARectToRect(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, SkImage& src,
                               const SkImageFilter::Context& ctx,
-                              SkBitmap* result, SkIPoint* offset) {
+                              SkAutoTUnref<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 271 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