skgpu::graphite::Context Class Reference

#include <Context.h>

Classes
class	ContextID

Public Member Functions
	Context (const Context &)=delete
	Context (Context &&)=delete
Context &	operator= (const Context &)=delete
Context &	operator= (Context &&)=delete
	~Context ()
BackendApi	backend () const
std::unique_ptr< Recorder >	makeRecorder (const RecorderOptions &={})
bool	insertRecording (const InsertRecordingInfo &)
bool	submit (SyncToCpu=SyncToCpu::kNo)
bool	hasUnfinishedGpuWork () const
void	asyncRescaleAndReadPixels (const SkImage *image, const SkImageInfo &dstImageInfo, const SkIRect &srcRect, SkImage::RescaleGamma rescaleGamma, SkImage::RescaleMode rescaleMode, SkImage::ReadPixelsCallback callback, SkImage::ReadPixelsContext context)
void	asyncRescaleAndReadPixels (const SkSurface *surface, const SkImageInfo &dstImageInfo, const SkIRect &srcRect, SkImage::RescaleGamma rescaleGamma, SkImage::RescaleMode rescaleMode, SkImage::ReadPixelsCallback callback, SkImage::ReadPixelsContext context)
void	asyncRescaleAndReadPixelsYUV420 (const SkImage *, SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, SkImage::RescaleGamma rescaleGamma, SkImage::RescaleMode rescaleMode, SkImage::ReadPixelsCallback callback, SkImage::ReadPixelsContext context)
void	asyncRescaleAndReadPixelsYUV420 (const SkSurface *, SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, SkImage::RescaleGamma rescaleGamma, SkImage::RescaleMode rescaleMode, SkImage::ReadPixelsCallback callback, SkImage::ReadPixelsContext context)
void	asyncRescaleAndReadPixelsYUVA420 (const SkImage *, SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, SkImage::RescaleGamma rescaleGamma, SkImage::RescaleMode rescaleMode, SkImage::ReadPixelsCallback callback, SkImage::ReadPixelsContext context)
void	asyncRescaleAndReadPixelsYUVA420 (const SkSurface *, SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, SkImage::RescaleGamma rescaleGamma, SkImage::RescaleMode rescaleMode, SkImage::ReadPixelsCallback callback, SkImage::ReadPixelsContext context)
void	checkAsyncWorkCompletion ()
void	deleteBackendTexture (const BackendTexture &)
void	freeGpuResources ()
void	performDeferredCleanup (std::chrono::milliseconds msNotUsed)
size_t	currentBudgetedBytes () const
size_t	maxBudgetedBytes () const
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
bool	isDeviceLost () const
int	maxTextureSize () const
bool	supportsProtectedContent () const
ContextPriv	priv ()
const ContextPriv	priv () const
ContextID	contextID () const

Protected Member Functions
	Context (sk_sp< SharedContext >, std::unique_ptr< QueueManager >, const ContextOptions &)

Friends
class	ContextPriv
class	ContextCtorAccessor

Detailed Description

Definition at line 43 of file Context.h.

Constructor & Destructor Documentation

Context() [1/3]

skgpu::graphite::Context::Context ( const Context &  )

delete

Context() [2/3]

skgpu::graphite::Context::Context ( Context &&  )

delete

~Context()

Context::~Context

(

)

Definition at line 99 of file Context.cpp.

                  {
#if defined(GRAPHITE_TEST_UTILS)
    ASSERT_SINGLE_OWNER
    for (auto& recorder : fTrackedRecorders) {
        recorder->priv().setContext(nullptr);
    }
#endif
}

Context() [3/3]

Context::Context ( sk_sp< SharedContext >  sharedContext, std::unique_ptr< QueueManager >  queueManager, const ContextOptions &  options  )

protected

Definition at line 80 of file Context.cpp.

        : fSharedContext(std::move(sharedContext))
        , fQueueManager(std::move(queueManager))
        , fContextID(ContextID::Next()) {
    // We have to create this outside the initializer list because we need to pass in the Context's
    // SingleOwner object and it is declared last
    fResourceProvider = fSharedContext->makeResourceProvider(&fSingleOwner,
                                                             SK_InvalidGenID,
                                                             options.fGpuBudgetInBytes);
    fMappedBufferManager = std::make_unique<ClientMappedBufferManager>(this->contextID());
#if defined(GRAPHITE_TEST_UTILS)
    if (options.fOptionsPriv) {
        fStoreContextRefInRecorder = options.fOptionsPriv->fStoreContextRefInRecorder;
    }
#endif
}

Member Function Documentation

asyncRescaleAndReadPixels() [1/2]

