Introduce GrColorType

This begins the journey towards using different types to refer to CPU data and GPU texture formats. This is one part of removing GrPixelConfig and more directly using GL/VK texture formats

GrColorType represents a particular layout of color/gray/alpha channels in CPU memory. It does not refer to texture formats or sRGB-encoding. It is basically SkColorType specialized to the GPU backend with some formats added and some removed.

Read/WritePixel interfaces use GrColorType to describe the CPU side of the transaction.

There's still a lot of punting to GrPixelConfig in API-specific code. There's a lot more to be done.

Bug: 6718
Bug: 7580

Change-Id: I8d813ae9a4416a06596f22a4b87da02091989718
Reviewed-on: https://skia-review.googlesource.com/107264
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>

1 files changed, 215 insertions, 32 deletions

diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index e35d1f5b56..1c28c400d0 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -9,9 +9,10 @@
 #define GrTypesPriv_DEFINED
 
 #include <chrono>
+#include "GrSharedEnums.h"
 #include "GrTypes.h"
+#include "SkImageInfo.h"
 #include "SkRefCnt.h"
-#include "GrSharedEnums.h"
 
 class GrCaps;
 
@@ -761,37 +762,6 @@ static constexpr GrPixelConfig kGray_8_as_Lum_GrPixelConfig = kPrivateConfig4_Gr
 static constexpr GrPixelConfig kGray_8_as_Red_GrPixelConfig = kPrivateConfig5_GrPixelConfig;
 
 /**
- * Utility functions for GrPixelConfig
- */
-// Returns true if the pixel config is 32 bits per pixel
-static inline bool GrPixelConfigIs8888Unorm(GrPixelConfig config) {
-    switch (config) {
-        case kRGBA_8888_GrPixelConfig:
-        case kBGRA_8888_GrPixelConfig:
-        case kSRGBA_8888_GrPixelConfig:
-        case kSBGRA_8888_GrPixelConfig:
-            return true;
-        case kUnknown_GrPixelConfig:
-        case kAlpha_8_GrPixelConfig:
-        case kAlpha_8_as_Alpha_GrPixelConfig:
-        case kAlpha_8_as_Red_GrPixelConfig:
-        case kGray_8_GrPixelConfig:
-        case kGray_8_as_Lum_GrPixelConfig:
-        case kGray_8_as_Red_GrPixelConfig:
-        case kRGB_565_GrPixelConfig:
-        case kRGBA_4444_GrPixelConfig:
-        case kRGBA_float_GrPixelConfig:
-        case kRG_float_GrPixelConfig:
-        case kAlpha_half_GrPixelConfig:
-        case kAlpha_half_as_Red_GrPixelConfig:
-        case kRGBA_half_GrPixelConfig:
-            return false;
-    }
-    SK_ABORT("Invalid pixel config");
-    return false;
-}
-
-/**
  * Refers to the encoding of a GPU buffer as it will be interpreted by the GPU when sampling and
  * blending.
  */
@@ -806,6 +776,10 @@ enum class GrSRGBConversion {
     kLinearToSRGB,
 };
 
