color: Clarify default behaviors

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"
 #include "third_party/skia/include/core/SkColorSpace.h"
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/skia_color_space_util.h"
 #include "ui/gfx/transform.h"
 
 namespace gfx {
 
-ColorSpace::PrimaryID ColorSpace::PrimaryIDFromInt(int primary_id) {
-  if (primary_id < 0 || primary_id > static_cast<int>(PrimaryID::LAST))
-    return PrimaryID::UNKNOWN;
-  if (primary_id > static_cast<int>(PrimaryID::LAST_STANDARD_VALUE) &&
-      primary_id < 1000)
-    return PrimaryID::UNKNOWN;
-  return static_cast<PrimaryID>(primary_id);
+ColorSpace::PrimaryID ColorSpace::PrimaryIDFromH264(int primary_id) {
+  // These values should match the H264 specification (see Table E-3
+  // Colour Primaries in https://www.itu.int/rec/T-REC-H.264/en).
+  switch (primary_id) {
+    case 0:  // RESERVED0
+      break;
+    case 1:
+      return PrimaryID::BT709;
+    case 2:  // UNSPECIFIED
+      break;
+    case 3:  // RESERVED
+      break;
+    case 4:
+      return PrimaryID::BT470M;
+    case 5:
+      return PrimaryID::BT470BG;
+    case 6:
+      return PrimaryID::SMPTE170M;
+    case 7:
+      return PrimaryID::SMPTE240M;
+    case 8:
+      return PrimaryID::FILM;
+    case 9:
+      return PrimaryID::BT2020;
+    case 10:
+      return PrimaryID::SMPTEST428_1;
+    case 11:
+      return PrimaryID::SMPTEST431_2;
+    case 12:
+      return PrimaryID::SMPTEST432_1;
+    default:
+      break;
+  }
+  // All unknown values default to BT709.

[hubbe, 2017/02/15 23:30:43]

This limits our ability to make smart guesses based on the values that *are*
set.

Like, if a video uses the BT601 primaries, it should probably use the BT601
matrix as well. However, with this code we won't be able to tell the difference
between an unset, invalid or default value anymore.

+  return PrimaryID::BT709;
 }
 
-ColorSpace::TransferID ColorSpace::TransferIDFromInt(int transfer_id) {
-  if (transfer_id < 0 || transfer_id > static_cast<int>(TransferID::LAST))
-    return TransferID::UNKNOWN;
-  if (transfer_id > static_cast<int>(TransferID::LAST_STANDARD_VALUE) &&
-      transfer_id < 1000)
-    return TransferID::UNKNOWN;
-  return static_cast<TransferID>(transfer_id);
+ColorSpace::TransferID ColorSpace::TransferIDFromH264(int transfer_id) {
+  switch (transfer_id) {
+    case 0:  // RESERVED0
+      break;
+    case 1:
+      return TransferID::BT709;
+    case 2:  // UNSPECIFIED
+      break;
+    case 3:  // RESERVED
+      break;
+    case 4:
+      return TransferID::GAMMA22;
+    case 5:
+      return TransferID::GAMMA28;
+    case 6:
+      return TransferID::SMPTE170M;
+    case 7:
+      return TransferID::SMPTE240M;
+    case 8:
+      return TransferID::LINEAR;
+    case 9:
+      return TransferID::LOG;
+    case 10:
+      return TransferID::LOG_SQRT;
+    case 11:
+      return TransferID::IEC61966_2_4;
+    case 12:
+      return TransferID::BT1361_ECG;
+    case 13:
+      return TransferID::IEC61966_2_1;
+    case 14:
+      return TransferID::BT2020_10;
+    case 15:
+      return TransferID::BT2020_12;
+    case 16:
+      return TransferID::SMPTEST2084;
+    case 17:
+      return TransferID::SMPTEST428_1;
+    case 18:
+      return TransferID::ARIB_STD_B67;
+    default:
+      break;
+  }
+  // All unknown values default to BT709
+  return TransferID::BT709;
 }
 
-ColorSpace::MatrixID ColorSpace::MatrixIDFromInt(int matrix_id) {
-  if (matrix_id < 0 || matrix_id > static_cast<int>(MatrixID::LAST))
-    return MatrixID::UNKNOWN;
-  if (matrix_id > static_cast<int>(MatrixID::LAST_STANDARD_VALUE) &&
-      matrix_id < 1000)
-    return MatrixID::UNKNOWN;
-  return static_cast<MatrixID>(matrix_id);
+ColorSpace::MatrixID ColorSpace::MatrixIDFromH264(int matrix_id) {
+  // The first 0-255 values should match the H264 specification (see Table E-5
+  // Matrix Coefficients in https://www.itu.int/rec/T-REC-H.264/en).
+  switch (matrix_id) {
+    case 0:
+      return MatrixID::RGB;
+    case 1:
+      return MatrixID::BT709;
+    case 2:  // UNSPECIFIED
+      break;
+    case 3:  // RESERVED
+      break;
+    case 4:
+      return MatrixID::FCC;
+    case 5:
+      return MatrixID::BT470BG;
+    case 6:
+      return MatrixID::SMPTE170M;
+    case 7:
+      return MatrixID::SMPTE240M;
+    case 8:
+      return MatrixID::YCOCG;
+    case 9:
+      return MatrixID::BT2020_NCL;
+    case 10:
+      return MatrixID::BT2020_CL;
+    case 11:
+      return MatrixID::YDZDX;
+    default:
+      break;
+  }
+  // All unknown values default to BT709
+  return MatrixID::BT709;
 }
 
 ColorSpace::ColorSpace() {}
 
 ColorSpace::ColorSpace(PrimaryID primaries,
                        TransferID transfer)
     : primaries_(primaries),
       transfer_(transfer),
       matrix_(MatrixID::RGB),
       range_(RangeID::FULL) {}
 
 ColorSpace::ColorSpace(PrimaryID primaries,
                        TransferID transfer,
                        MatrixID matrix,
                        RangeID range)
     : primaries_(primaries),
       transfer_(transfer),
       matrix_(matrix),
       range_(range) {}
 
-ColorSpace::ColorSpace(int primaries, int transfer, int matrix, RangeID range)
-    : primaries_(PrimaryIDFromInt(primaries)),
-      transfer_(TransferIDFromInt(transfer)),
-      matrix_(MatrixIDFromInt(matrix)),
-      range_(range) {}
-
 ColorSpace::ColorSpace(const ColorSpace& other)
     : primaries_(other.primaries_),
       transfer_(other.transfer_),
       matrix_(other.matrix_),
       range_(other.range_),
       icc_profile_id_(other.icc_profile_id_),
       icc_profile_sk_color_space_(other.icc_profile_sk_color_space_) {
   if (transfer_ == TransferID::CUSTOM) {
     memcpy(custom_transfer_params_, other.custom_transfer_params_,
            sizeof(custom_transfer_params_));
   }
   if (primaries_ == PrimaryID::CUSTOM) {
     memcpy(custom_primary_matrix_, other.custom_primary_matrix_,
            sizeof(custom_primary_matrix_));
   }
 }
 
 ColorSpace::~ColorSpace() = default;
 
 bool ColorSpace::IsValid() const {
-  return *this != gfx::ColorSpace();
+  return primaries_ != PrimaryID::INVALID && transfer_ != TransferID::INVALID;
 }
 
 // static
 ColorSpace ColorSpace::CreateSRGB() {
   return ColorSpace(PrimaryID::BT709, TransferID::IEC61966_2_1, MatrixID::RGB,
                     RangeID::FULL);
 }
 
 // static
 ColorSpace ColorSpace::CreateSCRGBLinear() {
@@ skipping 90 matching lines @@
   return false;
 }
 
 sk_sp<SkColorSpace> ColorSpace::ToSkColorSpace() const {
   // If we got a specific SkColorSpace from the ICCProfile that this color space
   // was created from, use that.
   if (icc_profile_sk_color_space_)
     return icc_profile_sk_color_space_;
 
   // Unspecified color spaces correspond to the null SkColorSpace.
-  if (primaries_ == PrimaryID::UNSPECIFIED ||
-      transfer_ == TransferID::UNSPECIFIED) {
+  if (!IsValid())
     return nullptr;
-  }
 
   // Handle only full-range RGB spaces.
   if (matrix_ != MatrixID::RGB) {
     DLOG(ERROR) << "Not creating non-RGB SkColorSpace";
     return nullptr;
   }
   if (range_ != RangeID::FULL) {
     DLOG(ERROR) << "Not creating non-full-range SkColorSpace";
     return nullptr;
   }
@@ skipping 28 matching lines @@
   return SkColorSpace::MakeRGB(fn, to_xyz_d50);
 }
 
 void ColorSpace::GetPrimaryMatrix(SkMatrix44* to_XYZD50) const {
   SkColorSpacePrimaries primaries = {0};
   switch (primaries_) {
     case ColorSpace::PrimaryID::CUSTOM:
       to_XYZD50->set3x3RowMajorf(custom_primary_matrix_);
       return;
 
-    case ColorSpace::PrimaryID::RESERVED0:
-    case ColorSpace::PrimaryID::RESERVED:
-    case ColorSpace::PrimaryID::UNSPECIFIED:
-    case ColorSpace::PrimaryID::UNKNOWN:
+    case ColorSpace::PrimaryID::INVALID:
+      to_XYZD50->setIdentity();
+      return;
+
     case ColorSpace::PrimaryID::BT709:
       // BT709 is our default case. Put it after the switch just
       // in case we somehow get an id which is not listed in the switch.
       // (We don't want to use "default", because we want the compiler
       //  to tell us if we forgot some enum values.)
       primaries.fRX = 0.640f;
       primaries.fRY = 0.330f;
       primaries.fGX = 0.300f;
       primaries.fGY = 0.600f;
       primaries.fBX = 0.150f;
@@ skipping 141 matching lines @@
       return true;
     case ColorSpace::TransferID::GAMMA22:
       fn->fG = 2.2f;
       return true;
     case ColorSpace::TransferID::GAMMA24:
       fn->fG = 2.4f;
       return true;
     case ColorSpace::TransferID::GAMMA28:
       fn->fG = 2.8f;
       return true;
-    case ColorSpace::TransferID::RESERVED0:
-    case ColorSpace::TransferID::RESERVED:
-    case ColorSpace::TransferID::UNSPECIFIED:
-    case ColorSpace::TransferID::UNKNOWN:
-    // All unknown values default to BT709
     case ColorSpace::TransferID::BT709:
     case ColorSpace::TransferID::SMPTE170M:
     case ColorSpace::TransferID::BT2020_10:
     case ColorSpace::TransferID::BT2020_12:
       fn->fA = 0.909672431050f;
       fn->fB = 0.090327568950f;
       fn->fC = 0.222222222222f;
       fn->fD = 0.081242862158f;
       fn->fG = 2.222222222222f;
       return true;
@@ skipping 19 matching lines @@
     case ColorSpace::TransferID::IEC61966_2_4:
       // This could potentially be represented the same as IEC61966_2_1, but
       // it handles negative values differently.
       break;
     case ColorSpace::TransferID::ARIB_STD_B67:
     case ColorSpace::TransferID::BT1361_ECG:
     case ColorSpace::TransferID::LOG:
     case ColorSpace::TransferID::LOG_SQRT:
     case ColorSpace::TransferID::SMPTEST2084:
     case ColorSpace::TransferID::SMPTEST2084_NON_HDR:
+    case ColorSpace::TransferID::INVALID:
       break;
   }
 
   return false;
 }
 
 bool ColorSpace::GetInverseTransferFunction(SkColorSpaceTransferFn* fn) const {
   if (!GetTransferFunction(fn))
     return false;
   *fn = SkTransferFnInverse(*fn);
   return true;
 }
 
 void ColorSpace::GetTransferMatrix(SkMatrix44* matrix) const {
   float Kr = 0;
   float Kb = 0;
   switch (matrix_) {
     case ColorSpace::MatrixID::RGB:
       matrix->setIdentity();
       return;
 
     case ColorSpace::MatrixID::BT709:
-    case ColorSpace::MatrixID::UNSPECIFIED:
-    case ColorSpace::MatrixID::RESERVED:
-    case ColorSpace::MatrixID::UNKNOWN:
       Kr = 0.2126f;
       Kb = 0.0722f;
       break;
 
     case ColorSpace::MatrixID::FCC:
       Kr = 0.30f;
       Kb = 0.11f;
       break;
 
     case ColorSpace::MatrixID::BT470BG:
@@ skipping 59 matching lines @@
               u_m * -Kr, u_m * -Kg, u_m * (1.0f - Kb), 0.5f,  // U
       v_m * (1.0f - Kr), v_m * -Kg,         v_m * -Kb, 0.5f,  // V
                    0.0f,      0.0f,              0.0f, 1.0f,
   };
   matrix->setRowMajorf(data);
 }
 
 void ColorSpace::GetRangeAdjustMatrix(SkMatrix44* matrix) const {
   switch (range_) {
     case RangeID::FULL:
-    case RangeID::UNSPECIFIED:
       matrix->setIdentity();
       return;
 
     case RangeID::DERIVED:
     case RangeID::LIMITED:
       break;
   }
   switch (matrix_) {
     case MatrixID::RGB:
     case MatrixID::YCOCG:
       matrix->setScale(255.0f/219.0f, 255.0f/219.0f, 255.0f/219.0f);
       matrix->postTranslate(-16.0f/219.0f, -16.0f/219.0f, -16.0f/219.0f);
       break;
 
     case MatrixID::BT709:
-    case MatrixID::UNSPECIFIED:
-    case MatrixID::RESERVED:
     case MatrixID::FCC:
     case MatrixID::BT470BG:
     case MatrixID::SMPTE170M:
     case MatrixID::SMPTE240M:
     case MatrixID::BT2020_NCL:
     case MatrixID::BT2020_CL:
     case MatrixID::YDZDX:
-    case MatrixID::UNKNOWN:
       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