GrProxyProvider Class Reference

#include <GrProxyProvider.h>

Classes
struct	TextureInfo

Public Types
enum class	InvalidateGPUResource : bool { kNo = false , kYes = true }
using	UseAllocator = GrSurfaceProxy::UseAllocator
typedef void *	ReleaseContext
typedef void(*	ReleaseProc) (ReleaseContext)
using	LazyInstantiationKeyMode = GrSurfaceProxy::LazyInstantiationKeyMode
using	LazySurfaceDesc = GrSurfaceProxy::LazySurfaceDesc
using	LazyCallbackResult = GrSurfaceProxy::LazyCallbackResult
using	LazyInstantiateCallback = GrSurfaceProxy::LazyInstantiateCallback

Public Member Functions
	GrProxyProvider (GrImageContext *)
	~GrProxyProvider ()
bool	assignUniqueKeyToProxy (const skgpu::UniqueKey &, GrTextureProxy *)
void	adoptUniqueKeyFromSurface (GrTextureProxy *proxy, const GrSurface *)
void	removeUniqueKeyFromProxy (GrTextureProxy *)
sk_sp< GrTextureProxy >	findProxyByUniqueKey (const skgpu::UniqueKey &)
sk_sp< GrTextureProxy >	findOrCreateProxyByUniqueKey (const skgpu::UniqueKey &, UseAllocator=UseAllocator::kYes)
GrSurfaceProxyView	findCachedProxyWithColorTypeFallback (const skgpu::UniqueKey &, GrSurfaceOrigin, GrColorType, int sampleCnt)
sk_sp< GrTextureProxy >	createProxyFromBitmap (const SkBitmap &, skgpu::Mipmapped, SkBackingFit, skgpu::Budgeted)
sk_sp< GrTextureProxy >	createProxy (const GrBackendFormat &, SkISize dimensions, GrRenderable, int renderTargetSampleCnt, skgpu::Mipmapped, SkBackingFit, skgpu::Budgeted, GrProtected, std::string_view label, GrInternalSurfaceFlags=GrInternalSurfaceFlags::kNone, UseAllocator useAllocator=UseAllocator::kYes)
sk_sp< GrTextureProxy >	createCompressedTextureProxy (SkISize dimensions, skgpu::Budgeted, skgpu::Mipmapped, GrProtected, SkTextureCompressionType, sk_sp< SkData > data)
sk_sp< GrTextureProxy >	wrapBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable, GrIOType, sk_sp< skgpu::RefCntedCallback >=nullptr)
sk_sp< GrTextureProxy >	wrapCompressedBackendTexture (const GrBackendTexture &, GrWrapOwnership, GrWrapCacheable, sk_sp< skgpu::RefCntedCallback >)
sk_sp< GrTextureProxy >	wrapRenderableBackendTexture (const GrBackendTexture &, int sampleCnt, GrWrapOwnership, GrWrapCacheable, sk_sp< skgpu::RefCntedCallback > releaseHelper)
sk_sp< GrSurfaceProxy >	wrapBackendRenderTarget (const GrBackendRenderTarget &, sk_sp< skgpu::RefCntedCallback > releaseHelper)
sk_sp< GrTextureProxy >	createLazyProxy (LazyInstantiateCallback &&, const GrBackendFormat &, SkISize dimensions, skgpu::Mipmapped, GrMipmapStatus, GrInternalSurfaceFlags, SkBackingFit, skgpu::Budgeted, GrProtected, UseAllocator, std::string_view label)
sk_sp< GrRenderTargetProxy >	createLazyRenderTargetProxy (LazyInstantiateCallback &&, const GrBackendFormat &, SkISize dimensions, int renderTargetSampleCnt, GrInternalSurfaceFlags, const TextureInfo *, GrMipmapStatus, SkBackingFit, skgpu::Budgeted, GrProtected, bool wrapsVkSecondaryCB, UseAllocator useAllocator)
void	processInvalidUniqueKey (const skgpu::UniqueKey &, GrTextureProxy *, InvalidateGPUResource)
GrDDLProvider	isDDLProvider () const
uint32_t	contextID () const
const GrCaps *	caps () const
sk_sp< const GrCaps >	refCaps () const
GrResourceProvider *	resourceProvider () const
int	numUniqueKeyProxies_TestOnly () const
void	orphanAllUniqueKeys ()
void	removeAllUniqueKeys ()
bool	renderingDirectly () const
bool	isAbandoned () const

Static Public Member Functions
static sk_sp< GrTextureProxy >	CreatePromiseProxy (GrContextThreadSafeProxy *, LazyInstantiateCallback &&, const GrBackendFormat &, SkISize dimensions, skgpu::Mipmapped)
static sk_sp< GrTextureProxy >	MakeFullyLazyProxy (LazyInstantiateCallback &&, const GrBackendFormat &, GrRenderable, int renderTargetSampleCnt, GrProtected, const GrCaps &, UseAllocator)

