hack

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 10 matching lines @@
 
 #include "SkBounder.h"
 #include "SkColorFilter.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
+#include "SkPicturePlayback.h"
 #include "SkRRect.h"
 #include "SkStroke.h"
 #include "SkSurface.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkErrorInternals.h"
 
+#define USE_SCRATCH 1
+
 #define CACHE_COMPATIBLE_DEVICE_TEXTURES 1
 
 #if 0
     extern bool (*gShouldDrawProc)();
     #define CHECK_SHOULD_DRAW(draw, forceI)                     \
         do {                                                    \
             if (gShouldDrawProc && !gShouldDrawProc()) return;  \
             this->prepareDraw(draw, forceI);                    \
         } while (0)
 #else
@@ skipping 138 matching lines @@
                                        GrRenderTarget* renderTarget,
                                        unsigned flags) {
     fDrawProcs = NULL;
 
     fContext = context;
     fContext->ref();
 
     fMainTextContext = SkNEW_ARGS(GrDistanceFieldTextContext, (fContext, fLeakyProperties));
     fFallbackTextContext = SkNEW_ARGS(GrBitmapTextContext, (fContext, fLeakyProperties));
 
-    fRenderTarget = NULL;
+    fRenderTarget1 = NULL;
     fNeedClear = flags & kNeedClear_Flag;
 
     SkASSERT(NULL != renderTarget);
-    fRenderTarget = renderTarget;
-    fRenderTarget->ref();
+//    SkDebugf("initFromRenderTarget\n");
+    fRenderTarget1 = renderTarget;
+    fRenderTarget1->ref();
 
     // Hold onto to the texture in the pixel ref (if there is one) because the texture holds a ref
     // on the RT but not vice-versa.
     // TODO: Remove this trickery once we figure out how to make SkGrPixelRef do this without
     // busting chrome (for a currently unknown reason).
-    GrSurface* surface = fRenderTarget->asTexture();
+    GrSurface* surface = fRenderTarget1->asTexture();
     if (NULL == surface) {
-        surface = fRenderTarget;
+        surface = fRenderTarget1;
     }
 
     SkImageInfo info;
     surface->asImageInfo(&info);
     SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (info, surface, SkToBool(flags & kCached_Flag)));
 
     this->setPixelRef(pr)->unref();
 }
 
 SkGpuDevice* SkGpuDevice::Create(GrContext* context, const SkImageInfo& origInfo,
@@ skipping 97 matching lines @@
 SkGpuDevice::~SkGpuDevice() {
     if (fDrawProcs) {
         delete fDrawProcs;
     }
 
     delete fMainTextContext;
     delete fFallbackTextContext;
 
     // The GrContext takes a ref on the target. We don't want to cause the render
     // target to be unnecessarily kept alive.
-    if (fContext->getRenderTarget() == fRenderTarget) {
+    if (fContext->getRenderTarget() == fRenderTarget1) {
         fContext->setRenderTarget(NULL);
     }
 
     if (fContext->getClip() == &fClipData) {
         fContext->setClip(NULL);
     }
 
-    SkSafeUnref(fRenderTarget);
+    SkSafeUnref(fRenderTarget1);
     fContext->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::makeRenderTargetCurrent() {
     DO_DEFERRED_CLEAR();
-    fContext->setRenderTarget(fRenderTarget);
+    fContext->setRenderTarget(fRenderTarget1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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.colorType(), dstInfo.alphaType());
     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(),
+    return fContext->readRenderTargetPixels(fRenderTarget1, 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.colorType(), info.alphaType());
     if (kUnknown_GrPixelConfig == config) {
         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);
+    fRenderTarget1->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
     this->onAccessBitmap().notifyPixelsChanged();
 
     return true;
 }
 
 const SkBitmap& SkGpuDevice::onAccessBitmap() {
     DO_DEFERRED_CLEAR();
     return INHERITED::onAccessBitmap();
 }
 
 void SkGpuDevice::onAttachToCanvas(SkCanvas* canvas) {
     INHERITED::onAttachToCanvas(canvas);
 
     // Canvas promises that this ptr is valid until onDetachFromCanvas is called
     fClipData.fClipStack = canvas->getClipStack();
 }
 
 void SkGpuDevice::onDetachFromCanvas() {
     INHERITED::onDetachFromCanvas();
     fClipData.fClipStack = 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 forceIdentity) {
     SkASSERT(NULL != fClipData.fClipStack);
 
-    fContext->setRenderTarget(fRenderTarget);
+    fContext->setRenderTarget(fRenderTarget1);
 
     SkASSERT(draw.fClipStack && draw.fClipStack == fClipData.fClipStack);
 
     if (forceIdentity) {
         fContext->setIdentityMatrix();
     } else {
         fContext->setMatrix(*draw.fMatrix);
     }
     fClipData.fOrigin = this->getOrigin();
 
     fContext->setClip(&fClipData);
 
     DO_DEFERRED_CLEAR();
 }
 
 GrRenderTarget* SkGpuDevice::accessRenderTarget() {
     DO_DEFERRED_CLEAR();
-    return fRenderTarget;
+    return fRenderTarget1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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);
@@ skipping 111 matching lines @@
         } else {
             return false;
         }
     }
 }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBitmap::Config SkGpuDevice::config() const {
-    if (NULL == fRenderTarget) {
+    if (NULL == fRenderTarget1) {
         return SkBitmap::kNo_Config;
     }
 
     bool isOpaque;
-    return grConfig2skConfig(fRenderTarget->config(), &isOpaque);
+    return grConfig2skConfig(fRenderTarget1->config(), &isOpaque);
 }
 
 void SkGpuDevice::clear(SkColor color) {
     SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
-    fContext->clear(&rect, SkColor2GrColor(color), true, fRenderTarget);
+    fContext->clear(&rect, SkColor2GrColor(color), true, fRenderTarget1);
     fNeedClear = false;
 }
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
 
     GrPaint grPaint;
     if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
         return;
     }
