First pass at pre-rendering saveLayers for GPU

src/core/SkPicturePlayback.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #ifndef SkPicturePlayback_DEFINED
 #define SkPicturePlayback_DEFINED
 
 #include "SkPicture.h"
 #include "SkReader32.h"
 
 #include "SkBitmap.h"
 #include "SkData.h"
 #include "SkMatrix.h"
 #include "SkReadBuffer.h"
@@ skipping 66 matching lines @@
                                                const SkPictInfo&,
                                                SkPicture::InstallPixelRefProc);
     static SkPicturePlayback* CreateFromBuffer(SkPicture* picture,
                                                SkReadBuffer&,
                                                const SkPictInfo&);
 
     virtual ~SkPicturePlayback();
 
     const SkPicture::OperationList& getActiveOps(const SkIRect& queryRect);
 
+    void setUseBBH(bool useBBH) { fUseBBH = useBBH; }
+
     void draw(SkCanvas& canvas, SkDrawPictureCallback*);
 
     void serialize(SkWStream*, SkPicture::EncodeBitmap) const;
     void flatten(SkWriteBuffer&) const;
 
     void dumpSize() const;
 
     bool containsBitmaps() const;
 
 #ifdef SK_BUILD_FOR_ANDROID
@@ skipping 116 matching lines @@
 #endif
 
 private:    // these help us with reading/writing
     bool parseStreamTag(SkPicture* picture, SkStream*, uint32_t tag, uint32_t size,
                         SkPicture::InstallPixelRefProc);
     bool parseBufferTag(SkPicture* picture, SkReadBuffer&, uint32_t tag, uint32_t size);
     void flattenToBuffer(SkWriteBuffer&) const;
 
 private:
     friend class SkPicture;
+    friend class SkGpuDevice;   // for access to setDrawLimits & setReplacements
 
     // The picture that owns this SkPicturePlayback object
     const SkPicture* fPicture;
 
     // Only used by getBitmap() if the passed in index is SkBitmapHeap::INVALID_SLOT. This empty
     // bitmap allows playback to draw nothing and move on.
     SkBitmap fBadBitmap;
 
     SkAutoTUnref<SkBitmapHeap> fBitmapHeap;
 
     SkTRefArray<SkBitmap>* fBitmaps;
     SkTRefArray<SkPaint>* fPaints;
 
     SkData* fOpData;    // opcodes and parameters
 
     SkPicture** fPictureRefs;
     int fPictureCount;
 
     SkBBoxHierarchy* fBoundingHierarchy;
     SkPictureStateTree* fStateTree;
 
+    // Limit the opcode playback to be between the offsets 'start' and 'stop'.
+    // The opcode at 'start' should be a saveLayer while the opcode at
+    // 'stop' should be a restore. Neither of those commands will be issued.
+    // Set both start & stop to 0 to disable draw limiting
+    // Draw limiting cannot be enabled at the same time as draw replacing
+    void setDrawLimits(size_t start, size_t stop) {
+        SkASSERT(NULL == fReplacements);
+        fStart = start;
+        fStop = stop;
+    }
+
+    // PlaybackReplacements collects op ranges that can be replaced with
+    // a single drawBitmap call (using a precomputed bitmap).
+    class PlaybackReplacements {

[reed1, 2014/05/07 16:13:28]

nit: can this guy live in the .cpp, and just forward-declare its name here?

[robertphillips, 2014/05/07 16:52:03]

SkGpuDevice needs access to it. I have, however, moved the non-single-line
methods to the cpp.

+    public:
+        // All the operations between fStart and fStop (inclusive) will be replaced with
+        // a single drawBitmap call using fPos, fBM and fPaint.
+        // fPaint will be NULL if the picture's paint wasn't copyable
+        struct ReplacementInfo {
+            size_t          fStart;
+            size_t          fStop;
+            SkPoint         fPos;
+            SkBitmap*       fBM;
+            const SkPaint*  fPaint;  // Note: this object doesn't own the paint
+        };
+
+        ~PlaybackReplacements() {
+            this->freeAll();
+        }
+
+        // Add a new replacement range. The replacement ranges should be 
+        // sorted in increasing order and non-overlapping (esp. no nested
+        // saveLayers).
+        ReplacementInfo* push() { 
+            SkDEBUGCODE(this->validate());
+            return fReplacements.push(); 
+        }
+
+    private:
+        friend class SkPicturePlayback; // for access to lookupByStart
+
+        // look up a replacement range by its start offset
+        ReplacementInfo* lookupByStart(size_t start);
+
+        void freeAll() {
+            for (int i = 0; i < fReplacements.count(); ++i) {
+                SkDELETE(fReplacements[i].fBM);
+            }
+            fReplacements.reset();
+        }
+
+#ifdef SK_DEBUG
+        void validate() const {
+            // Check that the ranges are monotonically increasing and non-overlapping
+            if (fReplacements.count() > 0) {
+                SkASSERT(fReplacements[0].fStart < fReplacements[0].fStop);
+
+                for (int i = 1; i < fReplacements.count(); ++i) {
+                    SkASSERT(fReplacements[i].fStart < fReplacements[i].fStop);
+                    SkASSERT(fReplacements[i-1].fStop < fReplacements[i].fStart);
+                }
+            }
+        }
+#endif
+
+        SkTDArray<ReplacementInfo> fReplacements;
+    };
+
+    // Replace all the draw ops in the replacement ranges in 'replacements' with
+    // the associated drawBitmap call
+    // Draw replacing cannot be enabled at the same time as draw limiting
+    void setReplacements(PlaybackReplacements* replacements) {
+        SkASSERT(fStart == 0 && fStop == 0);
+        fReplacements = replacements;
+    }
+
+    bool   fUseBBH;
+    size_t fStart;
+    size_t fStop;
+    PlaybackReplacements* fReplacements;
+
     class CachedOperationList : public SkPicture::OperationList {
     public:
         CachedOperationList() {
             fCacheQueryRect.setEmpty();
         }
 
         virtual bool valid() const { return true; }
         virtual int numOps() const SK_OVERRIDE { return fOps.count(); }
         virtual uint32_t offset(int index) const SK_OVERRIDE;
         virtual const SkMatrix& matrix(int index) const SK_OVERRIDE;
@@ skipping 21 matching lines @@
     static void WriteFactories(SkWStream* stream, const SkFactorySet& rec);
     static void WriteTypefaces(SkWStream* stream, const SkRefCntSet& rec);
 
 #ifdef SK_BUILD_FOR_ANDROID
     SkMutex fDrawMutex;
     bool fAbortCurrentPlayback;
 #endif
 };
 
 #endif