SkSurface_Ganesh.cpp File Reference

#include "src/gpu/ganesh/surface/SkSurface_Ganesh.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkImage.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkSurface.h"
#include "include/core/SkSurfaceProps.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrContextThreadSafeProxy.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "include/private/base/SkTo.h"
#include "include/private/chromium/GrDeferredDisplayList.h"
#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/core/SkDevice.h"
#include "src/core/SkSurfacePriv.h"
#include "src/gpu/RefCntedCallback.h"
#include "src/gpu/SkBackingFit.h"
#include "src/gpu/SkRenderEngineAbortf.h"
#include "src/gpu/ganesh/Device.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrContextThreadSafeProxyPriv.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrGpuResourcePriv.h"
#include "src/gpu/ganesh/GrProxyProvider.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrRenderTarget.h"
#include "src/gpu/ganesh/GrRenderTargetProxy.h"
#include "src/gpu/ganesh/GrSurfaceProxy.h"
#include "src/gpu/ganesh/GrSurfaceProxyPriv.h"
#include "src/gpu/ganesh/GrSurfaceProxyView.h"
#include "src/gpu/ganesh/GrTexture.h"
#include "src/gpu/ganesh/GrTextureProxy.h"
#include "src/gpu/ganesh/image/SkImage_Ganesh.h"
#include "src/image/SkImage_Base.h"
#include <algorithm>
#include <cstddef>
#include <utility>

Go to the source code of this file.

Namespaces
namespace	SkSurfaces
namespace	skgpu
namespace	skgpu::ganesh

Functions
static GrRenderTarget *	prepare_rt_for_external_access (SkSurface_Ganesh *surface, SkSurfaces::BackendHandleAccess access)
static bool	validate_backend_texture (const GrCaps *caps, const GrBackendTexture &tex, int sampleCnt, GrColorType grCT, bool texturable)
bool	validate_backend_render_target (const GrCaps *caps, const GrBackendRenderTarget &rt, GrColorType grCT)
SK_API sk_sp< SkSurface >	SkSurfaces::RenderTarget (GrRecordingContext *context, const GrSurfaceCharacterization &characterization, skgpu::Budgeted budgeted)
SK_API sk_sp< SkSurface >	SkSurfaces::RenderTarget (GrRecordingContext *context, skgpu::Budgeted budgeted, const SkImageInfo &imageInfo, int sampleCount, GrSurfaceOrigin surfaceOrigin, const SkSurfaceProps *surfaceProps, bool shouldCreateWithMips=false, bool isProtected=false)
SK_API sk_sp< SkSurface >	SkSurfaces::WrapBackendTexture (GrRecordingContext *context, const GrBackendTexture &backendTexture, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *surfaceProps, TextureReleaseProc textureReleaseProc=nullptr, ReleaseContext releaseContext=nullptr)
SK_API sk_sp< SkSurface >	SkSurfaces::WrapBackendRenderTarget (GrRecordingContext *context, const GrBackendRenderTarget &backendRenderTarget, GrSurfaceOrigin origin, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *surfaceProps, RenderTargetReleaseProc releaseProc=nullptr, ReleaseContext releaseContext=nullptr)
SK_API GrBackendTexture	SkSurfaces::GetBackendTexture (SkSurface *, BackendHandleAccess)
SK_API GrBackendRenderTarget	SkSurfaces::GetBackendRenderTarget (SkSurface *, BackendHandleAccess)
SK_API void	SkSurfaces::ResolveMSAA (SkSurface *surface)
SK_API GrSemaphoresSubmitted	skgpu::ganesh::Flush (SkSurface *)
SK_API GrSemaphoresSubmitted	skgpu::ganesh::Flush (sk_sp< SkSurface >)
SK_API void	skgpu::ganesh::FlushAndSubmit (SkSurface *)
SK_API void	skgpu::ganesh::FlushAndSubmit (sk_sp< SkSurface >)

Function Documentation

prepare_rt_for_external_access()

static GrRenderTarget * prepare_rt_for_external_access ( SkSurface_Ganesh *  surface, SkSurfaces::BackendHandleAccess  access  )

static

Definition at line 85 of file SkSurface_Ganesh.cpp.

                                                                                            {
    auto dContext = surface->recordingContext()->asDirectContext();
    if (!dContext) {
        return nullptr;
    }
    if (dContext->abandoned()) {
        return nullptr;
    }
 
    switch (access) {
        case SkSurfaces::BackendHandleAccess::kFlushRead:
            break;
        case SkSurfaces::BackendHandleAccess::kFlushWrite:
        case SkSurfaces::BackendHandleAccess::kDiscardWrite:
            // for now we don't special-case on Discard, but we may in the future.
            surface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
            break;
    }
 
    dContext->priv().flushSurface(surface->getDevice()->targetProxy());
 
    // Grab the render target *after* firing notifications, as it may get switched if CoW kicks in.
    return surface->getDevice()->targetProxy()->peekRenderTarget();
}

validate_backend_render_target()

bool validate_backend_render_target	(	const GrCaps *	caps,
		const GrBackendRenderTarget &	rt,
		GrColorType	grCT
	)

Definition at line 532 of file SkSurface_Ganesh.cpp.

                                                      {
    if (!caps->areColorTypeAndFormatCompatible(grCT, rt.getBackendFormat())) {
        return false;
    }
 
    if (!caps->isFormatAsColorTypeRenderable(grCT, rt.getBackendFormat(), rt.sampleCnt())) {
        return false;
    }
 
    // We require the stencil bits to be either 0, 8, or 16.
    int stencilBits = rt.stencilBits();
    if (stencilBits != 0 && stencilBits != 8 && stencilBits != 16) {
        return false;
    }
 
    return true;
}

validate_backend_texture()

static bool validate_backend_texture ( const GrCaps *  caps, const GrBackendTexture &  tex, int  sampleCnt, GrColorType  grCT, bool  texturable  )

static

Definition at line 428 of file SkSurface_Ganesh.cpp.

                                                      {
    if (!tex.isValid()) {
        return false;
    }
 
    GrBackendFormat backendFormat = tex.getBackendFormat();
    if (!backendFormat.isValid()) {
        RENDERENGINE_ABORTF("%s failed due to an invalid format", __func__);
        return false;
    }
 
    if (!caps->areColorTypeAndFormatCompatible(grCT, backendFormat)) {
        RENDERENGINE_ABORTF("%s failed due to an invalid format and colorType combination",
                            __func__);
        return false;
    }
 
    if (!caps->isFormatAsColorTypeRenderable(grCT, backendFormat, sampleCnt)) {
        RENDERENGINE_ABORTF(
                "%s failed due to no supported rendering path for the selected "
                "format and colorType",
                __func__);
        return false;
    }
 
    if (texturable && !caps->isFormatTexturable(backendFormat, tex.textureType())) {
        RENDERENGINE_ABORTF(
                "%s failed due to no texturing support for the selected format and "
                "colorType",
                __func__);
        return false;
    }
 
    return true;
}