| /* |
| * Copyright 2018 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/gpu/ganesh/image/SkImage_GaneshBase.h" |
| |
| #include "include/core/SkAlphaType.h" |
| #include "include/core/SkBitmap.h" |
| #include "include/core/SkColorSpace.h" |
| #include "include/core/SkColorType.h" |
| #include "include/core/SkImage.h" |
| #include "include/core/SkImageInfo.h" |
| #include "include/core/SkPixmap.h" |
| #include "include/core/SkRect.h" |
| #include "include/core/SkSize.h" |
| #include "include/core/SkTypes.h" |
| #include "include/gpu/GpuTypes.h" |
| #include "include/gpu/GrBackendSurface.h" |
| #include "include/gpu/GrDirectContext.h" |
| #include "include/gpu/GrRecordingContext.h" |
| #include "include/gpu/GrTypes.h" |
| #include "include/gpu/ganesh/SkImageGanesh.h" |
| #include "include/private/chromium/GrPromiseImageTexture.h" |
| #include "include/private/chromium/SkImageChromium.h" |
| #include "include/private/gpu/ganesh/GrTypesPriv.h" |
| #include "src/core/SkBitmapCache.h" |
| #include "src/core/SkColorSpacePriv.h" |
| #include "src/core/SkImageFilterTypes.h" |
| #include "src/core/SkImageFilter_Base.h" |
| #include "src/core/SkImageInfoPriv.h" |
| #include "src/gpu/RefCntedCallback.h" |
| #include "src/gpu/SkBackingFit.h" |
| #include "src/gpu/ganesh/GrCaps.h" |
| #include "src/gpu/ganesh/GrColorInfo.h" |
| #include "src/gpu/ganesh/GrDirectContextPriv.h" |
| #include "src/gpu/ganesh/GrImageContextPriv.h" |
| #include "src/gpu/ganesh/GrProxyProvider.h" |
| #include "src/gpu/ganesh/GrResourceCache.h" |
| #include "src/gpu/ganesh/GrResourceProvider.h" |
| #include "src/gpu/ganesh/GrSurface.h" |
| #include "src/gpu/ganesh/GrSurfaceProxy.h" |
| #include "src/gpu/ganesh/GrSurfaceProxyView.h" |
| #include "src/gpu/ganesh/GrTexture.h" |
| #include "src/gpu/ganesh/GrTextureProxy.h" |
| #include "src/gpu/ganesh/SurfaceContext.h" |
| #include "src/gpu/ganesh/image/GrImageUtils.h" |
| #include "src/gpu/ganesh/image/SkImage_Ganesh.h" |
| #include "src/image/SkImage_Base.h" |
| |
| #include <functional> |
| #include <memory> |
| #include <utility> |
| |
| class GrContextThreadSafeProxy; |
| class SkImageFilter; |
| struct SkIPoint; |
| |
| SkImage_GaneshBase::SkImage_GaneshBase(sk_sp<GrImageContext> context, |
| SkImageInfo info, |
| uint32_t uniqueID) |
| : SkImage_Base(std::move(info), uniqueID), fContext(std::move(context)) {} |
| |
| ////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| bool SkImage_GaneshBase::ValidateBackendTexture(const GrCaps* caps, |
| const GrBackendTexture& tex, |
| GrColorType grCT, |
| SkColorType ct, |
| SkAlphaType at, |
| sk_sp<SkColorSpace> cs) { |
| if (!tex.isValid()) { |
| return false; |
| } |
| SkColorInfo info(ct, at, cs); |
| if (!SkColorInfoIsValid(info)) { |
| return false; |
| } |
| GrBackendFormat backendFormat = tex.getBackendFormat(); |
| if (!backendFormat.isValid()) { |
| return false; |
| } |
| |
| return caps->areColorTypeAndFormatCompatible(grCT, backendFormat); |
| } |
| |
| bool SkImage_GaneshBase::ValidateCompressedBackendTexture(const GrCaps* caps, |
| const GrBackendTexture& tex, |
| SkAlphaType at) { |
| if (!tex.isValid() || tex.width() <= 0 || tex.height() <= 0) { |
| return false; |
| } |
| |
| if (tex.width() > caps->maxTextureSize() || tex.height() > caps->maxTextureSize()) { |
| return false; |
| } |
| |
| if (at == kUnknown_SkAlphaType) { |
| return false; |
| } |
| |
| GrBackendFormat backendFormat = tex.getBackendFormat(); |
| if (!backendFormat.isValid()) { |
| return false; |
| } |
| |
| if (!caps->isFormatCompressed(backendFormat)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| bool SkImage_GaneshBase::getROPixels(GrDirectContext* dContext, |
| SkBitmap* dst, |
| CachingHint chint) const { |
| if (!fContext->priv().matches(dContext)) { |
| return false; |
| } |
| |
| const auto desc = SkBitmapCacheDesc::Make(this); |
| if (SkBitmapCache::Find(desc, dst)) { |
| SkASSERT(dst->isImmutable()); |
| SkASSERT(dst->getPixels()); |
| return true; |
| } |
| |
| SkBitmapCache::RecPtr rec = nullptr; |
| SkPixmap pmap; |
| if (kAllow_CachingHint == chint) { |
| rec = SkBitmapCache::Alloc(desc, this->imageInfo(), &pmap); |
| if (!rec) { |
| return false; |
| } |
| } else { |
| if (!dst->tryAllocPixels(this->imageInfo()) || !dst->peekPixels(&pmap)) { |
| return false; |
| } |
| } |
| |
| auto [view, ct] = skgpu::ganesh::AsView(dContext, this, skgpu::Mipmapped::kNo); |
| if (!view) { |
| return false; |
| } |
| |
| GrColorInfo colorInfo(ct, this->alphaType(), this->refColorSpace()); |
| auto sContext = dContext->priv().makeSC(std::move(view), std::move(colorInfo)); |
| if (!sContext) { |
| return false; |
| } |
| |
| if (!sContext->readPixels(dContext, pmap, {0, 0})) { |
| return false; |
| } |
| |
| if (rec) { |
| SkBitmapCache::Add(std::move(rec), dst); |
| this->notifyAddedToRasterCache(); |
| } |
| return true; |
| } |
| |
| sk_sp<SkImage> SkImage_GaneshBase::makeSubset(GrDirectContext* direct, |
| const SkIRect& subset) const { |
| if (!fContext->priv().matches(direct)) { |
| return nullptr; |
| } |
| |
| if (subset.isEmpty()) { |
| return nullptr; |
| } |
| |
| const SkIRect bounds = SkIRect::MakeWH(this->width(), this->height()); |
| if (!bounds.contains(subset)) { |
| return nullptr; |
| } |
| |
| // optimization : return self if the subset == our bounds |
| if (bounds == subset) { |
| return sk_ref_sp(const_cast<SkImage_GaneshBase*>(this)); |
| } |
| |
| return this->onMakeSubset(direct, subset); |
| } |
| |
| sk_sp<SkImage> SkImage_GaneshBase::onMakeSubset(GrDirectContext* direct, |
| const SkIRect& subset) const { |
| if (!fContext->priv().matches(direct)) { |
| return nullptr; |
| } |
| auto [view, ct] = skgpu::ganesh::AsView(direct, this, skgpu::Mipmapped::kNo); |
| SkASSERT(view); |
| SkASSERT(ct == SkColorTypeToGrColorType(this->colorType())); |
| |
| skgpu::Budgeted isBudgeted = view.proxy()->isBudgeted(); |
| auto copyView = GrSurfaceProxyView::Copy(direct, |
| std::move(view), |
| skgpu::Mipmapped::kNo, |
| subset, |
| SkBackingFit::kExact, |
| isBudgeted, |
| /*label=*/"ImageGpuBase_MakeSubset"); |
| |
| if (!copyView) { |
| return nullptr; |
| } |
| |
| return sk_make_sp<SkImage_Ganesh>(sk_ref_sp(direct), |
| kNeedNewImageUniqueID, |
| std::move(copyView), |
| this->imageInfo().colorInfo()); |
| } |
| |
| sk_sp<SkImage> SkImage_GaneshBase::onMakeSubset(skgpu::graphite::Recorder*, |
| const SkIRect&, |
| RequiredProperties) const { |
| SkDEBUGFAIL("Cannot convert Ganesh-backed image to Graphite"); |
| return nullptr; |
| } |
| |
| sk_sp<SkImage> SkImage_GaneshBase::makeColorTypeAndColorSpace(skgpu::graphite::Recorder*, |
| SkColorType, |
| sk_sp<SkColorSpace>, |
| RequiredProperties) const { |
| SkDEBUGFAIL("Cannot convert Ganesh-backed image to Graphite"); |
| return nullptr; |
| } |
| |
| bool SkImage_GaneshBase::onReadPixels(GrDirectContext* dContext, |
| const SkImageInfo& dstInfo, |
| void* dstPixels, |
| size_t dstRB, |
| int srcX, |
| int srcY, |
| CachingHint) const { |
| if (!fContext->priv().matches(dContext) || |
| !SkImageInfoValidConversion(dstInfo, this->imageInfo())) { |
| return false; |
| } |
| |
| auto [view, ct] = skgpu::ganesh::AsView(dContext, this, skgpu::Mipmapped::kNo); |
| SkASSERT(view); |
| |
| GrColorInfo colorInfo(ct, this->alphaType(), this->refColorSpace()); |
| auto sContext = dContext->priv().makeSC(std::move(view), colorInfo); |
| if (!sContext) { |
| return false; |
| } |
| |
| return sContext->readPixels(dContext, {dstInfo, dstPixels, dstRB}, {srcX, srcY}); |
| } |
| |
| bool SkImage_GaneshBase::isValid(GrRecordingContext* context) const { |
| if (context && context->abandoned()) { |
| return false; |
| } |
| if (fContext->priv().abandoned()) { |
| return false; |
| } |
| if (context && !fContext->priv().matches(context)) { |
| return false; |
| } |
| return true; |
| } |
| |
| sk_sp<SkImage> SkImage_GaneshBase::makeColorTypeAndColorSpace(GrDirectContext* dContext, |
| SkColorType targetColorType, |
| sk_sp<SkColorSpace> targetCS) const { |
| if (kUnknown_SkColorType == targetColorType || !targetCS) { |
| return nullptr; |
| } |
| |
| auto myContext = this->context(); |
| // This check is also performed in the subclass, but we do it here for the short-circuit below. |
| if (!myContext || !myContext->priv().matches(dContext)) { |
| return nullptr; |
| } |
| |
| SkColorType colorType = this->colorType(); |
| SkColorSpace* colorSpace = this->colorSpace(); |
| if (!colorSpace) { |
| colorSpace = sk_srgb_singleton(); |
| } |
| if (colorType == targetColorType && |
| (SkColorSpace::Equals(colorSpace, targetCS.get()) || this->isAlphaOnly())) { |
| return sk_ref_sp(const_cast<SkImage_GaneshBase*>(this)); |
| } |
| |
| return this->onMakeColorTypeAndColorSpace(targetColorType, std::move(targetCS), dContext); |
| } |
| |
| sk_sp<GrTextureProxy> SkImage_GaneshBase::MakePromiseImageLazyProxy( |
| GrContextThreadSafeProxy* tsp, |
| SkISize dimensions, |
| const GrBackendFormat& backendFormat, |
| skgpu::Mipmapped mipmapped, |
| SkImages::PromiseImageTextureFulfillProc fulfillProc, |
| sk_sp<skgpu::RefCntedCallback> releaseHelper) { |
| SkASSERT(tsp); |
| SkASSERT(!dimensions.isEmpty()); |
| SkASSERT(releaseHelper); |
| |
| if (!fulfillProc) { |
| return nullptr; |
| } |
| |
| if (mipmapped == skgpu::Mipmapped::kYes && |
| GrTextureTypeHasRestrictedSampling(backendFormat.textureType())) { |
| // It is invalid to have a GL_TEXTURE_EXTERNAL or GL_TEXTURE_RECTANGLE and have mips as |
| // well. |
| return nullptr; |
| } |
| |
| /** |
| * This class is the lazy instantiation callback for promise images. It manages calling the |
| * client's Fulfill and Release procs. It attempts to reuse a GrTexture instance in |
| * cases where the client provides the same GrPromiseImageTexture as Fulfill results for |
| * multiple SkImages. The created GrTexture is given a key based on a unique ID associated with |
| * the GrPromiseImageTexture. |
| * |
| * A key invalidation message is installed on the GrPromiseImageTexture so that the GrTexture |
| * is deleted once it can no longer be used to instantiate a proxy. |
| */ |
| class PromiseLazyInstantiateCallback { |
| public: |
| PromiseLazyInstantiateCallback(SkImages::PromiseImageTextureFulfillProc fulfillProc, |
| sk_sp<skgpu::RefCntedCallback> releaseHelper) |
| : fFulfillProc(fulfillProc), fReleaseHelper(std::move(releaseHelper)) {} |
| PromiseLazyInstantiateCallback(PromiseLazyInstantiateCallback&&) = default; |
| PromiseLazyInstantiateCallback(const PromiseLazyInstantiateCallback&) { |
| // Because we get wrapped in std::function we must be copyable. But we should never |
| // be copied. |
| SkASSERT(false); |
| } |
| PromiseLazyInstantiateCallback& operator=(PromiseLazyInstantiateCallback&&) = default; |
| PromiseLazyInstantiateCallback& operator=(const PromiseLazyInstantiateCallback&) { |
| SkASSERT(false); |
| return *this; |
| } |
| |
| ~PromiseLazyInstantiateCallback() { |
| // Our destructor can run on any thread. We trigger the unref of fTexture by message. |
| if (fTexture) { |
| GrResourceCache::ReturnResourceFromThread(std::move(fTexture), fTextureContextID); |
| } |
| } |
| |
| GrSurfaceProxy::LazyCallbackResult operator()(GrResourceProvider* resourceProvider, |
| const GrSurfaceProxy::LazySurfaceDesc&) { |
| // We use the unique key in a way that is unrelated to the SkImage-based key that the |
| // proxy may receive, hence kUnsynced. |
| static constexpr auto kKeySyncMode = |
| GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced; |
| |
| // In order to make the SkImage "thread safe" we rely on holding an extra ref to the |
| // texture in the callback and signalling the unref via a message to the resource cache. |
| // We need to extend the callback's lifetime to that of the proxy. |
| static constexpr auto kReleaseCallbackOnInstantiation = false; |
| |
| // Our proxy is getting instantiated for the second+ time. We are only allowed to call |
| // Fulfill once. So return our cached result. |
| if (fTexture) { |
| return {fTexture, kReleaseCallbackOnInstantiation, kKeySyncMode}; |
| } else if (fFulfillProcFailed) { |
| // We've already called fulfill and it failed. Our contract says that we should only |
| // call each callback once. |
| return {}; |
| } |
| |
| SkImages::PromiseImageTextureContext textureContext = fReleaseHelper->context(); |
| sk_sp<GrPromiseImageTexture> promiseTexture = fFulfillProc(textureContext); |
| |
| if (!promiseTexture) { |
| fFulfillProcFailed = true; |
| return {}; |
| } |
| |
| const GrBackendTexture& backendTexture = promiseTexture->backendTexture(); |
| if (!backendTexture.isValid()) { |
| return {}; |
| } |
| |
| fTexture = resourceProvider->wrapBackendTexture( |
| backendTexture, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType); |
| if (!fTexture) { |
| return {}; |
| } |
| fTexture->setRelease(fReleaseHelper); |
| auto dContext = fTexture->getContext(); |
| fTextureContextID = dContext->directContextID(); |
| return {fTexture, kReleaseCallbackOnInstantiation, kKeySyncMode}; |
| } |
| |
| private: |
| SkImages::PromiseImageTextureFulfillProc fFulfillProc; |
| sk_sp<skgpu::RefCntedCallback> fReleaseHelper; |
| sk_sp<GrTexture> fTexture; |
| GrDirectContext::DirectContextID fTextureContextID; |
| bool fFulfillProcFailed = false; |
| } callback(fulfillProc, std::move(releaseHelper)); |
| |
| return GrProxyProvider::CreatePromiseProxy( |
| tsp, std::move(callback), backendFormat, dimensions, mipmapped); |
| } |
| |
| namespace SkImages { |
| sk_sp<SkImage> SubsetTextureFrom(GrDirectContext* context, |
| const SkImage* img, |
| const SkIRect& subset) { |
| if (context == nullptr || img == nullptr) { |
| return nullptr; |
| } |
| auto subsetImg = img->makeSubset(context, subset); |
| return SkImages::TextureFromImage(context, subsetImg.get()); |
| } |
| |
| sk_sp<SkImage> MakeWithFilter(GrRecordingContext* rContext, |
| sk_sp<SkImage> src, |
| const SkImageFilter* filter, |
| const SkIRect& subset, |
| const SkIRect& clipBounds, |
| SkIRect* outSubset, |
| SkIPoint* offset) { |
| if (!rContext || !src || !filter) { |
| return nullptr; |
| } |
| |
| GrSurfaceOrigin origin = kTopLeft_GrSurfaceOrigin; |
| if (as_IB(src)->isGaneshBacked()) { |
| SkImage_GaneshBase* base = static_cast<SkImage_GaneshBase*>(src.get()); |
| origin = base->origin(); |
| } |
| |
| sk_sp<skif::Backend> backend = |
| skif::MakeGaneshBackend(sk_ref_sp(rContext), origin, {}, src->colorType()); |
| return as_IFB(filter)->makeImageWithFilter(std::move(backend), |
| std::move(src), |
| subset, |
| clipBounds, |
| outSubset, |
| offset); |
| } |
| |
| GrDirectContext* GetContext(const SkImage* src) { |
| if (!src || !as_IB(src)->isGaneshBacked()) { |
| return nullptr; |
| } |
| return as_IB(src)->directContext(); |
| } |
| |
| |
| } // namespace SkImages |