AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
e384a1ed7f
skia2/tests/BackendAllocationTest.cpp
Robert Phillips b04b694689 Make GrGLGpu::createBackendTexture parallel GrGLGpu::createTextureImpl 
- in preparation for making createBackendTexture call createTextureImpl (just like GrGLGpu::onCreateTexture)

This is more pre-work for making https://skia-review.googlesource.com/c/skia/+/214445/ (Expand backend allocation API to allow an initialization color) reasonable to review.

Change-Id: I28a9ec889532fb72fd05bea4b1fdbb8935e5228b
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/215170
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
2019-05-22 14:40:20 +00:00

346 lines
15 KiB
C++
Raw Blame History

/*
* Copyright 2019 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/core/SkSurface.h"
#include "include/gpu/GrContext.h"
#include "src/gpu/GrContextPriv.h"
#include "src/image/SkImage_Base.h"
#include "tests/Test.h"
// Test wrapping of GrBackendObjects in SkSurfaces and SkImages
void test_wrapping(GrContext* context, skiatest::Reporter* reporter,
std::function<GrBackendTexture (GrContext*,
GrMipMapped,
GrRenderable)> create,
SkColorType colorType, GrMipMapped mipMapped, GrRenderable renderable) {
GrResourceCache* cache = context->priv().getResourceCache();
const int initialCount = cache->getResourceCount();
GrBackendTexture backendTex = create(context, mipMapped, renderable);
if (!backendTex.isValid()) {
ERRORF(reporter, "Couldn't create backendTexture for colorType %d renderable %s\n",
colorType,
GrRenderable::kYes == renderable ? "yes" : "no");
return;
}
// Skia proper should know nothing about the new backend object
REPORTER_ASSERT(reporter, initialCount == cache->getResourceCount());
if (kUnknown_SkColorType == colorType) {
context->deleteBackendTexture(backendTex);
return;
}
if (GrRenderable::kYes == renderable) {
sk_sp<SkSurface> surf = SkSurface::MakeFromBackendTexture(context,
backendTex,
kTopLeft_GrSurfaceOrigin,
0,
colorType,
nullptr, nullptr);
if (!surf) {
ERRORF(reporter, "Couldn't make surface from backendTexture for colorType %d\n",
colorType);
} else {
REPORTER_ASSERT(reporter, initialCount+1 == cache->getResourceCount());
}
}
{
sk_sp<SkImage> img = SkImage::MakeFromTexture(context,
backendTex,
kTopLeft_GrSurfaceOrigin,
colorType,
kPremul_SkAlphaType,
nullptr);
if (!img) {
ERRORF(reporter, "Couldn't make image from backendTexture for colorType %d\n",
colorType);
} else {
SkImage_Base* ib = as_IB(img);
GrTextureProxy* proxy = ib->peekProxy();
REPORTER_ASSERT(reporter, proxy);
REPORTER_ASSERT(reporter, mipMapped == proxy->proxyMipMapped());
REPORTER_ASSERT(reporter, proxy->isInstantiated());
REPORTER_ASSERT(reporter, mipMapped == proxy->mipMapped());
REPORTER_ASSERT(reporter, initialCount+1 == cache->getResourceCount());
}
}
REPORTER_ASSERT(reporter, initialCount == cache->getResourceCount());
context->deleteBackendTexture(backendTex);
}
///////////////////////////////////////////////////////////////////////////////
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ColorTypeBackendAllocationTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
const GrCaps* caps = context->priv().caps();
struct {
SkColorType fColorType;
GrPixelConfig fConfig;
} combinations[] = {
{ kAlpha_8_SkColorType, kAlpha_8_GrPixelConfig },
{ kRGB_565_SkColorType, kRGB_565_GrPixelConfig },
{ kARGB_4444_SkColorType, kRGBA_4444_GrPixelConfig },
{ kRGBA_8888_SkColorType, kRGBA_8888_GrPixelConfig },
{ kRGB_888x_SkColorType, kRGB_888_GrPixelConfig },
{ kBGRA_8888_SkColorType, kBGRA_8888_GrPixelConfig },
{ kRGBA_1010102_SkColorType, kRGBA_1010102_GrPixelConfig },
// The kRGB_101010x_SkColorType has no Ganesh correlate
{ kRGB_101010x_SkColorType, kUnknown_GrPixelConfig },
{ kGray_8_SkColorType, kGray_8_GrPixelConfig },
{ kRGBA_F16Norm_SkColorType, kRGBA_half_Clamped_GrPixelConfig },
{ kRGBA_F16_SkColorType, kRGBA_half_GrPixelConfig },
{ kRGBA_F32_SkColorType, kRGBA_float_GrPixelConfig },
};
SkASSERT(kLastEnum_SkColorType == SK_ARRAY_COUNT(combinations));
for (auto combo : combinations) {
SkColorType colorType = combo.fColorType;
if (!caps->isConfigTexturable(combo.fConfig)) {
continue;
}
if (GrBackendApi::kMetal == context->backend()) {
// skbug.com/9086 (Metal caps may not be handling RGBA32 correctly)
if (kRGBA_F32_SkColorType == combo.fColorType) {
continue;
}
}
for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
if (GrMipMapped::kYes == mipMapped && !caps->mipMapSupport()) {
continue;
}
for (auto renderable : { GrRenderable::kNo, GrRenderable::kYes }) {
if (GrRenderable::kYes == renderable) {
if (kRGB_888x_SkColorType == combo.fColorType) {
// Ganesh can't perform the blends correctly when rendering this format
continue;
}
if (!caps->isConfigRenderable(combo.fConfig)) {
continue;
}
}
{
auto uninitCreateMtd = [colorType](GrContext* context,
GrMipMapped mipMapped,
GrRenderable renderable) {
return context->createBackendTexture(32, 32, colorType,
mipMapped, renderable);
};
test_wrapping(context, reporter, uninitCreateMtd,
colorType, mipMapped, renderable);
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
#ifdef SK_GL
#include "src/gpu/gl/GrGLCaps.h"
#include "src/gpu/gl/GrGLDefines.h"
DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(GLBackendAllocationTest, reporter, ctxInfo) {
sk_gpu_test::GLTestContext* glCtx = ctxInfo.glContext();
GrGLStandard standard = glCtx->gl()->fStandard;
GrContext* context = ctxInfo.grContext();
const GrGLCaps* glCaps = static_cast<const GrGLCaps*>(context->priv().caps());
struct {
SkColorType fColorType;
GrGLenum fFormat;
// TODO: remove 'fConfig' and directly use 'fFormat' in GrGLCaps::isFormatTexturable
GrPixelConfig fConfig;
} combinations[] = {
{ kRGBA_8888_SkColorType, GR_GL_RGBA8, kRGBA_8888_GrPixelConfig },
{ kRGBA_8888_SkColorType, GR_GL_SRGB8_ALPHA8, kSRGBA_8888_GrPixelConfig },
{ kRGB_888x_SkColorType, GR_GL_RGBA8, kRGBA_8888_GrPixelConfig },
{ kRGB_888x_SkColorType, GR_GL_RGB8, kRGB_888_GrPixelConfig },
{ kBGRA_8888_SkColorType, GR_GL_RGBA8, kRGBA_8888_GrPixelConfig },
{ kBGRA_8888_SkColorType, GR_GL_BGRA8, kBGRA_8888_GrPixelConfig },
{ kBGRA_8888_SkColorType, GR_GL_SRGB8_ALPHA8, kSBGRA_8888_GrPixelConfig },
{ kRGBA_1010102_SkColorType, GR_GL_RGB10_A2, kRGBA_1010102_GrPixelConfig },
{ kRGB_565_SkColorType, GR_GL_RGB565, kRGB_565_GrPixelConfig },
{ kARGB_4444_SkColorType, GR_GL_RGBA4, kRGBA_4444_GrPixelConfig },
{ kAlpha_8_SkColorType, GR_GL_ALPHA8, kAlpha_8_as_Alpha_GrPixelConfig },
{ kAlpha_8_SkColorType, GR_GL_R8, kAlpha_8_as_Red_GrPixelConfig },
{ kGray_8_SkColorType, GR_GL_LUMINANCE8, kGray_8_as_Lum_GrPixelConfig },
{ kGray_8_SkColorType, GR_GL_R8, kGray_8_as_Red_GrPixelConfig },
{ kRGBA_F32_SkColorType, GR_GL_RGBA32F, kRGBA_float_GrPixelConfig },
{ kRGBA_F16Norm_SkColorType, GR_GL_RGBA16F, kRGBA_half_Clamped_GrPixelConfig },
{ kRGBA_F16_SkColorType, GR_GL_RGBA16F, kRGBA_half_GrPixelConfig },
// These backend formats don't have SkColorType equivalents
{ kUnknown_SkColorType, GR_GL_RG32F, kRG_float_GrPixelConfig },
{ kUnknown_SkColorType, GR_GL_RG8, kRG_88_GrPixelConfig },
{ kUnknown_SkColorType, GR_GL_R16F, kAlpha_half_as_Red_GrPixelConfig },
{ kUnknown_SkColorType, GR_GL_COMPRESSED_RGB8_ETC2, kRGB_ETC1_GrPixelConfig },
};
for (auto combo : combinations) {
GrBackendFormat format = GrBackendFormat::MakeGL(combo.fFormat, GR_GL_TEXTURE_2D);
if (GR_GL_COMPRESSED_RGB8_ETC2 == combo.fFormat) {
// We current disallow uninitialized ETC1 textures in the GL backend
continue;
}
if (!glCaps->isConfigTexturable(combo.fConfig)) {
continue;
}
if (kBGRA_8888_SkColorType == combo.fColorType) {
if (GR_GL_RGBA8 == combo.fFormat && kGL_GrGLStandard != standard) {
continue;
}
if (GR_GL_BGRA8 == combo.fFormat && kGL_GrGLStandard == standard) {
continue;
}
}
for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
if (GrMipMapped::kYes == mipMapped && !glCaps->mipMapSupport()) {
continue;
}
for (auto renderable : { GrRenderable::kNo, GrRenderable::kYes }) {
if (GrRenderable::kYes == renderable) {
if (kRGB_888x_SkColorType == combo.fColorType) {
// Ganesh can't perform the blends correctly when rendering this format
continue;
}
if (!glCaps->isConfigRenderable(combo.fConfig)) {
continue;
}
}
{
auto uninitCreateMtd = [format](GrContext* context,
GrMipMapped mipMapped,
GrRenderable renderable) {
return context->createBackendTexture(32, 32, format,
mipMapped, renderable);
};
test_wrapping(context, reporter, uninitCreateMtd,
combo.fColorType, mipMapped, renderable);
}
}
}
}
}
#endif
///////////////////////////////////////////////////////////////////////////////
#ifdef SK_VULKAN
#include "src/gpu/vk/GrVkCaps.h"
DEF_GPUTEST_FOR_VULKAN_CONTEXT(VkBackendAllocationTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
const GrVkCaps* vkCaps = static_cast<const GrVkCaps*>(context->priv().caps());
struct {
SkColorType fColorType;
VkFormat fFormat;
} combinations[] = {
{ kRGBA_8888_SkColorType, VK_FORMAT_R8G8B8A8_UNORM },
{ kRGBA_8888_SkColorType, VK_FORMAT_R8G8B8A8_SRGB },
{ kRGB_888x_SkColorType, VK_FORMAT_R8G8B8_UNORM },
{ kRGB_888x_SkColorType, VK_FORMAT_R8G8B8A8_UNORM },
{ kBGRA_8888_SkColorType, VK_FORMAT_B8G8R8A8_UNORM },
{ kBGRA_8888_SkColorType, VK_FORMAT_B8G8R8A8_SRGB },
{ kRGBA_1010102_SkColorType, VK_FORMAT_A2B10G10R10_UNORM_PACK32 },
{ kRGB_565_SkColorType, VK_FORMAT_R5G6B5_UNORM_PACK16 },
{ kARGB_4444_SkColorType, VK_FORMAT_R4G4B4A4_UNORM_PACK16 },
{ kARGB_4444_SkColorType, VK_FORMAT_B4G4R4A4_UNORM_PACK16 },
{ kAlpha_8_SkColorType, VK_FORMAT_R8_UNORM },
{ kGray_8_SkColorType, VK_FORMAT_R8_UNORM },
{ kRGBA_F32_SkColorType, VK_FORMAT_R32G32B32A32_SFLOAT },
{ kRGBA_F16Norm_SkColorType, VK_FORMAT_R16G16B16A16_SFLOAT },
{ kRGBA_F16_SkColorType, VK_FORMAT_R16G16B16A16_SFLOAT },
// These backend formats don't have SkColorType equivalents
{ kUnknown_SkColorType, VK_FORMAT_R32G32_SFLOAT },
{ kUnknown_SkColorType, VK_FORMAT_R8G8_UNORM },
{ kUnknown_SkColorType, VK_FORMAT_R16_SFLOAT },
{ kUnknown_SkColorType, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK },
};
for (auto combo : combinations) {
if (!vkCaps->isFormatTexturable(combo.fFormat)) {
continue;
}
GrBackendFormat format = GrBackendFormat::MakeVk(combo.fFormat);
for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
if (GrMipMapped::kYes == mipMapped && !vkCaps->mipMapSupport()) {
continue;
}
for (auto renderable : { GrRenderable::kNo, GrRenderable::kYes }) {
if (GrRenderable::kYes == renderable) {
if (kRGB_888x_SkColorType == combo.fColorType) {
// Ganesh can't perform the blends correctly when rendering this format
continue;
}
if (!vkCaps->isFormatRenderable(combo.fFormat)) {
continue;
}
}
{
auto uninitCreateMtd = [format](GrContext* context,
GrMipMapped mipMapped,
GrRenderable renderable) {
return context->createBackendTexture(32, 32, format,
mipMapped, renderable);
};
test_wrapping(context, reporter, uninitCreateMtd,
combo.fColorType, mipMapped, renderable);
}
}
}
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink