Implement SkBaseDevice snapshot support

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"
 #include "GrContext.h"
 #include "GrDistanceFieldTextContext.h"
 #include "GrGpu.h"
 #include "GrGpuResourcePriv.h"
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
 #include "GrStrokeInfo.h"
 #include "GrTracing.h"
 #include "SkCanvasPriv.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDrawProcs.h"
 #include "SkErrorInternals.h"
 #include "SkGlyphCache.h"
 #include "SkGrTexturePixelRef.h"
 #include "SkImageFilter.h"
+#include "SkImagePriv.h"
 #include "SkImage_Base.h"
 #include "SkLayerInfo.h"
 #include "SkMaskFilter.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
 #include "SkPictureData.h"
 #include "SkRRect.h"
 #include "SkRecord.h"
 #include "SkStroke.h"
 #include "SkSurface.h"
 #include "SkSurface_Gpu.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkVertState.h"
 #include "SkXfermode.h"
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "effects/GrTextureDomain.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;  \
-            this->prepareDraw(draw);                            \
-        } while (0)
+extern bool (*gShouldDrawProc)();
+#define CHECK_SHOULD_DRAW(draw)                            \
+    do {                                                   \
+        if (gShouldDrawProc && !gShouldDrawProc()) return; \
+        if (!this->prepareDraw(draw)) return;              \
+    } while (0)
 #else
-    #define CHECK_SHOULD_DRAW(draw) this->prepareDraw(draw)
+#define CHECK_SHOULD_DRAW(draw) if (!this->prepareDraw(draw)) return;
 #endif
 
+
 // This constant represents the screen alignment criterion in texels for
 // requiring texture domain clamping to prevent color bleeding when drawing
 // a sub region of a larger source image.
 #define COLOR_BLEED_TOLERANCE 0.001f
 
 #define DO_DEFERRED_CLEAR()             \
     do {                                \
         if (fNeedClear) {               \
             this->clearAll();           \
         }                               \
@@ skipping 88 matching lines @@
 }
 
 static SkSurfaceProps copy_or_default_props(const SkSurfaceProps* props) {
     if (props) {
         return SkSurfaceProps(*props);
     } else {
         return SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
     }
 }
 
+namespace {
+
+void wrap_surface(GrSurface* rt, SkBitmap* bm) {
+    bm->setInfo(rt->surfacePriv().info());
+    SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (rt->surfacePriv().info(), rt));
+    bm->setPixelRef(pr)->unref();
+}
+
+};
+
 SkGpuDevice::SkGpuDevice(GrRenderTarget* rt, const SkSurfaceProps* props, unsigned flags)
     : INHERITED(surfaceprops_to_deviceprops(props))
     , fSurfaceProps(copy_or_default_props(props))
