Refactored SkColorSpace and added in a Lab PCS GM

tools/flags/SkCommonFlagsConfig.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorSpace_Base.h"
 #include "SkCommonFlagsConfig.h"
 #include "SkImageInfo.h"
@@ skipping 115 matching lines @@
     "\t    Select framebuffer color format.\n"
     "\t    Options:\n"
     "\t\t8888\t\t\tLinear 8888.\n"
     "\t\tf16{_gamut}\t\tLinear 16-bit floating point.\n"
     "\t\tsrgb{_gamut}\t\tsRGB 8888.\n"
     "\t  gamut\ttype: string\tdefault: srgb.\n"
     "\t    Select color gamut for f16 or sRGB format buffers.\n"
     "\t    Options:\n"
     "\t\tsrgb\t\t\tsRGB gamut.\n"
     "\t\twide\t\t\tWide Gamut RGB.\n"
-    "\t\tnarrow\t\t\tNarrow Gamut RGB.\n"
     "\tdit\ttype: bool\tdefault: false.\n"
     "\t    Use device independent text.\n"
     "\tnvpr\ttype: bool\tdefault: false.\n"
     "\t    Use NV_path_rendering OpenGL and OpenGL ES extension.\n"
     "\tsamples\ttype: int\tdefault: 0.\n"
     "\t    Use multisampling with N samples.\n"
     "\n"
     "Predefined configs:\n\n"
     // Help text for pre-defined configs is auto-generated from gPredefinedConfigs
 #endif
@@ skipping 129 matching lines @@
         return true;
     }
 
     SkTArray<SkString> commands;
     SkStrSplit(value.c_str(), "_", &commands);
     if (commands.count() < 1 || commands.count() > 2) {
         return false;
     }
 
     // First, figure out color gamut that we'll work in (default to sRGB)
-    sk_sp<SkColorSpace> colorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
+    const bool linearGamma = commands[0].equals("f16");
+    *outColorSpace = SkColorSpace::NewNamed(linearGamma ? SkColorSpace::kSRGBLinear_Named
+                                                        : SkColorSpace::kSRGB_Named);
     if (commands.count() == 2) {
         if (commands[1].equals("srgb")) {
             // sRGB gamut (which is our default)
         } else if (commands[1].equals("wide")) {
             // WideGamut RGB
             const float gWideGamutRGB_toXYZD50[]{
                 0.7161046f, 0.1009296f, 0.1471858f,  // -> X
                 0.2581874f, 0.7249378f, 0.0168748f,  // -> Y
                 0.0000000f, 0.0517813f, 0.7734287f,  // -> Z
             };
             SkMatrix44 wideGamutRGBMatrix(SkMatrix44::kUninitialized_Constructor);
             wideGamutRGBMatrix.set3x3RowMajorf(gWideGamutRGB_toXYZD50);
-            colorSpace = SkColorSpace::NewRGB(SkColorSpace::kSRGB_RenderTargetGamma,
-                                              wideGamutRGBMatrix);
+            *outColorSpace = SkColorSpace::NewRGB(linearGamma
+                                                          ? SkColorSpace::kLinear_RenderTargetGamma
+                                                          : SkColorSpace::kSRGB_RenderTargetGamma,
+                                                  wideGamutRGBMatrix);
         } else if (commands[1].equals("narrow")) {
             // NarrowGamut RGB (an artifically smaller than sRGB gamut)
             SkColorSpacePrimaries primaries ={
                 0.54f, 0.33f,     // Rx, Ry
                 0.33f, 0.50f,     // Gx, Gy
                 0.25f, 0.20f,     // Bx, By
                 0.3127f, 0.3290f, // Wx, Wy
             };
             SkMatrix44 narrowGamutRGBMatrix(SkMatrix44::kUninitialized_Constructor);
             primaries.toXYZD50(&narrowGamutRGBMatrix);
-            colorSpace = SkColorSpace::NewRGB(SkColorSpace::kSRGB_RenderTargetGamma,
-                                              narrowGamutRGBMatrix);
+            *outColorSpace = SkColorSpace::NewRGB(linearGamma
+                                                          ? SkColorSpace::kLinear_RenderTargetGamma
+                                                          : SkColorSpace::kSRGB_RenderTargetGamma,
+                                                  narrowGamutRGBMatrix);
         } else {
             // Unknown color gamut
             return false;
         }
     }
 
     // Now pick a color type
     if (commands[0].equals("f16")) {
         *outColorType = kRGBA_F16_SkColorType;
-        *outColorSpace = as_CSB(colorSpace)->makeLinearGamma();
         return true;
     }
     if (commands[0].equals("srgb")) {
         *outColorType = kRGBA_8888_SkColorType;
-        *outColorSpace = colorSpace;
         return true;
     }
     return false;
 }
 
 SkCommandLineConfigGpu* parse_command_line_config_gpu(const SkString& tag,
                                                       const SkTArray<SkString>& vias,
                                                       const SkString& options) {
     // Defaults for GPU backend.
     bool seenAPI = false;
@@ skipping 97 matching lines @@
         if (extendedBackend.equals("gpu")) {
             parsedConfig = parse_command_line_config_gpu(tag, vias, extendedOptions);
         }
 #endif
         if (!parsedConfig) {
             parsedConfig = new SkCommandLineConfig(tag, simpleBackend, vias);
         }
         outResult->emplace_back(parsedConfig);
     }
 }