sk_gpu_test Namespace Reference

Namespaces
namespace	test_ops

Classes
class	ContextInfo
class	FenceSync
class	FlushFinishTracker
class	GLTestContext
class	GpuTimer
class	GrContextFactory
class	LazyYUVImage
class	MemoryCache
class	TestContext
class	VkTestMemoryAllocator

Typedefs
using	Mipmapped = skgpu::Mipmapped
using	Protected = skgpu::Protected
using	Renderable = skgpu::Renderable
using	PlatformFence = uint64_t
using	PlatformTimerQuery = uint64_t

Enumerations
enum class	ANGLEBackend { kD3D9 , kD3D11 , kOpenGL , kMetal }
enum class	ANGLEContextVersion { kES2 , kES3 }

Functions
GLTestContext *	CreatePlatformGLTestContext (GrGLStandard forcedGpuAPI, GLTestContext *shareContext)
sk_sp< SkSurface >	MakeBackendTextureSurface (GrDirectContext *dContext, const SkImageInfo &ii, GrSurfaceOrigin origin, int sampleCnt, skgpu::Mipmapped mipmapped, GrProtected isProtected, const SkSurfaceProps *props)
sk_sp< SkSurface >	MakeBackendTextureSurface (GrDirectContext *dContext, SkISize dimensions, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, skgpu::Mipmapped mipmapped, GrProtected isProtected, const SkSurfaceProps *props)
sk_sp< SkSurface >	MakeBackendRenderTargetSurface (GrDirectContext *dContext, const SkImageInfo &ii, GrSurfaceOrigin origin, int sampleCnt, GrProtected isProtected, const SkSurfaceProps *props)
sk_sp< SkSurface >	MakeBackendRenderTargetSurface (GrDirectContext *dContext, SkISize dimensions, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, GrProtected isProtected, const SkSurfaceProps *props)
sk_sp< const GrGLInterface >	CreateANGLEGLInterface ()
std::unique_ptr< GLTestContext >	MakeANGLETestContext (ANGLEBackend type, ANGLEContextVersion version, GLTestContext *shareContext, void *display)
static bool	fence_is_supported (const GLTestContext *ctx)
TestContext *	CreateMockTestContext (TestContext *)
MtlTestContext *	CreatePlatformMtlTestContext (MtlTestContext *sharedContext)
GrTextureProxy *	GetTextureImageProxy (SkImage *image, GrRecordingContext *rContext)
GrSurfaceProxyView	MakeTextureProxyViewFromData (GrDirectContext *dContext, GrRenderable renderable, GrSurfaceOrigin origin, GrCPixmap pixmap)
std::tuple< std::array< sk_sp< SkImage >, SkYUVAInfo::kMaxPlanes >, SkYUVAInfo >	MakeYUVAPlanesAsA8 (SkImage *src, SkYUVColorSpace cs, SkYUVAInfo::Subsampling ss, GrRecordingContext *rContext)

Variables
static constexpr PlatformFence	kInvalidFence = 0
static constexpr PlatformTimerQuery	kInvalidTimerQuery = 0

Typedef Documentation

Mipmapped

using sk_gpu_test::Mipmapped = typedef skgpu::Mipmapped

Definition at line 32 of file BackendTextureImageFactory.h.

PlatformFence

using sk_gpu_test::PlatformFence = typedef uint64_t

Definition at line 15 of file FenceSync.h.

PlatformTimerQuery

using sk_gpu_test::PlatformTimerQuery = typedef uint64_t

Definition at line 17 of file GpuTimer.h.

Protected

using sk_gpu_test::Protected = typedef skgpu::Protected

Definition at line 33 of file BackendTextureImageFactory.h.

Renderable

using sk_gpu_test::Renderable = typedef skgpu::Renderable

Definition at line 34 of file BackendTextureImageFactory.h.

Enumeration Type Documentation

ANGLEBackend

enum class sk_gpu_test::ANGLEBackend

strong

Enumerator
kD3D9
kD3D11
kOpenGL
kMetal

Definition at line 21 of file GLTestContext_angle.h.

                        {
    kD3D9,
    kD3D11,
    kOpenGL,
    kMetal
};

ANGLEContextVersion

enum class sk_gpu_test::ANGLEContextVersion

strong

Enumerator
kES2
kES3

Definition at line 28 of file GLTestContext_angle.h.

                               {
    kES2,
    kES3
};

Function Documentation

CreateANGLEGLInterface()

sk_sp< const GrGLInterface > sk_gpu_test::CreateANGLEGLInterface

(

)

Creates a GrGLInterface for the current ANGLE GLES Context. Here current means bound in ANGLE's implementation of EGL.

