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>

3 files changed, 96 insertions, 86 deletions

diff --git a/tests/FloatingPointTextureTest.cpp b/tests/FloatingPointTextureTest.cpp
index fe0975d514..9a06d2dce3 100644
--- a/tests/FloatingPointTextureTest.cpp
+++ b/tests/FloatingPointTextureTest.cpp
@@ -25,8 +25,8 @@
 static const int DEV_W = 100, DEV_H = 100;
 
 template <typename T>
-void runFPTest(skiatest::Reporter* reporter, GrContext* context,
-               T min, T max, T epsilon, T maxInt, int arraySize, GrPixelConfig config) {
+void runFPTest(skiatest::Reporter* reporter, GrContext* context, T min, T max, T epsilon, T maxInt,
+               int arraySize, GrColorType colorType) {
     if (0 != arraySize % 4) {
         REPORT_FAILURE(reporter, "(0 != arraySize % 4)",
                        SkString("arraySize must be divisible by 4."));
@@ -51,7 +51,7 @@ void runFPTest(skiatest::Reporter* reporter, GrContext* context,
         desc.fOrigin = 0 == origin ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
         desc.fWidth = DEV_W;
         desc.fHeight = DEV_H;
-        desc.fConfig = config;
+        desc.fConfig = GrColorTypeToPixelConfig(colorType, GrSRGBEncoded::kNo);
 
         sk_sp<GrTextureProxy> fpProxy = proxyProvider->createTextureProxy(
                                            desc, SkBudgeted::kNo, controlPixelData.begin(), 0);
@@ -64,10 +64,8 @@ void runFPTest(skiatest::Reporter* reporter, GrContext* context,
                                                                             std::move(fpProxy));
         REPORTER_ASSERT(reporter, sContext);
 
-        bool result = context->contextPriv().readSurfacePixels(sContext.get(),
-                                                               0, 0, DEV_W, DEV_H,
-                                                               desc.fConfig, nullptr,
-                                                               readBuffer.begin(), 0);
+        bool result = context->contextPriv().readSurfacePixels(
+                sContext.get(), 0, 0, DEV_W, DEV_H, colorType, nullptr, readBuffer.begin(), 0);
         REPORTER_ASSERT(reporter, result);
         REPORTER_ASSERT(reporter,
                         0 == memcmp(readBuffer.begin(), controlPixelData.begin(), readBuffer.bytes()));
@@ -79,16 +77,16 @@ static const float kMaxIntegerRepresentableInSPFloatingPoint = 16777216;  // 2 ^
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(FloatingPointTextureTest, reporter, ctxInfo) {
     runFPTest<float>(reporter, ctxInfo.grContext(), FLT_MIN, FLT_MAX, FLT_EPSILON,
-                     kMaxIntegerRepresentableInSPFloatingPoint,
-                     RGBA32F_CONTROL_ARRAY_SIZE, kRGBA_float_GrPixelConfig);
+                     kMaxIntegerRepresentableInSPFloatingPoint, RGBA32F_CONTROL_ARRAY_SIZE,
+                     GrColorType::kRGBA_F32);
 }
 
 static const int RG32F_CONTROL_ARRAY_SIZE = DEV_W * DEV_H * 2;
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(FloatingPointTextureTest_RG, reporter, ctxInfo) {
     runFPTest<float>(reporter, ctxInfo.grContext(), FLT_MIN, FLT_MAX, FLT_EPSILON,
-                     kMaxIntegerRepresentableInSPFloatingPoint,
-                     RG32F_CONTROL_ARRAY_SIZE, kRG_float_GrPixelConfig);
+                     kMaxIntegerRepresentableInSPFloatingPoint, RG32F_CONTROL_ARRAY_SIZE,
+                     GrColorType::kRG_F32);
 }
 
 static const int HALF_ALPHA_CONTROL_ARRAY_SIZE = DEV_W * DEV_H * 1 /*alpha-only*/;
@@ -96,16 +94,16 @@ static const SkHalf kMaxIntegerRepresentableInHalfFloatingPoint = 0x6800;  // 2
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(HalfFloatAlphaTextureTest, reporter, ctxInfo) {
     runFPTest<SkHalf>(reporter, ctxInfo.grContext(), SK_HalfMin, SK_HalfMax, SK_HalfEpsilon,
-        kMaxIntegerRepresentableInHalfFloatingPoint,
-        HALF_ALPHA_CONTROL_ARRAY_SIZE, kAlpha_half_GrPixelConfig);
+                      kMaxIntegerRepresentableInHalfFloatingPoint, HALF_ALPHA_CONTROL_ARRAY_SIZE,
+                      GrColorType::kAlpha_F16);
 }
 
 static const int HALF_RGBA_CONTROL_ARRAY_SIZE = DEV_W * DEV_H * 4 /*RGBA*/;
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(HalfFloatRGBATextureTest, reporter, ctxInfo) {
     runFPTest<SkHalf>(reporter, ctxInfo.grContext(), SK_HalfMin, SK_HalfMax, SK_HalfEpsilon,
-        kMaxIntegerRepresentableInHalfFloatingPoint,
-        HALF_RGBA_CONTROL_ARRAY_SIZE, kRGBA_half_GrPixelConfig);
+                      kMaxIntegerRepresentableInHalfFloatingPoint, HALF_RGBA_CONTROL_ARRAY_SIZE,
+                      GrColorType::kRGBA_F16);
 }
 
 #endif