+    , fSurface(NULL)
 {
     fDrawProcs = NULL;
 
     fContext = SkRef(rt->getContext());
     fNeedClear = flags & kNeedClear_Flag;
 
     fRenderTarget = SkRef(rt);
 
-    SkImageInfo info = rt->surfacePriv().info();
-    SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (info, rt));
-    fLegacyBitmap.setInfo(info);
-    fLegacyBitmap.setPixelRef(pr)->unref();
-
+    wrap_surface(fRenderTarget, &fLegacyBitmap);
     bool useDFT = fSurfaceProps.isUseDistanceFieldFonts();
     fTextContext = fContext->createTextContext(fRenderTarget, this, this->getLeakyProperties(),
                                                useDFT);
 }
 
 GrRenderTarget* SkGpuDevice::CreateRenderTarget(GrContext* context, SkSurface::Budgeted budgeted,
                                                 const SkImageInfo& origInfo, int sampleCount) {
     if (kUnknown_SkColorType == origInfo.colorType() ||
         origInfo.width() < 0 || origInfo.height() < 0) {
         return NULL;
@@ skipping 48 matching lines @@
     }
 
     delete fTextContext;
 
     fRenderTarget->unref();
     fContext->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+void SkGpuDevice::discard() {
+    if (fSurface) {
+        fSurface->notifyContentWillChange();
+    }
+    this->prepareBackendRenderTarget(kDiscard_ModifyMode);
+}
+
 bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                                int x, int y) {
     DO_DEFERRED_CLEAR();
 
     // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
     GrPixelConfig config = SkImageInfo2GrPixelConfig(dstInfo);
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
 
     uint32_t flags = 0;
     if (kUnpremul_SkAlphaType == dstInfo.alphaType()) {
         flags = GrContext::kUnpremul_PixelOpsFlag;
     }
     return fContext->readRenderTargetPixels(fRenderTarget, x, y, dstInfo.width(), dstInfo.height(),
                                             config, dstPixels, dstRowBytes, flags);
 }
 
 bool SkGpuDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
                                 int x, int y) {
     // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
     GrPixelConfig config = SkImageInfo2GrPixelConfig(info);
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
+
+    if (!this->prepareWrite()) {
+        return false;
+    }
+
     uint32_t flags = 0;
     if (kUnpremul_SkAlphaType == info.alphaType()) {
         flags = GrContext::kUnpremul_PixelOpsFlag;
     }
     fRenderTarget->writePixels(x, y, info.width(), info.height(), config, pixels, rowBytes, flags);
 
     // need to bump our genID for compatibility with clients that "know" we have a bitmap
     fLegacyBitmap.notifyPixelsChanged();
 
     return true;
 }
 
 const SkBitmap& SkGpuDevice::onAccessBitmap() {
-    DO_DEFERRED_CLEAR();
+    // Must prepare for write because user might obtain the texture from the bitmap and then modify
+    // it.
+    this->prepareWrite();
     return fLegacyBitmap;
 }
 
 void SkGpuDevice::onAttachToCanvas(SkCanvas* canvas) {
     INHERITED::onAttachToCanvas(canvas);
 
     // Canvas promises that this ptr is valid until onDetachFromCanvas is called
     fClipStack.reset(SkRef(canvas->getClipStack()));
 }
 
 void SkGpuDevice::onDetachFromCanvas() {
     INHERITED::onDetachFromCanvas();
     fClip.reset();
     fClipStack.reset(NULL);
 }
 
 // call this every draw call, to ensure that the context reflects our state,
 // and not the state from some other canvas/device
