Add onDrawBitmapLattice(), avoid unnecessary bitmap->image copy

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkClipStack.h"
 #include "SkColorFilter.h"
 #include "SkDraw.h"
 #include "SkDrawable.h"
 #include "SkDrawFilter.h"
 #include "SkDrawLooper.h"
 #include "SkErrorInternals.h"
 #include "SkImage.h"
 #include "SkImage_Base.h"
+#include "SkImage_Raster.h"
 #include "SkImageFilter.h"
 #include "SkImageFilterCache.h"
 #include "SkLatticeIter.h"
 #include "SkMatrixUtils.h"
 #include "SkMetaData.h"
 #include "SkPaintPriv.h"
 #include "SkPatchUtils.h"
 #include "SkPicture.h"
 #include "SkRasterClip.h"
 #include "SkReadPixelsRec.h"
@@ skipping 1955 matching lines @@
     if (dst.isEmpty()) {
         return;
     }
     if (SkLatticeIter::Valid(image->width(), image->height(), center)) {
         this->onDrawImageNine(image, center, dst, paint);
     } else {
         this->drawImageRect(image, dst, paint);
     }
 }
 
+void SkCanvas::drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst,

[msarett, 2016/08/03 15:07:57]

Just moved this.

+                                const SkPaint* paint) {
+    RETURN_ON_NULL(image);
+    if (dst.isEmpty()) {
+        return;
+    }
+    if (SkLatticeIter::Valid(image->width(), image->height(), lattice)) {
+        this->onDrawImageLattice(image, lattice, dst, paint);
+    } else {
+        this->drawImageRect(image, dst, paint);
+    }
+}
+
 void SkCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar dx, SkScalar dy, const SkPaint* paint) {
     if (bitmap.drawsNothing()) {
         return;
     }
     this->onDrawBitmap(bitmap, dx, dy, paint);
 }
 
 void SkCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkRect& src, const SkRect& dst,
                               const SkPaint* paint, SrcRectConstraint constraint) {
     if (bitmap.drawsNothing() || dst.isEmpty() || src.isEmpty()) {
@@ skipping 16 matching lines @@
 void SkCanvas::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst,
                               const SkPaint* paint) {
     if (bitmap.drawsNothing() || dst.isEmpty()) {
         return;
     }
     if (SkLatticeIter::Valid(bitmap.width(), bitmap.height(), center)) {
         this->onDrawBitmapNine(bitmap, center, dst, paint);
     } else {
         this->drawBitmapRect(bitmap, dst, paint);
     }
-
 }
 
 void SkCanvas::drawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice, const SkRect& dst,
                                  const SkPaint* paint) {
-    sk_sp<SkImage> image = SkImage::MakeFromBitmap(bitmap);
-    this->drawImageLattice(image.get(), lattice, dst, paint);
-}
-
-void SkCanvas::drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst,
-                                const SkPaint* paint) {
-    RETURN_ON_NULL(image);
-    if (dst.isEmpty()) {
+    if (bitmap.drawsNothing() || dst.isEmpty()) {
         return;
     }
-    if (SkLatticeIter::Valid(image->width(), image->height(), lattice)) {
-        this->onDrawImageLattice(image, lattice, dst, paint);
+    if (SkLatticeIter::Valid(bitmap.width(), bitmap.height(), lattice)) {
+        this->onDrawBitmapLattice(bitmap, lattice, dst, paint);
     } else {
-        this->drawImageRect(image, dst, paint);
+        this->drawBitmapRect(bitmap, dst, paint);
     }
 }
 
 void SkCanvas::drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
                          const SkColor colors[], int count, SkXfermode::Mode mode,
                          const SkRect* cull, const SkPaint* paint) {
     RETURN_ON_NULL(atlas);
     if (count <= 0) {
         return;
     }
@@ skipping 287 matching lines @@
                                       SkScalarRoundToInt(pt.fX),
                                       SkScalarRoundToInt(pt.fY), pnt);
         } else {
             iter.fDevice->drawImage(iter, image, x, y, pnt);
         }
     }
 
     LOOPER_END
 }
 