Friends
class	GrAHardwareBufferImageGenerator
class	GrResourceProvider

Detailed Description

Definition at line 28 of file GrProxyProvider.h.

Member Typedef Documentation

LazyCallbackResult

using GrProxyProvider::LazyCallbackResult = GrSurfaceProxy::LazyCallbackResult

Definition at line 147 of file GrProxyProvider.h.

LazyInstantiateCallback

using GrProxyProvider::LazyInstantiateCallback = GrSurfaceProxy::LazyInstantiateCallback

Definition at line 148 of file GrProxyProvider.h.

LazyInstantiationKeyMode

using GrProxyProvider::LazyInstantiationKeyMode = GrSurfaceProxy::LazyInstantiationKeyMode

Definition at line 145 of file GrProxyProvider.h.

LazySurfaceDesc

using GrProxyProvider::LazySurfaceDesc = GrSurfaceProxy::LazySurfaceDesc

Definition at line 146 of file GrProxyProvider.h.

ReleaseContext

typedef void* GrProxyProvider::ReleaseContext

Definition at line 112 of file GrProxyProvider.h.

ReleaseProc

typedef void(* GrProxyProvider::ReleaseProc) (ReleaseContext)

Definition at line 113 of file GrProxyProvider.h.

UseAllocator

using GrProxyProvider::UseAllocator = GrSurfaceProxy::UseAllocator

Definition at line 30 of file GrProxyProvider.h.

Member Enumeration Documentation

InvalidateGPUResource

enum class GrProxyProvider::InvalidateGPUResource : bool

strong

Enumerator
kNo
kYes

Definition at line 213 of file GrProxyProvider.h.

: bool { kNo = false, kYes = true };

Constructor & Destructor Documentation

GrProxyProvider()

GrProxyProvider::GrProxyProvider

(

GrImageContext *

imageContext

)

Definition at line 38 of file GrProxyProvider.cpp.

: fImageContext(imageContext) {}

~GrProxyProvider()

GrProxyProvider::~GrProxyProvider

(

)

Definition at line 40 of file GrProxyProvider.cpp.

                                  {
    if (this->renderingDirectly()) {
        // In DDL-mode a proxy provider can still have extant uniquely keyed proxies (since
        // they need their unique keys to, potentially, find a cached resource when the
        // DDL is played) but, in non-DDL-mode they should all have been cleaned up by this point.
        SkASSERT(!fUniquelyKeyedProxies.count());
    }
}

Member Function Documentation

adoptUniqueKeyFromSurface()

void GrProxyProvider::adoptUniqueKeyFromSurface	(	GrTextureProxy *	proxy,
		const GrSurface *	surf
	)

Definition at line 80 of file GrProxyProvider.cpp.

                                                                                            {
    SkASSERT(surf->getUniqueKey().isValid());
    proxy->cacheAccess().setUniqueKey(this, surf->getUniqueKey());
    SkASSERT(proxy->getUniqueKey() == surf->getUniqueKey());
    // multiple proxies can't get the same key
    SkASSERT(!fUniquelyKeyedProxies.find(surf->getUniqueKey()));
    fUniquelyKeyedProxies.add(proxy);
}

assignUniqueKeyToProxy()

bool GrProxyProvider::assignUniqueKeyToProxy	(	const skgpu::UniqueKey &	key,
		GrTextureProxy *	proxy
	)

Definition at line 49 of file GrProxyProvider.cpp.

                                                                                             {
    ASSERT_SINGLE_OWNER
    SkASSERT(key.isValid());
    if (this->isAbandoned() || !proxy) {
        return false;
    }
 
    // Only the proxyProvider that created a proxy should be assigning unique keys to it.
    SkASSERT(this->isDDLProvider() == proxy->creatingProvider());
 
#ifdef SK_DEBUG
    {
        auto direct = fImageContext->asDirectContext();
        if (direct) {
            GrResourceCache* resourceCache = direct->priv().getResourceCache();
            // If there is already a GrResource with this key then the caller has violated the
            // normal usage pattern of uniquely keyed resources (e.g., they have created one w/o
            // first seeing if it already existed in the cache).
            SkASSERT(!resourceCache->findAndRefUniqueResource(key));
        }
    }
#endif
 
    SkASSERT(!fUniquelyKeyedProxies.find(key));     // multiple proxies can't get the same key
 
    proxy->cacheAccess().setUniqueKey(this, key);
    SkASSERT(proxy->getUniqueKey() == key);
    fUniquelyKeyedProxies.add(proxy);
    return true;
}

caps()

const GrCaps * GrProxyProvider::caps

(

)

const

Definition at line 998 of file GrProxyProvider.cpp.

                                          {
    return fImageContext->priv().caps();
}

contextID()

uint32_t GrProxyProvider::contextID

(

)

const

Definition at line 994 of file GrProxyProvider.cpp.

                                          {
    return fImageContext->priv().contextID();
}

