GrContextThreadSafeProxy Class Reference

#include <GrContextThreadSafeProxy.h>

Inheritance diagram for GrContextThreadSafeProxy:

Public Member Functions
virtual	~GrContextThreadSafeProxy ()
GrSurfaceCharacterization	createCharacterization (size_t cacheMaxResourceBytes, const SkImageInfo &ii, const GrBackendFormat &backendFormat, int sampleCount, GrSurfaceOrigin origin, const SkSurfaceProps &surfaceProps, skgpu::Mipmapped isMipmapped, bool willUseGLFBO0=false, bool isTextureable=true, skgpu::Protected isProtected=GrProtected::kNo, bool vkRTSupportsInputAttachment=false, bool forVulkanSecondaryCommandBuffer=false)
GrBackendFormat	defaultBackendFormat (SkColorType ct, GrRenderable renderable) const
GrBackendFormat	compressedBackendFormat (SkTextureCompressionType c) const
int	maxSurfaceSampleCountForColorType (SkColorType colorType) const
bool	isValid () const
bool	operator== (const GrContextThreadSafeProxy &that) const
bool	operator!= (const GrContextThreadSafeProxy &that) const
GrContextThreadSafeProxyPriv	priv ()
const GrContextThreadSafeProxyPriv	priv () const
Public Member Functions inherited from SkNVRefCnt< GrContextThreadSafeProxy >
	SkNVRefCnt ()
	~SkNVRefCnt ()
bool	unique () const
void	ref () const
void	unref () const
void	deref () const
bool	refCntGreaterThan (int32_t threadIsolatedTestCnt) const

Protected Member Functions
	GrContextThreadSafeProxy (GrBackendApi, const GrContextOptions &)

Private Member Functions
virtual bool	isValidCharacterizationForVulkan (sk_sp< const GrCaps >, bool isTextureable, skgpu::Mipmapped isMipmapped, skgpu::Protected isProtected, bool vkRTSupportsInputAttachment, bool forVulkanSecondaryCommandBuffer)

Friends
class	GrContextThreadSafeProxyPriv

Detailed Description

Can be used to perform actions related to the generating GrContext in a thread safe manner. The proxy does not access the 3D API (e.g. OpenGL) that backs the generating GrContext.

Definition at line 34 of file GrContextThreadSafeProxy.h.

Constructor & Destructor Documentation

~GrContextThreadSafeProxy()

GrContextThreadSafeProxy::~GrContextThreadSafeProxy ( )

virtualdefault

GrContextThreadSafeProxy()

GrContextThreadSafeProxy::GrContextThreadSafeProxy ( GrBackendApi  backend, const GrContextOptions &  options  )

protected

Definition at line 31 of file GrContextThreadSafeProxy.cpp.

        : fBackend(backend), fOptions(options), fContextID(next_id()) {
}

Member Function Documentation

compressedBackendFormat()

GrBackendFormat GrContextThreadSafeProxy::compressedBackendFormat

(

SkTextureCompressionType

c

)

const

Retrieve the GrBackendFormat for a given SkTextureCompressionType. This is guaranteed to match the backend format used by the following createCompressedBackendTexture methods that take a CompressionType.

The caller should check that the returned format is valid.

Definition at line 163 of file GrContextThreadSafeProxy.cpp.

                                                                                                  {
    SkASSERT(fCaps);
 
    GrBackendFormat format = fCaps->getBackendFormatFromCompressionType(c);
 
    SkASSERT(!format.isValid() || fCaps->isFormatTexturable(format, GrTextureType::k2D));
    return format;
}

createCharacterization()

GrSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization	(	size_t	cacheMaxResourceBytes,
		const SkImageInfo &	ii,
		const GrBackendFormat &	backendFormat,
		int	sampleCount,
		GrSurfaceOrigin	origin,
		const SkSurfaceProps &	surfaceProps,
		skgpu::Mipmapped	isMipmapped,
		bool	willUseGLFBO0 = false,
		bool	isTextureable = true,
		skgpu::Protected	isProtected = GrProtected::kNo,
		bool	vkRTSupportsInputAttachment = false,
		bool	forVulkanSecondaryCommandBuffer = false
	)

