GrVkSecondaryCBDrawContext Class Reference

#include <GrVkSecondaryCBDrawContext.h>

Inheritance diagram for GrVkSecondaryCBDrawContext:

Public Member Functions
	~GrVkSecondaryCBDrawContext () override
SkCanvas *	getCanvas ()
void	flush ()
bool	wait (int numSemaphores, const GrBackendSemaphore waitSemaphores[], bool deleteSemaphoresAfterWait=true)
void	releaseResources ()
const SkSurfaceProps &	props () const
bool	characterize (GrSurfaceCharacterization *characterization) const
bool	draw (sk_sp< const GrDeferredDisplayList > deferredDisplayList)
bool	isCompatible (const GrSurfaceCharacterization &characterization) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< GrVkSecondaryCBDrawContext >	Make (GrRecordingContext *, const SkImageInfo &, const GrVkDrawableInfo &, const SkSurfaceProps *props)

Detailed Description

This class is a private header that is intended to only be used inside of Chromium. This requires Chromium to burrow in and include this specifically since it is not part of skia's public include directory. This class is used to draw into an external Vulkan secondary command buffer that is imported by the client. The secondary command buffer that gets imported must already have had begin called on it with VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT. Thus any draws to the imported command buffer cannot require changing the render pass. This requirement means that certain types of draws will not be supported when using a GrVkSecondaryCBDrawContext. This includes: Draws that require a dst copy for blending will be dropped Text draws will be dropped (these may require intermediate uploads of text data) Read and Write pixels will not work Any other draw that requires a copy will fail (this includes using backdrop filter with save layer). Stenciling is also disabled, but that should not restrict any actual draws from working.

While using a GrVkSecondaryCBDrawContext, the client can also draw into normal SkSurfaces and then draw those SkSufaces (as SkImages) into the GrVkSecondaryCBDrawContext. If any of the previously mentioned unsupported draws are needed by the client, they can draw them into an offscreen surface, and then draw that into the GrVkSecondaryCBDrawContext.

After all drawing to the GrVkSecondaryCBDrawContext has been done, the client must call flush() on the GrVkSecondaryCBDrawContext to actually fill in the secondary VkCommandBuffer with the draws.

Additionally, the client must keep the GrVkSecondaryCBDrawContext alive until the secondary VkCommandBuffer has been submitted and all work finished on the GPU. Before deleting the GrVkSecondaryCBDrawContext, the client must call releaseResources() so that Skia can cleanup any internal objects that were created for the draws into the secondary command buffer.

Definition at line 62 of file GrVkSecondaryCBDrawContext.h.

Constructor & Destructor Documentation

~GrVkSecondaryCBDrawContext()

GrVkSecondaryCBDrawContext::~GrVkSecondaryCBDrawContext ( )

override

Definition at line 97 of file GrVkSecondaryCBDrawContext.cpp.

                                                        {
    SkASSERT(!fDevice);
    SkASSERT(!fCachedCanvas.get());
}

Member Function Documentation

characterize()

bool GrVkSecondaryCBDrawContext::characterize

(

GrSurfaceCharacterization *

characterization

)

const

Definition at line 129 of file GrVkSecondaryCBDrawContext.cpp.

                                                                                               {
    auto direct = fDevice->recordingContext()->asDirectContext();
    if (!direct) {
        return false;
    }
 
    SkImageInfo ii = fDevice->imageInfo();
    if (ii.colorType() == kUnknown_SkColorType) {
        return false;
    }
 
    GrSurfaceProxyView readSurfaceView = fDevice->readSurfaceView();
    size_t maxResourceBytes = direct->getResourceCacheLimit();
 
    // We current don't support textured GrVkSecondaryCBDrawContexts.
    SkASSERT(!readSurfaceView.asTextureProxy());
 
    GrBackendFormat format = readSurfaceView.asRenderTargetProxy()->backendFormat();
    int numSamples = readSurfaceView.asRenderTargetProxy()->numSamples();
    GrProtected isProtected = readSurfaceView.asRenderTargetProxy()->isProtected();
 
    characterization->set(direct->threadSafeProxy(),
                          maxResourceBytes,
                          ii,
                          format,
                          readSurfaceView.origin(),
                          numSamples,
                          GrSurfaceCharacterization::Textureable(false),
                          skgpu::Mipmapped::kNo,
                          GrSurfaceCharacterization::UsesGLFBO0(false),
                          GrSurfaceCharacterization::VkRTSupportsInputAttachment(false),
                          GrSurfaceCharacterization::VulkanSecondaryCBCompatible(true),
                          isProtected,
                          this->props());
 
    return true;
}

