Switch GrCaps::areColorTypeAndFormatCompatible over to using GrColorType
This necessitated some Gr*Caps refactoring
Change-Id: I8d72e9645b51bcf72d58b2c2c4fbd9ee7e83ddf1
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/225184
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
diff --git a/src/gpu/GrCaps.h b/src/gpu/GrCaps.h
index 0e0cf32..c7b7c8e 100644
--- a/src/gpu/GrCaps.h
+++ b/src/gpu/GrCaps.h
@@ -362,15 +362,35 @@
* returned.
*/
virtual GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
- SkColorType) const = 0;
+ GrColorType) const = 0;
- virtual bool areColorTypeAndFormatCompatible(SkColorType ct, const GrBackendFormat&) const = 0;
+ bool areColorTypeAndFormatCompatible(SkColorType skCT,
+ const GrBackendFormat& format) const {
+ GrColorType grCT = SkColorTypeToGrColorType(skCT);
+ if (GrColorType::kUnknown == grCT) {
+ return false;
+ }
+
+ return this->areColorTypeAndFormatCompatible(grCT, format);
+ }
+
+ virtual bool areColorTypeAndFormatCompatible(GrColorType ct, const GrBackendFormat&) const = 0;
+
+ GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat& format,
+ SkColorType skCT) const {
+ GrColorType grCT = SkColorTypeToGrColorType(skCT);
+ if (GrColorType::kUnknown == grCT) {
+ return kUnknown_GrPixelConfig;
+ }
+
+ return this->getConfigFromBackendFormat(format, grCT);
+ }
// TODO: replace validateBackendRenderTarget with calls to getConfigFromBackendFormat?
// TODO: it seems like we could pass the full SkImageInfo and validate its colorSpace too
// Returns kUnknown if a valid config could not be determined.
virtual GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat& format,
- SkColorType ct) const = 0;
+ GrColorType ct) const = 0;
/**
* Special method only for YUVA images. Returns a config that matches the backend format or
diff --git a/src/gpu/GrProxyProvider.cpp b/src/gpu/GrProxyProvider.cpp
index c7d4de9..d71cf7a 100644
--- a/src/gpu/GrProxyProvider.cpp
+++ b/src/gpu/GrProxyProvider.cpp
@@ -415,15 +415,10 @@
// We have no way to verify these at the moment.
return true;
}
- SkColorType colorType = GrColorTypeToSkColorType(GrPixelConfigToColorType(config));
- if (colorType == kUnknown_SkColorType) {
- // We should add support for validating GrColorType with a GrBackendFormat. Currently we
- // only support SkColorType. For now we just assume things that don't have a corresponding
- // SkColorType are correct.
- return true;
- }
- return caps->areColorTypeAndFormatCompatible(colorType, format);
+ GrColorType grCT = GrPixelConfigToColorType(config);
+
+ return caps->areColorTypeAndFormatCompatible(grCT, format);
}
#endif
@@ -618,8 +613,7 @@
GrColorType colorType = GrPixelConfigToColorType(backendRT.config());
#ifdef SK_DEBUG
GrPixelConfig testConfig =
- this->caps()->validateBackendRenderTarget(backendRT,
- GrColorTypeToSkColorType(colorType));
+ this->caps()->validateBackendRenderTarget(backendRT, colorType);
SkASSERT(testConfig != kUnknown_GrPixelConfig);
#endif
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 39b0ca9..aaf2c82 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1677,8 +1677,7 @@
format = fContext->priv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);
}
- auto config = fContext->priv().caps()->getConfigFromBackendFormat(
- format, GrColorTypeToSkColorType(colorType));
+ auto config = fContext->priv().caps()->getConfigFromBackendFormat(format, colorType);
sk_sp<GrRenderTargetContext> rtc(fContext->priv().makeDeferredRenderTargetContext(
format,
fit,
diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp
index 58a623b..4452876 100644
--- a/src/gpu/gl/GrGLCaps.cpp
+++ b/src/gpu/gl/GrGLCaps.cpp
@@ -3619,9 +3619,14 @@
return this->isGLFormatTexturable(grCT, *glFormat);
}
-int GrGLCaps::getRenderTargetSampleCount(int requestedCount, SkColorType ct,
+int GrGLCaps::getRenderTargetSampleCount(int requestedCount, SkColorType skCT,
const GrBackendFormat& format) const {
- GrPixelConfig config = this->getConfigFromBackendFormat(format, ct);
+ GrColorType grCT = SkColorTypeToGrColorType(skCT);
+ if (GrColorType::kUnknown == grCT) {
+ return 0;
+ }
+
+ GrPixelConfig config = this->getConfigFromBackendFormat(format, grCT);
if (kUnknown_GrPixelConfig == config) {
return 0;
}
@@ -3652,8 +3657,13 @@
return 0;
}
-int GrGLCaps::maxRenderTargetSampleCount(SkColorType ct, const GrBackendFormat& format) const {
- GrPixelConfig config = this->getConfigFromBackendFormat(format, ct);
+int GrGLCaps::maxRenderTargetSampleCount(SkColorType skCT, const GrBackendFormat& format) const {
+ GrColorType grCT = SkColorTypeToGrColorType(skCT);
+ if (GrColorType::kUnknown == grCT) {
+ return 0;
+ }
+
+ GrPixelConfig config = this->getConfigFromBackendFormat(format, grCT);
if (kUnknown_GrPixelConfig == config) {
return 0;
}
@@ -3689,42 +3699,48 @@
return this->canFormatBeFBOColorAttachment(*glFormat);
}
-GrPixelConfig validate_sized_format(GrGLenum format, SkColorType ct, GrGLStandard standard) {
+// A near clone of format_color_type_valid_pair
+GrPixelConfig validate_sized_format(GrGLenum format, GrColorType ct, GrGLStandard standard) {
switch (ct) {
- case kUnknown_SkColorType:
+ case GrColorType::kUnknown:
return kUnknown_GrPixelConfig;
- case kAlpha_8_SkColorType:
+ case GrColorType::kAlpha_8:
if (GR_GL_ALPHA8 == format) {
return kAlpha_8_as_Alpha_GrPixelConfig;
} else if (GR_GL_R8 == format) {
return kAlpha_8_as_Red_GrPixelConfig;
}
break;
- case kRGB_565_SkColorType:
+ case GrColorType::kBGR_565:
if (GR_GL_RGB565 == format) {
return kRGB_565_GrPixelConfig;
}
break;
- case kARGB_4444_SkColorType:
+ case GrColorType::kABGR_4444:
if (GR_GL_RGBA4 == format) {
return kRGBA_4444_GrPixelConfig;
}
break;
- case kRGBA_8888_SkColorType:
+ case GrColorType::kRGBA_8888:
if (GR_GL_RGBA8 == format) {
return kRGBA_8888_GrPixelConfig;
} else if (GR_GL_SRGB8_ALPHA8 == format) {
return kSRGBA_8888_GrPixelConfig;
}
break;
- case kRGB_888x_SkColorType:
+ case GrColorType::kRGB_888x:
if (GR_GL_RGB8 == format) {
return kRGB_888_GrPixelConfig;
} else if (GR_GL_RGBA8 == format) {
return kRGB_888X_GrPixelConfig;
}
break;
- case kBGRA_8888_SkColorType:
+ case GrColorType::kRG_88:
+ if (GR_GL_RG8 == format) {
+ return kRG_88_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kBGRA_8888:
if (GR_GL_RGBA8 == format) {
if (GR_IS_GR_GL(standard)) {
return kBGRA_8888_GrPixelConfig;
@@ -3735,42 +3751,71 @@
}
}
break;
- case kRGBA_1010102_SkColorType:
+ case GrColorType::kRGBA_1010102:
if (GR_GL_RGB10_A2 == format) {
return kRGBA_1010102_GrPixelConfig;
}
break;
- case kRGB_101010x_SkColorType:
- break;
- case kGray_8_SkColorType:
+ case GrColorType::kGray_8:
if (GR_GL_LUMINANCE8 == format) {
return kGray_8_as_Lum_GrPixelConfig;
} else if (GR_GL_R8 == format) {
return kGray_8_as_Red_GrPixelConfig;
}
break;
- case kRGBA_F16Norm_SkColorType:
- if (GR_GL_RGBA16F == format) {
- return kRGBA_half_Clamped_GrPixelConfig;
+ case GrColorType::kAlpha_F16:
+ if (GR_GL_R16F == format) {
+ return kAlpha_half_GrPixelConfig;
}
break;
- case kRGBA_F16_SkColorType:
+ case GrColorType::kRGBA_F16:
if (GR_GL_RGBA16F == format) {
return kRGBA_half_GrPixelConfig;
}
break;
- case kRGBA_F32_SkColorType:
+ case GrColorType::kRGBA_F16_Clamped:
+ if (GR_GL_RGBA16F == format) {
+ return kRGBA_half_Clamped_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_F32:
+ if (GR_GL_RG32F == format) {
+ return kRG_float_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRGBA_F32:
if (GR_GL_RGBA32F == format) {
return kRGBA_float_GrPixelConfig;
}
break;
+ case GrColorType::kR_16:
+ if (GR_GL_R16 == format) {
+ return kR_16_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_1616:
+ if (GR_GL_RG16 == format) {
+ return kRG_1616_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRGBA_16161616:
+ if (GR_GL_RGBA16 == format) {
+ return kRGBA_16161616_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_F16:
+ if (GR_GL_RG16F == format) {
+ return kRG_half_GrPixelConfig;
+ }
+ break;
}
+
SkDebugf("Unknown pixel config 0x%x\n", format);
return kUnknown_GrPixelConfig;
}
GrPixelConfig GrGLCaps::validateBackendRenderTarget(const GrBackendRenderTarget& rt,
- SkColorType ct) const {
+ GrColorType ct) const {
GrGLFramebufferInfo fbInfo;
if (!rt.getGLFramebufferInfo(&fbInfo)) {
return kUnknown_GrPixelConfig;
@@ -3778,7 +3823,7 @@
return validate_sized_format(fbInfo.fFormat, ct, fStandard);
}
-bool GrGLCaps::areColorTypeAndFormatCompatible(SkColorType ct,
+bool GrGLCaps::areColorTypeAndFormatCompatible(GrColorType ct,
const GrBackendFormat& format) const {
const GrGLenum* glFormat = format.getGLFormat();
if (!glFormat) {
@@ -3789,7 +3834,7 @@
}
GrPixelConfig GrGLCaps::getConfigFromBackendFormat(const GrBackendFormat& format,
- SkColorType ct) const {
+ GrColorType ct) const {
const GrGLenum* glFormat = format.getGLFormat();
if (!glFormat) {
return kUnknown_GrPixelConfig;
diff --git a/src/gpu/gl/GrGLCaps.h b/src/gpu/gl/GrGLCaps.h
index 09e6f29..2e0aba9 100644
--- a/src/gpu/gl/GrGLCaps.h
+++ b/src/gpu/gl/GrGLCaps.h
@@ -417,11 +417,11 @@
bool fbFetchRequiresEnablePerSample() const { return fFBFetchRequiresEnablePerSample; }
GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
- SkColorType) const override;
+ GrColorType) const override;
- bool areColorTypeAndFormatCompatible(SkColorType, const GrBackendFormat&) const override;
+ bool areColorTypeAndFormatCompatible(GrColorType, const GrBackendFormat&) const override;
- GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, SkColorType) const override;
+ GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, GrColorType) const override;
GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat&) const override;
GrBackendFormat getBackendFormatFromGrColorType(GrColorType ct,
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 1288036..cad7f79 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -4131,13 +4131,7 @@
// Lots of tests don't go through Skia's public interface which will set the config so for
// testing we make sure we set a config here.
beRT.setPixelConfig(config);
-#ifdef SK_DEBUG
- SkColorType skColorType = GrColorTypeToSkColorType(colorType);
- if (skColorType != kUnknown_SkColorType) {
- SkASSERT(this->caps()->validateBackendRenderTarget(
- beRT, GrColorTypeToSkColorType(colorType)) != kUnknown_GrPixelConfig);
- }
-#endif
+ SkASSERT(kUnknown_GrPixelConfig != this->caps()->validateBackendRenderTarget(beRT, colorType));
return beRT;
}
diff --git a/src/gpu/mock/GrMockCaps.h b/src/gpu/mock/GrMockCaps.h
index 803359a..6e88296 100644
--- a/src/gpu/mock/GrMockCaps.h
+++ b/src/gpu/mock/GrMockCaps.h
@@ -120,11 +120,11 @@
}
GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
- SkColorType) const override {
+ GrColorType) const override {
return kUnknown_GrPixelConfig;
}
- bool areColorTypeAndFormatCompatible(SkColorType ct,
+ bool areColorTypeAndFormatCompatible(GrColorType ct,
const GrBackendFormat& format) const override {
const GrPixelConfig* mockFormat = format.getMockFormat();
if (!mockFormat) {
@@ -132,78 +132,110 @@
}
switch (ct) {
- case kUnknown_SkColorType:
+ case GrColorType::kUnknown:
return false;
- case kAlpha_8_SkColorType:
+ case GrColorType::kAlpha_8:
if (kAlpha_8_GrPixelConfig == *mockFormat ||
kAlpha_8_as_Alpha_GrPixelConfig == *mockFormat ||
kAlpha_8_as_Red_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kRGB_565_SkColorType:
+ case GrColorType::kBGR_565:
if (kRGB_565_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kARGB_4444_SkColorType:
+ case GrColorType::kABGR_4444:
if (kRGBA_4444_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kRGBA_8888_SkColorType:
+ case GrColorType::kRGBA_8888:
if (kRGBA_8888_GrPixelConfig == *mockFormat ||
kSRGBA_8888_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kRGB_888x_SkColorType:
+ case GrColorType::kRGB_888x:
if (kRGB_888X_GrPixelConfig == *mockFormat ||
kRGB_888_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kBGRA_8888_SkColorType:
+ case GrColorType::kRG_88:
+ if (kRG_88_GrPixelConfig == *mockFormat) {
+ return true;
+ }
+ break;
+ case GrColorType::kBGRA_8888:
if (kBGRA_8888_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kRGBA_1010102_SkColorType:
+ case GrColorType::kRGBA_1010102:
if (kRGBA_1010102_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kRGB_101010x_SkColorType:
- return false;
- case kGray_8_SkColorType:
+ case GrColorType::kGray_8:
if (kGray_8_GrPixelConfig == *mockFormat ||
kGray_8_as_Lum_GrPixelConfig == *mockFormat ||
kGray_8_as_Red_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kRGBA_F16Norm_SkColorType:
- if (kRGBA_half_Clamped_GrPixelConfig == *mockFormat) {
+ case GrColorType::kAlpha_F16:
+ if (kAlpha_half_GrPixelConfig == *mockFormat) {
return true;
}
- break;
- case kRGBA_F16_SkColorType:
+ case GrColorType::kRGBA_F16:
if (kRGBA_half_GrPixelConfig == *mockFormat) {
return true;
}
break;
- case kRGBA_F32_SkColorType:
+ case GrColorType::kRGBA_F16_Clamped:
+ if (kRGBA_half_Clamped_GrPixelConfig == *mockFormat) {
+ return true;
+ }
+ break;
+ case GrColorType::kRG_F32:
+ if (kRG_float_GrPixelConfig == *mockFormat) {
+ return true;
+ }
+ break;
+ case GrColorType::kRGBA_F32:
if (kRGBA_float_GrPixelConfig == *mockFormat) {
return true;
}
break;
+ case GrColorType::kR_16:
+ if (kR_16_GrPixelConfig == *mockFormat) {
+ return true;
+ }
+ break;
+ case GrColorType::kRG_1616:
+ if (kRG_1616_GrPixelConfig == *mockFormat) {
+ return true;
+ }
+ break;
+ case GrColorType::kRGBA_16161616:
+ if (kRGBA_16161616_GrPixelConfig == *mockFormat) {
+ return true;
+ }
+ break;
+ case GrColorType::kRG_F16:
+ if (kRG_half_GrPixelConfig == *mockFormat) {
+ return true;
+ }
+ break;
}
return false;
}
GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat& format,
- SkColorType ct) const override {
+ GrColorType) const override {
const GrPixelConfig* mockFormat = format.getMockFormat();
if (!mockFormat) {
return kUnknown_GrPixelConfig;
diff --git a/src/gpu/mtl/GrMtlCaps.h b/src/gpu/mtl/GrMtlCaps.h
index 7ab05d8..9472416 100644
--- a/src/gpu/mtl/GrMtlCaps.h
+++ b/src/gpu/mtl/GrMtlCaps.h
@@ -65,11 +65,11 @@
}
GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
- SkColorType) const override;
+ GrColorType) const override;
- bool areColorTypeAndFormatCompatible(SkColorType, const GrBackendFormat&) const override;
+ bool areColorTypeAndFormatCompatible(GrColorType, const GrBackendFormat&) const override;
- GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, SkColorType) const override;
+ GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, GrColorType) const override;
GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat&) const override;
diff --git a/src/gpu/mtl/GrMtlCaps.mm b/src/gpu/mtl/GrMtlCaps.mm
index 34f355b..ee21e98 100644
--- a/src/gpu/mtl/GrMtlCaps.mm
+++ b/src/gpu/mtl/GrMtlCaps.mm
@@ -253,8 +253,13 @@
return format_is_srgb(static_cast<MTLPixelFormat>(*format.getMtlFormat()));
}
-bool GrMtlCaps::isFormatTexturable(SkColorType ct, const GrBackendFormat& format) const {
- GrPixelConfig config = this->getConfigFromBackendFormat(format, ct);
+bool GrMtlCaps::isFormatTexturable(SkColorType skCT, const GrBackendFormat& format) const {
+ GrColorType grCT = SkColorTypeToGrColorType(skCT);
+ if (GrColorType::kUnknown == grCT) {
+ return false;
+ }
+
+ GrPixelConfig config = this->getConfigFromBackendFormat(format, grCT);
if (kUnknown_GrPixelConfig == config) {
return false;
}
@@ -262,10 +267,15 @@
return this->isConfigTexturable(config);
}
-int GrMtlCaps::maxRenderTargetSampleCount(SkColorType ct, const GrBackendFormat& format) const {
- GrPixelConfig config = this->getConfigFromBackendFormat(format, ct);
+int GrMtlCaps::maxRenderTargetSampleCount(SkColorType skCT, const GrBackendFormat& format) const {
+ GrColorType grCT = SkColorTypeToGrColorType(skCT);
+ if (GrColorType::kUnknown == grCT) {
+ return 0;
+ }
+
+ GrPixelConfig config = this->getConfigFromBackendFormat(format, grCT);
if (kUnknown_GrPixelConfig == config) {
- return false;
+ return 0;
}
return this->maxRenderTargetSampleCount(config);
@@ -281,10 +291,15 @@
}
int GrMtlCaps::getRenderTargetSampleCount(int requestedCount,
- SkColorType ct, const GrBackendFormat& format) const {
- GrPixelConfig config = this->getConfigFromBackendFormat(format, ct);
+ SkColorType skCT, const GrBackendFormat& format) const {
+ GrColorType grCT = SkColorTypeToGrColorType(skCT);
+ if (GrColorType::kUnknown == grCT) {
+ return 0;
+ }
+
+ GrPixelConfig config = this->getConfigFromBackendFormat(format, grCT);
if (kUnknown_GrPixelConfig == config) {
- return false;
+ return 0;
}
return this->getRenderTargetSampleCount(requestedCount, config);
@@ -481,12 +496,13 @@
return true;
}
-GrPixelConfig validate_sized_format(GrMTLPixelFormat grFormat, SkColorType ct) {
+// A near clone of format_color_type_valid_pair
+GrPixelConfig validate_sized_format(GrMTLPixelFormat grFormat, GrColorType ct) {
MTLPixelFormat format = static_cast<MTLPixelFormat>(grFormat);
switch (ct) {
- case kUnknown_SkColorType:
+ case GrColorType::kUnknown:
return kUnknown_GrPixelConfig;
- case kAlpha_8_SkColorType:
+ case GrColorType::kAlpha_8:
if (MTLPixelFormatA8Unorm == format) {
return kAlpha_8_as_Alpha_GrPixelConfig;
} else if (MTLPixelFormatR8Unorm == format) {
@@ -494,73 +510,106 @@
}
break;
#ifdef SK_BUILD_FOR_MAC
- case kRGB_565_SkColorType:
- case kARGB_4444_SkColorType:
+ case GrColorType::kBGR_565:
+ case GrColorType::kABGR_4444:
return kUnknown_GrPixelConfig;
break;
#else
- case kRGB_565_SkColorType:
+ case GrColorType::kBGR_565:
if (MTLPixelFormatB5G6R5Unorm == format) {
return kRGB_565_GrPixelConfig;
}
break;
- case kARGB_4444_SkColorType:
+ case GrColorType::kABGR_4444:
if (MTLPixelFormatABGR4Unorm == format) {
return kRGBA_4444_GrPixelConfig;
}
break;
#endif
- case kRGBA_8888_SkColorType:
+ case GrColorType::kRGBA_8888:
if (MTLPixelFormatRGBA8Unorm == format) {
return kRGBA_8888_GrPixelConfig;
} else if (MTLPixelFormatRGBA8Unorm_sRGB == format) {
return kSRGBA_8888_GrPixelConfig;
}
break;
- case kRGB_888x_SkColorType:
+ case GrColorType::kRGB_888x:
if (MTLPixelFormatRGBA8Unorm == format) {
return kRGB_888X_GrPixelConfig;
}
break;
- case kBGRA_8888_SkColorType:
+ case GrColorType::kRG_88:
+ if (MTLPixelFormatRG8Unorm == format) {
+ return kRG_88_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kBGRA_8888:
if (MTLPixelFormatBGRA8Unorm == format) {
return kBGRA_8888_GrPixelConfig;
}
break;
- case kRGBA_1010102_SkColorType:
+ case GrColorType::kRGBA_1010102:
if (MTLPixelFormatRGB10A2Unorm == format) {
return kRGBA_1010102_GrPixelConfig;
}
break;
- case kRGB_101010x_SkColorType:
- break;
- case kGray_8_SkColorType:
+ case GrColorType::kGray_8:
if (MTLPixelFormatR8Unorm == format) {
return kGray_8_as_Red_GrPixelConfig;
}
break;
- case kRGBA_F16Norm_SkColorType:
- if (MTLPixelFormatRGBA16Float == format) {
- return kRGBA_half_Clamped_GrPixelConfig;
+ case GrColorType::kAlpha_F16:
+ if (MTLPixelFormatR16Float == format) {
+ return kAlpha_half_GrPixelConfig;
}
break;
- case kRGBA_F16_SkColorType:
+ case GrColorType::kRGBA_F16:
if (MTLPixelFormatRGBA16Float == format) {
return kRGBA_half_GrPixelConfig;
}
break;
- case kRGBA_F32_SkColorType:
+ case GrColorType::kRGBA_F16_Clamped:
+ if (MTLPixelFormatRGBA16Float == format) {
+ return kRGBA_half_Clamped_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_F32:
+ if (MTLPixelFormatRG32Float == format) {
+ return kRG_float_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRGBA_F32:
if (MTLPixelFormatRGBA32Float == format) {
return kRGBA_float_GrPixelConfig;
}
break;
+ case GrColorType::kR_16:
+ if (MTLPixelFormatR16Unorm == format) {
+ return kR_16_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_1616:
+ if (MTLPixelFormatRG16Unorm == format) {
+ return kRG_1616_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRGBA_16161616:
+ if (MTLPixelFormatRGBA16Unorm == format) {
+ return kRGBA_16161616_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_F16:
+ if (MTLPixelFormatRG16Float == format) {
+ return kRG_half_GrPixelConfig;
+ }
+ break;
}
return kUnknown_GrPixelConfig;
}
GrPixelConfig GrMtlCaps::validateBackendRenderTarget(const GrBackendRenderTarget& rt,
- SkColorType ct) const {
+ GrColorType ct) const {
GrMtlTextureInfo fbInfo;
if (!rt.getMtlTextureInfo(&fbInfo)) {
return kUnknown_GrPixelConfig;
@@ -570,7 +619,7 @@
return validate_sized_format(texture.pixelFormat, ct);
}
-bool GrMtlCaps::areColorTypeAndFormatCompatible(SkColorType ct,
+bool GrMtlCaps::areColorTypeAndFormatCompatible(GrColorType ct,
const GrBackendFormat& format) const {
const GrMTLPixelFormat* mtlFormat = format.getMtlFormat();
if (!mtlFormat) {
@@ -582,7 +631,7 @@
GrPixelConfig GrMtlCaps::getConfigFromBackendFormat(const GrBackendFormat& format,
- SkColorType ct) const {
+ GrColorType ct) const {
const GrMTLPixelFormat* mtlFormat = format.getMtlFormat();
if (!mtlFormat) {
return kUnknown_GrPixelConfig;
diff --git a/src/gpu/vk/GrVkCaps.cpp b/src/gpu/vk/GrVkCaps.cpp
index 154d166..dd868b6 100644
--- a/src/gpu/vk/GrVkCaps.cpp
+++ b/src/gpu/vk/GrVkCaps.cpp
@@ -932,7 +932,8 @@
return true;
}
-static GrPixelConfig validate_image_info(VkFormat format, SkColorType ct, bool hasYcbcrConversion) {
+// A near clone of format_color_type_valid_pair
+static GrPixelConfig validate_image_info(VkFormat format, GrColorType ct, bool hasYcbcrConversion) {
if (format == VK_FORMAT_UNDEFINED) {
// If the format is undefined then it is only valid as an external image which requires that
// we have a valid VkYcbcrConversion.
@@ -952,32 +953,32 @@
}
switch (ct) {
- case kUnknown_SkColorType:
+ case GrColorType::kUnknown:
break;
- case kAlpha_8_SkColorType:
+ case GrColorType::kAlpha_8:
if (VK_FORMAT_R8_UNORM == format) {
return kAlpha_8_as_Red_GrPixelConfig;
}
break;
- case kRGB_565_SkColorType:
+ case GrColorType::kBGR_565:
if (VK_FORMAT_R5G6B5_UNORM_PACK16 == format) {
return kRGB_565_GrPixelConfig;
}
break;
- case kARGB_4444_SkColorType:
+ case GrColorType::kABGR_4444:
if (VK_FORMAT_B4G4R4A4_UNORM_PACK16 == format ||
VK_FORMAT_R4G4B4A4_UNORM_PACK16 == format) {
return kRGBA_4444_GrPixelConfig;
}
break;
- case kRGBA_8888_SkColorType:
+ case GrColorType::kRGBA_8888:
if (VK_FORMAT_R8G8B8A8_UNORM == format) {
return kRGBA_8888_GrPixelConfig;
} else if (VK_FORMAT_R8G8B8A8_SRGB == format) {
return kSRGBA_8888_GrPixelConfig;
}
break;
- case kRGB_888x_SkColorType:
+ case GrColorType::kRGB_888x:
if (VK_FORMAT_R8G8B8_UNORM == format) {
return kRGB_888_GrPixelConfig;
}
@@ -985,45 +986,78 @@
return kRGB_888X_GrPixelConfig;
}
break;
- case kBGRA_8888_SkColorType:
+ case GrColorType::kRG_88:
+ if (VK_FORMAT_R8G8_UNORM == format) {
+ return kRG_88_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kBGRA_8888:
if (VK_FORMAT_B8G8R8A8_UNORM == format) {
return kBGRA_8888_GrPixelConfig;
}
break;
- case kRGBA_1010102_SkColorType:
+ case GrColorType::kRGBA_1010102:
if (VK_FORMAT_A2B10G10R10_UNORM_PACK32 == format) {
return kRGBA_1010102_GrPixelConfig;
}
break;
- case kRGB_101010x_SkColorType:
- return kUnknown_GrPixelConfig;
- case kGray_8_SkColorType:
+ case GrColorType::kGray_8:
if (VK_FORMAT_R8_UNORM == format) {
return kGray_8_as_Red_GrPixelConfig;
}
break;
- case kRGBA_F16Norm_SkColorType:
- if (VK_FORMAT_R16G16B16A16_SFLOAT == format) {
- return kRGBA_half_Clamped_GrPixelConfig;
+ case GrColorType::kAlpha_F16:
+ if (VK_FORMAT_R16_SFLOAT == format) {
+ return kAlpha_half_GrPixelConfig;
}
break;
- case kRGBA_F16_SkColorType:
+ case GrColorType::kRGBA_F16:
if (VK_FORMAT_R16G16B16A16_SFLOAT == format) {
return kRGBA_half_GrPixelConfig;
}
break;
- case kRGBA_F32_SkColorType:
+ case GrColorType::kRGBA_F16_Clamped:
+ if (VK_FORMAT_R16G16B16A16_SFLOAT == format) {
+ return kRGBA_half_Clamped_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_F32:
+ if (VK_FORMAT_R32G32_SFLOAT == format) {
+ return kRG_float_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRGBA_F32:
if (VK_FORMAT_R32G32B32A32_SFLOAT == format) {
return kRGBA_float_GrPixelConfig;
}
break;
+ case GrColorType::kR_16:
+ if (VK_FORMAT_R16_UNORM == format) {
+ return kR_16_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_1616:
+ if (VK_FORMAT_R16G16_UNORM == format) {
+ return kRG_1616_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRGBA_16161616:
+ if (VK_FORMAT_R16G16B16A16_UNORM == format) {
+ return kRGBA_16161616_GrPixelConfig;
+ }
+ break;
+ case GrColorType::kRG_F16:
+ if (VK_FORMAT_R16G16_SFLOAT == format) {
+ return kRG_half_GrPixelConfig;
+ }
+ break;
}
return kUnknown_GrPixelConfig;
}
GrPixelConfig GrVkCaps::validateBackendRenderTarget(const GrBackendRenderTarget& rt,
- SkColorType ct) const {
+ GrColorType ct) const {
GrVkImageInfo imageInfo;
if (!rt.getVkImageInfo(&imageInfo)) {
return kUnknown_GrPixelConfig;
@@ -1031,7 +1065,7 @@
return validate_image_info(imageInfo.fFormat, ct, imageInfo.fYcbcrConversionInfo.isValid());
}
-bool GrVkCaps::areColorTypeAndFormatCompatible(SkColorType ct,
+bool GrVkCaps::areColorTypeAndFormatCompatible(GrColorType ct,
const GrBackendFormat& format) const {
const VkFormat* vkFormat = format.getVkFormat();
const GrVkYcbcrConversionInfo* ycbcrInfo = format.getVkYcbcrConversionInfo();
@@ -1044,7 +1078,7 @@
GrPixelConfig GrVkCaps::getConfigFromBackendFormat(const GrBackendFormat& format,
- SkColorType ct) const {
+ GrColorType ct) const {
const VkFormat* vkFormat = format.getVkFormat();
const GrVkYcbcrConversionInfo* ycbcrInfo = format.getVkYcbcrConversionInfo();
if (!vkFormat || !ycbcrInfo) {
diff --git a/src/gpu/vk/GrVkCaps.h b/src/gpu/vk/GrVkCaps.h
index 38ee237..d3873c0 100644
--- a/src/gpu/vk/GrVkCaps.h
+++ b/src/gpu/vk/GrVkCaps.h
@@ -162,11 +162,11 @@
bool* rectsMustMatch, bool* disallowSubrect) const override;
GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
- SkColorType) const override;
+ GrColorType) const override;
- bool areColorTypeAndFormatCompatible(SkColorType, const GrBackendFormat&) const override;
+ bool areColorTypeAndFormatCompatible(GrColorType, const GrBackendFormat&) const override;
- GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, SkColorType) const override;
+ GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, GrColorType) const override;
GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat&) const override;
GrBackendFormat getBackendFormatFromGrColorType(GrColorType ct,