reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 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 | |
Brian Osman | bd65955 | 2018-09-11 10:03:19 -0400 | [diff] [blame] | 8 | #include "SkImage_Lazy.h" |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 9 | |
| 10 | #include "SkBitmap.h" |
| 11 | #include "SkBitmapCache.h" |
Brian Osman | b70fd91 | 2018-10-22 16:10:44 -0400 | [diff] [blame] | 12 | #include "SkCachedData.h" |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 13 | #include "SkData.h" |
| 14 | #include "SkImageGenerator.h" |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 15 | #include "SkImagePriv.h" |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 16 | #include "SkNextID.h" |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 17 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 18 | #if SK_SUPPORT_GPU |
| 19 | #include "GrContext.h" |
| 20 | #include "GrContextPriv.h" |
| 21 | #include "GrGpuResourcePriv.h" |
| 22 | #include "GrImageTextureMaker.h" |
| 23 | #include "GrResourceKey.h" |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 24 | #include "GrProxyProvider.h" |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 25 | #include "GrSamplerState.h" |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 26 | #include "GrYUVProvider.h" |
| 27 | #include "SkGr.h" |
| 28 | #endif |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 29 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 30 | // Ref-counted tuple(SkImageGenerator, SkMutex) which allows sharing one generator among N images |
Mike Klein | 408ef21 | 2018-10-30 15:23:00 +0000 | [diff] [blame] | 31 | class SharedGenerator final : public SkNVRefCnt<SharedGenerator> { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 32 | public: |
| 33 | static sk_sp<SharedGenerator> Make(std::unique_ptr<SkImageGenerator> gen) { |
| 34 | return gen ? sk_sp<SharedGenerator>(new SharedGenerator(std::move(gen))) : nullptr; |
| 35 | } |
| 36 | |
Matt Sarett | b2004f7 | 2017-05-18 09:26:50 -0400 | [diff] [blame] | 37 | // This is thread safe. It is a const field set in the constructor. |
| 38 | const SkImageInfo& getInfo() { return fGenerator->getInfo(); } |
| 39 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 40 | private: |
| 41 | explicit SharedGenerator(std::unique_ptr<SkImageGenerator> gen) |
| 42 | : fGenerator(std::move(gen)) { |
| 43 | SkASSERT(fGenerator); |
| 44 | } |
| 45 | |
| 46 | friend class ScopedGenerator; |
| 47 | friend class SkImage_Lazy; |
| 48 | |
| 49 | std::unique_ptr<SkImageGenerator> fGenerator; |
| 50 | SkMutex fMutex; |
| 51 | }; |
| 52 | |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 53 | /////////////////////////////////////////////////////////////////////////////// |
| 54 | |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 55 | SkImage_Lazy::Validator::Validator(sk_sp<SharedGenerator> gen, const SkIRect* subset, |
Brian Osman | f48c996 | 2019-01-14 11:15:50 -0500 | [diff] [blame] | 56 | const SkColorType* colorType, sk_sp<SkColorSpace> colorSpace) |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 57 | : fSharedGenerator(std::move(gen)) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 58 | if (!fSharedGenerator) { |
| 59 | return; |
| 60 | } |
| 61 | |
| 62 | // The following generator accessors are safe without acquiring the mutex (const getters). |
| 63 | // TODO: refactor to use a ScopedGenerator instead, for clarity. |
| 64 | const SkImageInfo& info = fSharedGenerator->fGenerator->getInfo(); |
| 65 | if (info.isEmpty()) { |
| 66 | fSharedGenerator.reset(); |
| 67 | return; |
| 68 | } |
| 69 | |
| 70 | fUniqueID = fSharedGenerator->fGenerator->uniqueID(); |
| 71 | const SkIRect bounds = SkIRect::MakeWH(info.width(), info.height()); |
| 72 | if (subset) { |
| 73 | if (!bounds.contains(*subset)) { |
| 74 | fSharedGenerator.reset(); |
| 75 | return; |
| 76 | } |
| 77 | if (*subset != bounds) { |
| 78 | // we need a different uniqueID since we really are a subset of the raw generator |
| 79 | fUniqueID = SkNextID::ImageID(); |
| 80 | } |
| 81 | } else { |
| 82 | subset = &bounds; |
| 83 | } |
| 84 | |
| 85 | fInfo = info.makeWH(subset->width(), subset->height()); |
| 86 | fOrigin = SkIPoint::Make(subset->x(), subset->y()); |
Brian Osman | f48c996 | 2019-01-14 11:15:50 -0500 | [diff] [blame] | 87 | if (colorType || colorSpace) { |
| 88 | if (colorType) { |
| 89 | fInfo = fInfo.makeColorType(*colorType); |
| 90 | } |
| 91 | if (colorSpace) { |
| 92 | fInfo = fInfo.makeColorSpace(colorSpace); |
| 93 | } |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 94 | fUniqueID = SkNextID::ImageID(); |
| 95 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 96 | } |
| 97 | |
| 98 | /////////////////////////////////////////////////////////////////////////////// |
| 99 | |
| 100 | // Helper for exclusive access to a shared generator. |
| 101 | class SkImage_Lazy::ScopedGenerator { |
| 102 | public: |
| 103 | ScopedGenerator(const sk_sp<SharedGenerator>& gen) |
| 104 | : fSharedGenerator(gen) |
| 105 | , fAutoAquire(gen->fMutex) {} |
| 106 | |
| 107 | SkImageGenerator* operator->() const { |
| 108 | fSharedGenerator->fMutex.assertHeld(); |
| 109 | return fSharedGenerator->fGenerator.get(); |
| 110 | } |
| 111 | |
| 112 | operator SkImageGenerator*() const { |
| 113 | fSharedGenerator->fMutex.assertHeld(); |
| 114 | return fSharedGenerator->fGenerator.get(); |
| 115 | } |
| 116 | |
| 117 | private: |
| 118 | const sk_sp<SharedGenerator>& fSharedGenerator; |
| 119 | SkAutoExclusive fAutoAquire; |
| 120 | }; |
| 121 | |
| 122 | /////////////////////////////////////////////////////////////////////////////// |
| 123 | |
| 124 | SkImage_Lazy::SkImage_Lazy(Validator* validator) |
| 125 | : INHERITED(validator->fInfo.width(), validator->fInfo.height(), validator->fUniqueID) |
| 126 | , fSharedGenerator(std::move(validator->fSharedGenerator)) |
| 127 | , fInfo(validator->fInfo) |
| 128 | , fOrigin(validator->fOrigin) { |
| 129 | SkASSERT(fSharedGenerator); |
Brian Osman | eb7e529 | 2018-08-08 14:32:06 -0400 | [diff] [blame] | 130 | fUniqueID = validator->fUniqueID; |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 131 | } |
| 132 | |
Brian Osman | bd65955 | 2018-09-11 10:03:19 -0400 | [diff] [blame] | 133 | SkImage_Lazy::~SkImage_Lazy() { |
| 134 | #if SK_SUPPORT_GPU |
| 135 | for (int i = 0; i < fUniqueKeyInvalidatedMessages.count(); ++i) { |
| 136 | SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(*fUniqueKeyInvalidatedMessages[i]); |
| 137 | } |
| 138 | fUniqueKeyInvalidatedMessages.deleteAll(); |
| 139 | #endif |
| 140 | } |
| 141 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 142 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 143 | |
Brian Osman | c87cfb6 | 2018-07-11 09:08:46 -0400 | [diff] [blame] | 144 | static bool generate_pixels(SkImageGenerator* gen, const SkPixmap& pmap, int originX, int originY) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 145 | const int genW = gen->getInfo().width(); |
| 146 | const int genH = gen->getInfo().height(); |
| 147 | const SkIRect srcR = SkIRect::MakeWH(genW, genH); |
| 148 | const SkIRect dstR = SkIRect::MakeXYWH(originX, originY, pmap.width(), pmap.height()); |
| 149 | if (!srcR.contains(dstR)) { |
| 150 | return false; |
| 151 | } |
| 152 | |
| 153 | // If they are requesting a subset, we have to have a temp allocation for full image, and |
| 154 | // then copy the subset into their allocation |
| 155 | SkBitmap full; |
| 156 | SkPixmap fullPM; |
| 157 | const SkPixmap* dstPM = &pmap; |
| 158 | if (srcR != dstR) { |
| 159 | if (!full.tryAllocPixels(pmap.info().makeWH(genW, genH))) { |
| 160 | return false; |
| 161 | } |
| 162 | if (!full.peekPixels(&fullPM)) { |
| 163 | return false; |
| 164 | } |
| 165 | dstPM = &fullPM; |
| 166 | } |
| 167 | |
Brian Osman | c87cfb6 | 2018-07-11 09:08:46 -0400 | [diff] [blame] | 168 | if (!gen->getPixels(dstPM->info(), dstPM->writable_addr(), dstPM->rowBytes())) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 169 | return false; |
| 170 | } |
| 171 | |
| 172 | if (srcR != dstR) { |
| 173 | if (!full.readPixels(pmap, originX, originY)) { |
| 174 | return false; |
| 175 | } |
| 176 | } |
| 177 | return true; |
| 178 | } |
| 179 | |
Brian Osman | 00766bf | 2018-10-22 15:59:23 -0400 | [diff] [blame] | 180 | bool SkImage_Lazy::getROPixels(SkBitmap* bitmap, SkImage::CachingHint chint) const { |
| 181 | auto check_output_bitmap = [bitmap]() { |
| 182 | SkASSERT(bitmap->isImmutable()); |
| 183 | SkASSERT(bitmap->getPixels()); |
| 184 | (void)bitmap; |
| 185 | }; |
| 186 | |
| 187 | auto desc = SkBitmapCacheDesc::Make(this); |
| 188 | if (SkBitmapCache::Find(desc, bitmap)) { |
| 189 | check_output_bitmap(); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 190 | return true; |
| 191 | } |
| 192 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 193 | if (SkImage::kAllow_CachingHint == chint) { |
Brian Osman | 00766bf | 2018-10-22 15:59:23 -0400 | [diff] [blame] | 194 | SkPixmap pmap; |
| 195 | SkBitmapCache::RecPtr cacheRec = SkBitmapCache::Alloc(desc, fInfo, &pmap); |
| 196 | if (!cacheRec || |
| 197 | !generate_pixels(ScopedGenerator(fSharedGenerator), pmap, |
| 198 | fOrigin.x(), fOrigin.y())) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 199 | return false; |
| 200 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 201 | SkBitmapCache::Add(std::move(cacheRec), bitmap); |
Mike Reed | 30301c4 | 2018-07-19 09:39:21 -0400 | [diff] [blame] | 202 | this->notifyAddedToRasterCache(); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 203 | } else { |
Brian Osman | 00766bf | 2018-10-22 15:59:23 -0400 | [diff] [blame] | 204 | if (!bitmap->tryAllocPixels(fInfo) || |
| 205 | !generate_pixels(ScopedGenerator(fSharedGenerator), bitmap->pixmap(), |
| 206 | fOrigin.x(), fOrigin.y())) { |
| 207 | return false; |
| 208 | } |
Brian Osman | a0dc3d2 | 2018-10-09 15:17:38 -0400 | [diff] [blame] | 209 | bitmap->setImmutable(); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 210 | } |
| 211 | |
Brian Osman | 00766bf | 2018-10-22 15:59:23 -0400 | [diff] [blame] | 212 | check_output_bitmap(); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 213 | return true; |
| 214 | } |
| 215 | |
| 216 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 217 | |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 218 | bool SkImage_Lazy::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB, |
| 219 | int srcX, int srcY, CachingHint chint) const { |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 220 | SkBitmap bm; |
Brian Osman | e50cdf0 | 2018-10-19 13:02:14 -0400 | [diff] [blame] | 221 | if (this->getROPixels(&bm, chint)) { |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 222 | return bm.readPixels(dstInfo, dstPixels, dstRB, srcX, srcY); |
| 223 | } |
| 224 | return false; |
| 225 | } |
| 226 | |
Ben Wagner | bdf5433 | 2018-05-15 14:12:14 -0400 | [diff] [blame] | 227 | sk_sp<SkData> SkImage_Lazy::onRefEncoded() const { |
| 228 | ScopedGenerator generator(fSharedGenerator); |
| 229 | return generator->refEncodedData(); |
| 230 | } |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 231 | |
Brian Osman | 5bbd076 | 2017-05-08 11:07:42 -0400 | [diff] [blame] | 232 | bool SkImage_Lazy::onIsValid(GrContext* context) const { |
| 233 | ScopedGenerator generator(fSharedGenerator); |
| 234 | return generator->isValid(context); |
| 235 | } |
| 236 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 237 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 238 | |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 239 | #if SK_SUPPORT_GPU |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 240 | sk_sp<GrTextureProxy> SkImage_Lazy::asTextureProxyRef(GrContext* context, |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 241 | const GrSamplerState& params, |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 242 | SkScalar scaleAdjust[2]) const { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 243 | if (!context) { |
| 244 | return nullptr; |
| 245 | } |
| 246 | |
| 247 | GrImageTextureMaker textureMaker(context, this, kAllow_CachingHint); |
Brian Osman | 6064e1c | 2018-10-19 14:27:54 -0400 | [diff] [blame] | 248 | return textureMaker.refTextureProxyForParams(params, scaleAdjust); |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 249 | } |
| 250 | #endif |
| 251 | |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 252 | sk_sp<SkImage> SkImage_Lazy::onMakeSubset(const SkIRect& subset) const { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 253 | SkASSERT(fInfo.bounds().contains(subset)); |
| 254 | SkASSERT(fInfo.bounds() != subset); |
reed | 7b6945b | 2015-09-24 00:50:58 -0700 | [diff] [blame] | 255 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 256 | const SkIRect generatorSubset = subset.makeOffset(fOrigin.x(), fOrigin.y()); |
Brian Osman | f48c996 | 2019-01-14 11:15:50 -0500 | [diff] [blame] | 257 | const SkColorType colorType = fInfo.colorType(); |
| 258 | Validator validator(fSharedGenerator, &generatorSubset, &colorType, fInfo.refColorSpace()); |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 259 | return validator ? sk_sp<SkImage>(new SkImage_Lazy(&validator)) : nullptr; |
reed | 7b6945b | 2015-09-24 00:50:58 -0700 | [diff] [blame] | 260 | } |
| 261 | |
Brian Osman | f48c996 | 2019-01-14 11:15:50 -0500 | [diff] [blame] | 262 | sk_sp<SkImage> SkImage_Lazy::onMakeColorTypeAndColorSpace(SkColorType targetCT, |
| 263 | sk_sp<SkColorSpace> targetCS) const { |
| 264 | SkAutoExclusive autoAquire(fOnMakeColorTypeAndSpaceMutex); |
| 265 | if (fOnMakeColorTypeAndSpaceResult && |
| 266 | targetCT == fOnMakeColorTypeAndSpaceResult->colorType() && |
| 267 | SkColorSpace::Equals(targetCS.get(), fOnMakeColorTypeAndSpaceResult->colorSpace())) { |
| 268 | return fOnMakeColorTypeAndSpaceResult; |
Christopher Cameron | d4b6787 | 2017-07-13 15:18:08 -0700 | [diff] [blame] | 269 | } |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 270 | const SkIRect generatorSubset = |
| 271 | SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height()); |
Brian Osman | f48c996 | 2019-01-14 11:15:50 -0500 | [diff] [blame] | 272 | Validator validator(fSharedGenerator, &generatorSubset, &targetCT, targetCS); |
Christopher Cameron | d4b6787 | 2017-07-13 15:18:08 -0700 | [diff] [blame] | 273 | sk_sp<SkImage> result = validator ? sk_sp<SkImage>(new SkImage_Lazy(&validator)) : nullptr; |
| 274 | if (result) { |
Brian Osman | f48c996 | 2019-01-14 11:15:50 -0500 | [diff] [blame] | 275 | fOnMakeColorTypeAndSpaceResult = result; |
Christopher Cameron | d4b6787 | 2017-07-13 15:18:08 -0700 | [diff] [blame] | 276 | } |
| 277 | return result; |
Matt Sarett | 6de1310 | 2017-03-14 14:10:48 -0400 | [diff] [blame] | 278 | } |
| 279 | |
Mike Reed | 185130c | 2017-02-15 15:14:16 -0500 | [diff] [blame] | 280 | sk_sp<SkImage> SkImage::MakeFromGenerator(std::unique_ptr<SkImageGenerator> generator, |
| 281 | const SkIRect* subset) { |
Brian Osman | f48c996 | 2019-01-14 11:15:50 -0500 | [diff] [blame] | 282 | SkImage_Lazy::Validator |
| 283 | validator(SharedGenerator::Make(std::move(generator)), subset, nullptr, nullptr); |
fmalita | 7929e3a | 2016-10-27 08:15:44 -0700 | [diff] [blame] | 284 | |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 285 | return validator ? sk_make_sp<SkImage_Lazy>(&validator) : nullptr; |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 286 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 287 | |
| 288 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 289 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 290 | #if SK_SUPPORT_GPU |
| 291 | |
Brian Osman | bd65955 | 2018-09-11 10:03:19 -0400 | [diff] [blame] | 292 | void SkImage_Lazy::makeCacheKeyFromOrigKey(const GrUniqueKey& origKey, |
| 293 | GrUniqueKey* cacheKey) const { |
Brian Osman | 10494e3 | 2018-09-10 12:45:18 -0400 | [diff] [blame] | 294 | SkASSERT(!cacheKey->isValid()); |
| 295 | if (origKey.isValid()) { |
| 296 | static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain(); |
| 297 | GrUniqueKey::Builder builder(cacheKey, origKey, kDomain, 0, "Image"); |
| 298 | } |
| 299 | } |
| 300 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 301 | class Generator_GrYUVProvider : public GrYUVProvider { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 302 | public: |
| 303 | Generator_GrYUVProvider(SkImageGenerator* gen) : fGen(gen) {} |
| 304 | |
Robert Phillips | b4a8eac | 2018-09-21 08:26:33 -0400 | [diff] [blame] | 305 | private: |
| 306 | uint32_t onGetID() const override { return fGen->uniqueID(); } |
Jim Van Verth | e24b587 | 2018-10-29 16:26:02 -0400 | [diff] [blame] | 307 | bool onQueryYUVA8(SkYUVASizeInfo* sizeInfo, |
Jim Van Verth | 8f11e43 | 2018-10-18 14:36:59 -0400 | [diff] [blame] | 308 | SkYUVAIndex yuvaIndices[SkYUVAIndex::kIndexCount], |
| 309 | SkYUVColorSpace* colorSpace) const override { |
| 310 | return fGen->queryYUVA8(sizeInfo, yuvaIndices, colorSpace); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 311 | } |
Jim Van Verth | e24b587 | 2018-10-29 16:26:02 -0400 | [diff] [blame] | 312 | bool onGetYUVA8Planes(const SkYUVASizeInfo& sizeInfo, |
Jim Van Verth | 8f11e43 | 2018-10-18 14:36:59 -0400 | [diff] [blame] | 313 | const SkYUVAIndex yuvaIndices[SkYUVAIndex::kIndexCount], |
| 314 | void* planes[]) override { |
| 315 | return fGen->getYUVA8Planes(sizeInfo, yuvaIndices, planes); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 316 | } |
Robert Phillips | b4a8eac | 2018-09-21 08:26:33 -0400 | [diff] [blame] | 317 | |
| 318 | SkImageGenerator* fGen; |
| 319 | |
| 320 | typedef GrYUVProvider INHERITED; |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 321 | }; |
| 322 | |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 323 | static void set_key_on_proxy(GrProxyProvider* proxyProvider, |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 324 | GrTextureProxy* proxy, GrTextureProxy* originalProxy, |
| 325 | const GrUniqueKey& key) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 326 | if (key.isValid()) { |
Greg Daniel | f6f7b67 | 2018-02-15 13:06:26 -0500 | [diff] [blame] | 327 | if (originalProxy && originalProxy->getUniqueKey().isValid()) { |
| 328 | SkASSERT(originalProxy->getUniqueKey() == key); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 329 | SkASSERT(GrMipMapped::kYes == proxy->mipMapped() && |
| 330 | GrMipMapped::kNo == originalProxy->mipMapped()); |
Greg Daniel | f6f7b67 | 2018-02-15 13:06:26 -0500 | [diff] [blame] | 331 | // If we had an originalProxy with a valid key, that means there already is a proxy in |
| 332 | // the cache which matches the key, but it does not have mip levels and we require them. |
| 333 | // Thus we must remove the unique key from that proxy. |
Chris Dalton | 2de13dd | 2019-01-03 15:11:59 -0700 | [diff] [blame] | 334 | SkASSERT(originalProxy->getUniqueKey() == key); |
| 335 | proxyProvider->removeUniqueKeyFromProxy(originalProxy); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 336 | } |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 337 | proxyProvider->assignUniqueKeyToProxy(key, proxy); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 338 | } |
| 339 | } |
| 340 | |
Jim Van Verth | e24b587 | 2018-10-29 16:26:02 -0400 | [diff] [blame] | 341 | sk_sp<SkCachedData> SkImage_Lazy::getPlanes(SkYUVASizeInfo* yuvaSizeInfo, |
Jim Van Verth | 8f11e43 | 2018-10-18 14:36:59 -0400 | [diff] [blame] | 342 | SkYUVAIndex yuvaIndices[SkYUVAIndex::kIndexCount], |
Robert Phillips | b4a8eac | 2018-09-21 08:26:33 -0400 | [diff] [blame] | 343 | SkYUVColorSpace* yuvColorSpace, |
Jim Van Verth | e24b587 | 2018-10-29 16:26:02 -0400 | [diff] [blame] | 344 | const void* planes[SkYUVASizeInfo::kMaxCount]) { |
Robert Phillips | b4a8eac | 2018-09-21 08:26:33 -0400 | [diff] [blame] | 345 | ScopedGenerator generator(fSharedGenerator); |
| 346 | Generator_GrYUVProvider provider(generator); |
| 347 | |
Jim Van Verth | 8f11e43 | 2018-10-18 14:36:59 -0400 | [diff] [blame] | 348 | sk_sp<SkCachedData> data = provider.getPlanes(yuvaSizeInfo, yuvaIndices, yuvColorSpace, planes); |
Robert Phillips | b4a8eac | 2018-09-21 08:26:33 -0400 | [diff] [blame] | 349 | if (!data) { |
| 350 | return nullptr; |
| 351 | } |
| 352 | |
| 353 | return data; |
| 354 | } |
| 355 | |
| 356 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 357 | /* |
| 358 | * We have 4 ways to try to return a texture (in sorted order) |
| 359 | * |
| 360 | * 1. Check the cache for a pre-existing one |
| 361 | * 2. Ask the generator to natively create one |
| 362 | * 3. Ask the generator to return YUV planes, which the GPU can convert |
| 363 | * 4. Ask the generator to return RGB(A) data, which the GPU can convert |
| 364 | */ |
Brian Osman | bd65955 | 2018-09-11 10:03:19 -0400 | [diff] [blame] | 365 | sk_sp<GrTextureProxy> SkImage_Lazy::lockTextureProxy( |
| 366 | GrContext* ctx, |
| 367 | const GrUniqueKey& origKey, |
| 368 | SkImage::CachingHint chint, |
| 369 | bool willBeMipped, |
Brian Osman | bd65955 | 2018-09-11 10:03:19 -0400 | [diff] [blame] | 370 | GrTextureMaker::AllowedTexGenType genType) const { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 371 | // Values representing the various texture lock paths we can take. Used for logging the path |
| 372 | // taken to a histogram. |
| 373 | enum LockTexturePath { |
| 374 | kFailure_LockTexturePath, |
| 375 | kPreExisting_LockTexturePath, |
| 376 | kNative_LockTexturePath, |
| 377 | kCompressed_LockTexturePath, // Deprecated |
| 378 | kYUV_LockTexturePath, |
| 379 | kRGBA_LockTexturePath, |
| 380 | }; |
| 381 | |
| 382 | enum { kLockTexturePathCount = kRGBA_LockTexturePath + 1 }; |
| 383 | |
Brian Osman | 10494e3 | 2018-09-10 12:45:18 -0400 | [diff] [blame] | 384 | // Build our texture key. |
Greg Daniel | 25ceb1c | 2018-09-27 17:01:41 -0400 | [diff] [blame] | 385 | // Even though some proxies created here may have a specific origin and use that origin, we do |
| 386 | // not include that in the key. Since SkImages are meant to be immutable, a given SkImage will |
| 387 | // always have an associated proxy that is always one origin or the other. It never can change |
| 388 | // origins. Thus we don't need to include that info in the key iteself. |
Brian Osman | 10494e3 | 2018-09-10 12:45:18 -0400 | [diff] [blame] | 389 | GrUniqueKey key; |
| 390 | this->makeCacheKeyFromOrigKey(origKey, &key); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 391 | |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 392 | GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider(); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 393 | sk_sp<GrTextureProxy> proxy; |
| 394 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 395 | // 1. Check the cache for a pre-existing one |
| 396 | if (key.isValid()) { |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 397 | proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, kTopLeft_GrSurfaceOrigin); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 398 | if (proxy) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 399 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kPreExisting_LockTexturePath, |
| 400 | kLockTexturePathCount); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 401 | if (!willBeMipped || GrMipMapped::kYes == proxy->mipMapped()) { |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 402 | return proxy; |
| 403 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 404 | } |
| 405 | } |
| 406 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 407 | // 2. Ask the generator to natively create one |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 408 | if (!proxy) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 409 | ScopedGenerator generator(fSharedGenerator); |
Stan Iliev | ba81af2 | 2017-06-08 15:16:53 -0400 | [diff] [blame] | 410 | if (GrTextureMaker::AllowedTexGenType::kCheap == genType && |
| 411 | SkImageGenerator::TexGenType::kCheap != generator->onCanGenerateTexture()) { |
| 412 | return nullptr; |
| 413 | } |
Brian Osman | b3f3830 | 2018-09-07 15:24:44 -0400 | [diff] [blame] | 414 | if ((proxy = generator->generateTexture(ctx, fInfo, fOrigin, willBeMipped))) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 415 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kNative_LockTexturePath, |
| 416 | kLockTexturePathCount); |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 417 | set_key_on_proxy(proxyProvider, proxy.get(), nullptr, key); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 418 | if (!willBeMipped || GrMipMapped::kYes == proxy->mipMapped()) { |
Greg Daniel | 2ad0820 | 2018-09-07 09:13:36 -0400 | [diff] [blame] | 419 | *fUniqueKeyInvalidatedMessages.append() = |
| 420 | new GrUniqueKeyInvalidatedMessage(key, ctx->uniqueID()); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 421 | return proxy; |
| 422 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 423 | } |
| 424 | } |
| 425 | |
Greg Daniel | 3e70fa3 | 2017-10-05 16:27:06 -0400 | [diff] [blame] | 426 | // 3. Ask the generator to return YUV planes, which the GPU can convert. If we will be mipping |
| 427 | // the texture we fall through here and have the CPU generate the mip maps for us. |
| 428 | if (!proxy && !willBeMipped && !ctx->contextPriv().disableGpuYUVConversion()) { |
Brian Osman | b3f3830 | 2018-09-07 15:24:44 -0400 | [diff] [blame] | 429 | const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(fInfo); |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 430 | |
| 431 | SkColorType colorType = fInfo.colorType(); |
| 432 | GrBackendFormat format = |
| 433 | ctx->contextPriv().caps()->getBackendFormatFromColorType(colorType); |
| 434 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 435 | ScopedGenerator generator(fSharedGenerator); |
| 436 | Generator_GrYUVProvider provider(generator); |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 437 | |
Brian Osman | f48c996 | 2019-01-14 11:15:50 -0500 | [diff] [blame] | 438 | // The pixels in the texture will be in the generator's color space. |
| 439 | // If onMakeColorTypeAndColorSpace has been called then this will not match this image's |
| 440 | // color space. To correct this, apply a color space conversion from the generator's color |
| 441 | // space to this image's color space. |
Brian Osman | 861ea5b | 2018-06-14 09:14:03 -0400 | [diff] [blame] | 442 | SkColorSpace* generatorColorSpace = fSharedGenerator->fGenerator->getInfo().colorSpace(); |
| 443 | SkColorSpace* thisColorSpace = fInfo.colorSpace(); |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 444 | |
Mike Klein | ae5e864 | 2018-10-03 17:00:41 -0400 | [diff] [blame] | 445 | // TODO: Update to create the mipped surface in the YUV generator and draw the base |
| 446 | // layer directly into the mipped surface. |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 447 | proxy = provider.refAsTextureProxy(ctx, format, desc, generatorColorSpace, thisColorSpace); |
Mike Klein | ae5e864 | 2018-10-03 17:00:41 -0400 | [diff] [blame] | 448 | if (proxy) { |
| 449 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kYUV_LockTexturePath, |
| 450 | kLockTexturePathCount); |
| 451 | set_key_on_proxy(proxyProvider, proxy.get(), nullptr, key); |
| 452 | *fUniqueKeyInvalidatedMessages.append() = |
| 453 | new GrUniqueKeyInvalidatedMessage(key, ctx->uniqueID()); |
| 454 | return proxy; |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 455 | } |
| 456 | } |
| 457 | |
| 458 | // 4. Ask the generator to return RGB(A) data, which the GPU can convert |
| 459 | SkBitmap bitmap; |
Brian Osman | 00766bf | 2018-10-22 15:59:23 -0400 | [diff] [blame] | 460 | if (!proxy && this->getROPixels(&bitmap, chint)) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 461 | if (willBeMipped) { |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 462 | proxy = proxyProvider->createMipMapProxyFromBitmap(bitmap); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 463 | } |
| 464 | if (!proxy) { |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 465 | proxy = GrUploadBitmapToTextureProxy(proxyProvider, bitmap); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 466 | } |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 467 | if (proxy && (!willBeMipped || GrMipMapped::kYes == proxy->mipMapped())) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 468 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kRGBA_LockTexturePath, |
| 469 | kLockTexturePathCount); |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 470 | set_key_on_proxy(proxyProvider, proxy.get(), nullptr, key); |
Greg Daniel | 2ad0820 | 2018-09-07 09:13:36 -0400 | [diff] [blame] | 471 | *fUniqueKeyInvalidatedMessages.append() = |
| 472 | new GrUniqueKeyInvalidatedMessage(key, ctx->uniqueID()); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 473 | return proxy; |
| 474 | } |
| 475 | } |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 476 | |
| 477 | if (proxy) { |
| 478 | // We need a mipped proxy, but we either found a proxy earlier that wasn't mipped, generated |
| 479 | // a native non mipped proxy, or generated a non-mipped yuv proxy. Thus we generate a new |
| 480 | // mipped surface and copy the original proxy into the base layer. We will then let the gpu |
| 481 | // generate the rest of the mips. |
| 482 | SkASSERT(willBeMipped); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 483 | SkASSERT(GrMipMapped::kNo == proxy->mipMapped()); |
Greg Daniel | 2ad0820 | 2018-09-07 09:13:36 -0400 | [diff] [blame] | 484 | *fUniqueKeyInvalidatedMessages.append() = |
| 485 | new GrUniqueKeyInvalidatedMessage(key, ctx->uniqueID()); |
Greg Daniel | e1da1d9 | 2017-10-06 15:59:27 -0400 | [diff] [blame] | 486 | if (auto mippedProxy = GrCopyBaseMipMapToTextureProxy(ctx, proxy.get())) { |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 487 | set_key_on_proxy(proxyProvider, mippedProxy.get(), proxy.get(), key); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 488 | return mippedProxy; |
| 489 | } |
Greg Daniel | 8f5bbda | 2018-06-08 17:22:23 -0400 | [diff] [blame] | 490 | // We failed to make a mipped proxy with the base copied into it. This could have |
| 491 | // been from failure to make the proxy or failure to do the copy. Thus we will fall |
| 492 | // back to just using the non mipped proxy; See skbug.com/7094. |
| 493 | return proxy; |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 494 | } |
| 495 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 496 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kFailure_LockTexturePath, |
| 497 | kLockTexturePathCount); |
| 498 | return nullptr; |
| 499 | } |
| 500 | |
| 501 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 502 | |
| 503 | #endif |