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 | |
| 8 | #include "SkImage_Base.h" |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 9 | #include "SkImageCacherator.h" |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 10 | |
| 11 | #include "SkBitmap.h" |
| 12 | #include "SkBitmapCache.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 | #include "SkPixelRef.h" |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 18 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 19 | #if SK_SUPPORT_GPU |
| 20 | #include "GrContext.h" |
| 21 | #include "GrContextPriv.h" |
| 22 | #include "GrGpuResourcePriv.h" |
| 23 | #include "GrImageTextureMaker.h" |
| 24 | #include "GrResourceKey.h" |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 25 | #include "GrProxyProvider.h" |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 26 | #include "GrSamplerState.h" |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 27 | #include "GrYUVProvider.h" |
| 28 | #include "SkGr.h" |
| 29 | #endif |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 30 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 31 | // Ref-counted tuple(SkImageGenerator, SkMutex) which allows sharing one generator among N images |
| 32 | class SharedGenerator final : public SkNVRefCnt<SharedGenerator> { |
| 33 | public: |
| 34 | static sk_sp<SharedGenerator> Make(std::unique_ptr<SkImageGenerator> gen) { |
| 35 | return gen ? sk_sp<SharedGenerator>(new SharedGenerator(std::move(gen))) : nullptr; |
| 36 | } |
| 37 | |
Matt Sarett | b2004f7 | 2017-05-18 09:26:50 -0400 | [diff] [blame] | 38 | // This is thread safe. It is a const field set in the constructor. |
| 39 | const SkImageInfo& getInfo() { return fGenerator->getInfo(); } |
| 40 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 41 | private: |
| 42 | explicit SharedGenerator(std::unique_ptr<SkImageGenerator> gen) |
| 43 | : fGenerator(std::move(gen)) { |
| 44 | SkASSERT(fGenerator); |
| 45 | } |
| 46 | |
| 47 | friend class ScopedGenerator; |
| 48 | friend class SkImage_Lazy; |
| 49 | |
| 50 | std::unique_ptr<SkImageGenerator> fGenerator; |
| 51 | SkMutex fMutex; |
| 52 | }; |
| 53 | |
| 54 | class SkImage_Lazy : public SkImage_Base, public SkImageCacherator { |
| 55 | public: |
| 56 | struct Validator { |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 57 | Validator(sk_sp<SharedGenerator>, const SkIRect* subset, sk_sp<SkColorSpace> colorSpace); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 58 | |
| 59 | operator bool() const { return fSharedGenerator.get(); } |
| 60 | |
| 61 | sk_sp<SharedGenerator> fSharedGenerator; |
| 62 | SkImageInfo fInfo; |
| 63 | SkIPoint fOrigin; |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 64 | sk_sp<SkColorSpace> fColorSpace; |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 65 | uint32_t fUniqueID; |
| 66 | }; |
| 67 | |
| 68 | SkImage_Lazy(Validator* validator); |
| 69 | |
| 70 | SkImageInfo onImageInfo() const override { |
| 71 | return fInfo; |
herb | a7c9d63 | 2016-04-19 12:30:22 -0700 | [diff] [blame] | 72 | } |
Greg Daniel | 56008aa | 2018-03-14 15:33:42 -0400 | [diff] [blame] | 73 | SkColorType onColorType() const override { |
| 74 | return kUnknown_SkColorType; |
| 75 | } |
brianosman | 69c166d | 2016-08-17 14:01:05 -0700 | [diff] [blame] | 76 | SkAlphaType onAlphaType() const override { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 77 | return fInfo.alphaType(); |
brianosman | 69c166d | 2016-08-17 14:01:05 -0700 | [diff] [blame] | 78 | } |
herb | a7c9d63 | 2016-04-19 12:30:22 -0700 | [diff] [blame] | 79 | |
Mike Reed | f2c7364 | 2018-05-29 15:41:27 -0400 | [diff] [blame] | 80 | SkIRect onGetSubset() const override { |
| 81 | return SkIRect::MakeXYWH(fOrigin.fX, fOrigin.fY, fInfo.width(), fInfo.height()); |
| 82 | } |
| 83 | |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 84 | bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY, |
| 85 | CachingHint) const override; |
| 86 | #if SK_SUPPORT_GPU |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 87 | sk_sp<GrTextureProxy> asTextureProxyRef(GrContext*, |
| 88 | const GrSamplerState&, SkColorSpace*, |
| 89 | sk_sp<SkColorSpace>*, |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 90 | SkScalar scaleAdjust[2]) const override; |
| 91 | #endif |
Ben Wagner | bdf5433 | 2018-05-15 14:12:14 -0400 | [diff] [blame] | 92 | sk_sp<SkData> onRefEncoded() const override; |
reed | 7fb4f8b | 2016-03-11 04:33:52 -0800 | [diff] [blame] | 93 | sk_sp<SkImage> onMakeSubset(const SkIRect&) const override; |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame] | 94 | bool getROPixels(SkBitmap*, SkColorSpace* dstColorSpace, CachingHint) const override; |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 95 | bool onIsLazyGenerated() const override { return true; } |
Mike Reed | 7f1d020 | 2017-05-08 16:13:39 -0400 | [diff] [blame] | 96 | bool onCanLazyGenerateOnGPU() const override; |
Matt Sarett | 9f3dcb3 | 2017-05-04 08:53:32 -0400 | [diff] [blame] | 97 | sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>, SkColorType, |
| 98 | SkTransferFunctionBehavior) const override; |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 99 | |
Brian Osman | 5bbd076 | 2017-05-08 11:07:42 -0400 | [diff] [blame] | 100 | bool onIsValid(GrContext*) const override; |
| 101 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 102 | SkImageCacherator* peekCacherator() const override { |
| 103 | return const_cast<SkImage_Lazy*>(this); |
| 104 | } |
| 105 | |
| 106 | // Only return true if the generate has already been cached. |
| 107 | bool lockAsBitmapOnlyIfAlreadyCached(SkBitmap*, CachedFormat) const; |
| 108 | // Call the underlying generator directly |
| 109 | bool directGeneratePixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB, |
| 110 | int srcX, int srcY, SkTransferFunctionBehavior behavior) const; |
| 111 | |
| 112 | // SkImageCacherator interface |
| 113 | #if SK_SUPPORT_GPU |
| 114 | // Returns the texture proxy. If the cacherator is generating the texture and wants to cache it, |
| 115 | // it should use the passed in key (if the key is valid). |
| 116 | sk_sp<GrTextureProxy> lockTextureProxy(GrContext*, |
| 117 | const GrUniqueKey& key, |
| 118 | SkImage::CachingHint, |
| 119 | bool willBeMipped, |
Stan Iliev | ba81af2 | 2017-06-08 15:16:53 -0400 | [diff] [blame] | 120 | SkColorSpace* dstColorSpace, |
| 121 | GrTextureMaker::AllowedTexGenType genType) override; |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 122 | |
| 123 | // Returns the color space of the texture that would be returned if you called lockTexture. |
| 124 | // Separate code path to allow querying of the color space for textures that cached (even |
| 125 | // externally). |
| 126 | sk_sp<SkColorSpace> getColorSpace(GrContext*, SkColorSpace* dstColorSpace) override; |
| 127 | void makeCacheKeyFromOrigKey(const GrUniqueKey& origKey, CachedFormat, |
| 128 | GrUniqueKey* cacheKey) override; |
| 129 | #endif |
| 130 | |
| 131 | CachedFormat chooseCacheFormat(SkColorSpace* dstColorSpace, |
| 132 | const GrCaps* = nullptr) const override; |
| 133 | SkImageInfo buildCacheInfo(CachedFormat) const override; |
| 134 | |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 135 | private: |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 136 | class ScopedGenerator; |
| 137 | |
| 138 | /** |
| 139 | * On success (true), bitmap will point to the pixels for this generator. If this returns |
| 140 | * false, the bitmap will be reset to empty. |
| 141 | */ |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 142 | bool lockAsBitmap(SkBitmap*, SkImage::CachingHint, CachedFormat, const SkImageInfo&, |
| 143 | SkTransferFunctionBehavior) const; |
| 144 | |
| 145 | /** |
| 146 | * Populates parameters to pass to the generator for reading pixels or generating a texture. |
| 147 | * For image generators, legacy versus true color blending is indicated using a |
| 148 | * SkTransferFunctionBehavior, and the target color space is specified on the SkImageInfo. |
| 149 | * If generatorImageInfo has no color space set, set its color space to this SkImage's color |
| 150 | * space, and return "ignore" behavior, indicating legacy mode. If generatorImageInfo has a |
| 151 | * color space set, return "respect" behavior, indicating linear blending mode. |
| 152 | */ |
| 153 | SkTransferFunctionBehavior getGeneratorBehaviorAndInfo(SkImageInfo* generatorImageInfo) const; |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 154 | |
| 155 | sk_sp<SharedGenerator> fSharedGenerator; |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 156 | // Note that fInfo is not necessarily the info from the generator. It may be cropped by |
| 157 | // onMakeSubset and its color space may be changed by onMakeColorSpace. |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 158 | const SkImageInfo fInfo; |
| 159 | const SkIPoint fOrigin; |
| 160 | |
| 161 | struct IDRec { |
| 162 | SkOnce fOnce; |
| 163 | uint32_t fUniqueID; |
| 164 | }; |
| 165 | mutable IDRec fIDRecs[kNumCachedFormats]; |
| 166 | |
| 167 | uint32_t getUniqueID(CachedFormat) const; |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 168 | |
Christopher Cameron | d4b6787 | 2017-07-13 15:18:08 -0700 | [diff] [blame] | 169 | // Repeated calls to onMakeColorSpace will result in a proliferation of unique IDs and |
| 170 | // SkImage_Lazy instances. Cache the result of the last successful onMakeColorSpace call. |
| 171 | mutable SkMutex fOnMakeColorSpaceMutex; |
| 172 | mutable sk_sp<SkColorSpace> fOnMakeColorSpaceTarget; |
| 173 | mutable sk_sp<SkImage> fOnMakeColorSpaceResult; |
| 174 | |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 175 | typedef SkImage_Base INHERITED; |
| 176 | }; |
| 177 | |
| 178 | /////////////////////////////////////////////////////////////////////////////// |
| 179 | |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 180 | SkImage_Lazy::Validator::Validator(sk_sp<SharedGenerator> gen, const SkIRect* subset, |
| 181 | sk_sp<SkColorSpace> colorSpace) |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 182 | : fSharedGenerator(std::move(gen)) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 183 | if (!fSharedGenerator) { |
| 184 | return; |
| 185 | } |
| 186 | |
| 187 | // The following generator accessors are safe without acquiring the mutex (const getters). |
| 188 | // TODO: refactor to use a ScopedGenerator instead, for clarity. |
| 189 | const SkImageInfo& info = fSharedGenerator->fGenerator->getInfo(); |
| 190 | if (info.isEmpty()) { |
| 191 | fSharedGenerator.reset(); |
| 192 | return; |
| 193 | } |
| 194 | |
| 195 | fUniqueID = fSharedGenerator->fGenerator->uniqueID(); |
| 196 | const SkIRect bounds = SkIRect::MakeWH(info.width(), info.height()); |
| 197 | if (subset) { |
| 198 | if (!bounds.contains(*subset)) { |
| 199 | fSharedGenerator.reset(); |
| 200 | return; |
| 201 | } |
| 202 | if (*subset != bounds) { |
| 203 | // we need a different uniqueID since we really are a subset of the raw generator |
| 204 | fUniqueID = SkNextID::ImageID(); |
| 205 | } |
| 206 | } else { |
| 207 | subset = &bounds; |
| 208 | } |
| 209 | |
| 210 | fInfo = info.makeWH(subset->width(), subset->height()); |
| 211 | fOrigin = SkIPoint::Make(subset->x(), subset->y()); |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 212 | if (colorSpace) { |
| 213 | fInfo = fInfo.makeColorSpace(colorSpace); |
| 214 | fUniqueID = SkNextID::ImageID(); |
| 215 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | /////////////////////////////////////////////////////////////////////////////// |
| 219 | |
| 220 | // Helper for exclusive access to a shared generator. |
| 221 | class SkImage_Lazy::ScopedGenerator { |
| 222 | public: |
| 223 | ScopedGenerator(const sk_sp<SharedGenerator>& gen) |
| 224 | : fSharedGenerator(gen) |
| 225 | , fAutoAquire(gen->fMutex) {} |
| 226 | |
| 227 | SkImageGenerator* operator->() const { |
| 228 | fSharedGenerator->fMutex.assertHeld(); |
| 229 | return fSharedGenerator->fGenerator.get(); |
| 230 | } |
| 231 | |
| 232 | operator SkImageGenerator*() const { |
| 233 | fSharedGenerator->fMutex.assertHeld(); |
| 234 | return fSharedGenerator->fGenerator.get(); |
| 235 | } |
| 236 | |
| 237 | private: |
| 238 | const sk_sp<SharedGenerator>& fSharedGenerator; |
| 239 | SkAutoExclusive fAutoAquire; |
| 240 | }; |
| 241 | |
| 242 | /////////////////////////////////////////////////////////////////////////////// |
| 243 | |
| 244 | SkImage_Lazy::SkImage_Lazy(Validator* validator) |
| 245 | : INHERITED(validator->fInfo.width(), validator->fInfo.height(), validator->fUniqueID) |
| 246 | , fSharedGenerator(std::move(validator->fSharedGenerator)) |
| 247 | , fInfo(validator->fInfo) |
| 248 | , fOrigin(validator->fOrigin) { |
| 249 | SkASSERT(fSharedGenerator); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 250 | // We explicit set the legacy format slot, but leave the others uninitialized (via SkOnce) |
| 251 | // and only resolove them to IDs as needed (by calling getUniqueID()). |
| 252 | fIDRecs[kLegacy_CachedFormat].fOnce([this, validator] { |
| 253 | fIDRecs[kLegacy_CachedFormat].fUniqueID = validator->fUniqueID; |
| 254 | }); |
| 255 | } |
| 256 | |
| 257 | uint32_t SkImage_Lazy::getUniqueID(CachedFormat format) const { |
| 258 | IDRec* rec = &fIDRecs[format]; |
| 259 | rec->fOnce([rec] { |
| 260 | rec->fUniqueID = SkNextID::ImageID(); |
| 261 | }); |
| 262 | return rec->fUniqueID; |
| 263 | } |
| 264 | |
| 265 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 266 | |
| 267 | // Abstraction of GrCaps that handles the cases where we don't have a caps pointer (because |
| 268 | // we're in raster mode), or where GPU support is entirely missing. In theory, we only need the |
| 269 | // chosen format to be texturable, but that lets us choose F16 on GLES implemenations where we |
| 270 | // won't be able to read the texture back. We'd like to ensure that SkImake::makeNonTextureImage |
| 271 | // works, so we require that the formats we choose are renderable (as a proxy for being readable). |
| 272 | struct CacheCaps { |
| 273 | CacheCaps(const GrCaps* caps) : fCaps(caps) {} |
| 274 | |
| 275 | #if SK_SUPPORT_GPU |
| 276 | bool supportsHalfFloat() const { |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 277 | return !fCaps || (fCaps->isConfigTexturable(kRGBA_half_GrPixelConfig) && |
| 278 | fCaps->isConfigRenderable(kRGBA_half_GrPixelConfig)); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | bool supportsSRGB() const { |
| 282 | return !fCaps || |
| 283 | (fCaps->srgbSupport() && fCaps->isConfigTexturable(kSRGBA_8888_GrPixelConfig)); |
| 284 | } |
| 285 | |
| 286 | bool supportsSBGR() const { |
| 287 | return !fCaps || fCaps->srgbSupport(); |
| 288 | } |
| 289 | #else |
| 290 | bool supportsHalfFloat() const { return true; } |
| 291 | bool supportsSRGB() const { return true; } |
| 292 | bool supportsSBGR() const { return true; } |
| 293 | #endif |
| 294 | |
| 295 | const GrCaps* fCaps; |
| 296 | }; |
| 297 | |
| 298 | SkImageCacherator::CachedFormat SkImage_Lazy::chooseCacheFormat(SkColorSpace* dstColorSpace, |
| 299 | const GrCaps* grCaps) const { |
| 300 | SkColorSpace* cs = fInfo.colorSpace(); |
| 301 | if (!cs || !dstColorSpace) { |
| 302 | return kLegacy_CachedFormat; |
| 303 | } |
| 304 | |
| 305 | CacheCaps caps(grCaps); |
| 306 | switch (fInfo.colorType()) { |
| 307 | case kUnknown_SkColorType: |
| 308 | case kAlpha_8_SkColorType: |
| 309 | case kRGB_565_SkColorType: |
| 310 | case kARGB_4444_SkColorType: |
Brian Salomon | e41e176 | 2018-01-25 14:07:47 -0500 | [diff] [blame] | 311 | case kRGB_888x_SkColorType: |
| 312 | case kRGBA_1010102_SkColorType: |
| 313 | case kRGB_101010x_SkColorType: |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 314 | // We don't support color space on these formats, so always decode in legacy mode: |
| 315 | // TODO: Ask the codec to decode these to something else (at least sRGB 8888)? |
| 316 | return kLegacy_CachedFormat; |
| 317 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 318 | case kGray_8_SkColorType: |
| 319 | // TODO: What do we do with grayscale sources that have strange color spaces attached? |
| 320 | // The codecs and color space xform don't handle this correctly (yet), so drop it on |
| 321 | // the floor. (Also, inflating by a factor of 8 is going to be unfortunate). |
| 322 | // As it is, we don't directly support sRGB grayscale, so ask the codec to convert |
| 323 | // it for us. This bypasses some really sketchy code GrUploadPixmapToTexture. |
| 324 | if (cs->gammaCloseToSRGB() && caps.supportsSRGB()) { |
| 325 | return kSRGB8888_CachedFormat; |
| 326 | } else { |
| 327 | return kLegacy_CachedFormat; |
| 328 | } |
| 329 | |
| 330 | case kRGBA_8888_SkColorType: |
| 331 | if (cs->gammaCloseToSRGB()) { |
| 332 | if (caps.supportsSRGB()) { |
| 333 | return kSRGB8888_CachedFormat; |
| 334 | } else if (caps.supportsHalfFloat()) { |
| 335 | return kLinearF16_CachedFormat; |
| 336 | } else { |
| 337 | return kLegacy_CachedFormat; |
| 338 | } |
| 339 | } else { |
| 340 | if (caps.supportsHalfFloat()) { |
| 341 | return kLinearF16_CachedFormat; |
| 342 | } else if (caps.supportsSRGB()) { |
| 343 | return kSRGB8888_CachedFormat; |
| 344 | } else { |
| 345 | return kLegacy_CachedFormat; |
| 346 | } |
| 347 | } |
| 348 | |
| 349 | case kBGRA_8888_SkColorType: |
| 350 | // Odd case. sBGRA isn't a real thing, so we may not have this texturable. |
| 351 | if (caps.supportsSBGR()) { |
| 352 | if (cs->gammaCloseToSRGB()) { |
| 353 | return kSBGR8888_CachedFormat; |
| 354 | } else if (caps.supportsHalfFloat()) { |
| 355 | return kLinearF16_CachedFormat; |
| 356 | } else if (caps.supportsSRGB()) { |
| 357 | return kSRGB8888_CachedFormat; |
| 358 | } else { |
| 359 | // sBGRA support without sRGBA is highly unlikely (impossible?) Nevertheless. |
| 360 | return kLegacy_CachedFormat; |
| 361 | } |
| 362 | } else { |
| 363 | if (cs->gammaCloseToSRGB()) { |
| 364 | if (caps.supportsSRGB()) { |
| 365 | return kSRGB8888_CachedFormat; |
| 366 | } else if (caps.supportsHalfFloat()) { |
| 367 | return kLinearF16_CachedFormat; |
| 368 | } else { |
| 369 | return kLegacy_CachedFormat; |
| 370 | } |
| 371 | } else { |
| 372 | if (caps.supportsHalfFloat()) { |
| 373 | return kLinearF16_CachedFormat; |
| 374 | } else if (caps.supportsSRGB()) { |
| 375 | return kSRGB8888_CachedFormat; |
| 376 | } else { |
| 377 | return kLegacy_CachedFormat; |
| 378 | } |
| 379 | } |
| 380 | } |
| 381 | |
| 382 | case kRGBA_F16_SkColorType: |
| 383 | if (caps.supportsHalfFloat()) { |
| 384 | return kLinearF16_CachedFormat; |
| 385 | } else if (caps.supportsSRGB()) { |
| 386 | return kSRGB8888_CachedFormat; |
| 387 | } else { |
| 388 | return kLegacy_CachedFormat; |
| 389 | } |
| 390 | } |
| 391 | SkDEBUGFAIL("Unreachable"); |
| 392 | return kLegacy_CachedFormat; |
| 393 | } |
| 394 | |
| 395 | SkImageInfo SkImage_Lazy::buildCacheInfo(CachedFormat format) const { |
| 396 | switch (format) { |
| 397 | case kLegacy_CachedFormat: |
| 398 | return fInfo.makeColorSpace(nullptr); |
| 399 | case kLinearF16_CachedFormat: |
| 400 | return fInfo.makeColorType(kRGBA_F16_SkColorType) |
Brian Osman | 36703d9 | 2017-12-12 14:09:31 -0500 | [diff] [blame] | 401 | .makeColorSpace(fInfo.colorSpace()->makeLinearGamma()); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 402 | case kSRGB8888_CachedFormat: |
| 403 | // If the transfer function is nearly (but not exactly) sRGB, we don't want the codec |
| 404 | // to bother trans-coding. It would be slow, and do more harm than good visually, |
| 405 | // so we make sure to leave the colorspace as-is. |
| 406 | if (fInfo.colorSpace()->gammaCloseToSRGB()) { |
| 407 | return fInfo.makeColorType(kRGBA_8888_SkColorType); |
| 408 | } else { |
| 409 | return fInfo.makeColorType(kRGBA_8888_SkColorType) |
Brian Osman | 36703d9 | 2017-12-12 14:09:31 -0500 | [diff] [blame] | 410 | .makeColorSpace(fInfo.colorSpace()->makeSRGBGamma()); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 411 | } |
| 412 | case kSBGR8888_CachedFormat: |
| 413 | // See note above about not-quite-sRGB transfer functions. |
| 414 | if (fInfo.colorSpace()->gammaCloseToSRGB()) { |
| 415 | return fInfo.makeColorType(kBGRA_8888_SkColorType); |
| 416 | } else { |
| 417 | return fInfo.makeColorType(kBGRA_8888_SkColorType) |
Brian Osman | 36703d9 | 2017-12-12 14:09:31 -0500 | [diff] [blame] | 418 | .makeColorSpace(fInfo.colorSpace()->makeSRGBGamma()); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 419 | } |
| 420 | default: |
| 421 | SkDEBUGFAIL("Invalid cached format"); |
| 422 | return fInfo; |
| 423 | } |
| 424 | } |
| 425 | |
| 426 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 427 | |
| 428 | static bool check_output_bitmap(const SkBitmap& bitmap, uint32_t expectedID) { |
| 429 | SkASSERT(bitmap.getGenerationID() == expectedID); |
| 430 | SkASSERT(bitmap.isImmutable()); |
| 431 | SkASSERT(bitmap.getPixels()); |
| 432 | return true; |
| 433 | } |
| 434 | |
| 435 | bool SkImage_Lazy::directGeneratePixels(const SkImageInfo& info, void* pixels, size_t rb, |
| 436 | int srcX, int srcY, |
| 437 | SkTransferFunctionBehavior behavior) const { |
| 438 | ScopedGenerator generator(fSharedGenerator); |
| 439 | const SkImageInfo& genInfo = generator->getInfo(); |
| 440 | // Currently generators do not natively handle subsets, so check that first. |
| 441 | if (srcX || srcY || genInfo.width() != info.width() || genInfo.height() != info.height()) { |
| 442 | return false; |
| 443 | } |
| 444 | |
| 445 | SkImageGenerator::Options opts; |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 446 | // TODO: This should respect the behavior argument. |
| 447 | opts.fBehavior = SkTransferFunctionBehavior::kIgnore; |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 448 | return generator->getPixels(info, pixels, rb, &opts); |
| 449 | } |
| 450 | |
| 451 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 452 | |
| 453 | bool SkImage_Lazy::lockAsBitmapOnlyIfAlreadyCached(SkBitmap* bitmap, CachedFormat format) const { |
| 454 | uint32_t uniqueID = this->getUniqueID(format); |
| 455 | return SkBitmapCache::Find(SkBitmapCacheDesc::Make(uniqueID, |
| 456 | fInfo.width(), fInfo.height()), bitmap) && |
| 457 | check_output_bitmap(*bitmap, uniqueID); |
| 458 | } |
| 459 | |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 460 | static bool generate_pixels(SkImageGenerator* gen, const SkPixmap& pmap, int originX, int originY, |
| 461 | SkTransferFunctionBehavior behavior) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 462 | const int genW = gen->getInfo().width(); |
| 463 | const int genH = gen->getInfo().height(); |
| 464 | const SkIRect srcR = SkIRect::MakeWH(genW, genH); |
| 465 | const SkIRect dstR = SkIRect::MakeXYWH(originX, originY, pmap.width(), pmap.height()); |
| 466 | if (!srcR.contains(dstR)) { |
| 467 | return false; |
| 468 | } |
| 469 | |
| 470 | // If they are requesting a subset, we have to have a temp allocation for full image, and |
| 471 | // then copy the subset into their allocation |
| 472 | SkBitmap full; |
| 473 | SkPixmap fullPM; |
| 474 | const SkPixmap* dstPM = &pmap; |
| 475 | if (srcR != dstR) { |
| 476 | if (!full.tryAllocPixels(pmap.info().makeWH(genW, genH))) { |
| 477 | return false; |
| 478 | } |
| 479 | if (!full.peekPixels(&fullPM)) { |
| 480 | return false; |
| 481 | } |
| 482 | dstPM = &fullPM; |
| 483 | } |
| 484 | |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 485 | SkImageGenerator::Options opts; |
| 486 | opts.fBehavior = behavior; |
| 487 | if (!gen->getPixels(dstPM->info(), dstPM->writable_addr(), dstPM->rowBytes(), &opts)) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 488 | return false; |
| 489 | } |
| 490 | |
| 491 | if (srcR != dstR) { |
| 492 | if (!full.readPixels(pmap, originX, originY)) { |
| 493 | return false; |
| 494 | } |
| 495 | } |
| 496 | return true; |
| 497 | } |
| 498 | |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 499 | bool SkImage_Lazy::lockAsBitmap(SkBitmap* bitmap, SkImage::CachingHint chint, CachedFormat format, |
| 500 | const SkImageInfo& info, |
| 501 | SkTransferFunctionBehavior behavior) const { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 502 | if (this->lockAsBitmapOnlyIfAlreadyCached(bitmap, format)) { |
| 503 | return true; |
| 504 | } |
| 505 | |
| 506 | uint32_t uniqueID = this->getUniqueID(format); |
| 507 | |
| 508 | SkBitmap tmpBitmap; |
| 509 | SkBitmapCache::RecPtr cacheRec; |
| 510 | SkPixmap pmap; |
| 511 | if (SkImage::kAllow_CachingHint == chint) { |
| 512 | auto desc = SkBitmapCacheDesc::Make(uniqueID, info.width(), info.height()); |
| 513 | cacheRec = SkBitmapCache::Alloc(desc, info, &pmap); |
| 514 | if (!cacheRec) { |
| 515 | return false; |
| 516 | } |
| 517 | } else { |
| 518 | if (!tmpBitmap.tryAllocPixels(info)) { |
| 519 | return false; |
| 520 | } |
| 521 | if (!tmpBitmap.peekPixels(&pmap)) { |
| 522 | return false; |
| 523 | } |
| 524 | } |
| 525 | |
| 526 | ScopedGenerator generator(fSharedGenerator); |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 527 | if (!generate_pixels(generator, pmap, fOrigin.x(), fOrigin.y(), behavior)) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 528 | return false; |
| 529 | } |
| 530 | |
| 531 | if (cacheRec) { |
| 532 | SkBitmapCache::Add(std::move(cacheRec), bitmap); |
| 533 | SkASSERT(bitmap->getPixels()); // we're locked |
| 534 | SkASSERT(bitmap->isImmutable()); |
| 535 | SkASSERT(bitmap->getGenerationID() == uniqueID); |
| 536 | this->notifyAddedToCache(); |
| 537 | } else { |
| 538 | *bitmap = tmpBitmap; |
| 539 | bitmap->pixelRef()->setImmutableWithID(uniqueID); |
| 540 | } |
| 541 | |
| 542 | check_output_bitmap(*bitmap, uniqueID); |
| 543 | return true; |
| 544 | } |
| 545 | |
| 546 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 547 | |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 548 | bool SkImage_Lazy::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB, |
| 549 | int srcX, int srcY, CachingHint chint) const { |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame] | 550 | SkColorSpace* dstColorSpace = dstInfo.colorSpace(); |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 551 | SkBitmap bm; |
reed | 6868c3f | 2015-11-24 11:44:47 -0800 | [diff] [blame] | 552 | if (kDisallow_CachingHint == chint) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 553 | CachedFormat cacheFormat = this->chooseCacheFormat(dstColorSpace); |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 554 | SkImageInfo genPixelsInfo = dstInfo; |
| 555 | SkTransferFunctionBehavior behavior = getGeneratorBehaviorAndInfo(&genPixelsInfo); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 556 | if (this->lockAsBitmapOnlyIfAlreadyCached(&bm, cacheFormat)) { |
reed | 6868c3f | 2015-11-24 11:44:47 -0800 | [diff] [blame] | 557 | return bm.readPixels(dstInfo, dstPixels, dstRB, srcX, srcY); |
| 558 | } else { |
| 559 | // Try passing the caller's buffer directly down to the generator. If this fails we |
| 560 | // may still succeed in the general case, as the generator may prefer some other |
| 561 | // config, which we could then convert via SkBitmap::readPixels. |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 562 | if (this->directGeneratePixels(genPixelsInfo, dstPixels, dstRB, srcX, srcY, behavior)) { |
reed | 6868c3f | 2015-11-24 11:44:47 -0800 | [diff] [blame] | 563 | return true; |
| 564 | } |
| 565 | // else fall through |
| 566 | } |
| 567 | } |
| 568 | |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame] | 569 | if (this->getROPixels(&bm, dstColorSpace, chint)) { |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 570 | return bm.readPixels(dstInfo, dstPixels, dstRB, srcX, srcY); |
| 571 | } |
| 572 | return false; |
| 573 | } |
| 574 | |
Ben Wagner | bdf5433 | 2018-05-15 14:12:14 -0400 | [diff] [blame] | 575 | sk_sp<SkData> SkImage_Lazy::onRefEncoded() const { |
| 576 | ScopedGenerator generator(fSharedGenerator); |
| 577 | return generator->refEncodedData(); |
| 578 | } |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 579 | |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 580 | bool SkImage_Lazy::getROPixels(SkBitmap* bitmap, SkColorSpace* dstColorSpace, |
| 581 | CachingHint chint) const { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 582 | CachedFormat cacheFormat = this->chooseCacheFormat(dstColorSpace); |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 583 | const SkImageInfo cacheInfo = this->buildCacheInfo(cacheFormat); |
| 584 | SkImageInfo genPixelsInfo = cacheInfo; |
| 585 | SkTransferFunctionBehavior behavior = getGeneratorBehaviorAndInfo(&genPixelsInfo); |
| 586 | return this->lockAsBitmap(bitmap, chint, cacheFormat, genPixelsInfo, behavior); |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 587 | } |
| 588 | |
Brian Osman | 5bbd076 | 2017-05-08 11:07:42 -0400 | [diff] [blame] | 589 | bool SkImage_Lazy::onIsValid(GrContext* context) const { |
| 590 | ScopedGenerator generator(fSharedGenerator); |
| 591 | return generator->isValid(context); |
| 592 | } |
| 593 | |
Mike Reed | 7f1d020 | 2017-05-08 16:13:39 -0400 | [diff] [blame] | 594 | bool SkImage_Lazy::onCanLazyGenerateOnGPU() const { |
| 595 | #if SK_SUPPORT_GPU |
| 596 | ScopedGenerator generator(fSharedGenerator); |
Stan Iliev | ba81af2 | 2017-06-08 15:16:53 -0400 | [diff] [blame] | 597 | return SkImageGenerator::TexGenType::kNone != generator->onCanGenerateTexture(); |
Mike Reed | 7f1d020 | 2017-05-08 16:13:39 -0400 | [diff] [blame] | 598 | #else |
| 599 | return false; |
| 600 | #endif |
| 601 | } |
| 602 | |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 603 | SkTransferFunctionBehavior SkImage_Lazy::getGeneratorBehaviorAndInfo(SkImageInfo* generatorImageInfo) const { |
| 604 | if (generatorImageInfo->colorSpace()) { |
| 605 | return SkTransferFunctionBehavior::kRespect; |
| 606 | } |
| 607 | // Only specify an output color space if color conversion can be done on the color type. |
| 608 | switch (generatorImageInfo->colorType()) { |
| 609 | case kRGBA_8888_SkColorType: |
| 610 | case kBGRA_8888_SkColorType: |
| 611 | case kRGBA_F16_SkColorType: |
| 612 | case kRGB_565_SkColorType: |
| 613 | *generatorImageInfo = generatorImageInfo->makeColorSpace(fInfo.refColorSpace()); |
| 614 | break; |
| 615 | default: |
| 616 | break; |
| 617 | } |
| 618 | return SkTransferFunctionBehavior::kIgnore; |
| 619 | } |
| 620 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 621 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 622 | |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 623 | #if SK_SUPPORT_GPU |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 624 | sk_sp<GrTextureProxy> SkImage_Lazy::asTextureProxyRef(GrContext* context, |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 625 | const GrSamplerState& params, |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 626 | SkColorSpace* dstColorSpace, |
| 627 | sk_sp<SkColorSpace>* texColorSpace, |
| 628 | SkScalar scaleAdjust[2]) const { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 629 | if (!context) { |
| 630 | return nullptr; |
| 631 | } |
| 632 | |
| 633 | GrImageTextureMaker textureMaker(context, this, kAllow_CachingHint); |
| 634 | return textureMaker.refTextureProxyForParams(params, dstColorSpace, texColorSpace, scaleAdjust); |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 635 | } |
| 636 | #endif |
| 637 | |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 638 | sk_sp<SkImage> SkImage_Lazy::onMakeSubset(const SkIRect& subset) const { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 639 | SkASSERT(fInfo.bounds().contains(subset)); |
| 640 | SkASSERT(fInfo.bounds() != subset); |
reed | 7b6945b | 2015-09-24 00:50:58 -0700 | [diff] [blame] | 641 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 642 | const SkIRect generatorSubset = subset.makeOffset(fOrigin.x(), fOrigin.y()); |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 643 | Validator validator(fSharedGenerator, &generatorSubset, fInfo.refColorSpace()); |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 644 | return validator ? sk_sp<SkImage>(new SkImage_Lazy(&validator)) : nullptr; |
reed | 7b6945b | 2015-09-24 00:50:58 -0700 | [diff] [blame] | 645 | } |
| 646 | |
Matt Sarett | 9f3dcb3 | 2017-05-04 08:53:32 -0400 | [diff] [blame] | 647 | sk_sp<SkImage> SkImage_Lazy::onMakeColorSpace(sk_sp<SkColorSpace> target, |
| 648 | SkColorType targetColorType, |
| 649 | SkTransferFunctionBehavior premulBehavior) const { |
Christopher Cameron | d4b6787 | 2017-07-13 15:18:08 -0700 | [diff] [blame] | 650 | SkAutoExclusive autoAquire(fOnMakeColorSpaceMutex); |
| 651 | if (target && fOnMakeColorSpaceTarget && |
| 652 | SkColorSpace::Equals(target.get(), fOnMakeColorSpaceTarget.get())) { |
| 653 | return fOnMakeColorSpaceResult; |
| 654 | } |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 655 | const SkIRect generatorSubset = |
| 656 | SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height()); |
| 657 | Validator validator(fSharedGenerator, &generatorSubset, target); |
Christopher Cameron | d4b6787 | 2017-07-13 15:18:08 -0700 | [diff] [blame] | 658 | sk_sp<SkImage> result = validator ? sk_sp<SkImage>(new SkImage_Lazy(&validator)) : nullptr; |
| 659 | if (result) { |
| 660 | fOnMakeColorSpaceTarget = target; |
| 661 | fOnMakeColorSpaceResult = result; |
| 662 | } |
| 663 | return result; |
Matt Sarett | 6de1310 | 2017-03-14 14:10:48 -0400 | [diff] [blame] | 664 | } |
| 665 | |
Mike Reed | 185130c | 2017-02-15 15:14:16 -0500 | [diff] [blame] | 666 | sk_sp<SkImage> SkImage::MakeFromGenerator(std::unique_ptr<SkImageGenerator> generator, |
| 667 | const SkIRect* subset) { |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 668 | SkImage_Lazy::Validator validator(SharedGenerator::Make(std::move(generator)), subset, nullptr); |
fmalita | 7929e3a | 2016-10-27 08:15:44 -0700 | [diff] [blame] | 669 | |
Brian Osman | f1b4382 | 2017-04-20 13:43:23 -0400 | [diff] [blame] | 670 | return validator ? sk_make_sp<SkImage_Lazy>(&validator) : nullptr; |
reed | 85d9178 | 2015-09-10 14:33:38 -0700 | [diff] [blame] | 671 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 672 | |
| 673 | ////////////////////////////////////////////////////////////////////////////////////////////////// |
| 674 | |
| 675 | /** |
| 676 | * Implementation of SkImageCacherator interface, as needed by GrImageTextureMaker |
| 677 | */ |
| 678 | |
| 679 | #if SK_SUPPORT_GPU |
| 680 | |
| 681 | void SkImage_Lazy::makeCacheKeyFromOrigKey(const GrUniqueKey& origKey, CachedFormat format, |
| 682 | GrUniqueKey* cacheKey) { |
| 683 | SkASSERT(!cacheKey->isValid()); |
| 684 | if (origKey.isValid()) { |
| 685 | static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain(); |
Derek Sollenberger | e1c60d6 | 2018-04-04 11:53:35 -0400 | [diff] [blame] | 686 | GrUniqueKey::Builder builder(cacheKey, origKey, kDomain, 1, "Image"); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 687 | builder[0] = format; |
| 688 | } |
| 689 | } |
| 690 | |
| 691 | class Generator_GrYUVProvider : public GrYUVProvider { |
| 692 | SkImageGenerator* fGen; |
| 693 | |
| 694 | public: |
| 695 | Generator_GrYUVProvider(SkImageGenerator* gen) : fGen(gen) {} |
| 696 | |
| 697 | uint32_t onGetID() override { return fGen->uniqueID(); } |
| 698 | bool onQueryYUV8(SkYUVSizeInfo* sizeInfo, SkYUVColorSpace* colorSpace) const override { |
| 699 | return fGen->queryYUV8(sizeInfo, colorSpace); |
| 700 | } |
| 701 | bool onGetYUV8Planes(const SkYUVSizeInfo& sizeInfo, void* planes[3]) override { |
| 702 | return fGen->getYUV8Planes(sizeInfo, planes); |
| 703 | } |
| 704 | }; |
| 705 | |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 706 | static void set_key_on_proxy(GrProxyProvider* proxyProvider, |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 707 | GrTextureProxy* proxy, GrTextureProxy* originalProxy, |
| 708 | const GrUniqueKey& key) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 709 | if (key.isValid()) { |
Robert Phillips | 8a90f50 | 2017-07-24 15:09:56 -0400 | [diff] [blame] | 710 | SkASSERT(proxy->origin() == kTopLeft_GrSurfaceOrigin); |
Greg Daniel | f6f7b67 | 2018-02-15 13:06:26 -0500 | [diff] [blame] | 711 | if (originalProxy && originalProxy->getUniqueKey().isValid()) { |
| 712 | SkASSERT(originalProxy->getUniqueKey() == key); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 713 | SkASSERT(GrMipMapped::kYes == proxy->mipMapped() && |
| 714 | GrMipMapped::kNo == originalProxy->mipMapped()); |
Greg Daniel | f6f7b67 | 2018-02-15 13:06:26 -0500 | [diff] [blame] | 715 | // If we had an originalProxy with a valid key, that means there already is a proxy in |
| 716 | // the cache which matches the key, but it does not have mip levels and we require them. |
| 717 | // Thus we must remove the unique key from that proxy. |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 718 | proxyProvider->removeUniqueKeyFromProxy(key, originalProxy); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 719 | } |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 720 | proxyProvider->assignUniqueKeyToProxy(key, proxy); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 721 | } |
| 722 | } |
| 723 | |
| 724 | sk_sp<SkColorSpace> SkImage_Lazy::getColorSpace(GrContext* ctx, SkColorSpace* dstColorSpace) { |
Brian Osman | a8ac924 | 2017-09-07 10:19:08 -0400 | [diff] [blame] | 725 | if (!dstColorSpace) { |
| 726 | // In legacy mode, we do no modification to the image's color space or encoding. |
| 727 | // Subsequent legacy drawing is likely to ignore the color space, but some clients |
| 728 | // may want to know what space the image data is in, so return it. |
| 729 | return fInfo.refColorSpace(); |
| 730 | } else { |
Brian Salomon | c7fe0f7 | 2018-05-11 10:14:21 -0400 | [diff] [blame] | 731 | CachedFormat format = this->chooseCacheFormat(dstColorSpace, ctx->contextPriv().caps()); |
Brian Osman | a8ac924 | 2017-09-07 10:19:08 -0400 | [diff] [blame] | 732 | SkImageInfo cacheInfo = this->buildCacheInfo(format); |
| 733 | return cacheInfo.refColorSpace(); |
| 734 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 735 | } |
| 736 | |
| 737 | /* |
| 738 | * We have 4 ways to try to return a texture (in sorted order) |
| 739 | * |
| 740 | * 1. Check the cache for a pre-existing one |
| 741 | * 2. Ask the generator to natively create one |
| 742 | * 3. Ask the generator to return YUV planes, which the GPU can convert |
| 743 | * 4. Ask the generator to return RGB(A) data, which the GPU can convert |
| 744 | */ |
| 745 | sk_sp<GrTextureProxy> SkImage_Lazy::lockTextureProxy(GrContext* ctx, |
| 746 | const GrUniqueKey& origKey, |
| 747 | SkImage::CachingHint chint, |
| 748 | bool willBeMipped, |
Stan Iliev | ba81af2 | 2017-06-08 15:16:53 -0400 | [diff] [blame] | 749 | SkColorSpace* dstColorSpace, |
| 750 | GrTextureMaker::AllowedTexGenType genType) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 751 | // Values representing the various texture lock paths we can take. Used for logging the path |
| 752 | // taken to a histogram. |
| 753 | enum LockTexturePath { |
| 754 | kFailure_LockTexturePath, |
| 755 | kPreExisting_LockTexturePath, |
| 756 | kNative_LockTexturePath, |
| 757 | kCompressed_LockTexturePath, // Deprecated |
| 758 | kYUV_LockTexturePath, |
| 759 | kRGBA_LockTexturePath, |
| 760 | }; |
| 761 | |
| 762 | enum { kLockTexturePathCount = kRGBA_LockTexturePath + 1 }; |
| 763 | |
| 764 | // Determine which cached format we're going to use (which may involve decoding to a different |
| 765 | // info than the generator provides). |
Brian Salomon | c7fe0f7 | 2018-05-11 10:14:21 -0400 | [diff] [blame] | 766 | CachedFormat format = this->chooseCacheFormat(dstColorSpace, ctx->contextPriv().caps()); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 767 | |
| 768 | // Fold the cache format into our texture key |
| 769 | GrUniqueKey key; |
| 770 | this->makeCacheKeyFromOrigKey(origKey, format, &key); |
| 771 | |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 772 | GrProxyProvider* proxyProvider = ctx->contextPriv().proxyProvider(); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 773 | sk_sp<GrTextureProxy> proxy; |
| 774 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 775 | // 1. Check the cache for a pre-existing one |
| 776 | if (key.isValid()) { |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 777 | proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, kTopLeft_GrSurfaceOrigin); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 778 | if (proxy) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 779 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kPreExisting_LockTexturePath, |
| 780 | kLockTexturePathCount); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 781 | if (!willBeMipped || GrMipMapped::kYes == proxy->mipMapped()) { |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 782 | return proxy; |
| 783 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 784 | } |
| 785 | } |
| 786 | |
| 787 | // The CachedFormat is both an index for which cache "slot" we'll use to store this particular |
| 788 | // decoded variant of the encoded data, and also a recipe for how to transform the original |
| 789 | // info to get the one that we're going to decode to. |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 790 | const SkImageInfo cacheInfo = this->buildCacheInfo(format); |
| 791 | SkImageInfo genPixelsInfo = cacheInfo; |
| 792 | SkTransferFunctionBehavior behavior = getGeneratorBehaviorAndInfo(&genPixelsInfo); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 793 | |
| 794 | // 2. Ask the generator to natively create one |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 795 | if (!proxy) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 796 | ScopedGenerator generator(fSharedGenerator); |
Stan Iliev | ba81af2 | 2017-06-08 15:16:53 -0400 | [diff] [blame] | 797 | if (GrTextureMaker::AllowedTexGenType::kCheap == genType && |
| 798 | SkImageGenerator::TexGenType::kCheap != generator->onCanGenerateTexture()) { |
| 799 | return nullptr; |
| 800 | } |
Greg Daniel | f88c12e | 2017-10-09 09:57:35 -0400 | [diff] [blame] | 801 | if ((proxy = generator->generateTexture(ctx, genPixelsInfo, fOrigin, behavior, |
| 802 | willBeMipped))) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 803 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kNative_LockTexturePath, |
| 804 | kLockTexturePathCount); |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 805 | set_key_on_proxy(proxyProvider, proxy.get(), nullptr, key); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 806 | if (!willBeMipped || GrMipMapped::kYes == proxy->mipMapped()) { |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 807 | return proxy; |
| 808 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 809 | } |
| 810 | } |
| 811 | |
Greg Daniel | 3e70fa3 | 2017-10-05 16:27:06 -0400 | [diff] [blame] | 812 | // 3. Ask the generator to return YUV planes, which the GPU can convert. If we will be mipping |
| 813 | // the texture we fall through here and have the CPU generate the mip maps for us. |
| 814 | if (!proxy && !willBeMipped && !ctx->contextPriv().disableGpuYUVConversion()) { |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 815 | const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(cacheInfo); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 816 | ScopedGenerator generator(fSharedGenerator); |
| 817 | Generator_GrYUVProvider provider(generator); |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 818 | |
| 819 | // The pixels in the texture will be in the generator's color space. If onMakeColorSpace |
| 820 | // has been called then this will not match this image's color space. To correct this, apply |
| 821 | // a color space conversion from the generator's color space to this image's color space. |
Brian Osman | 56893cd | 2018-06-08 14:11:37 -0400 | [diff] [blame] | 822 | // Note that we can only do this conversion (on the GPU) if both color spaces are XYZ type. |
Christopher Cameron | 77e9666 | 2017-07-08 01:47:47 -0700 | [diff] [blame] | 823 | const SkColorSpace* generatorColorSpace = |
| 824 | fSharedGenerator->fGenerator->getInfo().colorSpace(); |
| 825 | const SkColorSpace* thisColorSpace = fInfo.colorSpace(); |
| 826 | |
Brian Osman | 56893cd | 2018-06-08 14:11:37 -0400 | [diff] [blame] | 827 | if ((!generatorColorSpace || generatorColorSpace->toXYZD50()) && |
| 828 | (!thisColorSpace || thisColorSpace->toXYZD50())) { |
| 829 | // TODO: Update to create the mipped surface in the YUV generator and draw the base |
| 830 | // layer directly into the mipped surface. |
| 831 | proxy = provider.refAsTextureProxy(ctx, desc, generatorColorSpace, thisColorSpace); |
| 832 | if (proxy) { |
| 833 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kYUV_LockTexturePath, |
| 834 | kLockTexturePathCount); |
| 835 | set_key_on_proxy(proxyProvider, proxy.get(), nullptr, key); |
| 836 | return proxy; |
| 837 | } |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 838 | } |
| 839 | } |
| 840 | |
| 841 | // 4. Ask the generator to return RGB(A) data, which the GPU can convert |
| 842 | SkBitmap bitmap; |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 843 | if (!proxy && this->lockAsBitmap(&bitmap, chint, format, genPixelsInfo, behavior)) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 844 | if (willBeMipped) { |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 845 | proxy = proxyProvider->createMipMapProxyFromBitmap(bitmap); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 846 | } |
| 847 | if (!proxy) { |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 848 | proxy = GrUploadBitmapToTextureProxy(proxyProvider, bitmap); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 849 | } |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 850 | if (proxy && (!willBeMipped || GrMipMapped::kYes == proxy->mipMapped())) { |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 851 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kRGBA_LockTexturePath, |
| 852 | kLockTexturePathCount); |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 853 | set_key_on_proxy(proxyProvider, proxy.get(), nullptr, key); |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 854 | return proxy; |
| 855 | } |
| 856 | } |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 857 | |
| 858 | if (proxy) { |
| 859 | // We need a mipped proxy, but we either found a proxy earlier that wasn't mipped, generated |
| 860 | // a native non mipped proxy, or generated a non-mipped yuv proxy. Thus we generate a new |
| 861 | // mipped surface and copy the original proxy into the base layer. We will then let the gpu |
| 862 | // generate the rest of the mips. |
| 863 | SkASSERT(willBeMipped); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 864 | SkASSERT(GrMipMapped::kNo == proxy->mipMapped()); |
Greg Daniel | e1da1d9 | 2017-10-06 15:59:27 -0400 | [diff] [blame] | 865 | if (auto mippedProxy = GrCopyBaseMipMapToTextureProxy(ctx, proxy.get())) { |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 866 | set_key_on_proxy(proxyProvider, mippedProxy.get(), proxy.get(), key); |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 867 | return mippedProxy; |
| 868 | } |
Greg Daniel | 8f5bbda | 2018-06-08 17:22:23 -0400 | [diff] [blame^] | 869 | // We failed to make a mipped proxy with the base copied into it. This could have |
| 870 | // been from failure to make the proxy or failure to do the copy. Thus we will fall |
| 871 | // back to just using the non mipped proxy; See skbug.com/7094. |
| 872 | return proxy; |
Greg Daniel | fc5060d | 2017-10-04 18:36:15 +0000 | [diff] [blame] | 873 | } |
| 874 | |
Brian Osman | df7e075 | 2017-04-26 16:20:28 -0400 | [diff] [blame] | 875 | SK_HISTOGRAM_ENUMERATION("LockTexturePath", kFailure_LockTexturePath, |
| 876 | kLockTexturePathCount); |
| 877 | return nullptr; |
| 878 | } |
| 879 | |
| 880 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 881 | |
| 882 | #endif |