[graphite] Lift colortype to format choice out of backends

Adds a new PreferredFormatForColorType static function that takes an
SkColorType and removes the temporary `Caps::getFormatForColorType()`
function that took a color type and Renderable.

The PreferredFormatForColorType does not need to be filtered on
renderability. Instead, the Caps::getDefaultSampledTextureInfo() impl
filters the returned span by whether or not the WriteSwizzleForCT
function returns a non-empty swizzle. We could have the definition of
PreferredFormatForColorType have two separate tables, one for renderable
and one for non-renderable, which would make the
getDefaultSampledTextureInfo() function simpler but at the expense of
two nearly identical lookup tables.

The details of the PreferredFormatForColorType lookup table is the union
of all the different backend's setColorType() blocks from their format
table initialization.

The internal `Caps::getDefaultTextureInfo` function is updated to
iterate over a span of texture formats to automatically use the first
that is supported.

Bug: b/390473370
Change-Id: I554a1b6a09bbcc64d5bf732bc563e2cb8d0db286
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/1165836
Commit-Queue: Michael Ludwig <michaelludwig@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>

Author: lhkbob

src/gpu/graphite/Caps.cpp

@@ -10,6 +10,7 @@
 #include "include/gpu/ShaderErrorHandler.h"
 #include "include/gpu/graphite/ContextOptions.h"
 #include "include/gpu/graphite/TextureInfo.h"
+#include "include/private/base/SkTArray.h"
 #include "include/private/base/SkTo.h"
 #include "src/gpu/graphite/ContextOptionsPriv.h"
 #include "src/gpu/graphite/RenderPassDesc.h"
