From eb61b7f620c1f84cb9d34c7752cea65fe5d1d721 Mon Sep 17 00:00:00 2001 From: Markus Handell Date: Tue, 22 Jun 2021 10:46:48 +0200 Subject: ModuleRtcRtcpImpl2: remove Module inheritance. This change achieves an Idle Wakeup savings of 200 Hz. ModuleRtcRtcpImpl2 had Process() logic only active if TMMBR() is enabled in RtcpSender, which it never is. Hence the Module inheritance could be removed. The change removes all known dependencies of the module inheritance, and any related mentions of ProcessThread. Fixed: webrtc:11581 Change-Id: I440942f07187fdb9ac18186dab088633969b340e Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/222604 Reviewed-by: Tommi Reviewed-by: Harald Alvestrand Commit-Queue: Markus Handell Cr-Commit-Position: refs/heads/master@{#34358} --- audio/audio_receive_stream.cc | 12 ++---- audio/audio_receive_stream.h | 1 - audio/audio_send_stream.cc | 2 - audio/audio_send_stream.h | 1 - audio/channel_receive.cc | 27 +++---------- audio/channel_receive.h | 2 - audio/channel_send.cc | 23 ++--------- audio/channel_send.h | 2 - audio/voip/audio_channel.cc | 13 ++----- audio/voip/audio_channel.h | 5 --- audio/voip/test/audio_channel_unittest.cc | 7 +--- audio/voip/test/voip_core_unittest.cc | 34 +--------------- audio/voip/voip_core.cc | 28 +++----------- audio/voip/voip_core.h | 8 +--- call/call.cc | 18 ++++----- call/flexfec_receive_stream_impl.cc | 8 +--- call/flexfec_receive_stream_impl.h | 12 ++---- call/flexfec_receive_stream_unittest.cc | 11 +----- call/rtp_video_sender.cc | 21 ---------- call/rtp_video_sender.h | 12 ------ call/rtp_video_sender_interface.h | 4 -- modules/rtp_rtcp/source/nack_rtx_unittest.cc | 2 - modules/rtp_rtcp/source/rtcp_sender.cc | 2 + modules/rtp_rtcp/source/rtcp_sender.h | 5 +++ modules/rtp_rtcp/source/rtp_rtcp_impl2.cc | 45 ---------------------- modules/rtp_rtcp/source/rtp_rtcp_impl2.h | 11 ------ modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc | 19 +-------- video/rtp_video_stream_receiver2.cc | 7 ---- video/rtp_video_stream_receiver2.h | 3 -- video/rtp_video_stream_receiver2_unittest.cc | 13 +++---- video/video_receive_stream2.cc | 3 -- video/video_receive_stream2.h | 3 -- video/video_receive_stream2_unittest.cc | 22 +++-------- video/video_send_stream.cc | 3 -- video/video_send_stream.h | 2 - video/video_send_stream_impl_unittest.cc | 2 - video/video_send_stream_tests.cc | 1 - 37 files changed, 59 insertions(+), 335 deletions(-) diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc index 6ec266b68d..d4e9c0ea77 100644 --- a/audio/audio_receive_stream.cc +++ b/audio/audio_receive_stream.cc @@ -70,7 +70,6 @@ namespace { std::unique_ptr CreateChannelReceive( Clock* clock, webrtc::AudioState* audio_state, - ProcessThread* module_process_thread, NetEqFactory* neteq_factory, const webrtc::AudioReceiveStream::Config& config, RtcEventLog* event_log) { @@ -78,11 +77,10 @@ std::unique_ptr CreateChannelReceive( internal::AudioState* internal_audio_state = static_cast(audio_state); return voe::CreateChannelReceive( - clock, module_process_thread, neteq_factory, - internal_audio_state->audio_device_module(), config.rtcp_send_transport, - event_log, config.rtp.local_ssrc, config.rtp.remote_ssrc, - config.jitter_buffer_max_packets, config.jitter_buffer_fast_accelerate, - config.jitter_buffer_min_delay_ms, + clock, neteq_factory, internal_audio_state->audio_device_module(), + config.rtcp_send_transport, event_log, config.rtp.local_ssrc, + config.rtp.remote_ssrc, config.jitter_buffer_max_packets, + config.jitter_buffer_fast_accelerate, config.jitter_buffer_min_delay_ms, config.jitter_buffer_enable_rtx_handling, config.decoder_factory, config.codec_pair_id, std::move(config.frame_decryptor), config.crypto_options, std::move(config.frame_transformer)); @@ -92,7 +90,6 @@ std::unique_ptr CreateChannelReceive( AudioReceiveStream::AudioReceiveStream( Clock* clock, PacketRouter* packet_router, - ProcessThread* module_process_thread, NetEqFactory* neteq_factory, const webrtc::AudioReceiveStream::Config& config, const rtc::scoped_refptr& audio_state, @@ -104,7 +101,6 @@ AudioReceiveStream::AudioReceiveStream( event_log, CreateChannelReceive(clock, audio_state.get(), - module_process_thread, neteq_factory, config, event_log)) {} diff --git a/audio/audio_receive_stream.h b/audio/audio_receive_stream.h index dc64e94510..61ebc2719f 100644 --- a/audio/audio_receive_stream.h +++ b/audio/audio_receive_stream.h @@ -48,7 +48,6 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream, public: AudioReceiveStream(Clock* clock, PacketRouter* packet_router, - ProcessThread* module_process_thread, NetEqFactory* neteq_factory, const webrtc::AudioReceiveStream::Config& config, const rtc::scoped_refptr& audio_state, diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc index aca7cd38b8..5d7bc71659 100644 --- a/audio/audio_send_stream.cc +++ b/audio/audio_send_stream.cc @@ -102,7 +102,6 @@ AudioSendStream::AudioSendStream( const webrtc::AudioSendStream::Config& config, const rtc::scoped_refptr& audio_state, TaskQueueFactory* task_queue_factory, - ProcessThread* module_process_thread, RtpTransportControllerSendInterface* rtp_transport, BitrateAllocatorInterface* bitrate_allocator, RtcEventLog* event_log, @@ -119,7 +118,6 @@ AudioSendStream::AudioSendStream( voe::CreateChannelSend( clock, task_queue_factory, - module_process_thread, config.send_transport, rtcp_rtt_stats, event_log, diff --git a/audio/audio_send_stream.h b/audio/audio_send_stream.h index 223328b26b..e0b15dc0c9 100644 --- a/audio/audio_send_stream.h +++ b/audio/audio_send_stream.h @@ -58,7 +58,6 @@ class AudioSendStream final : public webrtc::AudioSendStream, const webrtc::AudioSendStream::Config& config, const rtc::scoped_refptr& audio_state, TaskQueueFactory* task_queue_factory, - ProcessThread* module_process_thread, RtpTransportControllerSendInterface* rtp_transport, BitrateAllocatorInterface* bitrate_allocator, RtcEventLog* event_log, diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc index 150e2074e4..acab1467f4 100644 --- a/audio/channel_receive.cc +++ b/audio/channel_receive.cc @@ -86,7 +86,6 @@ class ChannelReceive : public ChannelReceiveInterface { // Used for receive streams. ChannelReceive( Clock* clock, - ProcessThread* module_process_thread, NetEqFactory* neteq_factory, AudioDeviceModule* audio_device_module, Transport* rtcp_send_transport, @@ -269,7 +268,6 @@ class ChannelReceive : public ChannelReceiveInterface { // frame. int64_t capture_start_ntp_time_ms_ RTC_GUARDED_BY(ts_stats_lock_); - ProcessThread* const module_process_thread_; AudioDeviceModule* _audioDeviceModulePtr; float _outputGain RTC_GUARDED_BY(volume_settings_mutex_); @@ -507,7 +505,6 @@ void ChannelReceive::SetSourceTracker(SourceTracker* source_tracker) { ChannelReceive::ChannelReceive( Clock* clock, - ProcessThread* module_process_thread, NetEqFactory* neteq_factory, AudioDeviceModule* audio_device_module, Transport* rtcp_send_transport, @@ -540,15 +537,12 @@ ChannelReceive::ChannelReceive( rtp_ts_wraparound_handler_(new rtc::TimestampWrapAroundHandler()), capture_start_rtp_time_stamp_(-1), capture_start_ntp_time_ms_(-1), - module_process_thread_(module_process_thread), _audioDeviceModulePtr(audio_device_module), _outputGain(1.0f), associated_send_channel_(nullptr), frame_decryptor_(frame_decryptor), crypto_options_(crypto_options), absolute_capture_time_interpolator_(clock) { - RTC_DCHECK(worker_thread_); - RTC_DCHECK(module_process_thread_); RTC_DCHECK(audio_device_module); network_thread_checker_.Detach(); @@ -579,20 +573,11 @@ ChannelReceive::ChannelReceive( // Ensure that RTCP is enabled for the created channel. rtp_rtcp_->SetRTCPStatus(RtcpMode::kCompound); - - // TODO(tommi): This should be an implementation detail of ModuleRtpRtcpImpl2 - // and the pointer to the process thread should be there (which also localizes - // the problem of getting rid of that dependency). - module_process_thread_->RegisterModule(rtp_rtcp_.get(), RTC_FROM_HERE); } ChannelReceive::~ChannelReceive() { RTC_DCHECK_RUN_ON(&construction_thread_); - // Unregister the module before stopping playout etc, to match the order - // things were set up in the ctor. - module_process_thread_->DeRegisterModule(rtp_rtcp_.get()); - // Resets the delegate's callback to ChannelReceive::OnReceivedPayloadData. if (frame_transformer_delegate_) frame_transformer_delegate_->Reset(); @@ -1090,7 +1075,6 @@ int64_t ChannelReceive::GetRTT() const { std::unique_ptr CreateChannelReceive( Clock* clock, - ProcessThread* module_process_thread, NetEqFactory* neteq_factory, AudioDeviceModule* audio_device_module, Transport* rtcp_send_transport, @@ -1107,12 +1091,11 @@ std::unique_ptr CreateChannelReceive( const webrtc::CryptoOptions& crypto_options, rtc::scoped_refptr frame_transformer) { return std::make_unique( - clock, module_process_thread, neteq_factory, audio_device_module, - rtcp_send_transport, rtc_event_log, local_ssrc, remote_ssrc, - jitter_buffer_max_packets, jitter_buffer_fast_playout, - jitter_buffer_min_delay_ms, jitter_buffer_enable_rtx_handling, - decoder_factory, codec_pair_id, std::move(frame_decryptor), - crypto_options, std::move(frame_transformer)); + clock, neteq_factory, audio_device_module, rtcp_send_transport, + rtc_event_log, local_ssrc, remote_ssrc, jitter_buffer_max_packets, + jitter_buffer_fast_playout, jitter_buffer_min_delay_ms, + jitter_buffer_enable_rtx_handling, decoder_factory, codec_pair_id, + std::move(frame_decryptor), crypto_options, std::move(frame_transformer)); } } // namespace voe diff --git a/audio/channel_receive.h b/audio/channel_receive.h index 196e441fac..f5afe50f3b 100644 --- a/audio/channel_receive.h +++ b/audio/channel_receive.h @@ -44,7 +44,6 @@ namespace webrtc { class AudioDeviceModule; class FrameDecryptorInterface; class PacketRouter; -class ProcessThread; class RateLimiter; class ReceiveStatistics; class RtcEventLog; @@ -169,7 +168,6 @@ class ChannelReceiveInterface : public RtpPacketSinkInterface { std::unique_ptr CreateChannelReceive( Clock* clock, - ProcessThread* module_process_thread, NetEqFactory* neteq_factory, AudioDeviceModule* audio_device_module, Transport* rtcp_send_transport, diff --git a/audio/channel_send.cc b/audio/channel_send.cc index 47afc7982b..52dd528504 100644 --- a/audio/channel_send.cc +++ b/audio/channel_send.cc @@ -69,7 +69,6 @@ class ChannelSend : public ChannelSendInterface, ChannelSend(Clock* clock, TaskQueueFactory* task_queue_factory, - ProcessThread* module_process_thread, Transport* rtp_transport, RtcpRttStats* rtcp_rtt_stats, RtcEventLog* rtc_event_log, @@ -180,7 +179,6 @@ class ChannelSend : public ChannelSendInterface, // voe::Channel into parts with single-threaded semantics, and thereby reduce // the need for locks. SequenceChecker worker_thread_checker_; - SequenceChecker module_process_thread_checker_; // Methods accessed from audio and video threads are checked for sequential- // only access. We don't necessarily own and control these threads, so thread // checkers cannot be used. E.g. Chromium may transfer "ownership" from one @@ -200,7 +198,6 @@ class ChannelSend : public ChannelSendInterface, uint32_t _timeStamp RTC_GUARDED_BY(encoder_queue_); // uses - ProcessThread* const _moduleProcessThreadPtr; RmsLevel rms_level_ RTC_GUARDED_BY(encoder_queue_); bool input_mute_ RTC_GUARDED_BY(volume_settings_mutex_); bool previous_frame_muted_ RTC_GUARDED_BY(encoder_queue_); @@ -445,7 +442,6 @@ int32_t ChannelSend::SendRtpAudio(AudioFrameType frameType, ChannelSend::ChannelSend( Clock* clock, TaskQueueFactory* task_queue_factory, - ProcessThread* module_process_thread, Transport* rtp_transport, RtcpRttStats* rtcp_rtt_stats, RtcEventLog* rtc_event_log, @@ -459,7 +455,6 @@ ChannelSend::ChannelSend( : event_log_(rtc_event_log), _timeStamp(0), // This is just an offset, RTP module will add it's own // random offset - _moduleProcessThreadPtr(module_process_thread), input_mute_(false), previous_frame_muted_(false), _includeAudioLevelIndication(false), @@ -475,9 +470,6 @@ ChannelSend::ChannelSend( TaskQueueFactory::Priority::NORMAL)), fixing_timestamp_stall_( !field_trial::IsDisabled("WebRTC-Audio-FixTimestampStall")) { - RTC_DCHECK(module_process_thread); - module_process_thread_checker_.Detach(); - audio_coding_.reset(AudioCodingModule::Create(AudioCodingModule::Config())); RtpRtcpInterface::Configuration configuration; @@ -504,8 +496,6 @@ ChannelSend::ChannelSend( rtp_sender_audio_ = std::make_unique(configuration.clock, rtp_rtcp_->RtpSender()); - _moduleProcessThreadPtr->RegisterModule(rtp_rtcp_.get(), RTC_FROM_HERE); - // Ensure that RTCP is enabled by default for the created channel. rtp_rtcp_->SetRTCPStatus(RtcpMode::kCompound); @@ -525,9 +515,6 @@ ChannelSend::~ChannelSend() { StopSend(); int error = audio_coding_->RegisterTransportCallback(NULL); RTC_DCHECK_EQ(0, error); - - if (_moduleProcessThreadPtr) - _moduleProcessThreadPtr->DeRegisterModule(rtp_rtcp_.get()); } void ChannelSend::StartSend() { @@ -858,7 +845,6 @@ ANAStats ChannelSend::GetANAStatistics() const { } RtpRtcpInterface* ChannelSend::GetRtpRtcp() const { - RTC_DCHECK(module_process_thread_checker_.IsCurrent()); return rtp_rtcp_.get(); } @@ -930,7 +916,6 @@ void ChannelSend::InitFrameTransformerDelegate( std::unique_ptr CreateChannelSend( Clock* clock, TaskQueueFactory* task_queue_factory, - ProcessThread* module_process_thread, Transport* rtp_transport, RtcpRttStats* rtcp_rtt_stats, RtcEventLog* rtc_event_log, @@ -942,10 +927,10 @@ std::unique_ptr CreateChannelSend( rtc::scoped_refptr frame_transformer, TransportFeedbackObserver* feedback_observer) { return std::make_unique( - clock, task_queue_factory, module_process_thread, rtp_transport, - rtcp_rtt_stats, rtc_event_log, frame_encryptor, crypto_options, - extmap_allow_mixed, rtcp_report_interval_ms, ssrc, - std::move(frame_transformer), feedback_observer); + clock, task_queue_factory, rtp_transport, rtcp_rtt_stats, rtc_event_log, + frame_encryptor, crypto_options, extmap_allow_mixed, + rtcp_report_interval_ms, ssrc, std::move(frame_transformer), + feedback_observer); } } // namespace voe diff --git a/audio/channel_send.h b/audio/channel_send.h index 2e23ef5d2d..cbdb3ee70a 100644 --- a/audio/channel_send.h +++ b/audio/channel_send.h @@ -28,7 +28,6 @@ namespace webrtc { class FrameEncryptorInterface; -class ProcessThread; class RtcEventLog; class RtpTransportControllerSendInterface; @@ -126,7 +125,6 @@ class ChannelSendInterface { std::unique_ptr CreateChannelSend( Clock* clock, TaskQueueFactory* task_queue_factory, - ProcessThread* module_process_thread, Transport* rtp_transport, RtcpRttStats* rtcp_rtt_stats, RtcEventLog* rtc_event_log, diff --git a/audio/voip/audio_channel.cc b/audio/voip/audio_channel.cc index d11e6d79f9..b4a50eec12 100644 --- a/audio/voip/audio_channel.cc +++ b/audio/voip/audio_channel.cc @@ -32,12 +32,10 @@ AudioChannel::AudioChannel( Transport* transport, uint32_t local_ssrc, TaskQueueFactory* task_queue_factory, - ProcessThread* process_thread, AudioMixer* audio_mixer, rtc::scoped_refptr decoder_factory) - : audio_mixer_(audio_mixer), process_thread_(process_thread) { + : audio_mixer_(audio_mixer) { RTC_DCHECK(task_queue_factory); - RTC_DCHECK(process_thread); RTC_DCHECK(audio_mixer); Clock* clock = Clock::GetRealTimeClock(); @@ -56,9 +54,6 @@ AudioChannel::AudioChannel( rtp_rtcp_->SetSendingMediaStatus(false); rtp_rtcp_->SetRTCPStatus(RtcpMode::kCompound); - // ProcessThread periodically services RTP stack for RTCP. - process_thread_->RegisterModule(rtp_rtcp_.get(), RTC_FROM_HERE); - ingress_ = std::make_unique(rtp_rtcp_.get(), clock, receive_statistics_.get(), std::move(decoder_factory)); @@ -80,12 +75,10 @@ AudioChannel::~AudioChannel() { audio_mixer_->RemoveSource(ingress_.get()); - // AudioEgress could hold current global TaskQueueBase that we need to clear - // before ProcessThread::DeRegisterModule. + // TODO(bugs.webrtc.org/11581): unclear if we still need to clear |egress_| + // here. egress_.reset(); ingress_.reset(); - - process_thread_->DeRegisterModule(rtp_rtcp_.get()); } bool AudioChannel::StartSend() { diff --git a/audio/voip/audio_channel.h b/audio/voip/audio_channel.h index 7b9fa6f74e..7338d9faab 100644 --- a/audio/voip/audio_channel.h +++ b/audio/voip/audio_channel.h @@ -22,7 +22,6 @@ #include "audio/voip/audio_egress.h" #include "audio/voip/audio_ingress.h" #include "modules/rtp_rtcp/source/rtp_rtcp_impl2.h" -#include "modules/utility/include/process_thread.h" #include "rtc_base/ref_count.h" namespace webrtc { @@ -35,7 +34,6 @@ class AudioChannel : public rtc::RefCountInterface { AudioChannel(Transport* transport, uint32_t local_ssrc, TaskQueueFactory* task_queue_factory, - ProcessThread* process_thread, AudioMixer* audio_mixer, rtc::scoped_refptr decoder_factory); ~AudioChannel() override; @@ -120,9 +118,6 @@ class AudioChannel : public rtc::RefCountInterface { // Synchronization is handled internally by AudioMixer. AudioMixer* audio_mixer_; - // Synchronization is handled internally by ProcessThread. - ProcessThread* process_thread_; - // Listed in order for safe destruction of AudioChannel object. // Synchronization for these are handled internally. std::unique_ptr receive_statistics_; diff --git a/audio/voip/test/audio_channel_unittest.cc b/audio/voip/test/audio_channel_unittest.cc index f99d163022..a4f518c5bd 100644 --- a/audio/voip/test/audio_channel_unittest.cc +++ b/audio/voip/test/audio_channel_unittest.cc @@ -17,7 +17,6 @@ #include "modules/audio_mixer/audio_mixer_impl.h" #include "modules/audio_mixer/sine_wave_generator.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h" -#include "modules/utility/include/process_thread.h" #include "rtc_base/logging.h" #include "test/gmock.h" #include "test/gtest.h" @@ -43,7 +42,6 @@ class AudioChannelTest : public ::testing::Test { AudioChannelTest() : fake_clock_(kStartTime), wave_generator_(1000.0, kAudioLevel) { task_queue_factory_ = std::make_unique(&task_queue_); - process_thread_ = ProcessThread::Create("ModuleProcessThread"); audio_mixer_ = AudioMixerImpl::Create(); encoder_factory_ = CreateBuiltinAudioEncoderFactory(); decoder_factory_ = CreateBuiltinAudioDecoderFactory(); @@ -66,8 +64,8 @@ class AudioChannelTest : public ::testing::Test { // simplify network routing logic. rtc::scoped_refptr audio_channel = rtc::make_ref_counted( - &transport_, ssrc, task_queue_factory_.get(), process_thread_.get(), - audio_mixer_.get(), decoder_factory_); + &transport_, ssrc, task_queue_factory_.get(), audio_mixer_.get(), + decoder_factory_); audio_channel->SetEncoder(kPcmuPayload, kPcmuFormat, encoder_factory_->MakeAudioEncoder( kPcmuPayload, kPcmuFormat, absl::nullopt)); @@ -95,7 +93,6 @@ class AudioChannelTest : public ::testing::Test { rtc::scoped_refptr audio_mixer_; rtc::scoped_refptr decoder_factory_; rtc::scoped_refptr encoder_factory_; - std::unique_ptr process_thread_; rtc::scoped_refptr audio_channel_; }; diff --git a/audio/voip/test/voip_core_unittest.cc b/audio/voip/test/voip_core_unittest.cc index 0d407601a3..896d0d98bb 100644 --- a/audio/voip/test/voip_core_unittest.cc +++ b/audio/voip/test/voip_core_unittest.cc @@ -14,7 +14,6 @@ #include "api/task_queue/default_task_queue_factory.h" #include "modules/audio_device/include/mock_audio_device.h" #include "modules/audio_processing/include/mock_audio_processing.h" -#include "modules/utility/include/mock/mock_process_thread.h" #include "test/gtest.h" #include "test/mock_transport.h" @@ -41,20 +40,15 @@ class VoipCoreTest : public ::testing::Test { rtc::scoped_refptr audio_processing = rtc::make_ref_counted>(); - auto process_thread = std::make_unique>(); - // Hold the pointer to use for testing. - process_thread_ = process_thread.get(); - voip_core_ = std::make_unique( std::move(encoder_factory), std::move(decoder_factory), CreateDefaultTaskQueueFactory(), audio_device_, - std::move(audio_processing), std::move(process_thread)); + std::move(audio_processing)); } std::unique_ptr voip_core_; NiceMock transport_; rtc::scoped_refptr audio_device_; - NiceMock* process_thread_; }; // Validate expected API calls that involves with VoipCore. Some verification is @@ -192,31 +186,5 @@ TEST_F(VoipCoreTest, StopSendAndPlayoutWithoutStarting) { EXPECT_EQ(voip_core_->ReleaseChannel(channel), VoipResult::kOk); } -// This tests correctness on ProcessThread usage where we expect the first/last -// channel creation/release triggers its Start/Stop method once only. -TEST_F(VoipCoreTest, TestProcessThreadOperation) { - EXPECT_CALL(*process_thread_, Start); - EXPECT_CALL(*process_thread_, RegisterModule).Times(2); - - auto channel_one = voip_core_->CreateChannel(&transport_, 0xdeadc0de); - auto channel_two = voip_core_->CreateChannel(&transport_, 0xdeadbeef); - - EXPECT_CALL(*process_thread_, Stop); - EXPECT_CALL(*process_thread_, DeRegisterModule).Times(2); - - EXPECT_EQ(voip_core_->ReleaseChannel(channel_one), VoipResult::kOk); - EXPECT_EQ(voip_core_->ReleaseChannel(channel_two), VoipResult::kOk); - - EXPECT_CALL(*process_thread_, Start); - EXPECT_CALL(*process_thread_, RegisterModule); - - auto channel_three = voip_core_->CreateChannel(&transport_, absl::nullopt); - - EXPECT_CALL(*process_thread_, Stop); - EXPECT_CALL(*process_thread_, DeRegisterModule); - - EXPECT_EQ(voip_core_->ReleaseChannel(channel_three), VoipResult::kOk); -} - } // namespace } // namespace webrtc diff --git a/audio/voip/voip_core.cc b/audio/voip/voip_core.cc index 67ae4c6521..fd66379f4a 100644 --- a/audio/voip/voip_core.cc +++ b/audio/voip/voip_core.cc @@ -41,18 +41,12 @@ VoipCore::VoipCore(rtc::scoped_refptr encoder_factory, rtc::scoped_refptr decoder_factory, std::unique_ptr task_queue_factory, rtc::scoped_refptr audio_device_module, - rtc::scoped_refptr audio_processing, - std::unique_ptr process_thread) { + rtc::scoped_refptr audio_processing) { encoder_factory_ = std::move(encoder_factory); decoder_factory_ = std::move(decoder_factory); task_queue_factory_ = std::move(task_queue_factory); audio_device_module_ = std::move(audio_device_module); audio_processing_ = std::move(audio_processing); - process_thread_ = std::move(process_thread); - - if (!process_thread_) { - process_thread_ = ProcessThread::Create("ModuleProcessThread"); - } audio_mixer_ = AudioMixerImpl::Create(); // AudioTransportImpl depends on audio mixer and audio processing instances. @@ -138,19 +132,13 @@ ChannelId VoipCore::CreateChannel(Transport* transport, } rtc::scoped_refptr channel = - rtc::make_ref_counted( - transport, local_ssrc.value(), task_queue_factory_.get(), - process_thread_.get(), audio_mixer_.get(), decoder_factory_); - - // Check if we need to start the process thread. - bool start_process_thread = false; + rtc::make_ref_counted(transport, local_ssrc.value(), + task_queue_factory_.get(), + audio_mixer_.get(), decoder_factory_); { MutexLock lock(&lock_); - // Start process thread if the channel is the first one. - start_process_thread = channels_.empty(); - channel_id = static_cast(next_channel_id_); channels_[channel_id] = channel; next_channel_id_++; @@ -162,10 +150,6 @@ ChannelId VoipCore::CreateChannel(Transport* transport, // Set ChannelId in audio channel for logging/debugging purpose. channel->SetId(channel_id); - if (start_process_thread) { - process_thread_->Start(); - } - return channel_id; } @@ -194,9 +178,9 @@ VoipResult VoipCore::ReleaseChannel(ChannelId channel_id) { } if (no_channels_after_release) { - // Release audio channel first to have it DeRegisterModule first. + // TODO(bugs.webrtc.org/11581): unclear if we still need to clear |channel| + // here. channel = nullptr; - process_thread_->Stop(); // Make sure to stop playout on ADM if it is playing. if (audio_device_module_->Playing()) { diff --git a/audio/voip/voip_core.h b/audio/voip/voip_core.h index b7c1f2947f..359e07272d 100644 --- a/audio/voip/voip_core.h +++ b/audio/voip/voip_core.h @@ -33,7 +33,6 @@ #include "modules/audio_device/include/audio_device.h" #include "modules/audio_mixer/audio_mixer_impl.h" #include "modules/audio_processing/include/audio_processing.h" -#include "modules/utility/include/process_thread.h" #include "rtc_base/synchronization/mutex.h" namespace webrtc { @@ -61,8 +60,7 @@ class VoipCore : public VoipEngine, rtc::scoped_refptr decoder_factory, std::unique_ptr task_queue_factory, rtc::scoped_refptr audio_device_module, - rtc::scoped_refptr audio_processing, - std::unique_ptr process_thread = nullptr); + rtc::scoped_refptr audio_processing); ~VoipCore() override = default; // Implements VoipEngine interfaces. @@ -160,10 +158,6 @@ class VoipCore : public VoipEngine, // Synchronization is handled internally by AudioDeviceModule. rtc::scoped_refptr audio_device_module_; - // Synchronization is handled internally by ProcessThread. - // Must be placed before |channels_| for proper destruction. - std::unique_ptr process_thread_; - Mutex lock_; // Member to track a next ChannelId for new AudioChannel. diff --git a/call/call.cc b/call/call.cc index f4a7d7cc9e..4651b0be70 100644 --- a/call/call.cc +++ b/call/call.cc @@ -893,9 +893,8 @@ webrtc::AudioSendStream* Call::CreateAudioSendStream( AudioSendStream* send_stream = new AudioSendStream( clock_, config, config_.audio_state, task_queue_factory_, - module_process_thread_->process_thread(), transport_send_.get(), - bitrate_allocator_.get(), event_log_, call_stats_->AsRtcpRttStats(), - suspended_rtp_state); + transport_send_.get(), bitrate_allocator_.get(), event_log_, + call_stats_->AsRtcpRttStats(), suspended_rtp_state); RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) == audio_send_ssrcs_.end()); audio_send_ssrcs_[config.rtp.ssrc] = send_stream; @@ -950,8 +949,7 @@ webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream( CreateRtcLogStreamConfig(config))); AudioReceiveStream* receive_stream = new AudioReceiveStream( - clock_, transport_send_->packet_router(), - module_process_thread_->process_thread(), config_.neteq_factory, config, + clock_, transport_send_->packet_router(), config_.neteq_factory, config, config_.audio_state, event_log_); audio_receive_streams_.insert(receive_stream); @@ -1033,8 +1031,8 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream( std::vector ssrcs = config.rtp.ssrcs; VideoSendStream* send_stream = new VideoSendStream( - clock_, num_cpu_cores_, module_process_thread_->process_thread(), - task_queue_factory_, call_stats_->AsRtcpRttStats(), transport_send_.get(), + clock_, num_cpu_cores_, task_queue_factory_, + call_stats_->AsRtcpRttStats(), transport_send_.get(), bitrate_allocator_.get(), video_send_delay_stats_.get(), event_log_, std::move(config), std::move(encoder_config), suspended_video_send_ssrcs_, suspended_video_payload_states_, std::move(fec_controller)); @@ -1131,8 +1129,7 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream( VideoReceiveStream2* receive_stream = new VideoReceiveStream2( task_queue_factory_, this, num_cpu_cores_, transport_send_->packet_router(), std::move(configuration), - module_process_thread_->process_thread(), call_stats_.get(), clock_, - new VCMTiming(clock_)); + call_stats_.get(), clock_, new VCMTiming(clock_)); // TODO(bugs.webrtc.org/11993): Set this up asynchronously on the network // thread. receive_stream->RegisterWithTransport(&video_receiver_controller_); @@ -1200,8 +1197,7 @@ FlexfecReceiveStream* Call::CreateFlexfecReceiveStream( // OnRtpPacket until the constructor is finished and the object is // in a valid state, since OnRtpPacket runs on the same thread. receive_stream = new FlexfecReceiveStreamImpl( - clock_, config, recovered_packet_receiver, call_stats_->AsRtcpRttStats(), - module_process_thread_->process_thread()); + clock_, config, recovered_packet_receiver, call_stats_->AsRtcpRttStats()); // TODO(bugs.webrtc.org/11993): Set this up asynchronously on the network // thread. diff --git a/call/flexfec_receive_stream_impl.cc b/call/flexfec_receive_stream_impl.cc index ab82a6d71a..688efb7b5e 100644 --- a/call/flexfec_receive_stream_impl.cc +++ b/call/flexfec_receive_stream_impl.cc @@ -140,8 +140,7 @@ FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl( Clock* clock, const Config& config, RecoveredPacketReceiver* recovered_packet_receiver, - RtcpRttStats* rtt_stats, - ProcessThread* process_thread) + RtcpRttStats* rtt_stats) : config_(config), receiver_(MaybeCreateFlexfecReceiver(clock, config_, @@ -150,20 +149,17 @@ FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl( rtp_rtcp_(CreateRtpRtcpModule(clock, rtp_receive_statistics_.get(), config_, - rtt_stats)), - process_thread_(process_thread) { + rtt_stats)) { RTC_LOG(LS_INFO) << "FlexfecReceiveStreamImpl: " << config_.ToString(); packet_sequence_checker_.Detach(); // RTCP reporting. rtp_rtcp_->SetRTCPStatus(config_.rtcp_mode); - process_thread_->RegisterModule(rtp_rtcp_.get(), RTC_FROM_HERE); } FlexfecReceiveStreamImpl::~FlexfecReceiveStreamImpl() { RTC_LOG(LS_INFO) << "~FlexfecReceiveStreamImpl: " << config_.ToString(); - process_thread_->DeRegisterModule(rtp_rtcp_.get()); } void FlexfecReceiveStreamImpl::RegisterWithTransport( diff --git a/call/flexfec_receive_stream_impl.h b/call/flexfec_receive_stream_impl.h index 12c4b04332..285a33f7bb 100644 --- a/call/flexfec_receive_stream_impl.h +++ b/call/flexfec_receive_stream_impl.h @@ -22,7 +22,6 @@ namespace webrtc { class FlexfecReceiver; -class ProcessThread; class ReceiveStatistics; class RecoveredPacketReceiver; class RtcpRttStats; @@ -33,12 +32,10 @@ class RtpStreamReceiverInterface; class FlexfecReceiveStreamImpl : public FlexfecReceiveStream { public: - FlexfecReceiveStreamImpl( - Clock* clock, - const Config& config, - RecoveredPacketReceiver* recovered_packet_receiver, - RtcpRttStats* rtt_stats, - ProcessThread* process_thread); + FlexfecReceiveStreamImpl(Clock* clock, + const Config& config, + RecoveredPacketReceiver* recovered_packet_receiver, + RtcpRttStats* rtt_stats); // Destruction happens on the worker thread. Prior to destruction the caller // must ensure that a registration with the transport has been cleared. See // `RegisterWithTransport` for details. @@ -75,7 +72,6 @@ class FlexfecReceiveStreamImpl : public FlexfecReceiveStream { // RTCP reporting. const std::unique_ptr rtp_receive_statistics_; const std::unique_ptr rtp_rtcp_; - ProcessThread* const process_thread_; std::unique_ptr rtp_stream_receiver_ RTC_GUARDED_BY(packet_sequence_checker_); diff --git a/call/flexfec_receive_stream_unittest.cc b/call/flexfec_receive_stream_unittest.cc index f4944d054f..312fe0c907 100644 --- a/call/flexfec_receive_stream_unittest.cc +++ b/call/flexfec_receive_stream_unittest.cc @@ -26,7 +26,6 @@ #include "modules/rtp_rtcp/source/byte_io.h" #include "modules/rtp_rtcp/source/rtp_header_extensions.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h" -#include "modules/utility/include/mock/mock_process_thread.h" #include "test/gmock.h" #include "test/gtest.h" #include "test/mock_transport.h" @@ -87,15 +86,13 @@ class FlexfecReceiveStreamTest : public ::testing::Test { protected: FlexfecReceiveStreamTest() : config_(CreateDefaultConfig(&rtcp_send_transport_)) { - EXPECT_CALL(process_thread_, RegisterModule(_, _)).Times(1); receive_stream_ = std::make_unique( Clock::GetRealTimeClock(), config_, &recovered_packet_receiver_, - &rtt_stats_, &process_thread_); + &rtt_stats_); receive_stream_->RegisterWithTransport(&rtp_stream_receiver_controller_); } ~FlexfecReceiveStreamTest() { - EXPECT_CALL(process_thread_, DeRegisterModule(_)).Times(1); receive_stream_->UnregisterFromTransport(); } @@ -103,7 +100,6 @@ class FlexfecReceiveStreamTest : public ::testing::Test { FlexfecReceiveStream::Config config_; MockRecoveredPacketReceiver recovered_packet_receiver_; MockRtcpRttStats rtt_stats_; - MockProcessThread process_thread_; RtpStreamReceiverController rtp_stream_receiver_controller_; std::unique_ptr receive_stream_; }; @@ -146,10 +142,9 @@ TEST_F(FlexfecReceiveStreamTest, RecoversPacket) { // clang-format on ::testing::StrictMock recovered_packet_receiver; - EXPECT_CALL(process_thread_, RegisterModule(_, _)).Times(1); FlexfecReceiveStreamImpl receive_stream(Clock::GetRealTimeClock(), config_, &recovered_packet_receiver, - &rtt_stats_, &process_thread_); + &rtt_stats_); receive_stream.RegisterWithTransport(&rtp_stream_receiver_controller_); EXPECT_CALL(recovered_packet_receiver, @@ -158,8 +153,6 @@ TEST_F(FlexfecReceiveStreamTest, RecoversPacket) { receive_stream.OnRtpPacket(ParsePacket(kFlexfecPacket)); // Tear-down - EXPECT_CALL(process_thread_, DeRegisterModule(_)).Times(1); - receive_stream.UnregisterFromTransport(); } diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc index e20ba321c9..7fad89b20b 100644 --- a/call/rtp_video_sender.cc +++ b/call/rtp_video_sender.cc @@ -371,7 +371,6 @@ RtpVideoSender::RtpVideoSender( field_trials_.Lookup("WebRTC-Vp9DependencyDescriptor"), "Enabled")), active_(false), - module_process_thread_(nullptr), suspended_ssrcs_(std::move(suspended_ssrcs)), fec_controller_(std::move(fec_controller)), fec_allowed_(true), @@ -399,7 +398,6 @@ RtpVideoSender::RtpVideoSender( RTC_DCHECK_EQ(rtp_config_.ssrcs.size(), rtp_streams_.size()); if (send_side_bwe_with_overhead_ && has_packet_feedback_) transport_->IncludeOverheadInPacedSender(); - module_process_thread_checker_.Detach(); // SSRCs are assumed to be sorted in the same order as |rtp_modules|. for (uint32_t ssrc : rtp_config_.ssrcs) { // Restore state if it previously existed. @@ -460,25 +458,6 @@ RtpVideoSender::~RtpVideoSender() { this); } -void RtpVideoSender::RegisterProcessThread( - ProcessThread* module_process_thread) { - TRACE_EVENT0("webrtc", "RtpVideoSender::RegisterProcessThread"); - RTC_DCHECK_RUN_ON(&module_process_thread_checker_); - RTC_DCHECK(!module_process_thread_); - module_process_thread_ = module_process_thread; - - for (const RtpStreamSender& stream : rtp_streams_) { - module_process_thread_->RegisterModule(stream.rtp_rtcp.get(), - RTC_FROM_HERE); - } -} - -void RtpVideoSender::DeRegisterProcessThread() { - RTC_DCHECK_RUN_ON(&module_process_thread_checker_); - for (const RtpStreamSender& stream : rtp_streams_) - module_process_thread_->DeRegisterModule(stream.rtp_rtcp.get()); -} - void RtpVideoSender::SetActive(bool active) { MutexLock lock(&mutex_); if (active_ == active) diff --git a/call/rtp_video_sender.h b/call/rtp_video_sender.h index 611edc6b27..991276fe79 100644 --- a/call/rtp_video_sender.h +++ b/call/rtp_video_sender.h @@ -35,7 +35,6 @@ #include "modules/rtp_rtcp/source/rtp_sender_video.h" #include "modules/rtp_rtcp/source/rtp_sequence_number_map.h" #include "modules/rtp_rtcp/source/rtp_video_header.h" -#include "modules/utility/include/process_thread.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/rate_limiter.h" #include "rtc_base/synchronization/mutex.h" @@ -90,15 +89,6 @@ class RtpVideoSender : public RtpVideoSenderInterface, rtc::scoped_refptr frame_transformer); ~RtpVideoSender() override; - // RegisterProcessThread register |module_process_thread| with those objects - // that use it. Registration has to happen on the thread were - // |module_process_thread| was created (libjingle's worker thread). - // TODO(perkj): Replace the use of |module_process_thread| with a TaskQueue, - // maybe |worker_queue|. - void RegisterProcessThread(ProcessThread* module_process_thread) - RTC_LOCKS_EXCLUDED(mutex_) override; - void DeRegisterProcessThread() RTC_LOCKS_EXCLUDED(mutex_) override; - // RtpVideoSender will only route packets if being active, all packets will be // dropped otherwise. void SetActive(bool active) RTC_LOCKS_EXCLUDED(mutex_) override; @@ -185,8 +175,6 @@ class RtpVideoSender : public RtpVideoSenderInterface, mutable Mutex mutex_; bool active_ RTC_GUARDED_BY(mutex_); - ProcessThread* module_process_thread_; - SequenceChecker module_process_thread_checker_; std::map suspended_ssrcs_; const std::unique_ptr fec_controller_; diff --git a/call/rtp_video_sender_interface.h b/call/rtp_video_sender_interface.h index 632c9e835a..a0b4baccb4 100644 --- a/call/rtp_video_sender_interface.h +++ b/call/rtp_video_sender_interface.h @@ -22,7 +22,6 @@ #include "call/rtp_config.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/rtp_sequence_number_map.h" -#include "modules/utility/include/process_thread.h" #include "modules/video_coding/include/video_codec_interface.h" namespace webrtc { @@ -32,9 +31,6 @@ struct FecProtectionParams; class RtpVideoSenderInterface : public EncodedImageCallback, public FecControllerOverride { public: - virtual void RegisterProcessThread(ProcessThread* module_process_thread) = 0; - virtual void DeRegisterProcessThread() = 0; - // RtpVideoSender will only route packets if being active, all // packets will be dropped otherwise. virtual void SetActive(bool active) = 0; diff --git a/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/modules/rtp_rtcp/source/nack_rtx_unittest.cc index 8afaf3ee61..fc035047b0 100644 --- a/modules/rtp_rtcp/source/nack_rtx_unittest.cc +++ b/modules/rtp_rtcp/source/nack_rtx_unittest.cc @@ -218,7 +218,6 @@ class RtpRtcpRtxNackTest : public ::testing::Test { if (length > 0) rtp_rtcp_module_->SendNACK(nack_list, length); fake_clock.AdvanceTimeMilliseconds(28); // 33ms - 5ms delay. - rtp_rtcp_module_->Process(); // Prepare next frame. timestamp += 3000; } @@ -265,7 +264,6 @@ TEST_F(RtpRtcpRtxNackTest, LongNackList) { // Prepare next frame. timestamp += 3000; fake_clock.AdvanceTimeMilliseconds(33); - rtp_rtcp_module_->Process(); } EXPECT_FALSE(transport_.expected_sequence_numbers_.empty()); EXPECT_FALSE(media_stream_.sequence_numbers_.empty()); diff --git a/modules/rtp_rtcp/source/rtcp_sender.cc b/modules/rtp_rtcp/source/rtcp_sender.cc index 30a9d01ebb..8f5e3b104c 100644 --- a/modules/rtp_rtcp/source/rtcp_sender.cc +++ b/modules/rtp_rtcp/source/rtcp_sender.cc @@ -955,6 +955,8 @@ void RTCPSender::SendCombinedRtcpPacket( void RTCPSender::SetNextRtcpSendEvaluationDuration(TimeDelta duration) { next_time_to_send_rtcp_ = clock_->CurrentTime() + duration; + // TODO(bugs.webrtc.org/11581): make unconditional once downstream consumers + // are using the callback method. if (schedule_next_rtcp_send_evaluation_function_) schedule_next_rtcp_send_evaluation_function_(duration); } diff --git a/modules/rtp_rtcp/source/rtcp_sender.h b/modules/rtp_rtcp/source/rtcp_sender.h index 027d3d0c13..2d1c7da0fc 100644 --- a/modules/rtp_rtcp/source/rtcp_sender.h +++ b/modules/rtp_rtcp/source/rtcp_sender.h @@ -69,6 +69,11 @@ class RTCPSender final { // TimeToSendRTCPReport/SendRTCP. // The RTCPSender client still needs to call TimeToSendRTCPReport/SendRTCP // to actually get RTCP sent. + // + // Note: It's recommended to use the callback to ensure program design that + // doesn't use polling. + // TODO(bugs.webrtc.org/11581): Make mandatory once downstream consumers + // have migrated to the callback solution. std::function schedule_next_rtcp_send_evaluation_function; RtcEventLog* event_log = nullptr; diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc index 77054576a8..7fae1e3bd0 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc +++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc @@ -39,7 +39,6 @@ namespace webrtc { namespace { -const int64_t kRtpRtcpMaxIdleTimeProcessMs = 5; const int64_t kDefaultExpectedRetransmissionTimeMs = 125; constexpr TimeDelta kRttUpdateInterval = TimeDelta::Millis(1000); @@ -84,9 +83,6 @@ ModuleRtpRtcpImpl2::ModuleRtpRtcpImpl2(const Configuration& configuration) })), rtcp_receiver_(configuration, this), clock_(configuration.clock), - last_rtt_process_time_(clock_->TimeInMilliseconds()), - next_process_time_(clock_->TimeInMilliseconds() + - kRtpRtcpMaxIdleTimeProcessMs), packet_overhead_(28), // IPV4 UDP. nack_last_time_sent_full_ms_(0), nack_last_seq_number_sent_(0), @@ -94,7 +90,6 @@ ModuleRtpRtcpImpl2::ModuleRtpRtcpImpl2(const Configuration& configuration) rtt_stats_(configuration.rtt_stats), rtt_ms_(0) { RTC_DCHECK(worker_queue_); - process_thread_checker_.Detach(); packet_sequence_checker_.Detach(); if (!configuration.receiver_only) { rtp_sender_ = std::make_unique(configuration); @@ -131,39 +126,6 @@ std::unique_ptr ModuleRtpRtcpImpl2::Create( return std::make_unique(configuration); } -// Returns the number of milliseconds until the module want a worker thread -// to call Process. -int64_t ModuleRtpRtcpImpl2::TimeUntilNextProcess() { - RTC_DCHECK_RUN_ON(&process_thread_checker_); - return std::max(0, - next_process_time_ - clock_->TimeInMilliseconds()); -} - -// Process any pending tasks such as timeouts (non time critical events). -void ModuleRtpRtcpImpl2::Process() { - RTC_DCHECK_RUN_ON(&process_thread_checker_); - - const Timestamp now = clock_->CurrentTime(); - - // TODO(bugs.webrtc.org/11581): Figure out why we need to call Process() 200 - // times a second. - next_process_time_ = now.ms() + kRtpRtcpMaxIdleTimeProcessMs; - - // TODO(bugs.webrtc.org/11581): once we don't use Process() to trigger - // calls to SendRTCP(), the only remaining timer will require remote_bitrate_ - // to be not null. In that case, we can disable the timer when it is null. - if (remote_bitrate_ && rtcp_sender_.Sending() && rtcp_sender_.TMMBR()) { - unsigned int target_bitrate = 0; - std::vector ssrcs; - if (remote_bitrate_->LatestEstimate(&ssrcs, &target_bitrate)) { - if (!ssrcs.empty()) { - target_bitrate = target_bitrate / ssrcs.size(); - } - rtcp_sender_.SetTargetBitrate(target_bitrate); - } - } -} - void ModuleRtpRtcpImpl2::SetRtxSendStatus(int mode) { rtp_sender_->packet_generator.SetRtxStatus(mode); } @@ -780,13 +742,6 @@ void ModuleRtpRtcpImpl2::PeriodicUpdate() { rtt_stats_->OnRttUpdate(rtt->ms()); set_rtt_ms(rtt->ms()); } - - // kTmmbrTimeoutIntervalMs is 25 seconds, so an order of seconds. - // Instead of this polling approach, consider having an optional timer in the - // RTCPReceiver class that is started/stopped based on the state of - // rtcp_sender_.TMMBR(). - if (rtcp_sender_.TMMBR() && rtcp_receiver_.UpdateTmmbrTimers()) - rtcp_receiver_.NotifyTmmbrUpdated(); } // RTC_RUN_ON(worker_queue_); diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl2.h b/modules/rtp_rtcp/source/rtp_rtcp_impl2.h index 849cc42c5e..0ad495593d 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_impl2.h +++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2.h @@ -50,7 +50,6 @@ struct PacedPacketInfo; struct RTPVideoHeader; class ModuleRtpRtcpImpl2 final : public RtpRtcpInterface, - public Module, public RTCPReceiver::ModuleRtpRtcp { public: explicit ModuleRtpRtcpImpl2( @@ -64,13 +63,6 @@ class ModuleRtpRtcpImpl2 final : public RtpRtcpInterface, static std::unique_ptr Create( const Configuration& configuration); - // Returns the number of milliseconds until the module want a worker thread to - // call Process. - int64_t TimeUntilNextProcess() override; - - // Process any pending tasks such as timeouts. - void Process() override; - // Receiver part. // Called when we receive an RTCP packet. @@ -310,7 +302,6 @@ class ModuleRtpRtcpImpl2 final : public RtpRtcpInterface, TimeDelta duration); TaskQueueBase* const worker_queue_; - RTC_NO_UNIQUE_ADDRESS SequenceChecker process_thread_checker_; RTC_NO_UNIQUE_ADDRESS SequenceChecker packet_sequence_checker_; std::unique_ptr rtp_sender_; @@ -319,8 +310,6 @@ class ModuleRtpRtcpImpl2 final : public RtpRtcpInterface, Clock* const clock_; - int64_t last_rtt_process_time_; - int64_t next_process_time_; uint16_t packet_overhead_; // Send side diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc index 5deb12d465..c8ab15de78 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc @@ -199,25 +199,20 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver, }; RtpRtcpModule(GlobalSimulatedTimeController* time_controller, - ProcessThread* process_thread, bool is_sender, const FieldTrialConfig& trials) : time_controller_(time_controller), is_sender_(is_sender), trials_(trials), - process_thread_(process_thread), receive_statistics_( ReceiveStatistics::Create(time_controller->GetClock())), transport_(kOneWayNetworkDelay, time_controller) { CreateModuleImpl(); } - ~RtpRtcpModule() { process_thread_->DeRegisterModule(impl_.get()); } - TimeController* const time_controller_; const bool is_sender_; const FieldTrialConfig& trials_; - ProcessThread* const process_thread_; RtcpPacketTypeCounter packets_sent_; RtcpPacketTypeCounter packets_received_; std::unique_ptr receive_statistics_; @@ -286,10 +281,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver, config.field_trials = &trials_; config.send_packet_observer = this; config.fec_generator = fec_generator_; - if (impl_) - process_thread_->DeRegisterModule(impl_.get()); impl_.reset(new ModuleRtpRtcpImpl2(config)); - process_thread_->RegisterModule(impl_.get(), RTC_FROM_HERE); impl_->SetRemoteSSRC(is_sender_ ? kReceiverSsrc : kSenderSsrc); impl_->SetRTCPStatus(RtcpMode::kCompound); } @@ -306,20 +298,12 @@ class RtpRtcpImpl2Test : public ::testing::TestWithParam { RtpRtcpImpl2Test() : time_controller_(Timestamp::Micros(133590000000000)), field_trials_(FieldTrialConfig::GetFromTestConfig(GetParam())), - process_thread_( - time_controller_.CreateProcessThread("RtpRtcpImpl2Test")), sender_(&time_controller_, - process_thread_.get(), /*is_sender=*/true, field_trials_), receiver_(&time_controller_, - process_thread_.get(), /*is_sender=*/false, - field_trials_) { - process_thread_->Start(); - } - - ~RtpRtcpImpl2Test() { process_thread_->Stop(); } + field_trials_) {} void SetUp() override { // Send module. @@ -367,7 +351,6 @@ class RtpRtcpImpl2Test : public ::testing::TestWithParam { GlobalSimulatedTimeController time_controller_; FieldTrialConfig field_trials_; - std::unique_ptr process_thread_; RtpRtcpModule sender_; std::unique_ptr sender_video_; RtpRtcpModule receiver_; diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc index 1dcdf72e60..4b43247b18 100644 --- a/video/rtp_video_stream_receiver2.cc +++ b/video/rtp_video_stream_receiver2.cc @@ -36,7 +36,6 @@ #include "modules/rtp_rtcp/source/rtp_rtcp_config.h" #include "modules/rtp_rtcp/source/video_rtp_depacketizer.h" #include "modules/rtp_rtcp/source/video_rtp_depacketizer_raw.h" -#include "modules/utility/include/process_thread.h" #include "modules/video_coding/frame_object.h" #include "modules/video_coding/h264_sprop_parameter_sets.h" #include "modules/video_coding/h264_sps_pps_tracker.h" @@ -211,7 +210,6 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2( ReceiveStatistics* rtp_receive_statistics, RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer, RtcpCnameCallback* rtcp_cname_callback, - ProcessThread* process_thread, NackSender* nack_sender, KeyFrameRequestSender* keyframe_request_sender, OnCompleteFrameCallback* complete_frame_callback, @@ -220,7 +218,6 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2( : clock_(clock), config_(*config), packet_router_(packet_router), - process_thread_(process_thread), ntp_estimator_(clock), rtp_header_extensions_(config_.rtp.extensions), forced_playout_delay_max_ms_("max_ms", absl::nullopt), @@ -289,8 +286,6 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2( {&forced_playout_delay_max_ms_, &forced_playout_delay_min_ms_}, field_trial::FindFullName("WebRTC-ForcePlayoutDelay")); - process_thread_->RegisterModule(rtp_rtcp_.get(), RTC_FROM_HERE); - if (config_.rtp.lntf.enabled) { loss_notification_controller_ = std::make_unique(&rtcp_feedback_buffer_, @@ -316,8 +311,6 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2( } RtpVideoStreamReceiver2::~RtpVideoStreamReceiver2() { - process_thread_->DeRegisterModule(rtp_rtcp_.get()); - if (packet_router_) packet_router_->RemoveReceiveRtpModule(rtp_rtcp_.get()); UpdateHistograms(); diff --git a/video/rtp_video_stream_receiver2.h b/video/rtp_video_stream_receiver2.h index 0c7e826189..ddff26b3bd 100644 --- a/video/rtp_video_stream_receiver2.h +++ b/video/rtp_video_stream_receiver2.h @@ -54,7 +54,6 @@ namespace webrtc { class NackModule2; class PacketRouter; -class ProcessThread; class ReceiveStatistics; class RtcpRttStats; class RtpPacketReceived; @@ -90,7 +89,6 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender, ReceiveStatistics* rtp_receive_statistics, RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer, RtcpCnameCallback* rtcp_cname_callback, - ProcessThread* process_thread, NackSender* nack_sender, // The KeyFrameRequestSender is optional; if not provided, key frame // requests are sent via the internal RtpRtcp module. @@ -287,7 +285,6 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender, // Ownership of this object lies with VideoReceiveStream, which owns |this|. const VideoReceiveStream::Config& config_; PacketRouter* const packet_router_; - ProcessThread* const process_thread_; RemoteNtpTimeEstimator ntp_estimator_; diff --git a/video/rtp_video_stream_receiver2_unittest.cc b/video/rtp_video_stream_receiver2_unittest.cc index d23b6047aa..7ccf0a5faa 100644 --- a/video/rtp_video_stream_receiver2_unittest.cc +++ b/video/rtp_video_stream_receiver2_unittest.cc @@ -166,16 +166,14 @@ class RtpVideoStreamReceiver2Test : public ::testing::Test, TaskQueueFactory::Priority::NORMAL)), task_queue_setter_(task_queue_.get()), override_field_trials_(field_trials), - config_(CreateConfig()), - process_thread_(ProcessThread::Create("TestThread")) { + config_(CreateConfig()) { rtp_receive_statistics_ = ReceiveStatistics::Create(Clock::GetRealTimeClock()); rtp_video_stream_receiver_ = std::make_unique( TaskQueueBase::Current(), Clock::GetRealTimeClock(), &mock_transport_, nullptr, nullptr, &config_, rtp_receive_statistics_.get(), nullptr, - nullptr, process_thread_.get(), &mock_nack_sender_, - &mock_key_frame_request_sender_, &mock_on_complete_frame_callback_, - nullptr, nullptr); + nullptr, &mock_nack_sender_, &mock_key_frame_request_sender_, + &mock_on_complete_frame_callback_, nullptr, nullptr); VideoCodec codec; codec.codecType = kVideoCodecGeneric; rtp_video_stream_receiver_->AddReceiveCodec(kPayloadType, codec, {}, @@ -250,7 +248,6 @@ class RtpVideoStreamReceiver2Test : public ::testing::Test, MockKeyFrameRequestSender mock_key_frame_request_sender_; MockTransport mock_transport_; MockOnCompleteFrameCallback mock_on_complete_frame_callback_; - std::unique_ptr process_thread_; std::unique_ptr rtp_receive_statistics_; std::unique_ptr rtp_video_stream_receiver_; RtpPacketSinkInterface* test_packet_sink_ = nullptr; @@ -1135,8 +1132,8 @@ TEST_F(RtpVideoStreamReceiver2Test, TransformFrame) { auto receiver = std::make_unique( TaskQueueBase::Current(), Clock::GetRealTimeClock(), &mock_transport_, nullptr, nullptr, &config_, rtp_receive_statistics_.get(), nullptr, - nullptr, process_thread_.get(), &mock_nack_sender_, nullptr, - &mock_on_complete_frame_callback_, nullptr, mock_frame_transformer); + nullptr, &mock_nack_sender_, nullptr, &mock_on_complete_frame_callback_, + nullptr, mock_frame_transformer); VideoCodec video_codec; video_codec.codecType = kVideoCodecGeneric; receiver->AddReceiveCodec(kPayloadType, video_codec, {}, diff --git a/video/video_receive_stream2.cc b/video/video_receive_stream2.cc index c929f07616..72257f01cc 100644 --- a/video/video_receive_stream2.cc +++ b/video/video_receive_stream2.cc @@ -216,7 +216,6 @@ VideoReceiveStream2::VideoReceiveStream2(TaskQueueFactory* task_queue_factory, int num_cpu_cores, PacketRouter* packet_router, VideoReceiveStream::Config config, - ProcessThread* process_thread, CallStats* call_stats, Clock* clock, VCMTiming* timing) @@ -241,7 +240,6 @@ VideoReceiveStream2::VideoReceiveStream2(TaskQueueFactory* task_queue_factory, rtp_receive_statistics_.get(), &stats_proxy_, &stats_proxy_, - process_thread, this, // NackSender nullptr, // Use default KeyFrameRequestSender this, // OnCompleteFrameCallback @@ -262,7 +260,6 @@ VideoReceiveStream2::VideoReceiveStream2(TaskQueueFactory* task_queue_factory, RTC_DCHECK(call_->worker_thread()); RTC_DCHECK(config_.renderer); RTC_DCHECK(call_stats_); - module_process_sequence_checker_.Detach(); packet_sequence_checker_.Detach(); RTC_DCHECK(!config_.decoders.empty()); diff --git a/video/video_receive_stream2.h b/video/video_receive_stream2.h index 8fd995084e..9557044277 100644 --- a/video/video_receive_stream2.h +++ b/video/video_receive_stream2.h @@ -39,7 +39,6 @@ namespace webrtc { -class ProcessThread; class RtpStreamReceiverInterface; class RtpStreamReceiverControllerInterface; class RtxReceiveStream; @@ -96,7 +95,6 @@ class VideoReceiveStream2 int num_cpu_cores, PacketRouter* packet_router, VideoReceiveStream::Config config, - ProcessThread* process_thread, CallStats* call_stats, Clock* clock, VCMTiming* timing); @@ -199,7 +197,6 @@ class VideoReceiveStream2 void UpdateHistograms(); RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_sequence_checker_; - RTC_NO_UNIQUE_ADDRESS SequenceChecker module_process_sequence_checker_; // TODO(bugs.webrtc.org/11993): This checker conceptually represents // operations that belong to the network thread. The Call class is currently // moving towards handling network packets on the network thread and while diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc index a37a5defb2..850fd0dbb5 100644 --- a/video/video_receive_stream2_unittest.cc +++ b/video/video_receive_stream2_unittest.cc @@ -109,8 +109,7 @@ class FrameObjectFake : public EncodedFrame { class VideoReceiveStream2Test : public ::testing::Test { public: VideoReceiveStream2Test() - : process_thread_(ProcessThread::Create("TestThread")), - task_queue_factory_(CreateDefaultTaskQueueFactory()), + : task_queue_factory_(CreateDefaultTaskQueueFactory()), h264_decoder_factory_(&mock_h264_video_decoder_), config_(&mock_transport_, &h264_decoder_factory_), call_stats_(Clock::GetRealTimeClock(), loop_.task_queue()) {} @@ -138,15 +137,13 @@ class VideoReceiveStream2Test : public ::testing::Test { video_receive_stream_ = std::make_unique( task_queue_factory_.get(), &fake_call_, kDefaultNumCpuCores, - &packet_router_, config_.Copy(), process_thread_.get(), - &call_stats_, clock_, timing_); + &packet_router_, config_.Copy(), &call_stats_, clock_, timing_); video_receive_stream_->RegisterWithTransport( &rtp_stream_receiver_controller_); } protected: test::RunLoop loop_; - std::unique_ptr process_thread_; const std::unique_ptr task_queue_factory_; test::VideoDecoderProxyFactory h264_decoder_factory_; VideoReceiveStream::Config config_; @@ -290,7 +287,6 @@ class VideoReceiveStream2TestWithFakeDecoder : public ::testing::Test { VideoReceiveStream2TestWithFakeDecoder() : fake_decoder_factory_( []() { return std::make_unique(); }), - process_thread_(ProcessThread::Create("TestThread")), task_queue_factory_(CreateDefaultTaskQueueFactory()), config_(&mock_transport_, &fake_decoder_factory_), call_stats_(Clock::GetRealTimeClock(), loop_.task_queue()) {} @@ -320,8 +316,7 @@ class VideoReceiveStream2TestWithFakeDecoder : public ::testing::Test { timing_ = new VCMTiming(clock_); video_receive_stream_.reset(new webrtc::internal::VideoReceiveStream2( task_queue_factory_.get(), &fake_call_, kDefaultNumCpuCores, - &packet_router_, config_.Copy(), process_thread_.get(), &call_stats_, - clock_, timing_)); + &packet_router_, config_.Copy(), &call_stats_, clock_, timing_)); video_receive_stream_->RegisterWithTransport( &rtp_stream_receiver_controller_); video_receive_stream_->SetAndGetRecordingState(std::move(state), false); @@ -330,7 +325,6 @@ class VideoReceiveStream2TestWithFakeDecoder : public ::testing::Test { protected: test::RunLoop loop_; test::FunctionVideoDecoderFactory fake_decoder_factory_; - std::unique_ptr process_thread_; const std::unique_ptr task_queue_factory_; VideoReceiveStream::Config config_; internal::CallStats call_stats_; @@ -576,7 +570,6 @@ class VideoReceiveStream2TestWithSimulatedClock fake_decoder_factory_([this] { return std::make_unique([this] { OnFrameDecoded(); }); }), - process_thread_(time_controller_.CreateProcessThread("ProcessThread")), config_(GetConfig(&mock_transport_, &fake_decoder_factory_, &fake_renderer_)), @@ -586,7 +579,6 @@ class VideoReceiveStream2TestWithSimulatedClock /*num_cores=*/2, &packet_router_, config_.Copy(), - process_thread_.get(), &call_stats_, time_controller_.GetClock(), new VCMTiming(time_controller_.GetClock())) { @@ -613,7 +605,6 @@ class VideoReceiveStream2TestWithSimulatedClock GlobalSimulatedTimeController time_controller_; test::RunLoop loop_; test::FunctionVideoDecoderFactory fake_decoder_factory_; - std::unique_ptr process_thread_; MockTransport mock_transport_; FakeRenderer fake_renderer_; cricket::FakeCall fake_call_; @@ -729,8 +720,7 @@ INSTANTIATE_TEST_SUITE_P( class VideoReceiveStream2TestWithLazyDecoderCreation : public ::testing::Test { public: VideoReceiveStream2TestWithLazyDecoderCreation() - : process_thread_(ProcessThread::Create("TestThread")), - task_queue_factory_(CreateDefaultTaskQueueFactory()), + : task_queue_factory_(CreateDefaultTaskQueueFactory()), config_(&mock_transport_, &mock_h264_decoder_factory_), call_stats_(Clock::GetRealTimeClock(), loop_.task_queue()) {} @@ -759,15 +749,13 @@ class VideoReceiveStream2TestWithLazyDecoderCreation : public ::testing::Test { video_receive_stream_ = std::make_unique( task_queue_factory_.get(), &fake_call_, kDefaultNumCpuCores, - &packet_router_, config_.Copy(), process_thread_.get(), - &call_stats_, clock_, timing_); + &packet_router_, config_.Copy(), &call_stats_, clock_, timing_); video_receive_stream_->RegisterWithTransport( &rtp_stream_receiver_controller_); } protected: test::RunLoop loop_; - std::unique_ptr process_thread_; const std::unique_ptr task_queue_factory_; MockVideoDecoderFactory mock_h264_decoder_factory_; VideoReceiveStream::Config config_; diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc index 591a8d58d8..46bf0dbc67 100644 --- a/video/video_send_stream.cc +++ b/video/video_send_stream.cc @@ -112,7 +112,6 @@ namespace internal { VideoSendStream::VideoSendStream( Clock* clock, int num_cpu_cores, - ProcessThread* module_process_thread, TaskQueueFactory* task_queue_factory, RtcpRttStats* call_stats, RtpTransportControllerSendInterface* transport, @@ -174,14 +173,12 @@ VideoSendStream::VideoSendStream( video_stream_encoder_->SetFecControllerOverride(rtp_video_sender_); - rtp_video_sender_->RegisterProcessThread(module_process_thread); ReconfigureVideoEncoder(std::move(encoder_config)); } VideoSendStream::~VideoSendStream() { RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK(!running_); - rtp_video_sender_->DeRegisterProcessThread(); transport_->DestroyRtpVideoSender(rtp_video_sender_); } diff --git a/video/video_send_stream.h b/video/video_send_stream.h index 7e89c46abd..b52871c6e1 100644 --- a/video/video_send_stream.h +++ b/video/video_send_stream.h @@ -37,7 +37,6 @@ class VideoSendStreamPeer; class CallStats; class IvfFileWriter; -class ProcessThread; class RateLimiter; class RtpRtcp; class RtpTransportControllerSendInterface; @@ -58,7 +57,6 @@ class VideoSendStream : public webrtc::VideoSendStream { VideoSendStream( Clock* clock, int num_cpu_cores, - ProcessThread* module_process_thread, TaskQueueFactory* task_queue_factory, RtcpRttStats* call_stats, RtpTransportControllerSendInterface* transport, diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc index 71cec7c981..30a4aacd92 100644 --- a/video/video_send_stream_impl_unittest.cc +++ b/video/video_send_stream_impl_unittest.cc @@ -62,8 +62,6 @@ std::string GetAlrProbingExperimentString() { } class MockRtpVideoSender : public RtpVideoSenderInterface { public: - MOCK_METHOD(void, RegisterProcessThread, (ProcessThread*), (override)); - MOCK_METHOD(void, DeRegisterProcessThread, (), (override)); MOCK_METHOD(void, SetActive, (bool), (override)); MOCK_METHOD(void, SetActiveModules, (const std::vector), (override)); MOCK_METHOD(bool, IsActive, (), (override)); diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc index 4e94d8fc77..9f9b8c16da 100644 --- a/video/video_send_stream_tests.cc +++ b/video/video_send_stream_tests.cc @@ -1486,7 +1486,6 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) { "bps", false); if (total_bitrate_bps > kHighBitrateBps) { rtp_rtcp_->SetRemb(kRembBitrateBps, {rtp_packet.Ssrc()}); - rtp_rtcp_->Process(); bitrate_capped_ = true; } else if (bitrate_capped_ && total_bitrate_bps < kRembRespectedBitrateBps) { -- cgit v1.2.3