Implement color-gamut media query

third_party/WebKit/Source/platform/graphics/ColorSpace.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 15 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/graphics/ColorSpace.h"
 
 #include "platform/graphics/skia/SkiaUtils.h"
+#include "public/platform/WebScreenInfo.h"
+#include "third_party/skia/include/core/SkColorSpaceXform.h"
 #include "third_party/skia/include/effects/SkTableColorFilter.h"
 #include "wtf/MathExtras.h"
 #include <algorithm>
 
 namespace blink {
 
 namespace ColorSpaceUtilities {
 
 static const uint8_t* getLinearRgbLUT() {
   static uint8_t linearRgbLUT[256];
@@ skipping 63 matching lines @@
 
 sk_sp<SkColorFilter> createColorSpaceFilter(ColorSpace srcColorSpace,
                                             ColorSpace dstColorSpace) {
   const uint8_t* lookupTable = getConversionLUT(dstColorSpace, srcColorSpace);
   if (!lookupTable)
     return nullptr;
 
   return SkTableColorFilter::MakeARGB(0, lookupTable, lookupTable, lookupTable);
 }
 
+ColorSpaceGamut getColorSpaceGamut(const WebScreenInfo& screenInfo) {
+  const gfx::ICCProfile& profile = screenInfo.iccProfile;
+  if (profile == gfx::ICCProfile())
+    return ColorSpaceGamut::Unknown;
+
+  return ColorSpaceUtilities::getColorSpaceGamut(
+      profile.GetColorSpace().ToSkColorSpace().get());
+}
+
+ColorSpaceGamut getColorSpaceGamut(SkColorSpace* colorSpace) {

[Noel Gordon, 2017/01/31 02:29:57]

The color profile media spec does not say how to compute the color space gamut. 
How do we achieve compat while that is so?

+  sk_sp<SkColorSpace> scRGB(
+      SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named));
+  std::unique_ptr<SkColorSpaceXform> transform(
+      SkColorSpaceXform::New(colorSpace, scRGB.get()));
+
+  if (!transform)
+    return ColorSpaceGamut::Unknown;
+
+  unsigned char in[3][4];
+  float out[3][4];
+  memset(in, 0, sizeof(in));
+  in[0][0] = 255;
+  in[1][1] = 255;
+  in[2][2] = 255;
+  in[0][3] = 255;
+  in[1][3] = 255;
+  in[2][3] = 255;
+  transform->apply(SkColorSpaceXform::kRGBA_F32_ColorFormat, out,
+                   SkColorSpaceXform::kRGBA_8888_ColorFormat, in, 3,
+                   kOpaque_SkAlphaType);
+  float score = out[0][0] * out[1][1] * out[2][2];

[Noel Gordon, 2017/01/31 02:29:57]

Aside: by the looks, this appears to compute a score from the principle diagnol
of the tristimulus matrix.   That is a poor measure of gamut area for profiles
having strong off-diagnol elements.  I expect that this score will produces
outliers, in that it will classify some wide gamut profiles as not being wide
gamut [1].

[1] And again for browser compat, this is the reason why the media color profile
spec needs to specify how to compute the gamut area.

[hubbe, 2017/01/31 04:06:20]

While I agree that this is a hacky method, I do think it is good enough to
work[1]. The matrix is in the sRGB coordinate space, so if the primaries are
more or less "red, green and blue" they will be roughly parallel with the sRGB
primaries. While other primaries are theoretically possible, we do not currently
support non-RGB colorspaces.

If we want a better method, we'll probably want to measure triangle overlap in
XYZ or CIELAB space...

[1] but not good enough to be standardized.

+
+  if (score < 0.9)
+    return ColorSpaceGamut::LessThanNTSC;
+  if (score < 0.95)
+    return ColorSpaceGamut::NTSC;  // actual score 0.912839
+  if (score < 1.1)
+    return ColorSpaceGamut::SRGB;  // actual score 1.0
+  if (score < 1.3)
+    return ColorSpaceGamut::AlmostP3;
+  if (score < 1.425)
+    return ColorSpaceGamut::P3;  // actual score 1.401899
+  if (score < 1.5)
+    return ColorSpaceGamut::AdobeRGB;  // actual score 1.458385
+  if (score < 2.0)
+    return ColorSpaceGamut::Wide;
+  if (score < 2.2)
+    return ColorSpaceGamut::BT2020;  // actual score 2.104520
+  if (score < 2.7)
+    return ColorSpaceGamut::ProPhoto;  // actual score 2.913247
+  return ColorSpaceGamut::UltraWide;
+}
+
 }  // namespace ColorSpaceUtilities
 
 }  // namespace blink