Fix layer hoisting image filter corner cases

src/gpu/GrLayerHoister.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrLayerCache.h"
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
 
 #include "SkCanvas.h"
 #include "SkGpuDevice.h"
 #include "SkGrPixelRef.h"
 #include "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkSurface.h"
 #include "SkSurface_Gpu.h"
 
 // Create the layer information for the hoisted layer and secure the
 // required texture/render target resources.
 static void prepare_for_hoisting(GrLayerCache* layerCache, 
                                  const SkPicture* topLevelPicture,
                                  const SkMatrix& initialMat,
                                  const SkLayerInfo::BlockInfo& info,
-                                 const SkIRect& layerRect,
+                                 const SkIRect& srcIR,
+                                 const SkIRect& dstIR,
                                  SkTDArray<GrHoistedLayer>* needRendering,
                                  SkTDArray<GrHoistedLayer>* recycled,
                                  bool attemptToAtlas,
                                  int numSamples) {
     const SkPicture* pict = info.fPicture ? info.fPicture : topLevelPicture;
 
     GrCachedLayer* layer = layerCache->findLayerOrCreate(topLevelPicture->uniqueID(),
                                                          SkToInt(info.fSaveLayerOpID),
                                                          SkToInt(info.fRestoreOpID),
-                                                         layerRect,
+                                                         srcIR,
+                                                         dstIR,
                                                          initialMat,
                                                          info.fKey,
                                                          info.fKeySize,
                                                          info.fPaint);
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = layerRect.width();
-    desc.fHeight = layerRect.height();
+    desc.fWidth = srcIR.width();
+    desc.fHeight = srcIR.height();
     desc.fConfig = kSkia8888_GrPixelConfig;
     desc.fSampleCnt = numSamples;
 
     bool locked, needsRendering;
     if (attemptToAtlas) {
         locked = layerCache->tryToAtlas(layer, desc, &needsRendering);
     } else {
         locked = layerCache->lock(layer, desc, &needsRendering);
     }
     if (!locked) {
@@ skipping 18 matching lines @@
     
     layerCache->addUse(layer);
     hl->fLayer = layer;
     hl->fPicture = pict;
     hl->fLocalMat = info.fLocalMat;
     hl->fInitialMat = initialMat;
     hl->fPreMat = initialMat;
     hl->fPreMat.preConcat(info.fPreMat);
 }
 
+// Compute the source rect if possible and return false if further processing 
+// on the layer should be abandoned based on its source rect.
+static bool compute_source_rect(const SkLayerInfo::BlockInfo& info, const SkMatrix& initialMat,
+                                const SkIRect& dstIR, SkIRect* srcIR) {
+    SkIRect clipBounds = dstIR;
+
+    SkMatrix totMat = initialMat;
+    totMat.preConcat(info.fPreMat);
+    totMat.preConcat(info.fLocalMat);
+
+    if (info.fPaint && info.fPaint->getImageFilter()) {
+        info.fPaint->getImageFilter()->filterBounds(clipBounds, totMat, &clipBounds);
+    }
+
+    if (!info.fSrcBounds.isEmpty()) {
+        SkRect r;
+
+        totMat.mapRect(&r, info.fSrcBounds);
+        r.roundOut(srcIR);
+
+        if (!srcIR->intersect(clipBounds)) {
+            return false;
+        }
+    } else {
+        *srcIR = clipBounds;
+    }
+
+    if (!GrLayerCache::PlausiblyAtlasable(srcIR->width(), srcIR->height())) {
+        return false;
+    }
+
+    return true;
+}
+
 // Atlased layers must be small enough to fit in the atlas, not have a
 // paint with an image filter and be neither nested nor nesting.
 // TODO: allow leaf nested layers to appear in the atlas.
 void GrLayerHoister::FindLayersToAtlas(GrContext* context,
                                        const SkPicture* topLevelPicture,
                                        const SkMatrix& initialMat,
                                        const SkRect& query,
                                        SkTDArray<GrHoistedLayer>* atlased,
                                        SkTDArray<GrHoistedLayer>* recycled,
                                        int numSamples) {
@@ skipping 30 matching lines @@
         if (disallowAtlasing) {
             continue;
         }
 
         SkRect layerRect;
         initialMat.mapRect(&layerRect, info.fBounds);
         if (!layerRect.intersect(query)) {
             continue;
         }
 
-        const SkIRect ir = layerRect.roundOut();
+        const SkIRect dstIR = layerRect.roundOut();
 
-        if (!GrLayerCache::PlausiblyAtlasable(ir.width(), ir.height())) {
+        SkIRect srcIR;
+
+        if (!compute_source_rect(info, initialMat, dstIR, &srcIR)) {
             continue;
         }
 
         prepare_for_hoisting(layerCache, topLevelPicture, initialMat,
-                             info, ir, atlased, recycled, true, 0);
+                             info, srcIR, dstIR, atlased, recycled, true, 0);
     }
 
 }
 
 void GrLayerHoister::FindLayersToHoist(GrContext* context,
                                        const SkPicture* topLevelPicture,
                                        const SkMatrix& initialMat,
                                        const SkRect& query,
                                        SkTDArray<GrHoistedLayer>* needRendering,
                                        SkTDArray<GrHoistedLayer>* recycled,
@@ skipping 21 matching lines @@
             // Parent layers are currently hoisted while nested layers are not.
             continue;
         }
 
         SkRect layerRect;
         initialMat.mapRect(&layerRect, info.fBounds);
         if (!layerRect.intersect(query)) {
             continue;
         }
 