Create a surface characterization for a DDL that will be replayed into the GrContext that created this proxy. On failure the resulting characterization will be invalid (i.e., "!c.isValid()").

Parameters

cacheMaxResourceBytes	The max resource bytes limit that will be in effect when the DDL created with this characterization is replayed. Note: the contract here is that the DDL will be created as if it had a full 'cacheMaxResourceBytes' to use. If replayed into a GrContext that already has locked GPU memory, the replay can exceed the budget. To rephrase, all resource allocation decisions are made at record time and at playback time the budget limits will be ignored.
ii	The image info specifying properties of the SkSurface that the DDL created with this characterization will be replayed into. Note: Ganesh doesn't make use of the SkImageInfo's alphaType
backendFormat	Information about the format of the GPU surface that will back the SkSurface upon replay
sampleCount	The sample count of the SkSurface that the DDL created with this characterization will be replayed into
origin	The origin of the SkSurface that the DDL created with this characterization will be replayed into
surfaceProps	The surface properties of the SkSurface that the DDL created with this characterization will be replayed into
isMipmapped	Will the surface the DDL will be replayed into have space allocated for mipmaps?
willUseGLFBO0	Will the surface the DDL will be replayed into be backed by GL FBO 0. This flag is only valid if using an GL backend.
isTextureable	Will the surface be able to act as a texture?
isProtected	Will the (Vulkan) surface be DRM protected?
vkRTSupportsInputAttachment	Can the vulkan surface be used as in input attachment?
forVulkanSecondaryCommandBuffer	Will the surface be wrapping a vulkan secondary command buffer via a GrVkSecondaryCBDrawContext? If this is true then the following is required: isTexureable = false isMipmapped = false willUseGLFBO0 = false vkRTSupportsInputAttachment = false

Definition at line 47 of file GrContextThreadSafeProxy.cpp.

                                              {
    SkASSERT(fCaps);
    if (!backendFormat.isValid()) {
        return {};
    }
 
    SkASSERT(isTextureable || isMipmapped == skgpu::Mipmapped::kNo);
 
    if (GrBackendApi::kOpenGL != backendFormat.backend() && willUseGLFBO0) {
        // The willUseGLFBO0 flags can only be used for a GL backend.
        return {};
    }
 
    if (GrBackendApi::kVulkan != backendFormat.backend() &&
        (vkRTSupportsInputAttachment || forVulkanSecondaryCommandBuffer)) {
        // The vkRTSupportsInputAttachment and forVulkanSecondaryCommandBuffer flags can only be
        // used for a Vulkan backend.
        return {};
    }
 
    if (!fCaps->mipmapSupport()) {
        isMipmapped = skgpu::Mipmapped::kNo;
    }
 
    if (ii.width()  < 1 || ii.width()  > fCaps->maxRenderTargetSize() ||
        ii.height() < 1 || ii.height() > fCaps->maxRenderTargetSize()) {
        return {};
    }
 
    GrColorType grColorType = SkColorTypeToGrColorType(ii.colorType());
 
    if (!fCaps->areColorTypeAndFormatCompatible(grColorType, backendFormat)) {
        return {};
    }
 
    if (!fCaps->isFormatAsColorTypeRenderable(grColorType, backendFormat, sampleCnt)) {
        return {};
    }
 
    sampleCnt = fCaps->getRenderTargetSampleCount(sampleCnt, backendFormat);
    SkASSERT(sampleCnt);
 
    if (willUseGLFBO0 && isTextureable) {
        return {};
    }
 
    if (isTextureable && !fCaps->isFormatTexturable(backendFormat, backendFormat.textureType())) {
        // Skia doesn't agree that this is textureable.
        return {};
    }
 
    if (GrBackendApi::kVulkan == backendFormat.backend()) {
        if (!isValidCharacterizationForVulkan(fCaps,
                                              isTextureable,
                                              isMipmapped,
                                              isProtected,
                                              vkRTSupportsInputAttachment,
                                              forVulkanSecondaryCommandBuffer)) {
            return {};
        }
    }
 
    return GrSurfaceCharacterization(
            sk_ref_sp<GrContextThreadSafeProxy>(this),
            cacheMaxResourceBytes,
            ii,
            backendFormat,
            origin,
            sampleCnt,
            GrSurfaceCharacterization::Textureable(isTextureable),
            isMipmapped,
            GrSurfaceCharacterization::UsesGLFBO0(willUseGLFBO0),
            GrSurfaceCharacterization::VkRTSupportsInputAttachment(vkRTSupportsInputAttachment),
            GrSurfaceCharacterization::VulkanSecondaryCBCompatible(forVulkanSecondaryCommandBuffer),
            isProtected,
            surfaceProps);
}