-void SkGpuDevice::prepareDraw(const SkDraw& draw) {
+bool SkGpuDevice::prepareDraw(const SkDraw& draw) {
     SkASSERT(fClipStack.get());
 
     SkASSERT(draw.fClipStack && draw.fClipStack == fClipStack);
 
     fClip.setClipStack(fClipStack, &this->getOrigin());
 
-    DO_DEFERRED_CLEAR();
+    if (!this->prepareBackendRenderTarget(kDrawContent_ModifyMode)) {
+        return false;
+    }
+
+    if (fSurface) {
+        fSurface->notifyContentWillChange();
+    }
+
+    return true;
+}
+
+bool SkGpuDevice::prepareWrite() {
+    if (!this->prepareBackendRenderTarget(kDrawContent_ModifyMode)) {
+        return false;
+    }
+    if (fSurface) {
+        fSurface->notifyContentWillChange();
+    }
+    return true;
 }
 
 GrRenderTarget* SkGpuDevice::accessRenderTarget() {
-    DO_DEFERRED_CLEAR();
+    // The render target could be read through the ptr, so we must do deferred clear. The render
+    // target could be written to through the ptr, so we must detach the snapshot.
+    this->prepareWrite();
     return fRenderTarget;
 }
 
 void SkGpuDevice::clearAll() {
     GrColor color = 0;
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::clearAll", fContext);
     SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
     fContext->clear(&rect, color, true, fRenderTarget);
     fNeedClear = false;
 }
 
-void SkGpuDevice::replaceRenderTarget(bool shouldRetainContent) {
-    // Caller must have accessed the render target, because it knows the rt must be replaced.
-    SkASSERT(!fNeedClear);
+bool SkGpuDevice::prepareBackendRenderTarget(ModifyMode writeMode) {
+    // We are preparing for modifying the render target. This will detach the snapshot in all
+    // cases, so do the detach right away.
+    SkAutoTUnref<SkImage> snapshot;
+    snapshot.swap(&fSnapshot);
+
+    bool needNewRenderTarget = false;
+
+    if (NULL != snapshot) {
+        SkASSERT(!fNeedClear);
+        needNewRenderTarget = fRenderTarget->asTexture() == SkTextureImageGetTexture(snapshot) &&
+                !snapshot->unique();
+    }
+
+    if (!needNewRenderTarget) {
+        if (writeMode == kDiscard_ModifyMode) {
+            fRenderTarget->discard();
+            fNeedClear = false;
+        }
+        if (fRenderTarget->wasDestroyed()) {
+            return false;
+        }
+
+        DO_DEFERRED_CLEAR();
+        return true;
+    }
 
     SkSurface::Budgeted budgeted =
             fRenderTarget->resourcePriv().isBudgeted() ? SkSurface::kYes_Budgeted
                                                        : SkSurface::kNo_Budgeted;
 
     SkAutoTUnref<GrRenderTarget> newRT(CreateRenderTarget(
-        fRenderTarget->getContext(), budgeted, this->imageInfo(), fRenderTarget->numSamples()));
+        this->context(), budgeted, this->imageInfo(), fRenderTarget->numSamples()));
 
     if (NULL == newRT) {
-        return;
+        return false;
     }
 
-    if (shouldRetainContent) {
+    if (writeMode == kDrawContent_ModifyMode) {
         if (fRenderTarget->wasDestroyed()) {
-            return;
+            return false;
         }
-        this->context()->copySurface(newRT, fRenderTarget);
+
+        if (fNeedClear) {
+            // Clear the snapshot render target and clear the new render target.
+            this->clearAll();
+            fNeedClear = true; // Clears the new render target.
+        } else {
+            this->context()->copySurface(newRT, fRenderTarget);
+        }
+    } else {
+        fNeedClear = false;
     }
 
     SkASSERT(fRenderTarget != newRT);
-
     fRenderTarget->unref();
     fRenderTarget = newRT.detach();
 
     SkASSERT(fRenderTarget->surfacePriv().info() == fLegacyBitmap.info());
-    SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (fRenderTarget->surfacePriv().info(), fRenderTarget));
-    fLegacyBitmap.setPixelRef(pr)->unref();
+    wrap_surface(fRenderTarget, &fLegacyBitmap);
+
+    SkASSERT(!fRenderTarget->wasDestroyed());
+
+    DO_DEFERRED_CLEAR();
+
+    if (snapshot) {
+        SkTextureImageApplyBudgetedDecision(snapshot);
+    }
+
+    return true;
 }
 
+bool SkGpuDevice::isBackendBudgeted() const {
+    return fRenderTarget->resourcePriv().isBudgeted();
+}
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_COMPILE_ASSERT(SkShader::kNone_BitmapType == 0, shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kDefault_BitmapType == 1, shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kRadial_BitmapType == 2, shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kSweep_BitmapType == 3, shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kTwoPointRadial_BitmapType == 4,
                   shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kTwoPointConical_BitmapType == 5,
                   shader_type_mismatch);
@@ skipping 377 matching lines @@
     // setup new clip
     GrClip clip(clipRect);
 
     // 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(mask->asRenderTarget(), clip, tempPaint, translate, devPath, strokeInfo);
     return mask;
 }
 