void Context::asyncRescaleAndReadPixels	(	const SkImage *	image,
		const SkImageInfo &	dstImageInfo,
		const SkIRect &	srcRect,
		SkImage::RescaleGamma	rescaleGamma,
		SkImage::RescaleMode	rescaleMode,
		SkImage::ReadPixelsCallback	callback,
		SkImage::ReadPixelsContext	context
	)

Definition at line 245 of file Context.cpp.

                                                                                  {
    this->asyncRescaleAndReadImpl(&Context::asyncReadPixels,
                                  rescaleGamma, rescaleMode,
                                  {image, srcRect, dstImageInfo, callback, callbackContext});
}

asyncRescaleAndReadPixels() [2/2]

void Context::asyncRescaleAndReadPixels	(	const SkSurface *	surface,
		const SkImageInfo &	dstImageInfo,
		const SkIRect &	srcRect,
		SkImage::RescaleGamma	rescaleGamma,
		SkImage::RescaleMode	rescaleMode,
		SkImage::ReadPixelsCallback	callback,
		SkImage::ReadPixelsContext	context
	)

Definition at line 257 of file Context.cpp.

                                                                                  {
    sk_sp<SkImage> surfaceImage = SkSurfaces::AsImage(sk_ref_sp(surface));
    if (!surfaceImage) {
        // The surface is not texturable, so the only supported readback is if there's no rescaling
        if (surface && asConstSB(surface)->isGraphiteBacked() &&
            srcRect.size() == dstImageInfo.dimensions()) {
            TextureProxy* proxy = static_cast<const Surface*>(surface)->backingTextureProxy();
            return this->asyncReadTexture(/*recorder=*/nullptr,
                                          {proxy, srcRect, dstImageInfo, callback, callbackContext},
                                          surface->imageInfo().colorInfo());
        }
        // else fall through and let asyncRescaleAndReadPixels() invoke the callback when it detects
        // the null image.
    }
    this->asyncRescaleAndReadPixels(surfaceImage.get(),
                                    dstImageInfo,
                                    srcRect,
                                    rescaleGamma,
                                    rescaleMode,
                                    callback,
                                    callbackContext);
}

asyncRescaleAndReadPixelsYUV420() [1/2]

void Context::asyncRescaleAndReadPixelsYUV420	(	const SkImage *	image,
		SkYUVColorSpace	yuvColorSpace,
		sk_sp< SkColorSpace >	dstColorSpace,
		const SkIRect &	srcRect,
		const SkISize &	dstSize,
		SkImage::RescaleGamma	rescaleGamma,
		SkImage::RescaleMode	rescaleMode,
		SkImage::ReadPixelsCallback	callback,
		SkImage::ReadPixelsContext	context
	)

Definition at line 351 of file Context.cpp.

                                                                                        {
    // Use kOpaque alpha type to signal that we don't read back the alpha channel
    SkImageInfo dstImageInfo = SkImageInfo::Make(dstSize,
                                                 kRGBA_8888_SkColorType,
                                                 kOpaque_SkAlphaType,
                                                 std::move(dstColorSpace));
    this->asyncRescaleAndReadImpl(&Context::asyncReadPixelsYUV420,
                                  rescaleGamma, rescaleMode,
                                  {image, srcRect, dstImageInfo, callback, callbackContext},
                                  yuvColorSpace);
}

asyncRescaleAndReadPixelsYUV420() [2/2]

void Context::asyncRescaleAndReadPixelsYUV420	(	const SkSurface *	surface,
		SkYUVColorSpace	yuvColorSpace,
		sk_sp< SkColorSpace >	dstColorSpace,
		const SkIRect &	srcRect,
		const SkISize &	dstSize,
		SkImage::RescaleGamma	rescaleGamma,
		SkImage::RescaleMode	rescaleMode,
		SkImage::ReadPixelsCallback	callback,
		SkImage::ReadPixelsContext	context
	)

Definition at line 371 of file Context.cpp.

                                                                                        {
    // YUV[A] readback requires the surface to be texturable since the plane conversion is performed
    // by draws. If AsImage() returns null, the image version of asyncRescaleAndReadback will
    // automatically fail.
    // TODO: Is it worth performing an extra copy from 'surface' into a texture in order to succeed?
    sk_sp<SkImage> surfaceImage = SkSurfaces::AsImage(sk_ref_sp(surface));
    this->asyncRescaleAndReadPixelsYUV420(surfaceImage.get(),
                                          yuvColorSpace,
                                          dstColorSpace,
                                          srcRect,
                                          dstSize,
                                          rescaleGamma,
                                          rescaleMode,
                                          callback,
                                          callbackContext);
}

asyncRescaleAndReadPixelsYUVA420() [1/2]