@@ -187,7 +188,7 @@ bool Caps::isRenderableWithMSRTSS(const TextureInfo& info) const {
 }
 
 TextureInfo Caps::getDefaultTextureInfo(SkEnumBitMask<TextureUsage> usage,
-                                        TextureFormat format,
+                                        SkSpan<const TextureFormat> formats,
                                         SampleCount sampleCount,
                                         Mipmapped mipmapped,
                                         Protected isProtected,
@@ -201,40 +202,45 @@ TextureInfo Caps::getDefaultTextureInfo(SkEnumBitMask<TextureUsage> usage,
         return {}; // Cannot handle protected content on this Context
     }
 
-    auto [supportedUsage, supportedSampleCounts] =
-            this->getTextureSupport(format, Tiling::kOptimal);
-    if ((supportedUsage & usage) != usage || !SkToBool(supportedSampleCounts & sampleCount)) {
-        return {}; // unsupported
-    }
+    for (TextureFormat format : formats) {
+        auto [supportedUsage, supportedSampleCounts] =
+                this->getTextureSupport(format, Tiling::kOptimal);
+        if ((supportedUsage & usage) != usage || !SkToBool(supportedSampleCounts & sampleCount)) {
+            continue; // unsupported, move on to the next possible format
+        }
 
-    if (SkToBool(usage & TextureUsage::kRender) &&
-        SkToBool(supportedUsage & TextureUsage::kMSRTSS) &&
-        sampleCount == SampleCount::k1) {
-        // Proactively prepare a single-sampled image for use with MSRTSS if it's supported by the
-        // format and kRender is requested. This flag is expected to be harmless (if not, it's a
-        // driver bug).
-        usage |= TextureUsage::kMSRTSS;
-    }
+        if (SkToBool(usage & TextureUsage::kRender) &&
+            SkToBool(supportedUsage & TextureUsage::kMSRTSS) &&
+            sampleCount == SampleCount::k1) {
+            // Proactivately prepare a single-sampled image for use with MSRTSS if it's supported by
+            // the format and kRender is requested. This flag is expected to be harmless (if not,
+            // it's a driver bug).
+            usage |= TextureUsage::kMSRTSS;
+        }
 
-    if (SkToBool(usage & TextureUsage::kCopyDst) &&
-        SkToBool(supportedUsage & TextureUsage::kHostCopy) &&
-        !SkToBool(usage & TextureUsage::kRender) &&
-        isProtected == Protected::kNo) {
-        // Proactively enable kHostCopy when supported by the format and kCopyDst is requested, so
-        // long as it's not going to be protected or rendered into. On every known driver where
-        // VK_EXT_host_image_copy is used by Skia, it's known that using the host-image-copy flag
-        // reduces the performance of renderable images.
-        usage |= TextureUsage::kHostCopy;
+        if (SkToBool(usage & TextureUsage::kCopyDst) &&
+            SkToBool(supportedUsage & TextureUsage::kHostCopy) &&
+            !SkToBool(usage & TextureUsage::kRender) &&
+            isProtected == Protected::kNo) {
+            // Proactively enable kHostCopy when supported by the format and kCopyDst is requested,
+            // so long as it's not going to be protected or rendered into. On every known driver
+            // where VK_EXT_host_image_copy is used by Skia, it's known that using the
+            // host-image-copy flag reduces the performance of renderable images.
+            usage |= TextureUsage::kHostCopy;
+        }
+        return this->onGetDefaultTextureInfo(usage, format, sampleCount, mipmapped,
+                                            isProtected, discardable);
     }
-    return this->onGetDefaultTextureInfo(usage, format, sampleCount, mipmapped,
-                                         isProtected, discardable);
+
+    // None of the possible formats were supported
+    return {};
 }
 
 TextureInfo Caps::getDefaultAttachmentTextureInfo(AttachmentDesc desc,
                                                   Protected isProtected,
                                                   Discardable discardable) const {
     return this->getDefaultTextureInfo(TextureUsage::kRender,
-                                       desc.fFormat,
+                                       SkSpan(&desc.fFormat, 1),
                                        desc.fSampleCount,
                                        Mipmapped::kNo,
                                        isProtected,
@@ -250,21 +256,32 @@ TextureInfo Caps::getDefaultSampledTextureInfo(SkColorType colorType,
                                                Protected isProtected,
                                                Renderable renderable) const {
     SkEnumBitMask<TextureUsage> usage = kDefaultSampledUsage;
+    SkSpan<const TextureFormat> formats = PreferredTextureFormats(colorType);
+    skia_private::STArray<3, TextureFormat> validFormats;
     if (renderable == Renderable::kYes) {
         usage |= TextureUsage::kRender;
+        // Any possible preferred format must also have a valid write swizzle for the requested
+        // color type.
+        for (TextureFormat f : formats) {
+            if (WriteSwizzleForColorType(colorType, f).has_value()) {
+                validFormats.push_back(f);
+            }
+        }
+        formats = validFormats;
     }
 
     return this->getDefaultTextureInfo(usage,
-                                       this->getFormatForColorType(colorType, renderable),
+                                       formats,
                                        SampleCount::k1,
                                        mipmapped,
                                        isProtected,
                                        Discardable::kNo);
 }
 
 TextureInfo Caps::getTextureInfoForSampledCopy(const TextureInfo& info, Mipmapped mipmapped) const {
+    const TextureFormat format = TextureInfoPriv::ViewFormat(info);
     return this->getDefaultTextureInfo(kDefaultSampledUsage,
-                                       TextureInfoPriv::ViewFormat(info),
+                                       SkSpan(&format, 1),
                                        SampleCount::k1,
                                        mipmapped,
                                        info.isProtected(),
@@ -275,8 +292,9 @@ TextureInfo Caps::getDefaultCompressedTextureInfo(SkTextureCompressionType compr
                                                   Mipmapped mipmapped,
                                                   Protected isProtected) const {
     // Remove CopySrc for compressed textures
+    const TextureFormat format = CompressionTypeToTextureFormat(compressionType);
     return this->getDefaultTextureInfo(kDefaultSampledUsage & ~TextureUsage::kCopySrc,
-                                       CompressionTypeToTextureFormat(compressionType),
+                                       SkSpan(&format, 1),
                                        SampleCount::k1,
                                        mipmapped,
                                        isProtected,
@@ -289,7 +307,7 @@ TextureInfo Caps::getDefaultStorageTextureInfo(SkColorType colorType) const {
     return this->getDefaultTextureInfo(TextureUsage::kStorage |
                                        TextureUsage::kSample |
                                        TextureUsage::kCopySrc,
-                                       this->getFormatForColorType(colorType, Renderable::kNo),
+                                       PreferredTextureFormats(colorType),
                                        SampleCount::k1,
                                        Mipmapped::kNo,
                                        Protected::kNo,

src/gpu/graphite/Caps.h

@@ -553,7 +553,15 @@ class Caps {
     // approach to textures and color types.
     const ColorTypeInfo* getColorTypeInfo(SkColorType, const TextureInfo&) const;
     virtual SkSpan<const ColorTypeInfo> getColorTypeInfos(const TextureInfo&) const = 0;
-    virtual TextureFormat getFormatForColorType(SkColorType, Renderable) const = 0;
+
+    // Validates format support and calls onGetDefaultTextureInfo if it would be valid, returning
+    // a TextureInfo for the first format that is supported.
+    TextureInfo getDefaultTextureInfo(SkEnumBitMask<TextureUsage> usage,
+                                      SkSpan<const TextureFormat>,
+                                      SampleCount,
+                                      Mipmapped,
+                                      Protected,
+                                      Discardable) const;
 
     // Return a TextureInfo that is configured to support the given usages with the requested format
     // and other properties. This is only called if getTextureSupport() matches for kOptimal tiling.
@@ -563,13 +571,6 @@ class Caps {
                                                 Mipmapped,
                                                 Protected,
                                                 Discardable) const = 0;
-    // Validates format support and calls onGetDefaultTextureInfo if it would be valid
-    TextureInfo getDefaultTextureInfo(SkEnumBitMask<TextureUsage> usage,
-                                      TextureFormat,
-                                      SampleCount,
-                                      Mipmapped,
-                                      Protected,
-                                      Discardable) const;
 
     // Return the supported TextureUsages and SampleCounts for a texture of the given format and
     // tiling, assuming the textures are created with the requisite usages.

src/gpu/graphite/Context.cpp

@@ -793,10 +793,18 @@ Context::PixelTransferResult Context::transferPixels(Recorder* recorder,
     // which may be different; dstColorInfo is what we have to transform it into when invoking the
     // async callbacks.
     SkColorInfo readColorInfo = srcColorInfo.makeColorType(supportedColorType);
-    if (readColorInfo != dstColorInfo || isRGB888Format) {
+    if (readColorInfo.alphaType() == kUnknown_SkAlphaType) {
+        readColorInfo = readColorInfo.makeAlphaType(kOpaque_SkAlphaType);
+    }
+    SkColorInfo outColorInfo = dstColorInfo;
+    if (outColorInfo.alphaType() == kUnknown_SkAlphaType) {
+        outColorInfo = outColorInfo.makeAlphaType(kOpaque_SkAlphaType);
+    }
+    if (readColorInfo != outColorInfo || isRGB888Format) {
         SkISize dims = srcRect.size();
         SkImageInfo srcInfo = SkImageInfo::Make(dims, readColorInfo);
-        SkImageInfo dstInfo = SkImageInfo::Make(dims, dstColorInfo);
+        SkImageInfo dstInfo = SkImageInfo::Make(dims, outColorInfo);
+
         result.fRowBytes = dstInfo.minRowBytes();
         result.fPixelConverter = [dstInfo, srcInfo, rowBytes, isRGB888Format](
                 void* dst, const void* src) {

src/gpu/graphite/TextureFormat.cpp

@@ -423,4 +423,57 @@ std::optional<skgpu::Swizzle> WriteSwizzleForColorType(SkColorType ct, TextureFo
     }
 }
 
+SkSpan<const TextureFormat> PreferredTextureFormats(SkColorType ct) {
+    #define N(...) std::size({__VA_ARGS__})
+    #define CASE(C, ...) case C: { \
+            static const std::array<TextureFormat, N(__VA_ARGS__)> kFormats{{__VA_ARGS__}}; \
+            return SkSpan(kFormats); }
+
+    switch (ct) {
+        case kUnknown_SkColorType:  return {};
+        // NOTE: Not all backends support all TextureFormats. Some of the more advanced formats
+        // may not be supported at all and have no viable fallback. For color types that have
+        // equivalent texture formats differing only in RGB vs. BGR swizzle, we allow both
+        // format variations to maximize color types that have some format. For alpha-only color
+        // types, we only match to red-channel formats as they have the broadest support.
+
+        CASE(kAlpha_8_SkColorType,            TextureFormat::kR8)
+        // NOTE: kRGB_565_SkColorType is misnamed and natively matches B5_G6_R5
+        CASE(kRGB_565_SkColorType,            TextureFormat::kB5_G6_R5, TextureFormat::kR5_G6_B5)
+        // NOTE: kARGB_4444_SkColorType is misnamed and natively matches ABGR4
+        CASE(kARGB_4444_SkColorType,          TextureFormat::kABGR4,    TextureFormat::kARGB4)
+        CASE(kRGBA_8888_SkColorType,          TextureFormat::kRGBA8,    TextureFormat::kBGRA8)
+        CASE(kRGB_888x_SkColorType,           TextureFormat::kRGB8,
+                                              TextureFormat::kRGBA8,
+                                              TextureFormat::kBGRA8)
+        CASE(kBGRA_8888_SkColorType,          TextureFormat::kBGRA8,    TextureFormat::kRGBA8)
+        CASE(kRGBA_1010102_SkColorType,       TextureFormat::kRGB10_A2, TextureFormat::kBGR10_A2)
+        CASE(kBGRA_1010102_SkColorType,       TextureFormat::kBGR10_A2, TextureFormat::kRGB10_A2)
+        CASE(kRGB_101010x_SkColorType,        TextureFormat::kRGB10_A2, TextureFormat::kBGR10_A2)
+        CASE(kBGR_101010x_SkColorType,        TextureFormat::kBGR10_A2, TextureFormat::kRGB10_A2)
+        CASE(kBGR_101010x_XR_SkColorType,     TextureFormat::kBGR10_XR)
+        CASE(kBGRA_10101010_XR_SkColorType,   TextureFormat::kBGRA10x6_XR)
+        CASE(kRGBA_10x6_SkColorType,          TextureFormat::kRGBA10x6)
+        CASE(kGray_8_SkColorType,             TextureFormat::kR8)
+        CASE(kRGBA_F16Norm_SkColorType,       TextureFormat::kRGBA16F)
+        CASE(kRGBA_F16_SkColorType,           TextureFormat::kRGBA16F)
+        CASE(kRGB_F16F16F16x_SkColorType,     TextureFormat::kRGBA16F)
+        CASE(kRGBA_F32_SkColorType,           TextureFormat::kRGBA32F)
+        CASE(kR8G8_unorm_SkColorType,         TextureFormat::kRG8)
+        CASE(kA16_float_SkColorType,          TextureFormat::kR16F)
+        CASE(kR16G16_float_SkColorType,       TextureFormat::kRG16F)
+        CASE(kA16_unorm_SkColorType,          TextureFormat::kR16)
+        CASE(kR16_unorm_SkColorType,          TextureFormat::kR16)
+        CASE(kR16G16_unorm_SkColorType,       TextureFormat::kRG16)
+        CASE(kR16G16B16A16_unorm_SkColorType, TextureFormat::kRGBA16)
+        CASE(kSRGBA_8888_SkColorType,         TextureFormat::kRGBA8_sRGB,
+                                              TextureFormat::kBGRA8_sRGB)
+        CASE(kR8_unorm_SkColorType,           TextureFormat::kR8)
+    }
+
+    SkUNREACHABLE;
+    #undef CASE
+    #undef N
+}
+
 } // namespace skgpu::graphite

src/gpu/graphite/TextureFormat.h

@@ -8,6 +8,7 @@
 #ifndef skgpu_graphite_TextureFormat_DEFINED
 #define skgpu_graphite_TextureFormat_DEFINED
 
+#include "include/core/SkSpan.h"
 #include "include/core/SkTextureCompressionType.h"
 #include "src/gpu/Swizzle.h"
 
@@ -17,6 +18,8 @@
 
 enum SkColorType : int;
 
+enum SkColorType : int;
+
 namespace skgpu::graphite {
 
 /**
@@ -172,6 +175,12 @@ Swizzle ReadSwizzleForColorType(SkColorType, TextureFormat);
 // and TextureInfo. If the returned optional is empty, it means the color type cannot be rendered to
 std::optional<Swizzle> WriteSwizzleForColorType(SkColorType, TextureFormat);
 
+// Formats are ordered from most preferred to least based on the policies described above in
+// TextureFormat. These must still be filtered by support for a given Caps. A TextureFormat that
+// can used with the provided SkColorType is not necessarily included in this list, e.g. we often
+// allow BGR vs RGB mismatches between CPU and GPU layouts if that's what the client provides.
+SkSpan<const TextureFormat> PreferredTextureFormats(SkColorType);
+
 } // namespace skgpu::graphite
 
 #endif // skgpu_graphite_TextureFormat_DEFINED