@@ skipping 333 matching lines @@
                            const SkPaint& paint, const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw, false);
 
     GrPaint grPaint;
     if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
         return;
     }
 
+//    grPaint.setAntiAlias(false);
+
     // If we have a prematrix, apply it to the path, optimizing for the case
     // where the original path can in fact be modified in place (even though
     // its parameter type is const).
     SkPath* pathPtr = const_cast<SkPath*>(&origSrcPath);
     SkTLazy<SkPath> tmpPath;
     SkTLazy<SkPath> effectPath;
 
     if (prePathMatrix) {
         SkPath* result = pathPtr;
 
@@ skipping 967 matching lines @@
         flags->fFlags = paint.getFlags() & ~SkPaint::kLCDRenderText_Flag;
         flags->fHinting = paint.getHinting();
         return true;
     }
     // we're cool with the paint as is
     return false;
 }
 
 void SkGpuDevice::flush() {
     DO_DEFERRED_CLEAR();
-    fContext->resolveRenderTarget(fRenderTarget);
+    fContext->resolveRenderTarget(fRenderTarget1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBaseDevice* SkGpuDevice::onCreateDevice(const SkImageInfo& info, Usage usage) {
     GrTextureDesc desc;
-    desc.fConfig = fRenderTarget->config();
+    desc.fConfig = fRenderTarget1->config();
     desc.fFlags = kRenderTarget_GrTextureFlagBit;
     desc.fWidth = info.width();
     desc.fHeight = info.height();
-    desc.fSampleCnt = fRenderTarget->numSamples();
+    desc.fSampleCnt = fRenderTarget1->numSamples();
 
     SkAutoTUnref<GrTexture> texture;
     // Skia's convention is to only clear a device if it is non-opaque.
     unsigned flags = info.isOpaque() ? 0 : kNeedClear_Flag;
 
 #if CACHE_COMPATIBLE_DEVICE_TEXTURES
     // layers are never draw in repeat modes, so we can request an approx
     // match and ignore any padding.
     flags |= kCached_Flag;
     const GrContext::ScratchTexMatch match = (kSaveLayer_Usage == usage) ?
                                                 GrContext::kApprox_ScratchTexMatch :
                                                 GrContext::kExact_ScratchTexMatch;
     texture.reset(fContext->lockAndRefScratchTexture(desc, match));
 #else
     texture.reset(fContext->createUncachedTexture(desc, NULL, 0));
 #endif
     if (NULL != texture.get()) {
         return SkGpuDevice::Create(texture, flags);
     } else {
         GrPrintf("---- failed to create compatible device texture [%d %d]\n",
                  info.width(), info.height());
         return NULL;
     }
 }
 
 SkSurface* SkGpuDevice::newSurface(const SkImageInfo& info) {
-    return SkSurface::NewRenderTarget(fContext, info, fRenderTarget->numSamples());
+    return SkSurface::NewRenderTarget(fContext, info, fRenderTarget1->numSamples());
 }
 
 // In the future this may not be a static method if we need to incorporate the
 // clip and matrix state into the key
 SkPicture::AccelData::Key SkGpuDevice::ComputeAccelDataKey() {
     static const SkPicture::AccelData::Key gGPUID = SkPicture::AccelData::GenerateDomain();
 
     return gGPUID;
 }
 
 void SkGpuDevice::EXPERIMENTAL_optimize(SkPicture* picture) {
+
     SkPicture::AccelData::Key key = ComputeAccelDataKey();
 
     GPUAccelData* data = SkNEW_ARGS(GPUAccelData, (key));
 
     picture->EXPERIMENTAL_addAccelData(data);
 
     GatherGPUInfo(picture, data);
 }
 
-bool SkGpuDevice::EXPERIMENTAL_drawPicture(SkPicture* picture) {
+void SkGpuDevice::EXPERIMENTAL_purge() {
+
+}
+
+static void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
+    SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
+    result->setConfig(info);
+    result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
+}
+
+#ifndef USE_SCRATCH
+
+static void generate_layer_cache_id(const SkPicture& picture, int layerID, GrCacheID* id) {
+    uint32_t genID = picture.uniqueID();
+
+    GrCacheID::Key key;
+    memcpy(key.fData8 +  0, &genID,   4);
+    memcpy(key.fData8 +  4, &layerID, 4);
+    static const size_t kKeyDataSize = 8;
+    memset(key.fData8 + kKeyDataSize, 0, sizeof(key) - kKeyDataSize);
+    GR_STATIC_ASSERT(sizeof(key) >= kKeyDataSize);
+    static const GrCacheID::Domain gLayerDomain = GrCacheID::GenerateDomain();
+    id->reset(gLayerDomain, key);
+}
+#endif
+
+bool SkGpuDevice::EXPERIMENTAL_drawPicture(SkCanvas* canvas1, SkPicture* picture) {
 
     SkPicture::AccelData::Key key = ComputeAccelDataKey();
 
     const SkPicture::AccelData* data = picture->EXPERIMENTAL_getAccelData(key);
     if (NULL == data) {
         return false;
     }
 
     const GPUAccelData *gpuData = static_cast<const GPUAccelData*>(data);
 
@@ skipping 35 matching lines @@
     SkRect r = SkRect::Make(clip);
     inv.mapRect(&r);
     r.roundOut(&clip);
 
     const SkPicture::OperationList& ops = picture->EXPERIMENTAL_getActiveOps(clip);
 
 #ifdef SK_PRINT_PULL_FORWARD_INFO
     SkDebugf("rect: %d %d %d %d\n", clip.fLeft, clip.fTop, clip.fRight, clip.fBottom);
 #endif
 
-    for (int i = 0; i < ops.numOps(); ++i) {
+    if (ops.valid()) {
+        for (int i = 0; i < ops.numOps(); ++i) {
+            for (int j = 0; j < gpuData->numSaveLayers(); ++j) {
+                const GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(j);
+
+                if (ops.offset(i) > info.fSaveLayerOpID && ops.offset(i) < info.fRestoreOpID) {
+                    pullForward[j] = true;
+                }
+            }
+        }
+    } else {
         for (int j = 0; j < gpuData->numSaveLayers(); ++j) {
-            const GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(j);
+            pullForward[j] = true;
+        }
+    }
 
-            if (ops.offset(i) > info.fSaveLayerOpID && ops.offset(i) < info.fRestoreOpID) {
-                pullForward[j] = true;
+    SkPicturePlayback::Bar bar;
+
+#ifdef SK_PRINT_PULL_FORWARD_INFO
+    SkDebugf("Need SaveLayers: ");
+#endif
+
+    for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
+        if (pullForward[i]) {
+            GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(picture, i);
+
+#ifdef SK_PRINT_PULL_FORWARD_INFO
+            SkDebugf("%d (%d), ", i, layer->layerID());
+#endif
+
+            const GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(i);
+
+            if (NULL != picture->fPlayback) {
+                SkPicturePlayback::Foo* temp = bar.push();
+
+                temp->fStart = info.fSaveLayerOpID;
+                temp->fStop = info.fRestoreOpID;
+                temp->fPos = info.fOrigin;
+
+                GrTextureDesc desc;
+                desc.fFlags = kRenderTarget_GrTextureFlagBit;
+                desc.fWidth = info.fSize.fWidth;
+                desc.fHeight = info.fSize.fHeight;
+                desc.fConfig = kSkia8888_GrPixelConfig;
+                // TODO: need to deal with sample count
+
+                bool bNeedsRendering = true;
+
+#if USE_SCRATCH
+                // This path just uses scratch textures and doesn't cache the texture.
+                // This can yield a lot of re-rendering
+                if (NULL == layer->getTexture()) {
+                    layer->setTexture(fContext->lockAndRefScratchTexture(desc, GrContext::kApprox_ScratchTexMatch));
+                    if (NULL == layer->getTexture()) {
+                        continue;
+                    }
+                } else {
+                    bNeedsRendering = false;
+                }
+#else
+                // This path caches the rendering result
+                GrCacheID cacheID;
+                generate_layer_cache_id(*picture, i, &cacheID);
+
+                layer->setTexture(fContext->findAndRefTexture(desc, cacheID, NULL));
+
+                if (NULL == layer->getTexture()) {
+                    layer->setTexture(fContext->createTexture(NULL, desc, cacheID, NULL, 0));
+                } else {
+                    bNeedsRendering = false;
+                }
+#endif
+
+                temp->fBM = SkNEW(SkBitmap);
+                wrap_texture(layer->getTexture(), desc.fWidth, desc.fHeight, temp->fBM);
+
+                temp->fPaint = info.fPaint;
+
+
+                if (bNeedsRendering) {
+                    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(layer->getTexture()->asRenderTarget()));
+
+                    SkCanvas* canvas = surface->getCanvas();
+
+                    canvas->translate(SkIntToScalar(-info.fOrigin.fX), SkIntToScalar(-info.fOrigin.fY));
+                    canvas->clear(SK_ColorTRANSPARENT);
+
+                    picture->fPlayback->draw(*canvas, info.fSaveLayerOpID, info.fRestoreOpID, NULL, NULL);
+                    canvas->flush();
+                }
             }
         }
     }
-
 #ifdef SK_PRINT_PULL_FORWARD_INFO
-    SkDebugf("Need SaveLayers: ");
-    for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
-        if (pullForward[i]) {
-            const GrAtlasedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(picture, i);
-
-            SkDebugf("%d (%d), ", i, layer->layerID());
-        }
-    }
     SkDebugf("\n");
 #endif
 
-    return false;
+    // Playback using new layers
+    picture->fPlayback->draw(*canvas1, -1, -1, NULL, &bar);
+
+    // playback normally
+//    picture->fPlayback->draw(*canvas1, -1, -1, NULL, NULL);
+
+    bar.freeAll();
+
+    for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
+//        GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(picture, i);
+
+#if USE_SCRATCH
+//        fContext->unlockScratchTexture(layer->getTexture());
+#endif
+//        layer->setTexture(NULL);
+    }
+
+    return true;
 }