createCompressedTextureProxy()

sk_sp< GrTextureProxy > GrProxyProvider::createCompressedTextureProxy	(	SkISize	dimensions,
		skgpu::Budgeted	budgeted,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		SkTextureCompressionType	compressionType,
		sk_sp< SkData >	data
	)

Definition at line 532 of file GrProxyProvider.cpp.

                            {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    GrBackendFormat format = this->caps()->getBackendFormatFromCompressionType(compressionType);
 
    if (!this->caps()->isFormatTexturable(format, GrTextureType::k2D)) {
        return nullptr;
    }
 
    GrMipmapStatus mipmapStatus = (skgpu::Mipmapped::kYes == mipmapped)
                                          ? GrMipmapStatus::kValid
                                          : GrMipmapStatus::kNotAllocated;
 
    sk_sp<GrTextureProxy> proxy = this->createLazyProxy(
            [data](GrResourceProvider* resourceProvider, const LazySurfaceDesc& desc) {
                return LazyCallbackResult(
                        resourceProvider->createCompressedTexture(desc.fDimensions,
                                                                  desc.fFormat,
                                                                  desc.fBudgeted,
                                                                  desc.fMipmapped,
                                                                  desc.fProtected,
                                                                  data.get(),
                                                                  desc.fLabel));
            },
            format,
            dimensions,
            mipmapped,
            mipmapStatus,
            GrInternalSurfaceFlags::kReadOnly,
            SkBackingFit::kExact,
            skgpu::Budgeted::kYes,
            GrProtected::kNo,
            UseAllocator::kYes,
            "ProxyProvider_CreateCompressedTextureProxy");
 
    if (!proxy) {
        return nullptr;
    }
 
    auto direct = fImageContext->asDirectContext();
    if (direct) {
        GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
        // In order to reuse code we always create a lazy proxy. When we aren't in DDL mode however
        // we're better off instantiating the proxy immediately here.
        if (!proxy->priv().doLazyInstantiation(resourceProvider)) {
            return nullptr;
        }
    }
    return proxy;
}

createLazyProxy()

sk_sp< GrTextureProxy > GrProxyProvider::createLazyProxy	(	LazyInstantiateCallback &&	callback,
		const GrBackendFormat &	format,
		SkISize	dimensions,
		skgpu::Mipmapped	mipmapped,
		GrMipmapStatus	mipmapStatus,
		GrInternalSurfaceFlags	surfaceFlags,
		SkBackingFit	fit,
		skgpu::Budgeted	budgeted,
		GrProtected	isProtected,
		GrSurfaceProxy::UseAllocator	useAllocator,
		std::string_view	label
	)

Creates a texture proxy that will be instantiated by a user-supplied callback during flush. The width and height must either both be greater than 0 or both less than or equal to zero. A non-positive value is a signal that the width height are currently unknown. The texture will not be renderable.

When called, the callback must be able to cleanup any resources that it captured at creation. It also must support being passed in a null GrResourceProvider. When this happens, the callback should cleanup any resources it captured and return an empty sk_sp<GrTextureProxy>.

Definition at line 790 of file GrProxyProvider.cpp.

                                                                             {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
    SkASSERT((dimensions.fWidth <= 0 && dimensions.fHeight <= 0) ||
             (dimensions.fWidth >  0 && dimensions.fHeight >  0));
 
    if (!format.isValid() || format.backend() != fImageContext->backend()) {
        return nullptr;
    }
 
    if (dimensions.fWidth > this->caps()->maxTextureSize() ||
        dimensions.fHeight > this->caps()->maxTextureSize()) {
        return nullptr;
    }
 
    return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(callback),
                                                    format,
                                                    dimensions,
                                                    mipmapped,
                                                    mipmapStatus,
                                                    fit,
                                                    budgeted,
                                                    isProtected,
                                                    surfaceFlags,
                                                    useAllocator,
                                                    this->isDDLProvider(),
                                                    label));
}

createLazyRenderTargetProxy()

sk_sp< GrRenderTargetProxy > GrProxyProvider::createLazyRenderTargetProxy	(	LazyInstantiateCallback &&	callback,
		const GrBackendFormat &	format,
		SkISize	dimensions,
		int	renderTargetSampleCnt,
		GrInternalSurfaceFlags	surfaceFlags,
		const TextureInfo *	textureInfo,
		GrMipmapStatus	mipmapStatus,
		SkBackingFit	fit,
		skgpu::Budgeted	budgeted,
		GrProtected	isProtected,
		bool	wrapsVkSecondaryCB,
		UseAllocator	useAllocator
	)

A null TextureInfo indicates a non-textureable render target.

