SkImage_GaneshBase Class Reference

#include <SkImage_GaneshBase.h>

Inheritance diagram for SkImage_GaneshBase:

Public Member Functions
bool	isValid (GrRecordingContext *) const final
sk_sp< SkImage >	makeColorTypeAndColorSpace (GrDirectContext *dContext, SkColorType targetColorType, sk_sp< SkColorSpace > targetCS) const final
sk_sp< SkImage >	makeSubset (GrDirectContext *direct, const SkIRect &subset) const final
GrImageContext *	context () const final
GrDirectContext *	directContext () const final
bool	getROPixels (GrDirectContext *, SkBitmap *, CachingHint) const final
sk_sp< SkImage >	onMakeSubset (GrDirectContext *, const SkIRect &subset) const final
bool	onReadPixels (GrDirectContext *dContext, const SkImageInfo &dstInfo, void *dstPixels, size_t dstRB, int srcX, int srcY, CachingHint) const override
virtual GrSemaphoresSubmitted	flush (GrDirectContext *, const GrFlushInfo &) const =0
virtual std::tuple< GrSurfaceProxyView, GrColorType >	asView (GrRecordingContext *, skgpu::Mipmapped, GrImageTexGenPolicy) const =0
virtual std::unique_ptr< GrFragmentProcessor >	asFragmentProcessor (GrRecordingContext *, SkSamplingOptions, const SkTileMode[2], const SkMatrix &, const SkRect *, const SkRect *) const =0
virtual GrSurfaceOrigin	origin () const =0
Public Member Functions inherited from SkImage_Base
	~SkImage_Base () override
