HDR: Do nonlinear blending in the compositor

ui/gfx/color_space.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/color_space.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
@@ skipping 183 matching lines @@
          matrix_ != MatrixID::INVALID && range_ != RangeID::INVALID;
 }
 
 // static
 ColorSpace ColorSpace::CreateSRGB() {
   return ColorSpace(PrimaryID::BT709, TransferID::IEC61966_2_1, MatrixID::RGB,
                     RangeID::FULL);
 }
 
 // static
+ColorSpace ColorSpace::CreateExtendedSRGB() {
+  return ColorSpace(PrimaryID::BT709, TransferID::IEC61966_2_1_HDR,
+                    MatrixID::RGB, RangeID::FULL);
+}
+
+// static
 ColorSpace ColorSpace::CreateCustom(const SkMatrix44& to_XYZD50,
                                     const SkColorSpaceTransferFn& fn) {
   ColorSpace result(ColorSpace::PrimaryID::CUSTOM,
                     ColorSpace::TransferID::CUSTOM, ColorSpace::MatrixID::RGB,
                     ColorSpace::RangeID::FULL);
   for (int row = 0; row < 3; ++row) {
     for (int col = 0; col < 3; ++col) {
       result.custom_primary_matrix_[3 * row + col] = to_XYZD50.get(row, col);
     }
   }
@@ skipping 51 matching lines @@
   if (transfer_ == TransferID::CUSTOM &&
       memcmp(custom_transfer_params_, other.custom_transfer_params_,
              sizeof(custom_transfer_params_)))
     return false;
   return true;
 }
 
 bool ColorSpace::IsHDR() const {
   return transfer_ == TransferID::SMPTEST2084 ||
          transfer_ == TransferID::ARIB_STD_B67 ||
-         transfer_ == TransferID::LINEAR_HDR;
+         transfer_ == TransferID::LINEAR_HDR ||
+         transfer_ == TransferID::IEC61966_2_1_HDR;
 }
 
 bool ColorSpace::operator!=(const ColorSpace& other) const {
   return !(*this == other);
 }
 
 bool ColorSpace::operator<(const ColorSpace& other) const {
   if (primaries_ < other.primaries_)
     return true;
   if (primaries_ > other.primaries_)
@@ skipping 323 matching lines @@
       fn->fG = 2.222222222222f;
       return true;
     case ColorSpace::TransferID::SMPTE240M:
       fn->fA = 0.899626676224f;
       fn->fB = 0.100373323776f;
       fn->fC = 0.250000000000f;
       fn->fD = 0.091286342118f;
       fn->fG = 2.222222222222f;
       return true;
     case ColorSpace::TransferID::IEC61966_2_1:
+    case ColorSpace::TransferID::IEC61966_2_1_HDR:
       fn->fA = 0.947867345704f;
       fn->fB = 0.052132654296f;
       fn->fC = 0.077399380805f;
       fn->fD = 0.040449937172f;
       fn->fG = 2.400000000000f;
       return true;
     case ColorSpace::TransferID::SMPTEST428_1:
       fn->fA = 0.225615407568f;
       fn->fE = -1.091041666667f;
       fn->fG = 2.600000000000f;
@@ skipping 15 matching lines @@
   return false;
 }
 
 bool ColorSpace::GetInverseTransferFunction(SkColorSpaceTransferFn* fn) const {
   if (!GetTransferFunction(fn))
     return false;
   *fn = SkTransferFnInverse(*fn);
   return true;
 }
 
+bool ColorSpace::HasExtendedSkTransferFn() const {
+  return transfer_ == TransferID::LINEAR_HDR ||
+         transfer_ == TransferID::IEC61966_2_1_HDR;
+}
+
 void ColorSpace::GetTransferMatrix(SkMatrix44* matrix) const {
   float Kr = 0;
   float Kb = 0;
   switch (matrix_) {
     case ColorSpace::MatrixID::RGB:
     case ColorSpace::MatrixID::INVALID:
       matrix->setIdentity();
       return;
 
     case ColorSpace::MatrixID::BT709:
@@ skipping 100 matching lines @@
     case MatrixID::BT2020_NCL:
     case MatrixID::BT2020_CL:
     case MatrixID::YDZDX:
       matrix->setScale(255.0f/219.0f, 255.0f/224.0f, 255.0f/224.0f);
       matrix->postTranslate(-16.0f/219.0f, -15.5f/224.0f, -15.5f/224.0f);
       break;
   }
 }
 
 }  // namespace gfx