diff options
author | Brian Osman <brianosman@google.com> | 2017-04-26 16:20:28 -0400 |
---|---|---|
committer | Skia Commit-Bot <skia-commit-bot@chromium.org> | 2017-04-27 18:31:19 +0000 |
commit | df7e075c74110fcfebdc49ca503684162e118af5 (patch) | |
tree | 4d4f55d2867115102a2d2460096c9fe8ce0ecb51 /src | |
parent | 0aa742f15a400433bafe6350c20523b4dd062f64 (diff) |
Fold SkImageCacherator into SkImage_Lazy
SkImageCacherator still exists, but only as an interface implemented
(solely) by SkImage_Lazy. The only external clients are
GrImageTextureMaker and SkImage_Gpu::getDeferredTextureImageData.
This is probably an improvement, but doesn't go as far as I'd hoped.
Bug: skia:
Change-Id: I6812badfabb6924b025621b21af00cbde9c16cac
Reviewed-on: https://skia-review.googlesource.com/14371
Reviewed-by: Matt Sarett <msarett@google.com>
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>
Diffstat (limited to 'src')
-rw-r--r-- | src/core/SkBitmapProvider.cpp | 1 | ||||
-rw-r--r-- | src/core/SkDevice.cpp | 1 | ||||
-rw-r--r-- | src/core/SkImageCacherator.cpp | 573 | ||||
-rw-r--r-- | src/core/SkImageCacherator.h | 140 | ||||
-rw-r--r-- | src/gpu/GrImageTextureMaker.cpp | 32 | ||||
-rw-r--r-- | src/gpu/GrImageTextureMaker.h | 3 | ||||
-rw-r--r-- | src/gpu/SkGpuDevice.cpp | 17 | ||||
-rw-r--r-- | src/image/SkImage_Gpu.cpp | 4 | ||||
-rw-r--r-- | src/image/SkImage_Lazy.cpp | 675 |
9 files changed, 686 insertions, 760 deletions
diff --git a/src/core/SkBitmapProvider.cpp b/src/core/SkBitmapProvider.cpp index 928214c498..90c4e62a54 100644 --- a/src/core/SkBitmapProvider.cpp +++ b/src/core/SkBitmapProvider.cpp @@ -7,7 +7,6 @@ #include "SkBitmapProvider.h" #include "SkImage_Base.h" -#include "SkImageCacherator.h" #include "SkPixelRef.h" int SkBitmapProvider::width() const { diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp index f2732e2569..99a7a0c7ff 100644 --- a/src/core/SkDevice.cpp +++ b/src/core/SkDevice.cpp @@ -9,7 +9,6 @@ #include "SkColorFilter.h" #include "SkDraw.h" #include "SkDrawFilter.h" -#include "SkImageCacherator.h" #include "SkImageFilter.h" #include "SkImageFilterCache.h" #include "SkImagePriv.h" diff --git a/src/core/SkImageCacherator.cpp b/src/core/SkImageCacherator.cpp deleted file mode 100644 index 9ef9f79a33..0000000000 --- a/src/core/SkImageCacherator.cpp +++ /dev/null @@ -1,573 +0,0 @@ -/* - * Copyright 2015 Google Inc. - * - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -#include "SkBitmap.h" -#include "SkBitmapCache.h" -#include "SkColorSpace_Base.h" -#include "SkImage_Base.h" -#include "SkImageCacherator.h" -#include "SkMallocPixelRef.h" -#include "SkNextID.h" -#include "SkPixelRef.h" -#include "SkResourceCache.h" - -#if SK_SUPPORT_GPU -#include "GrContext.h" -#include "GrContextPriv.h" -#include "GrGpuResourcePriv.h" -#include "GrImageTextureMaker.h" -#include "GrResourceKey.h" -#include "GrResourceProvider.h" -#include "GrSamplerParams.h" -#include "GrYUVProvider.h" -#include "SkGr.h" -#endif - -// Until we actually have codecs/etc. that can contain/support a GPU texture format -// skip this step, since for some generators, returning their encoded data as a SkData -// can be somewhat expensive, and this call doesn't indicate to the generator that we're -// only interested in GPU datas... -// see skbug.com/ 4971, 5128, ... -//#define SK_SUPPORT_COMPRESSED_TEXTURES_IN_CACHERATOR - -// Helper for exclusive access to a shared generator. -class SkImageCacherator::ScopedGenerator { -public: - ScopedGenerator(const sk_sp<SharedGenerator>& gen) - : fSharedGenerator(gen) - , fAutoAquire(gen->fMutex) {} - - SkImageGenerator* operator->() const { - fSharedGenerator->fMutex.assertHeld(); - return fSharedGenerator->fGenerator.get(); - } - - operator SkImageGenerator*() const { - fSharedGenerator->fMutex.assertHeld(); - return fSharedGenerator->fGenerator.get(); - } - -private: - const sk_sp<SharedGenerator>& fSharedGenerator; - SkAutoExclusive fAutoAquire; -}; - -SkImageCacherator::Validator::Validator(sk_sp<SharedGenerator> gen, const SkIRect* subset) - : fSharedGenerator(std::move(gen)) { - - if (!fSharedGenerator) { - return; - } - - // The following generator accessors are safe without acquiring the mutex (const getters). - // TODO: refactor to use a ScopedGenerator instead, for clarity. - const SkImageInfo& info = fSharedGenerator->fGenerator->getInfo(); - if (info.isEmpty()) { - fSharedGenerator.reset(); - return; - } - - fUniqueID = fSharedGenerator->fGenerator->uniqueID(); - const SkIRect bounds = SkIRect::MakeWH(info.width(), info.height()); - if (subset) { - if (!bounds.contains(*subset)) { - fSharedGenerator.reset(); - return; - } - if (*subset != bounds) { - // we need a different uniqueID since we really are a subset of the raw generator - fUniqueID = SkNextID::ImageID(); - } - } else { - subset = &bounds; - } - - fInfo = info.makeWH(subset->width(), subset->height()); - fOrigin = SkIPoint::Make(subset->x(), subset->y()); - - // colortables are poorly to not-at-all supported in our resourcecache, so we - // bully them into N32 (the generator will perform the up-sample) - if (fInfo.colorType() == kIndex_8_SkColorType) { - fInfo = fInfo.makeColorType(kN32_SkColorType); - } -} - -SkImageCacherator* SkImageCacherator::NewFromGenerator(std::unique_ptr<SkImageGenerator> gen, - const SkIRect* subset) { - Validator validator(SharedGenerator::Make(std::move(gen)), subset); - - return validator ? new SkImageCacherator(&validator) : nullptr; -} - -SkImageCacherator::SkImageCacherator(Validator* validator) - : fSharedGenerator(std::move(validator->fSharedGenerator)) // we take ownership - , fInfo(validator->fInfo) - , fOrigin(validator->fOrigin) -{ - SkASSERT(fSharedGenerator); - SkASSERT(fInfo.colorType() != kIndex_8_SkColorType); - // We explicit set the legacy format slot, but leave the others uninitialized (via SkOnce) - // and only resolove them to IDs as needed (by calling getUniqueID()). - fIDRecs[kLegacy_CachedFormat].fOnce([this, validator] { - fIDRecs[kLegacy_CachedFormat].fUniqueID = validator->fUniqueID; - }); -} - -SkImageCacherator::~SkImageCacherator() {} - -uint32_t SkImageCacherator::getUniqueID(CachedFormat format) const { - IDRec* rec = &fIDRecs[format]; - rec->fOnce([rec] { - rec->fUniqueID = SkNextID::ImageID(); - }); - return rec->fUniqueID; -} - -SkData* SkImageCacherator::refEncoded() { - ScopedGenerator generator(fSharedGenerator); - return generator->refEncodedData(); -} - -static bool check_output_bitmap(const SkBitmap& bitmap, uint32_t expectedID) { - SkASSERT(bitmap.getGenerationID() == expectedID); - SkASSERT(bitmap.isImmutable()); - SkASSERT(bitmap.getPixels()); - return true; -} - -bool SkImageCacherator::directGeneratePixels(const SkImageInfo& info, void* pixels, size_t rb, - int srcX, int srcY, - SkTransferFunctionBehavior behavior) { - ScopedGenerator generator(fSharedGenerator); - const SkImageInfo& genInfo = generator->getInfo(); - // Currently generators do not natively handle subsets, so check that first. - if (srcX || srcY || genInfo.width() != info.width() || genInfo.height() != info.height()) { - return false; - } - - SkImageGenerator::Options opts; - opts.fBehavior = behavior; - return generator->getPixels(info, pixels, rb, &opts); -} - -////////////////////////////////////////////////////////////////////////////////////////////////// - -bool SkImageCacherator::lockAsBitmapOnlyIfAlreadyCached(SkBitmap* bitmap, CachedFormat format) { - uint32_t uniqueID = this->getUniqueID(format); - return SkBitmapCache::Find(SkBitmapCacheDesc::Make(uniqueID, - fInfo.width(), fInfo.height()), bitmap) && - check_output_bitmap(*bitmap, uniqueID); -} - -static bool generate_pixels(SkImageGenerator* gen, const SkPixmap& pmap, int originX, int originY) { - const int genW = gen->getInfo().width(); - const int genH = gen->getInfo().height(); - const SkIRect srcR = SkIRect::MakeWH(genW, genH); - const SkIRect dstR = SkIRect::MakeXYWH(originX, originY, pmap.width(), pmap.height()); - if (!srcR.contains(dstR)) { - return false; - } - - // If they are requesting a subset, we have to have a temp allocation for full image, and - // then copy the subset into their allocation - SkBitmap full; - SkPixmap fullPM; - const SkPixmap* dstPM = &pmap; - if (srcR != dstR) { - if (!full.tryAllocPixels(pmap.info().makeWH(genW, genH))) { - return false; - } - if (!full.peekPixels(&fullPM)) { - return false; - } - dstPM = &fullPM; - } - - if (!gen->getPixels(dstPM->info(), dstPM->writable_addr(), dstPM->rowBytes())) { - return false; - } - - if (srcR != dstR) { - if (!full.readPixels(pmap, originX, originY)) { - return false; - } - } - return true; -} - -bool SkImageCacherator::lockAsBitmap(SkBitmap* bitmap, const SkImage* client, - SkImage::CachingHint chint, CachedFormat format, - const SkImageInfo& info) { - if (this->lockAsBitmapOnlyIfAlreadyCached(bitmap, format)) { - return true; - } - - uint32_t uniqueID = this->getUniqueID(format); - - SkBitmap tmpBitmap; - SkBitmapCache::RecPtr cacheRec; - SkPixmap pmap; - if (SkImage::kAllow_CachingHint == chint) { - auto desc = SkBitmapCacheDesc::Make(uniqueID, info.width(), info.height()); - cacheRec = SkBitmapCache::Alloc(desc, info, &pmap); - if (!cacheRec) { - return false; - } - } else { - if (!tmpBitmap.tryAllocPixels(info)) { - return false; - } - if (!tmpBitmap.peekPixels(&pmap)) { - return false; - } - } - - ScopedGenerator generator(fSharedGenerator); - if (!generate_pixels(generator, pmap, fOrigin.x(), fOrigin.y())) { - return false; - } - - if (cacheRec) { - SkBitmapCache::Add(std::move(cacheRec), bitmap); - SkASSERT(bitmap->getPixels()); // we're locked - SkASSERT(bitmap->isImmutable()); - SkASSERT(bitmap->getGenerationID() == uniqueID); - if (client) { - as_IB(client)->notifyAddedToCache(); - } - } else { - *bitmap = tmpBitmap; - bitmap->pixelRef()->setImmutableWithID(uniqueID); - } - - check_output_bitmap(*bitmap, uniqueID); - return true; -} - -////////////////////////////////////////////////////////////////////////////////////////////////// - -// Abstraction of GrCaps that handles the cases where we don't have a caps pointer (because -// we're in raster mode), or where GPU support is entirely missing. In theory, we only need the -// chosen format to be texturable, but that lets us choose F16 on GLES implemenations where we -// won't be able to read the texture back. We'd like to ensure that SkImake::makeNonTextureImage -// works, so we require that the formats we choose are renderable (as a proxy for being readable). -struct CacheCaps { - CacheCaps(const GrCaps* caps) : fCaps(caps) {} - -#if SK_SUPPORT_GPU - bool supportsHalfFloat() const { - return !fCaps || - (fCaps->isConfigTexturable(kRGBA_half_GrPixelConfig) && - fCaps->isConfigRenderable(kRGBA_half_GrPixelConfig, false)); - } - - bool supportsSRGB() const { - return !fCaps || - (fCaps->srgbSupport() && fCaps->isConfigTexturable(kSRGBA_8888_GrPixelConfig)); - } - - bool supportsSBGR() const { - return !fCaps || fCaps->srgbSupport(); - } -#else - bool supportsHalfFloat() const { return true; } - bool supportsSRGB() const { return true; } - bool supportsSBGR() const { return true; } -#endif - - const GrCaps* fCaps; -}; - -SkImageCacherator::CachedFormat SkImageCacherator::chooseCacheFormat(SkColorSpace* dstColorSpace, - const GrCaps* grCaps) { - SkColorSpace* cs = fInfo.colorSpace(); - if (!cs || !dstColorSpace) { - return kLegacy_CachedFormat; - } - - CacheCaps caps(grCaps); - switch (fInfo.colorType()) { - case kUnknown_SkColorType: - case kAlpha_8_SkColorType: - case kRGB_565_SkColorType: - case kARGB_4444_SkColorType: - // We don't support color space on these formats, so always decode in legacy mode: - // TODO: Ask the codec to decode these to something else (at least sRGB 8888)? - return kLegacy_CachedFormat; - - case kIndex_8_SkColorType: - SkDEBUGFAIL("Index_8 should have been remapped at construction time."); - return kLegacy_CachedFormat; - - case kGray_8_SkColorType: - // TODO: What do we do with grayscale sources that have strange color spaces attached? - // The codecs and color space xform don't handle this correctly (yet), so drop it on - // the floor. (Also, inflating by a factor of 8 is going to be unfortunate). - // As it is, we don't directly support sRGB grayscale, so ask the codec to convert - // it for us. This bypasses some really sketchy code GrUploadPixmapToTexture. - if (cs->gammaCloseToSRGB() && caps.supportsSRGB()) { - return kSRGB8888_CachedFormat; - } else { - return kLegacy_CachedFormat; - } - - case kRGBA_8888_SkColorType: - if (cs->gammaCloseToSRGB()) { - if (caps.supportsSRGB()) { - return kSRGB8888_CachedFormat; - } else if (caps.supportsHalfFloat()) { - return kLinearF16_CachedFormat; - } else { - return kLegacy_CachedFormat; - } - } else { - if (caps.supportsHalfFloat()) { - return kLinearF16_CachedFormat; - } else if (caps.supportsSRGB()) { - return kSRGB8888_CachedFormat; - } else { - return kLegacy_CachedFormat; - } - } - - case kBGRA_8888_SkColorType: - // Odd case. sBGRA isn't a real thing, so we may not have this texturable. - if (caps.supportsSBGR()) { - if (cs->gammaCloseToSRGB()) { - return kSBGR8888_CachedFormat; - } else if (caps.supportsHalfFloat()) { - return kLinearF16_CachedFormat; - } else if (caps.supportsSRGB()) { - return kSRGB8888_CachedFormat; - } else { - // sBGRA support without sRGBA is highly unlikely (impossible?) Nevertheless. - return kLegacy_CachedFormat; - } - } else { - if (cs->gammaCloseToSRGB()) { - if (caps.supportsSRGB()) { - return kSRGB8888_CachedFormat; - } else if (caps.supportsHalfFloat()) { - return kLinearF16_CachedFormat; - } else { - return kLegacy_CachedFormat; - } - } else { - if (caps.supportsHalfFloat()) { - return kLinearF16_CachedFormat; - } else if (caps.supportsSRGB()) { - return kSRGB8888_CachedFormat; - } else { - return kLegacy_CachedFormat; - } - } - } - - case kRGBA_F16_SkColorType: - if (caps.supportsHalfFloat()) { - return kLinearF16_CachedFormat; - } else if (caps.supportsSRGB()) { - return kSRGB8888_CachedFormat; - } else { - return kLegacy_CachedFormat; - } - } - SkDEBUGFAIL("Unreachable"); - return kLegacy_CachedFormat; -} - -SkImageInfo SkImageCacherator::buildCacheInfo(CachedFormat format) { - switch (format) { - case kLegacy_CachedFormat: - return fInfo.makeColorSpace(nullptr); - case kLinearF16_CachedFormat: - return fInfo.makeColorType(kRGBA_F16_SkColorType) - .makeColorSpace(as_CSB(fInfo.colorSpace())->makeLinearGamma()); - case kSRGB8888_CachedFormat: - // If the transfer function is nearly (but not exactly) sRGB, we don't want the codec - // to bother trans-coding. It would be slow, and do more harm than good visually, - // so we make sure to leave the colorspace as-is. - if (fInfo.colorSpace()->gammaCloseToSRGB()) { - return fInfo.makeColorType(kRGBA_8888_SkColorType); - } else { - return fInfo.makeColorType(kRGBA_8888_SkColorType) - .makeColorSpace(as_CSB(fInfo.colorSpace())->makeSRGBGamma()); - } - case kSBGR8888_CachedFormat: - // See note above about not-quite-sRGB transfer functions. - if (fInfo.colorSpace()->gammaCloseToSRGB()) { - return fInfo.makeColorType(kBGRA_8888_SkColorType); - } else { - return fInfo.makeColorType(kBGRA_8888_SkColorType) - .makeColorSpace(as_CSB(fInfo.colorSpace())->makeSRGBGamma()); - } - default: - SkDEBUGFAIL("Invalid cached format"); - return fInfo; - } -} - -////////////////////////////////////////////////////////////////////////////////////////////////// - -#if SK_SUPPORT_GPU - -void SkImageCacherator::makeCacheKeyFromOrigKey(const GrUniqueKey& origKey, CachedFormat format, - GrUniqueKey* cacheKey) { - SkASSERT(!cacheKey->isValid()); - if (origKey.isValid()) { - static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain(); - GrUniqueKey::Builder builder(cacheKey, origKey, kDomain, 1); - builder[0] = format; - } -} - -class Generator_GrYUVProvider : public GrYUVProvider { - SkImageGenerator* fGen; - -public: - Generator_GrYUVProvider(SkImageGenerator* gen) : fGen(gen) {} - - uint32_t onGetID() override { return fGen->uniqueID(); } - bool onQueryYUV8(SkYUVSizeInfo* sizeInfo, SkYUVColorSpace* colorSpace) const override { - return fGen->queryYUV8(sizeInfo, colorSpace); - } - bool onGetYUV8Planes(const SkYUVSizeInfo& sizeInfo, void* planes[3]) override { - return fGen->getYUV8Planes(sizeInfo, planes); - } -}; - -static void set_key_on_proxy(GrResourceProvider* resourceProvider, - GrTextureProxy* proxy, const GrUniqueKey& key) { - if (key.isValid()) { - resourceProvider->assignUniqueKeyToProxy(key, proxy); - } -} - -sk_sp<SkColorSpace> SkImageCacherator::getColorSpace(GrContext* ctx, SkColorSpace* dstColorSpace) { - // TODO: This isn't always correct. Picture generator currently produces textures in N32, - // and will (soon) emit them in an arbitrary (destination) space. We will need to stash that - // information in/on the key so we can return the correct space in case #1 of lockTexture. - CachedFormat format = this->chooseCacheFormat(dstColorSpace, ctx->caps()); - SkImageInfo cacheInfo = this->buildCacheInfo(format); - return sk_ref_sp(cacheInfo.colorSpace()); -} - -/* - * We have 4 ways to try to return a texture (in sorted order) - * - * 1. Check the cache for a pre-existing one - * 2. Ask the generator to natively create one - * 3. Ask the generator to return YUV planes, which the GPU can convert - * 4. Ask the generator to return RGB(A) data, which the GPU can convert - */ -sk_sp<GrTextureProxy> SkImageCacherator::lockTextureProxy(GrContext* ctx, - const GrUniqueKey& origKey, - const SkImage* client, - SkImage::CachingHint chint, - bool willBeMipped, - SkColorSpace* dstColorSpace) { - // Values representing the various texture lock paths we can take. Used for logging the path - // taken to a histogram. - enum LockTexturePath { - kFailure_LockTexturePath, - kPreExisting_LockTexturePath, - kNative_LockTexturePath, - kCompressed_LockTexturePath, // Deprecated - kYUV_LockTexturePath, - kRGBA_LockTexturePath, - }; - - enum { kLockTexturePathCount = kRGBA_LockTexturePath + 1 }; - - // Determine which cached format we're going to use (which may involve decoding to a different - // info than the generator provides). - CachedFormat format = this->chooseCacheFormat(dstColorSpace, ctx->caps()); - - // Fold the cache format into our texture key - GrUniqueKey key; - this->makeCacheKeyFromOrigKey(origKey, format, &key); - - // 1. Check the cache for a pre-existing one - if (key.isValid()) { - if (sk_sp<GrTextureProxy> proxy = ctx->resourceProvider()->findProxyByUniqueKey(key)) { - SK_HISTOGRAM_ENUMERATION("LockTexturePath", kPreExisting_LockTexturePath, - kLockTexturePathCount); - return proxy; - } - } - - // The CachedFormat is both an index for which cache "slot" we'll use to store this particular - // decoded variant of the encoded data, and also a recipe for how to transform the original - // info to get the one that we're going to decode to. - SkImageInfo cacheInfo = this->buildCacheInfo(format); - - // 2. Ask the generator to natively create one - { - ScopedGenerator generator(fSharedGenerator); - if (sk_sp<GrTextureProxy> proxy = generator->generateTexture(ctx, cacheInfo, fOrigin)) { - SK_HISTOGRAM_ENUMERATION("LockTexturePath", kNative_LockTexturePath, - kLockTexturePathCount); - set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key); - return proxy; - } - } - - // 3. Ask the generator to return YUV planes, which the GPU can convert - if (!ctx->contextPriv().disableGpuYUVConversion()) { - const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(cacheInfo, *ctx->caps()); - ScopedGenerator generator(fSharedGenerator); - Generator_GrYUVProvider provider(generator); - if (sk_sp<GrTextureProxy> proxy = provider.refAsTextureProxy(ctx, desc, true)) { - SK_HISTOGRAM_ENUMERATION("LockTexturePath", kYUV_LockTexturePath, - kLockTexturePathCount); - set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key); - return proxy; - } - } - - // 4. Ask the generator to return RGB(A) data, which the GPU can convert - SkBitmap bitmap; - if (this->lockAsBitmap(&bitmap, client, chint, format, cacheInfo)) { - sk_sp<GrTextureProxy> proxy; - if (willBeMipped) { - proxy = GrGenerateMipMapsAndUploadToTextureProxy(ctx, bitmap, dstColorSpace); - } - if (!proxy) { - proxy = GrUploadBitmapToTextureProxy(ctx->resourceProvider(), bitmap); - } - if (proxy) { - SK_HISTOGRAM_ENUMERATION("LockTexturePath", kRGBA_LockTexturePath, - kLockTexturePathCount); - set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key); - return proxy; - } - } - SK_HISTOGRAM_ENUMERATION("LockTexturePath", kFailure_LockTexturePath, - kLockTexturePathCount); - return nullptr; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////// - -sk_sp<GrTextureProxy> SkImageCacherator::lockAsTextureProxy(GrContext* ctx, - const GrSamplerParams& params, - SkColorSpace* dstColorSpace, - sk_sp<SkColorSpace>* texColorSpace, - const SkImage* client, - SkScalar scaleAdjust[2], - SkImage::CachingHint chint) { - if (!ctx) { - return nullptr; - } - - return GrImageTextureMaker(ctx, this, client, chint).refTextureProxyForParams(params, - dstColorSpace, - texColorSpace, - scaleAdjust); -} - -#endif diff --git a/src/core/SkImageCacherator.h b/src/core/SkImageCacherator.h index fb07b7646a..358744606e 100644 --- a/src/core/SkImageCacherator.h +++ b/src/core/SkImageCacherator.h @@ -8,30 +8,22 @@ #ifndef SkImageCacherator_DEFINED #define SkImageCacherator_DEFINED -#include "SkImageGenerator.h" -#include "SkMutex.h" -#include "SkTemplates.h" +#include "SkImage.h" +#include "SkImageInfo.h" class GrCaps; class GrContext; -class GrSamplerParams; class GrTextureProxy; class GrUniqueKey; -class SkBitmap; -class SkImage; +class SkColorSpace; /* - * Internal class to manage caching the output of an ImageGenerator. + * Interface used by GrImageTextureMaker to construct textures from instances of SkImage + * (specifically, SkImage_Lazy). */ class SkImageCacherator { public: - static SkImageCacherator* NewFromGenerator(std::unique_ptr<SkImageGenerator>, - const SkIRect* subset = nullptr); - - ~SkImageCacherator(); - - const SkImageInfo& info() const { return fInfo; } - uint32_t uniqueID() const { return this->getUniqueID(kLegacy_CachedFormat); } + virtual ~SkImageCacherator() {} enum CachedFormat { kLegacy_CachedFormat, // The format from the generator, with any color space stripped out @@ -42,122 +34,26 @@ public: kNumCachedFormats, }; -#if SK_SUPPORT_GPU - /** - * Returns a ref() on the texture produced by this generator. The caller must call unref() - * when it is done. Will return nullptr on failure. - * - * If not NULL, the client will be notified (->notifyAddedToCache()) when resources are - * added to the cache on its behalf. - * - * The caller is responsible for calling proxy->unref() when they are done. - * - * The scaleAdjust in/out parameter will return any scale adjustment that needs - * to be applied to the absolute texture coordinates in the case where the image - * was resized to meet the sampling requirements (e.g., resized out to the next power of 2). - * It can be null if the caller knows resizing will not be required. - */ - sk_sp<GrTextureProxy> lockAsTextureProxy(GrContext*, const GrSamplerParams&, - SkColorSpace* dstColorSpace, - sk_sp<SkColorSpace>* texColorSpace, - const SkImage* client, - SkScalar scaleAdjust[2], - SkImage::CachingHint = SkImage::kAllow_CachingHint); -#endif - - /** - * If the underlying src naturally is represented by an encoded blob (in SkData), this returns - * a ref to that data. If not, it returns null. - */ - SkData* refEncoded(); - - // Only return true if the generate has already been cached. - bool lockAsBitmapOnlyIfAlreadyCached(SkBitmap*, CachedFormat); - // Call the underlying generator directly - bool directGeneratePixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB, - int srcX, int srcY, SkTransferFunctionBehavior behavior); - -private: - // Ref-counted tuple(SkImageGenerator, SkMutex) which allows sharing of one generator - // among several cacherators. - class SharedGenerator final : public SkNVRefCnt<SharedGenerator> { - public: - static sk_sp<SharedGenerator> Make(std::unique_ptr<SkImageGenerator> gen) { - return gen ? sk_sp<SharedGenerator>(new SharedGenerator(std::move(gen))) : nullptr; - } - - private: - explicit SharedGenerator(std::unique_ptr<SkImageGenerator> gen) - : fGenerator(std::move(gen)) - { - SkASSERT(fGenerator); - } - - friend class ScopedGenerator; - friend class SkImageCacherator; - - std::unique_ptr<SkImageGenerator> fGenerator; - SkMutex fMutex; - }; - class ScopedGenerator; - - struct Validator { - Validator(sk_sp<SharedGenerator>, const SkIRect* subset); - - operator bool() const { return fSharedGenerator.get(); } - - sk_sp<SharedGenerator> fSharedGenerator; - SkImageInfo fInfo; - SkIPoint fOrigin; - uint32_t fUniqueID; - }; - - SkImageCacherator(Validator*); - - CachedFormat chooseCacheFormat(SkColorSpace* dstColorSpace, const GrCaps* = nullptr); - SkImageInfo buildCacheInfo(CachedFormat); - - /** - * On success (true), bitmap will point to the pixels for this generator. If this returns - * false, the bitmap will be reset to empty. - * - * If not NULL, the client will be notified (->notifyAddedToCache()) when resources are - * added to the cache on its behalf. - */ - bool lockAsBitmap(SkBitmap*, const SkImage* client, SkImage::CachingHint, CachedFormat, - const SkImageInfo&); + virtual CachedFormat chooseCacheFormat(SkColorSpace* dstColorSpace, + const GrCaps* = nullptr) const = 0; + virtual SkImageInfo buildCacheInfo(CachedFormat) const = 0; #if SK_SUPPORT_GPU // Returns the texture proxy. If the cacherator is generating the texture and wants to cache it, // it should use the passed in key (if the key is valid). - sk_sp<GrTextureProxy> lockTextureProxy(GrContext*, - const GrUniqueKey& key, - const SkImage* client, - SkImage::CachingHint, - bool willBeMipped, - SkColorSpace* dstColorSpace); + virtual sk_sp<GrTextureProxy> lockTextureProxy(GrContext*, + const GrUniqueKey& key, + SkImage::CachingHint, + bool willBeMipped, + SkColorSpace* dstColorSpace) = 0; + // Returns the color space of the texture that would be returned if you called lockTexture. // Separate code path to allow querying of the color space for textures that cached (even // externally). - sk_sp<SkColorSpace> getColorSpace(GrContext*, SkColorSpace* dstColorSpace); - void makeCacheKeyFromOrigKey(const GrUniqueKey& origKey, CachedFormat, GrUniqueKey* cacheKey); + virtual sk_sp<SkColorSpace> getColorSpace(GrContext*, SkColorSpace* dstColorSpace) = 0; + virtual void makeCacheKeyFromOrigKey(const GrUniqueKey& origKey, CachedFormat, + GrUniqueKey* cacheKey) = 0; #endif - - sk_sp<SharedGenerator> fSharedGenerator; - const SkImageInfo fInfo; - const SkIPoint fOrigin; - - struct IDRec { - SkOnce fOnce; - uint32_t fUniqueID; - }; - mutable IDRec fIDRecs[kNumCachedFormats]; - - uint32_t getUniqueID(CachedFormat) const; - - friend class GrImageTextureMaker; - friend class SkImage; - friend class SkImage_Lazy; }; #endif diff --git a/src/gpu/GrImageTextureMaker.cpp b/src/gpu/GrImageTextureMaker.cpp index a1a6053a03..bbdc9c1913 100644 --- a/src/gpu/GrImageTextureMaker.cpp +++ b/src/gpu/GrImageTextureMaker.cpp @@ -14,26 +14,20 @@ #include "SkImageCacherator.h" #include "SkPixelRef.h" -static bool cacher_is_alpha_only(const SkImageCacherator& cacher) { - return kAlpha_8_SkColorType == cacher.info().colorType(); -} - -GrImageTextureMaker::GrImageTextureMaker(GrContext* context, SkImageCacherator* cacher, - const SkImage* client, SkImage::CachingHint chint) - : INHERITED(context, cacher->info().width(), cacher->info().height(), - cacher_is_alpha_only(*cacher)) - , fCacher(cacher) - , fClient(client) - , fCachingHint(chint) { - if (client) { - GrMakeKeyFromImageID(&fOriginalKey, client->uniqueID(), - SkIRect::MakeWH(this->width(), this->height())); - } +GrImageTextureMaker::GrImageTextureMaker(GrContext* context, const SkImage* client, + SkImage::CachingHint chint) + : INHERITED(context, client->width(), client->height(), client->isAlphaOnly()) + , fCacher(as_IB(client)->peekCacherator()) + , fClient(client) + , fCachingHint(chint) { + SkASSERT(fCacher); + GrMakeKeyFromImageID(&fOriginalKey, client->uniqueID(), + SkIRect::MakeWH(this->width(), this->height())); } sk_sp<GrTextureProxy> GrImageTextureMaker::refOriginalTextureProxy(bool willBeMipped, SkColorSpace* dstColorSpace) { - return fCacher->lockTextureProxy(this->context(), fOriginalKey, fClient, fCachingHint, + return fCacher->lockTextureProxy(this->context(), fOriginalKey, fCachingHint, willBeMipped, dstColorSpace); } @@ -49,13 +43,11 @@ void GrImageTextureMaker::makeCopyKey(const CopyParams& stretch, GrUniqueKey* pa } void GrImageTextureMaker::didCacheCopy(const GrUniqueKey& copyKey) { - if (fClient) { - as_IB(fClient)->notifyAddedToCache(); - } + as_IB(fClient)->notifyAddedToCache(); } SkAlphaType GrImageTextureMaker::alphaType() const { - return fCacher->info().alphaType(); + return fClient->alphaType(); } sk_sp<SkColorSpace> GrImageTextureMaker::getColorSpace(SkColorSpace* dstColorSpace) { return fCacher->getColorSpace(this->context(), dstColorSpace); diff --git a/src/gpu/GrImageTextureMaker.h b/src/gpu/GrImageTextureMaker.h index 5145903775..4f3e8bd3de 100644 --- a/src/gpu/GrImageTextureMaker.h +++ b/src/gpu/GrImageTextureMaker.h @@ -17,8 +17,7 @@ class SkImageCacherator; is kAllow the image's ID is used for the cache key. */ class GrImageTextureMaker : public GrTextureMaker { public: - GrImageTextureMaker(GrContext* context, SkImageCacherator* cacher, const SkImage* client, - SkImage::CachingHint chint); + GrImageTextureMaker(GrContext* context, const SkImage* client, SkImage::CachingHint chint); protected: // TODO: consider overriding this, for the case where the underlying generator might be diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp index 6ddae65a9c..7a0585e0d0 100644 --- a/src/gpu/SkGpuDevice.cpp +++ b/src/gpu/SkGpuDevice.cpp @@ -22,7 +22,6 @@ #include "SkDraw.h" #include "SkGlyphCache.h" #include "SkGr.h" -#include "SkImageCacherator.h" #include "SkImageFilter.h" #include "SkImageFilterCache.h" #include "SkImageInfoPriv.h" @@ -1382,9 +1381,9 @@ void SkGpuDevice::drawImage(const SkImage* image, SkScalar x, SkScalar y, return; } this->drawBitmap(bm, SkMatrix::MakeTrans(x, y), paint); - } else if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) { + } else if (image->isLazyGenerated()) { CHECK_SHOULD_DRAW(); - GrImageTextureMaker maker(fContext.get(), cacher, image, SkImage::kAllow_CachingHint); + GrImageTextureMaker maker(fContext.get(), image, SkImage::kAllow_CachingHint); this->drawTextureProducer(&maker, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint, viewMatrix, this->clip(), paint); } else if (as_IB(image)->getROPixels(&bm, fRenderTargetContext->getColorSpace())) { @@ -1418,9 +1417,9 @@ void SkGpuDevice::drawImageRect(const SkImage* image, const SkRect* src, return; } this->drawBitmapRect(bm, src, dst, paint, constraint); - } else if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) { + } else if (image->isLazyGenerated()) { CHECK_SHOULD_DRAW(); - GrImageTextureMaker maker(fContext.get(), cacher, image, SkImage::kAllow_CachingHint); + GrImageTextureMaker maker(fContext.get(), image, SkImage::kAllow_CachingHint); this->drawTextureProducer(&maker, src, &dst, constraint, this->ctm(), this->clip(), paint); } else if (as_IB(image)->getROPixels(&bm, fRenderTargetContext->getColorSpace())) { this->drawBitmapRect(bm, src, dst, paint, constraint); @@ -1482,8 +1481,8 @@ void SkGpuDevice::drawImageNine(const SkImage* image, this->drawProducerNine(&adjuster, center, dst, paint); } else { SkBitmap bm; - if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) { - GrImageTextureMaker maker(fContext.get(), cacher, image, SkImage::kAllow_CachingHint); + if (image->isLazyGenerated()) { + GrImageTextureMaker maker(fContext.get(), image, SkImage::kAllow_CachingHint); this->drawProducerNine(&maker, center, dst, paint); } else if (as_IB(image)->getROPixels(&bm, fRenderTargetContext->getColorSpace())) { this->drawBitmapNine(bm, center, dst, paint); @@ -1538,8 +1537,8 @@ void SkGpuDevice::drawImageLattice(const SkImage* image, this->drawProducerLattice(&adjuster, lattice, dst, paint); } else { SkBitmap bm; - if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) { - GrImageTextureMaker maker(fContext.get(), cacher, image, SkImage::kAllow_CachingHint); + if (image->isLazyGenerated()) { + GrImageTextureMaker maker(fContext.get(), image, SkImage::kAllow_CachingHint); this->drawProducerLattice(&maker, lattice, dst, paint); } else if (as_IB(image)->getROPixels(&bm, fRenderTargetContext->getColorSpace())) { this->drawBitmapLattice(bm, lattice, dst, paint); diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp index 7b7737dd74..d3b8a85f9b 100644 --- a/src/image/SkImage_Gpu.cpp +++ b/src/image/SkImage_Gpu.cpp @@ -457,8 +457,8 @@ sk_sp<SkImage> SkImage::makeTextureImage(GrContext* context, SkColorSpace* dstCo return peek->getContext() == context ? sk_ref_sp(const_cast<SkImage*>(this)) : nullptr; } - if (SkImageCacherator* cacher = as_IB(this)->peekCacherator()) { - GrImageTextureMaker maker(context, cacher, this, kDisallow_CachingHint); + if (this->isLazyGenerated()) { + GrImageTextureMaker maker(context, this, kDisallow_CachingHint); return create_image_from_maker(context, &maker, this->alphaType(), this->uniqueID(), dstColorSpace); } diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp index 99995d17aa..215f4c284c 100644 --- a/src/image/SkImage_Lazy.cpp +++ b/src/image/SkImage_Lazy.cpp @@ -6,24 +6,69 @@ */ #include "SkImage_Base.h" +#include "SkImageCacherator.h" + #include "SkBitmap.h" +#include "SkBitmapCache.h" +#include "SkColorSpace_Base.h" #include "SkData.h" -#include "SkImageCacherator.h" +#include "SkImageGenerator.h" #include "SkImagePriv.h" +#include "SkNextID.h" #include "SkPixelRef.h" -class SkImage_Lazy : public SkImage_Base { +#if SK_SUPPORT_GPU +#include "GrContext.h" +#include "GrContextPriv.h" +#include "GrGpuResourcePriv.h" +#include "GrImageTextureMaker.h" +#include "GrResourceKey.h" +#include "GrResourceProvider.h" +#include "GrSamplerParams.h" +#include "GrYUVProvider.h" +#include "SkGr.h" +#endif + +// Ref-counted tuple(SkImageGenerator, SkMutex) which allows sharing one generator among N images +class SharedGenerator final : public SkNVRefCnt<SharedGenerator> { public: - SkImage_Lazy(SkImageCacherator::Validator* validator) - : INHERITED(validator->fInfo.width(), validator->fInfo.height(), validator->fUniqueID) - , fCache(validator) - {} + static sk_sp<SharedGenerator> Make(std::unique_ptr<SkImageGenerator> gen) { + return gen ? sk_sp<SharedGenerator>(new SharedGenerator(std::move(gen))) : nullptr; + } - virtual SkImageInfo onImageInfo() const override { - return fCache.info(); +private: + explicit SharedGenerator(std::unique_ptr<SkImageGenerator> gen) + : fGenerator(std::move(gen)) { + SkASSERT(fGenerator); + } + + friend class ScopedGenerator; + friend class SkImage_Lazy; + + std::unique_ptr<SkImageGenerator> fGenerator; + SkMutex fMutex; +}; + +class SkImage_Lazy : public SkImage_Base, public SkImageCacherator { +public: + struct Validator { + Validator(sk_sp<SharedGenerator>, const SkIRect* subset); + + operator bool() const { return fSharedGenerator.get(); } + + sk_sp<SharedGenerator> fSharedGenerator; + SkImageInfo fInfo; + SkIPoint fOrigin; + uint32_t fUniqueID; + }; + + SkImage_Lazy(Validator* validator); + + SkImageInfo onImageInfo() const override { + return fInfo; } SkAlphaType onAlphaType() const override { - return fCache.info().alphaType(); + return fInfo.alphaType(); } bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY, @@ -33,35 +78,452 @@ public: SkColorSpace*, sk_sp<SkColorSpace>*, SkScalar scaleAdjust[2]) const override; #endif - SkImageCacherator* peekCacherator() const override { return &fCache; } SkData* onRefEncoded() const override; sk_sp<SkImage> onMakeSubset(const SkIRect&) const override; bool getROPixels(SkBitmap*, SkColorSpace* dstColorSpace, CachingHint) const override; bool onIsLazyGenerated() const override { return true; } sk_sp<SkImage> onMakeColorSpace(sk_sp<SkColorSpace>) const override; + SkImageCacherator* peekCacherator() const override { + return const_cast<SkImage_Lazy*>(this); + } + + // Only return true if the generate has already been cached. + bool lockAsBitmapOnlyIfAlreadyCached(SkBitmap*, CachedFormat) const; + // Call the underlying generator directly + bool directGeneratePixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB, + int srcX, int srcY, SkTransferFunctionBehavior behavior) const; + + // SkImageCacherator interface +#if SK_SUPPORT_GPU + // Returns the texture proxy. If the cacherator is generating the texture and wants to cache it, + // it should use the passed in key (if the key is valid). + sk_sp<GrTextureProxy> lockTextureProxy(GrContext*, + const GrUniqueKey& key, + SkImage::CachingHint, + bool willBeMipped, + SkColorSpace* dstColorSpace) override; + + // Returns the color space of the texture that would be returned if you called lockTexture. + // Separate code path to allow querying of the color space for textures that cached (even + // externally). + sk_sp<SkColorSpace> getColorSpace(GrContext*, SkColorSpace* dstColorSpace) override; + void makeCacheKeyFromOrigKey(const GrUniqueKey& origKey, CachedFormat, + GrUniqueKey* cacheKey) override; +#endif + + CachedFormat chooseCacheFormat(SkColorSpace* dstColorSpace, + const GrCaps* = nullptr) const override; + SkImageInfo buildCacheInfo(CachedFormat) const override; + private: - mutable SkImageCacherator fCache; + class ScopedGenerator; + + /** + * On success (true), bitmap will point to the pixels for this generator. If this returns + * false, the bitmap will be reset to empty. + */ + bool lockAsBitmap(SkBitmap*, SkImage::CachingHint, CachedFormat, const SkImageInfo&) const; + + sk_sp<SharedGenerator> fSharedGenerator; + const SkImageInfo fInfo; + const SkIPoint fOrigin; + + struct IDRec { + SkOnce fOnce; + uint32_t fUniqueID; + }; + mutable IDRec fIDRecs[kNumCachedFormats]; + + uint32_t getUniqueID(CachedFormat) const; typedef SkImage_Base INHERITED; }; /////////////////////////////////////////////////////////////////////////////// +SkImage_Lazy::Validator::Validator(sk_sp<SharedGenerator> gen, const SkIRect* subset) + : fSharedGenerator(std::move(gen)) { + + if (!fSharedGenerator) { + return; + } + + // The following generator accessors are safe without acquiring the mutex (const getters). + // TODO: refactor to use a ScopedGenerator instead, for clarity. + const SkImageInfo& info = fSharedGenerator->fGenerator->getInfo(); + if (info.isEmpty()) { + fSharedGenerator.reset(); + return; + } + + fUniqueID = fSharedGenerator->fGenerator->uniqueID(); + const SkIRect bounds = SkIRect::MakeWH(info.width(), info.height()); + if (subset) { + if (!bounds.contains(*subset)) { + fSharedGenerator.reset(); + return; + } + if (*subset != bounds) { + // we need a different uniqueID since we really are a subset of the raw generator + fUniqueID = SkNextID::ImageID(); + } + } else { + subset = &bounds; + } + + fInfo = info.makeWH(subset->width(), subset->height()); + fOrigin = SkIPoint::Make(subset->x(), subset->y()); + + // colortables are poorly to not-at-all supported in our resourcecache, so we + // bully them into N32 (the generator will perform the up-sample) + if (fInfo.colorType() == kIndex_8_SkColorType) { + fInfo = fInfo.makeColorType(kN32_SkColorType); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +// Helper for exclusive access to a shared generator. +class SkImage_Lazy::ScopedGenerator { +public: + ScopedGenerator(const sk_sp<SharedGenerator>& gen) + : fSharedGenerator(gen) + , fAutoAquire(gen->fMutex) {} + + SkImageGenerator* operator->() const { + fSharedGenerator->fMutex.assertHeld(); + return fSharedGenerator->fGenerator.get(); + } + + operator SkImageGenerator*() const { + fSharedGenerator->fMutex.assertHeld(); + return fSharedGenerator->fGenerator.get(); + } + +private: + const sk_sp<SharedGenerator>& fSharedGenerator; + SkAutoExclusive fAutoAquire; +}; + +/////////////////////////////////////////////////////////////////////////////// + +SkImage_Lazy::SkImage_Lazy(Validator* validator) + : INHERITED(validator->fInfo.width(), validator->fInfo.height(), validator->fUniqueID) + , fSharedGenerator(std::move(validator->fSharedGenerator)) + , fInfo(validator->fInfo) + , fOrigin(validator->fOrigin) { + SkASSERT(fSharedGenerator); + SkASSERT(kIndex_8_SkColorType != fInfo.colorType()); + // We explicit set the legacy format slot, but leave the others uninitialized (via SkOnce) + // and only resolove them to IDs as needed (by calling getUniqueID()). + fIDRecs[kLegacy_CachedFormat].fOnce([this, validator] { + fIDRecs[kLegacy_CachedFormat].fUniqueID = validator->fUniqueID; + }); +} + +uint32_t SkImage_Lazy::getUniqueID(CachedFormat format) const { + IDRec* rec = &fIDRecs[format]; + rec->fOnce([rec] { + rec->fUniqueID = SkNextID::ImageID(); + }); + return rec->fUniqueID; +} + +////////////////////////////////////////////////////////////////////////////////////////////////// + +// Abstraction of GrCaps that handles the cases where we don't have a caps pointer (because +// we're in raster mode), or where GPU support is entirely missing. In theory, we only need the +// chosen format to be texturable, but that lets us choose F16 on GLES implemenations where we +// won't be able to read the texture back. We'd like to ensure that SkImake::makeNonTextureImage +// works, so we require that the formats we choose are renderable (as a proxy for being readable). +struct CacheCaps { + CacheCaps(const GrCaps* caps) : fCaps(caps) {} + +#if SK_SUPPORT_GPU + bool supportsHalfFloat() const { + return !fCaps || + (fCaps->isConfigTexturable(kRGBA_half_GrPixelConfig) && + fCaps->isConfigRenderable(kRGBA_half_GrPixelConfig, false)); + } + + bool supportsSRGB() const { + return !fCaps || + (fCaps->srgbSupport() && fCaps->isConfigTexturable(kSRGBA_8888_GrPixelConfig)); + } + + bool supportsSBGR() const { + return !fCaps || fCaps->srgbSupport(); + } +#else + bool supportsHalfFloat() const { return true; } + bool supportsSRGB() const { return true; } + bool supportsSBGR() const { return true; } +#endif + + const GrCaps* fCaps; +}; + +SkImageCacherator::CachedFormat SkImage_Lazy::chooseCacheFormat(SkColorSpace* dstColorSpace, + const GrCaps* grCaps) const { + SkColorSpace* cs = fInfo.colorSpace(); + if (!cs || !dstColorSpace) { + return kLegacy_CachedFormat; + } + + CacheCaps caps(grCaps); + switch (fInfo.colorType()) { + case kUnknown_SkColorType: + case kAlpha_8_SkColorType: + case kRGB_565_SkColorType: + case kARGB_4444_SkColorType: + // We don't support color space on these formats, so always decode in legacy mode: + // TODO: Ask the codec to decode these to something else (at least sRGB 8888)? + return kLegacy_CachedFormat; + + case kIndex_8_SkColorType: + SkDEBUGFAIL("Index_8 should have been remapped at construction time."); + return kLegacy_CachedFormat; + + case kGray_8_SkColorType: + // TODO: What do we do with grayscale sources that have strange color spaces attached? + // The codecs and color space xform don't handle this correctly (yet), so drop it on + // the floor. (Also, inflating by a factor of 8 is going to be unfortunate). + // As it is, we don't directly support sRGB grayscale, so ask the codec to convert + // it for us. This bypasses some really sketchy code GrUploadPixmapToTexture. + if (cs->gammaCloseToSRGB() && caps.supportsSRGB()) { + return kSRGB8888_CachedFormat; + } else { + return kLegacy_CachedFormat; + } + + case kRGBA_8888_SkColorType: + if (cs->gammaCloseToSRGB()) { + if (caps.supportsSRGB()) { + return kSRGB8888_CachedFormat; + } else if (caps.supportsHalfFloat()) { + return kLinearF16_CachedFormat; + } else { + return kLegacy_CachedFormat; + } + } else { + if (caps.supportsHalfFloat()) { + return kLinearF16_CachedFormat; + } else if (caps.supportsSRGB()) { + return kSRGB8888_CachedFormat; + } else { + return kLegacy_CachedFormat; + } + } + + case kBGRA_8888_SkColorType: + // Odd case. sBGRA isn't a real thing, so we may not have this texturable. + if (caps.supportsSBGR()) { + if (cs->gammaCloseToSRGB()) { + return kSBGR8888_CachedFormat; + } else if (caps.supportsHalfFloat()) { + return kLinearF16_CachedFormat; + } else if (caps.supportsSRGB()) { + return kSRGB8888_CachedFormat; + } else { + // sBGRA support without sRGBA is highly unlikely (impossible?) Nevertheless. + return kLegacy_CachedFormat; + } + } else { + if (cs->gammaCloseToSRGB()) { + if (caps.supportsSRGB()) { + return kSRGB8888_CachedFormat; + } else if (caps.supportsHalfFloat()) { + return kLinearF16_CachedFormat; + } else { + return kLegacy_CachedFormat; + } + } else { + if (caps.supportsHalfFloat()) { + return kLinearF16_CachedFormat; + } else if (caps.supportsSRGB()) { + return kSRGB8888_CachedFormat; + } else { + return kLegacy_CachedFormat; + } + } + } + + case kRGBA_F16_SkColorType: + if (caps.supportsHalfFloat()) { + return kLinearF16_CachedFormat; + } else if (caps.supportsSRGB()) { + return kSRGB8888_CachedFormat; + } else { + return kLegacy_CachedFormat; + } + } + SkDEBUGFAIL("Unreachable"); + return kLegacy_CachedFormat; +} + +SkImageInfo SkImage_Lazy::buildCacheInfo(CachedFormat format) const { + switch (format) { + case kLegacy_CachedFormat: + return fInfo.makeColorSpace(nullptr); + case kLinearF16_CachedFormat: + return fInfo.makeColorType(kRGBA_F16_SkColorType) + .makeColorSpace(as_CSB(fInfo.colorSpace())->makeLinearGamma()); + case kSRGB8888_CachedFormat: + // If the transfer function is nearly (but not exactly) sRGB, we don't want the codec + // to bother trans-coding. It would be slow, and do more harm than good visually, + // so we make sure to leave the colorspace as-is. + if (fInfo.colorSpace()->gammaCloseToSRGB()) { + return fInfo.makeColorType(kRGBA_8888_SkColorType); + } else { + return fInfo.makeColorType(kRGBA_8888_SkColorType) + .makeColorSpace(as_CSB(fInfo.colorSpace())->makeSRGBGamma()); + } + case kSBGR8888_CachedFormat: + // See note above about not-quite-sRGB transfer functions. + if (fInfo.colorSpace()->gammaCloseToSRGB()) { + return fInfo.makeColorType(kBGRA_8888_SkColorType); + } else { + return fInfo.makeColorType(kBGRA_8888_SkColorType) + .makeColorSpace(as_CSB(fInfo.colorSpace())->makeSRGBGamma()); + } + default: + SkDEBUGFAIL("Invalid cached format"); + return fInfo; + } +} + +////////////////////////////////////////////////////////////////////////////////////////////////// + +static bool check_output_bitmap(const SkBitmap& bitmap, uint32_t expectedID) { + SkASSERT(bitmap.getGenerationID() == expectedID); + SkASSERT(bitmap.isImmutable()); + SkASSERT(bitmap.getPixels()); + return true; +} + +bool SkImage_Lazy::directGeneratePixels(const SkImageInfo& info, void* pixels, size_t rb, + int srcX, int srcY, + SkTransferFunctionBehavior behavior) const { + ScopedGenerator generator(fSharedGenerator); + const SkImageInfo& genInfo = generator->getInfo(); + // Currently generators do not natively handle subsets, so check that first. + if (srcX || srcY || genInfo.width() != info.width() || genInfo.height() != info.height()) { + return false; + } + + SkImageGenerator::Options opts; + opts.fBehavior = behavior; + return generator->getPixels(info, pixels, rb, &opts); +} + +////////////////////////////////////////////////////////////////////////////////////////////////// + +bool SkImage_Lazy::lockAsBitmapOnlyIfAlreadyCached(SkBitmap* bitmap, CachedFormat format) const { + uint32_t uniqueID = this->getUniqueID(format); + return SkBitmapCache::Find(SkBitmapCacheDesc::Make(uniqueID, + fInfo.width(), fInfo.height()), bitmap) && + check_output_bitmap(*bitmap, uniqueID); +} + +static bool generate_pixels(SkImageGenerator* gen, const SkPixmap& pmap, int originX, int originY) { + const int genW = gen->getInfo().width(); + const int genH = gen->getInfo().height(); + const SkIRect srcR = SkIRect::MakeWH(genW, genH); + const SkIRect dstR = SkIRect::MakeXYWH(originX, originY, pmap.width(), pmap.height()); + if (!srcR.contains(dstR)) { + return false; + } + + // If they are requesting a subset, we have to have a temp allocation for full image, and + // then copy the subset into their allocation + SkBitmap full; + SkPixmap fullPM; + const SkPixmap* dstPM = &pmap; + if (srcR != dstR) { + if (!full.tryAllocPixels(pmap.info().makeWH(genW, genH))) { + return false; + } + if (!full.peekPixels(&fullPM)) { + return false; + } + dstPM = &fullPM; + } + + if (!gen->getPixels(dstPM->info(), dstPM->writable_addr(), dstPM->rowBytes())) { + return false; + } + + if (srcR != dstR) { + if (!full.readPixels(pmap, originX, originY)) { + return false; + } + } + return true; +} + +bool SkImage_Lazy::lockAsBitmap(SkBitmap* bitmap, SkImage::CachingHint chint, + CachedFormat format, const SkImageInfo& info) const { + if (this->lockAsBitmapOnlyIfAlreadyCached(bitmap, format)) { + return true; + } + + uint32_t uniqueID = this->getUniqueID(format); + + SkBitmap tmpBitmap; + SkBitmapCache::RecPtr cacheRec; + SkPixmap pmap; + if (SkImage::kAllow_CachingHint == chint) { + auto desc = SkBitmapCacheDesc::Make(uniqueID, info.width(), info.height()); + cacheRec = SkBitmapCache::Alloc(desc, info, &pmap); + if (!cacheRec) { + return false; + } + } else { + if (!tmpBitmap.tryAllocPixels(info)) { + return false; + } + if (!tmpBitmap.peekPixels(&pmap)) { + return false; + } + } + + ScopedGenerator generator(fSharedGenerator); + if (!generate_pixels(generator, pmap, fOrigin.x(), fOrigin.y())) { + return false; + } + + if (cacheRec) { + SkBitmapCache::Add(std::move(cacheRec), bitmap); + SkASSERT(bitmap->getPixels()); // we're locked + SkASSERT(bitmap->isImmutable()); + SkASSERT(bitmap->getGenerationID() == uniqueID); + this->notifyAddedToCache(); + } else { + *bitmap = tmpBitmap; + bitmap->pixelRef()->setImmutableWithID(uniqueID); + } + + check_output_bitmap(*bitmap, uniqueID); + return true; +} + +////////////////////////////////////////////////////////////////////////////////////////////////// + bool SkImage_Lazy::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB, int srcX, int srcY, CachingHint chint) const { SkColorSpace* dstColorSpace = dstInfo.colorSpace(); SkBitmap bm; if (kDisallow_CachingHint == chint) { - SkImageCacherator::CachedFormat cacheFormat = fCache.chooseCacheFormat(dstColorSpace); - if (fCache.lockAsBitmapOnlyIfAlreadyCached(&bm, cacheFormat)) { + CachedFormat cacheFormat = this->chooseCacheFormat(dstColorSpace); + if (this->lockAsBitmapOnlyIfAlreadyCached(&bm, cacheFormat)) { return bm.readPixels(dstInfo, dstPixels, dstRB, srcX, srcY); } else { // Try passing the caller's buffer directly down to the generator. If this fails we // may still succeed in the general case, as the generator may prefer some other // config, which we could then convert via SkBitmap::readPixels. - if (fCache.directGeneratePixels(dstInfo, dstPixels, dstRB, srcX, srcY, - SkTransferFunctionBehavior::kRespect)) { + if (this->directGeneratePixels(dstInfo, dstPixels, dstRB, srcX, srcY, + SkTransferFunctionBehavior::kRespect)) { return true; } // else fall through @@ -75,39 +537,46 @@ bool SkImage_Lazy::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, siz } SkData* SkImage_Lazy::onRefEncoded() const { - return fCache.refEncoded(); + ScopedGenerator generator(fSharedGenerator); + return generator->refEncodedData(); } bool SkImage_Lazy::getROPixels(SkBitmap* bitmap, SkColorSpace* dstColorSpace, CachingHint chint) const { - SkImageCacherator::CachedFormat cacheFormat = fCache.chooseCacheFormat(dstColorSpace); - SkImageInfo cacheInfo = fCache.buildCacheInfo(cacheFormat); - return fCache.lockAsBitmap(bitmap, this, chint, cacheFormat, cacheInfo); + CachedFormat cacheFormat = this->chooseCacheFormat(dstColorSpace); + SkImageInfo cacheInfo = this->buildCacheInfo(cacheFormat); + return this->lockAsBitmap(bitmap, chint, cacheFormat, cacheInfo); } +/////////////////////////////////////////////////////////////////////////////////////////////////// + #if SK_SUPPORT_GPU sk_sp<GrTextureProxy> SkImage_Lazy::asTextureProxyRef(GrContext* context, const GrSamplerParams& params, SkColorSpace* dstColorSpace, sk_sp<SkColorSpace>* texColorSpace, SkScalar scaleAdjust[2]) const { - return fCache.lockAsTextureProxy(context, params, dstColorSpace, - texColorSpace, this, scaleAdjust); + if (!context) { + return nullptr; + } + + GrImageTextureMaker textureMaker(context, this, kAllow_CachingHint); + return textureMaker.refTextureProxyForParams(params, dstColorSpace, texColorSpace, scaleAdjust); } #endif sk_sp<SkImage> SkImage_Lazy::onMakeSubset(const SkIRect& subset) const { - SkASSERT(fCache.info().bounds().contains(subset)); - SkASSERT(fCache.info().bounds() != subset); + SkASSERT(fInfo.bounds().contains(subset)); + SkASSERT(fInfo.bounds() != subset); - const SkIRect generatorSubset = subset.makeOffset(fCache.fOrigin.x(), fCache.fOrigin.y()); - SkImageCacherator::Validator validator(fCache.fSharedGenerator, &generatorSubset); + const SkIRect generatorSubset = subset.makeOffset(fOrigin.x(), fOrigin.y()); + Validator validator(fSharedGenerator, &generatorSubset); return validator ? sk_sp<SkImage>(new SkImage_Lazy(&validator)) : nullptr; } sk_sp<SkImage> SkImage_Lazy::onMakeColorSpace(sk_sp<SkColorSpace> target) const { SkBitmap dst; - SkImageInfo dstInfo = fCache.info().makeColorSpace(target); + SkImageInfo dstInfo = fInfo.makeColorSpace(target); if (kIndex_8_SkColorType == dstInfo.colorType() || kGray_8_SkColorType == dstInfo.colorType() || kRGB_565_SkColorType == dstInfo.colorType()) { @@ -117,8 +586,8 @@ sk_sp<SkImage> SkImage_Lazy::onMakeColorSpace(sk_sp<SkColorSpace> target) const // Use kIgnore for transfer function behavior. This is used by the SkColorSpaceXformCanvas, // which wants to pre-xform the inputs but ignore the transfer function on blends. - if (!fCache.directGeneratePixels(dstInfo, dst.getPixels(), dst.rowBytes(), 0, 0, - SkTransferFunctionBehavior::kIgnore)) { + if (!this->directGeneratePixels(dstInfo, dst.getPixels(), dst.rowBytes(), 0, 0, + SkTransferFunctionBehavior::kIgnore)) { return nullptr; } @@ -128,8 +597,154 @@ sk_sp<SkImage> SkImage_Lazy::onMakeColorSpace(sk_sp<SkColorSpace> target) const sk_sp<SkImage> SkImage::MakeFromGenerator(std::unique_ptr<SkImageGenerator> generator, const SkIRect* subset) { - SkImageCacherator::Validator validator( - SkImageCacherator::SharedGenerator::Make(std::move(generator)), subset); + SkImage_Lazy::Validator validator(SharedGenerator::Make(std::move(generator)), subset); return validator ? sk_make_sp<SkImage_Lazy>(&validator) : nullptr; } + +////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Implementation of SkImageCacherator interface, as needed by GrImageTextureMaker + */ + +#if SK_SUPPORT_GPU + +void SkImage_Lazy::makeCacheKeyFromOrigKey(const GrUniqueKey& origKey, CachedFormat format, + GrUniqueKey* cacheKey) { + SkASSERT(!cacheKey->isValid()); + if (origKey.isValid()) { + static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain(); + GrUniqueKey::Builder builder(cacheKey, origKey, kDomain, 1); + builder[0] = format; + } +} + +class Generator_GrYUVProvider : public GrYUVProvider { + SkImageGenerator* fGen; + +public: + Generator_GrYUVProvider(SkImageGenerator* gen) : fGen(gen) {} + + uint32_t onGetID() override { return fGen->uniqueID(); } + bool onQueryYUV8(SkYUVSizeInfo* sizeInfo, SkYUVColorSpace* colorSpace) const override { + return fGen->queryYUV8(sizeInfo, colorSpace); + } + bool onGetYUV8Planes(const SkYUVSizeInfo& sizeInfo, void* planes[3]) override { + return fGen->getYUV8Planes(sizeInfo, planes); + } +}; + +static void set_key_on_proxy(GrResourceProvider* resourceProvider, + GrTextureProxy* proxy, const GrUniqueKey& key) { + if (key.isValid()) { + resourceProvider->assignUniqueKeyToProxy(key, proxy); + } +} + +sk_sp<SkColorSpace> SkImage_Lazy::getColorSpace(GrContext* ctx, SkColorSpace* dstColorSpace) { + // TODO: This isn't always correct. Picture generator currently produces textures in N32, + // and will (soon) emit them in an arbitrary (destination) space. We will need to stash that + // information in/on the key so we can return the correct space in case #1 of lockTexture. + CachedFormat format = this->chooseCacheFormat(dstColorSpace, ctx->caps()); + SkImageInfo cacheInfo = this->buildCacheInfo(format); + return sk_ref_sp(cacheInfo.colorSpace()); +} + +/* + * We have 4 ways to try to return a texture (in sorted order) + * + * 1. Check the cache for a pre-existing one + * 2. Ask the generator to natively create one + * 3. Ask the generator to return YUV planes, which the GPU can convert + * 4. Ask the generator to return RGB(A) data, which the GPU can convert + */ +sk_sp<GrTextureProxy> SkImage_Lazy::lockTextureProxy(GrContext* ctx, + const GrUniqueKey& origKey, + SkImage::CachingHint chint, + bool willBeMipped, + SkColorSpace* dstColorSpace) { + // Values representing the various texture lock paths we can take. Used for logging the path + // taken to a histogram. + enum LockTexturePath { + kFailure_LockTexturePath, + kPreExisting_LockTexturePath, + kNative_LockTexturePath, + kCompressed_LockTexturePath, // Deprecated + kYUV_LockTexturePath, + kRGBA_LockTexturePath, + }; + + enum { kLockTexturePathCount = kRGBA_LockTexturePath + 1 }; + + // Determine which cached format we're going to use (which may involve decoding to a different + // info than the generator provides). + CachedFormat format = this->chooseCacheFormat(dstColorSpace, ctx->caps()); + + // Fold the cache format into our texture key + GrUniqueKey key; + this->makeCacheKeyFromOrigKey(origKey, format, &key); + + // 1. Check the cache for a pre-existing one + if (key.isValid()) { + if (sk_sp<GrTextureProxy> proxy = ctx->resourceProvider()->findProxyByUniqueKey(key)) { + SK_HISTOGRAM_ENUMERATION("LockTexturePath", kPreExisting_LockTexturePath, + kLockTexturePathCount); + return proxy; + } + } + + // The CachedFormat is both an index for which cache "slot" we'll use to store this particular + // decoded variant of the encoded data, and also a recipe for how to transform the original + // info to get the one that we're going to decode to. + SkImageInfo cacheInfo = this->buildCacheInfo(format); + + // 2. Ask the generator to natively create one + { + ScopedGenerator generator(fSharedGenerator); + if (sk_sp<GrTextureProxy> proxy = generator->generateTexture(ctx, cacheInfo, fOrigin)) { + SK_HISTOGRAM_ENUMERATION("LockTexturePath", kNative_LockTexturePath, + kLockTexturePathCount); + set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key); + return proxy; + } + } + + // 3. Ask the generator to return YUV planes, which the GPU can convert + if (!ctx->contextPriv().disableGpuYUVConversion()) { + const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(cacheInfo, *ctx->caps()); + ScopedGenerator generator(fSharedGenerator); + Generator_GrYUVProvider provider(generator); + if (sk_sp<GrTextureProxy> proxy = provider.refAsTextureProxy(ctx, desc, true)) { + SK_HISTOGRAM_ENUMERATION("LockTexturePath", kYUV_LockTexturePath, + kLockTexturePathCount); + set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key); + return proxy; + } + } + + // 4. Ask the generator to return RGB(A) data, which the GPU can convert + SkBitmap bitmap; + if (this->lockAsBitmap(&bitmap, chint, format, cacheInfo)) { + sk_sp<GrTextureProxy> proxy; + if (willBeMipped) { + proxy = GrGenerateMipMapsAndUploadToTextureProxy(ctx, bitmap, dstColorSpace); + } + if (!proxy) { + proxy = GrUploadBitmapToTextureProxy(ctx->resourceProvider(), bitmap); + } + if (proxy) { + SK_HISTOGRAM_ENUMERATION("LockTexturePath", kRGBA_LockTexturePath, + kLockTexturePathCount); + set_key_on_proxy(ctx->resourceProvider(), proxy.get(), key); + return proxy; + } + } + SK_HISTOGRAM_ENUMERATION("LockTexturePath", kFailure_LockTexturePath, + kLockTexturePathCount); + return nullptr; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#endif |