sk_sp< SkImage >	makeColorSpace (GrDirectContext *, sk_sp< SkColorSpace >) const override
sk_sp< SkImage >	makeColorSpace (skgpu::graphite::Recorder *, sk_sp< SkColorSpace >, RequiredProperties) const override
sk_sp< SkImage >	makeColorTypeAndColorSpace (GrDirectContext *dContext, SkColorType targetColorType, sk_sp< SkColorSpace > targetCS) const override
sk_sp< SkImage >	makeColorTypeAndColorSpace (skgpu::graphite::Recorder *, SkColorType, sk_sp< SkColorSpace >, RequiredProperties) const override
sk_sp< SkImage >	makeSubset (GrDirectContext *direct, const SkIRect &subset) const override
sk_sp< SkImage >	makeSubset (skgpu::graphite::Recorder *, const SkIRect &, RequiredProperties) const override
size_t	textureSize () const override
virtual bool	onPeekPixels (SkPixmap *) const
virtual const SkBitmap *	onPeekBitmap () const
virtual bool	onReadPixels (GrDirectContext *, const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint) const =0
virtual bool	onHasMipmaps () const =0
virtual bool	onIsProtected () const =0
virtual SkMipmap *	onPeekMips () const
sk_sp< SkMipmap >	refMips () const
virtual void	onAsyncRescaleAndReadPixels (const SkImageInfo &, SkIRect srcRect, RescaleGamma, RescaleMode, ReadPixelsCallback, ReadPixelsContext) const
virtual void	onAsyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace, bool readAlpha, sk_sp< SkColorSpace > dstColorSpace, SkIRect srcRect, SkISize dstSize, RescaleGamma, RescaleMode, ReadPixelsCallback, ReadPixelsContext) const
virtual GrImageContext *	context () const
virtual GrDirectContext *	directContext () const
virtual void	generatingSurfaceIsDeleted ()
virtual bool	getROPixels (GrDirectContext *, SkBitmap *, CachingHint=kAllow_CachingHint) const =0
virtual sk_sp< SkImage >	onMakeSubset (GrDirectContext *, const SkIRect &) const =0
virtual sk_sp< SkData >	onRefEncoded () const
virtual bool	onAsLegacyBitmap (GrDirectContext *, SkBitmap *) const
virtual Type	type () const =0
bool	isLazyGenerated () const override
bool	isRasterBacked () const
bool	isGaneshBacked () const
bool	isGraphiteBacked () const
bool	isYUVA () const
bool	isTextureBacked () const override
virtual void	notifyAddedToRasterCache () const
virtual sk_sp< SkImage >	onMakeColorTypeAndColorSpace (SkColorType, sk_sp< SkColorSpace >, GrDirectContext *) const =0
virtual sk_sp< SkImage >	onReinterpretColorSpace (sk_sp< SkColorSpace >) const =0
virtual sk_sp< SkImage >	onMakeWithMipmaps (sk_sp< SkMipmap >) const
virtual sk_sp< SkImage >	onMakeSubset (skgpu::graphite::Recorder *, const SkIRect &, RequiredProperties) const =0
Public Member Functions inherited from SkImage
const SkImageInfo &	imageInfo () const
int	width () const
int	height () const
SkISize	dimensions () const
SkIRect	bounds () const
uint32_t	uniqueID () const
SkAlphaType	alphaType () const
SkColorType	colorType () const
SkColorSpace *	colorSpace () const
sk_sp< SkColorSpace >	refColorSpace () const
bool	isAlphaOnly () const
bool	isOpaque () const
sk_sp< SkShader >	makeShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &, const SkMatrix *localMatrix=nullptr) const
sk_sp< SkShader >	makeShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &sampling, const SkMatrix &lm) const
sk_sp< SkShader >	makeShader (const SkSamplingOptions &sampling, const SkMatrix &lm) const
sk_sp< SkShader >	makeShader (const SkSamplingOptions &sampling, const SkMatrix *lm=nullptr) const
sk_sp< SkShader >	makeRawShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &, const SkMatrix *localMatrix=nullptr) const
sk_sp< SkShader >	makeRawShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &sampling, const SkMatrix &lm) const
sk_sp< SkShader >	makeRawShader (const SkSamplingOptions &sampling, const SkMatrix &lm) const
sk_sp< SkShader >	makeRawShader (const SkSamplingOptions &sampling, const SkMatrix *lm=nullptr) const
bool	peekPixels (SkPixmap *pixmap) const
virtual bool	isTextureBacked () const =0
virtual size_t	textureSize () const =0
virtual bool	isValid (GrRecordingContext *context) const =0
bool	readPixels (GrDirectContext *context, const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const
bool	readPixels (GrDirectContext *context, const SkPixmap &dst, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const
bool	readPixels (const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const
bool	readPixels (const SkPixmap &dst, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const
void	asyncRescaleAndReadPixels (const SkImageInfo &info, const SkIRect &srcRect, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const
void	asyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const
void	asyncRescaleAndReadPixelsYUVA420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const
bool	scalePixels (const SkPixmap &dst, const SkSamplingOptions &, CachingHint cachingHint=kAllow_CachingHint) const
sk_sp< SkData >	refEncodedData () const
virtual sk_sp< SkImage >	makeSubset (GrDirectContext *direct, const SkIRect &subset) const =0
virtual sk_sp< SkImage >	makeSubset (skgpu::graphite::Recorder *, const SkIRect &subset, RequiredProperties) const =0
bool	hasMipmaps () const
bool	isProtected () const
sk_sp< SkImage >	withDefaultMipmaps () const
sk_sp< SkImage >	makeNonTextureImage (GrDirectContext *=nullptr) const
sk_sp< SkImage >	makeRasterImage (GrDirectContext *, CachingHint cachingHint=kDisallow_CachingHint) const
sk_sp< SkImage >	makeRasterImage (CachingHint cachingHint=kDisallow_CachingHint) const
bool	asLegacyBitmap (SkBitmap *bitmap, LegacyBitmapMode legacyBitmapMode=kRO_LegacyBitmapMode) const
virtual bool	isLazyGenerated () const =0
virtual sk_sp< SkImage >	makeColorSpace (GrDirectContext *direct, sk_sp< SkColorSpace > target) const =0
virtual sk_sp< SkImage >	makeColorSpace (skgpu::graphite::Recorder *, sk_sp< SkColorSpace > targetColorSpace, RequiredProperties) const =0
virtual sk_sp< SkImage >	makeColorTypeAndColorSpace (GrDirectContext *direct, SkColorType targetColorType, sk_sp< SkColorSpace > targetCS) const =0
virtual sk_sp< SkImage >	makeColorTypeAndColorSpace (skgpu::graphite::Recorder *, SkColorType targetColorType, sk_sp< SkColorSpace > targetColorSpace, RequiredProperties) const =0
sk_sp< SkImage >	reinterpretColorSpace (sk_sp< SkColorSpace > newColorSpace) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static bool	ValidateBackendTexture (const GrCaps *, const GrBackendTexture &tex, GrColorType grCT, SkColorType ct, SkAlphaType at, sk_sp< SkColorSpace > cs)
static bool	ValidateCompressedBackendTexture (const GrCaps *, const GrBackendTexture &tex, SkAlphaType)
static sk_sp< GrTextureProxy >	MakePromiseImageLazyProxy (GrContextThreadSafeProxy *, SkISize dimensions, const GrBackendFormat &, skgpu::Mipmapped, SkImages::PromiseImageTextureFulfillProc, sk_sp< skgpu::RefCntedCallback > releaseHelper)

Protected Member Functions
	SkImage_GaneshBase (sk_sp< GrImageContext >, SkImageInfo, uint32_t uniqueID)
sk_sp< SkImage >	onMakeSubset (skgpu::graphite::Recorder *, const SkIRect &subset, RequiredProperties) const final
sk_sp< SkImage >	makeColorTypeAndColorSpace (skgpu::graphite::Recorder *, SkColorType, sk_sp< SkColorSpace >, RequiredProperties) const final
virtual sk_sp< SkImage >	onMakeColorTypeAndColorSpace (SkColorType, sk_sp< SkColorSpace >, GrDirectContext *) const=0
Protected Member Functions inherited from SkImage_Base
	SkImage_Base (const SkImageInfo &info, uint32_t uniqueID)

Protected Attributes
sk_sp< GrImageContext >	fContext

Additional Inherited Members
Public Types inherited from SkImage_Base
enum class	Type {   kRaster , kRasterPinnable , kLazy , kLazyPicture ,   kGanesh , kGaneshYUVA , kGraphite , kGraphiteYUVA }
Public Types inherited from SkImage
enum	CachingHint { kAllow_CachingHint , kDisallow_CachingHint }
enum class	RescaleGamma : bool { kSrc , kLinear }
enum class	RescaleMode { kNearest , kLinear , kRepeatedLinear , kRepeatedCubic }
enum	LegacyBitmapMode { kRO_LegacyBitmapMode }
using	ReadPixelsContext = void *
using	ReadPixelsCallback = void(ReadPixelsContext, std::unique_ptr< const AsyncReadResult >)

Detailed Description

Definition at line 54 of file SkImage_GaneshBase.h.

Constructor & Destructor Documentation

SkImage_GaneshBase()

SkImage_GaneshBase::SkImage_GaneshBase ( sk_sp< GrImageContext >  context, SkImageInfo  info, uint32_t  uniqueID  )

protected

Definition at line 61 of file SkImage_GaneshBase.cpp.

        : SkImage_Base(std::move(info), uniqueID), fContext(std::move(context)) {}

Member Function Documentation

asFragmentProcessor()

virtual std::unique_ptr< GrFragmentProcessor > SkImage_GaneshBase::asFragmentProcessor ( GrRecordingContext *  , SkSamplingOptions  , const  SkTileMode[2], const SkMatrix &  , const SkRect *  , const SkRect *    ) const

pure virtual

Implemented in SkImage_Ganesh, and SkImage_GaneshYUVA.

asView()

virtual std::tuple< GrSurfaceProxyView, GrColorType > SkImage_GaneshBase::asView ( GrRecordingContext *  , skgpu::Mipmapped  , GrImageTexGenPolicy    ) const

pure virtual

Implemented in SkImage_Ganesh, and SkImage_GaneshYUVA.

context()

GrImageContext * SkImage_GaneshBase::context ( ) const

inlinefinalvirtual

Reimplemented from SkImage_Base.

Definition at line 64 of file SkImage_GaneshBase.h.

{ return fContext.get(); }

directContext()

GrDirectContext * SkImage_GaneshBase::directContext ( ) const

inlinefinalvirtual

this->context() try-casted to GrDirectContext. Useful for migrations – avoid otherwise!

Reimplemented from SkImage_Base.

Definition at line 65 of file SkImage_GaneshBase.h.

{ return GrAsDirectContext(this->context()); }

flush()

virtual GrSemaphoresSubmitted SkImage_GaneshBase::flush ( GrDirectContext *  , const GrFlushInfo &    ) const

pure virtual

Implemented in SkImage_Ganesh, and SkImage_GaneshYUVA.

getROPixels()

bool SkImage_GaneshBase::getROPixels ( GrDirectContext *  dContext, SkBitmap *  dst, CachingHint  chint  ) const

finalvirtual

Implements SkImage_Base.

Definition at line 118 of file SkImage_GaneshBase.cpp.

                                                              {
    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;
}

isValid()

bool SkImage_GaneshBase::isValid ( GrRecordingContext *  context ) const

finalvirtual

Returns true if SkImage can be drawn on either raster surface or GPU surface. If context is nullptr, tests if SkImage draws on raster surface; otherwise, tests if SkImage draws on GPU surface associated with context.

SkImage backed by GPU texture may become invalid if associated context is invalid. lazy image may be invalid and may not draw to raster surface or GPU surface or both.

Parameters

context

GPU context

Returns

true if SkImage can be drawn

example: https://fiddle.skia.org/c/@Image_isValid

Implements SkImage.

Definition at line 257 of file SkImage_GaneshBase.cpp.

                                                                  {
    if (context && context->abandoned()) {
        return false;
    }
    if (fContext->priv().abandoned()) {
        return false;
    }
    if (context && !fContext->priv().matches(context)) {
        return false;
    }
    return true;
}

makeColorTypeAndColorSpace() [1/2]

sk_sp< SkImage > SkImage_GaneshBase::makeColorTypeAndColorSpace ( GrDirectContext *  direct, SkColorType  targetColorType, sk_sp< SkColorSpace >  targetCS  ) const

finalvirtual

Experimental. Creates SkImage in target SkColorType and SkColorSpace. Returns nullptr if SkImage could not be created.

Returns original SkImage if it is in target SkColorType and SkColorSpace.

If this image is texture-backed, the context parameter is required and must match the context of the source image.

Parameters

direct	The GrDirectContext in play, if it exists
targetColorType	SkColorType of returned SkImage
targetColorSpace	SkColorSpace of returned SkImage

Returns

created SkImage in target SkColorType and SkColorSpace

Implements SkImage.

Definition at line 270 of file SkImage_GaneshBase.cpp.

                                                                                                  {
    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);
}

makeColorTypeAndColorSpace() [2/2]

sk_sp< SkImage > SkImage_GaneshBase::makeColorTypeAndColorSpace ( skgpu::graphite::Recorder *  , SkColorType  targetColorType, sk_sp< SkColorSpace >  targetColorSpace, RequiredProperties    ) const

finalprotectedvirtual

Experimental. Creates SkImage in target SkColorType and SkColorSpace. Returns nullptr if SkImage could not be created.

Returns original SkImage if it is in target SkColorType and SkColorSpace.

If this image is graphite-backed, the recorder parameter is required.

Parameters

targetColorType	SkColorType of returned SkImage
targetColorSpace	SkColorSpace of returned SkImage
recorder	The Recorder in which to create the new image
RequiredProperties	properties the returned SkImage must possess (e.g. mipmaps)

Returns

created SkImage in target SkColorType and SkColorSpace

Implements SkImage.

Definition at line 225 of file SkImage_GaneshBase.cpp.

                                                                                        {
    SkDEBUGFAIL("Cannot convert Ganesh-backed image to Graphite");
    return nullptr;
}

MakePromiseImageLazyProxy()

sk_sp< GrTextureProxy > SkImage_GaneshBase::MakePromiseImageLazyProxy ( GrContextThreadSafeProxy *  tsp, SkISize  dimensions, const GrBackendFormat &  backendFormat, skgpu::Mipmapped  mipmapped, SkImages::PromiseImageTextureFulfillProc  fulfillProc, sk_sp< skgpu::RefCntedCallback >  releaseHelper  )

static

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.

Definition at line 296 of file SkImage_GaneshBase.cpp.

                                                    {
    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);
}

makeSubset()

sk_sp< SkImage > SkImage_GaneshBase::makeSubset ( GrDirectContext *  direct, const SkIRect &  subset  ) const

finalvirtual

Returns subset of this image.

Returns nullptr if any of the following are true:

• Subset is empty
• Subset is not contained inside the image's bounds
• Pixels in the source image could not be read or copied
• This image is texture-backed and the provided context is null or does not match the source image's context.

If the source image was texture-backed, the resulting image will be texture-backed also. Otherwise, the returned image will be raster-backed.

Parameters

direct	the GrDirectContext of the source image (nullptr is ok if the source image is not texture-backed).
subset	bounds of returned SkImage

Returns

the subsetted image, or nullptr

example: https://fiddle.skia.org/c/@Image_makeSubset

Implements SkImage.

Definition at line 167 of file SkImage_GaneshBase.cpp.

                                                                           {
    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);
}

onMakeColorTypeAndColorSpace()

virtual sk_sp< SkImage > SkImage_Base::onMakeColorTypeAndColorSpace ( SkColorType  , sk_sp< SkColorSpace >  , GrDirectContext *    ) const

protectedvirtual

Implements SkImage_Base.

Reimplemented in SkImage_GaneshYUVA.

onMakeSubset() [1/2]

sk_sp< SkImage > SkImage_GaneshBase::onMakeSubset ( GrDirectContext *  direct, const SkIRect &  subset  ) const

finalvirtual

Implements SkImage_Base.

Definition at line 190 of file SkImage_GaneshBase.cpp.

                                                                             {
    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());
}

onMakeSubset() [2/2]

sk_sp< SkImage > SkImage_GaneshBase::onMakeSubset ( skgpu::graphite::Recorder *  , const SkIRect &  subset, RequiredProperties    ) const

finalprotectedvirtual

Implements SkImage_Base.

Definition at line 218 of file SkImage_GaneshBase.cpp.

                                                                          {
    SkDEBUGFAIL("Cannot convert Ganesh-backed image to Graphite");
    return nullptr;
}

onReadPixels()

bool SkImage_GaneshBase::onReadPixels ( GrDirectContext *  dContext, const SkImageInfo &  dstInfo, void *  dstPixels, size_t  dstRB, int  srcX, int  srcY, CachingHint    ) const

overridevirtual

Implements SkImage_Base.

Definition at line 233 of file SkImage_GaneshBase.cpp.

                                                         {
    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});
}

origin()

virtual GrSurfaceOrigin SkImage_GaneshBase::origin ( ) const

pure virtual

Implemented in SkImage_Ganesh, and SkImage_GaneshYUVA.

ValidateBackendTexture()

bool SkImage_GaneshBase::ValidateBackendTexture ( const GrCaps *  caps, const GrBackendTexture &  tex, GrColorType  grCT, SkColorType  ct, SkAlphaType  at, sk_sp< SkColorSpace >  cs  )

static

Definition at line 68 of file SkImage_GaneshBase.cpp.

                                                                        {
    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);
}

ValidateCompressedBackendTexture()

bool SkImage_GaneshBase::ValidateCompressedBackendTexture ( const GrCaps *  caps, const GrBackendTexture &  tex, SkAlphaType  at  )

static

Definition at line 89 of file SkImage_GaneshBase.cpp.

                                                                          {
    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;
}

Member Data Documentation

fContext

sk_sp<GrImageContext> SkImage_GaneshBase::fContext

protected

Definition at line 127 of file SkImage_GaneshBase.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/image/SkImage_GaneshBase.h
• third_party/skia/src/gpu/ganesh/image/SkImage_GaneshBase.cpp