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::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::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);
+// static
+ColorSpace ColorSpace::CreateVideo(int video_primary,
+                                   int video_transfer,
+                                   int video_matrix,
+                                   RangeID range_id) {
+  ColorSpace result;
+  switch (video_primary) {

[hubbe, 2017/02/16 08:20:50]

Add TODO to make this smarter so that UNSPECIFIED values can be inferred from
values that are specified. Feel free to put my name on it. :)

[ccameron, 2017/02/16 20:45:27]

Done.

+    default:
+    case 0:  // RESERVED0
+    case 1:  // BT709
+    case 2:  // UNSPECIFIED
+    case 3:  // RESERVED
+      result.primaries_ = PrimaryID::BT709;
+      break;
+    case 4:  // BT470M
+      result.primaries_ = PrimaryID::BT470M;
+      break;
+    case 5:  // BT470BG
+      result.primaries_ = PrimaryID::BT470BG;
+      break;
+    case 6:  // SMPTE170M
+      result.primaries_ = PrimaryID::SMPTE170M;
+      break;
+    case 7:  // SMPTE240M
+      result.primaries_ = PrimaryID::SMPTE240M;
+      break;
+    case 8:  // FILM
+      result.primaries_ = PrimaryID::FILM;
+      break;
+    case 9:  // BT2020
+      result.primaries_ = PrimaryID::BT2020;
+      break;
+    case 10:  // SMPTEST428_1
+      result.primaries_ = PrimaryID::SMPTEST428_1;
+      break;
+    case 11:  // SMPTEST431_2
+      result.primaries_ = PrimaryID::SMPTEST431_2;
+      break;
+    case 12:  // SMPTEST432_1
+      result.primaries_ = PrimaryID::SMPTEST432_1;
+      break;
+  }
+  switch (video_transfer) {
+    default:
+    case 0:  // RESERVED0
+    case 1:  // BT709
+    case 2:  // UNSPECIFIED
+    case 3:  // RESERVED
+      result.transfer_ = TransferID::BT709;
+      break;
+    case 4:  // GAMMA22
+      result.transfer_ = TransferID::GAMMA22;
+      break;
+    case 5:  // GAMMA28
+      result.transfer_ = TransferID::GAMMA28;
+      break;
+    case 6:  // SMPTE170M
+      result.transfer_ = TransferID::SMPTE170M;
+      break;
+    case 7:  // SMPTE240M
+      result.transfer_ = TransferID::SMPTE240M;
+      break;
+    case 8:  // LINEAR
+      result.transfer_ = TransferID::LINEAR;
+      break;
+    case 9:  // LOG
+      result.transfer_ = TransferID::LOG;
+      break;
+    case 10:  // LOG_SQRT
+      result.transfer_ = TransferID::LOG_SQRT;
+      break;
+    case 11:  // IEC61966_2_4
+      result.transfer_ = TransferID::IEC61966_2_4;
+      break;
+    case 12:  // BT1361_ECG
+      result.transfer_ = TransferID::BT1361_ECG;
+      break;
+    case 13:  // IEC61966_2_1
+      result.transfer_ = TransferID::IEC61966_2_1;
+      break;
+    case 14:  // BT2020_10
+      result.transfer_ = TransferID::BT2020_10;
+      break;
+    case 15:  // BT2020_12
+      result.transfer_ = TransferID::BT2020_12;
+      break;
+    case 16:  // SMPTEST2084
+      result.transfer_ = TransferID::SMPTEST2084;
+      break;
+    case 17:  // SMPTEST428_1
+      result.transfer_ = TransferID::SMPTEST428_1;
+      break;
+    case 18:  // ARIB_STD_B67
+      result.transfer_ = TransferID::ARIB_STD_B67;
+      break;
+  }
+  switch (video_matrix) {
+    case 0:  // RGB
+      result.matrix_ = MatrixID::RGB;
+      break;
+    default:
+    case 1:  // BT709
+    case 2:  // UNSPECIFIED
+      break;
+    case 3:  // RESERVED
+      result.matrix_ = MatrixID::BT709;
+      break;
+    case 4:  // FCC
+      result.matrix_ = MatrixID::FCC;
+      break;
+    case 5:  // BT470BG
+      result.matrix_ = MatrixID::BT470BG;
+      break;
+    case 6:  // SMPTE170M
+      result.matrix_ = MatrixID::SMPTE170M;
+      break;
+    case 7:  // SMPTE240M
+      result.matrix_ = MatrixID::SMPTE240M;
+      break;
+    case 8:  // YCOCG
+      result.matrix_ = MatrixID::YCOCG;
+      break;
+    case 9:  // BT2020_NCL
+      result.matrix_ = MatrixID::BT2020_NCL;
+      break;
+    case 10:  // BT2020_CL
+      result.matrix_ = MatrixID::BT2020_CL;
+      break;
+    case 11:  // YDZDX
+      result.matrix_ = MatrixID::YDZDX;
+      break;
+  }
+  result.range_ = range_id;
+  return result;
 }
 
 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 &&
+         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::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:
+    case ColorSpace::MatrixID::INVALID:
       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:
+    case RangeID::INVALID:
       matrix->setIdentity();
       return;
 
     case RangeID::DERIVED:
     case RangeID::LIMITED:
       break;
   }
   switch (matrix_) {
     case MatrixID::RGB:
+    case MatrixID::INVALID:
     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