VideoDecoderConfig constructor now takes VideoColorSpace

Change-Id: I8ef53be026771a2c0674b6e5cce522b9dce05190
Reviewed-on: https://chromium-review.googlesource.com/c/1309214
Reviewed-by: Bill Budge <bbudge@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Frank Liberato <liberato@chromium.org>
Commit-Queue: Fredrik Hubinette <hubbe@chromium.org>
Cr-Commit-Position: refs/heads/master@{#605083}

chromecast/media/cma/base/demuxer_stream_for_test.cc

@@ -57,7 +57,7 @@ ::media::VideoDecoderConfig DemuxerStreamForTest::video_decoder_config() {
   gfx::Size natural_size(640, 480);
   return ::media::VideoDecoderConfig(
       ::media::kCodecH264, ::media::VIDEO_CODEC_PROFILE_UNKNOWN,
-      ::media::PIXEL_FORMAT_YV12, ::media::COLOR_SPACE_UNSPECIFIED,
+      ::media::PIXEL_FORMAT_YV12, ::media::VideoColorSpace(),
       ::media::VIDEO_ROTATION_0, coded_size, visible_rect, natural_size,
       ::media::EmptyExtraData(), ::media::Unencrypted());
 }

chromecast/media/cma/pipeline/audio_video_pipeline_impl_unittest.cc

@@ -153,7 +153,7 @@ class PipelineHelper {
       std::vector<::media::VideoDecoderConfig> video_configs;
       video_configs.push_back(::media::VideoDecoderConfig(
           ::media::kCodecH264, ::media::H264PROFILE_MAIN,
-          ::media::PIXEL_FORMAT_I420, ::media::COLOR_SPACE_UNSPECIFIED,
+          ::media::PIXEL_FORMAT_I420, ::media::VideoColorSpace(),
           ::media::VIDEO_ROTATION_0, gfx::Size(640, 480),
           gfx::Rect(0, 0, 640, 480), gfx::Size(640, 480),
           ::media::EmptyExtraData(), ::media::EncryptionScheme()));

chromecast/media/cma/test/mock_frame_provider.cc

@@ -81,7 +81,7 @@ void MockFrameProvider::DoRead(const ReadCB& read_cb) {
     gfx::Size natural_size(640, 480);
     video_config = ::media::VideoDecoderConfig(
         ::media::kCodecH264, ::media::VIDEO_CODEC_PROFILE_UNKNOWN,
-        ::media::PIXEL_FORMAT_YV12, ::media::COLOR_SPACE_UNSPECIFIED,
+        ::media::PIXEL_FORMAT_YV12, ::media::VideoColorSpace(),
         ::media::VIDEO_ROTATION_0, coded_size, visible_rect, natural_size,
         ::media::EmptyExtraData(), ::media::Unencrypted());
 

content/renderer/media/webrtc/rtc_video_decoder_adapter.cc

@@ -297,7 +297,7 @@ void RTCVideoDecoderAdapter::InitializeOnMediaThread(
   media::VideoDecoderConfig config(
       ToVideoCodec(video_codec_type_),
       GuessVideoCodecProfile(video_codec_type_), kDefaultPixelFormat,
-      media::COLOR_SPACE_UNSPECIFIED, media::VIDEO_ROTATION_0, kDefaultSize,
+      media::VideoColorSpace(), media::VIDEO_ROTATION_0, kDefaultSize,
       gfx::Rect(kDefaultSize), kDefaultSize, media::EmptyExtraData(),
       media::Unencrypted());
 

content/renderer/pepper/video_decoder_shim.cc

@@ -892,7 +892,7 @@ bool VideoDecoderShim::Initialize(const Config& vda_config, Client* client) {
 
   media::VideoDecoderConfig video_decoder_config(
       codec, vda_config.profile, media::PIXEL_FORMAT_I420,
-      media::COLOR_SPACE_UNSPECIFIED, media::VIDEO_ROTATION_0,
+      media::VideoColorSpace(), media::VIDEO_ROTATION_0,
       gfx::Size(32, 24),  // Small sizes that won't fail.
       gfx::Rect(32, 24), gfx::Size(32, 24),
       // TODO(bbudge): Verify extra data isn't needed.

media/base/fake_demuxer_stream.cc

@@ -158,7 +158,7 @@ void FakeDemuxerStream::UpdateVideoDecoderConfig() {
   const gfx::Rect kVisibleRect(kStartWidth, kStartHeight);
   video_decoder_config_.Initialize(
       kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, PIXEL_FORMAT_I420,
-      COLOR_SPACE_UNSPECIFIED, VIDEO_ROTATION_0, next_coded_size_, kVisibleRect,
+      VideoColorSpace(), VIDEO_ROTATION_0, next_coded_size_, kVisibleRect,
       next_coded_size_, EmptyExtraData(),
       is_encrypted_ ? AesCtrEncryptionScheme() : Unencrypted());
   next_coded_size_.Enlarge(kWidthDelta, kHeightDelta);

media/base/test_helpers.cc

@@ -127,14 +127,15 @@ void WaitableMessageLoopEvent::OnTimeout() {
 
 static VideoDecoderConfig GetTestConfig(VideoCodec codec,
                                         VideoCodecProfile config,
+                                        const VideoColorSpace& color_space,
                                         VideoRotation rotation,
                                         gfx::Size coded_size,
                                         bool is_encrypted) {
   gfx::Rect visible_rect(coded_size.width(), coded_size.height());
   gfx::Size natural_size = coded_size;
 
   return VideoDecoderConfig(
-      codec, config, PIXEL_FORMAT_I420, COLOR_SPACE_JPEG, rotation, coded_size,
+      codec, config, PIXEL_FORMAT_I420, color_space, rotation, coded_size,
       visible_rect, natural_size, EmptyExtraData(),
       is_encrypted ? AesCtrEncryptionScheme() : Unencrypted());
 }
@@ -145,50 +146,64 @@ static const gfx::Size kLargeSize(640, 480);
 // static
 VideoDecoderConfig TestVideoConfig::Invalid() {
   return GetTestConfig(kUnknownVideoCodec, VIDEO_CODEC_PROFILE_UNKNOWN,
-                       VIDEO_ROTATION_0, kNormalSize, false);
+                       VideoColorSpace::JPEG(), VIDEO_ROTATION_0, kNormalSize,
+                       false);
 }
 
 // static
 VideoDecoderConfig TestVideoConfig::Normal(VideoCodec codec) {
-  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN, VIDEO_ROTATION_0,
-                       kNormalSize, false);
+  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN,
+                       VideoColorSpace::JPEG(), VIDEO_ROTATION_0, kNormalSize,
+                       false);
+}
+
+// static
+VideoDecoderConfig TestVideoConfig::NormalWithColorSpace(
+    VideoCodec codec,
+    const VideoColorSpace& color_space) {
+  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN, color_space,
+                       VIDEO_ROTATION_0, kNormalSize, false);
 }
 
 // static
 VideoDecoderConfig TestVideoConfig::NormalH264(VideoCodecProfile config) {
-  return GetTestConfig(kCodecH264, config, VIDEO_ROTATION_0, kNormalSize,
-                       false);
+  return GetTestConfig(kCodecH264, config, VideoColorSpace::JPEG(),
+                       VIDEO_ROTATION_0, kNormalSize, false);
 }
 
 // static
 VideoDecoderConfig TestVideoConfig::NormalCodecProfile(
     VideoCodec codec,
     VideoCodecProfile profile) {
-  return GetTestConfig(codec, profile, VIDEO_ROTATION_0, kNormalSize, false);
+  return GetTestConfig(codec, profile, VideoColorSpace::JPEG(),
+                       VIDEO_ROTATION_0, kNormalSize, false);
 }
 
 // static
 VideoDecoderConfig TestVideoConfig::NormalEncrypted(VideoCodec codec) {
-  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN, VIDEO_ROTATION_0,
-                       kNormalSize, true);
+  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN,
+                       VideoColorSpace::JPEG(), VIDEO_ROTATION_0, kNormalSize,
+                       true);
 }
 
 // static
 VideoDecoderConfig TestVideoConfig::NormalRotated(VideoRotation rotation) {
-  return GetTestConfig(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, rotation,
-                       kNormalSize, false);
+  return GetTestConfig(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
+                       VideoColorSpace::JPEG(), rotation, kNormalSize, false);
 }
 
 // static
 VideoDecoderConfig TestVideoConfig::Large(VideoCodec codec) {
-  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN, VIDEO_ROTATION_0,
-                       kLargeSize, false);
+  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN,
+                       VideoColorSpace::JPEG(), VIDEO_ROTATION_0, kLargeSize,
+                       false);
 }
 
 // static
 VideoDecoderConfig TestVideoConfig::LargeEncrypted(VideoCodec codec) {
-  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN, VIDEO_ROTATION_0,
-                       kLargeSize, true);
+  return GetTestConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN,
+                       VideoColorSpace::JPEG(), VIDEO_ROTATION_0, kLargeSize,
+                       true);
 }
 
 // static