Definition at line 502 of file GLTestContext_angle.cpp.

                                                    {
    static Libs gLibs = { nullptr, nullptr };
 
    if (nullptr == gLibs.fGLLib) {
        // We load the ANGLE library and never let it go
#if defined(SK_BUILD_FOR_WIN)
        gLibs.fGLLib = SkLoadDynamicLibrary("libGLESv2.dll");
        gLibs.fEGLLib = SkLoadDynamicLibrary("libEGL.dll");
#elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
        gLibs.fGLLib = SkLoadDynamicLibrary("libGLESv2.dylib");
        gLibs.fEGLLib = SkLoadDynamicLibrary("libEGL.dylib");
#else
        gLibs.fGLLib = SkLoadDynamicLibrary("libGLESv2.so");
        gLibs.fEGLLib = SkLoadDynamicLibrary("libEGL.so");
#endif
    }
 
    if (nullptr == gLibs.fGLLib || nullptr == gLibs.fEGLLib) {
        // We can't setup the interface correctly w/o the so
        return nullptr;
    }
 
    return GrGLMakeAssembledGLESInterface(&gLibs, angle_get_gl_proc);
}

CreateMockTestContext()

TestContext * sk_gpu_test::CreateMockTestContext

(

TestContext *

shareContext = nullptr

)

Creates mock context object for use with GrContexts created with GrBackendApi::kMock. It will trivially succeed at everything.

Definition at line 44 of file MockTestContext.cpp.

{ return new MockTestContext(); }

CreatePlatformGLTestContext()

GLTestContext * sk_gpu_test::CreatePlatformGLTestContext	(	GrGLStandard	forcedGpuAPI,
		GLTestContext *	shareContext = nullptr
	)

Creates platform-dependent GL context object. The shareContext parameter is in an optional context with which to share display lists. This should be a pointer to an GLTestContext created with SkCreatePlatformGLTestContext. NULL indicates that no sharing is to take place. Returns a valid gl context object or NULL if such can not be created.

Definition at line 340 of file gm_bindings.cpp.

                                                                        {
    return new WasmWebGlTestContext();
}

CreatePlatformMtlTestContext()

MtlTestContext * sk_gpu_test::CreatePlatformMtlTestContext

(

MtlTestContext *

sharedContext

)

Definition at line 79 of file MtlTestContext.mm.

                                                                            {
    return MtlTestContextImpl::Create(sharedContext);
}

fence_is_supported()

static bool sk_gpu_test::fence_is_supported ( const GLTestContext *  ctx )

static

Definition at line 163 of file GLTestContext.cpp.

                                                         {
    if (kGL_GrGLStandard == ctx->gl()->fStandard) {
        if (GrGLGetVersion(ctx->gl()) < GR_GL_VER(3, 2) &&
            !ctx->gl()->hasExtension("GL_ARB_sync")) {
            return false;
        }
        return true;
    } else {
        if (ctx->gl()->hasExtension("GL_APPLE_sync")) {
            return true;
        } else if (ctx->gl()->hasExtension("GL_NV_fence")) {
            return true;
        } else if (GrGLGetVersion(ctx->gl()) >= GR_GL_VER(3, 0)) {
            return true;
        } else {
            return false;
        }
    }
}

GetTextureImageProxy()

GrTextureProxy * sk_gpu_test::GetTextureImageProxy	(	SkImage *	,
		GrRecordingContext *
	)

Returns the proxy backing an image if it is texture backed, otherwise nullptr.

Definition at line 32 of file ProxyUtils.cpp.

                                                                                   {
    if (!as_IB(image)->isGaneshBacked() || as_IB(image)->isYUVA()) {
        return nullptr;
    }
    if (!rContext) {
        // If the image is backed by a recording context we'll use that.
        GrImageContext* iContext = as_IB(image)->context();
        SkASSERT(iContext);
        rContext = iContext->priv().asRecordingContext();
        if (!rContext) {
            return nullptr;
        }
    }
    auto [view, ct] = skgpu::ganesh::AsView(rContext, image, skgpu::Mipmapped::kNo);
    if (!view) {
        // With the above checks we expect this to succeed unless there is a context mismatch.
        SkASSERT(!image->isValid(rContext));
        return nullptr;
    }
    GrSurfaceProxy* proxy = view.proxy();
    SkASSERT(proxy->asTextureProxy());
    return proxy->asTextureProxy();
}

MakeANGLETestContext()

std::unique_ptr< GLTestContext > sk_gpu_test::MakeANGLETestContext	(	ANGLEBackend	,
		ANGLEContextVersion	,
		GLTestContext *	shareContext = nullptr,
		void *	display = nullptr
	)

Creates a GLTestContext backed by ANGLE.