void Context::asyncRescaleAndReadPixelsYUVA420	(	const SkImage *	image,
		SkYUVColorSpace	yuvColorSpace,
		sk_sp< SkColorSpace >	dstColorSpace,
		const SkIRect &	srcRect,
		const SkISize &	dstSize,
		SkImage::RescaleGamma	rescaleGamma,
		SkImage::RescaleMode	rescaleMode,
		SkImage::ReadPixelsCallback	callback,
		SkImage::ReadPixelsContext	context
	)

Definition at line 396 of file Context.cpp.

                                                                                         {
    SkImageInfo dstImageInfo = SkImageInfo::Make(dstSize,
                                                 kRGBA_8888_SkColorType,
                                                 kPremul_SkAlphaType,
                                                 std::move(dstColorSpace));
    this->asyncRescaleAndReadImpl(&Context::asyncReadPixelsYUV420,
                                  rescaleGamma, rescaleMode,
                                  {image, srcRect, dstImageInfo, callback, callbackContext},
                                  yuvColorSpace);
}

asyncRescaleAndReadPixelsYUVA420() [2/2]

void Context::asyncRescaleAndReadPixelsYUVA420	(	const SkSurface *	surface,
		SkYUVColorSpace	yuvColorSpace,
		sk_sp< SkColorSpace >	dstColorSpace,
		const SkIRect &	srcRect,
		const SkISize &	dstSize,
		SkImage::RescaleGamma	rescaleGamma,
		SkImage::RescaleMode	rescaleMode,
		SkImage::ReadPixelsCallback	callback,
		SkImage::ReadPixelsContext	context
	)

Definition at line 415 of file Context.cpp.

                                                                                         {
    sk_sp<SkImage> surfaceImage = SkSurfaces::AsImage(sk_ref_sp(surface));
    this->asyncRescaleAndReadPixelsYUVA420(surfaceImage.get(),
                                           yuvColorSpace,
                                           dstColorSpace,
                                           srcRect,
                                           dstSize,
                                           rescaleGamma,
                                           rescaleMode,
                                           callback,
                                           callbackContext);
}

backend()

BackendApi Context::backend

(

)

const

Definition at line 130 of file Context.cpp.

{ return fSharedContext->backend(); }

checkAsyncWorkCompletion()

void Context::checkAsyncWorkCompletion

(

)

Checks whether any asynchronous work is complete and if so calls related callbacks.

Definition at line 746 of file Context.cpp.

                                       {
    this->checkForFinishedWork(SyncToCpu::kNo);
}

contextID()

ContextID skgpu::graphite::Context::contextID ( ) const

inline

Definition at line 203 of file Context.h.

{ return fContextID; }

currentBudgetedBytes()

size_t Context::currentBudgetedBytes

(

)

const

Returns the number of bytes of the Context's gpu memory cache budget that are currently in use.

Definition at line 776 of file Context.cpp.

                                           {
    ASSERT_SINGLE_OWNER
    return fResourceProvider->getResourceCacheCurrentBudgetedBytes();
}

deleteBackendTexture()

void Context::deleteBackendTexture

(

const BackendTexture &

texture

)

Called to delete the passed in BackendTexture. This should only be called if the BackendTexture was created by calling Recorder::createBackendTexture on a Recorder created from this Context. If the BackendTexture is not valid or does not match the BackendApi of the Context then nothing happens.

Otherwise this will delete/release the backend object that is wrapped in the BackendTexture. The BackendTexture will be reset to an invalid state and should not be used again.

Definition at line 750 of file Context.cpp.

                                                                {
    ASSERT_SINGLE_OWNER
 
    if (!texture.isValid() || texture.backend() != this->backend()) {
        return;
    }
    fResourceProvider->deleteBackendTexture(texture);
}

dumpMemoryStatistics()

void Context::dumpMemoryStatistics

(

SkTraceMemoryDump *

traceMemoryDump

)

const

Enumerates all cached GPU resources owned by the Context and dumps their memory to traceMemoryDump.

Definition at line 786 of file Context.cpp.

                                                                           {
    ASSERT_SINGLE_OWNER
    fResourceProvider->dumpMemoryStatistics(traceMemoryDump);
    // TODO: What is the graphite equivalent for the text blob cache and how do we print out its
    // used bytes here (see Ganesh implementation).
}

freeGpuResources()

void Context::freeGpuResources

(

)

Frees GPU resources created and held by the Context. Can be called to reduce GPU memory pressure. Any resources that are still in use (e.g. being used by work submitted to the GPU) will not be deleted by this call. If the caller wants to make sure all resources are freed, then they should first make sure to submit and wait on any outstanding work.

