| // 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 <iomanip> |
| #include <limits> |
| #include <map> |
| #include <sstream> |
| |
| #include "base/atomic_sequence_num.h" |
| #include "base/lazy_instance.h" |
| #include "base/logging.h" |
| #include "base/synchronization/lock.h" |
| #include "third_party/skia/include/core/SkColorSpace.h" |
| #include "third_party/skia/include/core/SkData.h" |
| #include "third_party/skia/include/core/SkICC.h" |
| #include "third_party/skia/include/core/SkImageInfo.h" |
| #include "ui/gfx/display_color_spaces.h" |
| #include "ui/gfx/icc_profile.h" |
| #include "ui/gfx/skia_color_space_util.h" |
| |
| namespace gfx { |
| |
| namespace { |
| |
| static bool IsAlmostZero(float value) { |
| return std::abs(value) < std::numeric_limits<float>::epsilon(); |
| } |
| |
| static bool FloatsEqualWithinTolerance(const float* a, |
| const float* b, |
| int n, |
| float tol) { |
| for (int i = 0; i < n; ++i) { |
| if (std::abs(a[i] - b[i]) > tol) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| skcms_TransferFunction GetPQSkTransferFunction(float sdr_white_level) { |
| // Note that SkColorSpace doesn't have the notion of an unspecified SDR white |
| // level. |
| if (sdr_white_level == 0.f) |
| sdr_white_level = ColorSpace::kDefaultSDRWhiteLevel; |
| |
| // The generic PQ transfer function produces normalized luminance values i.e. |
| // the range 0-1 represents 0-10000 nits for the reference display, but we |
| // want to map 1.0 to |sdr_white_level| nits so we need to scale accordingly. |
| const double w = 10000. / sdr_white_level; |
| // Distribute scaling factor W by scaling A and B with X ^ (1/F): |
| // ((A + Bx^C) / (D + Ex^C))^F * W = ((A + Bx^C) / (D + Ex^C) * W^(1/F))^F |
| // See https://crbug.com/1058580#c32 for discussion. |
| skcms_TransferFunction fn = SkNamedTransferFn::kPQ; |
| const double ws = pow(w, 1. / fn.f); |
| fn.a = ws * fn.a; |
| fn.b = ws * fn.b; |
| return fn; |
| } |
| |
| skcms_TransferFunction GetHLGSkTransferFunction(float sdr_white_level) { |
| // Note that SkColorSpace doesn't have the notion of an unspecified SDR white |
| // level. |
| if (sdr_white_level == 0.f) |
| sdr_white_level = ColorSpace::kDefaultSDRWhiteLevel; |
| |
| // The reference white level for HLG is 100 nits. We want to setup the |
| // returned transfer function such that output values are scaled by the white |
| // level; Skia uses the |f| transfer function parameter for this. |
| skcms_TransferFunction fn = SkNamedTransferFn::kHLG; |
| fn.f = ColorSpace::kDefaultSDRWhiteLevel / sdr_white_level - 1; |
| return fn; |
| } |
| |
| float GetSDRWhiteLevelFromPQSkTransferFunction( |
| const skcms_TransferFunction& fn) { |
| DCHECK_EQ(fn.g, SkNamedTransferFn::kPQ.g); |
| const double ws_a = static_cast<double>(fn.a) / SkNamedTransferFn::kPQ.a; |
| const double w_a = pow(ws_a, fn.f); |
| const double sdr_white_level_a = 10000.0f / w_a; |
| return sdr_white_level_a; |
| } |
| |
| float GetSDRWhiteLevelFromHLGSkTransferFunction( |
| const skcms_TransferFunction& fn) { |
| DCHECK_EQ(fn.g, SkNamedTransferFn::kHLG.g); |
| if (fn.f == 0) |
| return ColorSpace::kDefaultSDRWhiteLevel; |
| return 1.0f / ((fn.f + 1) / ColorSpace::kDefaultSDRWhiteLevel); |
| } |
| |
| bool PrimaryIdContainsSRGB(ColorSpace::PrimaryID id) { |
| DCHECK(id != ColorSpace::PrimaryID::INVALID && |
| id != ColorSpace::PrimaryID::CUSTOM); |
| |
| switch (id) { |
| case ColorSpace::PrimaryID::BT709: |
| case ColorSpace::PrimaryID::BT2020: |
| case ColorSpace::PrimaryID::SMPTEST428_1: |
| case ColorSpace::PrimaryID::SMPTEST431_2: |
| case ColorSpace::PrimaryID::SMPTEST432_1: |
| case ColorSpace::PrimaryID::XYZ_D50: |
| case ColorSpace::PrimaryID::ADOBE_RGB: |
| case ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| } // namespace |
| |
| // static |
| constexpr float ColorSpace::kDefaultSDRWhiteLevel; |
| |
| ColorSpace::ColorSpace(PrimaryID primaries, |
| TransferID transfer, |
| MatrixID matrix, |
| RangeID range, |
| const skcms_Matrix3x3* custom_primary_matrix, |
| const skcms_TransferFunction* custom_transfer_fn) |
| : primaries_(primaries), |
| transfer_(transfer), |
| matrix_(matrix), |
| range_(range) { |
| if (custom_primary_matrix) { |
| DCHECK_EQ(PrimaryID::CUSTOM, primaries_); |
| SetCustomPrimaries(*custom_primary_matrix); |
| } |
| if (custom_transfer_fn) |
| SetCustomTransferFunction(*custom_transfer_fn); |
| } |
| |
| ColorSpace::ColorSpace(const SkColorSpace& sk_color_space) |
| : ColorSpace(PrimaryID::INVALID, |
| TransferID::INVALID, |
| MatrixID::RGB, |
| RangeID::FULL) { |
| skcms_TransferFunction fn; |
| if (sk_color_space.isNumericalTransferFn(&fn)) { |
| transfer_ = TransferID::CUSTOM; |
| SetCustomTransferFunction(fn); |
| } else if (skcms_TransferFunction_isHLGish(&fn)) { |
| transfer_ = TransferID::ARIB_STD_B67; |
| transfer_params_[0] = GetSDRWhiteLevelFromHLGSkTransferFunction(fn); |
| } else if (skcms_TransferFunction_isPQish(&fn)) { |
| transfer_ = TransferID::SMPTEST2084; |
| transfer_params_[0] = GetSDRWhiteLevelFromPQSkTransferFunction(fn); |
| } else { |
| // Construct an invalid result: Unable to extract necessary parameters |
| return; |
| } |
| |
| skcms_Matrix3x3 to_XYZD50; |
| if (!sk_color_space.toXYZD50(&to_XYZD50)) { |
| // Construct an invalid result: Unable to extract necessary parameters |
| return; |
| } |
| SetCustomPrimaries(to_XYZD50); |
| } |
| |
| bool ColorSpace::IsValid() const { |
| return primaries_ != PrimaryID::INVALID && transfer_ != TransferID::INVALID && |
| matrix_ != MatrixID::INVALID && range_ != RangeID::INVALID; |
| } |
| |
| // static |
| ColorSpace ColorSpace::CreateSCRGBLinear(float sdr_white_level) { |
| skcms_TransferFunction fn = {0}; |
| fn.g = 1.0f; |
| fn.a = kDefaultScrgbLinearSdrWhiteLevel / sdr_white_level; |
| return ColorSpace(PrimaryID::BT709, TransferID::CUSTOM_HDR, MatrixID::RGB, |
| RangeID::FULL, nullptr, &fn); |
| } |
| |
| // static |
| ColorSpace ColorSpace::CreateHDR10(float sdr_white_level) { |
| ColorSpace result(PrimaryID::BT2020, TransferID::SMPTEST2084, MatrixID::RGB, |
| RangeID::FULL); |
| result.transfer_params_[0] = sdr_white_level; |
| return result; |
| } |
| |
| // static |
| ColorSpace ColorSpace::CreateHLG() { |
| return ColorSpace(PrimaryID::BT2020, TransferID::ARIB_STD_B67, MatrixID::RGB, |
| RangeID::FULL); |
| } |
| |
| // static |
| ColorSpace ColorSpace::CreatePiecewiseHDR( |
| PrimaryID primaries, |
| float sdr_joint, |
| float hdr_level, |
| const skcms_Matrix3x3* custom_primary_matrix) { |
| // If |sdr_joint| is 1, then this is just sRGB (and so |hdr_level| must be 1). |
| // An |sdr_joint| higher than 1 breaks. |
| DCHECK_LE(sdr_joint, 1.f); |
| if (sdr_joint == 1.f) |
| DCHECK_EQ(hdr_level, 1.f); |
| // An |hdr_level| of 1 has no HDR. An |hdr_level| less than 1 breaks. |
| DCHECK_GE(hdr_level, 1.f); |
| ColorSpace result(primaries, TransferID::PIECEWISE_HDR, MatrixID::RGB, |
| RangeID::FULL, custom_primary_matrix, nullptr); |
| result.transfer_params_[0] = sdr_joint; |
| result.transfer_params_[1] = hdr_level; |
| return result; |
| } |
| |
| // static |
| ColorSpace ColorSpace::CreateCustom(const skcms_Matrix3x3& to_XYZD50, |
| const skcms_TransferFunction& fn) { |
| ColorSpace result(ColorSpace::PrimaryID::CUSTOM, |
| ColorSpace::TransferID::CUSTOM, ColorSpace::MatrixID::RGB, |
| ColorSpace::RangeID::FULL, &to_XYZD50, &fn); |
| return result; |
| } |
| |
| // static |
| ColorSpace ColorSpace::CreateCustom(const skcms_Matrix3x3& to_XYZD50, |
| TransferID transfer) { |
| ColorSpace result(ColorSpace::PrimaryID::CUSTOM, transfer, |
| ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL, |
| &to_XYZD50, nullptr); |
| return result; |
| } |
| |
| void ColorSpace::SetCustomPrimaries(const skcms_Matrix3x3& to_XYZD50) { |
| const PrimaryID kIDsToCheck[] = { |
| PrimaryID::BT709, |
| PrimaryID::BT470M, |
| PrimaryID::BT470BG, |
| PrimaryID::SMPTE170M, |
| PrimaryID::SMPTE240M, |
| PrimaryID::FILM, |
| PrimaryID::BT2020, |
| PrimaryID::SMPTEST428_1, |
| PrimaryID::SMPTEST431_2, |
| PrimaryID::SMPTEST432_1, |
| PrimaryID::XYZ_D50, |
| PrimaryID::ADOBE_RGB, |
| PrimaryID::APPLE_GENERIC_RGB, |
| PrimaryID::WIDE_GAMUT_COLOR_SPIN, |
| }; |
| for (PrimaryID id : kIDsToCheck) { |
| skcms_Matrix3x3 matrix; |
| GetPrimaryMatrix(id, &matrix); |
| if (FloatsEqualWithinTolerance(&to_XYZD50.vals[0][0], &matrix.vals[0][0], 9, |
| 0.001f)) { |
| primaries_ = id; |
| return; |
| } |
| } |
| |
| memcpy(custom_primary_matrix_, &to_XYZD50, 9 * sizeof(float)); |
| primaries_ = PrimaryID::CUSTOM; |
| } |
| |
| void ColorSpace::SetCustomTransferFunction(const skcms_TransferFunction& fn) { |
| DCHECK(transfer_ == TransferID::CUSTOM || |
| transfer_ == TransferID::CUSTOM_HDR); |
| // These are all TransferIDs that will return a transfer function from |
| // GetTransferFunction. When multiple ids map to the same function, this list |
| // prioritizes the most common name (eg IEC61966_2_1). This applies only to |
| // SDR transfer functions. |
| if (transfer_ == TransferID::CUSTOM) { |
| const TransferID kIDsToCheck[] = { |
| TransferID::IEC61966_2_1, TransferID::LINEAR, |
| TransferID::GAMMA18, TransferID::GAMMA22, |
| TransferID::GAMMA24, TransferID::GAMMA28, |
| TransferID::SMPTE240M, TransferID::BT709_APPLE, |
| TransferID::SMPTEST428_1, |
| }; |
| for (TransferID id : kIDsToCheck) { |
| skcms_TransferFunction id_fn; |
| GetTransferFunction(id, &id_fn); |
| if (FloatsEqualWithinTolerance(&fn.g, &id_fn.g, 7, 0.001f)) { |
| transfer_ = id; |
| return; |
| } |
| } |
| } |
| transfer_params_[0] = fn.a; |
| transfer_params_[1] = fn.b; |
| transfer_params_[2] = fn.c; |
| transfer_params_[3] = fn.d; |
| transfer_params_[4] = fn.e; |
| transfer_params_[5] = fn.f; |
| transfer_params_[6] = fn.g; |
| } |
| |
| // static |
| size_t ColorSpace::TransferParamCount(TransferID transfer) { |
| switch (transfer) { |
| case TransferID::CUSTOM: |
| return 7; |
| case TransferID::CUSTOM_HDR: |
| return 7; |
| case TransferID::PIECEWISE_HDR: |
| return 2; |
| case TransferID::SMPTEST2084: |
| case TransferID::ARIB_STD_B67: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| |
| bool ColorSpace::operator==(const ColorSpace& other) const { |
| if (primaries_ != other.primaries_ || transfer_ != other.transfer_ || |
| matrix_ != other.matrix_ || range_ != other.range_) { |
| return false; |
| } |
| if (primaries_ == PrimaryID::CUSTOM) { |
| if (memcmp(custom_primary_matrix_, other.custom_primary_matrix_, |
| sizeof(custom_primary_matrix_))) { |
| return false; |
| } |
| } |
| if (size_t param_count = TransferParamCount(transfer_)) { |
| if (memcmp(transfer_params_, other.transfer_params_, |
| param_count * sizeof(float))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool ColorSpace::IsWide() const { |
| // These HDR transfer functions are always wide |
| if (transfer_ == TransferID::IEC61966_2_1_HDR || |
| transfer_ == TransferID::LINEAR_HDR || |
| transfer_ == TransferID::CUSTOM_HDR) |
| return true; |
| |
| if (primaries_ == PrimaryID::BT2020 || |
| primaries_ == PrimaryID::SMPTEST431_2 || |
| primaries_ == PrimaryID::SMPTEST432_1 || |
| primaries_ == PrimaryID::ADOBE_RGB || |
| primaries_ == PrimaryID::WIDE_GAMUT_COLOR_SPIN || |
| // TODO(cblume/ccameron): Compute if the custom primaries actually are |
| // wide. For now, assume so. |
| primaries_ == PrimaryID::CUSTOM) |
| return true; |
| |
| return false; |
| } |
| |
| bool ColorSpace::IsHDR() const { |
| return transfer_ == TransferID::SMPTEST2084 || |
| transfer_ == TransferID::ARIB_STD_B67 || |
| transfer_ == TransferID::LINEAR_HDR || |
| transfer_ == TransferID::IEC61966_2_1_HDR || |
| transfer_ == TransferID::CUSTOM_HDR || |
| transfer_ == TransferID::PIECEWISE_HDR; |
| } |
| |
| bool ColorSpace::FullRangeEncodedValues() const { |
| return transfer_ == TransferID::LINEAR_HDR || |
| transfer_ == TransferID::IEC61966_2_1_HDR || |
| transfer_ == TransferID::CUSTOM_HDR || |
| transfer_ == TransferID::PIECEWISE_HDR || |
| transfer_ == TransferID::BT1361_ECG || |
| transfer_ == TransferID::IEC61966_2_4; |
| } |
| |
| 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_) |
| return false; |
| if (transfer_ < other.transfer_) |
| return true; |
| if (transfer_ > other.transfer_) |
| return false; |
| if (matrix_ < other.matrix_) |
| return true; |
| if (matrix_ > other.matrix_) |
| return false; |
| if (range_ < other.range_) |
| return true; |
| if (range_ > other.range_) |
| return false; |
| if (primaries_ == PrimaryID::CUSTOM) { |
| int primary_result = |
| memcmp(custom_primary_matrix_, other.custom_primary_matrix_, |
| sizeof(custom_primary_matrix_)); |
| if (primary_result < 0) |
| return true; |
| if (primary_result > 0) |
| return false; |
| } |
| if (size_t param_count = TransferParamCount(transfer_)) { |
| int transfer_result = memcmp(transfer_params_, other.transfer_params_, |
| param_count * sizeof(float)); |
| if (transfer_result < 0) |
| return true; |
| if (transfer_result > 0) |
| return false; |
| } |
| return false; |
| } |
| |
| size_t ColorSpace::GetHash() const { |
| size_t result = (static_cast<size_t>(primaries_) << 0) | |
| (static_cast<size_t>(transfer_) << 8) | |
| (static_cast<size_t>(matrix_) << 16) | |
| (static_cast<size_t>(range_) << 24); |
| if (primaries_ == PrimaryID::CUSTOM) { |
| const uint32_t* params = |
| reinterpret_cast<const uint32_t*>(custom_primary_matrix_); |
| result ^= params[0]; |
| result ^= params[4]; |
| result ^= params[8]; |
| } |
| { |
| // Note that |transfer_params_| must be zero when they are unused. |
| const uint32_t* params = |
| reinterpret_cast<const uint32_t*>(transfer_params_); |
| result ^= params[3]; |
| result ^= params[6]; |
| } |
| return result; |
| } |
| |
| #define PRINT_ENUM_CASE(TYPE, NAME) \ |
| case TYPE::NAME: \ |
| ss << #NAME; \ |
| break; |
| |
| std::string ColorSpace::ToString() const { |
| std::stringstream ss; |
| ss << std::fixed << std::setprecision(4); |
| if (primaries_ != PrimaryID::CUSTOM) |
| ss << "{primaries:"; |
| switch (primaries_) { |
| PRINT_ENUM_CASE(PrimaryID, INVALID) |
| PRINT_ENUM_CASE(PrimaryID, BT709) |
| PRINT_ENUM_CASE(PrimaryID, BT470M) |
| PRINT_ENUM_CASE(PrimaryID, BT470BG) |
| PRINT_ENUM_CASE(PrimaryID, SMPTE170M) |
| PRINT_ENUM_CASE(PrimaryID, SMPTE240M) |
| PRINT_ENUM_CASE(PrimaryID, FILM) |
| PRINT_ENUM_CASE(PrimaryID, BT2020) |
| PRINT_ENUM_CASE(PrimaryID, SMPTEST428_1) |
| PRINT_ENUM_CASE(PrimaryID, SMPTEST431_2) |
| PRINT_ENUM_CASE(PrimaryID, SMPTEST432_1) |
| PRINT_ENUM_CASE(PrimaryID, XYZ_D50) |
| PRINT_ENUM_CASE(PrimaryID, ADOBE_RGB) |
| PRINT_ENUM_CASE(PrimaryID, APPLE_GENERIC_RGB) |
| PRINT_ENUM_CASE(PrimaryID, WIDE_GAMUT_COLOR_SPIN) |
| case PrimaryID::CUSTOM: |
| // |custom_primary_matrix_| is in row-major order. |
| const float sum_R = custom_primary_matrix_[0] + |
| custom_primary_matrix_[3] + custom_primary_matrix_[6]; |
| const float sum_G = custom_primary_matrix_[1] + |
| custom_primary_matrix_[4] + custom_primary_matrix_[7]; |
| const float sum_B = custom_primary_matrix_[2] + |
| custom_primary_matrix_[5] + custom_primary_matrix_[8]; |
| if (IsAlmostZero(sum_R) || IsAlmostZero(sum_G) || IsAlmostZero(sum_B)) |
| break; |
| |
| ss << "{primaries_d50_referred: [[" << (custom_primary_matrix_[0] / sum_R) |
| << ", " << (custom_primary_matrix_[3] / sum_R) << "], " |
| << " [" << (custom_primary_matrix_[1] / sum_G) << ", " |
| << (custom_primary_matrix_[4] / sum_G) << "], " |
| << " [" << (custom_primary_matrix_[2] / sum_B) << ", " |
| << (custom_primary_matrix_[5] / sum_B) << "]]"; |
| break; |
| } |
| ss << ", transfer:"; |
| switch (transfer_) { |
| PRINT_ENUM_CASE(TransferID, INVALID) |
| PRINT_ENUM_CASE(TransferID, BT709) |
| PRINT_ENUM_CASE(TransferID, BT709_APPLE) |
| PRINT_ENUM_CASE(TransferID, GAMMA18) |
| PRINT_ENUM_CASE(TransferID, GAMMA22) |
| PRINT_ENUM_CASE(TransferID, GAMMA24) |
| PRINT_ENUM_CASE(TransferID, GAMMA28) |
| PRINT_ENUM_CASE(TransferID, SMPTE170M) |
| PRINT_ENUM_CASE(TransferID, SMPTE240M) |
| PRINT_ENUM_CASE(TransferID, LINEAR) |
| PRINT_ENUM_CASE(TransferID, LOG) |
| PRINT_ENUM_CASE(TransferID, LOG_SQRT) |
| PRINT_ENUM_CASE(TransferID, IEC61966_2_4) |
| PRINT_ENUM_CASE(TransferID, BT1361_ECG) |
| PRINT_ENUM_CASE(TransferID, IEC61966_2_1) |
| PRINT_ENUM_CASE(TransferID, BT2020_10) |
| PRINT_ENUM_CASE(TransferID, BT2020_12) |
| PRINT_ENUM_CASE(TransferID, SMPTEST428_1) |
| PRINT_ENUM_CASE(TransferID, IEC61966_2_1_HDR) |
| PRINT_ENUM_CASE(TransferID, LINEAR_HDR) |
| case TransferID::ARIB_STD_B67: |
| ss << "HLG (SDR white point "; |
| if (transfer_params_[0] == 0.f) |
| ss << "default " << kDefaultSDRWhiteLevel; |
| else |
| ss << transfer_params_[0]; |
| ss << " nits)"; |
| break; |
| case TransferID::SMPTEST2084: |
| ss << "PQ (SDR white point "; |
| if (transfer_params_[0] == 0.f) |
| ss << "default " << kDefaultSDRWhiteLevel; |
| else |
| ss << transfer_params_[0]; |
| ss << " nits)"; |
| break; |
| case TransferID::CUSTOM: { |
| skcms_TransferFunction fn; |
| GetTransferFunction(&fn); |
| ss << fn.c << "*x + " << fn.f << " if x < " << fn.d << " else (" << fn.a |
| << "*x + " << fn.b << ")**" << fn.g << " + " << fn.e; |
| break; |
| } |
| case TransferID::CUSTOM_HDR: { |
| skcms_TransferFunction fn; |
| GetTransferFunction(&fn); |
| if (fn.g == 1.0f && fn.a > 0.0f && fn.b == 0.0f && fn.c == 0.0f && |
| fn.d == 0.0f && fn.e == 0.0f && fn.f == 0.0f) { |
| ss << "LINEAR_HDR (slope " << fn.a << ", SDR white point " |
| << kDefaultScrgbLinearSdrWhiteLevel / fn.a << " nits)"; |
| break; |
| } |
| ss << fn.c << "*x + " << fn.f << " if |x| < " << fn.d << " else sign(x)*(" |
| << fn.a << "*|x| + " << fn.b << ")**" << fn.g << " + " << fn.e; |
| break; |
| } |
| case TransferID::PIECEWISE_HDR: { |
| skcms_TransferFunction fn; |
| GetTransferFunction(&fn); |
| ss << "sRGB to 1 at " << transfer_params_[0] << ", linear to " |
| << transfer_params_[1] << " at 1"; |
| break; |
| } |
| } |
| ss << ", matrix:"; |
| switch (matrix_) { |
| PRINT_ENUM_CASE(MatrixID, INVALID) |
| PRINT_ENUM_CASE(MatrixID, RGB) |
| PRINT_ENUM_CASE(MatrixID, BT709) |
| PRINT_ENUM_CASE(MatrixID, FCC) |
| PRINT_ENUM_CASE(MatrixID, BT470BG) |
| PRINT_ENUM_CASE(MatrixID, SMPTE170M) |
| PRINT_ENUM_CASE(MatrixID, SMPTE240M) |
| PRINT_ENUM_CASE(MatrixID, YCOCG) |
| PRINT_ENUM_CASE(MatrixID, BT2020_NCL) |
| PRINT_ENUM_CASE(MatrixID, BT2020_CL) |
| PRINT_ENUM_CASE(MatrixID, YDZDX) |
| PRINT_ENUM_CASE(MatrixID, GBR) |
| } |
| ss << ", range:"; |
| switch (range_) { |
| PRINT_ENUM_CASE(RangeID, INVALID) |
| PRINT_ENUM_CASE(RangeID, LIMITED) |
| PRINT_ENUM_CASE(RangeID, FULL) |
| PRINT_ENUM_CASE(RangeID, DERIVED) |
| } |
| ss << "}"; |
| return ss.str(); |
| } |
| |
| #undef PRINT_ENUM_CASE |
| |
| ColorSpace ColorSpace::GetAsFullRangeRGB() const { |
| ColorSpace result(*this); |
| if (!IsValid()) |
| return result; |
| result.matrix_ = MatrixID::RGB; |
| result.range_ = RangeID::FULL; |
| return result; |
| } |
| |
| ContentColorUsage ColorSpace::GetContentColorUsage() const { |
| if (IsHDR()) |
| return ContentColorUsage::kHDR; |
| if (IsWide()) |
| return ContentColorUsage::kWideColorGamut; |
| return ContentColorUsage::kSRGB; |
| } |
| |
| ColorSpace ColorSpace::GetAsRGB() const { |
| ColorSpace result(*this); |
| if (IsValid()) |
| result.matrix_ = MatrixID::RGB; |
| return result; |
| } |
| |
| ColorSpace ColorSpace::GetScaledColorSpace(float factor) const { |
| ColorSpace result(*this); |
| skcms_Matrix3x3 to_XYZD50; |
| GetPrimaryMatrix(&to_XYZD50); |
| for (int row = 0; row < 3; ++row) { |
| for (int col = 0; col < 3; ++col) { |
| to_XYZD50.vals[row][col] *= factor; |
| } |
| } |
| result.SetCustomPrimaries(to_XYZD50); |
| return result; |
| } |
| |
| bool ColorSpace::IsSuitableForBlending() const { |
| switch (transfer_) { |
| case TransferID::SMPTEST2084: |
| // PQ is not an acceptable space to do blending in -- blending 0 and 1 |
| // evenly will get a result of sRGB 0.259 (instead of 0.5). |
| return false; |
| case TransferID::ARIB_STD_B67: |
| case TransferID::LINEAR_HDR: |
| // If the color space is nearly-linear, then it is not suitable for |
| // blending -- blending 0 and 1 evenly will get a result of sRGB 0.735 |
| // (instead of 0.5). |
| return false; |
| case TransferID::CUSTOM_HDR: { |
| // A gamma close enough to linear is treated as linear. |
| skcms_TransferFunction fn; |
| if (GetTransferFunction(&fn)) { |
| constexpr float kMinGamma = 1.25; |
| if (fn.g < kMinGamma) |
| return false; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| return true; |
| } |
| |
| ColorSpace ColorSpace::GetWithMatrixAndRange(MatrixID matrix, |
| RangeID range) const { |
| ColorSpace result(*this); |
| if (!IsValid()) |
| return result; |
| |
| result.matrix_ = matrix; |
| result.range_ = range; |
| return result; |
| } |
| |
| ColorSpace ColorSpace::GetWithSDRWhiteLevel(float sdr_white_level) const { |
| ColorSpace result = *this; |
| if (transfer_ == TransferID::SMPTEST2084 || |
| transfer_ == TransferID::ARIB_STD_B67) { |
| result.transfer_params_[0] = sdr_white_level; |
| } else if (transfer_ == TransferID::LINEAR_HDR) { |
| result.transfer_ = TransferID::CUSTOM_HDR; |
| skcms_TransferFunction fn = {0}; |
| fn.g = 1.f; |
| fn.a = kDefaultScrgbLinearSdrWhiteLevel / sdr_white_level; |
| result.SetCustomTransferFunction(fn); |
| } |
| return result; |
| } |
| |
| sk_sp<SkColorSpace> ColorSpace::ToSkColorSpace() const { |
| // Unspecified color spaces correspond to the null SkColorSpace. |
| 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; |
| } |
| |
| // Use the named SRGB and linear-SRGB instead of the generic constructors. |
| if (primaries_ == PrimaryID::BT709) { |
| if (transfer_ == TransferID::IEC61966_2_1) |
| return SkColorSpace::MakeSRGB(); |
| if (transfer_ == TransferID::LINEAR || transfer_ == TransferID::LINEAR_HDR) |
| return SkColorSpace::MakeSRGBLinear(); |
| } |
| |
| skcms_TransferFunction transfer_fn = SkNamedTransferFn::kSRGB; |
| switch (transfer_) { |
| case TransferID::IEC61966_2_1: |
| break; |
| case TransferID::LINEAR: |
| case TransferID::LINEAR_HDR: |
| transfer_fn = SkNamedTransferFn::kLinear; |
| break; |
| case TransferID::ARIB_STD_B67: |
| transfer_fn = GetHLGSkTransferFunction(transfer_params_[0]); |
| break; |
| case TransferID::SMPTEST2084: |
| transfer_fn = GetPQSkTransferFunction(transfer_params_[0]); |
| break; |
| default: |
| if (!GetTransferFunction(&transfer_fn)) { |
| DLOG(ERROR) << "Failed to get transfer function for SkColorSpace"; |
| return nullptr; |
| } |
| break; |
| } |
| skcms_Matrix3x3 gamut = SkNamedGamut::kSRGB; |
| switch (primaries_) { |
| case PrimaryID::BT709: |
| break; |
| case PrimaryID::ADOBE_RGB: |
| gamut = SkNamedGamut::kAdobeRGB; |
| break; |
| case PrimaryID::SMPTEST432_1: |
| gamut = SkNamedGamut::kDisplayP3; |
| break; |
| case PrimaryID::BT2020: |
| gamut = SkNamedGamut::kRec2020; |
| break; |
| default: |
| GetPrimaryMatrix(&gamut); |
| break; |
| } |
| |
| sk_sp<SkColorSpace> sk_color_space = |
| SkColorSpace::MakeRGB(transfer_fn, gamut); |
| if (!sk_color_space) |
| DLOG(ERROR) << "SkColorSpace::MakeRGB failed."; |
| |
| return sk_color_space; |
| } |
| |
| const struct _GLcolorSpace* ColorSpace::AsGLColorSpace() const { |
| return reinterpret_cast<const struct _GLcolorSpace*>(this); |
| } |
| |
| ColorSpace::PrimaryID ColorSpace::GetPrimaryID() const { |
| return primaries_; |
| } |
| |
| ColorSpace::TransferID ColorSpace::GetTransferID() const { |
| return transfer_; |
| } |
| |
| ColorSpace::MatrixID ColorSpace::GetMatrixID() const { |
| return matrix_; |
| } |
| |
| ColorSpace::RangeID ColorSpace::GetRangeID() const { |
| return range_; |
| } |
| |
| bool ColorSpace::HasExtendedSkTransferFn() const { |
| return transfer_ == TransferID::LINEAR_HDR || |
| transfer_ == TransferID::IEC61966_2_1_HDR; |
| } |
| |
| bool ColorSpace::Contains(const ColorSpace& other) const { |
| if (primaries_ == PrimaryID::INVALID || |
| other.primaries_ == PrimaryID::INVALID) |
| return false; |
| |
| // Contains() is commonly used to check if a color space contains sRGB. The |
| // computation can be bypassed for known primary IDs. |
| if (primaries_ != PrimaryID::CUSTOM && other.primaries_ == PrimaryID::BT709) |
| return PrimaryIdContainsSRGB(primaries_); |
| |
| // |matrix| is the primary transform matrix from |other| to this color space. |
| skcms_Matrix3x3 other_to_xyz; |
| skcms_Matrix3x3 this_to_xyz; |
| skcms_Matrix3x3 xyz_to_this; |
| other.GetPrimaryMatrix(&other_to_xyz); |
| GetPrimaryMatrix(&this_to_xyz); |
| skcms_Matrix3x3_invert(&this_to_xyz, &xyz_to_this); |
| skcms_Matrix3x3 matrix = skcms_Matrix3x3_concat(&xyz_to_this, &other_to_xyz); |
| |
| // Return true iff each primary is in the range [0, 1] after transforming. |
| // Transforming a primary vector by |matrix| always results in a column of |
| // |matrix|. So the multiplication can be skipped, and we can just check if |
| // each value in the matrix is in the range [0, 1]. |
| constexpr float epsilon = 0.001f; |
| for (int r = 0; r < 3; r++) { |
| for (int c = 0; c < 3; c++) { |
| if (matrix.vals[r][c] < -epsilon || matrix.vals[r][c] > 1 + epsilon) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| // static |
| void ColorSpace::GetPrimaryMatrix(PrimaryID primary_id, |
| skcms_Matrix3x3* to_XYZD50) { |
| SkColorSpacePrimaries primaries = {0}; |
| switch (primary_id) { |
| case ColorSpace::PrimaryID::CUSTOM: |
| case ColorSpace::PrimaryID::INVALID: |
| *to_XYZD50 = SkNamedGamut::kXYZ; // Identity |
| 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; |
| primaries.fBY = 0.060f; |
| primaries.fWX = 0.3127f; |
| primaries.fWY = 0.3290f; |
| break; |
| |
| case ColorSpace::PrimaryID::BT470M: |
| primaries.fRX = 0.67f; |
| primaries.fRY = 0.33f; |
| primaries.fGX = 0.21f; |
| primaries.fGY = 0.71f; |
| primaries.fBX = 0.14f; |
| primaries.fBY = 0.08f; |
| primaries.fWX = 0.31f; |
| primaries.fWY = 0.316f; |
| break; |
| |
| case ColorSpace::PrimaryID::BT470BG: |
| primaries.fRX = 0.64f; |
| primaries.fRY = 0.33f; |
| primaries.fGX = 0.29f; |
| primaries.fGY = 0.60f; |
| primaries.fBX = 0.15f; |
| primaries.fBY = 0.06f; |
| primaries.fWX = 0.3127f; |
| primaries.fWY = 0.3290f; |
| break; |
| |
| case ColorSpace::PrimaryID::SMPTE170M: |
| case ColorSpace::PrimaryID::SMPTE240M: |
| primaries.fRX = 0.630f; |
| primaries.fRY = 0.340f; |
| primaries.fGX = 0.310f; |
| primaries.fGY = 0.595f; |
| primaries.fBX = 0.155f; |
| primaries.fBY = 0.070f; |
| primaries.fWX = 0.3127f; |
| primaries.fWY = 0.3290f; |
| break; |
| |
| case ColorSpace::PrimaryID::APPLE_GENERIC_RGB: |
| primaries.fRX = 0.63002f; |
| primaries.fRY = 0.34000f; |
| primaries.fGX = 0.29505f; |
| primaries.fGY = 0.60498f; |
| primaries.fBX = 0.15501f; |
| primaries.fBY = 0.07701f; |
| primaries.fWX = 0.3127f; |
| primaries.fWY = 0.3290f; |
| break; |
| |
| case ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN: |
| primaries.fRX = 0.01f; |
| primaries.fRY = 0.98f; |
| primaries.fGX = 0.01f; |
| primaries.fGY = 0.01f; |
| primaries.fBX = 0.98f; |
| primaries.fBY = 0.01f; |
| primaries.fWX = 0.3127f; |
| primaries.fWY = 0.3290f; |
| break; |
| |
| case ColorSpace::PrimaryID::FILM: |
| primaries.fRX = 0.681f; |
| primaries.fRY = 0.319f; |
| primaries.fGX = 0.243f; |
| primaries.fGY = 0.692f; |
| primaries.fBX = 0.145f; |
| primaries.fBY = 0.049f; |
| primaries.fWX = 0.310f; |
| primaries.fWY = 0.136f; |
| break; |
| |
| case ColorSpace::PrimaryID::BT2020: |
| primaries.fRX = 0.708f; |
| primaries.fRY = 0.292f; |
| primaries.fGX = 0.170f; |
| primaries.fGY = 0.797f; |
| primaries.fBX = 0.131f; |
| primaries.fBY = 0.046f; |
| primaries.fWX = 0.3127f; |
| primaries.fWY = 0.3290f; |
| break; |
| |
| case ColorSpace::PrimaryID::SMPTEST428_1: |
| primaries.fRX = 1.0f; |
| primaries.fRY = 0.0f; |
| primaries.fGX = 0.0f; |
| primaries.fGY = 1.0f; |
| primaries.fBX = 0.0f; |
| primaries.fBY = 0.0f; |
| primaries.fWX = 1.0f / 3.0f; |
| primaries.fWY = 1.0f / 3.0f; |
| break; |
| |
| case ColorSpace::PrimaryID::SMPTEST431_2: |
| primaries.fRX = 0.680f; |
| primaries.fRY = 0.320f; |
| primaries.fGX = 0.265f; |
| primaries.fGY = 0.690f; |
| primaries.fBX = 0.150f; |
| primaries.fBY = 0.060f; |
| primaries.fWX = 0.314f; |
| primaries.fWY = 0.351f; |
| break; |
| |
| case ColorSpace::PrimaryID::SMPTEST432_1: |
| primaries.fRX = 0.680f; |
| primaries.fRY = 0.320f; |
| primaries.fGX = 0.265f; |
| primaries.fGY = 0.690f; |
| primaries.fBX = 0.150f; |
| primaries.fBY = 0.060f; |
| primaries.fWX = 0.3127f; |
| primaries.fWY = 0.3290f; |
| break; |
| |
| case ColorSpace::PrimaryID::XYZ_D50: |
| primaries.fRX = 1.0f; |
| primaries.fRY = 0.0f; |
| primaries.fGX = 0.0f; |
| primaries.fGY = 1.0f; |
| primaries.fBX = 0.0f; |
| primaries.fBY = 0.0f; |
| primaries.fWX = 0.34567f; |
| primaries.fWY = 0.35850f; |
| break; |
| |
| case ColorSpace::PrimaryID::ADOBE_RGB: |
| primaries.fRX = 0.6400f; |
| primaries.fRY = 0.3300f; |
| primaries.fGX = 0.2100f; |
| primaries.fGY = 0.7100f; |
| primaries.fBX = 0.1500f; |
| primaries.fBY = 0.0600f; |
| primaries.fWX = 0.3127f; |
| primaries.fWY = 0.3290f; |
| break; |
| } |
| primaries.toXYZD50(to_XYZD50); |
| } |
| |
| void ColorSpace::GetPrimaryMatrix(skcms_Matrix3x3* to_XYZD50) const { |
| if (primaries_ == PrimaryID::CUSTOM) { |
| memcpy(to_XYZD50, custom_primary_matrix_, 9 * sizeof(float)); |
| } else { |
| GetPrimaryMatrix(primaries_, to_XYZD50); |
| } |
| } |
| |
| void ColorSpace::GetPrimaryMatrix(skia::Matrix44* to_XYZD50) const { |
| skcms_Matrix3x3 toXYZ_3x3; |
| GetPrimaryMatrix(&toXYZ_3x3); |
| to_XYZD50->set3x3RowMajorf(&toXYZ_3x3.vals[0][0]); |
| } |
| |
| // static |
| bool ColorSpace::GetTransferFunction(TransferID transfer, |
| skcms_TransferFunction* fn) { |
| // Default to F(x) = pow(x, 1) |
| fn->a = 1; |
| fn->b = 0; |
| fn->c = 0; |
| fn->d = 0; |
| fn->e = 0; |
| fn->f = 0; |
| fn->g = 1; |
| |
| switch (transfer) { |
| case ColorSpace::TransferID::LINEAR: |
| case ColorSpace::TransferID::LINEAR_HDR: |
| return true; |
| case ColorSpace::TransferID::GAMMA18: |
| fn->g = 1.801f; |
| return true; |
| case ColorSpace::TransferID::GAMMA22: |
| fn->g = 2.2f; |
| return true; |
| case ColorSpace::TransferID::GAMMA24: |
| fn->g = 2.4f; |
| return true; |
| case ColorSpace::TransferID::GAMMA28: |
| fn->g = 2.8f; |
| return true; |
| case ColorSpace::TransferID::SMPTE240M: |
| fn->a = 0.899626676224f; |
| fn->b = 0.100373323776f; |
| fn->c = 0.250000000000f; |
| fn->d = 0.091286342118f; |
| fn->g = 2.222222222222f; |
| return true; |
| case ColorSpace::TransferID::BT709: |
| case ColorSpace::TransferID::SMPTE170M: |
| case ColorSpace::TransferID::BT2020_10: |
| case ColorSpace::TransferID::BT2020_12: |
| // With respect to rendering BT709 |
| // * SMPTE 1886 suggests that we should be using gamma 2.4. |
| // * Most displays actually use a gamma of 2.2, and most media playing |
| // software uses the sRGB transfer function. |
| // * User studies shows that users don't really care. |
| // * Apple's CoreVideo uses gamma=1.961. |
| // Bearing all of that in mind, use the same transfer function as sRGB, |
| // which will allow more optimization, and will more closely match other |
| // media players. |
| case ColorSpace::TransferID::IEC61966_2_1: |
| case ColorSpace::TransferID::IEC61966_2_1_HDR: |
| fn->a = 0.947867345704f; |
| fn->b = 0.052132654296f; |
| fn->c = 0.077399380805f; |
| fn->d = 0.040449937172f; |
| fn->g = 2.400000000000f; |
| return true; |
| case ColorSpace::TransferID::BT709_APPLE: |
| fn->g = 1.961000000000f; |
| return true; |
| case ColorSpace::TransferID::SMPTEST428_1: |
| fn->a = 1.034080527699f; // (52.37 / 48.0) ^ (1.0 / 2.6) per ITU-T H.273. |
| fn->g = 2.600000000000f; |
| return true; |
| 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::CUSTOM: |
| case ColorSpace::TransferID::CUSTOM_HDR: |
| case ColorSpace::TransferID::PIECEWISE_HDR: |
| case ColorSpace::TransferID::INVALID: |
| break; |
| } |
| |
| return false; |
| } |
| |
| bool ColorSpace::GetTransferFunction(skcms_TransferFunction* fn) const { |
| if (transfer_ == TransferID::CUSTOM || transfer_ == TransferID::CUSTOM_HDR) { |
| fn->a = transfer_params_[0]; |
| fn->b = transfer_params_[1]; |
| fn->c = transfer_params_[2]; |
| fn->d = transfer_params_[3]; |
| fn->e = transfer_params_[4]; |
| fn->f = transfer_params_[5]; |
| fn->g = transfer_params_[6]; |
| return true; |
| } else { |
| return GetTransferFunction(transfer_, fn); |
| } |
| } |
| |
| bool ColorSpace::GetInverseTransferFunction(skcms_TransferFunction* fn) const { |
| if (!GetTransferFunction(fn)) |
| return false; |
| *fn = SkTransferFnInverse(*fn); |
| return true; |
| } |
| |
| bool ColorSpace::GetSDRWhiteLevel(float* sdr_white_level) const { |
| if (transfer_ != TransferID::SMPTEST2084 && |
| transfer_ != TransferID::ARIB_STD_B67) { |
| return false; |
| } |
| if (transfer_params_[0] == 0.0f) |
| *sdr_white_level = kDefaultSDRWhiteLevel; |
| else |
| *sdr_white_level = transfer_params_[0]; |
| return true; |
| } |
| |
| bool ColorSpace::GetPiecewiseHDRParams(float* sdr_joint, |
| float* hdr_level) const { |
| if (transfer_ != TransferID::PIECEWISE_HDR) |
| return false; |
| *sdr_joint = transfer_params_[0]; |
| *hdr_level = transfer_params_[1]; |
| return true; |
| } |
| |
| void ColorSpace::GetTransferMatrix(int bit_depth, |
| skia::Matrix44* matrix) const { |
| DCHECK_GE(bit_depth, 8); |
| // If chroma samples are real numbers in the range of −0.5 to 0.5, an offset |
| // of 0.5 is added to get real numbers in the range of 0 to 1. When |
| // represented as an unsigned |bit_depth|-bit integer, this 0.5 offset is |
| // approximated by 1 << (bit_depth - 1). chroma_0_5 is this approximate value |
| // converted to a real number in the range of 0 to 1. |
| // |
| // TODO(wtc): For now chroma_0_5 is only used for YCgCo. It should also be |
| // used for YUV. |
| const float chroma_0_5 = |
| static_cast<float>(1 << (bit_depth - 1)) / ((1 << bit_depth) - 1); |
| float Kr = 0; |
| float Kb = 0; |
| switch (matrix_) { |
| case ColorSpace::MatrixID::RGB: |
| case ColorSpace::MatrixID::INVALID: |
| matrix->setIdentity(); |
| return; |
| |
| case ColorSpace::MatrixID::BT709: |
| Kr = 0.2126f; |
| Kb = 0.0722f; |
| break; |
| |
| case ColorSpace::MatrixID::FCC: |
| Kr = 0.30f; |
| Kb = 0.11f; |
| break; |
| |
| case ColorSpace::MatrixID::BT470BG: |
| case ColorSpace::MatrixID::SMPTE170M: |
| Kr = 0.299f; |
| Kb = 0.114f; |
| break; |
| |
| case ColorSpace::MatrixID::SMPTE240M: |
| Kr = 0.212f; |
| Kb = 0.087f; |
| break; |
| |
| case ColorSpace::MatrixID::YCOCG: { |
| float data[16] = {0.25f, 0.5f, 0.25f, 0.0f, // Y |
| -0.25f, 0.5f, -0.25f, chroma_0_5, // Cg |
| 0.5f, 0.0f, -0.5f, chroma_0_5, // Co |
| 0.0f, 0.0f, 0.0f, 1.0f}; |
| matrix->setRowMajorf(data); |
| return; |
| } |
| |
| // BT2020_CL is a special case. |
| // Basically we return a matrix that transforms RYB values |
| // to YUV values. (Note that the green component have been replaced |
| // with the luminance.) |
| case ColorSpace::MatrixID::BT2020_CL: { |
| Kr = 0.2627f; |
| Kb = 0.0593f; |
| float data[16] = {1.0f, 0.0f, 0.0f, 0.0f, // R |
| Kr, 1.0f - Kr - Kb, Kb, 0.0f, // Y |
| 0.0f, 0.0f, 1.0f, 0.0f, // B |
| 0.0f, 0.0f, 0.0f, 1.0f}; |
| matrix->setRowMajorf(data); |
| return; |
| } |
| |
| case ColorSpace::MatrixID::BT2020_NCL: |
| Kr = 0.2627f; |
| Kb = 0.0593f; |
| break; |
| |
| case ColorSpace::MatrixID::YDZDX: { |
| // clang-format off |
| float data[16] = { |
| 0.0f, 1.0f, 0.0f, 0.0f, // Y |
| 0.0f, -0.5f, 0.986566f / 2.0f, 0.5f, // DX or DZ |
| 0.5f, -0.991902f / 2.0f, 0.0f, 0.5f, // DZ or DX |
| 0.0f, 0.0f, 0.0f, 1.0f, |
| }; |
| // clang-format on |
| matrix->setRowMajorf(data); |
| return; |
| } |
| case ColorSpace::MatrixID::GBR: { |
| float data[16] = {0.0f, 1.0f, 0.0f, 0.0f, // G |
| 0.0f, 0.0f, 1.0f, 0.0f, // B |
| 1.0f, 0.0f, 0.0f, 0.0f, // R |
| 0.0f, 0.0f, 0.0f, 1.0f}; |
| matrix->setRowMajorf(data); |
| return; |
| } |
| } |
| float Kg = 1.0f - Kr - Kb; |
| float u_m = 0.5f / (1.0f - Kb); |
| float v_m = 0.5f / (1.0f - Kr); |
| // clang-format off |
| float data[16] = { |
| Kr, Kg, Kb, 0.0f, // Y |
| 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, |
| }; |
| // clang-format on |
| matrix->setRowMajorf(data); |
| } |
| |
| void ColorSpace::GetRangeAdjustMatrix(int bit_depth, |
| skia::Matrix44* matrix) const { |
| DCHECK_GE(bit_depth, 8); |
| switch (range_) { |
| case RangeID::FULL: |
| case RangeID::INVALID: |
| matrix->setIdentity(); |
| return; |
| |
| case RangeID::DERIVED: |
| case RangeID::LIMITED: |
| break; |
| } |
| |
| // See ITU-T H.273 (2016), Section 8.3. The following is derived from |
| // Equations 20-31. |
| const int shift = bit_depth - 8; |
| const float a_y = 219 << shift; |
| const float c = (1 << bit_depth) - 1; |
| const float scale_y = c / a_y; |
| switch (matrix_) { |
| case MatrixID::RGB: |
| case MatrixID::GBR: |
| case MatrixID::INVALID: |
| case MatrixID::YCOCG: { |
| matrix->setScale(scale_y, scale_y, scale_y); |
| matrix->postTranslate(-16.0f / 219.0f, -16.0f / 219.0f, -16.0f / 219.0f); |
| break; |
| } |
| |
| case MatrixID::BT709: |
| case MatrixID::FCC: |
| case MatrixID::BT470BG: |
| case MatrixID::SMPTE170M: |
| case MatrixID::SMPTE240M: |
| case MatrixID::BT2020_NCL: |
| case MatrixID::BT2020_CL: |
| case MatrixID::YDZDX: { |
| const float a_uv = 224 << shift; |
| const float scale_uv = c / a_uv; |
| const float translate_uv = (a_uv - c) / (2.0f * a_uv); |
| matrix->setScale(scale_y, scale_uv, scale_uv); |
| matrix->postTranslate(-16.0f / 219.0f, translate_uv, translate_uv); |
| break; |
| } |
| } |
| } |
| |
| bool ColorSpace::ToSkYUVColorSpace(int bit_depth, SkYUVColorSpace* out) const { |
| switch (matrix_) { |
| case MatrixID::BT709: |
| *out = range_ == RangeID::FULL ? kRec709_Full_SkYUVColorSpace |
| : kRec709_Limited_SkYUVColorSpace; |
| return true; |
| |
| case MatrixID::BT470BG: |
| case MatrixID::SMPTE170M: |
| *out = range_ == RangeID::FULL ? kJPEG_SkYUVColorSpace |
| : kRec601_Limited_SkYUVColorSpace; |
| return true; |
| |
| case MatrixID::BT2020_NCL: |
| if (bit_depth == 8) { |
| *out = range_ == RangeID::FULL ? kBT2020_8bit_Full_SkYUVColorSpace |
| : kBT2020_8bit_Limited_SkYUVColorSpace; |
| return true; |
| } |
| if (bit_depth == 10) { |
| *out = range_ == RangeID::FULL ? kBT2020_10bit_Full_SkYUVColorSpace |
| : kBT2020_10bit_Limited_SkYUVColorSpace; |
| return true; |
| } |
| if (bit_depth == 12) { |
| *out = range_ == RangeID::FULL ? kBT2020_12bit_Full_SkYUVColorSpace |
| : kBT2020_12bit_Limited_SkYUVColorSpace; |
| return true; |
| } |
| return false; |
| |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| std::ostream& operator<<(std::ostream& out, const ColorSpace& color_space) { |
| return out << color_space.ToString(); |
| } |
| |
| } // namespace gfx |