defaultBackendFormat()

GrBackendFormat GrContextThreadSafeProxy::defaultBackendFormat	(	SkColorType	ct,
		GrRenderable	renderable
	)		const

Definition at line 147 of file GrContextThreadSafeProxy.cpp.

                                                                                              {
    SkASSERT(fCaps);
    GrColorType grColorType = SkColorTypeToGrColorType(skColorType);
 
    GrBackendFormat format = fCaps->getDefaultBackendFormat(grColorType, renderable);
    if (!format.isValid()) {
        return GrBackendFormat();
    }
 
    SkASSERT(renderable == GrRenderable::kNo ||
             fCaps->isFormatAsColorTypeRenderable(grColorType, format));
 
    return format;
}

isValid()

bool GrContextThreadSafeProxy::isValid ( ) const

inline

Definition at line 124 of file GrContextThreadSafeProxy.h.

{ return nullptr != fCaps; }

isValidCharacterizationForVulkan()

bool GrContextThreadSafeProxy::isValidCharacterizationForVulkan ( sk_sp< const GrCaps >  , bool  isTextureable, skgpu::Mipmapped  isMipmapped, skgpu::Protected  isProtected, bool  vkRTSupportsInputAttachment, bool  forVulkanSecondaryCommandBuffer  )

privatevirtual

Reimplemented in GrVkContextThreadSafeProxy.

Definition at line 137 of file GrContextThreadSafeProxy.cpp.

                                              {
    return false;  // handled by a subclass
}

maxSurfaceSampleCountForColorType()

int GrContextThreadSafeProxy::maxSurfaceSampleCountForColorType

(

SkColorType

colorType

)

const

Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA rendering is supported for the color type. 0 is returned if rendering to this color type is not supported at all.

Definition at line 172 of file GrContextThreadSafeProxy.cpp.

                                                                                           {
    SkASSERT(fCaps);
 
    GrBackendFormat format = fCaps->getDefaultBackendFormat(SkColorTypeToGrColorType(colorType),
                                                            GrRenderable::kYes);
    return fCaps->maxRenderTargetSampleCount(format);
}

operator!=()

bool GrContextThreadSafeProxy::operator!= ( const GrContextThreadSafeProxy &  that ) const

inline

Definition at line 132 of file GrContextThreadSafeProxy.h.

{ return !(*this == that); }

operator==()

bool GrContextThreadSafeProxy::operator== ( const GrContextThreadSafeProxy &  that ) const

inline

Definition at line 126 of file GrContextThreadSafeProxy.h.

                                                                {
        // Each GrContext should only ever have a single thread-safe proxy.
        SkASSERT((this == &that) == (this->fContextID == that.fContextID));
        return this == &that;
    }

priv() [1/2]

GrContextThreadSafeProxyPriv GrContextThreadSafeProxy::priv ( )

inline

Definition at line 66 of file GrContextThreadSafeProxyPriv.h.

                                                                   {
    return GrContextThreadSafeProxyPriv(this);
}

priv() [2/2]

const GrContextThreadSafeProxyPriv GrContextThreadSafeProxy::priv ( ) const

inline

Definition at line 70 of file GrContextThreadSafeProxyPriv.h.

                                                                               {  // NOLINT(readability-const-return-type)
    return GrContextThreadSafeProxyPriv(const_cast<GrContextThreadSafeProxy*>(this));
}

Friends And Related Symbol Documentation

GrContextThreadSafeProxyPriv

friend class GrContextThreadSafeProxyPriv

friend

Definition at line 143 of file GrContextThreadSafeProxy.h.

---

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

• third_party/skia/include/gpu/GrContextThreadSafeProxy.h
• third_party/skia/src/gpu/ganesh/GrContextThreadSafeProxy.cpp
• third_party/skia/src/gpu/ganesh/GrContextThreadSafeProxyPriv.h