Definition at line 527 of file GLTestContext_angle.cpp.

                                                                                                {
#if defined(SK_BUILD_FOR_WIN) && defined(_M_ARM64)
    // Windows-on-ARM only has D3D11. This will fail correctly, but it produces huge amounts of
    // debug output for every unit test from both ANGLE and our context factory.
    if (ANGLEBackend::kD3D11 != type) {
        return nullptr;
    }
#endif
 
    // These checks squelch spam when display creation predictably fails
#if defined(SK_BUILD_FOR_WIN)
    if (ANGLEBackend::kMetal == type) {
        return nullptr;
    }
#endif
 
#if defined(SK_BUILD_FOR_MAC)
    if (ANGLEBackend::kMetal != type) {
        return nullptr;
    }
#endif
 
    ANGLEGLContext* angleShareContext = reinterpret_cast<ANGLEGLContext*>(shareContext);
    std::unique_ptr<GLTestContext> ctx(new ANGLEGLContext(type, version,
                                                          angleShareContext, display));
    if (!ctx->isValid()) {
        return nullptr;
    }
    return ctx;
}

MakeBackendRenderTargetSurface() [1/2]

sk_sp< SkSurface > sk_gpu_test::MakeBackendRenderTargetSurface	(	GrDirectContext *	,
		const SkImageInfo &	,
		GrSurfaceOrigin	,
		int	sampleCnt,
		GrProtected	= GrProtected::kNo,
		const SkSurfaceProps *	= nullptr
	)

Creates an SkSurface backed by a non-textureable render target.

Definition at line 70 of file BackendSurfaceFactory.cpp.

                                                                             {
    if (ii.alphaType() == kUnpremul_SkAlphaType || ii.alphaType() == kUnknown_SkAlphaType) {
        return nullptr;
    }
    auto ct = SkColorTypeToGrColorType(ii.colorType());
 
    struct ReleaseContext {
        sk_sp<GrDirectContext> fContext;
        GrBackendRenderTarget fRenderTarget;
    };
 
    auto bert = dContext->priv().getGpu()->createTestingOnlyBackendRenderTarget(
            ii.dimensions(), ct, sampleCnt, isProtected);
    auto rc = new ReleaseContext{sk_ref_sp(dContext), bert};
    SkASSERT(!bert.isValid() || bert.sampleCnt() >= sampleCnt);
 
    auto proc = [](void* c) {
        const auto* rc = static_cast<ReleaseContext*>(c);
        if (auto gpu = rc->fContext->priv().getGpu(); gpu && rc->fRenderTarget.isValid()) {
            gpu->deleteTestingOnlyBackendRenderTarget(rc->fRenderTarget);
        }
        delete rc;
    };
 
    return SkSurfaces::WrapBackendRenderTarget(
            dContext, bert, origin, ii.colorType(), ii.refColorSpace(), props, proc, rc);
}

MakeBackendRenderTargetSurface() [2/2]

sk_sp< SkSurface > sk_gpu_test::MakeBackendRenderTargetSurface	(	GrDirectContext *	dContext,
		SkISize	dimensions,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		GrProtected	isProtected,
		const SkSurfaceProps *	props
	)

Definition at line 103 of file BackendSurfaceFactory.cpp.

                                                                             {
    auto ii = SkImageInfo::Make(dimensions, colorType, kPremul_SkAlphaType, std::move(colorSpace));
    return MakeBackendRenderTargetSurface(dContext, ii, origin, sampleCnt, isProtected, props);
}

MakeBackendTextureSurface() [1/2]

sk_sp< SkSurface > sk_gpu_test::MakeBackendTextureSurface	(	GrDirectContext *	dContext,
		const SkImageInfo &	ii,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		const SkSurfaceProps *	props
	)

Definition at line 26 of file BackendSurfaceFactory.cpp.

                                                                        {
    if (ii.alphaType() == kUnpremul_SkAlphaType) {
        return nullptr;
    }
    auto mbet = ManagedBackendTexture::MakeWithoutData(dContext,
                                                       ii.width(),
                                                       ii.height(),
                                                       ii.colorType(),
                                                       mipmapped,
                                                       GrRenderable::kYes,
                                                       isProtected);
    if (!mbet) {
        return nullptr;
    }
    return SkSurfaces::WrapBackendTexture(dContext,
                                          mbet->texture(),
                                          origin,
                                          sampleCnt,
                                          ii.colorType(),
                                          ii.refColorSpace(),
                                          props,
                                          ManagedBackendTexture::ReleaseProc,
                                          mbet->releaseContext());
}

MakeBackendTextureSurface() [2/2]

sk_sp< SkSurface > sk_gpu_test::MakeBackendTextureSurface	(	GrDirectContext *	dContext,
		SkISize	dimensions,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		skgpu::Mipmapped	mipmapped,
		GrProtected	isProtected,
		const SkSurfaceProps *	props
	)