Definition at line 831 of file GrProxyProvider.cpp.

                                   {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
    SkASSERT((dimensions.fWidth <= 0 && dimensions.fHeight <= 0) ||
             (dimensions.fWidth >  0 && dimensions.fHeight >  0));
 
    if (dimensions.fWidth > this->caps()->maxRenderTargetSize() ||
        dimensions.fHeight > this->caps()->maxRenderTargetSize()) {
        return nullptr;
    }
 
    if (textureInfo) {
        // Wrapped vulkan secondary command buffers don't support texturing since we won't have an
        // actual VkImage to texture from.
        SkASSERT(!wrapsVkSecondaryCB);
        return sk_sp<GrRenderTargetProxy>(new GrTextureRenderTargetProxy(
                *this->caps(),
                std::move(callback),
                format,
                dimensions,
                sampleCnt,
                textureInfo->fMipmapped,
                mipmapStatus,
                fit,
                budgeted,
                isProtected,
                surfaceFlags,
                useAllocator,
                this->isDDLProvider(),
                /*label=*/"TextureRenderTarget_LazyRenderTargetProxy"));
    }
 
    GrRenderTargetProxy::WrapsVkSecondaryCB vkSCB =
            wrapsVkSecondaryCB ? GrRenderTargetProxy::WrapsVkSecondaryCB::kYes
                               : GrRenderTargetProxy::WrapsVkSecondaryCB::kNo;
 
    return sk_sp<GrRenderTargetProxy>(
            new GrRenderTargetProxy(std::move(callback),
                                    format,
                                    dimensions,
                                    sampleCnt,
                                    fit,
                                    budgeted,
                                    isProtected,
                                    surfaceFlags,
                                    useAllocator,
                                    vkSCB,
                                    /*label=*/"RenderTargetProxy_LazyRenderTargetProxy"));
}

CreatePromiseProxy()

sk_sp< GrTextureProxy > GrProxyProvider::CreatePromiseProxy ( GrContextThreadSafeProxy *  threadSafeProxy, LazyInstantiateCallback &&  callback, const GrBackendFormat &  format, SkISize  dimensions, skgpu::Mipmapped  mipmapped  )

static

Similar to createLazyProxy below, except narrowed to the use case of shared promise images i.e. static so it doesn't have access to mutable state. Used by MakePromiseImageLazyProxy().

Definition at line 748 of file GrProxyProvider.cpp.

                                                                                    {
    if (threadSafeProxy->priv().abandoned()) {
        return nullptr;
    }
    SkASSERT((dimensions.fWidth <= 0 && dimensions.fHeight <= 0) ||
             (dimensions.fWidth >  0 && dimensions.fHeight >  0));
 
    if (dimensions.fWidth > threadSafeProxy->priv().caps()->maxTextureSize() ||
        dimensions.fHeight > threadSafeProxy->priv().caps()->maxTextureSize()) {
        return nullptr;
    }
    if (!threadSafeProxy->priv().caps()->isFormatTexturable(format, format.textureType())) {
        return nullptr;
    }
    // Ganesh assumes that, when wrapping a mipmapped backend texture from a client, that its
    // mipmaps are fully fleshed out.
    GrMipmapStatus mipmapStatus = (skgpu::Mipmapped::kYes == mipmapped)
                                          ? GrMipmapStatus::kValid
                                          : GrMipmapStatus::kNotAllocated;
 
    // We pass kReadOnly here since we should treat content of the client's texture as immutable.
    // The promise API provides no way for the client to indicate that the texture is protected.
    auto proxy = sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(callback),
                                                          format,
                                                          dimensions,
                                                          mipmapped,
                                                          mipmapStatus,
                                                          SkBackingFit::kExact,
                                                          skgpu::Budgeted::kNo,
                                                          GrProtected::kNo,
                                                          GrInternalSurfaceFlags::kReadOnly,
                                                          GrSurfaceProxy::UseAllocator::kYes,
                                                          GrDDLProvider::kYes,
                                                          /*label=*/"PromiseProxy"));
    proxy->priv().setIsPromiseProxy();
    return proxy;
}

createProxy()

sk_sp< GrTextureProxy > GrProxyProvider::createProxy	(	const GrBackendFormat &	format,
		SkISize	dimensions,
		GrRenderable	renderable,
		int	renderTargetSampleCnt,
		skgpu::Mipmapped	mipmapped,
		SkBackingFit	fit,
		skgpu::Budgeted	budgeted,
		GrProtected	isProtected,
		std::string_view	label,
		GrInternalSurfaceFlags	surfaceFlags = GrInternalSurfaceFlags::kNone,
		GrSurfaceProxy::UseAllocator	useAllocator = UseAllocator::kYes
	)