media/base/test_helpers.h

@@ -88,6 +88,9 @@ class TestVideoConfig {
   static VideoDecoderConfig Invalid();
 
   static VideoDecoderConfig Normal(VideoCodec codec = kCodecVP8);
+  static VideoDecoderConfig NormalWithColorSpace(
+      VideoCodec codec,
+      const VideoColorSpace& color_space);
   static VideoDecoderConfig NormalH264(
       VideoCodecProfile = VIDEO_CODEC_PROFILE_UNKNOWN);
   static VideoDecoderConfig NormalCodecProfile(

media/base/video_decoder_config.cc

@@ -67,7 +67,7 @@ VideoDecoderConfig::VideoDecoderConfig(
     VideoCodec codec,
     VideoCodecProfile profile,
     VideoPixelFormat format,
-    ColorSpace color_space,
+    const VideoColorSpace& color_space,
     VideoRotation rotation,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
@@ -83,11 +83,6 @@ VideoDecoderConfig::VideoDecoderConfig(const VideoDecoderConfig& other) =
 
 VideoDecoderConfig::~VideoDecoderConfig() = default;
 
-void VideoDecoderConfig::set_color_space_info(
-    const VideoColorSpace& color_space_info) {
-  color_space_info_ = color_space_info;
-}
-
 const VideoColorSpace& VideoDecoderConfig::color_space_info() const {
   return color_space_info_;
 }
@@ -103,7 +98,7 @@ const base::Optional<HDRMetadata>& VideoDecoderConfig::hdr_metadata() const {
 void VideoDecoderConfig::Initialize(VideoCodec codec,
                                     VideoCodecProfile profile,
                                     VideoPixelFormat format,
-                                    ColorSpace color_space,
+                                    const VideoColorSpace& color_space,
                                     VideoRotation rotation,
                                     const gfx::Size& coded_size,
                                     const gfx::Rect& visible_rect,
@@ -119,21 +114,7 @@ void VideoDecoderConfig::Initialize(VideoCodec codec,
   natural_size_ = natural_size;
   extra_data_ = extra_data;
   encryption_scheme_ = encryption_scheme;
-
-  switch (color_space) {
-    case ColorSpace::COLOR_SPACE_JPEG:
-      color_space_info_ = VideoColorSpace::JPEG();
-      break;
-    case ColorSpace::COLOR_SPACE_HD_REC709:
-      color_space_info_ = VideoColorSpace::REC709();
-      break;
-    case ColorSpace::COLOR_SPACE_SD_REC601:
-      color_space_info_ = VideoColorSpace::REC601();
-      break;
-    case ColorSpace::COLOR_SPACE_UNSPECIFIED:
-    default:
-      break;
-  }
+  color_space_info_ = color_space;
 }
 
 bool VideoDecoderConfig::IsValidConfig() const {

media/base/video_decoder_config.h

@@ -38,7 +38,7 @@ class MEDIA_EXPORT VideoDecoderConfig {
   VideoDecoderConfig(VideoCodec codec,
                      VideoCodecProfile profile,
                      VideoPixelFormat format,
-                     ColorSpace color_space,
+                     const VideoColorSpace& color_space,
                      VideoRotation rotation,
                      const gfx::Size& coded_size,
                      const gfx::Rect& visible_rect,
@@ -54,7 +54,7 @@ class MEDIA_EXPORT VideoDecoderConfig {
   void Initialize(VideoCodec codec,
                   VideoCodecProfile profile,
                   VideoPixelFormat format,
-                  ColorSpace color_space,
+                  const VideoColorSpace& color_space,
                   VideoRotation rotation,
                   const gfx::Size& coded_size,
                   const gfx::Rect& visible_rect,
@@ -118,7 +118,6 @@ class MEDIA_EXPORT VideoDecoderConfig {
     return encryption_scheme_;
   }
 
-  void set_color_space_info(const VideoColorSpace& color_space_info);
   const VideoColorSpace& color_space_info() const;
 
   void set_hdr_metadata(const HDRMetadata& hdr_metadata);

media/base/video_decoder_config_unittest.cc

@@ -17,7 +17,7 @@ static const gfx::Size kNaturalSize(320, 240);
 
 TEST(VideoDecoderConfigTest, Invalid_UnsupportedPixelFormat) {
   VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
-                            PIXEL_FORMAT_UNKNOWN, COLOR_SPACE_UNSPECIFIED,
+                            PIXEL_FORMAT_UNKNOWN, VideoColorSpace(),
                             VIDEO_ROTATION_0, kCodedSize, kVisibleRect,
                             kNaturalSize, EmptyExtraData(), Unencrypted());
   EXPECT_FALSE(config.IsValidConfig());
@@ -26,36 +26,36 @@ TEST(VideoDecoderConfigTest, Invalid_UnsupportedPixelFormat) {
 TEST(VideoDecoderConfigTest, Invalid_AspectRatioNumeratorZero) {
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), 0, 1);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, kVideoFormat,
-                            COLOR_SPACE_UNSPECIFIED, VIDEO_ROTATION_0,
-                            kCodedSize, kVisibleRect, natural_size,
-                            EmptyExtraData(), Unencrypted());
+                            VideoColorSpace(), VIDEO_ROTATION_0, kCodedSize,
+                            kVisibleRect, natural_size, EmptyExtraData(),
+                            Unencrypted());
   EXPECT_FALSE(config.IsValidConfig());
 }
 
 TEST(VideoDecoderConfigTest, Invalid_AspectRatioDenominatorZero) {
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), 1, 0);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, kVideoFormat,
-                            COLOR_SPACE_UNSPECIFIED, VIDEO_ROTATION_0,
-                            kCodedSize, kVisibleRect, natural_size,
-                            EmptyExtraData(), Unencrypted());
+                            VideoColorSpace(), VIDEO_ROTATION_0, kCodedSize,
+                            kVisibleRect, natural_size, EmptyExtraData(),
+                            Unencrypted());
   EXPECT_FALSE(config.IsValidConfig());
 }
 
 TEST(VideoDecoderConfigTest, Invalid_AspectRatioNumeratorNegative) {
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), -1, 1);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, kVideoFormat,
-                            COLOR_SPACE_UNSPECIFIED, VIDEO_ROTATION_0,
-                            kCodedSize, kVisibleRect, natural_size,
-                            EmptyExtraData(), Unencrypted());
+                            VideoColorSpace(), VIDEO_ROTATION_0, kCodedSize,
+                            kVisibleRect, natural_size, EmptyExtraData(),
+                            Unencrypted());
   EXPECT_FALSE(config.IsValidConfig());
 }
 
 TEST(VideoDecoderConfigTest, Invalid_AspectRatioDenominatorNegative) {
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), 1, -1);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, kVideoFormat,
-                            COLOR_SPACE_UNSPECIFIED, VIDEO_ROTATION_0,
-                            kCodedSize, kVisibleRect, natural_size,
-                            EmptyExtraData(), Unencrypted());
+                            VideoColorSpace(), VIDEO_ROTATION_0, kCodedSize,
+                            kVisibleRect, natural_size, EmptyExtraData(),
+                            Unencrypted());
   EXPECT_FALSE(config.IsValidConfig());
 }
 
