AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
8481c5fca7
skia2/tests/ProxyTest.cpp
Aditya Kushwah fd86891407 Implement onSetLabel method. 
In this CL, the GrSurfaceProxy's and GrDrawOpAtlas's label strings
are plumbed so that it can be stored in the label string of
GrGpuResource. onSetLabel method, which is called from setLabel
method of GrGpuResource, will pass labels to Skia OpenGL backend
using ANGLE's labeling API.

Bug: chromium:1164111
Change-Id: I516c06f0ebbf6bbe6d31ea5a4a64b2baeedd1560
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/545717
Commit-Queue: Greg Daniel <egdaniel@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
2022-06-08 18:43:34 +00:00

367 lines
19 KiB
C++
Raw Blame History

/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
// This is a GPU-backend specific test.
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrDirectContext.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrGpu.h"
#include "src/gpu/ganesh/GrProxyProvider.h"
#include "src/gpu/ganesh/GrRenderTarget.h"
#include "src/gpu/ganesh/GrRenderTargetProxy.h"
#include "src/gpu/ganesh/GrResourceProvider.h"
#include "src/gpu/ganesh/GrSurface.h"
#include "src/gpu/ganesh/GrSurfaceProxyPriv.h"
#include "src/gpu/ganesh/GrTexture.h"
#include "src/gpu/ganesh/GrTextureProxy.h"
#include "src/gpu/ganesh/SkGr.h"
#include "tests/Test.h"
#include "tools/gpu/ManagedBackendTexture.h"
#ifdef SK_GL
#include "src/gpu/ganesh/gl/GrGLDefines_impl.h"
#include "src/gpu/ganesh/gl/GrGLUtil.h"
#endif
#include "tests/TestUtils.h"
// Check that the surface proxy's member vars are set as expected
static void check_surface(skiatest::Reporter* reporter,
GrSurfaceProxy* proxy,
int width, int height,
SkBudgeted budgeted) {
REPORTER_ASSERT(reporter, proxy->width() == width);
REPORTER_ASSERT(reporter, proxy->height() == height);
REPORTER_ASSERT(reporter, !proxy->uniqueID().isInvalid());
REPORTER_ASSERT(reporter, proxy->isBudgeted() == budgeted);
}
static void check_rendertarget(skiatest::Reporter* reporter,
const GrCaps& caps,
GrResourceProvider* provider,
GrRenderTargetProxy* rtProxy,
int numSamples,
SkBackingFit fit,
int expectedMaxWindowRects) {
REPORTER_ASSERT(reporter, rtProxy->maxWindowRectangles(caps) == expectedMaxWindowRects);
REPORTER_ASSERT(reporter, rtProxy->numSamples() == numSamples);
GrSurfaceProxy::UniqueID idBefore = rtProxy->uniqueID();
bool preinstantiated = rtProxy->isInstantiated();
REPORTER_ASSERT(reporter, rtProxy->instantiate(provider));
GrRenderTarget* rt = rtProxy->peekRenderTarget();
REPORTER_ASSERT(reporter, rtProxy->uniqueID() == idBefore);
// Deferred resources should always have a different ID from their instantiated rendertarget
if (preinstantiated) {
REPORTER_ASSERT(reporter, rtProxy->uniqueID().asUInt() == rt->uniqueID().asUInt());
} else {
REPORTER_ASSERT(reporter, rtProxy->uniqueID().asUInt() != rt->uniqueID().asUInt());
}
if (SkBackingFit::kExact == fit) {
REPORTER_ASSERT(reporter, rt->dimensions() == rtProxy->dimensions());
} else {
REPORTER_ASSERT(reporter, rt->width() >= rtProxy->width());
REPORTER_ASSERT(reporter, rt->height() >= rtProxy->height());
}
REPORTER_ASSERT(reporter, rt->backendFormat() == rtProxy->backendFormat());
REPORTER_ASSERT(reporter, rt->numSamples() == rtProxy->numSamples());
REPORTER_ASSERT(reporter, rt->flags() == rtProxy->testingOnly_getFlags());
}
static void check_texture(skiatest::Reporter* reporter,
GrResourceProvider* provider,
GrTextureProxy* texProxy,
SkBackingFit fit) {
GrSurfaceProxy::UniqueID idBefore = texProxy->uniqueID();
bool preinstantiated = texProxy->isInstantiated();
// The instantiated texture should have these dimensions. If the fit is kExact, then
// 'backingStoreDimensions' reports the original WxH. If it is kApprox, make sure that
// the texture is that size and didn't reuse one of the kExact surfaces in the provider.
// This is important because upstream usage (e.g. SkImage) reports size based on the
// backingStoreDimensions and client code may rely on that if they are creating backend
// resources.
// NOTE: we store these before instantiating, since after instantiation backingStoreDimensions
// just returns the target's dimensions. In this instance, we want to ensure the target's
// dimensions are no different from the original approximate (or exact) dimensions.
SkISize expectedSize = texProxy->backingStoreDimensions();
REPORTER_ASSERT(reporter, texProxy->instantiate(provider));
GrTexture* tex = texProxy->peekTexture();
REPORTER_ASSERT(reporter, texProxy->uniqueID() == idBefore);
// Deferred resources should always have a different ID from their instantiated texture
if (preinstantiated) {
REPORTER_ASSERT(reporter, texProxy->uniqueID().asUInt() == tex->uniqueID().asUInt());
} else {
REPORTER_ASSERT(reporter, texProxy->uniqueID().asUInt() != tex->uniqueID().asUInt());
}
REPORTER_ASSERT(reporter, tex->dimensions() == expectedSize);
REPORTER_ASSERT(reporter, tex->backendFormat() == texProxy->backendFormat());
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
auto direct = ctxInfo.directContext();
GrProxyProvider* proxyProvider = direct->priv().proxyProvider();
GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
const GrCaps& caps = *direct->priv().caps();
for (auto widthHeight : {100, 128, 1048576}) {
for (auto ct : {GrColorType::kAlpha_8, GrColorType::kBGR_565, GrColorType::kRGBA_8888,
GrColorType::kRGBA_1010102}) {
for (auto fit : {SkBackingFit::kExact, SkBackingFit::kApprox}) {
for (auto budgeted : {SkBudgeted::kYes, SkBudgeted::kNo}) {
for (auto numSamples : {1, 4, 16, 128}) {
SkISize dims = {widthHeight, widthHeight};
auto format = caps.getDefaultBackendFormat(ct, GrRenderable::kYes);
if (!format.isValid()) {
continue;
}
// Renderable
{
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
tex = resourceProvider->createApproxTexture(dims,
format,
GrTextureType::k2D,
GrRenderable::kYes,
numSamples,
GrProtected::kNo,
/*label=*/{});
} else {
tex = resourceProvider->createTexture(dims,
format,
GrTextureType::k2D,
GrRenderable::kYes,
numSamples,
GrMipmapped::kNo,
budgeted,
GrProtected::kNo,
/*label=*/{});
}
sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
format, dims, GrRenderable::kYes, numSamples, GrMipmapped::kNo,
fit, budgeted, GrProtected::kNo, /*label=*/{});
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
REPORTER_ASSERT(reporter, proxy->asRenderTargetProxy());
// This forces the proxy to compute and cache its
// pre-instantiation size guess. Later, when it is actually
// instantiated, it checks that the instantiated size is <= to
// the pre-computation. If the proxy never computed its
// pre-instantiation size then the check is skipped.
proxy->gpuMemorySize();
check_surface(reporter, proxy.get(), widthHeight, widthHeight,
budgeted);
int supportedSamples =
caps.getRenderTargetSampleCount(numSamples, format);
check_rendertarget(reporter, caps, resourceProvider,
proxy->asRenderTargetProxy(), supportedSamples,
fit, caps.maxWindowRectangles());
}
}
// Not renderable
{
sk_sp<GrTexture> tex;
if (SkBackingFit::kApprox == fit) {
tex = resourceProvider->createApproxTexture(dims,
format,
GrTextureType::k2D,
GrRenderable::kNo,
numSamples,
GrProtected::kNo,
/*label=*/{});
} else {
tex = resourceProvider->createTexture(dims,
format,
GrTextureType::k2D,
GrRenderable::kNo,
numSamples,
GrMipmapped::kNo,
budgeted,
GrProtected::kNo,
/*label=*/{});
}
sk_sp<GrTextureProxy> proxy(proxyProvider->createProxy(
format, dims, GrRenderable::kNo, numSamples, GrMipmapped::kNo,
fit, budgeted, GrProtected::kNo, /*label=*/{}));
REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
if (proxy) {
// This forces the proxy to compute and cache its
// pre-instantiation size guess. Later, when it is actually
// instantiated, it checks that the instantiated size is <= to
// the pre-computation. If the proxy never computed its
// pre-instantiation size then the check is skipped.
proxy->gpuMemorySize();
check_surface(reporter, proxy.get(), widthHeight, widthHeight,
budgeted);
check_texture(reporter, resourceProvider, proxy->asTextureProxy(),
fit);
}
}
}
}
}
}
}
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyTest, reporter, ctxInfo) {
auto direct = ctxInfo.directContext();
GrProxyProvider* proxyProvider = direct->priv().proxyProvider();
GrResourceProvider* resourceProvider = direct->priv().resourceProvider();
GrGpu* gpu = direct->priv().getGpu();
const GrCaps& caps = *direct->priv().caps();
static const int kWidthHeight = 100;
for (auto colorType :
{kAlpha_8_SkColorType, kRGBA_8888_SkColorType, kRGBA_1010102_SkColorType}) {
GrColorType grColorType = SkColorTypeToGrColorType(colorType);
// External on-screen render target.
// Tests wrapBackendRenderTarget with a GrBackendRenderTarget
// Our test-only function that creates a backend render target doesn't currently support
// sample counts :(.
if (direct->colorTypeSupportedAsSurface(colorType)) {
GrBackendRenderTarget backendRT = gpu->createTestingOnlyBackendRenderTarget(
{kWidthHeight, kWidthHeight}, grColorType);
sk_sp<GrSurfaceProxy> sProxy(
proxyProvider->wrapBackendRenderTarget(backendRT, nullptr));
check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
static constexpr int kExpectedNumSamples = 1;
check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
kExpectedNumSamples, SkBackingFit::kExact,
caps.maxWindowRectangles());
gpu->deleteTestingOnlyBackendRenderTarget(backendRT);
}
for (auto numSamples : {1, 4}) {
auto beFormat = caps.getDefaultBackendFormat(grColorType, GrRenderable::kYes);
int supportedNumSamples = caps.getRenderTargetSampleCount(numSamples, beFormat);
if (!supportedNumSamples) {
continue;
}
#ifdef SK_GL
// Test wrapping FBO 0 (with made up properties). This tests sample count and the
// special case where FBO 0 doesn't support window rectangles.
if (GrBackendApi::kOpenGL == ctxInfo.backend()) {
GrGLFramebufferInfo fboInfo;
fboInfo.fFBOID = 0;
fboInfo.fFormat = GrGLFormatToEnum(beFormat.asGLFormat());
SkASSERT(fboInfo.fFormat);
static constexpr int kStencilBits = 8;
GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples,
kStencilBits, fboInfo);
sk_sp<GrSurfaceProxy> sProxy(
proxyProvider->wrapBackendRenderTarget(backendRT, nullptr));
check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact, 0);
}
#endif
// Tests wrapBackendTexture that is only renderable
{
auto mbet = sk_gpu_test::ManagedBackendTexture::MakeWithoutData(direct,
kWidthHeight,
kWidthHeight,
colorType,
GrMipmapped::kNo,
GrRenderable::kYes);
if (!mbet) {
ERRORF(reporter,
"Could not create renderable backend texture of color type %d",
colorType);
continue;
}
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapRenderableBackendTexture(
mbet->texture(), supportedNumSamples, kBorrow_GrWrapOwnership,
GrWrapCacheable::kNo, nullptr);
if (!sProxy) {
ERRORF(reporter, "wrapRenderableBackendTexture failed");
continue;
}
check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
supportedNumSamples, SkBackingFit::kExact,
caps.maxWindowRectangles());
}
{
// Tests wrapBackendTexture that is only textureable
auto mbet = sk_gpu_test::ManagedBackendTexture::MakeWithoutData(direct,
kWidthHeight,
kWidthHeight,
colorType,
GrMipmapped::kNo,
GrRenderable::kNo);
if (!mbet) {
ERRORF(reporter,
"Could not create non-renderable backend texture of color type %d",
colorType);
continue;
}
sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTexture(
mbet->texture(), kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
kRead_GrIOType, mbet->refCountedCallback());
if (!sProxy) {
ERRORF(reporter, "wrapBackendTexture failed");
continue;
}
check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
check_texture(reporter, resourceProvider, sProxy->asTextureProxy(),
SkBackingFit::kExact);
}
}
}
}
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ZeroSizedProxyTest, reporter, ctxInfo) {
auto direct = ctxInfo.directContext();
GrProxyProvider* provider = direct->priv().proxyProvider();
for (auto renderable : {GrRenderable::kNo, GrRenderable::kYes}) {
for (auto fit : { SkBackingFit::kExact, SkBackingFit::kApprox }) {
for (int width : { 0, 100 }) {
for (int height : { 0, 100}) {
if (width && height) {
continue; // not zero-sized
}
const GrBackendFormat format =
direct->priv().caps()->getDefaultBackendFormat(
GrColorType::kRGBA_8888,
renderable);
sk_sp<GrTextureProxy> proxy = provider->createProxy(
format, {width, height}, renderable, 1, GrMipmapped::kNo, fit,
SkBudgeted::kNo, GrProtected::kNo, /*label=*/{});
REPORTER_ASSERT(reporter, !proxy);
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink