1 /* 2 * Copyright 2015 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 GrStrikeCache_DEFINED 9 #define GrStrikeCache_DEFINED 10 11 #include "GrDrawOpAtlas.h" 12 #include "GrGlyph.h" 13 #include "SkArenaAlloc.h" 14 #include "SkMasks.h" 15 #include "SkStrike.h" 16 #include "SkTDynamicHash.h" 17 18 class GrAtlasManager; 19 class GrGpu; 20 class GrStrikeCache; 21 22 /** 23 * The GrTextStrike manages a pool of CPU backing memory for GrGlyphs. This backing memory 24 * is indexed by a PackedID and SkStrike. The SkStrike is what actually creates the mask. 25 * The GrTextStrike may outlive the generating SkStrike. However, it retains a copy 26 * of it's SkDescriptor as a key to access (or regenerate) the SkStrike. GrTextStrikes are 27 * created by and owned by a GrStrikeCache. 28 */ 29 class GrTextStrike : public SkNVRefCnt<GrTextStrike> { 30 public: 31 GrTextStrike(const SkDescriptor& fontScalerKey); 32 getGlyph(const SkGlyph & skGlyph)33 GrGlyph* getGlyph(const SkGlyph& skGlyph) { 34 GrGlyph* glyph = fCache.find(skGlyph.getPackedID()); 35 if (!glyph) { 36 glyph = this->generateGlyph(skGlyph); 37 } 38 return glyph; 39 } 40 41 // This variant of the above function is called by GrAtlasTextOp. At this point, it is possible 42 // that the maskformat of the glyph differs from what we expect. In these cases we will just 43 // draw a clear square. 44 // skbug:4143 crbug:510931 getGlyph(SkPackedGlyphID packed,SkStrike * cache)45 GrGlyph* getGlyph(SkPackedGlyphID packed, 46 SkStrike* cache) { 47 GrGlyph* glyph = fCache.find(packed); 48 if (!glyph) { 49 // We could return this to the caller, but in practice it adds code complexity for 50 // potentially little benefit(ie, if the glyph is not in our font cache, then its not 51 // in the atlas and we're going to be doing a texture upload anyways). 52 const SkGlyph& skGlyph = GrToSkGlyph(cache, packed); 53 glyph = this->generateGlyph(skGlyph); 54 } 55 return glyph; 56 } 57 58 // returns true if glyph successfully added to texture atlas, false otherwise. If the glyph's 59 // mask format has changed, then addGlyphToAtlas will draw a clear box. This will almost never 60 // happen. 61 // TODO we can handle some of these cases if we really want to, but the long term solution is to 62 // get the actual glyph image itself when we get the glyph metrics. 63 GrDrawOpAtlas::ErrorCode addGlyphToAtlas(GrResourceProvider*, GrDeferredUploadTarget*, 64 GrStrikeCache*, GrAtlasManager*, GrGlyph*, 65 SkStrike*, GrMaskFormat expectedMaskFormat, 66 bool isScaledGlyph); 67 68 // testing countGlyphs()69 int countGlyphs() const { return fCache.count(); } 70 71 // remove any references to this plot 72 void removeID(GrDrawOpAtlas::AtlasID); 73 74 // If a TextStrike is abandoned by the cache, then the caller must get a new strike isAbandoned()75 bool isAbandoned() const { return fIsAbandoned; } 76 GetKey(const GrTextStrike & strike)77 static const SkDescriptor& GetKey(const GrTextStrike& strike) { 78 return *strike.fFontScalerKey.getDesc(); 79 } 80 Hash(const SkDescriptor & desc)81 static uint32_t Hash(const SkDescriptor& desc) { return desc.getChecksum(); } 82 83 private: 84 SkTDynamicHash<GrGlyph, SkPackedGlyphID> fCache; 85 SkAutoDescriptor fFontScalerKey; 86 SkArenaAlloc fAlloc{512}; 87 88 int fAtlasedGlyphs{0}; 89 bool fIsAbandoned{false}; 90 GrToSkGlyph(SkStrike * cache,SkPackedGlyphID id)91 static const SkGlyph& GrToSkGlyph(SkStrike* cache, SkPackedGlyphID id) { 92 return cache->getGlyphIDMetrics(id.code(), id.getSubXFixed(), id.getSubYFixed()); 93 } 94 95 GrGlyph* generateGlyph(const SkGlyph&); 96 97 friend class GrStrikeCache; 98 }; 99 100 /** 101 * GrStrikeCache manages strikes which are indexed by a SkStrike. These strikes can then be 102 * used to generate individual Glyph Masks. 103 */ 104 class GrStrikeCache { 105 public: 106 GrStrikeCache(const GrCaps* caps, size_t maxTextureBytes); 107 ~GrStrikeCache(); 108 setStrikeToPreserve(GrTextStrike * strike)109 void setStrikeToPreserve(GrTextStrike* strike) { fPreserveStrike = strike; } 110 111 // The user of the cache may hold a long-lived ref to the returned strike. However, actions by 112 // another client of the cache may cause the strike to be purged while it is still reffed. 113 // Therefore, the caller must check GrTextStrike::isAbandoned() if there are other 114 // interactions with the cache since the strike was received. getStrike(const SkStrike * cache)115 sk_sp<GrTextStrike> getStrike(const SkStrike* cache) { 116 sk_sp<GrTextStrike> strike = sk_ref_sp(fCache.find(cache->getDescriptor())); 117 if (!strike) { 118 strike = this->generateStrike(cache); 119 } 120 return strike; 121 } 122 getMasks()123 const SkMasks& getMasks() const { return *f565Masks; } 124 125 void freeAll(); 126 127 static void HandleEviction(GrDrawOpAtlas::AtlasID, void*); 128 129 private: generateStrike(const SkStrike * cache)130 sk_sp<GrTextStrike> generateStrike(const SkStrike* cache) { 131 // 'fCache' get the construction ref 132 sk_sp<GrTextStrike> strike = sk_ref_sp(new GrTextStrike(cache->getDescriptor())); 133 fCache.add(strike.get()); 134 return strike; 135 } 136 137 using StrikeHash = SkTDynamicHash<GrTextStrike, SkDescriptor>; 138 139 StrikeHash fCache; 140 GrTextStrike* fPreserveStrike; 141 std::unique_ptr<const SkMasks> f565Masks; 142 }; 143 144 #endif // GrStrikeCache_DEFINED 145