From 979b6d62a8ad2d47f043dceb86d74fcfb6c8dfc7 Mon Sep 17 00:00:00 2001 From: Per K Date: Fri, 26 Jan 2024 11:18:26 +0100 Subject: [PATCH] Refactor RtpVideoSender::SetActiveModules. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rename RtpVideoSender::SetActiveModules to SetSending to better match what it does. When a RtpVideoSender::SetSending(true) RTP packets can be sent on all associcated RTP streams (simulcast streams). Move registration of RtpRtcpModules to RtpTransportControllerSend to allow RtpTransportControllerSend to know when there are sending RTP streams. Purpose is to in later CLs allow RtpTransportControllerSend to trigger BWE probes. Bug: webrtc:14928 Change-Id: Ibf6c040b86713cdc4763c4691b7fd794b251eb49 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/335961 Reviewed-by: Erik Språng Commit-Queue: Per Kjellander Cr-Commit-Position: refs/heads/main@{#41620} --- call/rtp_transport_controller_send.cc | 25 ++++++ call/rtp_transport_controller_send.h | 2 + .../rtp_transport_controller_send_interface.h | 7 ++ call/rtp_video_sender.cc | 88 +++++-------------- call/rtp_video_sender.h | 9 +- call/rtp_video_sender_interface.h | 8 +- call/rtp_video_sender_unittest.cc | 79 ++++++----------- .../test/mock_rtp_transport_controller_send.h | 5 ++ video/video_send_stream_impl.cc | 5 +- video/video_send_stream_impl_unittest.cc | 22 ++--- 10 files changed, 102 insertions(+), 148 deletions(-) diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc index 600d4e2620..5ed1d6a0f3 100644 --- a/call/rtp_transport_controller_send.cc +++ b/call/rtp_transport_controller_send.cc @@ -159,6 +159,31 @@ void RtpTransportControllerSend::DestroyRtpVideoSender( video_rtp_senders_.erase(it); } +void RtpTransportControllerSend::RegisterSendingRtpStream( + RtpRtcpInterface& rtp_module) { + RTC_DCHECK_RUN_ON(&sequence_checker_); + // Allow pacer to send packets using this module. + packet_router_.AddSendRtpModule(&rtp_module, + /*remb_candidate=*/true); +} + +void RtpTransportControllerSend::DeRegisterSendingRtpStream( + RtpRtcpInterface& rtp_module) { + RTC_DCHECK_RUN_ON(&sequence_checker_); + // Disabling media, remove from packet router map to reduce size and + // prevent any stray packets in the pacer from asynchronously arriving + // to a disabled module. + packet_router_.RemoveSendRtpModule(&rtp_module); + // Clear the pacer queue of any packets pertaining to this module. + pacer_.RemovePacketsForSsrc(rtp_module.SSRC()); + if (rtp_module.RtxSsrc().has_value()) { + pacer_.RemovePacketsForSsrc(*rtp_module.RtxSsrc()); + } + if (rtp_module.FlexfecSsrc().has_value()) { + pacer_.RemovePacketsForSsrc(*rtp_module.FlexfecSsrc()); + } +} + void RtpTransportControllerSend::UpdateControlState() { absl::optional update = control_handler_->GetUpdate(); if (!update) diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h index c0bca41a2b..6f6f0809a3 100644 --- a/call/rtp_transport_controller_send.h +++ b/call/rtp_transport_controller_send.h @@ -75,6 +75,8 @@ class RtpTransportControllerSend final RtpVideoSenderInterface* rtp_video_sender) override; // Implements RtpTransportControllerSendInterface + void RegisterSendingRtpStream(RtpRtcpInterface& rtp_module) override; + void DeRegisterSendingRtpStream(RtpRtcpInterface& rtp_module) override; PacketRouter* packet_router() override; NetworkStateEstimateObserver* network_state_estimate_observer() override; diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h index 7edc135037..1938d86c57 100644 --- a/call/rtp_transport_controller_send_interface.h +++ b/call/rtp_transport_controller_send_interface.h @@ -47,6 +47,7 @@ class Transport; class PacketRouter; class RtpVideoSenderInterface; class RtpPacketSender; +class RtpRtcpInterface; struct RtpSenderObservers { RtcpRttStats* rtcp_rtt_stats; @@ -108,6 +109,12 @@ class RtpTransportControllerSendInterface { virtual void DestroyRtpVideoSender( RtpVideoSenderInterface* rtp_video_sender) = 0; + // Register a specific RTP stream as sending. This means that the pacer and + // packet router can send packets using this RTP stream. + virtual void RegisterSendingRtpStream(RtpRtcpInterface& rtp_module) = 0; + // Pacer and PacketRouter stop using this RTP stream. + virtual void DeRegisterSendingRtpStream(RtpRtcpInterface& rtp_module) = 0; + virtual NetworkStateEstimateObserver* network_state_estimate_observer() = 0; virtual TransportFeedbackObserver* transport_feedback_observer() = 0; diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc index 1ace08fa32..580850359c 100644 --- a/call/rtp_video_sender.cc +++ b/call/rtp_video_sender.cc @@ -470,85 +470,41 @@ RtpVideoSender::RtpVideoSender( } RtpVideoSender::~RtpVideoSender() { - // TODO(bugs.webrtc.org/13517): Remove once RtpVideoSender gets deleted on the - // transport task queue. - transport_checker_.Detach(); - + RTC_DCHECK_RUN_ON(&transport_checker_); SetActiveModulesLocked( - std::vector(rtp_streams_.size(), /*active=*/false)); - - RTC_DCHECK(!registered_for_feedback_); + /*sending=*/false); } -void RtpVideoSender::Stop() { +void RtpVideoSender::SetSending(bool enabled) { RTC_DCHECK_RUN_ON(&transport_checker_); MutexLock lock(&mutex_); - if (!active_) + if (enabled == active_) { return; - - const std::vector active_modules(rtp_streams_.size(), false); - SetActiveModulesLocked(active_modules); + } + SetActiveModulesLocked(/*sending=*/enabled); } -void RtpVideoSender::SetActiveModules(const std::vector& active_modules) { +void RtpVideoSender::SetActiveModulesLocked(bool sending) { RTC_DCHECK_RUN_ON(&transport_checker_); - MutexLock lock(&mutex_); - return SetActiveModulesLocked(active_modules); -} - -void RtpVideoSender::SetActiveModulesLocked( - const std::vector& active_modules) { - RTC_DCHECK_RUN_ON(&transport_checker_); - RTC_CHECK_EQ(rtp_streams_.size(), active_modules.size()); - active_ = false; - for (size_t i = 0; i < active_modules.size(); ++i) { - if (active_modules[i]) { - active_ = true; - } - + if (active_ == sending) { + return; + } + active_ = sending; + for (size_t i = 0; i < rtp_streams_.size(); ++i) { RtpRtcpInterface& rtp_module = *rtp_streams_[i].rtp_rtcp; - const bool was_active = rtp_module.Sending(); - const bool should_be_active = active_modules[i]; - - rtp_module.SetSendingStatus(active_modules[i]); - - if (was_active && !should_be_active) { - // Disabling media, remove from packet router map to reduce size and - // prevent any stray packets in the pacer from asynchronously arriving - // to a disabled module. - transport_->packet_router()->RemoveSendRtpModule(&rtp_module); - - // Clear the pacer queue of any packets pertaining to this module. - transport_->packet_sender()->RemovePacketsForSsrc(rtp_module.SSRC()); - if (rtp_module.RtxSsrc().has_value()) { - transport_->packet_sender()->RemovePacketsForSsrc( - *rtp_module.RtxSsrc()); - } - if (rtp_module.FlexfecSsrc().has_value()) { - transport_->packet_sender()->RemovePacketsForSsrc( - *rtp_module.FlexfecSsrc()); - } - } - - // If set to false this module won't send media. - rtp_module.SetSendingMediaStatus(active_modules[i]); - - if (!was_active && should_be_active) { - // Turning on media, register with packet router. - transport_->packet_router()->AddSendRtpModule(&rtp_module, - /*remb_candidate=*/true); + rtp_module.SetSendingStatus(sending); + rtp_module.SetSendingMediaStatus(sending); + if (sending) { + transport_->RegisterSendingRtpStream(rtp_module); + } else { + transport_->DeRegisterSendingRtpStream(rtp_module); } } - if (!active_) { - auto* feedback_provider = transport_->GetStreamFeedbackProvider(); - if (registered_for_feedback_) { - feedback_provider->DeRegisterStreamFeedbackObserver(this); - registered_for_feedback_ = false; - } - } else if (!registered_for_feedback_) { - auto* feedback_provider = transport_->GetStreamFeedbackProvider(); + auto* feedback_provider = transport_->GetStreamFeedbackProvider(); + if (!sending) { + feedback_provider->DeRegisterStreamFeedbackObserver(this); + } else { feedback_provider->RegisterStreamFeedbackObserver(rtp_config_.ssrcs, this); - registered_for_feedback_ = true; } } diff --git a/call/rtp_video_sender.h b/call/rtp_video_sender.h index 10b0d19d05..957b46e560 100644 --- a/call/rtp_video_sender.h +++ b/call/rtp_video_sender.h @@ -95,11 +95,7 @@ class RtpVideoSender : public RtpVideoSenderInterface, RtpVideoSender(const RtpVideoSender&) = delete; RtpVideoSender& operator=(const RtpVideoSender&) = delete; - // Sets the sending status of the rtp modules and appropriately sets the - // payload router to active if any rtp modules are active. - void SetActiveModules(const std::vector& active_modules) - RTC_LOCKS_EXCLUDED(mutex_) override; - void Stop() RTC_LOCKS_EXCLUDED(mutex_) override; + void SetSending(bool enabled) RTC_LOCKS_EXCLUDED(mutex_) override; bool IsActive() RTC_LOCKS_EXCLUDED(mutex_) override; void OnNetworkAvailability(bool network_available) @@ -160,7 +156,7 @@ class RtpVideoSender : public RtpVideoSenderInterface, private: bool IsActiveLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_); - void SetActiveModulesLocked(const std::vector& active_modules) + void SetActiveModulesLocked(bool sending) RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_); void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_); void ConfigureProtection(); @@ -184,7 +180,6 @@ class RtpVideoSender : public RtpVideoSenderInterface, // transport task queue. mutable Mutex mutex_; bool active_ RTC_GUARDED_BY(mutex_); - bool registered_for_feedback_ RTC_GUARDED_BY(transport_checker_) = false; const std::unique_ptr fec_controller_; bool fec_allowed_ RTC_GUARDED_BY(mutex_); diff --git a/call/rtp_video_sender_interface.h b/call/rtp_video_sender_interface.h index 3f2877155a..6bbcb7f46e 100644 --- a/call/rtp_video_sender_interface.h +++ b/call/rtp_video_sender_interface.h @@ -31,12 +31,8 @@ struct FecProtectionParams; class RtpVideoSenderInterface : public EncodedImageCallback, public FecControllerOverride { public: - // Sets the sending status of the rtp modules and appropriately sets the - // RtpVideoSender to active if any rtp modules are active. - // A module will only send packet if beeing active. - virtual void SetActiveModules(const std::vector& active_modules) = 0; - // Set the sending status of all rtp modules to inactive. - virtual void Stop() = 0; + // Sets weather or not RTP packets is allowed to be sent on this sender. + virtual void SetSending(bool enabled) = 0; virtual bool IsActive() = 0; virtual void OnNetworkAvailability(bool network_available) = 0; diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc index cf099afaa3..72234aa409 100644 --- a/call/rtp_video_sender_unittest.cc +++ b/call/rtp_video_sender_unittest.cc @@ -180,17 +180,13 @@ class RtpVideoSenderTestFixture { /*frame_transformer=*/nullptr, field_trials) {} - ~RtpVideoSenderTestFixture() { Stop(); } + ~RtpVideoSenderTestFixture() { SetSending(false); } RtpVideoSender* router() { return router_.get(); } MockTransport& transport() { return transport_; } void AdvanceTime(TimeDelta delta) { time_controller_.AdvanceTime(delta); } - void Stop() { router_->Stop(); } - - void SetActiveModules(const std::vector& active_modules) { - router_->SetActiveModules(active_modules); - } + void SetSending(bool sending) { router_->SetSending(sending); } private: test::ScopedKeyValueConfig field_trials_; @@ -227,20 +223,20 @@ TEST(RtpVideoSenderTest, SendOnOneModule) { EXPECT_NE(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image, nullptr).error); - test.SetActiveModules({true}); + test.SetSending(true); EXPECT_EQ(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image, nullptr).error); - test.SetActiveModules({false}); + test.SetSending(false); EXPECT_NE(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image, nullptr).error); - test.SetActiveModules({true}); + test.SetSending(true); EXPECT_EQ(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image, nullptr).error); } -TEST(RtpVideoSenderTest, SendSimulcastSetActive) { +TEST(RtpVideoSenderTest, OnEncodedImageReturnOkWhenSendingTrue) { constexpr uint8_t kPayload = 'a'; EncodedImage encoded_image_1; encoded_image_1.SetRtpTimestamp(1); @@ -254,7 +250,7 @@ TEST(RtpVideoSenderTest, SendSimulcastSetActive) { CodecSpecificInfo codec_info; codec_info.codecType = kVideoCodecVP8; - test.SetActiveModules({true, true}); + test.SetSending(true); EXPECT_EQ(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); @@ -262,20 +258,9 @@ TEST(RtpVideoSenderTest, SendSimulcastSetActive) { encoded_image_2.SetSimulcastIndex(1); EXPECT_EQ(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image_2, &codec_info).error); - - // Inactive. - test.Stop(); - EXPECT_NE(EncodedImageCallback::Result::OK, - test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); - EXPECT_NE(EncodedImageCallback::Result::OK, - test.router()->OnEncodedImage(encoded_image_2, &codec_info).error); } -// Tests how setting individual rtp modules to active affects the overall -// behavior of the payload router. First sets one module to active and checks -// that outgoing data can be sent on this module, and checks that no data can -// be sent if both modules are inactive. -TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) { +TEST(RtpVideoSenderTest, OnEncodedImageReturnErrorCodeWhenSendingFalse) { constexpr uint8_t kPayload = 'a'; EncodedImage encoded_image_1; encoded_image_1.SetRtpTimestamp(1); @@ -291,23 +276,15 @@ TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) { CodecSpecificInfo codec_info; codec_info.codecType = kVideoCodecVP8; - // Only setting one stream to active will still set the payload router to - // active and allow sending data on the active stream. - std::vector active_modules({true, false}); - test.SetActiveModules(active_modules); - EXPECT_EQ(EncodedImageCallback::Result::OK, - test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); - - // Setting both streams to inactive will turn the payload router to + // Setting rtp streams to inactive will turn the payload router to // inactive. - active_modules = {false, false}; - test.SetActiveModules(active_modules); + test.SetSending(false); // An incoming encoded image will not ask the module to send outgoing data // because the payload router is inactive. EXPECT_NE(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); EXPECT_NE(EncodedImageCallback::Result::OK, - test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); + test.router()->OnEncodedImage(encoded_image_2, &codec_info).error); } TEST(RtpVideoSenderTest, @@ -324,7 +301,7 @@ TEST(RtpVideoSenderTest, codec_info.codecType = kVideoCodecVP8; RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); // A layer is sent on both rtp streams. test.router()->OnVideoLayersAllocationUpdated( {.active_spatial_layers = {{.rtp_stream_index = 0}, @@ -347,7 +324,7 @@ TEST(RtpVideoSenderTest, TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); std::map initial_states = test.router()->GetRtpPayloadStates(); @@ -372,7 +349,7 @@ TEST(RtpVideoSenderTest, CreateWithPreviousStates) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, states); - test.SetActiveModules({true, true}); + test.SetSending(true); std::map initial_states = test.router()->GetRtpPayloadStates(); @@ -412,7 +389,7 @@ TEST(RtpVideoSenderTest, FrameCountCallbacks) { test.router()->OnEncodedImage(encoded_image, nullptr).error); ::testing::Mock::VerifyAndClearExpectations(&callback); - test.SetActiveModules({true}); + test.SetSending(true); FrameCounts frame_counts; EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1)) @@ -441,7 +418,7 @@ TEST(RtpVideoSenderTest, FrameCountCallbacks) { TEST(RtpVideoSenderTest, DoesNotRetrasmitAckedPackets) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); constexpr uint8_t kPayload = 'a'; EncodedImage encoded_image; @@ -606,7 +583,7 @@ TEST(RtpVideoSenderTest, RetransmitsOnTransportWideLossInfo) { TEST(RtpVideoSenderTest, EarlyRetransmits) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); const uint8_t kPayload[1] = {'a'}; EncodedImage encoded_image; @@ -701,7 +678,7 @@ TEST(RtpVideoSenderTest, EarlyRetransmits) { TEST(RtpVideoSenderTest, SupportsDependencyDescriptor) { RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -773,7 +750,7 @@ TEST(RtpVideoSenderTest, EXPECT_TRUE(sent_packets.emplace_back(&extensions).Parse(packet)); return true; }); - test.SetActiveModules({true}); + test.SetSending(true); EncodedImage key_frame_image; key_frame_image._frameType = VideoFrameType::kVideoFrameKey; @@ -807,7 +784,7 @@ TEST(RtpVideoSenderTest, TEST(RtpVideoSenderTest, SupportsDependencyDescriptorForVp9) { RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -863,7 +840,7 @@ TEST(RtpVideoSenderTest, SupportsDependencyDescriptorForVp9) { TEST(RtpVideoSenderTest, SupportsDependencyDescriptorForVp9NotProvidedByEncoder) { RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -918,7 +895,7 @@ TEST(RtpVideoSenderTest, GenerateDependecyDescriptorForGenericCodecs) { test::ScopedKeyValueConfig field_trials( "WebRTC-GenericCodecDependencyDescriptor/Enabled/"); RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}, &field_trials); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -964,7 +941,7 @@ TEST(RtpVideoSenderTest, GenerateDependecyDescriptorForGenericCodecs) { TEST(RtpVideoSenderTest, SupportsStoppingUsingDependencyDescriptor) { RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -1049,7 +1026,7 @@ TEST(RtpVideoSenderTest, OverheadIsSubtractedFromTargetBitrate) { kRtpHeaderSizeBytes + kTransportPacketOverheadBytes; RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}, &field_trials); test.router()->OnTransportOverheadChanged(kTransportPacketOverheadBytes); - test.SetActiveModules({true}); + test.SetSending(true); { test.router()->OnBitrateUpdated(CreateBitrateAllocationUpdate(300000), @@ -1076,7 +1053,7 @@ TEST(RtpVideoSenderTest, OverheadIsSubtractedFromTargetBitrate) { TEST(RtpVideoSenderTest, ClearsPendingPacketsOnInactivation) { RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -1127,13 +1104,13 @@ TEST(RtpVideoSenderTest, ClearsPendingPacketsOnInactivation) { // Disable the sending module and advance time slightly. No packets should be // sent. - test.SetActiveModules({false}); + test.SetSending(false); test.AdvanceTime(TimeDelta::Millis(20)); EXPECT_TRUE(sent_packets.empty()); // Reactive the send module - any packets should have been removed, so nothing // should be transmitted. - test.SetActiveModules({true}); + test.SetSending(true); test.AdvanceTime(TimeDelta::Millis(33)); EXPECT_TRUE(sent_packets.empty()); @@ -1156,7 +1133,7 @@ TEST(RtpVideoSenderTest, ClearsPendingPacketsOnInactivation) { TEST(RtpVideoSenderTest, RetransmitsBaseLayerOnly) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); test.router()->SetRetransmissionMode(kRetransmitBaseLayer); constexpr uint8_t kPayload = 'a'; diff --git a/call/test/mock_rtp_transport_controller_send.h b/call/test/mock_rtp_transport_controller_send.h index b24e5a59ec..2a0bc233ff 100644 --- a/call/test/mock_rtp_transport_controller_send.h +++ b/call/test/mock_rtp_transport_controller_send.h @@ -50,6 +50,11 @@ class MockRtpTransportControllerSend DestroyRtpVideoSender, (RtpVideoSenderInterface*), (override)); + MOCK_METHOD(void, RegisterSendingRtpStream, (RtpRtcpInterface&), (override)); + MOCK_METHOD(void, + DeRegisterSendingRtpStream, + (RtpRtcpInterface&), + (override)); MOCK_METHOD(PacketRouter*, packet_router, (), (override)); MOCK_METHOD(NetworkStateEstimateObserver*, network_state_estimate_observer, diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc index e5ff2cd727..8c748dd81d 100644 --- a/video/video_send_stream_impl.cc +++ b/video/video_send_stream_impl.cc @@ -627,10 +627,9 @@ bool VideoSendStreamImpl::started() { void VideoSendStreamImpl::Start() { RTC_DCHECK_RUN_ON(&thread_checker_); - const std::vector active_layers(config_.rtp.ssrcs.size(), true); // This sender is allowed to send RTP packets. Start monitoring and allocating // a rate if there is also active encodings. (has_active_encodings_). - rtp_video_sender_->SetActiveModules(active_layers); + rtp_video_sender_->SetSending(true); if (!IsRunning() && has_active_encodings_) { StartupVideoSendStream(); } @@ -681,7 +680,7 @@ void VideoSendStreamImpl::Stop() { return; TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop"); - rtp_video_sender_->Stop(); + rtp_video_sender_->SetSending(false); if (IsRunning()) { StopVideoSendStream(); } diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc index e3a1618939..fe5f999a39 100644 --- a/video/video_send_stream_impl_unittest.cc +++ b/video/video_send_stream_impl_unittest.cc @@ -75,6 +75,7 @@ using ::testing::Invoke; using ::testing::Mock; using ::testing::NiceMock; using ::testing::Return; +using ::testing::SaveArg; constexpr int64_t kDefaultInitialBitrateBps = 333000; const double kDefaultBitratePriority = 0.5; @@ -87,8 +88,7 @@ std::string GetAlrProbingExperimentString() { } class MockRtpVideoSender : public RtpVideoSenderInterface { public: - MOCK_METHOD(void, SetActiveModules, (const std::vector&), (override)); - MOCK_METHOD(void, Stop, (), (override)); + MOCK_METHOD(void, SetSending, (bool sending), (override)); MOCK_METHOD(bool, IsActive, (), (override)); MOCK_METHOD(void, OnNetworkAvailability, (bool), (override)); MOCK_METHOD((std::map), @@ -158,19 +158,11 @@ class VideoSendStreamImplTest : public ::testing::Test { .WillRepeatedly(Return(&packet_router_)); EXPECT_CALL(transport_controller_, CreateRtpVideoSender) .WillRepeatedly(Return(&rtp_video_sender_)); - ON_CALL(rtp_video_sender_, Stop()).WillByDefault(::testing::Invoke([&] { - active_modules_.clear(); + ON_CALL(rtp_video_sender_, IsActive()).WillByDefault(Invoke([&]() { + return rtp_sending_; })); - ON_CALL(rtp_video_sender_, IsActive()) - .WillByDefault(::testing::Invoke([&]() { - for (bool enabled : active_modules_) { - if (enabled) - return true; - } - return false; - })); - ON_CALL(rtp_video_sender_, SetActiveModules) - .WillByDefault(::testing::SaveArg<0>(&active_modules_)); + ON_CALL(rtp_video_sender_, SetSending) + .WillByDefault(SaveArg<0>(&rtp_sending_)); } ~VideoSendStreamImplTest() {} @@ -225,7 +217,7 @@ class VideoSendStreamImplTest : public ::testing::Test { NiceMock bitrate_allocator_; NiceMock* video_stream_encoder_ = nullptr; NiceMock rtp_video_sender_; - std::vector active_modules_; + bool rtp_sending_ = false; RtcEventLogNull event_log_; VideoSendStream::Config config_;