Definition at line 57 of file BackendSurfaceFactory.cpp.

                                                                        {
    auto ii = SkImageInfo::Make(dimensions, colorType, kPremul_SkAlphaType, std::move(colorSpace));
    return MakeBackendTextureSurface(
            dContext, ii, origin, sampleCnt, mipmapped, isProtected, props);
}

MakeTextureProxyViewFromData()

GrSurfaceProxyView sk_gpu_test::MakeTextureProxyViewFromData	(	GrDirectContext *	,
		GrRenderable	,
		GrSurfaceOrigin	,
		GrCPixmap	pixmap
	)

Makes a texture proxy containing the passed in color data.

Definition at line 56 of file ProxyUtils.cpp.

                                                                  {
    if (dContext->abandoned()) {
        return {};
    }
 
    const GrCaps* caps = dContext->priv().caps();
 
    const GrBackendFormat format = caps->getDefaultBackendFormat(pixmap.colorType(), renderable);
    if (!format.isValid()) {
        return {};
    }
    skgpu::Swizzle swizzle = caps->getReadSwizzle(format, pixmap.colorType());
 
    sk_sp<GrTextureProxy> proxy;
    proxy = dContext->priv().proxyProvider()->createProxy(format,
                                                          pixmap.dimensions(),
                                                          renderable,
                                                          /*sample count*/ 1,
                                                          skgpu::Mipmapped::kNo,
                                                          SkBackingFit::kExact,
                                                          skgpu::Budgeted::kYes,
                                                          GrProtected::kNo,
                                                          /*label=*/"TextureProxyViewFromData");
    if (!proxy) {
        return {};
    }
    GrSurfaceProxyView view(proxy, origin, swizzle);
    auto sContext = dContext->priv().makeSC(std::move(view), pixmap.colorInfo());
    if (!sContext) {
        return {};
    }
    if (!sContext->writePixels(dContext, pixmap, {0, 0})) {
        return {};
    }
    return sContext->readSurfaceView();
}

MakeYUVAPlanesAsA8()

std::tuple< std::array< sk_sp< SkImage >, SkYUVAInfo::kMaxPlanes >, SkYUVAInfo > sk_gpu_test::MakeYUVAPlanesAsA8	(	SkImage *	src,
		SkYUVColorSpace	cs,
		SkYUVAInfo::Subsampling	ss,
		GrRecordingContext *	rContext
	)

Definition at line 152 of file YUVUtils.cpp.

                                                 {
    float rgbToYUV[20];
    SkColorMatrix_RGB2YUV(cs, rgbToYUV);
 
    SkYUVAInfo::PlaneConfig config = src->isOpaque() ? SkYUVAInfo::PlaneConfig::kY_U_V
                                                     : SkYUVAInfo::PlaneConfig::kY_U_V_A;
    SkISize dims[SkYUVAInfo::kMaxPlanes];
    int n = SkYUVAInfo::PlaneDimensions(src->dimensions(),
                                        config,
                                        ss,
                                        kTopLeft_SkEncodedOrigin,
                                        dims);
    std::array<sk_sp<SkImage>, 4> planes;
    for (int i = 0; i < n; ++i) {
        SkImageInfo info = SkImageInfo::MakeA8(dims[i]);
        sk_sp<SkSurface> surf;
        if (rContext) {
            surf = SkSurfaces::RenderTarget(rContext, skgpu::Budgeted::kYes, info, 1, nullptr);
        } else {
            surf = SkSurfaces::Raster(info);
        }
        if (!surf) {
            return {};
        }
 
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrc);
 
        // Make a matrix with the ith row of rgbToYUV copied to the A row since we're drawing to A8.
        float m[20] = {};
        std::copy_n(rgbToYUV + 5*i, 5, m + 15);
        paint.setColorFilter(SkColorFilters::Matrix(m));
        surf->getCanvas()->drawImageRect(src,
                                         SkRect::Make(dims[i]),
                                         SkSamplingOptions(SkFilterMode::kLinear),
                                         &paint);
        planes[i] = surf->makeImageSnapshot();
        if (!planes[i]) {
            return {};
        }
    }
    SkYUVAInfo info(src->dimensions(), config, ss, cs);
    return {planes, info};
}

Variable Documentation

kInvalidFence

constexpr PlatformFence sk_gpu_test::kInvalidFence = 0

staticconstexpr

Definition at line 16 of file FenceSync.h.

kInvalidTimerQuery

constexpr PlatformTimerQuery sk_gpu_test::kInvalidTimerQuery = 0

staticconstexpr

Definition at line 18 of file GpuTimer.h.