diff --git a/tests/SRGBReadWritePixelsTest.cpp b/tests/SRGBReadWritePixelsTest.cpp
index c9fd99662a..7ced2ebe97 100644
--- a/tests/SRGBReadWritePixelsTest.cpp
+++ b/tests/SRGBReadWritePixelsTest.cpp
@@ -289,10 +289,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SRGBReadWritePixels, reporter, ctxInfo) {
     // Write data to an untagged context. The write does no conversion no matter what encoding the
     // src data has.
     for (auto writeEncoding : {Encoding::kSRGB, Encoding::kUntagged, Encoding::kLinear}) {
-        // Currently this converts to sRGB when we read. TODO: Should reading from an untagged
-        // context to sRGB fail or do no conversion?
-        do_test(Encoding::kUntagged, writeEncoding, Encoding::kSRGB, error,
-                check_linear_to_srgb_conversion, context, reporter);
+        // The read from untagged to sRGB also does no conversion. TODO: Should it just fail?
+        do_test(Encoding::kUntagged, writeEncoding, Encoding::kSRGB, error, check_no_conversion,
+                context, reporter);
         // Reading untagged back as untagged should do no conversion.
         do_test(Encoding::kUntagged, writeEncoding, Encoding::kUntagged, error, check_no_conversion,
                 context, reporter);
diff --git a/tests/TransferPixelsTest.cpp b/tests/TransferPixelsTest.cpp
index 8f71528da6..1c82ede78a 100755
--- a/tests/TransferPixelsTest.cpp
+++ b/tests/TransferPixelsTest.cpp
@@ -62,7 +62,7 @@ bool does_full_buffer_contain_correct_values(GrColor* srcBuffer,
     return true;
 }
 
-void basic_transfer_test(skiatest::Reporter* reporter, GrContext* context, GrPixelConfig config,
+void basic_transfer_test(skiatest::Reporter* reporter, GrContext* context, GrColorType colorType,
                          GrSurfaceOrigin origin, bool renderTarget) {
     if (GrCaps::kNone_MapFlags == context->caps()->mapBufferFlags()) {
         return;
@@ -97,89 +97,102 @@ void basic_transfer_test(skiatest::Reporter* reporter, GrContext* context, GrPix
     memcpy(data, srcBuffer.get(), size);
     buffer->unmap();
 
-    // create texture
-    GrSurfaceDesc desc;
-    desc.fFlags = renderTarget ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags;
-    desc.fOrigin = origin;
-    desc.fWidth = kTextureWidth;
-    desc.fHeight = kTextureHeight;
-    desc.fConfig = config;
-    desc.fSampleCnt = 1;
-    sk_sp<GrTexture> tex = resourceProvider->createTexture(desc, SkBudgeted::kNo);
-
-    //////////////////////////
-    // transfer full data
-
-    bool result;
-    result = gpu->transferPixels(tex.get(), 0, 0, kTextureWidth, kTextureHeight,
-                                 config, buffer.get(), 0, rowBytes);
-    REPORTER_ASSERT(reporter, result);
-
-    memset(dstBuffer.get(), 0xCDCD, size);
-    result = gpu->readPixels(tex.get(), origin, 0, 0, kTextureWidth, kTextureHeight,
-                             config, dstBuffer.get(), rowBytes);
-    if (result) {
-        REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_values(srcBuffer,
-                                                                          dstBuffer,
-                                                                          kTextureWidth,
-                                                                          kTextureHeight,
-                                                                          kBufferWidth,
-                                                                          kBufferHeight,
-                                                                          origin));
-    }
-
-    //////////////////////////
-    // transfer partial data
+    for (auto srgbEncoding : {GrSRGBEncoded::kNo, GrSRGBEncoded::kYes}) {
+        // create texture
+        GrSurfaceDesc desc;
+        desc.fFlags = renderTarget ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags;
+        desc.fOrigin = origin;
+        desc.fWidth = kTextureWidth;
+        desc.fHeight = kTextureHeight;
+        desc.fConfig = GrColorTypeToPixelConfig(colorType, srgbEncoding);
+        desc.fSampleCnt = 1;
+
+        if (kUnknown_GrPixelConfig == desc.fConfig) {
+            SkASSERT(GrSRGBEncoded::kYes == srgbEncoding);
+            continue;
+        }
 
-    const int kLeft = 2;
-    const int kTop = 10;
-    const int kWidth = 10;
-    const int kHeight = 2;
+        if (!context->caps()->isConfigTexturable(desc.fConfig) ||
+            (renderTarget && !context->caps()->isConfigRenderable(desc.fConfig))) {
+            continue;
+        }
 
-    // change color of subrectangle
-    fill_transfer_data(kLeft, kTop, kWidth, kHeight, kBufferWidth, srcBuffer.get());
-    data = buffer->map();
-    memcpy(data, srcBuffer.get(), size);
-    buffer->unmap();
+        sk_sp<GrTexture> tex = resourceProvider->createTexture(desc, SkBudgeted::kNo);
+
+        //////////////////////////
+        // transfer full data
+
+        bool result;
+        result = gpu->transferPixels(tex.get(), 0, 0, kTextureWidth, kTextureHeight, colorType,
+                                     buffer.get(), 0, rowBytes);
+        REPORTER_ASSERT(reporter, result);
+
+        memset(dstBuffer.get(), 0xCDCD, size);
+        result = gpu->readPixels(tex.get(), origin, 0, 0, kTextureWidth, kTextureHeight, colorType,
+                                 dstBuffer.get(), rowBytes);
+        if (result) {
+            REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_values(srcBuffer,
+                                                                              dstBuffer,
+                                                                              kTextureWidth,
+                                                                              kTextureHeight,
+                                                                              kBufferWidth,
+                                                                              kBufferHeight,
+                                                                              origin));
+        }
 
-    size_t offset = sizeof(GrColor)*(kTop*kBufferWidth + kLeft);
-    result = gpu->transferPixels(tex.get(), kLeft, kTop, kWidth, kHeight, config,
-                                 buffer.get(), offset, rowBytes);
-    REPORTER_ASSERT(reporter, result);
-
-    memset(dstBuffer.get(), 0xCDCD, size);
-    result = gpu->readPixels(tex.get(), origin, 0, 0, kTextureWidth, kTextureHeight,
-                             config, dstBuffer.get(), rowBytes);
-    if (result) {
-        REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_values(srcBuffer,
-                                                                          dstBuffer,
-                                                                          kTextureWidth,
-                                                                          kTextureHeight,
-                                                                          kBufferWidth,
-                                                                          kBufferHeight,
-                                                                          origin));
+        //////////////////////////
+        // transfer partial data
+
+        const int kLeft = 2;
+        const int kTop = 10;
+        const int kWidth = 10;
+        const int kHeight = 2;
+
+        // change color of subrectangle
+        fill_transfer_data(kLeft, kTop, kWidth, kHeight, kBufferWidth, srcBuffer.get());
+        data = buffer->map();
+        memcpy(data, srcBuffer.get(), size);
+        buffer->unmap();
+
+        size_t offset = sizeof(GrColor) * (kTop * kBufferWidth + kLeft);
+        result = gpu->transferPixels(tex.get(), kLeft, kTop, kWidth, kHeight, colorType,
+                                     buffer.get(), offset, rowBytes);
+        REPORTER_ASSERT(reporter, result);
+
+        memset(dstBuffer.get(), 0xCDCD, size);
+        result = gpu->readPixels(tex.get(), origin, 0, 0, kTextureWidth, kTextureHeight, colorType,
+                                 dstBuffer.get(), rowBytes);
+        if (result) {
+            REPORTER_ASSERT(reporter, does_full_buffer_contain_correct_values(srcBuffer,
+                                                                              dstBuffer,
+                                                                              kTextureWidth,
+                                                                              kTextureHeight,
+                                                                              kBufferWidth,
+                                                                              kBufferHeight,
+                                                                              origin));
+        }
     }
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(TransferPixelsTest, reporter, ctxInfo) {
     // RGBA
-    basic_transfer_test(reporter, ctxInfo.grContext(), kRGBA_8888_GrPixelConfig,
+    basic_transfer_test(reporter, ctxInfo.grContext(), GrColorType::kRGBA_8888,
                         kTopLeft_GrSurfaceOrigin, false);
-    basic_transfer_test(reporter, ctxInfo.grContext(), kRGBA_8888_GrPixelConfig,
+    basic_transfer_test(reporter, ctxInfo.grContext(), GrColorType::kRGBA_8888,
                         kTopLeft_GrSurfaceOrigin, true);
-    basic_transfer_test(reporter, ctxInfo.grContext(), kRGBA_8888_GrPixelConfig,
+    basic_transfer_test(reporter, ctxInfo.grContext(), GrColorType::kRGBA_8888,
                         kBottomLeft_GrSurfaceOrigin, false);
-    basic_transfer_test(reporter, ctxInfo.grContext(), kRGBA_8888_GrPixelConfig,
+    basic_transfer_test(reporter, ctxInfo.grContext(), GrColorType::kRGBA_8888,
                         kBottomLeft_GrSurfaceOrigin, true);
 
     // BGRA
-    basic_transfer_test(reporter, ctxInfo.grContext(), kBGRA_8888_GrPixelConfig,
+    basic_transfer_test(reporter, ctxInfo.grContext(), GrColorType::kBGRA_8888,
                         kTopLeft_GrSurfaceOrigin, false);
-    basic_transfer_test(reporter, ctxInfo.grContext(), kBGRA_8888_GrPixelConfig,
+    basic_transfer_test(reporter, ctxInfo.grContext(), GrColorType::kBGRA_8888,
                         kTopLeft_GrSurfaceOrigin, true);
-    basic_transfer_test(reporter, ctxInfo.grContext(), kBGRA_8888_GrPixelConfig,
+    basic_transfer_test(reporter, ctxInfo.grContext(), GrColorType::kBGRA_8888,
                         kBottomLeft_GrSurfaceOrigin, false);
-    basic_transfer_test(reporter, ctxInfo.grContext(), kBGRA_8888_GrPixelConfig,
+    basic_transfer_test(reporter, ctxInfo.grContext(), GrColorType::kBGRA_8888,
                         kBottomLeft_GrSurfaceOrigin, true);
 }