-        const SkIRect ir = layerRect.roundOut();
+        const SkIRect dstIR = layerRect.roundOut();
 
-        prepare_for_hoisting(layerCache, topLevelPicture, initialMat, info, ir,
+        SkIRect srcIR;
+        if (!compute_source_rect(info, initialMat, dstIR, &srcIR)) {
+            continue;
+        }
+
+        prepare_for_hoisting(layerCache, topLevelPicture, initialMat, info, srcIR, dstIR,
                              needRendering, recycled, false, numSamples);
     }
 }
 
 void GrLayerHoister::DrawLayersToAtlas(GrContext* context,
                                        const SkTDArray<GrHoistedLayer>& atlased) {
     if (atlased.count() > 0) {
         // All the atlased layers are rendered into the same GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         atlased[0].fLayer->texture()->asRenderTarget(), NULL));
 
         SkCanvas* atlasCanvas = surface->getCanvas();
 
         for (int i = 0; i < atlased.count(); ++i) {
             const GrCachedLayer* layer = atlased[i].fLayer;
             const SkPicture* pict = atlased[i].fPicture;
-            const SkIPoint offset = SkIPoint::Make(layer->bound().fLeft, layer->bound().fTop);
+            const SkIPoint offset = SkIPoint::Make(layer->srcIR().fLeft, layer->srcIR().fTop);
             SkDEBUGCODE(const SkPaint* layerPaint = layer->paint();)
 
             SkASSERT(!layerPaint || !layerPaint->getImageFilter());
             SkASSERT(!layer->filter());
 
             atlasCanvas->save();
 
             // Add a rect clip to make sure the rendering doesn't
             // extend beyond the boundaries of the atlased sub-rect
             const SkRect bound = SkRect::Make(layer->rect());
@@ skipping 15 matching lines @@
                                 pict->drawablePicts(), pict->drawableCount(),
                                 layer->start() + 1, layer->stop(), initialCTM);
 
             atlasCanvas->restore();
         }
 
         atlasCanvas->flush();
     }
 }
 
