Video Color Managament

media/base/video_color_space_unittest.cc

+// Copyright (c) 2016 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 "media/base/video_color_space.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+VideoColorSpace::PrimaryID all_primaries[] = {
+    VideoColorSpace::PRI_BT709,        VideoColorSpace::PRI_BT470M,
+    VideoColorSpace::PRI_BT470BG,      VideoColorSpace::PRI_SMPTE170M,
+    VideoColorSpace::PRI_SMPTE240M,    VideoColorSpace::PRI_FILM,
+    VideoColorSpace::PRI_BT2020,       VideoColorSpace::PRI_SMPTEST428_1,
+    VideoColorSpace::PRI_SMPTEST431_2, VideoColorSpace::PRI_SMPTEST432_1,
+};
+
+VideoColorSpace::TransferID all_transfers[] = {
+    VideoColorSpace::TRC_BT709,        VideoColorSpace::TRC_GAMMA22,
+    VideoColorSpace::TRC_GAMMA28,      VideoColorSpace::TRC_SMPTE170M,
+    VideoColorSpace::TRC_SMPTE240M,    VideoColorSpace::TRC_LINEAR,
+    VideoColorSpace::TRC_LOG,          VideoColorSpace::TRC_LOG_SQRT,
+    VideoColorSpace::TRC_IEC61966_2_4, VideoColorSpace::TRC_BT1361_ECG,
+    VideoColorSpace::TRC_IEC61966_2_1, VideoColorSpace::TRC_BT2020_10,
+    VideoColorSpace::TRC_BT2020_12,    VideoColorSpace::TRC_SMPTEST2084,
+
+    // This one is weird as the non-linear numbers are not between 0 and 1.
+    // TODO(hubbe): Test this separately.
+    //  VideoColorSpace::TRC_SMPTEST428_1,
+};
+
+VideoColorSpace::MatrixID all_matrices[] = {
+    VideoColorSpace::SPC_RGB, VideoColorSpace::SPC_BT709,
+    VideoColorSpace::SPC_UNSPECIFIED, VideoColorSpace::SPC_RESERVED,
+    VideoColorSpace::SPC_FCC, VideoColorSpace::SPC_BT470BG,
+    VideoColorSpace::SPC_SMPTE170M, VideoColorSpace::SPC_SMPTE240M,
+
+    // YCOCG produces lots of negative values which isn't compatible with many
+    // transfer functions.
+    // TODO(hubbe): Test this separately.
+    // VideoColorSpace::SPC_YCOCG,
+    VideoColorSpace::SPC_BT2020_NCL, VideoColorSpace::SPC_BT2020_CL,
+    VideoColorSpace::SPC_YDZDX,
+};
+
+TEST(SimpleVideoColorSpace, BT709toSRGB) {
+  VideoColorSpace bt709(COLOR_SPACE_HD_REC709);
+  VideoColorSpace sRGB = VideoColorSpace::SRGB();
+  ColorTransform t(bt709, sRGB, ColorTransform::INTENT_ABSOLUTE);
+
+  VideoColorSpace::TriStim tmp(16.0f / 255.0f, 0.5f, 0.5f);
+  t.transform(&tmp, 1);
+  EXPECT_NEAR(tmp.values[0], 0.0f, 0.001f);
+  EXPECT_NEAR(tmp.values[1], 0.0f, 0.001f);
+  EXPECT_NEAR(tmp.values[2], 0.0f, 0.001f);
+
+  tmp = VideoColorSpace::TriStim(235.0f / 255.0f, 0.5f, 0.5f);
+  t.transform(&tmp, 1);
+  EXPECT_NEAR(tmp.values[0], 1.0f, 0.001f);
+  EXPECT_NEAR(tmp.values[1], 1.0f, 0.001f);
+  EXPECT_NEAR(tmp.values[2], 1.0f, 0.001f);
+
+  // Test a blue color
+  tmp = VideoColorSpace::TriStim(128.0f / 255.0f, 240.0f / 255.0f, 0.5f);
+  t.transform(&tmp, 1);
+  EXPECT_GT(tmp.values[2], tmp.values[0]);
+  EXPECT_GT(tmp.values[2], tmp.values[1]);
+}
+
+TEST(SimpleVideoColorSpace, UnknownToSRGB) {
+  VideoColorSpace unknown;
+  VideoColorSpace sRGB = VideoColorSpace::SRGB();
+  ColorTransform t(unknown, sRGB, ColorTransform::INTENT_PERCEIVED);
+
+  VideoColorSpace::TriStim tmp(16.0f / 255.0f, 0.5f, 0.5f);
+  t.transform(&tmp, 1);
+  EXPECT_NEAR(tmp.values[0], 0.0f, 0.001f);
+  EXPECT_NEAR(tmp.values[1], 0.0f, 0.001f);
+  EXPECT_NEAR(tmp.values[2], 0.0f, 0.001f);
+
+  tmp = VideoColorSpace::TriStim(235.0f / 255.0f, 0.5f, 0.5f);
+  t.transform(&tmp, 1);
+  EXPECT_NEAR(tmp.values[0], 1.0f, 0.001f);
+  EXPECT_NEAR(tmp.values[1], 1.0f, 0.001f);
+  EXPECT_NEAR(tmp.values[2], 1.0f, 0.001f);
+
+  // Test a blue color
+  tmp = VideoColorSpace::TriStim(128.0f / 255.0f, 240.0f / 255.0f, 0.5f);
+  t.transform(&tmp, 1);
+  EXPECT_GT(tmp.values[2], tmp.values[0]);
+  EXPECT_GT(tmp.values[2], tmp.values[1]);
+}
+
+class PrimaryTest : public testing::TestWithParam<VideoColorSpace::PrimaryID> {
+};
+
+TEST_P(PrimaryTest, checkInvertible) {
+  EXPECT_EQ(VideoColorSpace::GetPrimaryMatrix(GetParam()).rows[3][3], 1.0f);
+  // Check that all primary matrices are invertable.
+  EXPECT_EQ(
+      VideoColorSpace::Invert(VideoColorSpace::GetPrimaryMatrix(GetParam()))
+          .rows[3][3],
+      1.0f);
+};
+
+INSTANTIATE_TEST_CASE_P(VideoColorSpace,
+                        PrimaryTest,
+                        testing::ValuesIn(all_primaries));
+
+class MatrixTest : public testing::TestWithParam<VideoColorSpace::MatrixID> {};
+
+TEST_P(MatrixTest, checkInvertible) {
+  EXPECT_EQ(VideoColorSpace::GetTransferMatrix(GetParam()).rows[3][3], 1.0f);
+  // Check that all transfer matrices are invertable.
+  EXPECT_EQ(
+      VideoColorSpace::Invert(VideoColorSpace::GetTransferMatrix(GetParam()))
+          .rows[3][3],
+      1.0f);
+};
+
+INSTANTIATE_TEST_CASE_P(VideoColorSpace,
+                        MatrixTest,
+                        testing::ValuesIn(all_matrices));
+
+class TransferTest
+    : public testing::TestWithParam<VideoColorSpace::TransferID> {};
+
+TEST_P(TransferTest, basicTest) {
+  for (float x = 0.0; x <= 1.0; x += 1.0f / 128.0f) {
+    float linear = VideoColorSpace::toLinear(GetParam(), x);
+    float x2 = VideoColorSpace::fromLinear(GetParam(), linear);
+    EXPECT_NEAR(x, x2, 0.001);
+  }
+}
+
+INSTANTIATE_TEST_CASE_P(VideoColorSpace,
+                        TransferTest,
+                        testing::ValuesIn(all_transfers));
+
+typedef std::tr1::tuple<VideoColorSpace::PrimaryID,
+                        VideoColorSpace::TransferID,
+                        VideoColorSpace::MatrixID,
+                        bool>
+    VideoColorSpaceTestData;
+class VideoColorSpaceTest
+    : public testing::TestWithParam<VideoColorSpaceTestData> {
+ public:
+  VideoColorSpaceTest()
+      : color_space_(std::tr1::get<0>(GetParam()),
+                     std::tr1::get<1>(GetParam()),
+                     std::tr1::get<2>(GetParam()),
+                     std::tr1::get<3>(GetParam())) {}
+
+ protected:
+  VideoColorSpace color_space_;
+};
+
+TEST_P(VideoColorSpaceTest, testGetters) {
+  EXPECT_EQ(color_space_.GetPrimaries().size(), 4u);
+  EXPECT_NE(color_space_.GetPrimaryMatrix().rows[0][0], -10.0f);
+  EXPECT_NE(color_space_.toLinear(0.0), -1.0f);
+  EXPECT_NE(color_space_.fromLinear(0.0), -1.0f);
+}
+
+TEST_P(VideoColorSpaceTest, testNullTransform) {
+  ColorTransform t(color_space_, color_space_, ColorTransform::INTENT_ABSOLUTE);
+  VideoColorSpace::TriStim tristim(0.4, 0.5, 0.6);
+  t.transform(&tristim, 1);
+  EXPECT_NEAR(tristim.values[0], 0.4, 0.001);
+  EXPECT_NEAR(tristim.values[1], 0.5, 0.001);
+  EXPECT_NEAR(tristim.values[2], 0.6, 0.001);
+}
+
+TEST_P(VideoColorSpaceTest, toXYZandBack) {
+  ColorTransform t1(color_space_, VideoColorSpace::XYZ(),
+                    ColorTransform::INTENT_ABSOLUTE);
+  ColorTransform t2(VideoColorSpace::XYZ(), color_space_,
+                    ColorTransform::INTENT_ABSOLUTE);
+  VideoColorSpace::TriStim tristim(0.4, 0.5, 0.6);
+  t1.transform(&tristim, 1);
+  t2.transform(&tristim, 1);
+  EXPECT_NEAR(tristim.values[0], 0.4, 0.001);
+  EXPECT_NEAR(tristim.values[1], 0.5, 0.001);
+  EXPECT_NEAR(tristim.values[2], 0.6, 0.001);
+}
+
+INSTANTIATE_TEST_CASE_P(
+    A,
+    VideoColorSpaceTest,
+    testing::Combine(testing::ValuesIn(all_primaries),
+                     testing::ValuesIn(all_transfers),
+                     testing::Values(VideoColorSpace::SPC_BT709),
+                     testing::Values(false)));
+
+INSTANTIATE_TEST_CASE_P(
+    B,
+    VideoColorSpaceTest,
+    testing::Combine(testing::Values(VideoColorSpace::PRI_BT709),
+                     testing::ValuesIn(all_transfers),
+                     testing::ValuesIn(all_matrices),
+                     testing::Values(true, false)));
+
+INSTANTIATE_TEST_CASE_P(
+    C,
+    VideoColorSpaceTest,
+    testing::Combine(testing::ValuesIn(all_primaries),
+                     testing::Values(VideoColorSpace::TRC_BT709),
+                     testing::ValuesIn(all_matrices),
+                     testing::Values(true, false)));
+
+}  // namespace