+/**
+ * Utility functions for GrPixelConfig
+ */
+
 // Returns whether the config's color channels are sRGB encoded.
 static inline GrSRGBEncoded GrPixelConfigIsSRGBEncoded(GrPixelConfig config) {
     switch (config) {
@@ -1045,6 +1019,215 @@ static inline GrPixelConfigIsClamped GrGetPixelConfigIsClamped(GrPixelConfig con
                                                 : GrPixelConfigIsClamped::kYes;
 }
 
+/**
+ * Like SkColorType this describes a layout of pixel data in CPU memory. It specifies the channels,
+ * their type, and width. This exists so that the GPU backend can have private types that have no
+ * analog in the public facing SkColorType enum and omit types not implemented in the GPU backend.
+ * It does not refer to a texture format and the mapping to texture formats may be many-to-many.
+ * It does not specify the sRGB encding of the stored values.
+ */
+enum class GrColorType {
+    kUnknown,
+    kAlpha_8,
+    kRGB_565,
+    kABGR_4444,  // This name differs from SkColorType. kARGB_4444_SkColorType is misnamed.
+    kRGBA_8888,
+    kBGRA_8888,
+    kGray_8,
+    kAlpha_F16,
+    kRGBA_F16,
+    kRG_F32,
+    kRGBA_F32,
+};
+
+static inline SkColorType GrColorTypeToSkColorType(GrColorType ct) {
+    switch (ct) {
+        case GrColorType::kUnknown:   return kUnknown_SkColorType;
+        case GrColorType::kAlpha_8:   return kAlpha_8_SkColorType;
+        case GrColorType::kRGB_565:   return kRGB_565_SkColorType;
+        case GrColorType::kABGR_4444: return kARGB_4444_SkColorType;
+        case GrColorType::kRGBA_8888: return kRGBA_8888_SkColorType;
+        case GrColorType::kBGRA_8888: return kBGRA_8888_SkColorType;
+        case GrColorType::kGray_8:    return kGray_8_SkColorType;
+        case GrColorType::kAlpha_F16: return kUnknown_SkColorType;
+        case GrColorType::kRGBA_F16:  return kRGBA_F16_SkColorType;
+        case GrColorType::kRG_F32:    return kUnknown_SkColorType;
+        case GrColorType::kRGBA_F32:  return kUnknown_SkColorType;
+    }
+    SK_ABORT("Invalid GrColorType");
+    return kUnknown_SkColorType;
+}
+
+static inline GrColorType SkColorTypeToGrColorType(SkColorType ct) {
+    switch (ct) {
+        case kUnknown_SkColorType:      return GrColorType::kUnknown;
+        case kAlpha_8_SkColorType:      return GrColorType::kAlpha_8;
+        case kRGB_565_SkColorType:      return GrColorType::kRGB_565;
+        case kARGB_4444_SkColorType:    return GrColorType::kABGR_4444;
+        case kRGBA_8888_SkColorType:    return GrColorType::kRGBA_8888;
+        case kBGRA_8888_SkColorType:    return GrColorType::kBGRA_8888;
+        case kRGB_888x_SkColorType:     return GrColorType::kUnknown;
+        case kGray_8_SkColorType:       return GrColorType::kGray_8;
+        case kRGBA_F16_SkColorType:     return GrColorType::kRGBA_F16;
+        case kRGBA_1010102_SkColorType: return GrColorType::kUnknown;
+        case kRGB_101010x_SkColorType:  return GrColorType::kUnknown;
+    }
+    SK_ABORT("Invalid SkColorType");
+    return GrColorType::kUnknown;
+}
+
+static inline int GrColorTypeBytesPerPixel(GrColorType ct) {
+    switch (ct) {
+        case GrColorType::kUnknown:   return 0;
+        case GrColorType::kAlpha_8:   return 1;
+        case GrColorType::kRGB_565:   return 2;
+        case GrColorType::kABGR_4444: return 2;
+        case GrColorType::kRGBA_8888: return 4;
+        case GrColorType::kBGRA_8888: return 4;
+        case GrColorType::kGray_8:    return 1;
+        case GrColorType::kAlpha_F16: return 2;
+        case GrColorType::kRGBA_F16:  return 8;
+        case GrColorType::kRG_F32:    return 8;
+        case GrColorType::kRGBA_F32:  return 16;
+    }
+    SK_ABORT("Invalid GrColorType");
+    return 0;
+}
+
+static inline int GrColorTypeIsAlphaOnly(GrColorType ct) {
+    switch (ct) {
+        case GrColorType::kUnknown:   return false;
+        case GrColorType::kAlpha_8:   return true;
+        case GrColorType::kRGB_565:   return false;
+        case GrColorType::kABGR_4444: return false;
+        case GrColorType::kRGBA_8888: return false;
+        case GrColorType::kBGRA_8888: return false;
+        case GrColorType::kGray_8:    return false;
+        case GrColorType::kAlpha_F16: return true;
+        case GrColorType::kRGBA_F16:  return false;
+        case GrColorType::kRG_F32:    return false;
+        case GrColorType::kRGBA_F32:  return false;
+    }
+    SK_ABORT("Invalid GrColorType");
+    return false;
+}
+
+static inline GrColorType GrPixelConfigToColorTypeAndEncoding(GrPixelConfig config,
+                                                              GrSRGBEncoded* srgbEncoded) {
+    SkASSERT(srgbEncoded);
+    switch (config) {
+        case kUnknown_GrPixelConfig:
+            return GrColorType::kUnknown;
+        case kAlpha_8_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kAlpha_8;
+        case kGray_8_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kGray_8;
+        case kRGB_565_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kRGB_565;
+        case kRGBA_4444_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kABGR_4444;
+        case kRGBA_8888_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kRGBA_8888;
+        case kBGRA_8888_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kBGRA_8888;
+        case kSRGBA_8888_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kYes;
+            return GrColorType::kRGBA_8888;
+        case kSBGRA_8888_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kYes;
+            return GrColorType::kBGRA_8888;
+        case kRGBA_float_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kRGBA_F32;
+        case kRG_float_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kRG_F32;
+        case kAlpha_half_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kAlpha_F16;
+        case kRGBA_half_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kRGBA_F16;
+        case kAlpha_8_as_Alpha_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kAlpha_8;
+        case kAlpha_8_as_Red_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kAlpha_8;
+        case kAlpha_half_as_Red_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kAlpha_F16;
+        case kGray_8_as_Lum_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kGray_8;
+        case kGray_8_as_Red_GrPixelConfig:
+            *srgbEncoded = GrSRGBEncoded::kNo;
+            return GrColorType::kGray_8;
+    }
+    SK_ABORT("Invalid GrPixelConfig");
+    return GrColorType::kUnknown;
+}
+
+static inline GrColorType GrPixelConfigToColorType(GrPixelConfig config) {
+    GrSRGBEncoded bogusEncoded;
+    return GrPixelConfigToColorTypeAndEncoding(config, &bogusEncoded);
+}
+
+static inline GrPixelConfig GrColorTypeToPixelConfig(GrColorType config,
+                                                     GrSRGBEncoded srgbEncoded) {
+    switch (config) {
+        case GrColorType::kUnknown:
+            return kUnknown_GrPixelConfig;
+        case GrColorType::kAlpha_8:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig
+                                                        : kAlpha_8_GrPixelConfig;
+
+        case GrColorType::kGray_8:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig
+                                                        : kGray_8_GrPixelConfig;
+
+        case GrColorType::kRGB_565:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig
+                                                        : kRGB_565_GrPixelConfig;
+
+        case GrColorType::kABGR_4444:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig
+                                                        : kRGBA_4444_GrPixelConfig;
+
+        case GrColorType::kRGBA_8888:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kSRGBA_8888_GrPixelConfig
+                                                        : kRGBA_8888_GrPixelConfig;
+
+        case GrColorType::kBGRA_8888:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kSBGRA_8888_GrPixelConfig
+                                                        : kBGRA_8888_GrPixelConfig;
+
+        case GrColorType::kRGBA_F32:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig
+                                                        : kRGBA_float_GrPixelConfig;
+
+        case GrColorType::kRG_F32:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig
+                                                        : kRG_float_GrPixelConfig;
+
+        case GrColorType::kAlpha_F16:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig
+                                                        : kAlpha_half_GrPixelConfig;
+
+        case GrColorType::kRGBA_F16:
+            return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig
+                                                        : kRGBA_half_GrPixelConfig;
+    }
+    SK_ABORT("Invalid GrColorType");
+    return kUnknown_GrPixelConfig;
+}
+
 class GrReleaseProcHelper : public SkRefCnt {
 public:
     // These match the definitions in SkImage, from whence they came