Definition at line 456 of file GrProxyProvider.cpp.

                                                                                            {
    ASSERT_SINGLE_OWNER
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    const GrCaps* caps = this->caps();
 
    if (caps->isFormatCompressed(format)) {
        // Deferred proxies for compressed textures are not supported.
        return nullptr;
    }
 
    if (skgpu::Mipmapped::kYes == mipmapped) {
        // SkMipmap doesn't include the base level in the level count so we have to add 1
        int mipCount = SkMipmap::ComputeLevelCount(dimensions.fWidth, dimensions.fHeight) + 1;
        if (1 == mipCount) {
            mipmapped = skgpu::Mipmapped::kNo;
        }
    }
 
    if (!caps->validateSurfaceParams(dimensions,
                                     format,
                                     renderable,
                                     renderTargetSampleCnt,
                                     mipmapped,
                                     GrTextureType::k2D)) {
        return nullptr;
    }
    GrMipmapStatus mipmapStatus = (skgpu::Mipmapped::kYes == mipmapped)
                                          ? GrMipmapStatus::kDirty
                                          : GrMipmapStatus::kNotAllocated;
    if (renderable == GrRenderable::kYes) {
        renderTargetSampleCnt = caps->getRenderTargetSampleCount(renderTargetSampleCnt, format);
        SkASSERT(renderTargetSampleCnt);
        GrInternalSurfaceFlags extraFlags = caps->getExtraSurfaceFlagsForDeferredRT();
        // We know anything we instantiate later from this deferred path will be
        // both texturable and renderable
        return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(*caps,
                                                                    format,
                                                                    dimensions,
                                                                    renderTargetSampleCnt,
                                                                    mipmapped,
                                                                    mipmapStatus,
                                                                    fit,
                                                                    budgeted,
                                                                    isProtected,
                                                                    surfaceFlags | extraFlags,
                                                                    useAllocator,
                                                                    this->isDDLProvider(),
                                                                    label));
    }
 
    return sk_sp<GrTextureProxy>(new GrTextureProxy(format,
                                                    dimensions,
                                                    mipmapped,
                                                    mipmapStatus,
                                                    fit,
                                                    budgeted,
                                                    isProtected,
                                                    surfaceFlags,
                                                    useAllocator,
                                                    this->isDDLProvider(),
                                                    label));
}

createProxyFromBitmap()

sk_sp< GrTextureProxy > GrProxyProvider::createProxyFromBitmap	(	const SkBitmap &	bitmap,
		skgpu::Mipmapped	mipmapped,
		SkBackingFit	fit,
		skgpu::Budgeted	budgeted
	)

Definition at line 271 of file GrProxyProvider.cpp.

                                                                                     {
    ASSERT_SINGLE_OWNER
    SkASSERT(fit == SkBackingFit::kExact || mipmapped == skgpu::Mipmapped::kNo);
 
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    if (!SkImageInfoIsValid(bitmap.info())) {
        return nullptr;
    }
 
    ATRACE_ANDROID_FRAMEWORK("Upload %sTexture [%dx%d]",
                             skgpu::Mipmapped::kYes == mipmapped ? "MipMap " : "",
                             bitmap.width(),
                             bitmap.height());
 
    // In non-ddl we will always instantiate right away. Thus we never want to copy the SkBitmap
    // even if its mutable. In ddl, if the bitmap is mutable then we must make a copy since the
    // upload of the data to the gpu can happen at anytime and the bitmap may change by then.
    SkBitmap copyBitmap = bitmap;
    if (!this->renderingDirectly() && !bitmap.isImmutable()) {
        copyBitmap.allocPixels();
        if (!bitmap.readPixels(copyBitmap.pixmap())) {
            return nullptr;
        }
        if (mipmapped == skgpu::Mipmapped::kYes && bitmap.fMips) {
            copyBitmap.fMips = sk_sp<SkMipmap>(SkMipmap::Build(copyBitmap.pixmap(),
                                                               /* factoryProc= */ nullptr,
                                                               /* computeContents= */ false));
            if (copyBitmap.fMips) {
                for (int i = 0; i < copyBitmap.fMips->countLevels(); ++i) {
                    SkMipmap::Level src, dst;
                    bitmap.fMips->getLevel(i, &src);
                    copyBitmap.fMips->getLevel(i, &dst);
                    src.fPixmap.readPixels(dst.fPixmap);
                }
            }
        }
        copyBitmap.setImmutable();
    }
 
    sk_sp<GrTextureProxy> proxy;
    if (mipmapped == skgpu::Mipmapped::kNo ||
        !SkMipmap::ComputeLevelCount(copyBitmap.dimensions())) {
        proxy = this->createNonMippedProxyFromBitmap(copyBitmap, fit, budgeted);
    } else {
        proxy = this->createMippedProxyFromBitmap(copyBitmap, budgeted);
    }
 
    if (!proxy) {
        return nullptr;
    }
 
    auto direct = fImageContext->asDirectContext();
    if (direct) {
        GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
 
        // In order to reuse code we always create a lazy proxy. When we aren't in DDL mode however
        // we're better off instantiating the proxy immediately here.
        if (!proxy->priv().doLazyInstantiation(resourceProvider)) {
            return nullptr;
        }
    }
    return proxy;
}

findCachedProxyWithColorTypeFallback()

GrSurfaceProxyView GrProxyProvider::findCachedProxyWithColorTypeFallback	(	const skgpu::UniqueKey &	key,
		GrSurfaceOrigin	origin,
		GrColorType	ct,
		int	sampleCnt
	)