-SkBitmap wrap_texture(GrTexture* texture) {
-    SkBitmap result;
-    result.setInfo(texture->surfacePriv().info());
-    result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (result.info(), texture)))->unref();
-    return result;
-}
-
 };
 
 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);
 
     return this->internalDrawPath(origSrcPath, paint, *draw.fMatrix, prePathMatrix,
@@ skipping 721 matching lines @@
                                 const SkImageFilter* filter,
                                 const SkImageFilter::Context& ctx,
                                 SkBitmap* 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()) {
-        return filter->filterImageGPU(&proxy, wrap_texture(texture), ctx, result, offset);
+        SkBitmap filterInput;
+        wrap_surface(texture, &filterInput);
+        return filter->filterImageGPU(&proxy, filterInput, 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 115 matching lines @@
     dstSize.fWidth = tmpDst.width();
     dstSize.fHeight = tmpDst.height();
 
     this->drawBitmapCommon(*draw, bitmap, &tmpSrc, &dstSize, paint, flags);
 }
 
 void SkGpuDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
                              int x, int y, const SkPaint& paint) {
     // clear of the source device must occur before CHECK_SHOULD_DRAW
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawDevice", fContext);
-    SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
-
     // TODO: If the source device covers the whole of this device, we could
     // omit fNeedsClear -related flushing.
-    // TODO: if source needs clear, we could maybe omit the draw fully.
+    // TODO: if source is a gpu device, we could inspect its fNeedsClear,
+    // and we could maybe omit the draw fully.
 
-    // drawDevice is defined to be in device coords.
-    CHECK_SHOULD_DRAW(draw);
-
-    GrRenderTarget* devRT = dev->accessRenderTarget();
-    GrTexture* devTex;
-    if (NULL == (devTex = devRT->asTexture())) {
+    SkAutoTUnref<SkImage> devImage(device->newImageSnapshot());
+    if (NULL == devImage) {
+        return;
+    }
+    GrTexture* devTex = devImage->getTexture();
+    if (NULL == devTex) {
         return;
     }
 
-    const SkImageInfo ii = dev->imageInfo();
-    int w = ii.width();
-    int h = ii.height();
+    int w = devImage->width();
+    int h = devImage->height();
 
     SkImageFilter* filter = paint.getImageFilter();
     // This bitmap will own the filtered result as a texture.
     SkBitmap filteredBitmap;
 
     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,
                                 &offset)) {
             devTex = filteredBitmap.getTexture();
             w = filteredBitmap.width();
             h = filteredBitmap.height();
             x += offset.fX;
             y += offset.fY;
         } else {
             return;
         }
     }
+    // drawDevice is defined to be in device coords.
+    CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
     grPaint.addColorTextureProcessor(devTex, SkMatrix::I());
 
     SkPaint2GrPaintNoShader(this->context(), fRenderTarget, paint,
                             SkColor2GrColorJustAlpha(paint.getColor()), false, &grPaint);
 
     SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(x),
                                       SkIntToScalar(y),
                                       SkIntToScalar(w),
@@ skipping 199 matching lines @@
         return true;
     }
     return false;
 }
 
 void SkGpuDevice::flush() {
     DO_DEFERRED_CLEAR();
     fRenderTarget->prepareForExternalRead();
 }
 
+SkImage* SkGpuDevice::newImageSnapshot() {
+    return this->newImageSnapshot(&fSurfaceProps, SkSurface::kYes_Budgeted);
+}
+
+SkImage* SkGpuDevice::newImageSnapshot(const SkSurfaceProps* props, SkSurface::Budgeted budgeted) {
+    if (NULL == fSnapshot) {
+        if (fRenderTarget->wasDestroyed()) {
+            return NULL;
+        }
+        DO_DEFERRED_CLEAR();
+        const int sampleCount = fRenderTarget->numSamples();
+        SkImage* image = SkNewImageFromBitmapTexture(fLegacyBitmap, sampleCount, budgeted);
+        if (!image) {
+            return NULL;
+        }
+        if (props) {
+            as_IB(image)->initWithProps(*props);
+        }
+        fSnapshot.reset(image);
+    }
+    return SkRef(fSnapshot.get());
+}
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBaseDevice* SkGpuDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint*) {
     GrSurfaceDesc desc;
     desc.fConfig = fRenderTarget->config();
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = cinfo.fInfo.width();
     desc.fHeight = cinfo.fInfo.height();
     desc.fSampleCnt = fRenderTarget->numSamples();
 
@@ skipping 92 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