Switch BackendAllocationTests from GrPixelConfig to GrColorType
Bug: skia:6718
Change-Id: Ifd78a1b227dc468ce882cf3caf78b4fae80cc006
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/229386
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
Reviewed-by: Jim Van Verth <jvanverth@google.com>
diff --git a/src/gpu/mtl/GrMtlCaps.h b/src/gpu/mtl/GrMtlCaps.h
index d6b13e1..d3f39e5 100644
--- a/src/gpu/mtl/GrMtlCaps.h
+++ b/src/gpu/mtl/GrMtlCaps.h
@@ -111,9 +111,9 @@
uint16_t fFlags;
};
#ifdef SK_BUILD_FOR_IOS
- static constexpr size_t kNumMtlFormats = 17;
+ static constexpr size_t kNumMtlFormats = 18;
#else
- static constexpr size_t kNumMtlFormats = 14;
+ static constexpr size_t kNumMtlFormats = 15;
#endif
static size_t GetFormatIndex(MTLPixelFormat);
FormatInfo fFormatTable[kNumMtlFormats];
diff --git a/src/gpu/mtl/GrMtlCaps.mm b/src/gpu/mtl/GrMtlCaps.mm
index b982183..558fc3f 100644
--- a/src/gpu/mtl/GrMtlCaps.mm
+++ b/src/gpu/mtl/GrMtlCaps.mm
@@ -438,6 +438,7 @@
MTLPixelFormatRGBA8Unorm,
MTLPixelFormatR8Unorm,
+ MTLPixelFormatA8Unorm,
MTLPixelFormatBGRA8Unorm,
#ifdef SK_BUILD_FOR_IOS
MTLPixelFormatB5G6R5Unorm,
@@ -481,6 +482,10 @@
info = &fFormatTable[GetFormatIndex(MTLPixelFormatR8Unorm)];
info->fFlags = FormatInfo::kAllFlags;
+ // A8Unorm
+ info = &fFormatTable[GetFormatIndex(MTLPixelFormatA8Unorm)];
+ info->fFlags = FormatInfo::kTextureable_Flag;
+
#ifdef SK_BUILD_FOR_IOS
// B5G6R5Unorm
info = &fFormatTable[GetFormatIndex(MTLPixelFormatB5G6R5Unorm)];
@@ -897,6 +902,9 @@
readCT = GrColorType::kGray_8;
}
break;
+ case MTLPixelFormatA8Unorm:
+ readCT = GrColorType::kAlpha_8;
+ break;
case MTLPixelFormatBGRA8Unorm:
readCT = GrColorType::kBGRA_8888;
break;
diff --git a/src/gpu/mtl/GrMtlUtil.mm b/src/gpu/mtl/GrMtlUtil.mm
index 2fce05a..43eb3af 100644
--- a/src/gpu/mtl/GrMtlUtil.mm
+++ b/src/gpu/mtl/GrMtlUtil.mm
@@ -291,6 +291,7 @@
size_t GrMtlBytesPerFormat(MTLPixelFormat format) {
switch (format) {
+ case MTLPixelFormatA8Unorm:
case MTLPixelFormatR8Unorm:
return 1;
diff --git a/tests/BackendAllocationTest.cpp b/tests/BackendAllocationTest.cpp
index 3429e06..8fb4a8b 100644
--- a/tests/BackendAllocationTest.cpp
+++ b/tests/BackendAllocationTest.cpp
@@ -23,15 +23,15 @@
std::function<GrBackendTexture (GrContext*,
GrMipMapped,
GrRenderable)> create,
- SkColorType colorType, GrMipMapped mipMapped, GrRenderable renderable) {
+ GrColorType grColorType, 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,
+ ERRORF(reporter, "Couldn't create backendTexture for grColorType %d renderable %s\n",
+ grColorType,
GrRenderable::kYes == renderable ? "yes" : "no");
return;
}
@@ -39,7 +39,10 @@
// Skia proper should know nothing about the new backend object
REPORTER_ASSERT(reporter, initialCount == cache->getResourceCount());
- if (kUnknown_SkColorType == colorType) {
+ SkColorType skColorType = GrColorTypeToSkColorType(grColorType);
+
+ // Wrapping a backendTexture in an image requires an SkColorType
+ if (kUnknown_SkColorType == skColorType) {
context->deleteBackendTexture(backendTex);
return;
}
@@ -49,11 +52,11 @@
backendTex,
kTopLeft_GrSurfaceOrigin,
0,
- colorType,
+ skColorType,
nullptr, nullptr);
if (!surf) {
ERRORF(reporter, "Couldn't make surface from backendTexture for colorType %d\n",
- colorType);
+ skColorType);
} else {
REPORTER_ASSERT(reporter, initialCount+1 == cache->getResourceCount());
}
@@ -63,12 +66,12 @@
sk_sp<SkImage> img = SkImage::MakeFromTexture(context,
backendTex,
kTopLeft_GrSurfaceOrigin,
- colorType,
+ skColorType,
kPremul_SkAlphaType,
nullptr);
if (!img) {
- ERRORF(reporter, "Couldn't make image from backendTexture for colorType %d\n",
- colorType);
+ ERRORF(reporter, "Couldn't make image from backendTexture for skColorType %d\n",
+ skColorType);
} else {
SkImage_Base* ib = as_IB(img);
@@ -128,7 +131,7 @@
const SkColor4f&,
GrMipMapped,
GrRenderable)> create,
- SkColorType colorType, const SkColor4f& color,
+ GrColorType grColorType, const SkColor4f& color,
GrMipMapped mipMapped, GrRenderable renderable) {
GrBackendTexture backendTex = create(context, color, mipMapped, renderable);
if (!backendTex.isValid()) {
@@ -136,25 +139,28 @@
return;
}
- if (kUnknown_SkColorType == colorType) {
+ SkColorType skColorType = GrColorTypeToSkColorType(grColorType);
+
+ // Can't wrap backend textures in images and surfaces w/o an SkColorType
+ if (kUnknown_SkColorType == skColorType) {
// TODO: burrow in and scrappily check that data was uploaded!
context->deleteBackendTexture(backendTex);
return;
}
- SkAlphaType at = SkColorTypeIsAlwaysOpaque(colorType) ? kOpaque_SkAlphaType
- : kPremul_SkAlphaType;
+ SkAlphaType at = SkColorTypeIsAlwaysOpaque(skColorType) ? kOpaque_SkAlphaType
+ : kPremul_SkAlphaType;
- SkImageInfo ii = SkImageInfo::Make(32, 32, colorType, at);
+ SkImageInfo ii = SkImageInfo::Make(32, 32, skColorType, at);
SkColor4f rasterColor = color;
- if (kGray_8_SkColorType == colorType) {
+ if (kGray_8_SkColorType == skColorType) {
// For the GPU backends, gray implies a single channel which is opaque.
rasterColor.fR = color.fA;
rasterColor.fG = color.fA;
rasterColor.fB = color.fA;
rasterColor.fA = 1.0f;
- } else if (kAlpha_8_SkColorType == colorType) {
+ } else if (kAlpha_8_SkColorType == skColorType) {
// For the GPU backends, alpha implies a single alpha channel.
rasterColor.fR = 0;
rasterColor.fG = 0;
@@ -175,13 +181,13 @@
backendTex,
kTopLeft_GrSurfaceOrigin,
0,
- colorType,
+ skColorType,
nullptr, nullptr);
if (surf) {
bool result = surf->readPixels(actual, 0, 0);
REPORTER_ASSERT(reporter, result);
- compare_pixmaps(expected, actual, colorType, reporter);
+ compare_pixmaps(expected, actual, skColorType, reporter);
actual.erase(SkColors::kTransparent);
}
@@ -191,7 +197,7 @@
sk_sp<SkImage> img = SkImage::MakeFromTexture(context,
backendTex,
kTopLeft_GrSurfaceOrigin,
- colorType,
+ skColorType,
at,
nullptr);
if (img) {
@@ -206,7 +212,7 @@
colorType);
#endif
} else {
- compare_pixmaps(expected, actual, colorType, reporter);
+ compare_pixmaps(expected, actual, skColorType, reporter);
}
}
@@ -218,7 +224,7 @@
if (GrBackendApi::kOpenGL == context->backend()) {
GrGLGpu* glGPU = static_cast<GrGLGpu*>(context->priv().getGpu());
- if (kRGBA_F32_SkColorType == colorType && GrMipMapped::kYes == mipMapped &&
+ if (kRGBA_F32_SkColorType == skColorType && GrMipMapped::kYes == mipMapped &&
kGLES_GrGLStandard == glGPU->ctxInfo().standard()) {
context->deleteBackendTexture(backendTex);
return;
@@ -264,7 +270,7 @@
if (!colors_eq(actualColor, rasterColor.toSkColor(), 1)) {
ERRORF(reporter, "Pixel mismatch colorType %d: level: %d e: 0x%x a: 0x%x\n",
- colorType, i, rasterColor.toSkColor(), actualColor);
+ skColorType, i, rasterColor.toSkColor(), actualColor);
}
}
}
@@ -408,7 +414,7 @@
{ kRGBA_F32_SkColorType, kRGBA_float_GrPixelConfig, SkColors::kGray },
};
- SkASSERT(kLastEnum_SkColorType == SK_ARRAY_COUNT(combinations));
+ GR_STATIC_ASSERT(kLastEnum_SkColorType == SK_ARRAY_COUNT(combinations));
for (auto combo : combinations) {
SkColorType colorType = combo.fColorType;
@@ -452,7 +458,7 @@
};
test_wrapping(context, reporter, uninitCreateMtd,
- colorType, mipMapped, renderable);
+ SkColorTypeToGrColorType(colorType), mipMapped, renderable);
}
{
@@ -482,7 +488,8 @@
};
test_color_init(context, reporter, createWithColorMtd,
- colorType, combo.fColor, mipMapped, renderable);
+ SkColorTypeToGrColorType(colorType),
+ combo.fColor, mipMapped, renderable);
}
}
}
@@ -495,6 +502,7 @@
#include "src/gpu/gl/GrGLCaps.h"
#include "src/gpu/gl/GrGLDefines.h"
+#include "src/gpu/gl/GrGLUtil.h"
DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(GLBackendAllocationTest, reporter, ctxInfo) {
sk_gpu_test::GLTestContext* glCtx = ctxInfo.glContext();
@@ -506,103 +514,57 @@
constexpr SkColor4f kGrayCol { 0.75f, 0.75f, 0.75f, 0.75f };
struct {
- SkColorType fColorType;
+ GrColorType fColorType;
GrGLenum fFormat;
- // TODO: remove 'fConfig' and directly use 'fFormat' in GrGLCaps::isFormatTexturable
- GrPixelConfig fConfig;
SkColor4f fColor;
} combinations[] = {
- { kRGBA_8888_SkColorType, GR_GL_RGBA8,
- kRGBA_8888_GrPixelConfig, SkColors::kRed },
- { kRGBA_8888_SkColorType, GR_GL_SRGB8_ALPHA8,
- kSRGBA_8888_GrPixelConfig, SkColors::kRed },
+ { GrColorType::kRGBA_8888, GR_GL_RGBA8, SkColors::kRed },
+ { GrColorType::kRGBA_8888_SRGB, GR_GL_SRGB8_ALPHA8, SkColors::kRed },
- { kRGB_888x_SkColorType, GR_GL_RGBA8,
- kRGBA_8888_GrPixelConfig, SkColors::kYellow },
- { kRGB_888x_SkColorType, GR_GL_RGB8,
- kRGB_888_GrPixelConfig, SkColors::kCyan },
+ { GrColorType::kRGB_888x, GR_GL_RGBA8, SkColors::kYellow },
+ { GrColorType::kRGB_888x, GR_GL_RGB8, SkColors::kCyan },
- { kBGRA_8888_SkColorType, GR_GL_RGBA8,
- kRGBA_8888_GrPixelConfig, SkColors::kBlue },
- { kBGRA_8888_SkColorType, GR_GL_BGRA8,
- kBGRA_8888_GrPixelConfig, SkColors::kBlue },
+ { GrColorType::kBGRA_8888, GR_GL_RGBA8, SkColors::kBlue },
+ { GrColorType::kBGRA_8888, GR_GL_BGRA8, SkColors::kBlue },
+ // TODO: readback is busted when alpha = 0.5f (perhaps premul vs. unpremul)
+ { GrColorType::kRGBA_1010102, GR_GL_RGB10_A2, { 0.5f, 0, 0, 1.0f } },
+ { GrColorType::kBGR_565, GR_GL_RGB565, SkColors::kRed },
+ { GrColorType::kABGR_4444, GR_GL_RGBA4, SkColors::kGreen },
- { kRGBA_1010102_SkColorType, GR_GL_RGB10_A2,
- // TODO: readback is busted when alpha = 0.5f (perhaps premul vs. unpremul)
- kRGBA_1010102_GrPixelConfig, { 0.5f, 0, 0, 1.0f }},
- { kRGB_565_SkColorType, GR_GL_RGB565,
- kRGB_565_GrPixelConfig, SkColors::kRed },
- { kARGB_4444_SkColorType, GR_GL_RGBA4,
- kRGBA_4444_GrPixelConfig, SkColors::kGreen },
+ { GrColorType::kAlpha_8, GR_GL_ALPHA8, kTransCol },
+ { GrColorType::kAlpha_8, GR_GL_R8, kTransCol },
- { kAlpha_8_SkColorType, GR_GL_ALPHA8,
- kAlpha_8_as_Alpha_GrPixelConfig, kTransCol },
- { kAlpha_8_SkColorType, GR_GL_R8,
- kAlpha_8_as_Red_GrPixelConfig, kTransCol },
+ { GrColorType::kGray_8, GR_GL_LUMINANCE8, kGrayCol },
+ { GrColorType::kGray_8, GR_GL_R8, kGrayCol },
- { kGray_8_SkColorType, GR_GL_LUMINANCE8,
- kGray_8_as_Lum_GrPixelConfig, kGrayCol },
- { kGray_8_SkColorType, GR_GL_R8,
- kGray_8_as_Red_GrPixelConfig, kGrayCol },
+ { GrColorType::kRGBA_F32, GR_GL_RGBA32F, SkColors::kRed },
- { kRGBA_F32_SkColorType, GR_GL_RGBA32F,
- kRGBA_float_GrPixelConfig, SkColors::kRed },
+ { GrColorType::kRGBA_F16_Clamped, GR_GL_RGBA16F, SkColors::kLtGray },
+ { GrColorType::kRGBA_F16, GR_GL_RGBA16F, SkColors::kYellow },
- { kRGBA_F16Norm_SkColorType, GR_GL_RGBA16F,
- kRGBA_half_Clamped_GrPixelConfig, SkColors::kLtGray },
- { kRGBA_F16_SkColorType, GR_GL_RGBA16F,
- kRGBA_half_GrPixelConfig, SkColors::kYellow },
+ { GrColorType::kRG_88, GR_GL_RG8, { 0.5f, 0.5f, 0, 0 } },
+ { GrColorType::kAlpha_F16, GR_GL_R16F, { 1.0f, 0, 0, 0.5f } },
+ { GrColorType::kAlpha_F16, GR_GL_LUMINANCE16F, kGrayCol },
- // These backend formats don't have SkColorType equivalents
- { kUnknown_SkColorType, GR_GL_RG8,
- kRG_88_GrPixelConfig, { 0.5f, 0.5f, 0, 0 }},
- { kUnknown_SkColorType, GR_GL_R16F,
- kAlpha_half_as_Red_GrPixelConfig, { 1.0f, 0, 0, 0.5f }},
- { kUnknown_SkColorType, GR_GL_LUMINANCE16F,
- kAlpha_half_as_Lum_GrPixelConfig, kGrayCol },
- { kUnknown_SkColorType, GR_GL_COMPRESSED_RGB8_ETC2,
- kRGB_ETC1_GrPixelConfig, SkColors::kRed },
- { kUnknown_SkColorType, GR_GL_COMPRESSED_ETC1_RGB8,
- kRGB_ETC1_GrPixelConfig, SkColors::kRed },
- { kUnknown_SkColorType, GR_GL_R16,
- kR_16_GrPixelConfig, SkColors::kRed },
- { kUnknown_SkColorType, GR_GL_RG16,
- kRG_1616_GrPixelConfig, SkColors::kYellow },
+ { GrColorType::kR_16, GR_GL_R16, SkColors::kRed },
+ { GrColorType::kRG_1616, GR_GL_RG16, SkColors::kYellow },
// Experimental (for Y416 and mutant P016/P010)
- { kUnknown_SkColorType, GR_GL_RGBA16,
- kRGBA_16161616_GrPixelConfig, SkColors::kLtGray },
- { kUnknown_SkColorType, GR_GL_RG16F,
- kRG_half_GrPixelConfig, SkColors::kYellow },
+ { GrColorType::kRGBA_16161616, GR_GL_RGBA16, SkColors::kLtGray },
+ { GrColorType::kRG_F16, GR_GL_RG16F, SkColors::kYellow },
+
+ { GrColorType::kUnknown, GR_GL_COMPRESSED_RGB8_ETC2, SkColors::kRed },
+ { GrColorType::kUnknown, GR_GL_COMPRESSED_ETC1_RGB8, SkColors::kRed },
};
for (auto combo : combinations) {
- if (kRGB_ETC1_GrPixelConfig == combo.fConfig) {
- // RGB8_ETC2/ETC1_RGB8 is an either/or situation
- GrGLenum supportedETC1Format = glCaps->configSizedInternalFormat(combo.fConfig);
- if (supportedETC1Format != combo.fFormat) {
- continue;
- }
- }
-
GrBackendFormat format = GrBackendFormat::MakeGL(combo.fFormat, GR_GL_TEXTURE_2D);
- if (GR_GL_COMPRESSED_RGB8_ETC2 == combo.fFormat ||
- GR_GL_COMPRESSED_ETC1_RGB8 == combo.fFormat) {
- // We current disallow uninitialized ETC1 textures in the GL backend
+ if (!glCaps->isFormatTexturable(combo.fColorType, format)) {
continue;
}
- GrColorType grCT = SkColorTypeAndFormatToGrColorType(glCaps, combo.fColorType, format);
- if (GrColorType::kUnknown == grCT) {
- continue;
- }
-
- if (!glCaps->isFormatTexturable(grCT, format)) {
- continue;
- }
-
- if (kBGRA_8888_SkColorType == combo.fColorType) {
+ if (GrColorType::kBGRA_8888 == combo.fColorType) {
if (GR_GL_RGBA8 == combo.fFormat && kGL_GrGLStandard != standard) {
continue;
}
@@ -619,16 +581,19 @@
for (auto renderable : { GrRenderable::kNo, GrRenderable::kYes }) {
if (GrRenderable::kYes == renderable) {
- if (kRGB_888x_SkColorType == combo.fColorType) {
+ if (GrColorType::kRGB_888x == combo.fColorType) {
// Ganesh can't perform the blends correctly when rendering this format
continue;
}
- if (!glCaps->isConfigRenderable(combo.fConfig)) {
+ if (!glCaps->isFormatRenderable(combo.fColorType, format)) {
continue;
}
}
- {
+
+ // We current disallow uninitialized compressed textures in the GL backend
+ if (GR_GL_COMPRESSED_RGB8_ETC2 != combo.fFormat &&
+ GR_GL_COMPRESSED_ETC1_RGB8 != combo.fFormat) {
auto uninitCreateMtd = [format](GrContext* context,
GrMipMapped mipMapped,
GrRenderable renderable) {
@@ -643,7 +608,7 @@
{
// GL has difficulties reading back from these combinations
- if (kAlpha_8_SkColorType == combo.fColorType) {
+ if (GrColorType::kAlpha_8 == combo.fColorType) {
continue;
}
if (GrRenderable::kYes != renderable) {
@@ -683,49 +648,51 @@
constexpr SkColor4f kGrayCol { 0.75f, 0.75f, 0.75f, 0.75f };
struct {
- SkColorType fColorType;
+ GrColorType fColorType;
VkFormat fFormat;
SkColor4f fColor;
} combinations[] = {
- { kRGBA_8888_SkColorType, VK_FORMAT_R8G8B8A8_UNORM, SkColors::kRed },
- { kRGBA_8888_SkColorType, VK_FORMAT_R8G8B8A8_SRGB, SkColors::kRed },
+ { GrColorType::kRGBA_8888, VK_FORMAT_R8G8B8A8_UNORM, SkColors::kRed },
+ { GrColorType::kRGBA_8888_SRGB, VK_FORMAT_R8G8B8A8_SRGB, SkColors::kRed },
// In this configuration (i.e., an RGB_888x colortype with an RGBA8 backing format),
// there is nothing to tell Skia to make the provided color opaque. Clients will need
// to provide an opaque initialization color in this case.
- { kRGB_888x_SkColorType, VK_FORMAT_R8G8B8A8_UNORM, SkColors::kYellow },
- { kRGB_888x_SkColorType, VK_FORMAT_R8G8B8_UNORM, SkColors::kCyan },
+ { GrColorType::kRGB_888x, VK_FORMAT_R8G8B8A8_UNORM, SkColors::kYellow },
+ { GrColorType::kRGB_888x, VK_FORMAT_R8G8B8_UNORM, SkColors::kCyan },
- { kBGRA_8888_SkColorType, VK_FORMAT_B8G8R8A8_UNORM, SkColors::kBlue },
+ { GrColorType::kBGRA_8888, VK_FORMAT_B8G8R8A8_UNORM, SkColors::kBlue },
- { kRGBA_1010102_SkColorType, VK_FORMAT_A2B10G10R10_UNORM_PACK32, { 0.5f, 0, 0, 1.0f } },
- { kRGB_565_SkColorType, VK_FORMAT_R5G6B5_UNORM_PACK16, SkColors::kRed },
+ { GrColorType::kRGBA_1010102, VK_FORMAT_A2B10G10R10_UNORM_PACK32, { 0.5f, 0, 0, 1.0f }},
+ { GrColorType::kBGR_565, VK_FORMAT_R5G6B5_UNORM_PACK16, SkColors::kRed },
- { kARGB_4444_SkColorType, VK_FORMAT_R4G4B4A4_UNORM_PACK16, SkColors::kCyan },
- { kARGB_4444_SkColorType, VK_FORMAT_B4G4R4A4_UNORM_PACK16, SkColors::kYellow },
+ { GrColorType::kABGR_4444, VK_FORMAT_R4G4B4A4_UNORM_PACK16, SkColors::kCyan },
+ { GrColorType::kABGR_4444, VK_FORMAT_B4G4R4A4_UNORM_PACK16, SkColors::kYellow },
- { kAlpha_8_SkColorType, VK_FORMAT_R8_UNORM, kTransCol },
+ { GrColorType::kAlpha_8, VK_FORMAT_R8_UNORM, kTransCol },
// In this config (i.e., a Gray8 color type with an R8 backing format), there is nothing
// to tell Skia this isn't an Alpha8 color type (so it will initialize the texture with
// the alpha channel of the color). Clients should, in general, fill all the channels
// of the provided color with the same value in such cases.
- { kGray_8_SkColorType, VK_FORMAT_R8_UNORM, kGrayCol },
+ { GrColorType::kGray_8, VK_FORMAT_R8_UNORM, kGrayCol },
- { kRGBA_F32_SkColorType, VK_FORMAT_R32G32B32A32_SFLOAT, SkColors::kRed },
+ { GrColorType::kRGBA_F32, VK_FORMAT_R32G32B32A32_SFLOAT, SkColors::kRed },
- { kRGBA_F16Norm_SkColorType, VK_FORMAT_R16G16B16A16_SFLOAT, SkColors::kLtGray },
- { kRGBA_F16_SkColorType, VK_FORMAT_R16G16B16A16_SFLOAT, SkColors::kYellow },
+ { GrColorType::kRGBA_F16_Clamped, VK_FORMAT_R16G16B16A16_SFLOAT, SkColors::kLtGray },
+ { GrColorType::kRGBA_F16, VK_FORMAT_R16G16B16A16_SFLOAT, SkColors::kYellow },
// These backend formats don't have SkColorType equivalents
- { kUnknown_SkColorType, VK_FORMAT_R8G8_UNORM, { 0.5f, 0.5f, 0, 0 } },
- { kUnknown_SkColorType, VK_FORMAT_R16_SFLOAT, { 1.0f, 0, 0, 0.5f } },
- { kUnknown_SkColorType, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, SkColors::kRed },
- { kUnknown_SkColorType, VK_FORMAT_R16_UNORM, SkColors::kRed },
- { kUnknown_SkColorType, VK_FORMAT_R16G16_UNORM, SkColors::kYellow },
+ { GrColorType::kRG_88, VK_FORMAT_R8G8_UNORM, { 0.5f, 0.5f, 0, 0 }},
+ { GrColorType::kAlpha_F16, VK_FORMAT_R16_SFLOAT, { 1.0f, 0, 0, 0.5f }},
+
+ { GrColorType::kR_16, VK_FORMAT_R16_UNORM, SkColors::kRed },
+ { GrColorType::kRG_1616, VK_FORMAT_R16G16_UNORM, SkColors::kYellow },
// Experimental (for Y416 and mutant P016/P010)
- { kUnknown_SkColorType, VK_FORMAT_R16G16B16A16_UNORM, SkColors::kLtGray },
- { kUnknown_SkColorType, VK_FORMAT_R16G16_SFLOAT, SkColors::kYellow },
+ { GrColorType::kRGBA_16161616, VK_FORMAT_R16G16B16A16_UNORM, SkColors::kLtGray },
+ { GrColorType::kRG_F16, VK_FORMAT_R16G16_SFLOAT, SkColors::kYellow },
+
+ { GrColorType::kUnknown, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, SkColors::kRed },
};
for (auto combo : combinations) {
@@ -743,7 +710,7 @@
for (auto renderable : { GrRenderable::kNo, GrRenderable::kYes }) {
if (GrRenderable::kYes == renderable) {
- if (kRGB_888x_SkColorType == combo.fColorType) {
+ if (GrColorType::kRGB_888x == combo.fColorType) {
// Ganesh can't perform the blends correctly when rendering this format
continue;
}
@@ -752,7 +719,8 @@
}
}
- {
+ // We current disallow uninitialized compressed textures in the Vulkan backend
+ if (combo.fFormat != VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK) {
auto uninitCreateMtd = [format](GrContext* context,
GrMipMapped mipMapped,
GrRenderable renderable) {
@@ -779,11 +747,11 @@
// expectation.
GrSwizzle swizzle;
switch (combo.fColorType) {
- case kAlpha_8_SkColorType:
+ case GrColorType::kAlpha_8:
SkASSERT(combo.fFormat == VK_FORMAT_R8_UNORM);
swizzle = GrSwizzle("aaaa");
break;
- case kARGB_4444_SkColorType:
+ case GrColorType::kABGR_4444:
if (combo.fFormat == VK_FORMAT_B4G4R4A4_UNORM_PACK16) {
swizzle = GrSwizzle("bgra");
}
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index 35b8109..09eef93 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -169,6 +169,8 @@
tex = resourceProvider->createTexture(desc, GrRenderable::kYes, 1, SkBudgeted::kNo,
GrProtected::kNo,
GrResourceProvider::Flags::kNoPendingIO);
+ // In order to remove this GrPixelConfig usage, this test will need to be rewritten
+ // w/ true backend formats. Otherwise the compressed formats get elided.
bool isRenderable = caps->isConfigRenderable(config);
REPORTER_ASSERT(reporter, SkToBool(tex) == isRenderable,
"config:%d, tex:%d, isRenderable:%d", config, SkToBool(tex),
diff --git a/tests/MtlBackendAllocationTest.mm b/tests/MtlBackendAllocationTest.mm
index 16df58f..4051154 100644
--- a/tests/MtlBackendAllocationTest.mm
+++ b/tests/MtlBackendAllocationTest.mm
@@ -17,14 +17,14 @@
std::function<GrBackendTexture (GrContext*,
GrMipMapped,
GrRenderable)> create,
- SkColorType colorType, GrMipMapped mipMapped, GrRenderable renderable);
+ GrColorType colorType, GrMipMapped mipMapped, GrRenderable renderable);
void test_color_init(GrContext* context, skiatest::Reporter* reporter,
std::function<GrBackendTexture (GrContext*,
const SkColor4f&,
GrMipMapped,
GrRenderable)> create,
- SkColorType colorType, const SkColor4f& color,
+ GrColorType colorType, const SkColor4f& color,
GrMipMapped mipMapped, GrRenderable renderable);
DEF_GPUTEST_FOR_METAL_CONTEXT(MtlBackendAllocationTest, reporter, ctxInfo) {
@@ -34,68 +34,57 @@
constexpr SkColor4f kTransCol { 0, 0.25f, 0.75f, 0.5f };
struct {
- SkColorType fColorType;
- GrMTLPixelFormat fFormat;
- // TODO: remove 'fConfig' and directly use 'fFormat' in GrMtlCaps::isFormatTexturable
- GrPixelConfig fConfig;
+ GrColorType fColorType;
+ MTLPixelFormat fFormat;
SkColor4f fColor;
} combinations[] = {
- { kRGBA_8888_SkColorType, MTLPixelFormatRGBA8Unorm,
- kRGBA_8888_GrPixelConfig, SkColors::kRed },
- { kRGBA_8888_SkColorType, MTLPixelFormatRGBA8Unorm_sRGB,
- kSRGBA_8888_GrPixelConfig, SkColors::kRed },
+ { GrColorType::kRGBA_8888, MTLPixelFormatRGBA8Unorm, SkColors::kRed },
+ { GrColorType::kRGBA_8888_SRGB, MTLPixelFormatRGBA8Unorm_sRGB, SkColors::kRed },
- { kRGB_888x_SkColorType, MTLPixelFormatRGBA8Unorm,
- kRGBA_8888_GrPixelConfig, { 1, 1, 0, 0.5f } },
+ { GrColorType::kRGB_888x, MTLPixelFormatRGBA8Unorm, { 1, 1, 0, 0.5f } },
- { kBGRA_8888_SkColorType, MTLPixelFormatBGRA8Unorm,
- kBGRA_8888_GrPixelConfig, SkColors::kBlue },
+ { GrColorType::kBGRA_8888, MTLPixelFormatBGRA8Unorm, SkColors::kBlue },
- { kRGBA_1010102_SkColorType, MTLPixelFormatRGB10A2Unorm,
- kRGBA_1010102_GrPixelConfig, { 0.5f, 0, 0, 1.0f } },
+ { GrColorType::kRGBA_1010102, MTLPixelFormatRGB10A2Unorm, { 0.5f, 0, 0, 1.0f } },
#ifdef SK_BUILD_FOR_IOS
- { kRGB_565_SkColorType, MTLPixelFormatB5G6R5Unorm,
- kRGB_565_GrPixelConfig, SkColors::kRed },
- { kARGB_4444_SkColorType, MTLPixelFormatABGR4Unorm,
- kRGBA_4444_GrPixelConfig, SkColors::kGreen },
+ { GrColorType::kBGR_565, MTLPixelFormatB5G6R5Unorm, SkColors::kRed },
+ { GrColorType::kABGR_4444, MTLPixelFormatABGR4Unorm, SkColors::kGreen },
#endif
- { kAlpha_8_SkColorType, MTLPixelFormatA8Unorm,
- kAlpha_8_as_Alpha_GrPixelConfig, kTransCol },
- { kAlpha_8_SkColorType, MTLPixelFormatR8Unorm,
- kAlpha_8_as_Red_GrPixelConfig, kTransCol },
+ { GrColorType::kAlpha_8, MTLPixelFormatA8Unorm, kTransCol },
+ { GrColorType::kAlpha_8, MTLPixelFormatR8Unorm, kTransCol },
- { kGray_8_SkColorType, MTLPixelFormatR8Unorm,
- kGray_8_as_Red_GrPixelConfig, SkColors::kDkGray },
+ { GrColorType::kGray_8, MTLPixelFormatR8Unorm, SkColors::kDkGray },
- { kRGBA_F32_SkColorType, MTLPixelFormatRGBA32Float,
- kRGBA_float_GrPixelConfig, SkColors::kRed },
+ { GrColorType::kRGBA_F32, MTLPixelFormatRGBA32Float, SkColors::kRed },
- { kRGBA_F16Norm_SkColorType, MTLPixelFormatRGBA16Float,
- kRGBA_half_Clamped_GrPixelConfig, SkColors::kLtGray },
- { kRGBA_F16_SkColorType, MTLPixelFormatRGBA16Float,
- kRGBA_half_GrPixelConfig, SkColors::kYellow },
+ { GrColorType::kRGBA_F16_Clamped, MTLPixelFormatRGBA16Float, SkColors::kLtGray },
+ { GrColorType::kRGBA_F16, MTLPixelFormatRGBA16Float, SkColors::kYellow },
- // These backend formats don't have SkColorType equivalents
- { kUnknown_SkColorType, MTLPixelFormatRG8Unorm,
- kRG_88_GrPixelConfig, { 0.5f, 0.5f, 0, 0 }},
- { kUnknown_SkColorType, MTLPixelFormatR16Float,
- kAlpha_half_as_Red_GrPixelConfig, { 1.0f, 0, 0, 0.5f }},
+ { GrColorType::kRG_88, MTLPixelFormatRG8Unorm, { 0.5f, 0.5f, 0, 0 } },
+ { GrColorType::kAlpha_F16, MTLPixelFormatR16Float, { 1.0f, 0, 0, 0.5f } },
+
+ { GrColorType::kR_16, MTLPixelFormatR16Unorm, SkColors::kRed },
+ { GrColorType::kRG_1616, MTLPixelFormatRG16Unorm, SkColors::kYellow },
+
+ // Experimental (for Y416 and mutant P016/P010)
+ { GrColorType::kRGBA_16161616, MTLPixelFormatRGBA16Unorm, SkColors::kLtGray },
+ { GrColorType::kRG_F16, MTLPixelFormatRG16Float, SkColors::kYellow },
+
#ifdef SK_BUILD_FOR_IOS
- { kUnknown_SkColorType, MTLPixelFormatETC2_RGB8,
- kRGB_ETC1_GrPixelConfig, SkColors::kRed }
+ { GrColorType::kUnknown, MTLPixelFormatETC2_RGB8, SkColors::kRed }
#endif
};
for (auto combo : combinations) {
GrBackendFormat format = GrBackendFormat::MakeMtl(combo.fFormat);
- if (!mtlCaps->isConfigTexturable(combo.fConfig)) {
+ if (!mtlCaps->isFormatTexturable(combo.fFormat)) {
continue;
}
// skbug.com/9086 (Metal caps may not be handling RGBA32 correctly)
- if (kRGBA_F32_SkColorType == combo.fColorType) {
+ if (GrColorType::kRGBA_F32 == combo.fColorType) {
continue;
}
@@ -107,15 +96,19 @@
for (auto renderable : { GrRenderable::kNo, GrRenderable::kYes }) {
if (GrRenderable::kYes == renderable) {
- if (kRGB_888x_SkColorType == combo.fColorType) {
+ if (GrColorType::kRGB_888x == combo.fColorType) {
// Ganesh can't perform the blends correctly when rendering this format
continue;
}
- if (!mtlCaps->isConfigRenderable(combo.fConfig)) {
+ if (!mtlCaps->isFormatRenderable(combo.fFormat)) {
continue;
}
}
+#ifdef SK_BUILD_FOR_IOS
+ // We current disallow uninitialized compressed textures in the Metal backend
+ if (combo.fFormat != MTLPixelFormatETC2_RGB8)
+#endif
{
auto uninitCreateMtd = [format](GrContext* context,
GrMipMapped mipMapped,