A helper that uses findOrCreateProxyByUniqueKey() to find a proxy and, if found, creates a view for the found proxy using the passed in origin and color type. It is assumed that if the proxy is renderable then it was created via a fallback code path so the fallback color type will be used to create the view.

Definition at line 250 of file GrProxyProvider.cpp.

                       {
    auto proxy = this->findOrCreateProxyByUniqueKey(key);
    if (!proxy) {
        return {};
    }
    const GrCaps* caps = fImageContext->priv().caps();
 
    // Assume that we used a fallback color type if and only if the proxy is renderable.
    if (proxy->asRenderTargetProxy()) {
        GrBackendFormat expectedFormat;
        std::tie(ct, expectedFormat) = caps->getFallbackColorTypeAndFormat(ct, sampleCnt);
        SkASSERT(expectedFormat == proxy->backendFormat());
    }
    skgpu::Swizzle swizzle = caps->getReadSwizzle(proxy->backendFormat(), ct);
    return {std::move(proxy), origin, swizzle};
}

findOrCreateProxyByUniqueKey()

sk_sp< GrTextureProxy > GrProxyProvider::findOrCreateProxyByUniqueKey	(	const skgpu::UniqueKey &	key,
		UseAllocator	useAllocator = UseAllocator::kYes
	)

Definition at line 215 of file GrProxyProvider.cpp.

                                                                                               {
    ASSERT_SINGLE_OWNER
 
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    sk_sp<GrTextureProxy> result = this->findProxyByUniqueKey(key);
    if (result) {
        return result;
    }
 
    auto direct = fImageContext->asDirectContext();
    if (!direct) {
        return nullptr;
    }
 
    GrResourceCache* resourceCache = direct->priv().getResourceCache();
 
    GrGpuResource* resource = resourceCache->findAndRefUniqueResource(key);
    if (!resource) {
        return nullptr;
    }
 
    sk_sp<GrTexture> texture(static_cast<GrSurface*>(resource)->asTexture());
    SkASSERT(texture);
 
    result = this->createWrapped(std::move(texture), useAllocator);
    SkASSERT(result->getUniqueKey() == key);
    // createWrapped should've added this for us
    SkASSERT(fUniquelyKeyedProxies.find(key));
    return result;
}

findProxyByUniqueKey()

sk_sp< GrTextureProxy > GrProxyProvider::findProxyByUniqueKey

(

const skgpu::UniqueKey &

key

)

Definition at line 101 of file GrProxyProvider.cpp.

                                                                                     {
    ASSERT_SINGLE_OWNER
 
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    GrTextureProxy* proxy = fUniquelyKeyedProxies.find(key);
    if (proxy) {
        return sk_ref_sp(proxy);
    }
    return nullptr;
}

isAbandoned()

bool GrProxyProvider::isAbandoned

(

)

const

Definition at line 1006 of file GrProxyProvider.cpp.

                                        {
    return fImageContext->priv().abandoned();
}

isDDLProvider()

GrDDLProvider GrProxyProvider::isDDLProvider

(

)

const

Definition at line 990 of file GrProxyProvider.cpp.

                                                   {
    return fImageContext->asDirectContext() ? GrDDLProvider::kNo : GrDDLProvider::kYes;
}

MakeFullyLazyProxy()

sk_sp< GrTextureProxy > GrProxyProvider::MakeFullyLazyProxy ( LazyInstantiateCallback &&  callback, const GrBackendFormat &  format, GrRenderable  renderable, int  renderTargetSampleCnt, GrProtected  isProtected, const GrCaps &  caps, UseAllocator  useAllocator  )

static

Fully lazy proxies have unspecified width and height. Methods that rely on those values (e.g., width, height, getBoundsRect) should be avoided.

Definition at line 895 of file GrProxyProvider.cpp.

                                                                                     {
    if (!format.isValid()) {
        return nullptr;
    }
 
    SkASSERT(renderTargetSampleCnt == 1 || renderable == GrRenderable::kYes);
    // TODO: If we ever have callers requesting specific surface flags then we shouldn't use the
    // extra deferred flags here. Instead those callers should all pass in exactly what they want.
    // However, as of today all uses of this essentially create a deferred proxy in the end.
    GrInternalSurfaceFlags surfaceFlags = caps.getExtraSurfaceFlagsForDeferredRT();
 
    // MakeFullyLazyProxy is only called at flush time so we know these texture proxies are
    // not being created by a DDL provider.
    static constexpr SkISize kLazyDims = {-1, -1};
    if (GrRenderable::kYes == renderable) {
        return sk_sp<GrTextureProxy>(
                new GrTextureRenderTargetProxy(caps,
                                               std::move(callback),
                                               format,
                                               kLazyDims,
                                               renderTargetSampleCnt,
                                               skgpu::Mipmapped::kNo,
                                               GrMipmapStatus::kNotAllocated,
                                               SkBackingFit::kApprox,
                                               skgpu::Budgeted::kYes,
                                               isProtected,
                                               surfaceFlags,
                                               useAllocator,
                                               GrDDLProvider::kNo,
                                               /*label=*/"TextureRenderTarget_FullyLazyProxy"));
    } else {
        return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(callback),
                                                        format,
                                                        kLazyDims,
                                                        skgpu::Mipmapped::kNo,
                                                        GrMipmapStatus::kNotAllocated,
                                                        SkBackingFit::kApprox,
                                                        skgpu::Budgeted::kYes,
                                                        isProtected,
                                                        surfaceFlags,
                                                        useAllocator,
                                                        GrDDLProvider::kNo,
                                                        /*label=*/"Texture_FullyLazyProxy"));
    }
}

