qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 1 | /* |
| 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 | #include "SkMaskCache.h" |
| 9 | |
| 10 | #define CHECK_LOCAL(localCache, localName, globalName, ...) \ |
| 11 | ((localCache) ? localCache->localName(__VA_ARGS__) : SkResourceCache::globalName(__VA_ARGS__)) |
| 12 | |
| 13 | struct MaskValue { |
| 14 | SkMask fMask; |
| 15 | SkCachedData* fData; |
| 16 | }; |
| 17 | |
| 18 | namespace { |
| 19 | static unsigned gRRectBlurKeyNamespaceLabel; |
| 20 | |
| 21 | struct RRectBlurKey : public SkResourceCache::Key { |
| 22 | public: |
| 23 | RRectBlurKey(SkScalar sigma, const SkRRect& rrect, SkBlurStyle style, SkBlurQuality quality) |
| 24 | : fSigma(sigma) |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 25 | , fStyle(style) |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 26 | , fQuality(quality) |
| 27 | , fRRect(rrect) |
| 28 | { |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 29 | this->init(&gRRectBlurKeyNamespaceLabel, 0, |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 30 | sizeof(fSigma) + sizeof(fStyle) + sizeof(fQuality) + sizeof(fRRect)); |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 31 | } |
| 32 | |
| 33 | SkScalar fSigma; |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 34 | int32_t fStyle; |
| 35 | int32_t fQuality; |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 36 | SkRRect fRRect; |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 37 | }; |
| 38 | |
| 39 | struct RRectBlurRec : public SkResourceCache::Rec { |
| 40 | RRectBlurRec(RRectBlurKey key, const SkMask& mask, SkCachedData* data) |
| 41 | : fKey(key) |
| 42 | { |
| 43 | fValue.fMask = mask; |
| 44 | fValue.fData = data; |
| 45 | fValue.fData->attachToCacheAndRef(); |
| 46 | } |
Brian Salomon | d3b6597 | 2017-03-22 12:05:03 -0400 | [diff] [blame] | 47 | ~RRectBlurRec() override { |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 48 | fValue.fData->detachFromCacheAndUnref(); |
| 49 | } |
| 50 | |
| 51 | RRectBlurKey fKey; |
| 52 | MaskValue fValue; |
| 53 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 54 | const Key& getKey() const override { return fKey; } |
| 55 | size_t bytesUsed() const override { return sizeof(*this) + fValue.fData->size(); } |
reed | 216b643 | 2015-08-19 12:25:40 -0700 | [diff] [blame] | 56 | const char* getCategory() const override { return "rrect-blur"; } |
| 57 | SkDiscardableMemory* diagnostic_only_getDiscardable() const override { |
| 58 | return fValue.fData->diagnostic_only_getDiscardable(); |
| 59 | } |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 60 | |
| 61 | static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) { |
| 62 | const RRectBlurRec& rec = static_cast<const RRectBlurRec&>(baseRec); |
| 63 | MaskValue* result = (MaskValue*)contextData; |
| 64 | |
| 65 | SkCachedData* tmpData = rec.fValue.fData; |
| 66 | tmpData->ref(); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 67 | if (nullptr == tmpData->data()) { |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 68 | tmpData->unref(); |
| 69 | return false; |
| 70 | } |
| 71 | *result = rec.fValue; |
| 72 | return true; |
| 73 | } |
| 74 | }; |
| 75 | } // namespace |
| 76 | |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 77 | SkCachedData* SkMaskCache::FindAndRef(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality, |
| 78 | const SkRRect& rrect, SkMask* mask, SkResourceCache* localCache) { |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 79 | MaskValue result; |
| 80 | RRectBlurKey key(sigma, rrect, style, quality); |
| 81 | if (!CHECK_LOCAL(localCache, find, Find, key, RRectBlurRec::Visitor, &result)) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 82 | return nullptr; |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | *mask = result.fMask; |
| 86 | mask->fImage = (uint8_t*)(result.fData->data()); |
| 87 | return result.fData; |
| 88 | } |
| 89 | |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 90 | void SkMaskCache::Add(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality, |
| 91 | const SkRRect& rrect, const SkMask& mask, SkCachedData* data, |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 92 | SkResourceCache* localCache) { |
| 93 | RRectBlurKey key(sigma, rrect, style, quality); |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 94 | return CHECK_LOCAL(localCache, add, Add, new RRectBlurRec(key, mask, data)); |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | ////////////////////////////////////////////////////////////////////////////////////////// |
| 98 | |
| 99 | namespace { |
| 100 | static unsigned gRectsBlurKeyNamespaceLabel; |
| 101 | |
| 102 | struct RectsBlurKey : public SkResourceCache::Key { |
| 103 | public: |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 104 | RectsBlurKey(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality, |
| 105 | const SkRect rects[], int count) |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 106 | : fSigma(sigma) |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 107 | , fStyle(style) |
| 108 | , fQuality(quality) |
| 109 | { |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 110 | SkASSERT(1 == count || 2 == count); |
qiankun.miao | 69469b5 | 2014-12-05 11:16:25 -0800 | [diff] [blame] | 111 | SkIRect ir; |
| 112 | rects[0].roundOut(&ir); |
jvanverth | 73e81ab | 2016-05-06 09:33:55 -0700 | [diff] [blame] | 113 | fSizes[0] = SkSize::Make(rects[0].width(), rects[0].height()); |
qiankun.miao | 69469b5 | 2014-12-05 11:16:25 -0800 | [diff] [blame] | 114 | if (2 == count) { |
jvanverth | 73e81ab | 2016-05-06 09:33:55 -0700 | [diff] [blame] | 115 | fSizes[1] = SkSize::Make(rects[1].width(), rects[1].height()); |
qiankun.miao | 69469b5 | 2014-12-05 11:16:25 -0800 | [diff] [blame] | 116 | fSizes[2] = SkSize::Make(rects[0].x() - rects[1].x(), rects[0].y() - rects[1].y()); |
jvanverth | 73e81ab | 2016-05-06 09:33:55 -0700 | [diff] [blame] | 117 | } else { |
| 118 | fSizes[1] = SkSize::Make(0, 0); |
| 119 | fSizes[2] = SkSize::Make(0, 0); |
qiankun.miao | 69469b5 | 2014-12-05 11:16:25 -0800 | [diff] [blame] | 120 | } |
jvanverth | 73e81ab | 2016-05-06 09:33:55 -0700 | [diff] [blame] | 121 | fSizes[3] = SkSize::Make(rects[0].x() - ir.x(), rects[0].y() - ir.y()); |
qiankun.miao | 69469b5 | 2014-12-05 11:16:25 -0800 | [diff] [blame] | 122 | |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 123 | this->init(&gRectsBlurKeyNamespaceLabel, 0, |
qiankun.miao | 69469b5 | 2014-12-05 11:16:25 -0800 | [diff] [blame] | 124 | sizeof(fSigma) + sizeof(fStyle) + sizeof(fQuality) + sizeof(fSizes)); |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 125 | } |
| 126 | |
| 127 | SkScalar fSigma; |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 128 | int32_t fStyle; |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 129 | int32_t fQuality; |
qiankun.miao | 69469b5 | 2014-12-05 11:16:25 -0800 | [diff] [blame] | 130 | SkSize fSizes[4]; |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 131 | }; |
| 132 | |
| 133 | struct RectsBlurRec : public SkResourceCache::Rec { |
| 134 | RectsBlurRec(RectsBlurKey key, const SkMask& mask, SkCachedData* data) |
| 135 | : fKey(key) |
| 136 | { |
| 137 | fValue.fMask = mask; |
| 138 | fValue.fData = data; |
| 139 | fValue.fData->attachToCacheAndRef(); |
| 140 | } |
Brian Salomon | d3b6597 | 2017-03-22 12:05:03 -0400 | [diff] [blame] | 141 | ~RectsBlurRec() override { |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 142 | fValue.fData->detachFromCacheAndUnref(); |
| 143 | } |
| 144 | |
| 145 | RectsBlurKey fKey; |
| 146 | MaskValue fValue; |
| 147 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 148 | const Key& getKey() const override { return fKey; } |
| 149 | size_t bytesUsed() const override { return sizeof(*this) + fValue.fData->size(); } |
reed | 216b643 | 2015-08-19 12:25:40 -0700 | [diff] [blame] | 150 | const char* getCategory() const override { return "rects-blur"; } |
| 151 | SkDiscardableMemory* diagnostic_only_getDiscardable() const override { |
| 152 | return fValue.fData->diagnostic_only_getDiscardable(); |
| 153 | } |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 154 | |
| 155 | static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) { |
| 156 | const RectsBlurRec& rec = static_cast<const RectsBlurRec&>(baseRec); |
sugoi | 692135f | 2015-01-19 10:10:27 -0800 | [diff] [blame] | 157 | MaskValue* result = static_cast<MaskValue*>(contextData); |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 158 | |
| 159 | SkCachedData* tmpData = rec.fValue.fData; |
| 160 | tmpData->ref(); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 161 | if (nullptr == tmpData->data()) { |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 162 | tmpData->unref(); |
| 163 | return false; |
| 164 | } |
| 165 | *result = rec.fValue; |
| 166 | return true; |
| 167 | } |
| 168 | }; |
| 169 | } // namespace |
| 170 | |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 171 | SkCachedData* SkMaskCache::FindAndRef(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality, |
| 172 | const SkRect rects[], int count, SkMask* mask, |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 173 | SkResourceCache* localCache) { |
| 174 | MaskValue result; |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 175 | RectsBlurKey key(sigma, style, quality, rects, count); |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 176 | if (!CHECK_LOCAL(localCache, find, Find, key, RectsBlurRec::Visitor, &result)) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 177 | return nullptr; |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 178 | } |
| 179 | |
| 180 | *mask = result.fMask; |
| 181 | mask->fImage = (uint8_t*)(result.fData->data()); |
| 182 | return result.fData; |
| 183 | } |
| 184 | |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 185 | void SkMaskCache::Add(SkScalar sigma, SkBlurStyle style, SkBlurQuality quality, |
| 186 | const SkRect rects[], int count, const SkMask& mask, SkCachedData* data, |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 187 | SkResourceCache* localCache) { |
reed | 4dca7a8 | 2014-10-23 12:42:46 -0700 | [diff] [blame] | 188 | RectsBlurKey key(sigma, style, quality, rects, count); |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 189 | return CHECK_LOCAL(localCache, add, Add, new RectsBlurRec(key, mask, data)); |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 190 | } |