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 97 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 78 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 163 of file Context.cpp.

                                                                                  {
    if (!image || !as_IB(image)->isGraphiteBacked()) {
        callback(callbackContext, nullptr);
        return;
    }
    // TODO(b/238756380): YUVA read not supported right now
    if (as_IB(image)->isYUVA()) {
        callback(callbackContext, nullptr);
        return;
    }
 
    if (!SkIRect::MakeSize(image->imageInfo().dimensions()).contains(srcRect)) {
        callback(callbackContext, nullptr);
        return;
    }
 
    if (srcRect.size() == dstImageInfo.bounds().size()) {
        // No need for rescale
        auto graphiteImage = reinterpret_cast<const skgpu::graphite::Image*>(image);
        const TextureProxyView& proxyView = graphiteImage->textureProxyView();
        return this->asyncReadPixels(proxyView.proxy(),
                                     image->imageInfo(),
                                     dstImageInfo.colorInfo(),
                                     srcRect,
                                     callback,
                                     callbackContext);
    }
 
    // Make a recorder to record drawing commands into
    std::unique_ptr<Recorder> recorder = this->makeRecorder();
 
    sk_sp<SkImage> scaledImage = RescaleImage(recorder.get(),
                                              image,
                                              srcRect,
                                              dstImageInfo,
                                              rescaleGamma,
                                              rescaleMode);
    if (!scaledImage) {
        callback(callbackContext, nullptr);
        return;
    }
 
    // Add draw commands to queue before starting the transfer
    std::unique_ptr<Recording> recording = recorder->snap();
    if (!recording) {
        callback(callbackContext, nullptr);
        return;
    }
    InsertRecordingInfo recordingInfo;
    recordingInfo.fRecording = recording.get();
    if (!this->insertRecording(recordingInfo)) {
        callback(callbackContext, nullptr);
        return;
    }
 
    SkASSERT(scaledImage->imageInfo() == dstImageInfo);
 
    auto scaledGraphiteImage = reinterpret_cast<const skgpu::graphite::Image*>(scaledImage.get());
    const TextureProxyView& scaledProxyView = scaledGraphiteImage->textureProxyView();
 
    this->asyncReadPixels(scaledProxyView.proxy(),
                          dstImageInfo,
                          dstImageInfo.colorInfo(),
                          dstImageInfo.bounds(),
                          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 237 of file Context.cpp.

                                                                                  {
    if (!static_cast<const SkSurface_Base*>(surface)->isGraphiteBacked()) {
        callback(callbackContext, nullptr);
        return;
    }
 
    sk_sp<SkImage> surfaceImage = SkSurfaces::AsImage(sk_ref_sp(surface));
    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 340 of file Context.cpp.

                                                                                        {
    this->asyncRescaleAndReadPixelsYUV420Impl(image,
                                              yuvColorSpace,
                                              /*readAlpha=*/false,
                                              dstColorSpace,
                                              srcRect,
                                              dstSize,
                                              rescaleGamma,
                                              rescaleMode,
                                              callback,
                                              callbackContext);
}

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 361 of file Context.cpp.

                                                                                        {
    if (!static_cast<const SkSurface_Base*>(surface)->isGraphiteBacked()) {
        callback(callbackContext, nullptr);
        return;
    }
 
    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 387 of file Context.cpp.

                                                                                         {
    this->asyncRescaleAndReadPixelsYUV420Impl(image,
                                              yuvColorSpace,
                                              /*readAlpha=*/true,
                                              dstColorSpace,
                                              srcRect,
                                              dstSize,
                                              rescaleGamma,
                                              rescaleMode,
                                              callback,
                                              callbackContext);
}

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 408 of file Context.cpp.

                                                                                         {
    if (!static_cast<const SkSurface_Base*>(surface)->isGraphiteBacked()) {
        callback(callbackContext, nullptr);
        return;
    }
 
    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 128 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 786 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 816 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 790 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 826 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 799 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 161 of file Context.cpp.

{ return fQueueManager->hasUnfinishedGpuWork(); }

insertRecording()

bool Context::insertRecording

(

const InsertRecordingInfo &

info

)

Definition at line 142 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 833 of file Context.cpp.

                                 {
    return fSharedContext->isDeviceLost();
}

makeRecorder()

std::unique_ptr< Recorder > Context::makeRecorder

(

const RecorderOptions &

options = {}

)

Definition at line 130 of file Context.cpp.

                                                                            {
    ASSERT_SINGLE_OWNER
 
    auto recorder = std::unique_ptr<Recorder>(new Recorder(fSharedContext, options));
#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 821 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 837 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 807 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 148 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 841 of file Context.cpp.

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

Friends And Related Symbol 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