-void SkCanvas::onDrawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst,
-                                  const SkPaint* paint) {
-    if (nullptr == paint || paint->canComputeFastBounds()) {
-        SkRect storage;
-        if (this->quickReject(paint ? paint->computeFastBounds(dst, &storage) : dst)) {
-            return;
-        }
-    }
-
-    SkLazyPaint lazy;
-    if (nullptr == paint) {
-        paint = lazy.init();
-    }
-
-    LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type, &dst)
-
-    while (iter.next()) {
-        iter.fDevice->drawImageLattice(iter, image, lattice, dst, looper.paint());
-    }
-
-    LOOPER_END
-}
-
 void SkCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
                                const SkPaint* paint, SrcRectConstraint constraint) {
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawImageRect()");
     if (nullptr == paint || paint->canComputeFastBounds()) {
         SkRect storage = dst;
         if (paint) {
             paint->computeFastBounds(dst, &storage);
         }
         if (this->quickReject(storage)) {
             return;
@@ skipping 150 matching lines @@
 
     LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type, &dst)
 
     while (iter.next()) {
         iter.fDevice->drawBitmapNine(iter, bitmap, center, dst, looper.paint());
     }
 
     LOOPER_END
 }
 
+void SkCanvas::onDrawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst,

[msarett, 2016/08/03 15:07:57]

Also moved.

+                                  const SkPaint* paint) {
+    if (nullptr == paint || paint->canComputeFastBounds()) {
+        SkRect storage;
+        if (this->quickReject(paint ? paint->computeFastBounds(dst, &storage) : dst)) {
+            return;
+        }
+    }
+
+    SkLazyPaint lazy;
+    if (nullptr == paint) {
+        paint = lazy.init();
+    }
+
+    LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type, &dst)
+
+    while (iter.next()) {
+        iter.fDevice->drawImageLattice(iter, image, lattice, dst, looper.paint());
+    }
+
+    LOOPER_END
+}
+
+void SkCanvas::onDrawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice,

[msarett, 2016/08/03 15:07:57]

This is new.  Could we also use this implementation for SkPictureRecord and
SkRecorder?  Or do they need to copy when converting to SkImage?

[mtklein, 2016/08/03 15:11:51]

They need to copy if immutable (though I think SkPictureRecord will never
actually see a mutable bitmap today... they should all have been previously
snapped by SkRecorder).

[mtklein, 2016/08/03 15:12:19]

They need to copy if *mutable...

[msarett, 2016/08/03 15:49:23]

Gotcha, I think the Picture/Record impls are as they should be then.

+                                   const SkRect& dst, const SkPaint* paint) {
+    sk_sp<SkImage> image = sk_sp<SkImage>((SkImage*) new SkImage_Raster(bitmap, true));

[mtklein, 2016/08/03 15:11:51]

I think we spell this,

   sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap,
kNever_ForceCopyMode)


Are we sure we know this is safe here?  I thought we had to be down in the
raster device before we know it's not going to be retained somehow (e.g. by PDF
or GPU devices).

[reed1, 2016/08/03 15:21:05]

I had suggested this point in the pipeline to commit to a volatile image, but
perhaps you're right. Not sure about pdf, but gpu is allowed to not look at the
image pixels until later. Maybe we need to push down further to the device level
virtual (i.e. add drawBitmapLattice to device), at least when the bitmap is not
immutable...

[msarett, 2016/08/03 15:49:23]

Changed to use SkMakeImageFromRasterBitmap.  Pushing bitmap virtual down to
device level.

+    this->onDrawImageLattice(image.get(), lattice, dst, paint);
+}
+
 class SkDeviceFilteredPaint {
 public:
     SkDeviceFilteredPaint(SkBaseDevice* device, const SkPaint& paint) {
         uint32_t filteredFlags = device->filterTextFlags(paint);
         if (filteredFlags != paint.getFlags()) {
             SkPaint* newPaint = fLazy.set(paint);
             newPaint->setFlags(filteredFlags);
             fPaint = newPaint;
         } else {
             fPaint = &paint;
@@ skipping 608 matching lines @@
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }
 
 #ifdef SK_SUPPORT_LEGACY_NEW_SURFACE_API
 SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     return this->makeSurface(info, props).release();
 }
 #endif