| /* | |
| * Copyright 2014 Google Inc. | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #ifndef GrLayerCache_DEFINED | |
| #define GrLayerCache_DEFINED | |
| #include "GrAtlas.h" | |
| #include "GrRect.h" | |
| #include "SkChecksum.h" | |
| #include "SkImageFilter.h" | |
| #include "SkMessageBus.h" | |
| #include "SkPicture.h" | |
| #include "SkTDynamicHash.h" | |
| // Set to 0 to disable caching of hoisted layers | |
| #define GR_CACHE_HOISTED_LAYERS 0 | |
| // GrPictureInfo stores the atlas plots used by a single picture. A single | |
| // plot may be used to store layers from multiple pictures. | |
| struct GrPictureInfo { | |
| public: | |
| static const int kNumPlots = 4; | |
| // for SkTDynamicHash - just use the pictureID as the hash key | |
| static const uint32_t& GetKey(const GrPictureInfo& pictInfo) { return pictInfo.fPictureID; } | |
| static uint32_t Hash(const uint32_t& key) { return SkChecksum::Mix(key); } | |
| // GrPictureInfo proper | |
| GrPictureInfo(uint32_t pictureID) : fPictureID(pictureID) { | |
| #if !GR_CACHE_HOISTED_LAYERS | |
| memset(fPlotUses, 0, sizeof(fPlotUses)); | |
| #endif | |
| } | |
| #if !GR_CACHE_HOISTED_LAYERS | |
| void incPlotUsage(int plotID) { | |
| SkASSERT(plotID < kNumPlots); | |
| fPlotUses[plotID]++; | |
| } | |
| void decPlotUsage(int plotID) { | |
| SkASSERT(plotID < kNumPlots); | |
| SkASSERT(fPlotUses[plotID] > 0); | |
| fPlotUses[plotID]--; | |
| } | |
| int plotUsage(int plotID) const { | |
| SkASSERT(plotID < kNumPlots); | |
| return fPlotUses[plotID]; | |
| } | |
| #endif | |
| const uint32_t fPictureID; | |
| GrAtlas::ClientPlotUsage fPlotUsage; | |
| #if !GR_CACHE_HOISTED_LAYERS | |
| private: | |
| int fPlotUses[kNumPlots]; | |
| #endif | |
| }; | |
| // GrCachedLayer encapsulates the caching information for a single saveLayer. | |
| // | |
| // Atlased layers get a ref to the backing GrTexture while non-atlased layers | |
| // get a ref to the GrTexture in which they reside. In both cases 'fRect' | |
| // contains the layer's extent in its texture. | |
| // Atlased layers also get a pointer to the plot in which they reside. | |
| // For non-atlased layers, the lock field just corresponds to locking in | |
| // the resource cache. For atlased layers, it implements an additional level | |
| // of locking to allow atlased layers to be reused multiple times. | |
| struct GrCachedLayer { | |
| public: | |
| // For SkTDynamicHash | |
| struct Key { | |
| Key(uint32_t pictureID, const SkMatrix& initialMat, | |
| const unsigned* key, int keySize, bool copyKey = false) | |
| : fKeySize(keySize) | |
| , fFreeKey(copyKey) { | |
| fIDMatrix.fPictureID = pictureID; | |
| fIDMatrix.fInitialMat = initialMat; | |
| fIDMatrix.fInitialMat.getType(); // force initialization of type so hashes match | |
| if (copyKey) { | |
| unsigned* tempKey = SkNEW_ARRAY(unsigned, keySize); | |
| memcpy(tempKey, key, keySize*sizeof(unsigned)); | |
| fKey = tempKey; | |
| } else { | |
| fKey = key; | |
| } | |
| // The pictureID/matrix portion needs to be tightly packed. | |
| GR_STATIC_ASSERT(sizeof(IDMatrix) == sizeof(uint32_t)+ // pictureID | |
| 9 * sizeof(SkScalar) + sizeof(uint32_t)); // matrix | |
| } | |
| ~Key() { | |
| if (fFreeKey) { | |
| SkDELETE_ARRAY(fKey); | |
| } | |
| } | |
| bool operator==(const Key& other) const { | |
| if (fKeySize != other.fKeySize) { | |
| return false; | |
| } | |
| return fIDMatrix.fPictureID == other.fIDMatrix.fPictureID && | |
| fIDMatrix.fInitialMat.cheapEqualTo(other.fIDMatrix.fInitialMat) && | |
| !memcmp(fKey, other.fKey, fKeySize * sizeof(int)); | |
| } | |
| uint32_t pictureID() const { return fIDMatrix.fPictureID; } | |
| // TODO: remove these when GrCachedLayer & ReplacementInfo fuse | |
| const unsigned* key() const { SkASSERT(fFreeKey); return fKey; } | |
| int keySize() const { SkASSERT(fFreeKey); return fKeySize; } | |
| uint32_t hash() const { | |
| uint32_t hash = SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(fKey), | |
| fKeySize * sizeof(int)); | |
| return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(&fIDMatrix), | |
| sizeof(IDMatrix), hash); | |
| } | |
| private: | |
| struct IDMatrix { | |
| // ID of the picture of which this layer is a part | |
| uint32_t fPictureID; | |
| // The initial matrix passed into drawPicture | |
| SkMatrix fInitialMat; | |
| } fIDMatrix; | |
| const unsigned* fKey; | |
| const int fKeySize; | |
| bool fFreeKey; | |
| }; | |
| static const Key& GetKey(const GrCachedLayer& layer) { return layer.fKey; } | |
| static uint32_t Hash(const Key& key) { return key.hash(); } | |
| // GrCachedLayer proper | |
| GrCachedLayer(uint32_t pictureID, unsigned start, unsigned stop, | |
| const SkIRect& srcIR, const SkIRect& dstIR, | |
| const SkMatrix& ctm, | |
| const unsigned* key, int keySize, | |
| const SkPaint* paint) | |
| : fKey(pictureID, ctm, key, keySize, true) | |
| , fStart(start) | |
| , fStop(stop) | |
| , fSrcIR(srcIR) | |
| , fDstIR(dstIR) | |
| , fOffset(SkIPoint::Make(0, 0)) | |
| , fPaint(paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL) | |
| , fFilter(NULL) | |
| , fTexture(NULL) | |
| , fRect(SkIRect::MakeEmpty()) | |
| , fPlot(NULL) | |
| , fUses(0) | |
| , fLocked(false) { | |
| SkASSERT(SK_InvalidGenID != pictureID); | |
| if (fPaint) { | |
| if (fPaint->getImageFilter() && fPaint->getImageFilter()->canFilterImageGPU()) { | |
| fFilter = SkSafeRef(fPaint->getImageFilter()); | |
| fPaint->setImageFilter(NULL); | |
| } | |
| } | |
| } | |
| ~GrCachedLayer() { | |
| SkSafeUnref(fTexture); | |
| SkSafeUnref(fFilter); | |
| SkDELETE(fPaint); | |
| } | |
| uint32_t pictureID() const { return fKey.pictureID(); } | |
| // TODO: remove these when GrCachedLayer & ReplacementInfo fuse | |
| const unsigned* key() const { return fKey.key(); } | |
| int keySize() const { return fKey.keySize(); } | |
| unsigned start() const { return fStart; } | |
| // TODO: make bound debug only | |
| const SkIRect& srcIR() const { return fSrcIR; } | |
| const SkIRect& dstIR() const { return fDstIR; } | |
| unsigned stop() const { return fStop; } | |
| void setTexture(GrTexture* texture, const SkIRect& rect) { | |
| SkRefCnt_SafeAssign(fTexture, texture); | |
| fRect = rect; | |
| } | |
| GrTexture* texture() { return fTexture; } | |
| const SkPaint* paint() const { return fPaint; } | |
| const SkImageFilter* filter() const { return fFilter; } | |
| const SkIRect& rect() const { return fRect; } | |
| void setOffset(const SkIPoint& offset) { fOffset = offset; } | |
| const SkIPoint& offset() const { return fOffset; } | |
| void setPlot(GrPlot* plot) { | |
| SkASSERT(NULL == plot || NULL == fPlot); | |
| fPlot = plot; | |
| } | |
| GrPlot* plot() { return fPlot; } | |
| bool isAtlased() const { return SkToBool(fPlot); } | |
| void setLocked(bool locked) { fLocked = locked; } | |
| bool locked() const { return fLocked; } | |
| SkDEBUGCODE(const GrPlot* plot() const { return fPlot; }) | |
| SkDEBUGCODE(void validate(const GrTexture* backingTexture) const;) | |
| private: | |
| const Key fKey; | |
| // The "saveLayer" operation index of the cached layer | |
| const unsigned fStart; | |
| // The final "restore" operation index of the cached layer | |
| const unsigned fStop; | |
| // The layer's src rect (i.e., the portion of the source scene required | |
| // for filtering). | |
| const SkIRect fSrcIR; | |
| // The layer's dest rect (i.e., where it will land in device space) | |
| const SkIRect fDstIR; | |
| // Offset sometimes required by image filters | |
| SkIPoint fOffset; | |
| // The paint used when dropping the layer down into the owning canvas. | |
| // Can be NULL. This class makes a copy for itself. | |
| SkPaint* fPaint; | |
| // The imagefilter that needs to be applied to the layer prior to it being | |
| // composited with the rest of the scene. | |
| const SkImageFilter* fFilter; | |
| // fTexture is a ref on the atlasing texture for atlased layers and a | |
| // ref on a GrTexture for non-atlased textures. | |
| GrTexture* fTexture; | |
| // For both atlased and non-atlased layers 'fRect' contains the bound of | |
| // the layer in whichever texture it resides. It is empty when 'fTexture' | |
| // is NULL. | |
| SkIRect fRect; | |
| // For atlased layers, fPlot stores the atlas plot in which the layer rests. | |
| // It is always NULL for non-atlased layers. | |
| GrPlot* fPlot; | |
| // The number of actively hoisted layers using this cached image (e.g., | |
| // extant GrHoistedLayers pointing at this object). This object will | |
| // be unlocked when the use count reaches 0. | |
| int fUses; | |
| // For non-atlased layers 'fLocked' should always match "fTexture". | |
| // (i.e., if there is a texture it is locked). | |
| // For atlased layers, 'fLocked' is true if the layer is in a plot and | |
| // actively required for rendering. If the layer is in a plot but not | |
| // actively required for rendering, then 'fLocked' is false. If the | |
| // layer isn't in a plot then is can never be locked. | |
| bool fLocked; | |
| void addUse() { ++fUses; } | |
| void removeUse() { SkASSERT(fUses > 0); --fUses; } | |
| int uses() const { return fUses; } | |
| friend class GrLayerCache; // for access to usage methods | |
| friend class TestingAccess; // for testing | |
| }; | |
| // The GrLayerCache caches pre-computed saveLayers for later rendering. | |
| // Non-atlased layers are stored in their own GrTexture while the atlased | |
| // layers share a single GrTexture. | |
| // Unlike the GrFontCache, the GrTexture atlas only has one GrAtlas (for 8888) | |
| // and one GrPlot (for the entire atlas). As such, the GrLayerCache | |
| // roughly combines the functionality of the GrFontCache and GrTextStrike | |
| // classes. | |
| class GrLayerCache { | |
| public: | |
| GrLayerCache(GrContext*); | |
| ~GrLayerCache(); | |
| // As a cache, the GrLayerCache can be ordered to free up all its cached | |
| // elements by the GrContext | |
| void freeAll(); | |
| GrCachedLayer* findLayer(uint32_t pictureID, const SkMatrix& ctm, | |
| const unsigned* key, int keySize); | |
| GrCachedLayer* findLayerOrCreate(uint32_t pictureID, | |
| int start, int stop, | |
| const SkIRect& srcIR, | |
| const SkIRect& dstIR, | |
| const SkMatrix& initialMat, | |
| const unsigned* key, int keySize, | |
| const SkPaint* paint); | |
| // Attempt to place 'layer' in the atlas. Return true on success; false on failure. | |
| // When true is returned, 'needsRendering' will indicate if the layer must be (re)drawn. | |
| // Additionally, the GPU resources will be locked. | |
| bool tryToAtlas(GrCachedLayer* layer, const GrSurfaceDesc& desc, bool* needsRendering); | |
| // Attempt to lock the GPU resources required for a layer. Return true on success; | |
| // false on failure. When true is returned 'needsRendering' will indicate if the | |
| // layer must be (re)drawn. | |
| // Note that atlased layers should already have been locked and rendered so only | |
| // free floating layers will have 'needsRendering' set. | |
| // Currently, this path always uses a new scratch texture for non-Atlased layers | |
| // and (thus) doesn't cache anything. This can yield a lot of re-rendering. | |
| // TODO: allow rediscovery of free-floating layers that are still in the resource cache. | |
| bool lock(GrCachedLayer* layer, const GrSurfaceDesc& desc, bool* needsRendering); | |
| // addUse is just here to keep the API symmetric | |
| void addUse(GrCachedLayer* layer) { layer->addUse(); } | |
| void removeUse(GrCachedLayer* layer) { | |
| layer->removeUse(); | |
| if (layer->uses() == 0) { | |
| // If no one cares about the layer allow it to be recycled. | |
| this->unlock(layer); | |
| } | |
| } | |
| // Cleanup after any SkPicture deletions | |
| void processDeletedPictures(); | |
| SkDEBUGCODE(void validate() const;) | |
| #ifdef SK_DEVELOPER | |
| void writeLayersToDisk(const SkString& dirName); | |
| #endif | |
| static bool PlausiblyAtlasable(int width, int height) { | |
| return width <= kPlotWidth && height <= kPlotHeight; | |
| } | |
| #if !GR_CACHE_HOISTED_LAYERS | |
| void purgeAll(); | |
| #endif | |
| private: | |
| static const int kAtlasTextureWidth = 1024; | |
| static const int kAtlasTextureHeight = 1024; | |
| static const int kNumPlotsX = 2; | |
| static const int kNumPlotsY = 2; | |
| static const int kPlotWidth = kAtlasTextureWidth / kNumPlotsX; | |
| static const int kPlotHeight = kAtlasTextureHeight / kNumPlotsY; | |
| GrContext* fContext; // pointer back to owning context | |
| SkAutoTDelete<GrAtlas> fAtlas; // TODO: could lazily allocate | |
| // We cache this information here (rather then, say, on the owning picture) | |
| // because we want to be able to clean it up as needed (e.g., if a picture | |
| // is leaked and never cleans itself up we still want to be able to | |
| // remove the GrPictureInfo once its layers are purged from all the atlas | |
| // plots). | |
| SkTDynamicHash<GrPictureInfo, uint32_t> fPictureHash; | |
| SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key> fLayerHash; | |
| SkMessageBus<SkPicture::DeletionMessage>::Inbox fPictDeletionInbox; | |
| // This implements a plot-centric locking mechanism (since the atlas | |
| // backing texture is always locked). Each layer that is locked (i.e., | |
| // needed for the current rendering) in a plot increments the plot lock | |
| // count for that plot. Similarly, once a rendering is complete all the | |
| // layers used in it decrement the lock count for the used plots. | |
| // Plots with a 0 lock count are open for recycling/purging. | |
| int fPlotLocks[kNumPlotsX * kNumPlotsY]; | |
| // Inform the cache that layer's cached image is not currently required | |
| void unlock(GrCachedLayer* layer); | |
| void initAtlas(); | |
| GrCachedLayer* createLayer(uint32_t pictureID, int start, int stop, | |
| const SkIRect& srcIR, const SkIRect& dstIR, | |
| const SkMatrix& initialMat, | |
| const unsigned* key, int keySize, | |
| const SkPaint* paint); | |
| // Remove all the layers (and unlock any resources) associated with 'pictureID' | |
| void purge(uint32_t pictureID); | |
| void purgePlot(GrPlot* plot); | |
| // Try to find a purgeable plot and clear it out. Return true if a plot | |
| // was purged; false otherwise. | |
| bool purgePlot(); | |
| void incPlotLock(int plotIdx) { ++fPlotLocks[plotIdx]; } | |
| void decPlotLock(int plotIdx) { | |
| SkASSERT(fPlotLocks[plotIdx] > 0); | |
| --fPlotLocks[plotIdx]; | |
| } | |
| // for testing | |
| friend class TestingAccess; | |
| int numLayers() const { return fLayerHash.count(); } | |
| }; | |
| #endif |