blob: df8c670689bb2258b66be6bbf20747b80654cabb [file] [log] [blame]
robertphillips@google.come930a072014-04-03 00:34:27 +00001/*
2 * Copyright 2014 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef GrLayerCache_DEFINED
9#define GrLayerCache_DEFINED
10
robertphillips4ec84da2014-06-24 13:10:43 -070011#include "GrAtlas.h"
robertphillips@google.come930a072014-04-03 00:34:27 +000012#include "GrRect.h"
robertphillips9e6835d2014-10-22 05:33:52 -070013
robertphillips3d533ac2014-07-20 09:40:00 -070014#include "SkChecksum.h"
robertphillips7b9e8a42014-12-11 08:20:31 -080015#include "SkImageFilter.h"
robertphillipsd771f6b2014-07-22 10:18:06 -070016#include "SkMessageBus.h"
robertphillips82365912014-11-12 09:32:34 -080017#include "SkPicture.h"
robertphillips9e6835d2014-10-22 05:33:52 -070018#include "SkTDynamicHash.h"
robertphillips@google.come930a072014-04-03 00:34:27 +000019
robertphillips4ab5a902014-10-29 13:56:02 -070020// Set to 0 to disable caching of hoisted layers
21#define GR_CACHE_HOISTED_LAYERS 0
22
mtklein04c96952014-11-24 08:20:57 -080023// GrPictureInfo stores the atlas plots used by a single picture. A single
robertphillips261b8a92014-07-17 08:26:44 -070024// plot may be used to store layers from multiple pictures.
25struct GrPictureInfo {
26public:
robertphillips225a6272014-10-30 11:39:19 -070027 static const int kNumPlots = 4;
28
robertphillips3d533ac2014-07-20 09:40:00 -070029 // for SkTDynamicHash - just use the pictureID as the hash key
30 static const uint32_t& GetKey(const GrPictureInfo& pictInfo) { return pictInfo.fPictureID; }
31 static uint32_t Hash(const uint32_t& key) { return SkChecksum::Mix(key); }
32
33 // GrPictureInfo proper
robertphillips225a6272014-10-30 11:39:19 -070034 GrPictureInfo(uint32_t pictureID) : fPictureID(pictureID) {
35#if !GR_CACHE_HOISTED_LAYERS
36 memset(fPlotUses, 0, sizeof(fPlotUses));
37#endif
38 }
39
40#if !GR_CACHE_HOISTED_LAYERS
41 void incPlotUsage(int plotID) {
42 SkASSERT(plotID < kNumPlots);
43 fPlotUses[plotID]++;
44 }
45
46 void decPlotUsage(int plotID) {
47 SkASSERT(plotID < kNumPlots);
48 SkASSERT(fPlotUses[plotID] > 0);
49 fPlotUses[plotID]--;
50 }
51
52 int plotUsage(int plotID) const {
53 SkASSERT(plotID < kNumPlots);
54 return fPlotUses[plotID];
55 }
56#endif
robertphillips261b8a92014-07-17 08:26:44 -070057
robertphillips3d533ac2014-07-20 09:40:00 -070058 const uint32_t fPictureID;
robertphillips261b8a92014-07-17 08:26:44 -070059 GrAtlas::ClientPlotUsage fPlotUsage;
robertphillips225a6272014-10-30 11:39:19 -070060
61#if !GR_CACHE_HOISTED_LAYERS
62private:
63 int fPlotUses[kNumPlots];
64#endif
robertphillips261b8a92014-07-17 08:26:44 -070065};
66
commit-bot@chromium.org365cd312014-04-11 15:53:47 +000067// GrCachedLayer encapsulates the caching information for a single saveLayer.
68//
robertphillips21048b52014-07-15 19:46:35 -070069// Atlased layers get a ref to the backing GrTexture while non-atlased layers
70// get a ref to the GrTexture in which they reside. In both cases 'fRect'
71// contains the layer's extent in its texture.
robertphillips261b8a92014-07-17 08:26:44 -070072// Atlased layers also get a pointer to the plot in which they reside.
robertphillips0c423322014-07-31 11:02:38 -070073// For non-atlased layers, the lock field just corresponds to locking in
74// the resource cache. For atlased layers, it implements an additional level
robertphillips320c9232014-07-29 06:07:19 -070075// of locking to allow atlased layers to be reused multiple times.
commit-bot@chromium.org365cd312014-04-11 15:53:47 +000076struct GrCachedLayer {
robertphillips@google.come930a072014-04-03 00:34:27 +000077public:
robertphillips3d533ac2014-07-20 09:40:00 -070078 // For SkTDynamicHash
79 struct Key {
robertphillips01d6e5f2014-12-01 09:09:27 -080080 Key(uint32_t pictureID, const SkMatrix& initialMat,
robertphillipse99d4992014-12-03 07:33:57 -080081 const unsigned* key, int keySize, bool copyKey = false)
robertphillips01d6e5f2014-12-01 09:09:27 -080082 : fKeySize(keySize)
83 , fFreeKey(copyKey) {
84 fIDMatrix.fPictureID = pictureID;
85 fIDMatrix.fInitialMat = initialMat;
86 fIDMatrix.fInitialMat.getType(); // force initialization of type so hashes match
robertphillips3aac6e02014-10-20 08:52:40 -070087
robertphillips01d6e5f2014-12-01 09:09:27 -080088 if (copyKey) {
robertphillipse99d4992014-12-03 07:33:57 -080089 unsigned* tempKey = SkNEW_ARRAY(unsigned, keySize);
90 memcpy(tempKey, key, keySize*sizeof(unsigned));
robertphillips01d6e5f2014-12-01 09:09:27 -080091 fKey = tempKey;
92 } else {
93 fKey = key;
94 }
95
96 // The pictureID/matrix portion needs to be tightly packed.
97 GR_STATIC_ASSERT(sizeof(IDMatrix) == sizeof(uint32_t)+ // pictureID
98 9 * sizeof(SkScalar) + sizeof(uint32_t)); // matrix
99 }
100
101 ~Key() {
102 if (fFreeKey) {
103 SkDELETE_ARRAY(fKey);
104 }
robertphillips3d533ac2014-07-20 09:40:00 -0700105 }
106
robertphillips0c423322014-07-31 11:02:38 -0700107 bool operator==(const Key& other) const {
robertphillips01d6e5f2014-12-01 09:09:27 -0800108 if (fKeySize != other.fKeySize) {
109 return false;
110 }
111 return fIDMatrix.fPictureID == other.fIDMatrix.fPictureID &&
112 fIDMatrix.fInitialMat.cheapEqualTo(other.fIDMatrix.fInitialMat) &&
113 !memcmp(fKey, other.fKey, fKeySize * sizeof(int));
robertphillips0c423322014-07-31 11:02:38 -0700114 }
115
robertphillips01d6e5f2014-12-01 09:09:27 -0800116 uint32_t pictureID() const { return fIDMatrix.fPictureID; }
117
118 // TODO: remove these when GrCachedLayer & ReplacementInfo fuse
robertphillipse99d4992014-12-03 07:33:57 -0800119 const unsigned* key() const { SkASSERT(fFreeKey); return fKey; }
robertphillips01d6e5f2014-12-01 09:09:27 -0800120 int keySize() const { SkASSERT(fFreeKey); return fKeySize; }
121
122 uint32_t hash() const {
123 uint32_t hash = SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(fKey),
124 fKeySize * sizeof(int));
125 return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(&fIDMatrix),
126 sizeof(IDMatrix), hash);
127 }
robertphillips3d533ac2014-07-20 09:40:00 -0700128
129 private:
robertphillips01d6e5f2014-12-01 09:09:27 -0800130 struct IDMatrix {
131 // ID of the picture of which this layer is a part
132 uint32_t fPictureID;
133 // The initial matrix passed into drawPicture
134 SkMatrix fInitialMat;
135 } fIDMatrix;
136
robertphillipse99d4992014-12-03 07:33:57 -0800137 const unsigned* fKey;
138 const int fKeySize;
139 bool fFreeKey;
robertphillips3d533ac2014-07-20 09:40:00 -0700140 };
141
142 static const Key& GetKey(const GrCachedLayer& layer) { return layer.fKey; }
robertphillips01d6e5f2014-12-01 09:09:27 -0800143 static uint32_t Hash(const Key& key) { return key.hash(); }
robertphillips952841b2014-06-30 08:26:50 -0700144
robertphillips3d533ac2014-07-20 09:40:00 -0700145 // GrCachedLayer proper
robertphillipse99d4992014-12-03 07:33:57 -0800146 GrCachedLayer(uint32_t pictureID, unsigned start, unsigned stop,
robertphillips478dd722014-12-16 08:25:55 -0800147 const SkIRect& srcIR, const SkIRect& dstIR,
148 const SkMatrix& ctm,
robertphillipse99d4992014-12-03 07:33:57 -0800149 const unsigned* key, int keySize,
robertphillips3aac6e02014-10-20 08:52:40 -0700150 const SkPaint* paint)
robertphillips01d6e5f2014-12-01 09:09:27 -0800151 : fKey(pictureID, ctm, key, keySize, true)
152 , fStart(start)
robertphillipsed420592014-09-29 11:39:38 -0700153 , fStop(stop)
robertphillips478dd722014-12-16 08:25:55 -0800154 , fSrcIR(srcIR)
155 , fDstIR(dstIR)
156 , fOffset(SkIPoint::Make(0, 0))
robertphillipsa0537de2014-09-18 08:01:23 -0700157 , fPaint(paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL)
robertphillips7b9e8a42014-12-11 08:20:31 -0800158 , fFilter(NULL)
robertphillips3d533ac2014-07-20 09:40:00 -0700159 , fTexture(NULL)
robertphillipse99d4992014-12-03 07:33:57 -0800160 , fRect(SkIRect::MakeEmpty())
robertphillips320c9232014-07-29 06:07:19 -0700161 , fPlot(NULL)
robertphillips7bb9ed72014-10-10 11:38:29 -0700162 , fUses(0)
robertphillips320c9232014-07-29 06:07:19 -0700163 , fLocked(false) {
robertphillipse99d4992014-12-03 07:33:57 -0800164 SkASSERT(SK_InvalidGenID != pictureID);
robertphillips7b9e8a42014-12-11 08:20:31 -0800165
166 if (fPaint) {
robertphillips95145a92015-01-14 08:08:21 -0800167 if (fPaint->getImageFilter()) {
robertphillips478dd722014-12-16 08:25:55 -0800168 fFilter = SkSafeRef(fPaint->getImageFilter());
169 fPaint->setImageFilter(NULL);
170 }
robertphillips7b9e8a42014-12-11 08:20:31 -0800171 }
robertphillips3d533ac2014-07-20 09:40:00 -0700172 }
173
robertphillipsed6f03e2014-07-30 07:31:35 -0700174 ~GrCachedLayer() {
175 SkSafeUnref(fTexture);
robertphillips7b9e8a42014-12-11 08:20:31 -0800176 SkSafeUnref(fFilter);
robertphillipsa0537de2014-09-18 08:01:23 -0700177 SkDELETE(fPaint);
robertphillipsed6f03e2014-07-30 07:31:35 -0700178 }
179
robertphillips0c423322014-07-31 11:02:38 -0700180 uint32_t pictureID() const { return fKey.pictureID(); }
robertphillips01d6e5f2014-12-01 09:09:27 -0800181 // TODO: remove these when GrCachedLayer & ReplacementInfo fuse
robertphillipse99d4992014-12-03 07:33:57 -0800182 const unsigned* key() const { return fKey.key(); }
robertphillips01d6e5f2014-12-01 09:09:27 -0800183 int keySize() const { return fKey.keySize(); }
robertphillips@google.come930a072014-04-03 00:34:27 +0000184
robertphillipse99d4992014-12-03 07:33:57 -0800185 unsigned start() const { return fStart; }
robertphillips01d6e5f2014-12-01 09:09:27 -0800186 // TODO: make bound debug only
robertphillips478dd722014-12-16 08:25:55 -0800187 const SkIRect& srcIR() const { return fSrcIR; }
188 const SkIRect& dstIR() const { return fDstIR; }
robertphillipse99d4992014-12-03 07:33:57 -0800189 unsigned stop() const { return fStop; }
190 void setTexture(GrTexture* texture, const SkIRect& rect) {
robertphillipsed6f03e2014-07-30 07:31:35 -0700191 SkRefCnt_SafeAssign(fTexture, texture);
robertphillips952841b2014-06-30 08:26:50 -0700192 fRect = rect;
robertphillips95145a92015-01-14 08:08:21 -0800193 if (!fTexture) {
194 fLocked = false;
195 }
commit-bot@chromium.org365cd312014-04-11 15:53:47 +0000196 }
robertphillips952841b2014-06-30 08:26:50 -0700197 GrTexture* texture() { return fTexture; }
robertphillips4aa6dfc2014-09-17 07:50:47 -0700198 const SkPaint* paint() const { return fPaint; }
robertphillips7b9e8a42014-12-11 08:20:31 -0800199 const SkImageFilter* filter() const { return fFilter; }
robertphillipse99d4992014-12-03 07:33:57 -0800200 const SkIRect& rect() const { return fRect; }
commit-bot@chromium.org365cd312014-04-11 15:53:47 +0000201
robertphillips478dd722014-12-16 08:25:55 -0800202 void setOffset(const SkIPoint& offset) { fOffset = offset; }
203 const SkIPoint& offset() const { return fOffset; }
204
robertphillips261b8a92014-07-17 08:26:44 -0700205 void setPlot(GrPlot* plot) {
robertphillips6f294af2014-08-18 08:50:03 -0700206 SkASSERT(NULL == plot || NULL == fPlot);
robertphillips261b8a92014-07-17 08:26:44 -0700207 fPlot = plot;
208 }
209 GrPlot* plot() { return fPlot; }
robertphillips21048b52014-07-15 19:46:35 -0700210
bsalomon49f085d2014-09-05 13:34:00 -0700211 bool isAtlased() const { return SkToBool(fPlot); }
robertphillips261b8a92014-07-17 08:26:44 -0700212
robertphillips320c9232014-07-29 06:07:19 -0700213 void setLocked(bool locked) { fLocked = locked; }
214 bool locked() const { return fLocked; }
215
216 SkDEBUGCODE(const GrPlot* plot() const { return fPlot; })
robertphillips261b8a92014-07-17 08:26:44 -0700217 SkDEBUGCODE(void validate(const GrTexture* backingTexture) const;)
robertphillips21048b52014-07-15 19:46:35 -0700218
robertphillips@google.come930a072014-04-03 00:34:27 +0000219private:
robertphillips3d533ac2014-07-20 09:40:00 -0700220 const Key fKey;
commit-bot@chromium.org365cd312014-04-11 15:53:47 +0000221
robertphillips01d6e5f2014-12-01 09:09:27 -0800222 // The "saveLayer" operation index of the cached layer
robertphillipse99d4992014-12-03 07:33:57 -0800223 const unsigned fStart;
robertphillipsed420592014-09-29 11:39:38 -0700224 // The final "restore" operation index of the cached layer
robertphillipse99d4992014-12-03 07:33:57 -0800225 const unsigned fStop;
robertphillipsed420592014-09-29 11:39:38 -0700226
robertphillips478dd722014-12-16 08:25:55 -0800227 // The layer's src rect (i.e., the portion of the source scene required
228 // for filtering).
229 const SkIRect fSrcIR;
230 // The layer's dest rect (i.e., where it will land in device space)
231 const SkIRect fDstIR;
232 // Offset sometimes required by image filters
233 SkIPoint fOffset;
robertphillips01d6e5f2014-12-01 09:09:27 -0800234
robertphillips4aa6dfc2014-09-17 07:50:47 -0700235 // The paint used when dropping the layer down into the owning canvas.
robertphillipsa0537de2014-09-18 08:01:23 -0700236 // Can be NULL. This class makes a copy for itself.
robertphillips7b9e8a42014-12-11 08:20:31 -0800237 SkPaint* fPaint;
238
239 // The imagefilter that needs to be applied to the layer prior to it being
240 // composited with the rest of the scene.
241 const SkImageFilter* fFilter;
robertphillips4aa6dfc2014-09-17 07:50:47 -0700242
skia.committer@gmail.comd9427312014-04-12 03:05:59 +0000243 // fTexture is a ref on the atlasing texture for atlased layers and a
robertphillips320c9232014-07-29 06:07:19 -0700244 // ref on a GrTexture for non-atlased textures.
commit-bot@chromium.org365cd312014-04-11 15:53:47 +0000245 GrTexture* fTexture;
246
robertphillips21048b52014-07-15 19:46:35 -0700247 // For both atlased and non-atlased layers 'fRect' contains the bound of
248 // the layer in whichever texture it resides. It is empty when 'fTexture'
249 // is NULL.
robertphillipse99d4992014-12-03 07:33:57 -0800250 SkIRect fRect;
robertphillips261b8a92014-07-17 08:26:44 -0700251
252 // For atlased layers, fPlot stores the atlas plot in which the layer rests.
253 // It is always NULL for non-atlased layers.
254 GrPlot* fPlot;
robertphillips320c9232014-07-29 06:07:19 -0700255
robertphillips7bb9ed72014-10-10 11:38:29 -0700256 // The number of actively hoisted layers using this cached image (e.g.,
257 // extant GrHoistedLayers pointing at this object). This object will
258 // be unlocked when the use count reaches 0.
259 int fUses;
260
bsalomon49f085d2014-09-05 13:34:00 -0700261 // For non-atlased layers 'fLocked' should always match "fTexture".
robertphillips320c9232014-07-29 06:07:19 -0700262 // (i.e., if there is a texture it is locked).
263 // For atlased layers, 'fLocked' is true if the layer is in a plot and
264 // actively required for rendering. If the layer is in a plot but not
265 // actively required for rendering, then 'fLocked' is false. If the
266 // layer isn't in a plot then is can never be locked.
267 bool fLocked;
robertphillips7bb9ed72014-10-10 11:38:29 -0700268
269 void addUse() { ++fUses; }
270 void removeUse() { SkASSERT(fUses > 0); --fUses; }
271 int uses() const { return fUses; }
272
273 friend class GrLayerCache; // for access to usage methods
274 friend class TestingAccess; // for testing
robertphillips@google.come930a072014-04-03 00:34:27 +0000275};
276
277// The GrLayerCache caches pre-computed saveLayers for later rendering.
commit-bot@chromium.org365cd312014-04-11 15:53:47 +0000278// Non-atlased layers are stored in their own GrTexture while the atlased
279// layers share a single GrTexture.
robertphillips1d86ee82014-06-24 15:08:49 -0700280// Unlike the GrFontCache, the GrTexture atlas only has one GrAtlas (for 8888)
robertphillips@google.come930a072014-04-03 00:34:27 +0000281// and one GrPlot (for the entire atlas). As such, the GrLayerCache
282// roughly combines the functionality of the GrFontCache and GrTextStrike
283// classes.
284class GrLayerCache {
285public:
robertphillips4ec84da2014-06-24 13:10:43 -0700286 GrLayerCache(GrContext*);
robertphillips@google.come930a072014-04-03 00:34:27 +0000287 ~GrLayerCache();
288
robertphillips4ec84da2014-06-24 13:10:43 -0700289 // As a cache, the GrLayerCache can be ordered to free up all its cached
290 // elements by the GrContext
robertphillips@google.come930a072014-04-03 00:34:27 +0000291 void freeAll();
292
robertphillipse99d4992014-12-03 07:33:57 -0800293 GrCachedLayer* findLayer(uint32_t pictureID, const SkMatrix& ctm,
294 const unsigned* key, int keySize);
robertphillips6f294af2014-08-18 08:50:03 -0700295 GrCachedLayer* findLayerOrCreate(uint32_t pictureID,
robertphillips0c423322014-07-31 11:02:38 -0700296 int start, int stop,
robertphillips478dd722014-12-16 08:25:55 -0800297 const SkIRect& srcIR,
298 const SkIRect& dstIR,
robertphillips01d6e5f2014-12-01 09:09:27 -0800299 const SkMatrix& initialMat,
robertphillipse99d4992014-12-03 07:33:57 -0800300 const unsigned* key, int keySize,
robertphillips4aa6dfc2014-09-17 07:50:47 -0700301 const SkPaint* paint);
robertphillips6f294af2014-08-18 08:50:03 -0700302
robertphillipsfd61ed02014-10-28 07:21:44 -0700303 // Attempt to place 'layer' in the atlas. Return true on success; false on failure.
304 // When true is returned, 'needsRendering' will indicate if the layer must be (re)drawn.
305 // Additionally, the GPU resources will be locked.
bsalomonf2703d82014-10-28 14:33:06 -0700306 bool tryToAtlas(GrCachedLayer* layer, const GrSurfaceDesc& desc, bool* needsRendering);
robertphillipsfd61ed02014-10-28 07:21:44 -0700307
308 // Attempt to lock the GPU resources required for a layer. Return true on success;
309 // false on failure. When true is returned 'needsRendering' will indicate if the
310 // layer must be (re)drawn.
311 // Note that atlased layers should already have been locked and rendered so only
312 // free floating layers will have 'needsRendering' set.
313 // Currently, this path always uses a new scratch texture for non-Atlased layers
314 // and (thus) doesn't cache anything. This can yield a lot of re-rendering.
315 // TODO: allow rediscovery of free-floating layers that are still in the resource cache.
bsalomonf2703d82014-10-28 14:33:06 -0700316 bool lock(GrCachedLayer* layer, const GrSurfaceDesc& desc, bool* needsRendering);
robertphillips4ec84da2014-06-24 13:10:43 -0700317
robertphillips7bb9ed72014-10-10 11:38:29 -0700318 // addUse is just here to keep the API symmetric
319 void addUse(GrCachedLayer* layer) { layer->addUse(); }
320 void removeUse(GrCachedLayer* layer) {
321 layer->removeUse();
322 if (layer->uses() == 0) {
323 // If no one cares about the layer allow it to be recycled.
324 this->unlock(layer);
325 }
326 }
robertphillips@google.come930a072014-04-03 00:34:27 +0000327
robertphillipsd771f6b2014-07-22 10:18:06 -0700328 // Cleanup after any SkPicture deletions
329 void processDeletedPictures();
robertphillips952841b2014-06-30 08:26:50 -0700330
robertphillips21048b52014-07-15 19:46:35 -0700331 SkDEBUGCODE(void validate() const;)
332
robertphillips84ac0822014-10-14 07:07:59 -0700333#ifdef SK_DEVELOPER
334 void writeLayersToDisk(const SkString& dirName);
335#endif
336
robertphillipsfd61ed02014-10-28 07:21:44 -0700337 static bool PlausiblyAtlasable(int width, int height) {
338 return width <= kPlotWidth && height <= kPlotHeight;
339 }
340
robertphillips4ab5a902014-10-29 13:56:02 -0700341#if !GR_CACHE_HOISTED_LAYERS
342 void purgeAll();
343#endif
344
robertphillips@google.come930a072014-04-03 00:34:27 +0000345private:
robertphillips320c9232014-07-29 06:07:19 -0700346 static const int kAtlasTextureWidth = 1024;
347 static const int kAtlasTextureHeight = 1024;
348
robertphillips261b8a92014-07-17 08:26:44 -0700349 static const int kNumPlotsX = 2;
350 static const int kNumPlotsY = 2;
351
robertphillips320c9232014-07-29 06:07:19 -0700352 static const int kPlotWidth = kAtlasTextureWidth / kNumPlotsX;
353 static const int kPlotHeight = kAtlasTextureHeight / kNumPlotsY;
354
robertphillips4ec84da2014-06-24 13:10:43 -0700355 GrContext* fContext; // pointer back to owning context
robertphillips1d86ee82014-06-24 15:08:49 -0700356 SkAutoTDelete<GrAtlas> fAtlas; // TODO: could lazily allocate
robertphillips261b8a92014-07-17 08:26:44 -0700357
358 // We cache this information here (rather then, say, on the owning picture)
359 // because we want to be able to clean it up as needed (e.g., if a picture
360 // is leaked and never cleans itself up we still want to be able to
361 // remove the GrPictureInfo once its layers are purged from all the atlas
362 // plots).
robertphillips3d533ac2014-07-20 09:40:00 -0700363 SkTDynamicHash<GrPictureInfo, uint32_t> fPictureHash;
robertphillips@google.come930a072014-04-03 00:34:27 +0000364
robertphillips3d533ac2014-07-20 09:40:00 -0700365 SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key> fLayerHash;
robertphillips@google.come930a072014-04-03 00:34:27 +0000366
mtklein04c96952014-11-24 08:20:57 -0800367 SkMessageBus<SkPicture::DeletionMessage>::Inbox fPictDeletionInbox;
robertphillipsd771f6b2014-07-22 10:18:06 -0700368
robertphillips320c9232014-07-29 06:07:19 -0700369 // This implements a plot-centric locking mechanism (since the atlas
370 // backing texture is always locked). Each layer that is locked (i.e.,
371 // needed for the current rendering) in a plot increments the plot lock
robertphillipsa32c6bc2014-10-09 12:47:01 -0700372 // count for that plot. Similarly, once a rendering is complete all the
373 // layers used in it decrement the lock count for the used plots.
374 // Plots with a 0 lock count are open for recycling/purging.
robertphillips320c9232014-07-29 06:07:19 -0700375 int fPlotLocks[kNumPlotsX * kNumPlotsY];
376
robertphillips7bb9ed72014-10-10 11:38:29 -0700377 // Inform the cache that layer's cached image is not currently required
378 void unlock(GrCachedLayer* layer);
379
robertphillips952841b2014-06-30 08:26:50 -0700380 void initAtlas();
robertphillips01d6e5f2014-12-01 09:09:27 -0800381 GrCachedLayer* createLayer(uint32_t pictureID, int start, int stop,
robertphillips478dd722014-12-16 08:25:55 -0800382 const SkIRect& srcIR, const SkIRect& dstIR,
383 const SkMatrix& initialMat,
robertphillipse99d4992014-12-03 07:33:57 -0800384 const unsigned* key, int keySize,
robertphillips3aac6e02014-10-20 08:52:40 -0700385 const SkPaint* paint);
robertphillips6f294af2014-08-18 08:50:03 -0700386
robertphillipsd771f6b2014-07-22 10:18:06 -0700387 // Remove all the layers (and unlock any resources) associated with 'pictureID'
388 void purge(uint32_t pictureID);
389
robertphillips6f294af2014-08-18 08:50:03 -0700390 void purgePlot(GrPlot* plot);
391
robertphillips320c9232014-07-29 06:07:19 -0700392 // Try to find a purgeable plot and clear it out. Return true if a plot
393 // was purged; false otherwise.
394 bool purgePlot();
395
robertphillips7bb9ed72014-10-10 11:38:29 -0700396 void incPlotLock(int plotIdx) { ++fPlotLocks[plotIdx]; }
397 void decPlotLock(int plotIdx) {
398 SkASSERT(fPlotLocks[plotIdx] > 0);
399 --fPlotLocks[plotIdx];
400 }
401
robertphillips952841b2014-06-30 08:26:50 -0700402 // for testing
robertphillipsd771f6b2014-07-22 10:18:06 -0700403 friend class TestingAccess;
robertphillips952841b2014-06-30 08:26:50 -0700404 int numLayers() const { return fLayerHash.count(); }
robertphillips@google.come930a072014-04-03 00:34:27 +0000405};
406
407#endif