From f24a06406a5e0863fee82d6470bb655d3b4ac2af Mon Sep 17 00:00:00 2001 From: sprang Date: Tue, 28 Feb 2017 13:23:26 -0800 Subject: [PATCH] Recreate WebrtcVideoSendStream if screen content setting is changed. This avoids the situation where an encoder, not supporting certain screen content settings, is created for a config where screencast is off, and later ReconfigureEncoder() is called updating the configuration but not the encoder instance, causing an inconsistency in the encoder's InitEncode() call. TBR=pthatcher@webrtc.org BUG=webrtc:4172 Review-Url: https://codereview.webrtc.org/2710493008 Cr-Commit-Position: refs/heads/master@{#16921} --- webrtc/media/engine/fakewebrtcvideoengine.h | 7 +- webrtc/media/engine/webrtcvideoengine2.cc | 32 +++- webrtc/media/engine/webrtcvideoengine2.h | 9 +- .../engine/webrtcvideoengine2_unittest.cc | 148 ++++++++++-------- webrtc/video/video_send_stream.cc | 4 +- webrtc/video/video_send_stream.h | 1 + webrtc/video/video_send_stream_tests.cc | 69 ++++++-- 7 files changed, 184 insertions(+), 86 deletions(-) diff --git a/webrtc/media/engine/fakewebrtcvideoengine.h b/webrtc/media/engine/fakewebrtcvideoengine.h index 497d70133a..2dce2c503f 100644 --- a/webrtc/media/engine/fakewebrtcvideoengine.h +++ b/webrtc/media/engine/fakewebrtcvideoengine.h @@ -196,10 +196,13 @@ class FakeWebRtcVideoEncoderFactory : public WebRtcVideoEncoderFactory { } bool WaitForCreatedVideoEncoders(int num_encoders) { - while (created_video_encoder_event_.Wait(kEventTimeoutMs)) { + int64_t start_offset_ms = rtc::TimeMillis(); + int64_t wait_time = kEventTimeoutMs; + do { if (GetNumCreatedEncoders() >= num_encoders) return true; - } + wait_time = kEventTimeoutMs - (rtc::TimeMillis() - start_offset_ms); + } while (wait_time > 0 && created_video_encoder_event_.Wait(wait_time)); return false; } diff --git a/webrtc/media/engine/webrtcvideoengine2.cc b/webrtc/media/engine/webrtcvideoengine2.cc index 39bec6472c..9f37f33c63 100644 --- a/webrtc/media/engine/webrtcvideoengine2.cc +++ b/webrtc/media/engine/webrtcvideoengine2.cc @@ -1588,7 +1588,8 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream( ? webrtc::RtcpMode::kReducedSize : webrtc::RtcpMode::kCompound; if (codec_settings) { - SetCodec(*codec_settings); + bool force_encoder_allocation = false; + SetCodec(*codec_settings, force_encoder_allocation); } } @@ -1612,6 +1613,18 @@ bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend( if (options_present) { VideoOptions old_options = parameters_.options; parameters_.options.SetAll(*options); + if (parameters_.options.is_screencast.value_or(false) != + old_options.is_screencast.value_or(false) && + parameters_.codec_settings) { + // If screen content settings change, we may need to recreate the codec + // instance so that the correct type is used. + + bool force_encoder_allocation = true; + SetCodec(*parameters_.codec_settings, force_encoder_allocation); + // Mark screenshare parameter as being updated, then test for any other + // changes that may require codec reconfiguration. + old_options.is_screencast = options->is_screencast; + } if (parameters_.options != old_options) { ReconfigureEncoder(); } @@ -1645,10 +1658,11 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const { WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder( - const VideoCodec& codec) { + const VideoCodec& codec, + bool force_encoder_allocation) { RTC_DCHECK_RUN_ON(&thread_checker_); // Do not re-create encoders of the same type. - if (codec == allocated_encoder_.codec && + if (!force_encoder_allocation && codec == allocated_encoder_.codec && allocated_encoder_.encoder != nullptr) { return allocated_encoder_; } @@ -1695,12 +1709,14 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder( } void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec( - const VideoCodecSettings& codec_settings) { + const VideoCodecSettings& codec_settings, + bool force_encoder_allocation) { RTC_DCHECK_RUN_ON(&thread_checker_); parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); - AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec); + AllocatedEncoder new_encoder = + CreateVideoEncoder(codec_settings.codec, force_encoder_allocation); parameters_.config.encoder_settings.encoder = new_encoder.encoder; parameters_.config.encoder_settings.full_overuse_time = new_encoder.external; parameters_.config.encoder_settings.payload_name = codec_settings.codec.name; @@ -1767,10 +1783,12 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSendParameters( // Set codecs and options. if (params.codec) { - SetCodec(*params.codec); + bool force_encoder_allocation = false; + SetCodec(*params.codec, force_encoder_allocation); recreate_stream = false; // SetCodec has already recreated the stream. } else if (params.conference_mode && parameters_.codec_settings) { - SetCodec(*parameters_.codec_settings); + bool force_encoder_allocation = false; + SetCodec(*parameters_.codec_settings, force_encoder_allocation); recreate_stream = false; // SetCodec has already recreated the stream. } if (recreate_stream) { diff --git a/webrtc/media/engine/webrtcvideoengine2.h b/webrtc/media/engine/webrtcvideoengine2.h index 7043e031a4..309a84d924 100644 --- a/webrtc/media/engine/webrtcvideoengine2.h +++ b/webrtc/media/engine/webrtcvideoengine2.h @@ -306,9 +306,14 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport { rtc::scoped_refptr ConfigureVideoEncoderSettings(const VideoCodec& codec); - AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec); + // If force_encoder_allocation is true, a new AllocatedEncoder is always + // created. If false, the allocated encoder may be reused, if the type + // matches. + AllocatedEncoder CreateVideoEncoder(const VideoCodec& codec, + bool force_encoder_allocation); void DestroyVideoEncoder(AllocatedEncoder* encoder); - void SetCodec(const VideoCodecSettings& codec); + void SetCodec(const VideoCodecSettings& codec, + bool force_encoder_allocation); void RecreateWebRtcStream(); webrtc::VideoEncoderConfig CreateVideoEncoderConfig( const VideoCodec& codec) const; diff --git a/webrtc/media/engine/webrtcvideoengine2_unittest.cc b/webrtc/media/engine/webrtcvideoengine2_unittest.cc index 5c560c159c..57ba5d2e22 100644 --- a/webrtc/media/engine/webrtcvideoengine2_unittest.cc +++ b/webrtc/media/engine/webrtcvideoengine2_unittest.cc @@ -906,6 +906,68 @@ TEST_F(WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory) { EXPECT_EQ(sp.id, params[0].receive_stream_id); } +TEST_F(WebRtcVideoEngine2Test, RecreatesEncoderOnContentTypeChange) { + cricket::FakeWebRtcVideoEncoderFactory encoder_factory; + encoder_factory.AddSupportedVideoCodecType("VP8"); + std::unique_ptr fake_call( + new FakeCall(webrtc::Call::Config(&event_log_))); + std::unique_ptr channel( + SetUpForExternalEncoderFactory(&encoder_factory)); + ASSERT_TRUE( + channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); + cricket::VideoCodec codec = GetEngineCodec("VP8"); + cricket::VideoSendParameters parameters; + parameters.codecs.push_back(codec); + channel->OnReadyToSend(true); + channel->SetSend(true); + ASSERT_TRUE(channel->SetSendParameters(parameters)); + + cricket::FakeVideoCapturer capturer; + VideoOptions options; + EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer)); + + EXPECT_EQ(cricket::CS_RUNNING, + capturer.Start(capturer.GetSupportedFormats()->front())); + EXPECT_TRUE(capturer.CaptureFrame()); + ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1)); + EXPECT_EQ(webrtc::kRealtimeVideo, + encoder_factory.encoders().back()->GetCodecSettings().mode); + + EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer)); + EXPECT_TRUE(capturer.CaptureFrame()); + // No change in content type, keep current encoder. + EXPECT_EQ(1, encoder_factory.GetNumCreatedEncoders()); + + options.is_screencast.emplace(true); + EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer)); + EXPECT_TRUE(capturer.CaptureFrame()); + // Change to screen content, recreate encoder. For the simulcast encoder + // adapter case, this will result in two calls since InitEncode triggers a + // a new instance. + ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2)); + EXPECT_EQ(webrtc::kScreensharing, + encoder_factory.encoders().back()->GetCodecSettings().mode); + + EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer)); + EXPECT_TRUE(capturer.CaptureFrame()); + // Still screen content, no need to update encoder. + EXPECT_EQ(2, encoder_factory.GetNumCreatedEncoders()); + + options.is_screencast.emplace(false); + options.video_noise_reduction.emplace(false); + EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer)); + // Change back to regular video content, update encoder. Also change + // a non |is_screencast| option just to verify it doesn't affect recreation. + EXPECT_TRUE(capturer.CaptureFrame()); + ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(3)); + EXPECT_EQ(webrtc::kRealtimeVideo, + encoder_factory.encoders().back()->GetCodecSettings().mode); + + // Remove stream previously added to free the external encoder instance. + EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); + EXPECT_EQ(0u, encoder_factory.encoders().size()); +} + #define WEBRTC_BASE_TEST(test) \ TEST_F(WebRtcVideoChannel2BaseTest, test) { Base::test(); } @@ -1668,9 +1730,10 @@ TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { EXPECT_TRUE( channel_->SetVideoSend(last_ssrc_, true, &screencast_options, &capturer)); EXPECT_TRUE(capturer.CaptureFrame()); - // Send stream not recreated after option change. - ASSERT_EQ(send_stream, fake_call_->GetVideoSendStreams().front()); - EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames()); + // Send stream recreated after option change. + ASSERT_EQ(2, fake_call_->GetNumCreatedSendStreams()); + send_stream = fake_call_->GetVideoSendStreams().front(); + EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); // Verify screencast settings. encoder_config = send_stream->GetEncoderConfig().Copy(); @@ -1686,57 +1749,6 @@ TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); } -TEST_F(WebRtcVideoChannel2Test, NoRecreateStreamForScreencast) { - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); - ASSERT_TRUE( - channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); - EXPECT_TRUE(channel_->SetSend(true)); - - cricket::FakeVideoCapturer capturer; - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, &capturer)); - EXPECT_EQ(cricket::CS_RUNNING, - capturer.Start(capturer.GetSupportedFormats()->front())); - EXPECT_TRUE(capturer.CaptureFrame()); - - ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams()); - FakeVideoSendStream* stream = fake_call_->GetVideoSendStreams().front(); - webrtc::VideoEncoderConfig encoder_config = stream->GetEncoderConfig().Copy(); - EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo, - encoder_config.content_type); - - EXPECT_EQ(1, stream->GetNumberOfSwappedFrames()); - - /* Switch to screencast source. We expect a reconfigure of the - * encoder, but no change of the send stream. */ - struct VideoOptions video_options; - video_options.is_screencast = rtc::Optional(true); - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, &video_options, &capturer)); - - EXPECT_TRUE(capturer.CaptureFrame()); - ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams()); - ASSERT_EQ(stream, fake_call_->GetVideoSendStreams().front()); - EXPECT_EQ(2, stream->GetNumberOfSwappedFrames()); - - encoder_config = stream->GetEncoderConfig().Copy(); - EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen, - encoder_config.content_type); - - /* Switch back. */ - video_options.is_screencast = rtc::Optional(false); - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, &video_options, &capturer)); - - EXPECT_TRUE(capturer.CaptureFrame()); - ASSERT_EQ(1, fake_call_->GetNumCreatedSendStreams()); - ASSERT_EQ(stream, fake_call_->GetVideoSendStreams().front()); - EXPECT_EQ(3, stream->GetNumberOfSwappedFrames()); - - encoder_config = stream->GetEncoderConfig().Copy(); - EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo, - encoder_config.content_type); - - EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr)); -} - TEST_F(WebRtcVideoChannel2Test, ConferenceModeScreencastConfiguresTemporalLayer) { static const int kConferenceScreencastTemporalBitrateBps = @@ -1910,7 +1922,7 @@ TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) { EXPECT_EQ(1, send_stream->num_encoder_reconfigurations()); // Change |options| and expect 2 reconfigurations. - options.is_screencast = rtc::Optional(true); + options.video_noise_reduction = rtc::Optional(true); EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); EXPECT_EQ(2, send_stream->num_encoder_reconfigurations()); @@ -2204,15 +2216,24 @@ TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) { channel_->SetVideoSend(last_ssrc_, true /* enable */, &screenshare_options, &screen_share); EXPECT_TRUE(screen_share.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); - EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames()); + ASSERT_EQ(2, fake_call_->GetNumCreatedSendStreams()); + send_stream = fake_call_->GetVideoSendStreams().front(); + EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); EXPECT_EQ(1284, send_stream->GetLastWidth()); EXPECT_EQ(724, send_stream->GetLastHeight()); // Switch back to the normal capturer. Expect the frame to be CPU adapted. channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options, &capturer); + send_stream = fake_call_->GetVideoSendStreams().front(); + // We have a new fake send stream, so it doesn't remember the old sink wants. + // In practice, it will be populated from + // ViEEncoder::VideoSourceProxy::SetSource(), so simulate that here. + send_stream->InjectVideoSinkWants(wants); EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); - EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames()); + ASSERT_EQ(3, fake_call_->GetNumCreatedSendStreams()); + send_stream = fake_call_->GetVideoSendStreams().front(); + EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames()); EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth()); EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight()); @@ -4170,25 +4191,26 @@ class WebRtcVideoChannel2SimulcastTest : public testing::Test { bool screenshare, bool conference_mode) { cricket::VideoSendParameters parameters; - VideoOptions options; parameters.codecs.push_back(codec); parameters.conference_mode = conference_mode; - if (screenshare) { - options.is_screencast = rtc::Optional(screenshare); - } ASSERT_TRUE(channel_->SetSendParameters(parameters)); std::vector ssrcs = MAKE_VECTOR(kSsrcs3); RTC_DCHECK(num_configured_streams <= ssrcs.size()); ssrcs.resize(num_configured_streams); - FakeVideoSendStream* stream = - AddSendStream(CreateSimStreamParams("cname", ssrcs)); + AddSendStream(CreateSimStreamParams("cname", ssrcs)); // Send a full-size frame to trigger a stream reconfiguration to use all // expected simulcast layers. cricket::FakeVideoCapturer capturer; + VideoOptions options; + if (screenshare) + options.is_screencast = rtc::Optional(screenshare); EXPECT_TRUE( channel_->SetVideoSend(ssrcs.front(), true, &options, &capturer)); + // Fetch the latest stream since SetVideoSend() may recreate it if the + // screen content setting is changed. + FakeVideoSendStream* stream = fake_call_.GetVideoSendStreams().front(); EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(cricket::VideoFormat( capture_width, capture_height, cricket::VideoFormat::FpsToInterval(30), diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc index c777ce863d..3f2bba866e 100644 --- a/webrtc/video/video_send_stream.cc +++ b/webrtc/video/video_send_stream.cc @@ -629,7 +629,8 @@ VideoSendStream::VideoSendStream( stats_proxy_(Clock::GetRealTimeClock(), config, encoder_config.content_type), - config_(std::move(config)) { + config_(std::move(config)), + content_type_(encoder_config.content_type) { vie_encoder_.reset(new ViEEncoder( num_cpu_cores, &stats_proxy_, config_.encoder_settings, config_.pre_encode_callback, config_.post_encode_callback)); @@ -692,6 +693,7 @@ void VideoSendStream::ReconfigureVideoEncoder(VideoEncoderConfig config) { // TODO(perkj): Some test cases in VideoSendStreamTest call // ReconfigureVideoEncoder from the network thread. // RTC_DCHECK_RUN_ON(&thread_checker_); + RTC_DCHECK(content_type_ == config.content_type); vie_encoder_->ConfigureEncoder(std::move(config), config_.rtp.max_packet_size, config_.rtp.nack.rtp_history_ms > 0); } diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h index be62a2eaf9..9617580ddd 100644 --- a/webrtc/video/video_send_stream.h +++ b/webrtc/video/video_send_stream.h @@ -104,6 +104,7 @@ class VideoSendStream : public webrtc::VideoSendStream { SendStatisticsProxy stats_proxy_; const VideoSendStream::Config config_; + const VideoEncoderConfig::ContentType content_type_; std::unique_ptr send_stream_; std::unique_ptr vie_encoder_; }; diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc index 189f0304dc..4617622819 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -1513,22 +1513,32 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) { RunBaseTest(&test); } +// Test class takes takes as argument a switch selecting if type switch should +// occur and a function pointer to reset the send stream. This is necessary +// since you cannot change the content type of a VideoSendStream, you need to +// recreate it. Stopping and recreating the stream can only be done on the main +// thread and in the context of VideoSendStreamTest (not BaseTest). +template class MaxPaddingSetTest : public test::SendTest { public: static const uint32_t kMinTransmitBitrateBps = 400000; static const uint32_t kActualEncodeBitrateBps = 40000; static const uint32_t kMinPacketsToSend = 50; - explicit MaxPaddingSetTest(bool test_switch_content_type) + explicit MaxPaddingSetTest(bool test_switch_content_type, T* stream_reset_fun) : SendTest(test::CallTest::kDefaultTimeoutMs), + content_switch_event_(false, false), call_(nullptr), send_stream_(nullptr), + send_stream_config_(nullptr), packets_sent_(0), - running_without_padding_(test_switch_content_type) {} + running_without_padding_(test_switch_content_type), + stream_resetter_(stream_reset_fun) {} void OnVideoStreamsCreated( VideoSendStream* send_stream, const std::vector& receive_streams) override { + rtc::CritScope lock(&crit_); send_stream_ = send_stream; } @@ -1537,7 +1547,7 @@ class MaxPaddingSetTest : public test::SendTest { std::vector* receive_configs, VideoEncoderConfig* encoder_config) override { RTC_DCHECK_EQ(1, encoder_config->number_of_streams); - if (running_without_padding_) { + if (RunningWithoutPadding()) { encoder_config->min_transmit_bitrate_bps = 0; encoder_config->content_type = VideoEncoderConfig::ContentType::kRealtimeVideo; @@ -1545,6 +1555,7 @@ class MaxPaddingSetTest : public test::SendTest { encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps; encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen; } + send_stream_config_ = send_config->Copy(); encoder_config_ = encoder_config->Copy(); } @@ -1554,7 +1565,6 @@ class MaxPaddingSetTest : public test::SendTest { Action OnSendRtp(const uint8_t* packet, size_t length) override { rtc::CritScope lock(&crit_); - if (running_without_padding_) EXPECT_EQ(0, call_->GetStats().max_padding_bitrate_bps); @@ -1566,11 +1576,12 @@ class MaxPaddingSetTest : public test::SendTest { if (running_without_padding_) { // We've sent kMinPacketsToSend packets with default configuration, switch // to enabling screen content and setting min transmit bitrate. + // Note that we need to recreate the stream if changing content type. packets_sent_ = 0; encoder_config_.min_transmit_bitrate_bps = kMinTransmitBitrateBps; encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen; - send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); running_without_padding_ = false; + content_switch_event_.Set(); return SEND_PACKET; } @@ -1582,25 +1593,57 @@ class MaxPaddingSetTest : public test::SendTest { } void PerformTest() override { + if (RunningWithoutPadding()) { + ASSERT_TRUE( + content_switch_event_.Wait(test::CallTest::kDefaultTimeoutMs)); + rtc::CritScope lock(&crit_); + RTC_DCHECK(stream_resetter_); + (*stream_resetter_)(send_stream_config_, encoder_config_); + } + ASSERT_TRUE(Wait()) << "Timed out waiting for a valid padding bitrate."; } private: + bool RunningWithoutPadding() const { + rtc::CritScope lock(&crit_); + return running_without_padding_; + } + rtc::CriticalSection crit_; + rtc::Event content_switch_event_; Call* call_; - VideoSendStream* send_stream_; + VideoSendStream* send_stream_ GUARDED_BY(crit_); + VideoSendStream::Config send_stream_config_; VideoEncoderConfig encoder_config_; uint32_t packets_sent_ GUARDED_BY(crit_); bool running_without_padding_; + T* const stream_resetter_; }; TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrate) { - MaxPaddingSetTest test(false); + auto reset_fun = [](const VideoSendStream::Config& send_stream_config, + const VideoEncoderConfig& encoder_config) {}; + MaxPaddingSetTest test(false, &reset_fun); RunBaseTest(&test); } TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrateAfterContentSwitch) { - MaxPaddingSetTest test(true); + // Function for removing and recreating the send stream with a new config. + auto reset_fun = [this](const VideoSendStream::Config& send_stream_config, + const VideoEncoderConfig& encoder_config) { + Stop(); + sender_call_->DestroyVideoSendStream(video_send_stream_); + video_send_config_ = send_stream_config.Copy(); + video_encoder_config_ = encoder_config.Copy(); + video_send_stream_ = sender_call_->CreateVideoSendStream( + video_send_config_.Copy(), video_encoder_config_.Copy()); + video_send_stream_->SetSource( + frame_generator_capturer_.get(), + VideoSendStream::DegradationPreference::kMaintainResolution); + Start(); + }; + MaxPaddingSetTest test(true, &reset_fun); RunBaseTest(&test); } @@ -2070,6 +2113,7 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { std::vector* receive_configs, VideoEncoderConfig* encoder_config) override { send_config->encoder_settings.encoder = this; + encoder_config->max_bitrate_bps = kFirstMaxBitrateBps; encoder_config_ = encoder_config->Copy(); } @@ -2084,10 +2128,10 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { size_t max_payload_size) override { if (num_initializations_ == 0) { // Verify default values. - EXPECT_EQ(kRealtimeVideo, config->mode); + EXPECT_EQ(kFirstMaxBitrateBps / 1000, config->maxBitrate); } else { // Verify that changed values are propagated. - EXPECT_EQ(kScreensharing, config->mode); + EXPECT_EQ(kSecondMaxBitrateBps / 1000, config->maxBitrate); } ++num_initializations_; init_encode_event_.Set(); @@ -2098,7 +2142,7 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { EXPECT_TRUE(init_encode_event_.Wait(kDefaultTimeoutMs)); EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized."; - encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen; + encoder_config_.max_bitrate_bps = kSecondMaxBitrateBps; stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); EXPECT_TRUE(init_encode_event_.Wait(kDefaultTimeoutMs)); EXPECT_EQ(2u, num_initializations_) @@ -2106,6 +2150,9 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) { "new encoder settings."; } + const uint32_t kFirstMaxBitrateBps = 1000000; + const uint32_t kSecondMaxBitrateBps = 2000000; + rtc::Event init_encode_event_; size_t num_initializations_; VideoSendStream* stream_;