Remove picture pre-allocation from SkPictureRecorder

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
@@ skipping 44 matching lines @@
 // This tag specifies the size of the ReadBuffer, needed for the following tags
 #define SK_PICT_BUFFER_SIZE_TAG     SkSetFourByteTag('a', 'r', 'a', 'y')
 // these are all inside the ARRAYS tag
 #define SK_PICT_BITMAP_BUFFER_TAG  SkSetFourByteTag('b', 't', 'm', 'p')
 #define SK_PICT_PAINT_BUFFER_TAG   SkSetFourByteTag('p', 'n', 't', ' ')
 #define SK_PICT_PATH_BUFFER_TAG    SkSetFourByteTag('p', 't', 'h', ' ')
 
 // Always write this guy last (with no length field afterwards)
 #define SK_PICT_EOF_TAG     SkSetFourByteTag('e', 'o', 'f', ' ')
 
+// SkPictureContentInfo is not serialized! It is intended solely for use
+// with suitableForGpuRasterization.
+class SkPictureContentInfo {
+public:
+    SkPictureContentInfo() { this->reset(); }
+
+    SkPictureContentInfo(const SkPictureContentInfo& src) { this->set(src); }
+
+    void set(const SkPictureContentInfo& src) {
+        fNumPaintWithPathEffectUses = src.fNumPaintWithPathEffectUses;
+        fNumAAConcavePaths = src.fNumAAConcavePaths;
+        fNumAAHairlineConcavePaths = src.fNumAAHairlineConcavePaths;
+    }
+
+    void reset() {
+        fNumPaintWithPathEffectUses = 0;
+        fNumAAConcavePaths = 0;
+        fNumAAHairlineConcavePaths = 0;
+    }
+
+    void swap(SkPictureContentInfo* other) {
+        SkTSwap(fNumPaintWithPathEffectUses, other->fNumPaintWithPathEffectUses);
+        SkTSwap(fNumAAConcavePaths, other->fNumAAConcavePaths);
+        SkTSwap(fNumAAHairlineConcavePaths, other->fNumAAHairlineConcavePaths);
+    }
+
+    void incPaintWithPathEffectUses() { ++fNumPaintWithPathEffectUses; }
+    int numPaintWithPathEffectUses() const { return fNumPaintWithPathEffectUses; }
+
+    void incAAConcavePaths() { ++fNumAAConcavePaths; }
+    int numAAConcavePaths() const { return fNumAAConcavePaths; }
+
+    void incAAHairlineConcavePaths() {
+        ++fNumAAHairlineConcavePaths;
+        SkASSERT(fNumAAHairlineConcavePaths <= fNumAAConcavePaths);
+    }
+    int numAAHairlineConcavePaths() const { return fNumAAHairlineConcavePaths; }
+
+private:
+    // This field is incremented every time a paint with a path effect is
+    // used (i.e., it is not a de-duplicated count)
+    int fNumPaintWithPathEffectUses;
+    // This field is incremented every time an anti-aliased drawPath call is
+    // issued with a concave path
+    int fNumAAConcavePaths;
+    // This field is incremented every time a drawPath call is
+    // issued for a hairline stroked concave path.
+    int fNumAAHairlineConcavePaths;
+};
+
 /**
  * Container for data that is needed to deep copy a SkPicture. The container
  * enables the data to be generated once and reused for subsequent copies.
  */
 struct SkPictCopyInfo {
     SkPictCopyInfo() : initialized(false), controller(1024) {}
 
     bool initialized;
     SkChunkFlatController controller;
     SkTDArray<SkFlatData*> paintData;
 };
 
 class SkPicturePlayback {
 public:
     SkPicturePlayback(const SkPicture* picture, const SkPicturePlayback& src,
                       SkPictCopyInfo* deepCopyInfo = NULL);
-    SkPicturePlayback(const SkPicture* picture, const SkPictureRecord& record, const SkPictInfo&,
-                      bool deepCopyOps);
+    SkPicturePlayback(const SkPicture* picture, const SkPictureRecord& record, 
+                      const SkPictInfo&, bool deepCopyOps);
     static SkPicturePlayback* CreateFromStream(SkPicture* picture,
                                                SkStream*,
                                                const SkPictInfo&,
                                                SkPicture::InstallPixelRefProc);
     static SkPicturePlayback* CreateFromBuffer(SkPicture* picture,
                                                SkReadBuffer&,
                                                const SkPictInfo&);
 
     virtual ~SkPicturePlayback();
 
@@ skipping 122 matching lines @@
     int dumpPtr(char* bufferPtr, char* buffer, char* name, void* ptr);
     int dumpRectPtr(char* bufferPtr, char* buffer, char* name);
     int dumpScalar(char* bufferPtr, char* buffer, char* name);
     void dumpText(char** bufferPtrPtr, char* buffer);
     void dumpStream();
 
 public:
     void dump() const;
 #endif
 
+#if SK_SUPPORT_GPU
+    bool suitableForGpuRasterization(GrContext* context, const char **reason) const;
+#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
 
@@ skipping 10 matching lines @@
     SkTRefArray<SkPaint>* fPaints;
 
     SkData* fOpData;    // opcodes and parameters
 
     const SkPicture** fPictureRefs;
     int fPictureCount;
 
     SkBBoxHierarchy* fBoundingHierarchy;
     SkPictureStateTree* fStateTree;
 
+    SkPictureContentInfo fContentInfo;
+
     // 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;
     }
@@ skipping 82 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