-void GrLayerHoister::FilterLayer(GrContext* context, SkGpuDevice* device, GrCachedLayer* layer) {
+void GrLayerHoister::FilterLayer(GrContext* context,
+                                 SkGpuDevice* device,
+                                 const GrHoistedLayer& info) {
+    GrCachedLayer* layer = info.fLayer;
+
     SkASSERT(layer->filter());
+    SkASSERT(layer->filter()->canFilterImageGPU());
 
     static const int kDefaultCacheSize = 32 * 1024 * 1024;
 
-    if (layer->filter()->canFilterImageGPU()) {
-        SkBitmap filteredBitmap;
-        SkIPoint offset = SkIPoint::Make(0, 0);
+    SkBitmap filteredBitmap;
+    SkIPoint offset = SkIPoint::Make(0, 0);
 
-        SkASSERT(0 == layer->rect().fLeft && 0 == layer->rect().fTop);
-        SkIRect clipBounds = layer->rect();
+    const SkIPoint filterOffset = SkIPoint::Make(layer->srcIR().fLeft, layer->srcIR().fTop);
 
-        // This cache is transient, and is freed (along with all its contained
-        // textures) when it goes out of scope.
-        SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kDefaultCacheSize));
-        SkImageFilter::Context filterContext(SkMatrix::I(), clipBounds, cache);
+    SkMatrix totMat = SkMatrix::I();
+    totMat.preConcat(info.fPreMat);
+    totMat.preConcat(info.fLocalMat);
+    totMat.postTranslate(-SkIntToScalar(filterOffset.fX), -SkIntToScalar(filterOffset.fY));
 
-        if (!device->filterTexture(context, layer->texture(), layer->filter(),
-                                   filterContext, &filteredBitmap, &offset)) {
-            // Filtering failed. Press on with the unfiltered version
-            return;
-        }
 
-        // TODO: need to fix up offset
-        SkASSERT(0 == offset.fX && 0 == offset.fY);
+    SkASSERT(0 == layer->rect().fLeft && 0 == layer->rect().fTop);
+    SkIRect clipBounds = layer->rect();
 
-        SkIRect newRect = SkIRect::MakeWH(filteredBitmap.width(), filteredBitmap.height());
-        layer->setTexture(filteredBitmap.getTexture(), newRect);
+    // This cache is transient, and is freed (along with all its contained
+    // textures) when it goes out of scope.
+    SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kDefaultCacheSize));
+    SkImageFilter::Context filterContext(totMat, clipBounds, cache);
+
+    if (!device->filterTexture(context, layer->texture(), layer->filter(),
+                               filterContext, &filteredBitmap, &offset)) {
+        // Filtering failed. Press on with the unfiltered version
+        return;
     }
+
+    SkIRect newRect = SkIRect::MakeWH(filteredBitmap.width(), filteredBitmap.height());
+    layer->setTexture(filteredBitmap.getTexture(), newRect);
+    layer->setOffset(offset);
 }
 
 void GrLayerHoister::DrawLayers(GrContext* context, const SkTDArray<GrHoistedLayer>& layers) {
     for (int i = 0; i < layers.count(); ++i) {
         GrCachedLayer* layer = layers[i].fLayer;
         const SkPicture* pict = layers[i].fPicture;
-        const SkIPoint offset = SkIPoint::Make(layer->bound().fLeft, layer->bound().fTop);
+        const SkIPoint offset = SkIPoint::Make(layer->srcIR().fLeft, layer->srcIR().fTop);
 
         // Each non-atlased layer has its own GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         layer->texture()->asRenderTarget(), NULL));
 
         SkCanvas* layerCanvas = surface->getCanvas();
 
         SkASSERT(0 == layer->rect().fLeft && 0 == layer->rect().fTop);
 
         // Add a rect clip to make sure the rendering doesn't
@@ skipping 11 matching lines @@
 
         SkRecordPartialDraw(*pict->fRecord.get(), layerCanvas,
                             pict->drawablePicts(), pict->drawableCount(),
                             layer->start()+1, layer->stop(), initialCTM);
 
         layerCanvas->flush();
 
         if (layer->filter()) {
             SkSurface_Gpu* gpuSurf = static_cast<SkSurface_Gpu*>(surface.get());
 
-            FilterLayer(context, gpuSurf->getDevice(), layer);
+            FilterLayer(context, gpuSurf->getDevice(), layers[i]);
         }
     }
 }
 
 void GrLayerHoister::UnlockLayers(GrContext* context,
                                   const SkTDArray<GrHoistedLayer>& layers) {
     GrLayerCache* layerCache = context->getLayerCache();
 
     for (int i = 0; i < layers.count(); ++i) {
         layerCache->removeUse(layers[i].fLayer);
     }
 
     SkDEBUGCODE(layerCache->validate();)
 }
 
 void GrLayerHoister::PurgeCache(GrContext* context) {
 #if !GR_CACHE_HOISTED_LAYERS
     GrLayerCache* layerCache = context->getLayerCache();
 
     // This code completely clears out the atlas. It is required when
     // caching is disabled so the atlas doesn't fill up and force more
     // free floating layers
     layerCache->purgeAll();
 #endif
 }