Reduce the number of backend->pixelconfig GrCaps virtuals.
Moves method to get GrBackendFormat from GrBackendTexture from GrCaps
to GrBackendTexture so that a GrContext is not required.
Uses kUnknown_GrPixelConfig as failure return from GrCaps functions
rather than an GrPixelConfig* out param and bool result.
Having the texture type be part of GrBackendFormat made removing the
GrCaps function that goes from GrBackendRenderTarget to GrPixelConfig
awkward so that was left alone for now.
Change-Id: If9be0f898c538be4a7b24022b6011f63441a0317
Reviewed-on: https://skia-review.googlesource.com/c/175991
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
diff --git a/gn/gpu.gni b/gn/gpu.gni
index 81ac5a2..c857cdc 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -668,6 +668,7 @@
"$_src/gpu/mtl/GrMtlCaps.mm",
"$_src/gpu/mtl/GrMtlCopyManager.h",
"$_src/gpu/mtl/GrMtlCopyManager.mm",
+ "$_src/gpu/mtl/GrMtlCppUtil.h",
"$_src/gpu/mtl/GrMtlCopyPipelineState.h",
"$_src/gpu/mtl/GrMtlCopyPipelineState.mm",
"$_src/gpu/mtl/GrMtlGpu.h",
diff --git a/include/gpu/GrBackendSurface.h b/include/gpu/GrBackendSurface.h
index c72283e..28543c3 100644
--- a/include/gpu/GrBackendSurface.h
+++ b/include/gpu/GrBackendSurface.h
@@ -184,6 +184,9 @@
bool getMtlTextureInfo(GrMtlTextureInfo*) const;
#endif
+ // Get the GrBackendFormat for this texture (or an invalid format if this is not valid).
+ GrBackendFormat getBackendFormat() const;
+
// If the backend API is Mock, copies a snapshot of the GrMockTextureInfo struct into the passed
// in pointer and returns true. Otherwise returns false if the backend API is not Mock.
bool getMockTextureInfo(GrMockTextureInfo*) const;
diff --git a/src/gpu/GrAHardwareBufferImageGenerator.cpp b/src/gpu/GrAHardwareBufferImageGenerator.cpp
index 8b86721..faacd63 100644
--- a/src/gpu/GrAHardwareBufferImageGenerator.cpp
+++ b/src/gpu/GrAHardwareBufferImageGenerator.cpp
@@ -538,12 +538,13 @@
return nullptr;
}
- GrPixelConfig pixelConfig;
GrBackendFormat backendFormat = get_backend_format(context, fHardwareBuffer,
context->contextPriv().getBackend(),
fBufferFormat);
- if (!context->contextPriv().caps()->getConfigFromBackendFormat(
- backendFormat, this->getInfo().colorType(), &pixelConfig)) {
+ GrPixelConfig pixelConfig = context->contextPriv().caps()->getConfigFromBackendFormat(
+ backendFormat, this->getInfo().colorType());
+
+ if (pixelConfig == kUnknown_GrPixelConfig) {
return nullptr;
}
diff --git a/src/gpu/GrBackendSurface.cpp b/src/gpu/GrBackendSurface.cpp
index c512c0a..44b08b3 100644
--- a/src/gpu/GrBackendSurface.cpp
+++ b/src/gpu/GrBackendSurface.cpp
@@ -18,6 +18,7 @@
#endif
#ifdef SK_METAL
#include "mtl/GrMtlTypes.h"
+#include "mtl/GrMtlCppUtil.h"
#endif
GrBackendFormat::GrBackendFormat(GrGLenum format, GrGLenum target)
@@ -342,6 +343,37 @@
return false;
}
+GrBackendFormat GrBackendTexture::getBackendFormat() const {
+ if (!this->isValid()) {
+ return GrBackendFormat();
+ }
+ switch (fBackend) {
+ case GrBackendApi::kOpenGL:
+ return GrBackendFormat::MakeGL(fGLInfo.fFormat, fGLInfo.fTarget);
+#ifdef SK_VULKAN
+ case GrBackendApi::kVulkan: {
+ auto info = fVkInfo.snapImageInfo();
+ if (info.fYcbcrConversionInfo.isValid()) {
+ SkASSERT(info.fFormat == VK_FORMAT_UNDEFINED);
+ return GrBackendFormat::MakeVk(info.fYcbcrConversionInfo);
+ }
+ return GrBackendFormat::MakeVk(info.fFormat);
+ }
+#endif
+#ifdef SK_METAL
+ case GrBackendApi::kMetal: {
+ GrMtlTextureInfo mtlInfo;
+ SkAssertResult(this->getMtlTextureInfo(&mtlInfo));
+ return GrBackendFormat::MakeMtl(GrGetMTLPixelFormatFromMtlTextureInfo(mtlInfo));
+ }
+#endif
+ case GrBackendApi::kMock:
+ return GrBackendFormat::MakeMock(fMockInfo.fConfig);
+ default:
+ return GrBackendFormat();
+ }
+}
+
#if GR_TEST_UTILS
bool GrBackendTexture::TestingOnly_Equals(const GrBackendTexture& t0, const GrBackendTexture& t1) {
if (!t0.isValid() || !t1.isValid()) {
diff --git a/src/gpu/GrBackendTextureImageGenerator.cpp b/src/gpu/GrBackendTextureImageGenerator.cpp
index 1785823..f191174 100644
--- a/src/gpu/GrBackendTextureImageGenerator.cpp
+++ b/src/gpu/GrBackendTextureImageGenerator.cpp
@@ -43,8 +43,13 @@
context->contextPriv().getResourceCache()->insertCrossContextGpuResource(texture.get());
GrBackendTexture backendTexture = texture->getBackendTexture();
- if (!context->contextPriv().caps()->validateBackendTexture(backendTexture, colorType,
- &backendTexture.fConfig)) {
+ GrBackendFormat backendFormat = backendTexture.getBackendFormat();
+ if (!backendFormat.isValid()) {
+ return nullptr;
+ }
+ backendTexture.fConfig =
+ context->contextPriv().caps()->getConfigFromBackendFormat(backendFormat, colorType);
+ if (backendTexture.fConfig == kUnknown_GrPixelConfig) {
return nullptr;
}
@@ -133,8 +138,7 @@
GrBackendTexture backendTexture = fBackendTexture;
RefHelper* refHelper = fRefHelper;
- GrBackendFormat format =
- context->contextPriv().caps()->createFormatFromBackendTexture(backendTexture);
+ GrBackendFormat format = backendTexture.getBackendFormat();
SkASSERT(format.isValid());
sk_sp<GrTextureProxy> proxy = proxyProvider->createLazyProxy(
diff --git a/src/gpu/GrCaps.cpp b/src/gpu/GrCaps.cpp
index b1257bc..986ae20 100644
--- a/src/gpu/GrCaps.cpp
+++ b/src/gpu/GrCaps.cpp
@@ -292,11 +292,3 @@
GrBackendFormat GrCaps::getBackendFormatFromColorType(SkColorType ct) const {
return this->getBackendFormatFromGrColorType(SkColorTypeToGrColorType(ct), GrSRGBEncoded::kNo);
}
-
-GrBackendFormat GrCaps::createFormatFromBackendTexture(const GrBackendTexture& backendTex) const {
- if (!backendTex.isValid()) {
- return GrBackendFormat();
- }
- return this->onCreateFormatFromBackendTexture(backendTex);
-}
-
diff --git a/src/gpu/GrCaps.h b/src/gpu/GrCaps.h
index d9fc1af..0fee8cf 100644
--- a/src/gpu/GrCaps.h
+++ b/src/gpu/GrCaps.h
@@ -270,48 +270,31 @@
bool validateSurfaceDesc(const GrSurfaceDesc&, GrMipMapped) const;
/**
- * Returns true if the GrBackendTexture can be used with the supplied SkColorType. If it is
- * compatible, the passed in GrPixelConfig will be set to a config that matches the backend
- * format and requested SkColorType.
+ * If the GrBackendRenderTarget can be used with the supplied SkColorType the return will be
+ * the config that matches the backend format and requested SkColorType. Otherwise, kUnknown is
+ * returned.
*/
- virtual bool validateBackendTexture(const GrBackendTexture& tex, SkColorType ct,
- GrPixelConfig*) const = 0;
- virtual bool validateBackendRenderTarget(const GrBackendRenderTarget&, SkColorType,
- GrPixelConfig*) const = 0;
+ virtual GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
+ SkColorType) const = 0;
- // TODO: replace validateBackendTexture and validateBackendRenderTarget with calls to
- // getConfigFromBackendFormat?
+ // TODO: replace validateBackendRenderTarget with calls to getConfigFromBackendFormat?
// TODO: it seems like we could pass the full SkImageInfo and validate its colorSpace too
- virtual bool getConfigFromBackendFormat(const GrBackendFormat& format, SkColorType ct,
- GrPixelConfig*) const = 0;
+ // Returns kUnknown if a valid config could not be determined.
+ virtual GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat& format,
+ SkColorType ct) const = 0;
/**
- * Special method only for YUVA images. Returns true if the format can be used for a
- * YUVA plane, and the passed in GrPixelConfig will be set to a config that matches
- * the backend texture.
+ * Special method only for YUVA images. Returns a config that matches the backend format or
+ * kUnknown if a config could not be determined.
*/
- virtual bool getYUVAConfigFromBackendTexture(const GrBackendTexture& tex,
- GrPixelConfig*) const = 0;
+ virtual GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat& format) const = 0;
- /**
- * Special method only for YUVA images. Returns true if the format can be used for a
- * YUVA plane, and the passed in GrPixelConfig will be set to a config that matches
- * the backend format.
- */
- virtual bool getYUVAConfigFromBackendFormat(const GrBackendFormat& format,
- GrPixelConfig*) const = 0;
-
+ /** These are used when creating a new texture internally. */
virtual GrBackendFormat getBackendFormatFromGrColorType(GrColorType ct,
GrSRGBEncoded srgbEncoded) const = 0;
GrBackendFormat getBackendFormatFromColorType(SkColorType ct) const;
/**
- * Creates a GrBackendFormat which matches the backend texture. If the backend texture is
- * invalid, the function will return the default GrBackendFormat.
- */
- GrBackendFormat createFormatFromBackendTexture(const GrBackendTexture&) const;
-
- /**
* The CLAMP_TO_BORDER wrap mode for texture coordinates was added to desktop GL in 1.3, and
* GLES 3.2, but is also available in extensions. Vulkan and Metal always have support.
*/
@@ -325,12 +308,6 @@
expand them. */
void applyOptionsOverrides(const GrContextOptions& options);
- /**
- * Subclasses implement this to actually create a GrBackendFormat to match backend texture. At
- * this point, the backend texture has already been validated.
- */
- virtual GrBackendFormat onCreateFormatFromBackendTexture(const GrBackendTexture&) const = 0;
-
sk_sp<GrShaderCaps> fShaderCaps;
bool fNPOTTextureTileSupport : 1;
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index a9e1be1..ff386a3 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -204,8 +204,8 @@
isMipMapped = false;
}
- GrPixelConfig config = kUnknown_GrPixelConfig;
- if (!fCaps->getConfigFromBackendFormat(backendFormat, ii.colorType(), &config)) {
+ GrPixelConfig config = fCaps->getConfigFromBackendFormat(backendFormat, ii.colorType());
+ if (config == kUnknown_GrPixelConfig) {
return SkSurfaceCharacterization(); // return an invalid characterization
}
diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp
index 211ea13..a71549e 100644
--- a/src/gpu/gl/GrGLCaps.cpp
+++ b/src/gpu/gl/GrGLCaps.cpp
@@ -2871,163 +2871,132 @@
return count;
}
-bool validate_sized_format(GrGLenum format, SkColorType ct, GrPixelConfig* config,
- GrGLStandard standard) {
- *config = kUnknown_GrPixelConfig;
-
+GrPixelConfig validate_sized_format(GrGLenum format, SkColorType ct, GrGLStandard standard) {
switch (ct) {
case kUnknown_SkColorType:
- return false;
+ return kUnknown_GrPixelConfig;
case kAlpha_8_SkColorType:
if (GR_GL_ALPHA8 == format) {
- *config = kAlpha_8_as_Alpha_GrPixelConfig;
+ return kAlpha_8_as_Alpha_GrPixelConfig;
} else if (GR_GL_R8 == format) {
- *config = kAlpha_8_as_Red_GrPixelConfig;
+ return kAlpha_8_as_Red_GrPixelConfig;
}
break;
case kRGB_565_SkColorType:
if (GR_GL_RGB565 == format) {
- *config = kRGB_565_GrPixelConfig;
+ return kRGB_565_GrPixelConfig;
}
break;
case kARGB_4444_SkColorType:
if (GR_GL_RGBA4 == format) {
- *config = kRGBA_4444_GrPixelConfig;
+ return kRGBA_4444_GrPixelConfig;
}
break;
case kRGBA_8888_SkColorType:
if (GR_GL_RGBA8 == format) {
- *config = kRGBA_8888_GrPixelConfig;
+ return kRGBA_8888_GrPixelConfig;
} else if (GR_GL_SRGB8_ALPHA8 == format) {
- *config = kSRGBA_8888_GrPixelConfig;
+ return kSRGBA_8888_GrPixelConfig;
}
break;
case kRGB_888x_SkColorType:
if (GR_GL_RGB8 == format) {
- *config = kRGB_888_GrPixelConfig;
+ return kRGB_888_GrPixelConfig;
}
break;
case kBGRA_8888_SkColorType:
if (GR_GL_RGBA8 == format) {
if (kGL_GrGLStandard == standard) {
- *config = kBGRA_8888_GrPixelConfig;
+ return kBGRA_8888_GrPixelConfig;
}
} else if (GR_GL_BGRA8 == format) {
if (kGLES_GrGLStandard == standard) {
- *config = kBGRA_8888_GrPixelConfig;
+ return kBGRA_8888_GrPixelConfig;
}
} else if (GR_GL_SRGB8_ALPHA8 == format) {
- *config = kSBGRA_8888_GrPixelConfig;
+ return kSBGRA_8888_GrPixelConfig;
}
break;
case kRGBA_1010102_SkColorType:
if (GR_GL_RGB10_A2 == format) {
- *config = kRGBA_1010102_GrPixelConfig;
+ return kRGBA_1010102_GrPixelConfig;
}
break;
case kRGB_101010x_SkColorType:
- return false;
+ break;
case kGray_8_SkColorType:
if (GR_GL_LUMINANCE8 == format) {
- *config = kGray_8_as_Lum_GrPixelConfig;
+ return kGray_8_as_Lum_GrPixelConfig;
} else if (GR_GL_R8 == format) {
- *config = kGray_8_as_Red_GrPixelConfig;
+ return kGray_8_as_Red_GrPixelConfig;
}
break;
case kRGBA_F16_SkColorType:
if (GR_GL_RGBA16F == format) {
- *config = kRGBA_half_GrPixelConfig;
+ return kRGBA_half_GrPixelConfig;
}
break;
case kRGBA_F32_SkColorType:
if (GR_GL_RGBA32F == format) {
- *config = kRGBA_float_GrPixelConfig;
+ return kRGBA_float_GrPixelConfig;
}
break;
}
- return kUnknown_GrPixelConfig != *config;
+ return kUnknown_GrPixelConfig;
}
-bool GrGLCaps::validateBackendTexture(const GrBackendTexture& tex, SkColorType ct,
- GrPixelConfig* config) const {
- GrGLTextureInfo texInfo;
- if (!tex.getGLTextureInfo(&texInfo)) {
- return false;
- }
- return validate_sized_format(texInfo.fFormat, ct, config, fStandard);
-}
-
-bool GrGLCaps::validateBackendRenderTarget(const GrBackendRenderTarget& rt, SkColorType ct,
- GrPixelConfig* config) const {
+GrPixelConfig GrGLCaps::validateBackendRenderTarget(const GrBackendRenderTarget& rt,
+ SkColorType ct) const {
GrGLFramebufferInfo fbInfo;
if (!rt.getGLFramebufferInfo(&fbInfo)) {
- return false;
+ return kUnknown_GrPixelConfig;
}
- return validate_sized_format(fbInfo.fFormat, ct, config, fStandard);
+ return validate_sized_format(fbInfo.fFormat, ct, fStandard);
}
-bool GrGLCaps::getConfigFromBackendFormat(const GrBackendFormat& format, SkColorType ct,
- GrPixelConfig* config) const {
+GrPixelConfig GrGLCaps::getConfigFromBackendFormat(const GrBackendFormat& format,
+ SkColorType ct) const {
const GrGLenum* glFormat = format.getGLFormat();
if (!glFormat) {
- return false;
+ return kUnknown_GrPixelConfig;
}
- return validate_sized_format(*glFormat, ct, config, fStandard);
+ return validate_sized_format(*glFormat, ct, fStandard);
}
-static bool get_yuva_config(GrGLenum format, GrPixelConfig* config) {
- *config = kUnknown_GrPixelConfig;
+static GrPixelConfig get_yuva_config(GrGLenum format) {
+ GrPixelConfig config = kUnknown_GrPixelConfig;
switch (format) {
- case GR_GL_ALPHA8:
- *config = kAlpha_8_as_Alpha_GrPixelConfig;
- break;
- case GR_GL_R8:
- *config = kAlpha_8_as_Red_GrPixelConfig;
- break;
- case GR_GL_RG8:
- *config = kRG_88_GrPixelConfig;
- break;
- case GR_GL_RGBA8:
- *config = kRGBA_8888_GrPixelConfig;
- break;
- case GR_GL_RGB8:
- *config = kRGB_888_GrPixelConfig;
- break;
- case GR_GL_BGRA8:
- *config = kBGRA_8888_GrPixelConfig;
- break;
- default:
- return false;
+ case GR_GL_ALPHA8:
+ config = kAlpha_8_as_Alpha_GrPixelConfig;
+ break;
+ case GR_GL_R8:
+ config = kAlpha_8_as_Red_GrPixelConfig;
+ break;
+ case GR_GL_RG8:
+ config = kRG_88_GrPixelConfig;
+ break;
+ case GR_GL_RGBA8:
+ config = kRGBA_8888_GrPixelConfig;
+ break;
+ case GR_GL_RGB8:
+ config = kRGB_888_GrPixelConfig;
+ break;
+ case GR_GL_BGRA8:
+ config = kBGRA_8888_GrPixelConfig;
+ break;
}
- return true;
+ return config;
}
-bool GrGLCaps::getYUVAConfigFromBackendTexture(const GrBackendTexture& tex,
- GrPixelConfig* config) const {
- GrGLTextureInfo texInfo;
- if (!tex.getGLTextureInfo(&texInfo)) {
- return false;
- }
- return get_yuva_config(texInfo.fFormat, config);
-}
-
-bool GrGLCaps::getYUVAConfigFromBackendFormat(const GrBackendFormat& format,
- GrPixelConfig* config) const {
+GrPixelConfig GrGLCaps::getYUVAConfigFromBackendFormat(const GrBackendFormat& format) const {
const GrGLenum* glFormat = format.getGLFormat();
if (!glFormat) {
- return false;
+ return kUnknown_GrPixelConfig;
}
- return get_yuva_config(*glFormat, config);
-}
-
-GrBackendFormat GrGLCaps::onCreateFormatFromBackendTexture(
- const GrBackendTexture& backendTex) const {
- GrGLTextureInfo glInfo;
- SkAssertResult(backendTex.getGLTextureInfo(&glInfo));
- return GrBackendFormat::MakeGL(glInfo.fFormat, glInfo.fTarget);
+ return get_yuva_config(*glFormat);
}
GrBackendFormat GrGLCaps::getBackendFormatFromGrColorType(GrColorType ct,
diff --git a/src/gpu/gl/GrGLCaps.h b/src/gpu/gl/GrGLCaps.h
index 54dc126..a40f278 100644
--- a/src/gpu/gl/GrGLCaps.h
+++ b/src/gpu/gl/GrGLCaps.h
@@ -425,17 +425,11 @@
bool samplerObjectSupport() const { return fSamplerObjectSupport; }
- bool validateBackendTexture(const GrBackendTexture&, SkColorType,
- GrPixelConfig*) const override;
- bool validateBackendRenderTarget(const GrBackendRenderTarget&, SkColorType,
- GrPixelConfig*) const override;
+ GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
+ SkColorType) const override;
- bool getConfigFromBackendFormat(const GrBackendFormat&, SkColorType,
- GrPixelConfig*) const override;
- bool getYUVAConfigFromBackendTexture(const GrBackendTexture&,
- GrPixelConfig*) const override;
- bool getYUVAConfigFromBackendFormat(const GrBackendFormat&,
- GrPixelConfig*) const override;
+ GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, SkColorType) const override;
+ GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat&) const override;
GrBackendFormat getBackendFormatFromGrColorType(GrColorType ct,
GrSRGBEncoded srgbEncoded) const override;
@@ -465,8 +459,6 @@
void onApplyOptionsOverrides(const GrContextOptions& options) override;
- GrBackendFormat onCreateFormatFromBackendTexture(const GrBackendTexture&) const override;
-
bool onIsWindowRectanglesSupportedForRT(const GrBackendRenderTarget&) const override;
void initFSAASupport(const GrContextOptions& contextOptions, const GrGLContextInfo&,
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 9378c79..ca86895 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -4242,7 +4242,7 @@
SkColorType skColorType = GrColorTypeToSkColorType(colorType);
if (skColorType != kUnknown_SkColorType) {
SkASSERT(this->caps()->validateBackendRenderTarget(
- beRT, GrColorTypeToSkColorType(colorType), &config));
+ beRT, GrColorTypeToSkColorType(colorType)) != kUnknown_GrPixelConfig);
}
#endif
return beRT;
diff --git a/src/gpu/mock/GrMockCaps.h b/src/gpu/mock/GrMockCaps.h
index e940423..c58b9bb 100644
--- a/src/gpu/mock/GrMockCaps.h
+++ b/src/gpu/mock/GrMockCaps.h
@@ -73,51 +73,26 @@
return false;
}
- bool validateBackendTexture(const GrBackendTexture& tex, SkColorType,
- GrPixelConfig* config) const override {
- GrMockTextureInfo texInfo;
- if (!tex.getMockTextureInfo(&texInfo)) {
- return false;
- }
-
- *config = texInfo.fConfig;
- return true;
+ GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
+ SkColorType) const override {
+ return kUnknown_GrPixelConfig;
}
- bool validateBackendRenderTarget(const GrBackendRenderTarget& rt, SkColorType,
- GrPixelConfig*) const override {
- return false;
- }
-
- bool getConfigFromBackendFormat(const GrBackendFormat& format, SkColorType ct,
- GrPixelConfig* config) const override {
+ GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat& format,
+ SkColorType ct) const override {
const GrPixelConfig* mockFormat = format.getMockFormat();
if (!mockFormat) {
- return false;
+ return kUnknown_GrPixelConfig;
}
- *config = *mockFormat;
- return true;
+ return *mockFormat;
}
- bool getYUVAConfigFromBackendTexture(const GrBackendTexture& tex,
- GrPixelConfig* config) const override {
- GrMockTextureInfo texInfo;
- if (!tex.getMockTextureInfo(&texInfo)) {
- return false;
- }
-
- *config = texInfo.fConfig;
- return true;
- }
-
- bool getYUVAConfigFromBackendFormat(const GrBackendFormat& format,
- GrPixelConfig* config) const override {
+ GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat& format) const override {
const GrPixelConfig* mockFormat = format.getMockFormat();
if (!mockFormat) {
- return false;
+ return kUnknown_GrPixelConfig;
}
- *config = *mockFormat;
- return true;
+ return *mockFormat;
}
GrBackendFormat getBackendFormatFromGrColorType(GrColorType ct,
@@ -130,12 +105,6 @@
}
private:
- GrBackendFormat onCreateFormatFromBackendTexture(
- const GrBackendTexture& backendTex) const override {
- GrMockTextureInfo mockInfo;
- SkAssertResult(backendTex.getMockTextureInfo(&mockInfo));
- return GrBackendFormat::MakeMock(mockInfo.fConfig);
- }
bool onSurfaceSupportsWritePixels(const GrSurface*) const override { return true; }
bool onCanCopySurface(const GrSurfaceProxy* dst, const GrSurfaceProxy* src,
const SkIRect& srcRect, const SkIPoint& dstPoint) const override {
diff --git a/src/gpu/mtl/GrMtlCaps.h b/src/gpu/mtl/GrMtlCaps.h
index 9d7b86f..7822f60 100644
--- a/src/gpu/mtl/GrMtlCaps.h
+++ b/src/gpu/mtl/GrMtlCaps.h
@@ -62,28 +62,17 @@
return false;
}
- bool validateBackendTexture(const GrBackendTexture&, SkColorType,
- GrPixelConfig*) const override {
- return false;
- }
- bool validateBackendRenderTarget(const GrBackendRenderTarget&, SkColorType,
- GrPixelConfig*) const override {
- return false;
+ GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
+ SkColorType) const override {
+ return kUnknown_GrPixelConfig;
}
- bool getConfigFromBackendFormat(const GrBackendFormat&, SkColorType,
- GrPixelConfig*) const override {
- return false;
+ GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, SkColorType) const override {
+ return kUnknown_GrPixelConfig;
}
- bool getYUVAConfigFromBackendTexture(const GrBackendTexture&,
- GrPixelConfig*) const override {
- return false;
- }
-
- bool getYUVAConfigFromBackendFormat(const GrBackendFormat&,
- GrPixelConfig*) const override {
- return false;
+ GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat&) const override {
+ return kUnknown_GrPixelConfig;
}
GrBackendFormat getBackendFormatFromGrColorType(GrColorType ct,
@@ -101,8 +90,6 @@
void initGrCaps(const id<MTLDevice> device);
void initShaderCaps();
- GrBackendFormat onCreateFormatFromBackendTexture(const GrBackendTexture&) const override;
-
void initConfigTable();
bool onSurfaceSupportsWritePixels(const GrSurface*) const override { return true; }
diff --git a/src/gpu/mtl/GrMtlCaps.mm b/src/gpu/mtl/GrMtlCaps.mm
index a2c2109..2f56e6b 100644
--- a/src/gpu/mtl/GrMtlCaps.mm
+++ b/src/gpu/mtl/GrMtlCaps.mm
@@ -420,15 +420,6 @@
fPreferredStencilFormat = StencilFormat{ MTLPixelFormatStencil8, 8, 8, true };
}
-GrBackendFormat GrMtlCaps::onCreateFormatFromBackendTexture(
- const GrBackendTexture& backendTex) const {
- GrMtlTextureInfo mtlInfo;
- SkAssertResult(backendTex.getMtlTextureInfo(&mtlInfo));
- id<MTLTexture> mtlTexture = GrGetMTLTexture(mtlInfo.fTexture,
- GrWrapOwnership::kBorrow_GrWrapOwnership);
- return GrBackendFormat::MakeMtl(mtlTexture.pixelFormat);
-}
-
GrBackendFormat GrMtlCaps::getBackendFormatFromGrColorType(GrColorType ct,
GrSRGBEncoded srgbEncoded) const {
GrPixelConfig config = GrColorTypeToPixelConfig(ct, srgbEncoded);
diff --git a/src/gpu/mtl/GrMtlCppUtil.h b/src/gpu/mtl/GrMtlCppUtil.h
new file mode 100644
index 0000000..ed796fc
--- /dev/null
+++ b/src/gpu/mtl/GrMtlCppUtil.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrMtlCppUtil_DEFINED
+#define GrMtlCppUtil_DEFINED
+
+#include "mtl/GrMtlTypes.h"
+
+// Utilities that can be used from cpp files (rather than .mm).
+
+GrMTLPixelFormat GrGetMTLPixelFormatFromMtlTextureInfo(const GrMtlTextureInfo&);
+
+
+#endif
diff --git a/src/gpu/mtl/GrMtlUtil.mm b/src/gpu/mtl/GrMtlUtil.mm
index c897d07..6d80fbe 100644
--- a/src/gpu/mtl/GrMtlUtil.mm
+++ b/src/gpu/mtl/GrMtlUtil.mm
@@ -232,3 +232,13 @@
}
return mtlTexture;
}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// CPP Utils
+
+GrMTLPixelFormat GrGetMTLPixelFormatFromMtlTextureInfo(const GrMtlTextureInfo& info) {
+ id<MTLTexture> mtlTexture = GrGetMTLTexture(info.fTexture,
+ GrWrapOwnership::kBorrow_GrWrapOwnership);
+ return static_cast<GrMTLPixelFormat>(mtlTexture.pixelFormat);
+}
diff --git a/src/gpu/vk/GrVkCaps.cpp b/src/gpu/vk/GrVkCaps.cpp
index 8874e5d..21302fe 100644
--- a/src/gpu/vk/GrVkCaps.cpp
+++ b/src/gpu/vk/GrVkCaps.cpp
@@ -700,10 +700,7 @@
return true;
}
-bool validate_image_info(VkFormat format, SkColorType ct, GrPixelConfig* config,
- bool hasYcbcrConversion) {
- *config = kUnknown_GrPixelConfig;
-
+GrPixelConfig validate_image_info(VkFormat format, SkColorType 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.
@@ -711,167 +708,123 @@
// We don't actually care what the color type or config are since we won't use those
// values for external textures, but since our code requires setting a config here
// just default it to RGBA.
- *config = kRGBA_8888_GrPixelConfig;
- return true;
+ return kRGBA_8888_GrPixelConfig;
} else {
- return false;
+ return kUnknown_GrPixelConfig;
}
}
if (hasYcbcrConversion) {
// We only support having a ycbcr conversion for external images.
- return false;
+ return kUnknown_GrPixelConfig;
}
switch (ct) {
case kUnknown_SkColorType:
- return false;
+ break;
case kAlpha_8_SkColorType:
if (VK_FORMAT_R8_UNORM == format) {
- *config = kAlpha_8_as_Red_GrPixelConfig;
+ return kAlpha_8_as_Red_GrPixelConfig;
}
break;
case kRGB_565_SkColorType:
if (VK_FORMAT_R5G6B5_UNORM_PACK16 == format) {
- *config = kRGB_565_GrPixelConfig;
+ return kRGB_565_GrPixelConfig;
}
break;
case kARGB_4444_SkColorType:
if (VK_FORMAT_B4G4R4A4_UNORM_PACK16 == format) {
- *config = kRGBA_4444_GrPixelConfig;
+ return kRGBA_4444_GrPixelConfig;
}
break;
case kRGBA_8888_SkColorType:
if (VK_FORMAT_R8G8B8A8_UNORM == format) {
- *config = kRGBA_8888_GrPixelConfig;
+ return kRGBA_8888_GrPixelConfig;
} else if (VK_FORMAT_R8G8B8A8_SRGB == format) {
- *config = kSRGBA_8888_GrPixelConfig;
+ return kSRGBA_8888_GrPixelConfig;
}
break;
case kRGB_888x_SkColorType:
if (VK_FORMAT_R8G8B8_UNORM == format) {
- *config = kRGB_888_GrPixelConfig;
+ return kRGB_888_GrPixelConfig;
}
break;
case kBGRA_8888_SkColorType:
if (VK_FORMAT_B8G8R8A8_UNORM == format) {
- *config = kBGRA_8888_GrPixelConfig;
+ return kBGRA_8888_GrPixelConfig;
} else if (VK_FORMAT_B8G8R8A8_SRGB == format) {
- *config = kSBGRA_8888_GrPixelConfig;
+ return kSBGRA_8888_GrPixelConfig;
}
break;
case kRGBA_1010102_SkColorType:
if (VK_FORMAT_A2B10G10R10_UNORM_PACK32 == format) {
- *config = kRGBA_1010102_GrPixelConfig;
+ return kRGBA_1010102_GrPixelConfig;
}
break;
case kRGB_101010x_SkColorType:
- return false;
+ return kUnknown_GrPixelConfig;
case kGray_8_SkColorType:
if (VK_FORMAT_R8_UNORM == format) {
- *config = kGray_8_as_Red_GrPixelConfig;
+ return kGray_8_as_Red_GrPixelConfig;
}
break;
case kRGBA_F16_SkColorType:
if (VK_FORMAT_R16G16B16A16_SFLOAT == format) {
- *config = kRGBA_half_GrPixelConfig;
+ return kRGBA_half_GrPixelConfig;
}
break;
case kRGBA_F32_SkColorType:
if (VK_FORMAT_R32G32B32A32_SFLOAT == format) {
- *config = kRGBA_float_GrPixelConfig;
+ return kRGBA_float_GrPixelConfig;
}
break;
}
- return kUnknown_GrPixelConfig != *config;
+ return kUnknown_GrPixelConfig;
}
-bool GrVkCaps::validateBackendTexture(const GrBackendTexture& tex, SkColorType ct,
- GrPixelConfig* config) const {
- GrVkImageInfo imageInfo;
- if (!tex.getVkImageInfo(&imageInfo)) {
- return false;
- }
-
- return validate_image_info(imageInfo.fFormat, ct, config,
- imageInfo.fYcbcrConversionInfo.isValid());
-}
-
-bool GrVkCaps::validateBackendRenderTarget(const GrBackendRenderTarget& rt, SkColorType ct,
- GrPixelConfig* config) const {
+GrPixelConfig GrVkCaps::validateBackendRenderTarget(const GrBackendRenderTarget& rt,
+ SkColorType ct) const {
GrVkImageInfo imageInfo;
if (!rt.getVkImageInfo(&imageInfo)) {
- return false;
+ return kUnknown_GrPixelConfig;
}
-
- return validate_image_info(imageInfo.fFormat, ct, config,
- imageInfo.fYcbcrConversionInfo.isValid());
+ return validate_image_info(imageInfo.fFormat, ct, imageInfo.fYcbcrConversionInfo.isValid());
}
-bool GrVkCaps::getConfigFromBackendFormat(const GrBackendFormat& format, SkColorType ct,
- GrPixelConfig* config) const {
+GrPixelConfig GrVkCaps::getConfigFromBackendFormat(const GrBackendFormat& format,
+ SkColorType ct) const {
const VkFormat* vkFormat = format.getVkFormat();
const GrVkYcbcrConversionInfo* ycbcrInfo = format.getVkYcbcrConversionInfo();
if (!vkFormat || !ycbcrInfo) {
- return false;
+ return kUnknown_GrPixelConfig;
}
- return validate_image_info(*vkFormat, ct, config, ycbcrInfo->isValid());
+ return validate_image_info(*vkFormat, ct, ycbcrInfo->isValid());
}
-static bool get_yuva_config(VkFormat vkFormat, GrPixelConfig* config) {
- *config = kUnknown_GrPixelConfig;
-
+static GrPixelConfig get_yuva_config(VkFormat vkFormat) {
switch (vkFormat) {
- case VK_FORMAT_R8_UNORM:
- *config = kAlpha_8_as_Red_GrPixelConfig;
- break;
- case VK_FORMAT_R8G8B8A8_UNORM:
- *config = kRGBA_8888_GrPixelConfig;
- break;
- case VK_FORMAT_R8G8B8_UNORM:
- *config = kRGB_888_GrPixelConfig;
- break;
- case VK_FORMAT_R8G8_UNORM:
- *config = kRG_88_GrPixelConfig;
- break;
- case VK_FORMAT_B8G8R8A8_UNORM:
- *config = kBGRA_8888_GrPixelConfig;
- break;
- default:
- return false;
+ case VK_FORMAT_R8_UNORM:
+ return kAlpha_8_as_Red_GrPixelConfig;
+ case VK_FORMAT_R8G8B8A8_UNORM:
+ return kRGBA_8888_GrPixelConfig;
+ case VK_FORMAT_R8G8B8_UNORM:
+ return kRGB_888_GrPixelConfig;
+ case VK_FORMAT_R8G8_UNORM:
+ return kRG_88_GrPixelConfig;
+ case VK_FORMAT_B8G8R8A8_UNORM:
+ return kBGRA_8888_GrPixelConfig;
+ default:
+ return kUnknown_GrPixelConfig;
}
-
- return true;
}
-bool GrVkCaps::getYUVAConfigFromBackendTexture(const GrBackendTexture& tex,
- GrPixelConfig* config) const {
- GrVkImageInfo imageInfo;
- if (!tex.getVkImageInfo(&imageInfo)) {
- return false;
- }
- return get_yuva_config(imageInfo.fFormat, config);
-}
-
-bool GrVkCaps::getYUVAConfigFromBackendFormat(const GrBackendFormat& format,
- GrPixelConfig* config) const {
+GrPixelConfig GrVkCaps::getYUVAConfigFromBackendFormat(const GrBackendFormat& format) const {
const VkFormat* vkFormat = format.getVkFormat();
if (!vkFormat) {
- return false;
+ return kUnknown_GrPixelConfig;
}
- return get_yuva_config(*vkFormat, config);
-}
-
-GrBackendFormat GrVkCaps::onCreateFormatFromBackendTexture(
- const GrBackendTexture& backendTex) const {
- GrVkImageInfo vkInfo;
- SkAssertResult(backendTex.getVkImageInfo(&vkInfo));
- if (vkInfo.fYcbcrConversionInfo.isValid()) {
- SkASSERT(vkInfo.fFormat == VK_FORMAT_UNDEFINED);
- return GrBackendFormat::MakeVk(vkInfo.fYcbcrConversionInfo);
- }
- return GrBackendFormat::MakeVk(vkInfo.fFormat);
+ return get_yuva_config(*vkFormat);
}
GrBackendFormat GrVkCaps::getBackendFormatFromGrColorType(GrColorType ct,
diff --git a/src/gpu/vk/GrVkCaps.h b/src/gpu/vk/GrVkCaps.h
index e27e8d5..bb7ec48 100644
--- a/src/gpu/vk/GrVkCaps.h
+++ b/src/gpu/vk/GrVkCaps.h
@@ -146,17 +146,11 @@
bool initDescForDstCopy(const GrRenderTargetProxy* src, GrSurfaceDesc* desc, GrSurfaceOrigin*,
bool* rectsMustMatch, bool* disallowSubrect) const override;
- bool validateBackendTexture(const GrBackendTexture&, SkColorType,
- GrPixelConfig*) const override;
- bool validateBackendRenderTarget(const GrBackendRenderTarget&, SkColorType,
- GrPixelConfig*) const override;
+ GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
+ SkColorType) const override;
- bool getConfigFromBackendFormat(const GrBackendFormat&, SkColorType,
- GrPixelConfig*) const override;
- bool getYUVAConfigFromBackendTexture(const GrBackendTexture&,
- GrPixelConfig*) const override;
- bool getYUVAConfigFromBackendFormat(const GrBackendFormat&,
- GrPixelConfig*) const override;
+ GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat&, SkColorType) const override;
+ GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat&) const override;
GrBackendFormat getBackendFormatFromGrColorType(GrColorType ct,
GrSRGBEncoded srgbEncoded) const override;
@@ -181,8 +175,6 @@
const GrVkExtensions&);
void initShaderCaps(const VkPhysicalDeviceProperties&, const VkPhysicalDeviceFeatures2&);
- GrBackendFormat onCreateFormatFromBackendTexture(const GrBackendTexture&) const override;
-
void initConfigTable(const GrVkInterface*, VkPhysicalDevice, const VkPhysicalDeviceProperties&);
void initStencilFormat(const GrVkInterface* iface, VkPhysicalDevice physDev);
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index 6258e79..e49dc59 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -350,9 +350,9 @@
return nullptr;
}
- GrPixelConfig config = kUnknown_GrPixelConfig;
- if (!context->contextPriv().caps()->getConfigFromBackendFormat(backendFormat, colorType,
- &config)) {
+ GrPixelConfig config =
+ context->contextPriv().caps()->getConfigFromBackendFormat(backendFormat, colorType);
+ if (config == kUnknown_GrPixelConfig) {
return nullptr;
}
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index 3bd42cf..033b778 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -42,8 +42,12 @@
if (!SkImageInfoIsValid(info)) {
return false;
}
-
- return ctx->contextPriv().caps()->validateBackendTexture(tex, ct, config);
+ GrBackendFormat backendFormat = tex.getBackendFormat();
+ if (!backendFormat.isValid()) {
+ return false;
+ }
+ *config = ctx->contextPriv().caps()->getConfigFromBackendFormat(backendFormat, ct);
+ return *config != kUnknown_GrPixelConfig;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
@@ -312,9 +316,13 @@
GrBackendTexture yuvaTexturesCopy[4];
for (int textureIndex = 0; textureIndex < numTextures; ++textureIndex) {
yuvaTexturesCopy[textureIndex] = yuvaTextures[textureIndex];
- if (!ctx->contextPriv().caps()->getYUVAConfigFromBackendTexture(
- yuvaTexturesCopy[textureIndex],
- &yuvaTexturesCopy[textureIndex].fConfig)) {
+ GrBackendFormat backendFormat = yuvaTexturesCopy[textureIndex].getBackendFormat();
+ if (!backendFormat.isValid()) {
+ return false;
+ }
+ yuvaTexturesCopy[textureIndex].fConfig =
+ ctx->contextPriv().caps()->getYUVAConfigFromBackendFormat(backendFormat);
+ if (yuvaTexturesCopy[textureIndex].fConfig == kUnknown_GrPixelConfig) {
return false;
}
SkASSERT(yuvaTexturesCopy[textureIndex].isValid());
@@ -390,6 +398,7 @@
SkASSERT(context);
SkASSERT(width > 0 && height > 0);
SkASSERT(doneProc);
+ SkASSERT(config != kUnknown_GrPixelConfig);
if (!fulfillProc || !releaseProc) {
doneProc(textureContext);
diff --git a/src/image/SkImage_GpuYUVA.cpp b/src/image/SkImage_GpuYUVA.cpp
index 34bb2c2..74edded 100644
--- a/src/image/SkImage_GpuYUVA.cpp
+++ b/src/image/SkImage_GpuYUVA.cpp
@@ -274,10 +274,9 @@
// Get lazy proxies
sk_sp<GrTextureProxy> proxies[4];
for (int texIdx = 0; texIdx < numTextures; ++texIdx) {
- GrPixelConfig config;
- bool res = context->contextPriv().caps()->getYUVAConfigFromBackendFormat(
- yuvaFormats[texIdx], &config);
- if (!res) {
+ GrPixelConfig config =
+ context->contextPriv().caps()->getYUVAConfigFromBackendFormat(yuvaFormats[texIdx]);
+ if (config == kUnknown_GrPixelConfig) {
return nullptr;
}
proxies[texIdx] = MakePromiseImageLazyProxy(
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index 41f36a8..daa0684 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -393,7 +393,12 @@
return false;
}
- if (!ctx->contextPriv().caps()->validateBackendTexture(tex, ct, config)) {
+ GrBackendFormat backendFormat = tex.getBackendFormat();
+ if (!backendFormat.isValid()) {
+ return false;
+ }
+ *config = ctx->contextPriv().caps()->getConfigFromBackendFormat(backendFormat, ct);
+ if (*config == kUnknown_GrPixelConfig) {
return false;
}
@@ -461,7 +466,8 @@
return false;
}
- if (!ctx->contextPriv().caps()->validateBackendRenderTarget(rt, ct, config)) {
+ *config = ctx->contextPriv().caps()->validateBackendRenderTarget(rt, ct);
+ if (*config == kUnknown_GrPixelConfig) {
return false;
}
diff --git a/tests/PromiseImageTest.cpp b/tests/PromiseImageTest.cpp
index 2a43458..7224461 100644
--- a/tests/PromiseImageTest.cpp
+++ b/tests/PromiseImageTest.cpp
@@ -104,7 +104,7 @@
nullptr, kWidth, kHeight, GrColorType::kRGBA_8888, true, GrMipMapped::kNo);
REPORTER_ASSERT(reporter, backendTex.isValid());
- GrBackendFormat backendFormat = gpu->caps()->createFormatFromBackendTexture(backendTex);
+ GrBackendFormat backendFormat = backendTex.getBackendFormat();
REPORTER_ASSERT(reporter, backendFormat.isValid());
PromiseTextureChecker promiseChecker(backendTex);
diff --git a/tools/DDLPromiseImageHelper.cpp b/tools/DDLPromiseImageHelper.cpp
index fcda20e..2586835 100644
--- a/tools/DDLPromiseImageHelper.cpp
+++ b/tools/DDLPromiseImageHelper.cpp
@@ -24,10 +24,6 @@
}
}
-const GrCaps* DDLPromiseImageHelper::PromiseImageCallbackContext::caps() const {
- return fContext->contextPriv().caps();
-}
-
///////////////////////////////////////////////////////////////////////////////////////////////////
DDLPromiseImageHelper::~DDLPromiseImageHelper() {}
@@ -179,8 +175,6 @@
}
SkASSERT(curImage.index() == *indexPtr);
- const GrCaps* caps = curImage.caps();
-
sk_sp<SkImage> image;
if (curImage.isYUV()) {
GrBackendFormat backendFormats[SkYUVASizeInfo::kMaxCount];
@@ -191,8 +185,8 @@
SkAssertResult(SkYUVAIndex::AreValidIndices(curImage.yuvaIndices(), &textureCount));
for (int i = 0; i < textureCount; ++i) {
const GrBackendTexture& backendTex = curImage.backendTexture(i);
- backendFormats[i] = caps->createFormatFromBackendTexture(backendTex);
-
+ backendFormats[i] = backendTex.getBackendFormat();
+ SkASSERT(backendFormats[i].isValid());
contexts[i] = curImage.refCallbackContext(i).release();
sizes[i].set(curImage.yuvPixmap(i).width(), curImage.yuvPixmap(i).height());
}
@@ -215,7 +209,8 @@
} else {
const GrBackendTexture& backendTex = curImage.backendTexture(0);
- GrBackendFormat backendFormat = caps->createFormatFromBackendTexture(backendTex);
+ GrBackendFormat backendFormat = backendTex.getBackendFormat();
+ SkASSERT(backendFormat.isValid());
// Each DDL recorder gets its own ref on the promise callback context for the
// promise images it creates.
diff --git a/tools/DDLPromiseImageHelper.h b/tools/DDLPromiseImageHelper.h
index 583f3fd..7a636ce 100644
--- a/tools/DDLPromiseImageHelper.h
+++ b/tools/DDLPromiseImageHelper.h
@@ -83,8 +83,6 @@
const GrBackendTexture& backendTexture() const { return fBackendTexture; }
- const GrCaps* caps() const;
-
private:
GrContext* fContext;
GrBackendTexture fBackendTexture;
@@ -145,8 +143,6 @@
return fCallbackContexts[index];
}
- const GrCaps* caps() const { return fCallbackContexts[0]->caps(); }
-
const GrBackendTexture& backendTexture(int index) const {
SkASSERT(index >= 0 && index < (this->isYUV() ? SkYUVASizeInfo::kMaxCount : 1));
return fCallbackContexts[index]->backendTexture();
