From 143cec1cc68b9ba44f3ef4467f1422704f2395f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Spr=C3=A5ng?= Date: Tue, 28 Apr 2015 10:01:41 +0200 Subject: [PATCH] Set correct encoder-specific settings for vpx in the new API. Also, make VideoEncoderConfig::ContentType an enum class. BUG=4569 R=mflodman@webrtc.org, pbos@webrtc.org Review URL: https://webrtc-codereview.appspot.com/46069004 Cr-Commit-Position: refs/heads/master@{#9093} --- talk/media/webrtc/fakewebrtccall.cc | 25 ++- talk/media/webrtc/fakewebrtccall.h | 6 +- talk/media/webrtc/simulcast.cc | 1 + talk/media/webrtc/webrtcvideoengine2.cc | 37 +++- talk/media/webrtc/webrtcvideoengine2.h | 3 +- .../webrtc/webrtcvideoengine2_unittest.cc | 169 ++++++++++++++++-- webrtc/config.cc | 9 +- webrtc/config.h | 4 +- .../video_coding/codecs/vp8/vp8_impl.cc | 2 +- webrtc/video/full_stack.cc | 2 +- webrtc/video/screenshare_loopback.cc | 2 +- webrtc/video/video_send_stream.cc | 4 +- webrtc/video/video_send_stream_tests.cc | 4 +- 13 files changed, 228 insertions(+), 40 deletions(-) diff --git a/talk/media/webrtc/fakewebrtccall.cc b/talk/media/webrtc/fakewebrtccall.cc index 0a34aadde9..ade4028193 100644 --- a/talk/media/webrtc/fakewebrtccall.cc +++ b/talk/media/webrtc/fakewebrtccall.cc @@ -64,7 +64,17 @@ bool FakeVideoSendStream::GetVp8Settings( return false; } - *settings = vp8_settings_; + *settings = vpx_settings_.vp8; + return true; +} + +bool FakeVideoSendStream::GetVp9Settings( + webrtc::VideoCodecVP9* settings) const { + if (!codec_settings_set_) { + return false; + } + + *settings = vpx_settings_.vp9; return true; } @@ -99,9 +109,16 @@ bool FakeVideoSendStream::ReconfigureVideoEncoder( const webrtc::VideoEncoderConfig& config) { encoder_config_ = config; if (config.encoder_specific_settings != NULL) { - assert(config_.encoder_settings.payload_name == "VP8"); - vp8_settings_ = *reinterpret_cast( - config.encoder_specific_settings); + if (config_.encoder_settings.payload_name == "VP8") { + vpx_settings_.vp8 = *reinterpret_cast( + config.encoder_specific_settings); + } else if (config_.encoder_settings.payload_name == "VP9") { + vpx_settings_.vp9 = *reinterpret_cast( + config.encoder_specific_settings); + } else { + ADD_FAILURE() << "Unsupported encoder payload: " + << config_.encoder_settings.payload_name; + } } codec_settings_set_ = config.encoder_specific_settings != NULL; return true; diff --git a/talk/media/webrtc/fakewebrtccall.h b/talk/media/webrtc/fakewebrtccall.h index 4a1b90df20..c02bf4f34f 100644 --- a/talk/media/webrtc/fakewebrtccall.h +++ b/talk/media/webrtc/fakewebrtccall.h @@ -47,6 +47,7 @@ class FakeVideoSendStream : public webrtc::VideoSendStream, bool IsSending() const; bool GetVp8Settings(webrtc::VideoCodecVP8* settings) const; + bool GetVp9Settings(webrtc::VideoCodecVP9* settings) const; int GetNumberOfSwappedFrames() const; int GetLastWidth() const; @@ -69,7 +70,10 @@ class FakeVideoSendStream : public webrtc::VideoSendStream, webrtc::VideoSendStream::Config config_; webrtc::VideoEncoderConfig encoder_config_; bool codec_settings_set_; - webrtc::VideoCodecVP8 vp8_settings_; + union VpxSettings { + webrtc::VideoCodecVP8 vp8; + webrtc::VideoCodecVP9 vp9; + } vpx_settings_; int num_swapped_frames_; webrtc::I420VideoFrame last_frame_; webrtc::VideoSendStream::Stats stats_; diff --git a/talk/media/webrtc/simulcast.cc b/talk/media/webrtc/simulcast.cc index ffd623fa28..6a822b8ad2 100755 --- a/talk/media/webrtc/simulcast.cc +++ b/talk/media/webrtc/simulcast.cc @@ -460,6 +460,7 @@ bool ScreenshareLayerConfig::FromFieldTrialGroup( void ConfigureConferenceModeScreencastCodec(webrtc::VideoCodec* codec) { codec->codecSpecific.VP8.numberOfTemporalLayers = 2; + codec->codecSpecific.VP8.automaticResizeOn = false; ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault(); // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc index ec4f983ebd..09af9b586e 100644 --- a/talk/media/webrtc/webrtcvideoengine2.cc +++ b/talk/media/webrtc/webrtcvideoengine2.cc @@ -312,15 +312,29 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams( void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings( const VideoCodec& codec, - const VideoOptions& options) { + const VideoOptions& options, + bool is_screencast) { + // No automatic resizing when using simulcast. + bool automatic_resize = !is_screencast && ssrcs_.size() == 1; + bool frame_dropping = !is_screencast; + bool denoising; + if (is_screencast) { + denoising = false; + } else { + options.video_noise_reduction.Get(&denoising); + } + if (CodecNamesEq(codec.name, kVp8CodecName)) { encoder_settings_.vp8 = webrtc::VideoEncoder::GetDefaultVp8Settings(); - options.video_noise_reduction.Get(&encoder_settings_.vp8.denoisingOn); + encoder_settings_.vp8.automaticResizeOn = automatic_resize; + encoder_settings_.vp8.denoisingOn = denoising; + encoder_settings_.vp8.frameDroppingOn = frame_dropping; return &encoder_settings_.vp8; } if (CodecNamesEq(codec.name, kVp9CodecName)) { encoder_settings_.vp9 = webrtc::VideoEncoder::GetDefaultVp9Settings(); - options.video_noise_reduction.Get(&encoder_settings_.vp9.denoisingOn); + encoder_settings_.vp9.denoisingOn = denoising; + encoder_settings_.vp9.frameDroppingOn = frame_dropping; return &encoder_settings_.vp9; } return NULL; @@ -1778,10 +1792,12 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig( &screencast_min_bitrate_kbps); encoder_config.min_transmit_bitrate_bps = screencast_min_bitrate_kbps * 1000; - encoder_config.content_type = webrtc::VideoEncoderConfig::kScreenshare; + encoder_config.content_type = + webrtc::VideoEncoderConfig::ContentType::kScreen; } else { encoder_config.min_transmit_bitrate_bps = 0; - encoder_config.content_type = webrtc::VideoEncoderConfig::kRealtimeVideo; + encoder_config.content_type = + webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo; } // Restrict dimensions according to codec max. @@ -1800,7 +1816,7 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig( encoder_config.streams = CreateVideoStreams( clamped_codec, parameters_.options, parameters_.max_bitrate_bps, - parameters_.config.rtp.ssrcs.size()); + dimensions.is_screencast ? 1 : parameters_.config.rtp.ssrcs.size()); // Conference mode screencast uses 2 temporal layers split at 100kbit. if (parameters_.options.conference_mode.GetWithDefaultIfUnset(false) && @@ -1844,8 +1860,8 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions( webrtc::VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec); - encoder_config.encoder_specific_settings = - ConfigureVideoEncoderSettings(codec_settings.codec, parameters_.options); + encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings( + codec_settings.codec, parameters_.options, is_screencast); bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config); @@ -2000,7 +2016,10 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() { VideoCodecSettings codec_settings; parameters_.codec_settings.Get(&codec_settings); parameters_.encoder_config.encoder_specific_settings = - ConfigureVideoEncoderSettings(codec_settings.codec, parameters_.options); + ConfigureVideoEncoderSettings( + codec_settings.codec, parameters_.options, + parameters_.encoder_config.content_type == + webrtc::VideoEncoderConfig::ContentType::kScreen); webrtc::VideoSendStream::Config config = parameters_.config; if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) { diff --git a/talk/media/webrtc/webrtcvideoengine2.h b/talk/media/webrtc/webrtcvideoengine2.h index b8ddfc6f11..b6b976415c 100644 --- a/talk/media/webrtc/webrtcvideoengine2.h +++ b/talk/media/webrtc/webrtcvideoengine2.h @@ -353,7 +353,8 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler, size_t num_streams); void* ConfigureVideoEncoderSettings(const VideoCodec& codec, - const VideoOptions& options) + const VideoOptions& options, + bool is_screencast) EXCLUSIVE_LOCKS_REQUIRED(lock_); AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec) diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.cc b/talk/media/webrtc/webrtcvideoengine2_unittest.cc index eb915d8c3f..54e52c2260 100644 --- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc +++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc @@ -820,7 +820,7 @@ TEST_F(WebRtcVideoChannel2BaseTest, DISABLED_SendVp8HdAndReceiveAdaptedVp8Vga) { class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test, public WebRtcCallFactory { public: - WebRtcVideoChannel2Test() : fake_call_(NULL) {} + WebRtcVideoChannel2Test() : fake_call_(NULL), last_ssrc_(0) {} void SetUp() override { engine_.SetCallFactory(this); engine_.Init(rtc::Thread::Current()); @@ -831,6 +831,10 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test, } protected: + virtual std::vector GetCodecs() { + return engine_.codecs(); + } + webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { assert(fake_call_ == NULL); fake_call_ = new FakeCall(config); @@ -971,6 +975,26 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test, void TestCpuAdaptation(bool enable_overuse); + FakeVideoSendStream* SetDenoisingOption(bool enabled) { + VideoOptions options; + options.video_noise_reduction.Set(enabled); + channel_->SetOptions(options); + return fake_call_->GetVideoSendStreams().back(); + } + + FakeVideoSendStream* SetUpSimulcast(bool enabled) { + last_ssrc_ += 3; + if (enabled) { + std::vector ssrcs; + ssrcs.push_back(last_ssrc_); + ssrcs.push_back(last_ssrc_ + 1); + ssrcs.push_back(last_ssrc_ + 2); + return AddSendStream(CreateSimStreamParams("cname", ssrcs)); + } else { + return AddSendStream(StreamParams::CreateLegacy(last_ssrc_)); + } + } + FakeCall* fake_call_; rtc::scoped_ptr channel_; uint32 last_ssrc_; @@ -1374,7 +1398,7 @@ TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { // Verify non-screencast settings. webrtc::VideoEncoderConfig encoder_config = send_stream->GetEncoderConfig(); - EXPECT_EQ(webrtc::VideoEncoderConfig::kRealtimeVideo, + EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo, encoder_config.content_type); EXPECT_EQ(codec.width, encoder_config.streams.front().width); EXPECT_EQ(codec.height, encoder_config.streams.front().height); @@ -1388,7 +1412,7 @@ TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { // Verify screencast settings. encoder_config = send_stream->GetEncoderConfig(); - EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare, + EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen, encoder_config.content_type); EXPECT_EQ(kScreenshareMinBitrateKbps * 1000, encoder_config.min_transmit_bitrate_bps); @@ -1426,7 +1450,7 @@ TEST_F(WebRtcVideoChannel2Test, // Verify screencast settings. encoder_config = send_stream->GetEncoderConfig(); - EXPECT_EQ(webrtc::VideoEncoderConfig::kScreenshare, + EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen, encoder_config.content_type); ASSERT_EQ(1u, encoder_config.streams.size()); ASSERT_EQ(1u, encoder_config.streams[0].temporal_layer_thresholds_bps.size()); @@ -1472,22 +1496,143 @@ TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) { EXPECT_TRUE(vp8_settings.denoisingOn); } -TEST_F(WebRtcVideoChannel2Test, SetOptionsWithDenoising) { - VideoOptions options; - options.video_noise_reduction.Set(false); - channel_->SetOptions(options); +TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) { + std::vector codecs; + codecs.push_back(kVp8Codec720p); + ASSERT_TRUE(channel_->SetSendCodecs(codecs)); + + FakeVideoSendStream* stream = SetUpSimulcast(false); + + cricket::FakeVideoCapturer capturer; + capturer.SetScreencast(false); + EXPECT_EQ(cricket::CS_RUNNING, + capturer.Start(capturer.GetSupportedFormats()->front())); + EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer)); + channel_->SetSend(true); + + EXPECT_TRUE(capturer.CaptureFrame()); + + stream = SetDenoisingOption(false); - FakeVideoSendStream* stream = AddSendStream(); webrtc::VideoCodecVP8 vp8_settings; ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; EXPECT_FALSE(vp8_settings.denoisingOn); + EXPECT_TRUE(vp8_settings.automaticResizeOn); + EXPECT_TRUE(vp8_settings.frameDroppingOn); - options.video_noise_reduction.Set(true); - channel_->SetOptions(options); + stream = SetDenoisingOption(true); - stream = fake_call_->GetVideoSendStreams()[0]; ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; EXPECT_TRUE(vp8_settings.denoisingOn); + EXPECT_TRUE(vp8_settings.automaticResizeOn); + EXPECT_TRUE(vp8_settings.frameDroppingOn); + + EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL)); + stream = SetUpSimulcast(true); + EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer)); + channel_->SetSend(true); + EXPECT_TRUE(capturer.CaptureFrame()); + + EXPECT_EQ(3, stream->GetVideoStreams().size()); + ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; + // Autmatic resize off when using simulcast. + EXPECT_FALSE(vp8_settings.automaticResizeOn); + EXPECT_TRUE(vp8_settings.frameDroppingOn); + + // In screen-share mode, denoising is forced off and simulcast disabled. + capturer.SetScreencast(true); + EXPECT_TRUE(capturer.CaptureFrame()); + stream = SetDenoisingOption(false); + + EXPECT_EQ(1, stream->GetVideoStreams().size()); + ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; + EXPECT_FALSE(vp8_settings.denoisingOn); + // Resizing and frame dropping always off for screen sharing. + EXPECT_FALSE(vp8_settings.automaticResizeOn); + EXPECT_FALSE(vp8_settings.frameDroppingOn); + + stream = SetDenoisingOption(true); + + ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; + EXPECT_FALSE(vp8_settings.denoisingOn); + EXPECT_FALSE(vp8_settings.automaticResizeOn); + EXPECT_FALSE(vp8_settings.frameDroppingOn); + + EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL)); +} + +class Vp9SettingsTest : public WebRtcVideoChannel2Test { + public: + Vp9SettingsTest() : WebRtcVideoChannel2Test() { + encoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9"); + } + virtual ~Vp9SettingsTest() {} + + protected: + void SetUp() override { + engine_.SetExternalEncoderFactory(&encoder_factory_); + + WebRtcVideoChannel2Test::SetUp(); + } + + void TearDown() override { + // Remove references to encoder_factory_ since this will be destroyed + // before channel_ and engine_. + engine_.Terminate(); + engine_.SetExternalEncoderFactory(nullptr); + ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs())); + } + + cricket::FakeWebRtcVideoEncoderFactory encoder_factory_; +}; + +TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { + std::vector codecs; + codecs.push_back(kVp9Codec); + ASSERT_TRUE(channel_->SetSendCodecs(codecs)); + + FakeVideoSendStream* stream = SetUpSimulcast(false); + + cricket::FakeVideoCapturer capturer; + capturer.SetScreencast(false); + EXPECT_EQ(cricket::CS_RUNNING, + capturer.Start(capturer.GetSupportedFormats()->front())); + EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer)); + channel_->SetSend(true); + + EXPECT_TRUE(capturer.CaptureFrame()); + + stream = SetDenoisingOption(false); + + webrtc::VideoCodecVP9 vp9_settings; + ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set."; + EXPECT_FALSE(vp9_settings.denoisingOn); + // Frame dropping always on for real time video. + EXPECT_TRUE(vp9_settings.frameDroppingOn); + + stream = SetDenoisingOption(true); + + ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set."; + EXPECT_TRUE(vp9_settings.denoisingOn); + EXPECT_TRUE(vp9_settings.frameDroppingOn); + + // In screen-share mode, denoising is forced off. + capturer.SetScreencast(true); + EXPECT_TRUE(capturer.CaptureFrame()); + stream = SetDenoisingOption(false); + + ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set."; + EXPECT_FALSE(vp9_settings.denoisingOn); + // Frame dropping always off for screen sharing. + EXPECT_FALSE(vp9_settings.frameDroppingOn); + + stream = SetDenoisingOption(false); + + ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set."; + EXPECT_FALSE(vp9_settings.denoisingOn); + EXPECT_FALSE(vp9_settings.frameDroppingOn); + + EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL)); } TEST_F(WebRtcVideoChannel2Test, DISABLED_MultipleSendStreamsWithOneCapturer) { diff --git a/webrtc/config.cc b/webrtc/config.cc index 7b75a68de8..7dfecd1507 100644 --- a/webrtc/config.cc +++ b/webrtc/config.cc @@ -63,9 +63,10 @@ std::string VideoStream::ToString() const { } VideoEncoderConfig::VideoEncoderConfig() - : content_type(kRealtimeVideo), + : content_type(ContentType::kRealtimeVideo), encoder_specific_settings(NULL), - min_transmit_bitrate_bps(0) {} + min_transmit_bitrate_bps(0) { +} VideoEncoderConfig::~VideoEncoderConfig() = default; @@ -81,10 +82,10 @@ std::string VideoEncoderConfig::ToString() const { ss << ']'; ss << ", content_type: "; switch (content_type) { - case kRealtimeVideo: + case ContentType::kRealtimeVideo: ss << "kRealtimeVideo"; break; - case kScreenshare: + case ContentType::kScreen: ss << "kScreenshare"; break; } diff --git a/webrtc/config.h b/webrtc/config.h index aae60e7fa6..29b9d99960 100644 --- a/webrtc/config.h +++ b/webrtc/config.h @@ -91,9 +91,9 @@ struct VideoStream { }; struct VideoEncoderConfig { - enum ContentType { + enum class ContentType { kRealtimeVideo, - kScreenshare, + kScreen, }; VideoEncoderConfig(); diff --git a/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc b/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc index d8ec286c95..c2127f09cb 100644 --- a/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc +++ b/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc @@ -730,7 +730,7 @@ int VP8EncoderImpl::Encode( } // Only apply scaling to improve for single-layer streams. The scaling metrics - // use framedrops as a signal and is only applicable when we drop frames. + // use frame drops as a signal and is only applicable when we drop frames. const bool use_quality_scaler = encoders_.size() == 1 && configurations_[0].rc_dropframe_thresh > 0 && codec_.codecSpecific.VP8.automaticResizeOn; diff --git a/webrtc/video/full_stack.cc b/webrtc/video/full_stack.cc index 7f98f38a79..c047ab50ff 100644 --- a/webrtc/video/full_stack.cc +++ b/webrtc/video/full_stack.cc @@ -460,7 +460,7 @@ void FullStackTest::RunTest(const FullStackTestParams& params) { stream->max_framerate = params.clip.fps; if (params.screenshare) { - encoder_config_.content_type = VideoEncoderConfig::kScreenshare; + encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen; encoder_config_.min_transmit_bitrate_bps = 400 * 1000; VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings(); vp8_settings.denoisingOn = false; diff --git a/webrtc/video/screenshare_loopback.cc b/webrtc/video/screenshare_loopback.cc index 66bdf6ebc5..38bf0e90b8 100644 --- a/webrtc/video/screenshare_loopback.cc +++ b/webrtc/video/screenshare_loopback.cc @@ -116,7 +116,7 @@ class ScreenshareLoopback : public test::Loopback { VideoEncoderConfig CreateEncoderConfig() override { VideoEncoderConfig encoder_config(test::Loopback::CreateEncoderConfig()); VideoStream* stream = &encoder_config.streams[0]; - encoder_config.content_type = VideoEncoderConfig::kScreenshare; + encoder_config.content_type = VideoEncoderConfig::ContentType::kScreen; encoder_config.min_transmit_bitrate_bps = flags::MinTransmitBitrate(); VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings(); vp8_settings.denoisingOn = false; diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc index 87a418083b..68b80cefcf 100644 --- a/webrtc/video/video_send_stream.cc +++ b/webrtc/video/video_send_stream.cc @@ -315,10 +315,10 @@ bool VideoSendStream::ReconfigureVideoEncoder( } switch (config.content_type) { - case VideoEncoderConfig::kRealtimeVideo: + case VideoEncoderConfig::ContentType::kRealtimeVideo: video_codec.mode = kRealtimeVideo; break; - case VideoEncoderConfig::kScreenshare: + case VideoEncoderConfig::ContentType::kScreen: video_codec.mode = kScreensharing; if (config.streams.size() == 1 && config.streams[0].temporal_layer_thresholds_bps.size() == 1) { diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc index ea59c60e35..b33894ead0 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -1332,7 +1332,7 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { void PerformTest() override { EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; - encoder_config_.content_type = VideoEncoderConfig::kScreenshare; + encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen; stream_->ReconfigureVideoEncoder(encoder_config_); EXPECT_EQ(2u, num_initializations_) << "ReconfigureVideoEncoder did not reinitialize the encoder with " @@ -1563,7 +1563,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) { encoder_config->streams[0].temporal_layer_thresholds_bps.empty()); encoder_config->streams[0].temporal_layer_thresholds_bps.push_back( kScreencastTargetBitrateKbps * 1000); - encoder_config->content_type = VideoEncoderConfig::kScreenshare; + encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; } void PerformTest() override {