numUniqueKeyProxies_TestOnly()

int GrProxyProvider::numUniqueKeyProxies_TestOnly

(

)

const

Definition at line 50 of file TextureProxyTest.cpp.

                                                        {
    return fUniquelyKeyedProxies.count();
}

orphanAllUniqueKeys()

void GrProxyProvider::orphanAllUniqueKeys

(

)

Definition at line 1010 of file GrProxyProvider.cpp.

                                          {
    fUniquelyKeyedProxies.foreach([&](GrTextureProxy* proxy){
        proxy->fProxyProvider = nullptr;
    });
}

processInvalidUniqueKey()

void GrProxyProvider::processInvalidUniqueKey	(	const skgpu::UniqueKey &	key,
		GrTextureProxy *	proxy,
		InvalidateGPUResource	invalidateGPUResource
	)

Definition at line 947 of file GrProxyProvider.cpp.

                                                                                           {
    this->processInvalidUniqueKeyImpl(key, proxy, invalidateGPUResource, RemoveTableEntry::kYes);
}

refCaps()

sk_sp< const GrCaps > GrProxyProvider::refCaps

(

)

const

Definition at line 1002 of file GrProxyProvider.cpp.

                                                   {
    return fImageContext->priv().refCaps();
}

removeAllUniqueKeys()

void GrProxyProvider::removeAllUniqueKeys

(

)

Definition at line 1016 of file GrProxyProvider.cpp.

                                          {
    fUniquelyKeyedProxies.foreach([&](GrTextureProxy* proxy){
        // It's not safe to remove table entries while iterating with foreach(),
        // but since we're going to remove them all anyway, simply save that for the end.
        this->processInvalidUniqueKeyImpl(proxy->getUniqueKey(), proxy,
                                          InvalidateGPUResource::kNo,
                                          RemoveTableEntry::kNo);
    });
    // Removing all those table entries is safe now.
    fUniquelyKeyedProxies.reset();
}

removeUniqueKeyFromProxy()

void GrProxyProvider::removeUniqueKeyFromProxy

(

GrTextureProxy *

proxy

)

Definition at line 89 of file GrProxyProvider.cpp.

                                                                    {
    ASSERT_SINGLE_OWNER
    SkASSERT(proxy);
    SkASSERT(proxy->getUniqueKey().isValid());
 
    if (this->isAbandoned()) {
        return;
    }
 
    this->processInvalidUniqueKey(proxy->getUniqueKey(), proxy, InvalidateGPUResource::kYes);
}

renderingDirectly()

bool GrProxyProvider::renderingDirectly

(

)

const

Does the proxy provider have access to a GrDirectContext? If so, proxies will be instantiated immediately.

Definition at line 1028 of file GrProxyProvider.cpp.

                                              {
    return fImageContext->asDirectContext();
}

resourceProvider()

GrResourceProvider * GrProxyProvider::resourceProvider

(

)

const

Definition at line 706 of file GrProxyProvider.cpp.

                                                            {
    GrDirectContext* direct = fImageContext->asDirectContext();
    if (!direct) {
        return nullptr;
    }
 
    return direct->priv().resourceProvider();
}

wrapBackendRenderTarget()

sk_sp< GrSurfaceProxy > GrProxyProvider::wrapBackendRenderTarget	(	const GrBackendRenderTarget &	backendRT,
		sk_sp< skgpu::RefCntedCallback >	releaseHelper
	)

Definition at line 715 of file GrProxyProvider.cpp.

                                                    {
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    // This is only supported on a direct GrContext.
    auto direct = fImageContext->asDirectContext();
    if (!direct) {
        return nullptr;
    }
 
    GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
 
    sk_sp<GrRenderTarget> rt = resourceProvider->wrapBackendRenderTarget(backendRT);
    if (!rt) {
        return nullptr;
    }
 
    if (releaseHelper) {
        rt->setRelease(std::move(releaseHelper));
    }
 
    SkASSERT(!rt->asTexture());  // A GrRenderTarget that's not textureable
    SkASSERT(!rt->getUniqueKey().isValid());
    // Make sure we match how we created the proxy with skgpu::Budgeted::kNo
    SkASSERT(GrBudgetedType::kBudgeted != rt->resourcePriv().budgetedType());
 
    return sk_sp<GrRenderTargetProxy>(
            new GrRenderTargetProxy(std::move(rt), UseAllocator::kNo, {}));
}