@@ -64,9 +64,9 @@ TEST(VideoDecoderConfigTest, Invalid_AspectRatioNumeratorTooLarge) {
   int num = ceil(static_cast<double>(limits::kMaxDimension + 1) / width);
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), num, 1);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, kVideoFormat,
-                            COLOR_SPACE_UNSPECIFIED, VIDEO_ROTATION_0,
-                            kCodedSize, kVisibleRect, natural_size,
-                            EmptyExtraData(), Unencrypted());
+                            VideoColorSpace(), VIDEO_ROTATION_0, kCodedSize,
+                            kVisibleRect, natural_size, EmptyExtraData(),
+                            Unencrypted());
   EXPECT_FALSE(config.IsValidConfig());
 }
 
@@ -78,9 +78,9 @@ TEST(VideoDecoderConfigTest, Invalid_AspectRatioDenominatorVeryLarge) {
   EXPECT_EQ(320, natural_size.width());
   EXPECT_EQ(240 * 641, natural_size.height());
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, kVideoFormat,
-                            COLOR_SPACE_UNSPECIFIED, VIDEO_ROTATION_0,
-                            kCodedSize, kVisibleRect, natural_size,
-                            EmptyExtraData(), Unencrypted());
+                            VideoColorSpace(), VIDEO_ROTATION_0, kCodedSize,
+                            kVisibleRect, natural_size, EmptyExtraData(),
+                            Unencrypted());
   EXPECT_FALSE(config.IsValidConfig());
 }
 