draw()

bool GrVkSecondaryCBDrawContext::draw

(

sk_sp< const GrDeferredDisplayList >

deferredDisplayList

)

Definition at line 222 of file GrVkSecondaryCBDrawContext.cpp.

                                                                            {
#else
bool GrVkSecondaryCBDrawContext::draw(const GrDeferredDisplayList* ddl) {
#endif
    if (!ddl || !this->isCompatible(ddl->characterization())) {
        return false;
    }
 
    auto direct = fDevice->recordingContext()->asDirectContext();
    if (!direct) {
        return false;
    }
 
    GrSurfaceProxyView readSurfaceView = fDevice->readSurfaceView();
 
    direct->priv().createDDLTask(std::move(ddl), readSurfaceView.asRenderTargetProxyRef());
    return true;
}

flush()

void GrVkSecondaryCBDrawContext::flush

(

)

Definition at line 109 of file GrVkSecondaryCBDrawContext.cpp.

                                       {
    auto dContext = GrAsDirectContext(fDevice->recordingContext());
 
    if (dContext) {
        dContext->priv().flushSurface(fDevice->targetProxy());
        dContext->submit();
    }
}

getCanvas()

SkCanvas * GrVkSecondaryCBDrawContext::getCanvas

(

)

Definition at line 102 of file GrVkSecondaryCBDrawContext.cpp.

                                                {
    if (!fCachedCanvas) {
        fCachedCanvas = std::make_unique<SkCanvas>(fDevice);
    }
    return fCachedCanvas.get();
}

isCompatible()

bool GrVkSecondaryCBDrawContext::isCompatible

(

const GrSurfaceCharacterization &

characterization

)

const

Definition at line 167 of file GrVkSecondaryCBDrawContext.cpp.

                                                                 {
 
    auto dContext = fDevice->recordingContext()->asDirectContext();
    if (!dContext) {
        return false;
    }
 
    if (!characterization.isValid()) {
        return false;
    }
 
    if (!characterization.vulkanSecondaryCBCompatible()) {
        return false;
    }
 
    if (characterization.isTextureable()) {
        // We don't support textureable DDL when rendering to a GrVkSecondaryCBDrawContext.
        return false;
    }
 
    if (characterization.usesGLFBO0()) {
        return false;
    }
 
    SkImageInfo ii = fDevice->imageInfo();
    if (ii.colorType() == kUnknown_SkColorType) {
        return false;
    }
 
    GrSurfaceProxyView readSurfaceView = fDevice->readSurfaceView();
    // As long as the current state in the context allows for greater or equal resources,
    // we allow the DDL to be replayed.
    // DDL TODO: should we just remove the resource check and ignore the cache limits on playback?
    size_t maxResourceBytes = dContext->getResourceCacheLimit();
 
    GrBackendFormat format = readSurfaceView.asRenderTargetProxy()->backendFormat();
    int numSamples = readSurfaceView.asRenderTargetProxy()->numSamples();
    GrProtected isProtected = readSurfaceView.asRenderTargetProxy()->isProtected();
 
    return characterization.contextInfo() &&
           characterization.contextInfo()->priv().matches(dContext) &&
           characterization.cacheMaxResourceBytes() <= maxResourceBytes &&
           characterization.origin() == readSurfaceView.origin() &&
           characterization.backendFormat() == format &&
           characterization.width() == ii.width() &&
           characterization.height() == ii.height() &&
           characterization.colorType() == ii.colorType() &&
           characterization.sampleCount() == numSamples &&
           SkColorSpace::Equals(characterization.colorSpace(), ii.colorInfo().colorSpace()) &&
           characterization.isProtected() == isProtected &&
           characterization.surfaceProps() == fDevice->surfaceProps();
}

Make()

sk_sp< GrVkSecondaryCBDrawContext > GrVkSecondaryCBDrawContext::Make ( GrRecordingContext *  rContext, const SkImageInfo &  imageInfo, const GrVkDrawableInfo &  vkInfo, const SkSurfaceProps *  props  )

static

Definition at line 27 of file GrVkSecondaryCBDrawContext.cpp.

                                                                                                {
    if (!rContext) {
        return nullptr;
    }
 
    if (rContext->backend() != GrBackendApi::kVulkan) {
        return nullptr;
    }
 
 
    GrProxyProvider* gpp = rContext->priv().proxyProvider();
    if (gpp->isAbandoned()) {
        return nullptr;
    }
 
    GrResourceProvider* resourceProvider = gpp->resourceProvider();
    if (!resourceProvider) {
        return nullptr;
    }
 
    sk_sp<GrRenderTarget> rt = resourceProvider->wrapVulkanSecondaryCBAsRenderTarget(imageInfo,
                                                                                     vkInfo);
    if (!rt) {
        return nullptr;
    }
 
    SkASSERT(!rt->asTexture());  // A GrRenderTarget that's not textureable
    SkASSERT(!rt->getUniqueKey().isValid());
    // This proxy should be unbudgeted because we're just wrapping an external resource
    SkASSERT(GrBudgetedType::kBudgeted != rt->resourcePriv().budgetedType());
 
    GrColorType colorType = SkColorTypeToGrColorType(imageInfo.colorType());
 
    if (!gpp->caps()->isFormatAsColorTypeRenderable(
            colorType, GrBackendFormats::MakeVk(vkInfo.fFormat), /*sampleCount=*/1)) {
        return nullptr;
    }
 
    sk_sp<GrRenderTargetProxy> proxy(
            new GrRenderTargetProxy(std::move(rt),
                                    GrSurfaceProxy::UseAllocator::kNo,
                                    GrRenderTargetProxy::WrapsVkSecondaryCB::kYes));
 
    if (!proxy) {
        return nullptr;
    }
 
    SkASSERT(proxy->isInstantiated());
 
    auto device = rContext->priv().createDevice(SkColorTypeToGrColorType(imageInfo.colorType()),
                                                std::move(proxy),
                                                imageInfo.refColorSpace(),
                                                kTopLeft_GrSurfaceOrigin,
                                                SkSurfacePropsCopyOrDefault(props),
                                                skgpu::ganesh::Device::InitContents::kUninit);
    if (!device) {
        return nullptr;
    }
 
    return sk_sp<GrVkSecondaryCBDrawContext>(new GrVkSecondaryCBDrawContext(std::move(device),
                                                                            props));
}

props()

const SkSurfaceProps & GrVkSecondaryCBDrawContext::props ( ) const

inline

Definition at line 108 of file GrVkSecondaryCBDrawContext.h.

{ return fProps; }

releaseResources()

void GrVkSecondaryCBDrawContext::releaseResources

(

)

Definition at line 124 of file GrVkSecondaryCBDrawContext.cpp.

                                                  {
    fCachedCanvas.reset();
    fDevice.reset();
}

wait()

bool GrVkSecondaryCBDrawContext::wait	(	int	numSemaphores,
		const GrBackendSemaphore	waitSemaphores[],
		bool	deleteSemaphoresAfterWait = true
	)

Inserts a list of GPU semaphores that Skia will have the driver wait on before executing commands for this secondary CB. The wait semaphores will get added to the VkCommandBuffer owned by this GrContext when flush() is called, and not the command buffer which the Secondary CB is from. This will guarantee that the driver waits on the semaphores before the secondary command buffer gets executed. We will submit the semphore to wait at VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT and VK_PIPELINE_STAGE_TRANSFER_BIT. If this call returns false, then the GPU back end will not wait on any passed in semaphores, and the client will still own the semaphores, regardless of the value of deleteSemaphoresAfterWait.

If deleteSemaphoresAfterWait is false then Skia will not delete the semaphores. In this case it is the client's responsibility to not destroy or attempt to reuse the semaphores until it knows that Skia has finished waiting on them. This can be done by using finishedProcs on flush calls.

Parameters

numSemaphores	size of waitSemaphores array
waitSemaphores	array of semaphore containers @paramm deleteSemaphoresAfterWait who owns and should delete the semaphores

Returns

true if GPU is waiting on semaphores

Definition at line 118 of file GrVkSecondaryCBDrawContext.cpp.

                                                                      {
    return fDevice->wait(numSemaphores, waitSemaphores, deleteSemaphoresAfterWait);
}

---

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

• third_party/skia/include/private/chromium/GrVkSecondaryCBDrawContext.h
• third_party/skia/src/gpu/ganesh/vk/GrVkSecondaryCBDrawContext.cpp