wrapBackendTexture()

sk_sp< GrTextureProxy > GrProxyProvider::wrapBackendTexture	(	const GrBackendTexture &	backendTex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable,
		GrIOType	ioType,
		sk_sp< skgpu::RefCntedCallback >	releaseHelper = nullptr
	)

Definition at line 592 of file GrProxyProvider.cpp.

                                                    {
    SkASSERT(ioType != kWrite_GrIOType);
 
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    // This is only supported on a direct GrContext.
    auto direct = fImageContext->asDirectContext();
    if (!direct) {
        return nullptr;
    }
 
    GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
 
    sk_sp<GrTexture> tex =
            resourceProvider->wrapBackendTexture(backendTex, ownership, cacheable, ioType);
    if (!tex) {
        return nullptr;
    }
 
    if (releaseHelper) {
        tex->setRelease(std::move(releaseHelper));
    }
 
    SkASSERT(!tex->asRenderTarget());  // Strictly a GrTexture
    // Make sure we match how we created the proxy with skgpu::Budgeted::kNo
    SkASSERT(GrBudgetedType::kBudgeted != tex->resourcePriv().budgetedType());
 
    return sk_sp<GrTextureProxy>(
            new GrTextureProxy(std::move(tex), UseAllocator::kNo, this->isDDLProvider()));
}

wrapCompressedBackendTexture()

sk_sp< GrTextureProxy > GrProxyProvider::wrapCompressedBackendTexture	(	const GrBackendTexture &	beTex,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable,
		sk_sp< skgpu::RefCntedCallback >	releaseHelper
	)

Definition at line 630 of file GrProxyProvider.cpp.

                                                    {
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    // This is only supported on a direct GrContext.
    auto direct = fImageContext->asDirectContext();
    if (!direct) {
        return nullptr;
    }
 
    GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
 
    sk_sp<GrTexture> tex = resourceProvider->wrapCompressedBackendTexture(beTex, ownership,
                                                                          cacheable);
    if (!tex) {
        return nullptr;
    }
 
    if (releaseHelper) {
        tex->setRelease(std::move(releaseHelper));
    }
 
    SkASSERT(!tex->asRenderTarget());  // Strictly a GrTexture
    // Make sure we match how we created the proxy with skgpu::Budgeted::kNo
    SkASSERT(GrBudgetedType::kBudgeted != tex->resourcePriv().budgetedType());
 
    return sk_sp<GrTextureProxy>(
            new GrTextureProxy(std::move(tex), UseAllocator::kNo, this->isDDLProvider()));
}

wrapRenderableBackendTexture()

sk_sp< GrTextureProxy > GrProxyProvider::wrapRenderableBackendTexture	(	const GrBackendTexture &	backendTex,
		int	sampleCnt,
		GrWrapOwnership	ownership,
		GrWrapCacheable	cacheable,
		sk_sp< skgpu::RefCntedCallback >	releaseHelper
	)

Definition at line 665 of file GrProxyProvider.cpp.

                                                    {
    if (this->isAbandoned()) {
        return nullptr;
    }
 
    // This is only supported on a direct GrContext.
    auto direct = fImageContext->asDirectContext();
    if (!direct) {
        return nullptr;
    }
 
    const GrCaps* caps = this->caps();
 
    GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
 
    sampleCnt = caps->getRenderTargetSampleCount(sampleCnt, backendTex.getBackendFormat());
    SkASSERT(sampleCnt);
 
    sk_sp<GrTexture> tex = resourceProvider->wrapRenderableBackendTexture(
            backendTex, sampleCnt, ownership, cacheable);
    if (!tex) {
        return nullptr;
    }
 
    if (releaseHelper) {
        tex->setRelease(std::move(releaseHelper));
    }
 
    SkASSERT(tex->asRenderTarget());  // A GrTextureRenderTarget
    // Make sure we match how we created the proxy with skgpu::Budgeted::kNo
    SkASSERT(GrBudgetedType::kBudgeted != tex->resourcePriv().budgetedType());
 
    return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(
            std::move(tex), UseAllocator::kNo, this->isDDLProvider()));
}

Friends And Related Function Documentation

GrAHardwareBufferImageGenerator

friend class GrAHardwareBufferImageGenerator

friend

Definition at line 280 of file GrProxyProvider.h.

GrResourceProvider

friend class GrResourceProvider

friend

Definition at line 281 of file GrProxyProvider.h.

---

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

• third_party/skia/src/gpu/ganesh/GrProxyProvider.h
• third_party/skia/src/gpu/ganesh/GrProxyProvider.cpp
• third_party/skia/tests/TextureProxyTest.cpp