media/base/video_thumbnail_decoder_unittest.cc

@@ -33,7 +33,7 @@ class VideoThumbnailDecoderTest : public testing::Test {
     auto mock_video_decoder = std::make_unique<MockVideoDecoder>();
     mock_video_decoder_ = mock_video_decoder.get();
     VideoDecoderConfig valid_config(
-        kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_I420, COLOR_SPACE_UNSPECIFIED,
+        kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_I420, VideoColorSpace(),
         VIDEO_ROTATION_0, gfx::Size(1, 1), gfx::Rect(1, 1), gfx::Size(1, 1),
         EmptyExtraData(), Unencrypted());
 

media/blink/video_decode_stats_reporter_unittest.cc

@@ -41,9 +41,10 @@ VideoDecoderConfig MakeVideoConfig(VideoCodec codec,
                                    gfx::Size natural_size) {
   gfx::Size coded_size = natural_size;
   gfx::Rect visible_rect(coded_size.width(), coded_size.height());
-  return VideoDecoderConfig(codec, profile, PIXEL_FORMAT_I420, COLOR_SPACE_JPEG,
-                            VIDEO_ROTATION_0, coded_size, visible_rect,
-                            natural_size, EmptyExtraData(), Unencrypted());
+  return VideoDecoderConfig(codec, profile, PIXEL_FORMAT_I420,
+                            VideoColorSpace::JPEG(), VIDEO_ROTATION_0,
+                            coded_size, visible_rect, natural_size,
+                            EmptyExtraData(), Unencrypted());
 }
 
 VideoDecoderConfig MakeDefaultVideoConfig() {

media/cast/sender/h264_vt_encoder_unittest.cc

@@ -303,7 +303,7 @@ TEST_F(H264VideoToolboxEncoderTest, DISABLED_CheckFrameMetadataSequence) {
 // Failed on mac_chromium_rel_ng trybot. http://crbug.com/627260
 TEST_F(H264VideoToolboxEncoderTest, DISABLED_CheckFramesAreDecodable) {
   VideoDecoderConfig config(
-      kCodecH264, H264PROFILE_MAIN, frame_->format(), COLOR_SPACE_UNSPECIFIED,
+      kCodecH264, H264PROFILE_MAIN, frame_->format(), VideoColorSpace(),
       VIDEO_ROTATION_0, frame_->coded_size(), frame_->visible_rect(),
       frame_->natural_size(), EmptyExtraData(), Unencrypted());
   scoped_refptr<EndToEndFrameChecker> checker(new EndToEndFrameChecker(config));

media/cdm/library_cdm/clear_key_cdm/cdm_video_decoder.cc

@@ -50,15 +50,13 @@ media::VideoDecoderConfig ToClearMediaVideoDecoderConfig(
 
   VideoDecoderConfig media_config(
       ToMediaVideoCodec(config.codec), ToMediaVideoCodecProfile(config.profile),
-      ToMediaVideoFormat(config.format), COLOR_SPACE_UNSPECIFIED,
+      ToMediaVideoFormat(config.format), ToMediaColorSpace(config.color_space),
       VideoRotation::VIDEO_ROTATION_0, coded_size, gfx::Rect(coded_size),
       coded_size,
       std::vector<uint8_t>(config.extra_data,
                            config.extra_data + config.extra_data_size),
       Unencrypted());
 
-  media_config.set_color_space_info(ToMediaColorSpace(config.color_space));
-
   return media_config;
 }
 

media/ffmpeg/ffmpeg_common.cc

@@ -589,10 +589,9 @@ bool AVStreamToVideoDecoderConfig(const AVStream* stream,
     extra_data.assign(codec_context->extradata,
                       codec_context->extradata + codec_context->extradata_size);
   }
-  config->Initialize(codec, profile, format, COLOR_SPACE_UNSPECIFIED,
-                     video_rotation, coded_size, visible_rect, natural_size,
-                     extra_data, GetEncryptionScheme(stream));
-  config->set_color_space_info(color_space);
+  config->Initialize(codec, profile, format, color_space, video_rotation,
+                     coded_size, visible_rect, natural_size, extra_data,
+                     GetEncryptionScheme(stream));
   return true;
 }
 

media/filters/ffmpeg_video_decoder_unittest.cc

@@ -227,9 +227,9 @@ TEST_F(FFmpegVideoDecoderTest, Initialize_Normal) {
 TEST_F(FFmpegVideoDecoderTest, Initialize_OpenDecoderFails) {
   // Specify Theora w/o extra data so that avcodec_open2() fails.
   VideoDecoderConfig config(kCodecTheora, VIDEO_CODEC_PROFILE_UNKNOWN,
-                            kVideoFormat, COLOR_SPACE_UNSPECIFIED,
-                            VIDEO_ROTATION_0, kCodedSize, kVisibleRect,
-                            kNaturalSize, EmptyExtraData(), Unencrypted());
+                            kVideoFormat, VideoColorSpace(), VIDEO_ROTATION_0,
+                            kCodedSize, kVisibleRect, kNaturalSize,
+                            EmptyExtraData(), Unencrypted());
   InitializeWithConfigWithResult(config, false);
 }