Add ability to pick a different gamut in GPU f16 or sRGB configs

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 "SkCommonFlagsConfig.h"
 #include "SkImageInfo.h"
 
@@ skipping 10 matching lines @@
     " angle"
 #endif
 #endif
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     " hwui"
 #endif
     ;
 
 static const char configHelp[] =
     "Options: 565 8888 debug gpu gl gpudebug gpudft gpunull "
-    "msaa16 msaa4 glmsaa4 gpuf16 gpusrgb glsrgb nonrendering null nullgpu "
-    "nvpr16 nvpr4 nvprdit16 nvprdit4 glnvpr4 glnvprdit4 pdf skp svg xps"
+    "msaa16 msaa4 glmsaa4 gpuf16 gpusrgb gpuwide glsrgb nonrendering null nullgpu "
+    "nvpr16 nvpr4 nvprdit16 nvprdit4 glnvpr4 glnvprdit4 pdf skp svg xps "
     "glinst glinst4 glinstdit4 glinst16 glinstdit16 esinst esinst4 esinsdit4"
 #if SK_ANGLE
 #ifdef SK_BUILD_FOR_WIN
     " angle"
 #endif
     " angle-gl"
 #endif
 #if SK_COMMAND_BUFFER
     " commandbuffer"
 #endif
@@ skipping 34 matching lines @@
 #if SK_MESA
     "\t\tmesa\t\t\tUse MESA.\n"
 #endif
 #ifdef SK_VULKAN
     "\t\tvulkan\t\t\tUse Vulkan.\n"
 #endif
     "\tcolor\ttype: string\tdefault: 8888.\n"
     "\t    Select framebuffer color format.\n"
     "\t    Options:\n"
     "\t\t8888\t\t\tLinear 8888.\n"
-    "\t\tf16 \t\t\tLinear 16-bit floating point.\n"
-    "\t\tsrgb\t\t\tsRGB 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"
     "\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"
     "\tgpu       \t= gpu()\n"
     "\tgl        \t= gpu(api=gl)\n"
     "\tmsaa4     \t= gpu(samples=4)\n"
     "\tglmsaa4   \t= gpu(api=gl,samples=4)\n"
     "\tmsaa16    \t= gpu(samples=16)\n"
     "\tnvpr4     \t= gpu(nvpr=true,samples=4)\n"
     "\tglnvpr4   \t= gpu(api=gl,nvpr=true,samples=4)\n"
     "\tnvpr16    \t= gpu(nvpr=true,samples=16)\n"
     "\tnvprdit4  \t= gpu(nvpr=true,samples=4,dit=true)\n"
     "\tglnvprdit4\t= gpu(api=gl,nvpr=true,samples=4,dit=true)\n"
     "\tnvprdit16 \t= gpu(nvpr=true,samples=16,dit=true)\n"
     "\tgpuf16    \t= gpu(color=f16)\n"
     "\tgpusrgb   \t= gpu(color=srgb)\n"
+    "\tgpuwide   \t= gpu(color=f16_wide)\n"
     "\tglsrgb    \t= gpu(api=gl,color=srgb)\n"
     "\tgpudft    \t= gpu(dit=true)\n"
     "\tgpudebug  \t= gpu(api=debug)\n"
     "\tgpunull   \t= gpu(api=null)\n"
     "\tdebug     \t= gpu(api=debug)\n"
     "\tnullgpu   \t= gpu(api=null)\n"
 #if SK_ANGLE
 #ifdef SK_BUILD_FOR_WIN
     "\tangle     \t= gpu(api=angle)\n"
 #endif
@@ skipping 36 matching lines @@
     { "glinst",      "gpu", "api=gl,inst=true" },
     { "glinst4",     "gpu", "api=gl,inst=true,samples=4" },
     { "glinstdit4",  "gpu", "api=gl,inst=true,samples=4,dit=true" },
     { "glinst16",    "gpu", "api=gl,inst=true,samples=16" },
     { "glinstdit16", "gpu", "api=gl,inst=true,samples=16,dit=true" },
     { "esinst",      "gpu", "api=gles,inst=true" },
     { "esinst4",     "gpu", "api=gles,inst=true,samples=4" },
     { "esinstdit4",  "gpu", "api=gles,inst=true,samples=4,dit=true" },
     { "gpuf16",      "gpu", "color=f16" },
     { "gpusrgb",     "gpu", "color=srgb" },
+    { "gpuwide",     "gpu", "color=f16_wide" },
     { "glsrgb",      "gpu", "api=gl,color=srgb" },
     { "gpudft",      "gpu", "dit=true" },
     { "gpudebug",    "gpu", "api=debug" },
     { "gpunull",     "gpu", "api=null" },
     { "debug",       "gpu", "api=debug" },
     { "nullgpu",     "gpu", "api=null" }
 #if SK_ANGLE
 #ifdef SK_BUILD_FOR_WIN
     , { "angle",      "gpu", "api=angle" }
 #endif
@@ skipping 122 matching lines @@
     return false;
 }
 static bool parse_option_gpu_color(const SkString& value,
                                    SkColorType* outColorType,
                                    sk_sp<SkColorSpace>* outColorSpace) {
     if (value.equals("8888")) {
         *outColorType = kN32_SkColorType;
         *outColorSpace = nullptr;
         return true;
     }
-    if (value.equals("f16")) {
+
+    SkTArray<SkString> commands;
+    SkStrSplit(value.c_str(), "_", &commands);

[Brian Osman, 2016/09/19 19:39:19]

I realize this is unfortunate (introducing a new meta-option with sub-parsing).
It would clearly be better to start decoupling this (even adding a top-level
option to DM). But given the current architecture, this seemed like the easiest
approach.

+    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);
+    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);
+        } else {
+            // Unknown color gamut
+            return false;
+        }
+    }
+
+    // Now pick a color type
+    if (commands[0].equals("f16")) {
         *outColorType = kRGBA_F16_SkColorType;
-        *outColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named)->makeLinearGamma();
+        *outColorSpace = colorSpace->makeLinearGamma();
         return true;
     }
-    if (value.equals("srgb")) {
+    if (commands[0].equals("srgb")) {
         *outColorType = kN32_SkColorType;
-        *outColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
+        *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 104 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);
     }
 }