First draft of non-scale/translate filters plus blit optimization.

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 "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkBitmapDevice.h"
@@ skipping 95 matching lines @@
     these are used (assuming we're not on a layer) we rebuild these cache
     values: they reflect the top of the save stack, but translated and clipped
     by the device's XY offset and bitmap-bounds.
 */
 struct DeviceCM {
     DeviceCM*           fNext;
     SkBaseDevice*       fDevice;
     SkRasterClip        fClip;
     const SkMatrix*     fMatrix;
     SkPaint*            fPaint; // may be null (in the future)
+    SkMatrix            fStashedMatrix;
+    SkMatrix            fExtraMatrix;
 
     DeviceCM(SkBaseDevice* device, const SkPaint* paint, SkCanvas* canvas,
-             bool conservativeRasterClip)
+             bool conservativeRasterClip, const SkMatrix& stashedMatrix,
+             const SkMatrix& extraMatrix)
         : fNext(NULL)
         , fClip(conservativeRasterClip)
+        , fStashedMatrix(stashedMatrix)
+        , fExtraMatrix(extraMatrix)
     {
         if (NULL != device) {
             device->ref();
             device->onAttachToCanvas(canvas);
         }
         fDevice = device;
         fPaint = paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL;
     }
 
     ~DeviceCM() {
@@ skipping 300 matching lines @@
     fCachedLocalClipBoundsDirty = true;
     fAllowSoftClip = true;
     fAllowSimplifyClip = false;
     fDeviceCMDirty = true;
     fSaveCount = 1;
     fMetaData = NULL;
 
     fMCRec = (MCRec*)fMCStack.push_back();
     new (fMCRec) MCRec(fConservativeRasterClip);
 
-    fMCRec->fLayer = SkNEW_ARGS(DeviceCM, (NULL, NULL, NULL, fConservativeRasterClip));
+    fMCRec->fLayer = SkNEW_ARGS(DeviceCM, (NULL, NULL, NULL, fConservativeRasterClip, fMCRec->fMatrix, SkMatrix::I()));
     fMCRec->fTopLayer = fMCRec->fLayer;
 
     fSurfaceBase = NULL;
 
     fClipStack.reset(SkNEW(SkClipStack));
 
     if (device) {
         device->initForRootLayer(fProps.pixelGeometry());
         if (device->forceConservativeRasterClip()) {
             fConservativeRasterClip = true;
@@ skipping 372 matching lines @@
 
 static bool bounds_affects_clip(SkCanvas::SaveFlags flags) {
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     return (flags & SkCanvas::kClipToLayer_SaveFlag) != 0;
 #else
     return true;
 #endif
 }
 
 bool SkCanvas::clipRectBounds(const SkRect* bounds, SaveFlags flags,
-                              SkIRect* intersection, const SkImageFilter* imageFilter) {
+                              SkIRect* intersection, const SkImageFilter* imageFilter,
+                              const SkMatrix* shearAndRotateMatrix) {
     SkIRect clipBounds;
     if (!this->getClipDeviceBounds(&clipBounds)) {
         return false;
     }
 
     const SkMatrix& ctm = fMCRec->fMatrix;  // this->getTotalMatrix()
 
     if (imageFilter) {
+        if (shearAndRotateMatrix) {
+            SkMatrix shearAndRotateInverse;
+            if (!shearAndRotateMatrix->invert(&shearAndRotateInverse)) {
+                return false;
+            }
+            SkMatrix matrix;
+            if (!ctm.invert(&matrix)) {
+                return false;
+            }
+            matrix.postConcat(shearAndRotateInverse);
+            matrix.postConcat(ctm);
+            SkRect floatBounds;
+            matrix.mapRect(&floatBounds, SkRect::Make(clipBounds));
+            clipBounds = floatBounds.roundOut();
+        }
         imageFilter->filterBounds(clipBounds, ctm, &clipBounds);
     }
+
     SkIRect ir;
     if (bounds) {
         SkRect r;
 
         ctm.mapRect(&r, *bounds);
         r.roundOut(&ir);
         // early exit if the layer's bounds are clipped out
         if (!ir.intersect(clipBounds)) {
             if (bounds_affects_clip(flags)) {
                 fCachedLocalClipBoundsDirty = true;
@@ skipping 37 matching lines @@
     fSaveCount += 1;
     this->internalSaveLayer(bounds, paint, flags, strategy);
     return this->getSaveCount() - 1;
 }
 
 void SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags,
                                  SaveLayerStrategy strategy) {
 #ifndef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     flags |= kClipToLayer_SaveFlag;
 #endif
+    SkImageFilter* imageFilter = paint ? paint->getImageFilter() : NULL;
+    SkMatrix matrix = fMCRec->fMatrix;
+    SkMatrix shearAndRotate = SkMatrix::I();
+    bool doShearAndRotate = false;
+    if (imageFilter && !matrix.isScaleTranslate()) {
+        doShearAndRotate = true;
+        SkMatrix scaleAndTranslate;
+        scaleAndTranslate.setTranslate(matrix.getTranslateX(), matrix.getTranslateY());
+        SkScalar xScale = SkScalarSqrt(matrix[0] * matrix[0] + matrix[3] * matrix[3]);
+        SkScalar yScale = SkScalarSqrt(matrix[1] * matrix[1] + matrix[4] * matrix[4]);
+        scaleAndTranslate.postScale(xScale, yScale);
+        if (!scaleAndTranslate.invert(&shearAndRotate)) {
+            SkASSERT(false);
+        }
+        shearAndRotate.preConcat(matrix);
+        fMCRec->fMatrix = scaleAndTranslate;
+    }
 
     // do this before we create the layer. We don't call the public save() since
     // that would invoke a possibly overridden virtual
     this->internalSave();
 
     fDeviceCMDirty = true;
 
     SkIRect ir;
-    if (!this->clipRectBounds(bounds, flags, &ir, paint ? paint->getImageFilter() : NULL)) {
+    if (!this->clipRectBounds(bounds, flags, &ir, imageFilter, doShearAndRotate ? &shearAndRotate : NULL)) {
         return;
     }
 
     // FIXME: do willSaveLayer() overriders returning kNoLayer_SaveLayerStrategy really care about
     // the clipRectBounds() call above?
     if (kNoLayer_SaveLayerStrategy == strategy) {
         return;
     }
 
     bool isOpaque = !SkToBool(flags & kHasAlphaLayer_SaveFlag);
@@ skipping 23 matching lines @@
 #endif
     device = device->onCreateDevice(SkBaseDevice::CreateInfo(info, usage, fProps.pixelGeometry()),
                                     paint);
     if (NULL == device) {
         SkErrorInternals::SetError( kInternalError_SkError,
                                     "Unable to create device for layer.");
         return;
     }
 
     device->setOrigin(ir.fLeft, ir.fTop);
-    DeviceCM* layer = SkNEW_ARGS(DeviceCM, (device, paint, this, fConservativeRasterClip));
+    DeviceCM* layer = SkNEW_ARGS(DeviceCM, (device, paint, this, fConservativeRasterClip, matrix, shearAndRotate));
     device->unref();
 
     layer->fNext = fMCRec->fTopLayer;
     fMCRec->fLayer = layer;
     fMCRec->fTopLayer = layer;    // this field is NOT an owner of layer
 }
 
 int SkCanvas::saveLayerAlpha(const SkRect* bounds, U8CPU alpha) {
     return this->saveLayerAlpha(bounds, alpha, kARGB_ClipLayer_SaveFlag);
 }
@@ skipping 28 matching lines @@
     fMCRec = (MCRec*)fMCStack.back();
 
     /*  Time to draw the layer's offscreen. We can't call the public drawSprite,
         since if we're being recorded, we don't want to record this (the
         recorder will have already recorded the restore).
     */
     if (layer) {
         if (layer->fNext) {
             const SkIPoint& origin = layer->fDevice->getOrigin();
             this->internalDrawDevice(layer->fDevice, origin.x(), origin.y(),
-                                     layer->fPaint);
+                                     layer->fPaint, layer->fExtraMatrix);
             // reset this, since internalDrawDevice will have set it to true
             fDeviceCMDirty = true;
         }
+        if (layer->fPaint && layer->fPaint->fImageFilter) {
+            fMCRec->fMatrix = layer->fStashedMatrix;
+        }
         SkDELETE(layer);
     }
 }
 
 SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     if (NULL == props) {
         props = &fProps;
     }
     return this->onNewSurface(info, *props);
 }
@@ skipping 84 matching lines @@
     LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type, bounds)
 
     while (iter.next()) {
         iter.fDevice->drawBitmap(iter, bitmap, matrix, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::internalDrawDevice(SkBaseDevice* srcDev, int x, int y,
-                                  const SkPaint* paint) {
+                                  const SkPaint* paint, const SkMatrix& extraMatrix) {
     SkPaint tmp;
     if (NULL == paint) {
         paint = &tmp;
     }
 
     LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
     while (iter.next()) {
         SkBaseDevice* dstDev = iter.fDevice;
         paint = &looper.paint();
         SkImageFilter* filter = paint->getImageFilter();
         SkIPoint pos = { x - iter.getX(), y - iter.getY() };
         if (filter && !dstDev->canHandleImageFilter(filter)) {
             SkDeviceImageFilterProxy proxy(dstDev, fProps);
             SkBitmap dst;
             SkIPoint offset = SkIPoint::Make(0, 0);
             const SkBitmap& src = srcDev->accessBitmap(false);
             SkMatrix matrix = *iter.fMatrix;
             matrix.postTranslate(SkIntToScalar(-pos.x()), SkIntToScalar(-pos.y()));
             SkIRect clipBounds = SkIRect::MakeWH(srcDev->width(), srcDev->height());
             SkAutoTUnref<SkImageFilter::Cache> cache(dstDev->getImageFilterCache());
             SkImageFilter::Context ctx(matrix, clipBounds, cache.get());
             if (filter->filterImage(&proxy, src, ctx, &dst, &offset)) {
                 SkPaint tmpUnfiltered(*paint);
                 tmpUnfiltered.setImageFilter(NULL);
-                dstDev->drawSprite(iter, dst, pos.x() + offset.x(), pos.y() + offset.y(),
-                                   tmpUnfiltered);
+                if (extraMatrix.isIdentity()) {
+                    offset += pos;
+                    dstDev->drawSprite(iter, dst, offset.x(), offset.y(),
+                                       tmpUnfiltered);
+                } else {
+                    SkMatrix matrix = extraMatrix;
+                    matrix.preTranslate(offset.x(), offset.y());
+                    dstDev->drawBitmap(iter, dst, matrix,
+                                       tmpUnfiltered);
+                }
             }
         } else {
             dstDev->drawDevice(iter, srcDev, pos.x(), pos.y(), *paint);
         }
     }
     LOOPER_END
 }
 
 void SkCanvas::onDrawSprite(const SkBitmap& bitmap, int x, int y, const SkPaint* paint) {
     if (gTreatSpriteAsBitmap) {
@@ skipping 1371 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }