Revert "Remame VideoSendStream::UpdateActiveSimulcastLayers to StartPerRtpStream"
This reverts commit d8c4de71722c9de38f942932be21d4015f32a3bc.
Reason for revert: Tentative revert due to possible perf regression. b/260123362
Original change's description:
> Remame VideoSendStream::UpdateActiveSimulcastLayers to StartPerRtpStream
>
> VideoSendStreamImpl::Start and VideoSendStream::Start are not used by PeerConnections, only StartPerRtpStream.
> Therefore this cl:
> - Change implementation of VideoSendStream::Start to use VideoSendStream::StartPerRtpStream. VideoSendstream::Start is kept for convenience.
> - Remove VideoSendStreamImpl::Start() since it was only used by tests that use call and is confusing.
> - RtpVideoSender::SetActive is removed/changed to RtpVideoSender::Stop(). For normal operations RtpVideoSender::SetActiveModules is used.
>
> Bug: none
> Change-Id: I43b153250b07c02fe63c84e3c4cec18d4ec0d47a
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/283660
> Reviewed-by: Erik Språng <sprang@webrtc.org>
> Commit-Queue: Per Kjellander <perkj@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#38698}
Bug: none
Change-Id: I4f0d27679e51361b9ec54d2ae8e4d972527875d1
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/284940
Reviewed-by: Per Kjellander <perkj@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Auto-Submit: Per Kjellander <perkj@webrtc.org>
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38725}
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 0852a7b..5d2d1f1 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -480,24 +480,33 @@
RTC_DCHECK(!registered_for_feedback_);
}
-void RtpVideoSender::Stop() {
+void RtpVideoSender::SetActive(bool active) {
RTC_DCHECK_RUN_ON(&transport_checker_);
MutexLock lock(&mutex_);
- if (!active_)
+ if (active_ == active)
return;
- const std::vector<bool> active_modules(rtp_streams_.size(), false);
+ const std::vector<bool> active_modules(rtp_streams_.size(), active);
SetActiveModulesLocked(active_modules);
+
+ auto* feedback_provider = transport_->GetStreamFeedbackProvider();
+ if (active && !registered_for_feedback_) {
+ feedback_provider->RegisterStreamFeedbackObserver(rtp_config_.ssrcs, this);
+ registered_for_feedback_ = true;
+ } else if (!active && registered_for_feedback_) {
+ feedback_provider->DeRegisterStreamFeedbackObserver(this);
+ registered_for_feedback_ = false;
+ }
}
-void RtpVideoSender::SetActiveModules(const std::vector<bool>& active_modules) {
+void RtpVideoSender::SetActiveModules(const std::vector<bool> active_modules) {
RTC_DCHECK_RUN_ON(&transport_checker_);
MutexLock lock(&mutex_);
return SetActiveModulesLocked(active_modules);
}
void RtpVideoSender::SetActiveModulesLocked(
- const std::vector<bool>& active_modules) {
+ const std::vector<bool> active_modules) {
RTC_DCHECK_RUN_ON(&transport_checker_);
RTC_DCHECK_EQ(rtp_streams_.size(), active_modules.size());
active_ = false;
@@ -529,17 +538,6 @@
/*remb_candidate=*/true);
}
}
- 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();
- feedback_provider->RegisterStreamFeedbackObserver(rtp_config_.ssrcs, this);
- registered_for_feedback_ = true;
- }
}
bool RtpVideoSender::IsActive() {
diff --git a/call/rtp_video_sender.h b/call/rtp_video_sender.h
index 9b88916..9804bd8 100644
--- a/call/rtp_video_sender.h
+++ b/call/rtp_video_sender.h
@@ -95,11 +95,13 @@
RtpVideoSender(const RtpVideoSender&) = delete;
RtpVideoSender& operator=(const RtpVideoSender&) = delete;
+ // RtpVideoSender will only route packets if being active, all packets will be
+ // dropped otherwise.
+ void SetActive(bool active) RTC_LOCKS_EXCLUDED(mutex_) override;
// 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<bool>& active_modules)
+ void SetActiveModules(std::vector<bool> active_modules)
RTC_LOCKS_EXCLUDED(mutex_) override;
- void Stop() RTC_LOCKS_EXCLUDED(mutex_) override;
bool IsActive() RTC_LOCKS_EXCLUDED(mutex_) override;
void OnNetworkAvailability(bool network_available)
@@ -155,7 +157,7 @@
private:
bool IsActiveLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
- void SetActiveModulesLocked(const std::vector<bool>& active_modules)
+ void SetActiveModulesLocked(std::vector<bool> active_modules)
RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void ConfigureProtection();
diff --git a/call/rtp_video_sender_interface.h b/call/rtp_video_sender_interface.h
index 3f28771..acb68e3 100644
--- a/call/rtp_video_sender_interface.h
+++ b/call/rtp_video_sender_interface.h
@@ -31,12 +31,12 @@
class RtpVideoSenderInterface : public EncodedImageCallback,
public FecControllerOverride {
public:
+ // RtpVideoSender will only route packets if being active, all
+ // packets will be dropped otherwise.
+ virtual void SetActive(bool active) = 0;
// 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<bool>& active_modules) = 0;
- // Set the sending status of all rtp modules to inactive.
- virtual void Stop() = 0;
+ virtual void SetActiveModules(std::vector<bool> active_modules) = 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 a8595e3..3ce9ca2 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -187,14 +187,14 @@
/*frame_transformer=*/nullptr,
field_trials) {}
- ~RtpVideoSenderTestFixture() { Stop(); }
+ ~RtpVideoSenderTestFixture() { SetActive(false); }
RtpVideoSender* router() { return router_.get(); }
MockTransport& transport() { return transport_; }
void AdvanceTime(TimeDelta delta) { time_controller_.AdvanceTime(delta); }
- void Stop() {
- RunOnTransportQueue([&]() { router_->Stop(); });
+ void SetActive(bool active) {
+ RunOnTransportQueue([&]() { router_->SetActive(active); });
}
void SetActiveModules(const std::vector<bool>& active_modules) {
@@ -249,15 +249,15 @@
EXPECT_NE(EncodedImageCallback::Result::OK,
test.router()->OnEncodedImage(encoded_image, nullptr).error);
- test.SetActiveModules({true});
+ test.SetActive(true);
EXPECT_EQ(EncodedImageCallback::Result::OK,
test.router()->OnEncodedImage(encoded_image, nullptr).error);
- test.SetActiveModules({false});
+ test.SetActive(false);
EXPECT_NE(EncodedImageCallback::Result::OK,
test.router()->OnEncodedImage(encoded_image, nullptr).error);
- test.SetActiveModules({true});
+ test.SetActive(true);
EXPECT_EQ(EncodedImageCallback::Result::OK,
test.router()->OnEncodedImage(encoded_image, nullptr).error);
}
@@ -276,7 +276,7 @@
CodecSpecificInfo codec_info;
codec_info.codecType = kVideoCodecVP8;
- test.SetActiveModules({true, true});
+ test.SetActive(true);
EXPECT_EQ(EncodedImageCallback::Result::OK,
test.router()->OnEncodedImage(encoded_image_1, &codec_info).error);
@@ -286,7 +286,7 @@
test.router()->OnEncodedImage(encoded_image_2, &codec_info).error);
// Inactive.
- test.Stop();
+ test.SetActive(false);
EXPECT_NE(EncodedImageCallback::Result::OK,
test.router()->OnEncodedImage(encoded_image_1, &codec_info).error);
EXPECT_NE(EncodedImageCallback::Result::OK,
@@ -370,7 +370,7 @@
TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) {
RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2},
kPayloadType, {});
- test.SetActiveModules({true, true});
+ test.SetActive(true);
std::map<uint32_t, RtpPayloadState> initial_states =
test.router()->GetRtpPayloadStates();
@@ -395,7 +395,7 @@
RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2},
kPayloadType, states);
- test.SetActiveModules({true, true});
+ test.SetActive(true);
std::map<uint32_t, RtpPayloadState> initial_states =
test.router()->GetRtpPayloadStates();
@@ -435,7 +435,7 @@
test.router()->OnEncodedImage(encoded_image, nullptr).error);
::testing::Mock::VerifyAndClearExpectations(&callback);
- test.SetActiveModules({true});
+ test.SetActive(true);
FrameCounts frame_counts;
EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1))
@@ -464,7 +464,7 @@
TEST(RtpVideoSenderTest, DoesNotRetrasmitAckedPackets) {
RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2},
kPayloadType, {});
- test.SetActiveModules({true, true});
+ test.SetActive(true);
constexpr uint8_t kPayload = 'a';
EncodedImage encoded_image;
@@ -629,7 +629,7 @@
TEST(RtpVideoSenderTest, EarlyRetransmits) {
RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2},
kPayloadType, {});
- test.SetActiveModules({true, true});
+ test.SetActive(true);
const uint8_t kPayload[1] = {'a'};
EncodedImage encoded_image;
@@ -724,7 +724,7 @@
TEST(RtpVideoSenderTest, SupportsDependencyDescriptor) {
RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {});
- test.SetActiveModules({true});
+ test.SetActive(true);
RtpHeaderExtensionMap extensions;
extensions.Register<RtpDependencyDescriptorExtension>(
@@ -797,7 +797,7 @@
sent_packets.emplace_back(&extensions).Parse(packet, length));
return true;
});
- test.SetActiveModules({true});
+ test.SetActive(true);
EncodedImage key_frame_image;
key_frame_image._frameType = VideoFrameType::kVideoFrameKey;
@@ -831,7 +831,7 @@
TEST(RtpVideoSenderTest, SupportsDependencyDescriptorForVp9) {
RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {});
- test.SetActiveModules({true});
+ test.SetActive(true);
RtpHeaderExtensionMap extensions;
extensions.Register<RtpDependencyDescriptorExtension>(
@@ -887,7 +887,7 @@
TEST(RtpVideoSenderTest,
SupportsDependencyDescriptorForVp9NotProvidedByEncoder) {
RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {});
- test.SetActiveModules({true});
+ test.SetActive(true);
RtpHeaderExtensionMap extensions;
extensions.Register<RtpDependencyDescriptorExtension>(
@@ -942,7 +942,7 @@
test::ScopedKeyValueConfig field_trials(
"WebRTC-GenericCodecDependencyDescriptor/Enabled/");
RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}, &field_trials);
- test.SetActiveModules({true});
+ test.SetActive(true);
RtpHeaderExtensionMap extensions;
extensions.Register<RtpDependencyDescriptorExtension>(
@@ -988,7 +988,7 @@
TEST(RtpVideoSenderTest, SupportsStoppingUsingDependencyDescriptor) {
RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {});
- test.SetActiveModules({true});
+ test.SetActive(true);
RtpHeaderExtensionMap extensions;
extensions.Register<RtpDependencyDescriptorExtension>(
@@ -1073,7 +1073,7 @@
kRtpHeaderSizeBytes + kTransportPacketOverheadBytes;
RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}, &field_trials);
test.router()->OnTransportOverheadChanged(kTransportPacketOverheadBytes);
- test.SetActiveModules({true});
+ test.SetActive(true);
{
test.router()->OnBitrateUpdated(CreateBitrateAllocationUpdate(300000),
diff --git a/call/video_send_stream.h b/call/video_send_stream.h
index 9608281..e54a51d 100644
--- a/call/video_send_stream.h
+++ b/call/video_send_stream.h
@@ -216,15 +216,11 @@
// Note: This starts stream activity if it is inactive and one of the layers
// is active. This stops stream activity if it is active and all layers are
// inactive.
- // `active_layers` should have the same size as the number of configured
- // simulcast layers or one if only one rtp stream is used.
- virtual void StartPerRtpStream(std::vector<bool> active_layers) = 0;
+ virtual void UpdateActiveSimulcastLayers(std::vector<bool> active_layers) = 0;
// Starts stream activity.
// When a stream is active, it can receive, process and deliver packets.
- // Prefer to use StartPerRtpStream.
virtual void Start() = 0;
-
// Stops stream activity.
// When a stream is stopped, it can't receive, process or deliver packets.
virtual void Stop() = 0;
@@ -232,9 +228,9 @@
// Accessor for determining if the stream is active. This is an inexpensive
// call that must be made on the same thread as `Start()` and `Stop()` methods
// are called on and will return `true` iff activity has been started either
- // via `Start()` or `StartPerRtpStream()`. If activity is either
+ // via `Start()` or `UpdateActiveSimulcastLayers()`. If activity is either
// stopped or is in the process of being stopped as a result of a call to
- // either `Stop()` or `StartPerRtpStream()` where all layers were
+ // either `Stop()` or `UpdateActiveSimulcastLayers()` where all layers were
// deactivated, the return value will be `false`.
virtual bool started() = 0;
diff --git a/media/engine/fake_webrtc_call.cc b/media/engine/fake_webrtc_call.cc
index 8046c3a..063be93 100644
--- a/media/engine/fake_webrtc_call.cc
+++ b/media/engine/fake_webrtc_call.cc
@@ -338,7 +338,7 @@
webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
}
-void FakeVideoSendStream::StartPerRtpStream(
+void FakeVideoSendStream::UpdateActiveSimulcastLayers(
const std::vector<bool> active_layers) {
sending_ = false;
for (const bool active_layer : active_layers) {
diff --git a/media/engine/fake_webrtc_call.h b/media/engine/fake_webrtc_call.h
index 370b707..a3876b3 100644
--- a/media/engine/fake_webrtc_call.h
+++ b/media/engine/fake_webrtc_call.h
@@ -202,7 +202,7 @@
void OnFrame(const webrtc::VideoFrame& frame) override;
// webrtc::VideoSendStream implementation.
- void StartPerRtpStream(std::vector<bool> active_layers) override;
+ void UpdateActiveSimulcastLayers(std::vector<bool> active_layers) override;
void Start() override;
void Stop() override;
bool started() override { return IsSending(); }
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index d4bdeff..8dfc46c 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -2439,7 +2439,7 @@
}
// This updates what simulcast layers are sending, and possibly starts
// or stops the VideoSendStream.
- stream_->StartPerRtpStream(active_layers);
+ stream_->UpdateActiveSimulcastLayers(active_layers);
} else {
if (stream_ != nullptr) {
stream_->Stop();
@@ -2846,7 +2846,7 @@
parameters_.encoder_config.encoder_specific_settings = NULL;
- // Calls stream_->StartPerRtpStream() to start the VideoSendStream
+ // Calls stream_->UpdateActiveSimulcastLayers() to start the VideoSendStream
// if necessary conditions are met.
UpdateSendState();
diff --git a/test/call_test.cc b/test/call_test.cc
index 156b8a7..7e7c9bb 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -591,11 +591,8 @@
}
void CallTest::StartVideoStreams() {
- for (size_t i = 0; i < video_send_streams_.size(); ++i) {
- std::vector<bool> active_rtp_streams(
- video_send_configs_[i].rtp.ssrcs.size(), true);
- video_send_streams_[i]->StartPerRtpStream(active_rtp_streams);
- }
+ for (VideoSendStream* video_send_stream : video_send_streams_)
+ video_send_stream->Start();
for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_)
video_recv_stream->Start();
}
diff --git a/test/scenario/video_stream.cc b/test/scenario/video_stream.cc
index 96ced83..ad352f9 100644
--- a/test/scenario/video_stream.cc
+++ b/test/scenario/video_stream.cc
@@ -480,7 +480,7 @@
MutexLock lock(&mutex_);
if (config_.encoder.codec ==
VideoStreamConfig::Encoder::Codec::kVideoCodecVP8) {
- send_stream_->StartPerRtpStream(active_layers);
+ send_stream_->UpdateActiveSimulcastLayers(active_layers);
}
VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config_);
RTC_CHECK_EQ(encoder_config.simulcast_layers.size(), active_layers.size());
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index e5545e7..30598c1 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -209,12 +209,8 @@
transport_->DestroyRtpVideoSender(rtp_video_sender_);
}
-void VideoSendStream::Start() {
- const std::vector<bool> active_layers(config_.rtp.ssrcs.size(), true);
- StartPerRtpStream(active_layers);
-}
-
-void VideoSendStream::StartPerRtpStream(const std::vector<bool> active_layers) {
+void VideoSendStream::UpdateActiveSimulcastLayers(
+ const std::vector<bool> active_layers) {
RTC_DCHECK_RUN_ON(&thread_checker_);
// Keep our `running_` flag expected state in sync with active layers since
@@ -236,16 +232,35 @@
}
}
active_layers_string << "}";
- RTC_LOG(LS_INFO) << "StartPerRtpStream: " << active_layers_string.str();
+ RTC_LOG(LS_INFO) << "UpdateActiveSimulcastLayers: "
+ << active_layers_string.str();
rtp_transport_queue_->RunOrPost(
SafeTask(transport_queue_safety_, [this, active_layers] {
- send_stream_.StartPerRtpStream(active_layers);
+ send_stream_.UpdateActiveSimulcastLayers(active_layers);
}));
running_ = running;
}
+void VideoSendStream::Start() {
+ RTC_DCHECK_RUN_ON(&thread_checker_);
+ RTC_DLOG(LS_INFO) << "VideoSendStream::Start";
+ if (running_)
+ return;
+
+ running_ = true;
+
+ // It is expected that after VideoSendStream::Start has been called, incoming
+ // frames are not dropped in VideoStreamEncoder. To ensure this, Start has to
+ // be synchronized.
+ // TODO(tommi): ^^^ Validate if this still holds.
+ rtp_transport_queue_->RunSynchronous([this] {
+ transport_queue_safety_->SetAlive();
+ send_stream_.Start();
+ });
+}
+
void VideoSendStream::Stop() {
RTC_DCHECK_RUN_ON(&thread_checker_);
if (!running_)
diff --git a/video/video_send_stream.h b/video/video_send_stream.h
index a7ce112..a052b85 100644
--- a/video/video_send_stream.h
+++ b/video/video_send_stream.h
@@ -78,8 +78,8 @@
void DeliverRtcp(const uint8_t* packet, size_t length);
// webrtc::VideoSendStream implementation.
+ void UpdateActiveSimulcastLayers(std::vector<bool> active_layers) override;
void Start() override;
- void StartPerRtpStream(std::vector<bool> active_layers) override;
void Stop() override;
bool started() override;
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index f34388e..06f6a05 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -312,18 +312,31 @@
rtp_video_sender_->DeliverRtcp(packet, length);
}
-void VideoSendStreamImpl::StartPerRtpStream(
+void VideoSendStreamImpl::UpdateActiveSimulcastLayers(
const std::vector<bool> active_layers) {
RTC_DCHECK_RUN_ON(rtp_transport_queue_);
bool previously_active = rtp_video_sender_->IsActive();
rtp_video_sender_->SetActiveModules(active_layers);
if (!rtp_video_sender_->IsActive() && previously_active) {
+ // Payload router switched from active to inactive.
StopVideoSendStream();
} else if (rtp_video_sender_->IsActive() && !previously_active) {
+ // Payload router switched from inactive to active.
StartupVideoSendStream();
}
}
+void VideoSendStreamImpl::Start() {
+ RTC_DCHECK_RUN_ON(rtp_transport_queue_);
+ RTC_LOG(LS_INFO) << "VideoSendStream::Start";
+ if (rtp_video_sender_->IsActive())
+ return;
+
+ TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Start");
+ rtp_video_sender_->SetActive(true);
+ StartupVideoSendStream();
+}
+
void VideoSendStreamImpl::StartupVideoSendStream() {
RTC_DCHECK_RUN_ON(rtp_transport_queue_);
transport_queue_safety_->SetAlive();
@@ -365,7 +378,7 @@
RTC_DCHECK(transport_queue_safety_->alive());
TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop");
- rtp_video_sender_->Stop();
+ rtp_video_sender_->SetActive(false);
StopVideoSendStream();
}
diff --git a/video/video_send_stream_impl.h b/video/video_send_stream_impl.h
index f145450..d444eab 100644
--- a/video/video_send_stream_impl.h
+++ b/video/video_send_stream_impl.h
@@ -79,7 +79,8 @@
~VideoSendStreamImpl() override;
void DeliverRtcp(const uint8_t* packet, size_t length);
- void StartPerRtpStream(std::vector<bool> active_layers);
+ void UpdateActiveSimulcastLayers(std::vector<bool> active_layers);
+ void Start();
void Stop();
// TODO(holmer): Move these to RtpTransportControllerSend.
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index c38dcd0..8a88ba0 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -66,8 +66,8 @@
}
class MockRtpVideoSender : public RtpVideoSenderInterface {
public:
- MOCK_METHOD(void, SetActiveModules, (const std::vector<bool>&), (override));
- MOCK_METHOD(void, Stop, (), (override));
+ MOCK_METHOD(void, SetActive, (bool), (override));
+ MOCK_METHOD(void, SetActiveModules, (const std::vector<bool>), (override));
MOCK_METHOD(bool, IsActive, (), (override));
MOCK_METHOD(void, OnNetworkAvailability, (bool), (override));
MOCK_METHOD((std::map<uint32_t, RtpState>),
@@ -139,19 +139,12 @@
.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(::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_));
+ EXPECT_CALL(rtp_video_sender_, SetActive(_))
+ .WillRepeatedly(::testing::Invoke(
+ [&](bool active) { rtp_video_sender_active_ = active; }));
+ EXPECT_CALL(rtp_video_sender_, IsActive())
+ .WillRepeatedly(
+ ::testing::Invoke([&]() { return rtp_video_sender_active_; }));
ON_CALL(transport_controller_, GetWorkerQueue())
.WillByDefault(Return(&worker_queue_));
}
@@ -190,8 +183,8 @@
NiceMock<MockBitrateAllocator> bitrate_allocator_;
NiceMock<MockVideoStreamEncoder> video_stream_encoder_;
NiceMock<MockRtpVideoSender> rtp_video_sender_;
- std::vector<bool> active_modules_;
+ bool rtp_video_sender_active_ = false;
RtcEventLogNull event_log_;
VideoSendStream::Config config_;
SendDelayStats send_delay_stats_;
@@ -217,7 +210,7 @@
EXPECT_EQ(config.bitrate_priority, kDefaultBitratePriority);
}));
worker_queue_.RunSynchronous([&] {
- vss_impl->StartPerRtpStream({true});
+ vss_impl->Start();
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())).Times(1);
vss_impl->Stop();
});
@@ -232,7 +225,7 @@
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kRealtimeVideo);
- worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+ worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
// QVGA + VGA configuration matching defaults in
// media/engine/simulcast.cc.
@@ -298,7 +291,7 @@
auto vss_impl = CreateVideoSendStreamImpl(
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kScreen);
- worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+ worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
// Simulcast screenshare.
VideoStream low_stream;
@@ -364,7 +357,7 @@
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kRealtimeVideo);
- worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+ worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
// 2-layer video simulcast.
VideoStream low_stream;
low_stream.width = 320;
@@ -429,7 +422,7 @@
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kScreen);
worker_queue_.RunSynchronous([&] {
- vss_impl->StartPerRtpStream({true});
+ vss_impl->Start();
vss_impl->Stop();
});
}
@@ -441,7 +434,7 @@
VideoEncoderConfig::ContentType::kScreen);
worker_queue_.RunSynchronous([&] {
EXPECT_CALL(transport_controller_, SetPacingFactor(_)).Times(0);
- vss_impl->StartPerRtpStream({true});
+ vss_impl->Start();
vss_impl->Stop();
});
}
@@ -454,7 +447,7 @@
EXPECT_CALL(transport_controller_, SetPacingFactor(_)).Times(0);
VideoStreamEncoderInterface::EncoderSink* const sink =
static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get());
- worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+ worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
// Populate a test instance of video bitrate allocation.
VideoBitrateAllocation alloc;
alloc.SetBitrate(0, 0, 10000);
@@ -501,7 +494,7 @@
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kScreen);
worker_queue_.RunSynchronous([&] {
- vss_impl->StartPerRtpStream({true});
+ vss_impl->Start();
// Unpause encoder, to allows allocations to be passed through.
const uint32_t kBitrateBps = 100000;
EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
@@ -563,7 +556,7 @@
VideoEncoderConfig::ContentType::kScreen);
worker_queue_.RunSynchronous([&] {
- vss_impl->StartPerRtpStream({true});
+ vss_impl->Start();
// Unpause encoder, to allows allocations to be passed through.
const uint32_t kBitrateBps = 100000;
EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
@@ -606,7 +599,7 @@
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kScreen);
worker_queue_.RunSynchronous([&] {
- vss_impl->StartPerRtpStream({true});
+ vss_impl->Start();
const uint32_t kBitrateBps = 100000;
// Unpause encoder, to allows allocations to be passed through.
EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
@@ -716,7 +709,7 @@
auto vss_impl = CreateVideoSendStreamImpl(
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kRealtimeVideo);
- worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+ worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
VideoStream qvga_stream;
qvga_stream.width = 320;
qvga_stream.height = 180;
@@ -849,7 +842,7 @@
int min_transmit_bitrate_bps = 30000;
config_.rtp.ssrcs.emplace_back(1);
- worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+ worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
// Starts without padding.
EXPECT_EQ(0, padding_bitrate);
encoder_queue_->PostTask([&] {
@@ -900,7 +893,7 @@
VideoEncoderConfig::ContentType::kRealtimeVideo);
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())).Times(0);
worker_queue_.RunSynchronous([&] {
- vss_impl->StartPerRtpStream({true});
+ vss_impl->Start();
const uint32_t kBitrateBps = 100000;
EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
.Times(1)
@@ -948,7 +941,7 @@
? VideoEncoderConfig::ContentType::kScreen
: VideoEncoderConfig::ContentType::kRealtimeVideo);
- worker_queue_.RunSynchronous([&] { vss_impl->StartPerRtpStream({true}); });
+ worker_queue_.RunSynchronous([&] { vss_impl->Start(); });
// Svc
VideoStream stream;