Definition at line 759 of file Context.cpp.

                               {
    ASSERT_SINGLE_OWNER
 
    this->checkAsyncWorkCompletion();
 
    fResourceProvider->freeGpuResources();
}

hasUnfinishedGpuWork()

bool Context::hasUnfinishedGpuWork

(

)

const

Returns true if there is work that was submitted to the GPU that has not finished.

Definition at line 175 of file Context.cpp.

{ return fQueueManager->hasUnfinishedGpuWork(); }

insertRecording()

bool Context::insertRecording

(

const InsertRecordingInfo &

info

)

Definition at line 156 of file Context.cpp.

                                                             {
    ASSERT_SINGLE_OWNER
 
    return fQueueManager->addRecording(info, this);
}

isDeviceLost()

bool Context::isDeviceLost

(

)

const

Returns true if the backend-specific context has gotten into an unrecoverarble, lost state (e.g. if we've gotten a VK_ERROR_DEVICE_LOST in the Vulkan backend).

Definition at line 793 of file Context.cpp.

                                 {
    return fSharedContext->isDeviceLost();
}

makeRecorder()

std::unique_ptr< Recorder > Context::makeRecorder

(

const RecorderOptions &

options = {}

)

Definition at line 132 of file Context.cpp.

                                                                            {
    ASSERT_SINGLE_OWNER
 
    // This is a client-owned Recorder so pass a null context so it creates its own ResourceProvider
    auto recorder = std::unique_ptr<Recorder>(new Recorder(fSharedContext, options, nullptr));
#if defined(GRAPHITE_TEST_UTILS)
    if (fStoreContextRefInRecorder) {
        recorder->priv().setContext(this);
    }
#endif
    return recorder;
}

maxBudgetedBytes()

size_t Context::maxBudgetedBytes

(

)

const

Returns the size of Context's gpu memory cache budget in bytes.

Definition at line 781 of file Context.cpp.

                                       {
    ASSERT_SINGLE_OWNER
    return fResourceProvider->getResourceCacheLimit();
}

maxTextureSize()

int Context::maxTextureSize

(

)

const

Returns the maximum texture dimension supported by the underlying backend.

Definition at line 797 of file Context.cpp.

                                  {
    return fSharedContext->caps()->maxTextureSize();
}

operator=() [1/2]

Context & skgpu::graphite::Context::operator= ( const Context &  )

delete

operator=() [2/2]

Context & skgpu::graphite::Context::operator= ( Context &&  )

delete

performDeferredCleanup()

void Context::performDeferredCleanup

(

std::chrono::milliseconds

msNotUsed

)

Purge GPU resources on the Context that haven't been used in the past 'msNotUsed' milliseconds or are otherwise marked for deletion, regardless of whether the context is under budget.

Definition at line 767 of file Context.cpp.

                                                                    {
    ASSERT_SINGLE_OWNER
 
    this->checkAsyncWorkCompletion();
 
    auto purgeTime = skgpu::StdSteadyClock::now() - msNotUsed;
    fResourceProvider->purgeResourcesNotUsedSince(purgeTime);
}

priv() [1/2]

ContextPriv Context::priv ( )

inline

Definition at line 85 of file ContextPriv.h.

{ return ContextPriv(this); }

priv() [2/2]

const ContextPriv Context::priv ( ) const

inline

Definition at line 88 of file ContextPriv.h.

                                             {
    return ContextPriv(const_cast<Context *>(this));
}

submit()

bool Context::submit

(

SyncToCpu

syncToCpu = SyncToCpu::kNo

)

Definition at line 162 of file Context.cpp.

                                        {
    ASSERT_SINGLE_OWNER
 
    if (syncToCpu == SyncToCpu::kYes && !fSharedContext->caps()->allowCpuSync()) {
        SKGPU_LOG_E("SyncToCpu::kYes not supported with ContextOptions::fNeverYieldToWebGPU. "
                    "The parameter is ignored and no synchronization will occur.");
        syncToCpu = SyncToCpu::kNo;
    }
    bool success = fQueueManager->submitToGpu();
    this->checkForFinishedWork(syncToCpu);
    return success;
}

supportsProtectedContent()

bool Context::supportsProtectedContent

(

)

const

Definition at line 801 of file Context.cpp.

                                             {
    return fSharedContext->isProtected() == Protected::kYes;
}

Friends And Related Function Documentation

ContextCtorAccessor

friend class ContextCtorAccessor

friend

Definition at line 210 of file Context.h.

ContextPriv

friend class ContextPriv

friend

Definition at line 209 of file Context.h.

---

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

• third_party/skia/include/gpu/graphite/Context.h
• third_party/skia/src/gpu/graphite/Context.cpp
• third_party/skia/src/gpu/graphite/ContextPriv.h