aboutsummaryrefslogtreecommitdiff
path: root/audio
diff options
context:
space:
mode:
Diffstat (limited to 'audio')
-rw-r--r--audio/BUILD.gn2
-rw-r--r--audio/audio_receive_stream.cc178
-rw-r--r--audio/audio_receive_stream.h66
-rw-r--r--audio/audio_receive_stream_unittest.cc68
-rw-r--r--audio/audio_send_stream.cc23
-rw-r--r--audio/audio_send_stream.h8
-rw-r--r--audio/audio_send_stream_unittest.cc11
-rw-r--r--audio/audio_state.cc2
-rw-r--r--audio/audio_state_unittest.cc15
-rw-r--r--audio/channel_receive.cc246
-rw-r--r--audio/channel_receive.h6
-rw-r--r--audio/channel_receive_frame_transformer_delegate.cc2
-rw-r--r--audio/channel_receive_frame_transformer_delegate.h4
-rw-r--r--audio/channel_receive_frame_transformer_delegate_unittest.cc16
-rw-r--r--audio/channel_send.cc2
-rw-r--r--audio/channel_send_frame_transformer_delegate_unittest.cc16
-rw-r--r--audio/mock_voe_channel_proxy.h8
-rw-r--r--audio/voip/test/audio_channel_unittest.cc2
-rw-r--r--audio/voip/test/voip_core_unittest.cc2
-rw-r--r--audio/voip/voip_core.cc2
20 files changed, 425 insertions, 254 deletions
diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index ccbf9fd2e3..054e090ba6 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -95,6 +95,7 @@ rtc_library("audio") {
"../rtc_base/experiments:field_trial_parser",
"../rtc_base/synchronization:mutex",
"../rtc_base/system:no_unique_address",
+ "../rtc_base/task_utils:pending_task_safety_flag",
"../rtc_base/task_utils:to_queued_task",
"../system_wrappers",
"../system_wrappers:field_trial",
@@ -151,6 +152,7 @@ if (rtc_include_tests) {
"../api/audio_codecs:audio_codecs_api",
"../api/audio_codecs/opus:audio_decoder_opus",
"../api/audio_codecs/opus:audio_encoder_opus",
+ "../api/crypto:frame_decryptor_interface",
"../api/rtc_event_log",
"../api/task_queue:default_task_queue_factory",
"../api/units:time_delta",
diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc
index 467647be5e..6ec266b68d 100644
--- a/audio/audio_receive_stream.cc
+++ b/audio/audio_receive_stream.cc
@@ -18,6 +18,7 @@
#include "api/audio_codecs/audio_format.h"
#include "api/call/audio_sink.h"
#include "api/rtp_parameters.h"
+#include "api/sequence_checker.h"
#include "audio/audio_send_stream.h"
#include "audio/audio_state.h"
#include "audio/channel_receive.h"
@@ -83,14 +84,13 @@ std::unique_ptr<voe::ChannelReceiveInterface> CreateChannelReceive(
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, config.frame_decryptor, config.crypto_options,
- std::move(config.frame_transformer));
+ config.codec_pair_id, std::move(config.frame_decryptor),
+ config.crypto_options, std::move(config.frame_transformer));
}
} // namespace
AudioReceiveStream::AudioReceiveStream(
Clock* clock,
- RtpStreamReceiverControllerInterface* receiver_controller,
PacketRouter* packet_router,
ProcessThread* module_process_thread,
NetEqFactory* neteq_factory,
@@ -98,7 +98,6 @@ AudioReceiveStream::AudioReceiveStream(
const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
webrtc::RtcEventLog* event_log)
: AudioReceiveStream(clock,
- receiver_controller,
packet_router,
config,
audio_state,
@@ -112,13 +111,13 @@ AudioReceiveStream::AudioReceiveStream(
AudioReceiveStream::AudioReceiveStream(
Clock* clock,
- RtpStreamReceiverControllerInterface* receiver_controller,
PacketRouter* packet_router,
const webrtc::AudioReceiveStream::Config& config,
const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
webrtc::RtcEventLog* event_log,
std::unique_ptr<voe::ChannelReceiveInterface> channel_receive)
- : audio_state_(audio_state),
+ : config_(config),
+ audio_state_(audio_state),
source_tracker_(clock),
channel_receive_(std::move(channel_receive)) {
RTC_LOG(LS_INFO) << "AudioReceiveStream: " << config.rtp.remote_ssrc;
@@ -127,7 +126,8 @@ AudioReceiveStream::AudioReceiveStream(
RTC_DCHECK(audio_state_);
RTC_DCHECK(channel_receive_);
- RTC_DCHECK(receiver_controller);
+ packet_sequence_checker_.Detach();
+
RTC_DCHECK(packet_router);
// Configure bandwidth estimation.
channel_receive_->RegisterReceiverCongestionControlObjects(packet_router);
@@ -137,10 +137,14 @@ AudioReceiveStream::AudioReceiveStream(
// be updated.
channel_receive_->SetSourceTracker(&source_tracker_);
- // Register with transport.
- rtp_stream_receiver_ = receiver_controller->CreateReceiver(
- config.rtp.remote_ssrc, channel_receive_.get());
- ConfigureStream(this, config, true);
+ // Complete configuration.
+ // TODO(solenberg): Config NACK history window (which is a packet count),
+ // using the actual packet size for the configured codec.
+ channel_receive_->SetNACKStatus(config.rtp.nack.rtp_history_ms != 0,
+ config.rtp.nack.rtp_history_ms / 20);
+ channel_receive_->SetReceiveCodecs(config.decoder_map);
+ // `frame_transformer` and `frame_decryptor` have been given to
+ // `channel_receive_` already.
}
AudioReceiveStream::~AudioReceiveStream() {
@@ -151,10 +155,43 @@ AudioReceiveStream::~AudioReceiveStream() {
channel_receive_->ResetReceiverCongestionControlObjects();
}
-void AudioReceiveStream::Reconfigure(
+void AudioReceiveStream::RegisterWithTransport(
+ RtpStreamReceiverControllerInterface* receiver_controller) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ RTC_DCHECK(!rtp_stream_receiver_);
+ rtp_stream_receiver_ = receiver_controller->CreateReceiver(
+ config_.rtp.remote_ssrc, channel_receive_.get());
+}
+
+void AudioReceiveStream::UnregisterFromTransport() {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ rtp_stream_receiver_.reset();
+}
+
+void AudioReceiveStream::ReconfigureForTesting(
const webrtc::AudioReceiveStream::Config& config) {
- RTC_DCHECK(worker_thread_checker_.IsCurrent());
- ConfigureStream(this, config, false);
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+
+ // SSRC can't be changed mid-stream.
+ RTC_DCHECK_EQ(config_.rtp.remote_ssrc, config.rtp.remote_ssrc);
+ RTC_DCHECK_EQ(config_.rtp.local_ssrc, config.rtp.local_ssrc);
+
+ // Configuration parameters which cannot be changed.
+ RTC_DCHECK_EQ(config_.rtcp_send_transport, config.rtcp_send_transport);
+ // Decoder factory cannot be changed because it is configured at
+ // voe::Channel construction time.
+ RTC_DCHECK_EQ(config_.decoder_factory, config.decoder_factory);
+
+ // TODO(solenberg): Config NACK history window (which is a packet count),
+ // using the actual packet size for the configured codec.
+ RTC_DCHECK_EQ(config_.rtp.nack.rtp_history_ms, config.rtp.nack.rtp_history_ms)
+ << "Use SetUseTransportCcAndNackHistory";
+
+ RTC_DCHECK(config_.decoder_map == config.decoder_map) << "Use SetDecoderMap";
+ RTC_DCHECK_EQ(config_.frame_transformer, config.frame_transformer)
+ << "Use SetDepacketizerToDecoderFrameTransformer";
+
+ config_ = config;
}
void AudioReceiveStream::Start() {
@@ -182,6 +219,49 @@ bool AudioReceiveStream::IsRunning() const {
return playing_;
}
+void AudioReceiveStream::SetDepacketizerToDecoderFrameTransformer(
+ rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ channel_receive_->SetDepacketizerToDecoderFrameTransformer(
+ std::move(frame_transformer));
+}
+
+void AudioReceiveStream::SetDecoderMap(
+ std::map<int, SdpAudioFormat> decoder_map) {
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ config_.decoder_map = std::move(decoder_map);
+ channel_receive_->SetReceiveCodecs(config_.decoder_map);
+}
+
+void AudioReceiveStream::SetUseTransportCcAndNackHistory(bool use_transport_cc,
+ int history_ms) {
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ RTC_DCHECK_GE(history_ms, 0);
+ config_.rtp.transport_cc = use_transport_cc;
+ if (config_.rtp.nack.rtp_history_ms != history_ms) {
+ config_.rtp.nack.rtp_history_ms = history_ms;
+ // TODO(solenberg): Config NACK history window (which is a packet count),
+ // using the actual packet size for the configured codec.
+ channel_receive_->SetNACKStatus(history_ms != 0, history_ms / 20);
+ }
+}
+
+void AudioReceiveStream::SetFrameDecryptor(
+ rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
+ // TODO(bugs.webrtc.org/11993): This is called via WebRtcAudioReceiveStream,
+ // expect to be called on the network thread.
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ channel_receive_->SetFrameDecryptor(std::move(frame_decryptor));
+}
+
+void AudioReceiveStream::SetRtpExtensions(
+ std::vector<RtpExtension> extensions) {
+ // TODO(bugs.webrtc.org/11993): This is called via WebRtcAudioReceiveStream,
+ // expect to be called on the network thread.
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ config_.rtp.extensions = std::move(extensions);
+}
+
webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats(
bool get_and_clear_legacy_stats) const {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
@@ -351,8 +431,7 @@ bool AudioReceiveStream::SetMinimumPlayoutDelay(int delay_ms) {
}
void AudioReceiveStream::AssociateSendStream(AudioSendStream* send_stream) {
- // TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
- RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
channel_receive_->SetAssociatedSendChannel(
send_stream ? send_stream->GetChannel() : nullptr);
associated_send_stream_ = send_stream;
@@ -366,6 +445,24 @@ void AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
channel_receive_->ReceivedRTCPPacket(packet, length);
}
+void AudioReceiveStream::SetSyncGroup(const std::string& sync_group) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ config_.sync_group = sync_group;
+}
+
+void AudioReceiveStream::SetLocalSsrc(uint32_t local_ssrc) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ // TODO(tommi): Consider storing local_ssrc in one place.
+ config_.rtp.local_ssrc = local_ssrc;
+ channel_receive_->OnLocalSsrcChange(local_ssrc);
+}
+
+uint32_t AudioReceiveStream::local_ssrc() const {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
+ RTC_DCHECK_EQ(config_.rtp.local_ssrc, channel_receive_->GetLocalSsrc());
+ return config_.rtp.local_ssrc;
+}
+
const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
return config_;
@@ -373,9 +470,7 @@ const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const {
const AudioSendStream* AudioReceiveStream::GetAssociatedSendStreamForTesting()
const {
- // TODO(bugs.webrtc.org/11993): Expect to be called on the network thread or
- // remove test method and |associated_send_stream_| variable.
- RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
return associated_send_stream_;
}
@@ -384,50 +479,5 @@ internal::AudioState* AudioReceiveStream::audio_state() const {
RTC_DCHECK(audio_state);
return audio_state;
}
-
-void AudioReceiveStream::ConfigureStream(AudioReceiveStream* stream,
- const Config& new_config,
- bool first_time) {
- RTC_LOG(LS_INFO) << "AudioReceiveStream::ConfigureStream: "
- << new_config.ToString();
- RTC_DCHECK(stream);
- const auto& channel_receive = stream->channel_receive_;
- const auto& old_config = stream->config_;
-
- // Configuration parameters which cannot be changed.
- RTC_DCHECK(first_time ||
- old_config.rtp.remote_ssrc == new_config.rtp.remote_ssrc);
- RTC_DCHECK(first_time ||
- old_config.rtcp_send_transport == new_config.rtcp_send_transport);
- // Decoder factory cannot be changed because it is configured at
- // voe::Channel construction time.
- RTC_DCHECK(first_time ||
- old_config.decoder_factory == new_config.decoder_factory);
-
- if (!first_time) {
- // SSRC can't be changed mid-stream.
- RTC_DCHECK_EQ(old_config.rtp.local_ssrc, new_config.rtp.local_ssrc);
- RTC_DCHECK_EQ(old_config.rtp.remote_ssrc, new_config.rtp.remote_ssrc);
- }
-
- // TODO(solenberg): Config NACK history window (which is a packet count),
- // using the actual packet size for the configured codec.
- if (first_time || old_config.rtp.nack.rtp_history_ms !=
- new_config.rtp.nack.rtp_history_ms) {
- channel_receive->SetNACKStatus(new_config.rtp.nack.rtp_history_ms != 0,
- new_config.rtp.nack.rtp_history_ms / 20);
- }
- if (first_time || old_config.decoder_map != new_config.decoder_map) {
- channel_receive->SetReceiveCodecs(new_config.decoder_map);
- }
-
- if (first_time ||
- old_config.frame_transformer != new_config.frame_transformer) {
- channel_receive->SetDepacketizerToDecoderFrameTransformer(
- new_config.frame_transformer);
- }
-
- stream->config_ = new_config;
-}
} // namespace internal
} // namespace webrtc
diff --git a/audio/audio_receive_stream.h b/audio/audio_receive_stream.h
index a8438c252a..dc64e94510 100644
--- a/audio/audio_receive_stream.h
+++ b/audio/audio_receive_stream.h
@@ -11,7 +11,9 @@
#ifndef AUDIO_AUDIO_RECEIVE_STREAM_H_
#define AUDIO_AUDIO_RECEIVE_STREAM_H_
+#include <map>
#include <memory>
+#include <string>
#include <vector>
#include "api/audio/audio_mixer.h"
@@ -22,6 +24,7 @@
#include "call/audio_receive_stream.h"
#include "call/syncable.h"
#include "modules/rtp_rtcp/source/source_tracker.h"
+#include "rtc_base/system/no_unique_address.h"
#include "system_wrappers/include/clock.h"
namespace webrtc {
@@ -44,7 +47,6 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream,
public Syncable {
public:
AudioReceiveStream(Clock* clock,
- RtpStreamReceiverControllerInterface* receiver_controller,
PacketRouter* packet_router,
ProcessThread* module_process_thread,
NetEqFactory* neteq_factory,
@@ -54,7 +56,6 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream,
// For unit tests, which need to supply a mock channel receive.
AudioReceiveStream(
Clock* clock,
- RtpStreamReceiverControllerInterface* receiver_controller,
PacketRouter* packet_router,
const webrtc::AudioReceiveStream::Config& config,
const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
@@ -65,13 +66,36 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream,
AudioReceiveStream(const AudioReceiveStream&) = delete;
AudioReceiveStream& operator=(const AudioReceiveStream&) = delete;
+ // 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.
+ // TODO(tommi): As a further improvement to this, performing the full
+ // destruction on the network thread could be made the default.
~AudioReceiveStream() override;
+ // Called on the network thread to register/unregister with the network
+ // transport.
+ void RegisterWithTransport(
+ RtpStreamReceiverControllerInterface* receiver_controller);
+ // If registration has previously been done (via `RegisterWithTransport`) then
+ // `UnregisterFromTransport` must be called prior to destruction, on the
+ // network thread.
+ void UnregisterFromTransport();
+
// webrtc::AudioReceiveStream implementation.
- void Reconfigure(const webrtc::AudioReceiveStream::Config& config) override;
void Start() override;
void Stop() override;
+ const RtpConfig& rtp_config() const override { return config_.rtp; }
bool IsRunning() const override;
+ void SetDepacketizerToDecoderFrameTransformer(
+ rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+ override;
+ void SetDecoderMap(std::map<int, SdpAudioFormat> decoder_map) override;
+ void SetUseTransportCcAndNackHistory(bool use_transport_cc,
+ int history_ms) override;
+ void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
+ frame_decryptor) override;
+ void SetRtpExtensions(std::vector<RtpExtension> extensions) override;
webrtc::AudioReceiveStream::Stats GetStats(
bool get_and_clear_legacy_stats) const override;
@@ -98,26 +122,48 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream,
void AssociateSendStream(AudioSendStream* send_stream);
void DeliverRtcp(const uint8_t* packet, size_t length);
+
+ void SetSyncGroup(const std::string& sync_group);
+
+ void SetLocalSsrc(uint32_t local_ssrc);
+
+ uint32_t local_ssrc() const;
+
+ uint32_t remote_ssrc() const {
+ // The remote_ssrc member variable of config_ will never change and can be
+ // considered const.
+ return config_.rtp.remote_ssrc;
+ }
+
const webrtc::AudioReceiveStream::Config& config() const;
const AudioSendStream* GetAssociatedSendStreamForTesting() const;
- private:
- static void ConfigureStream(AudioReceiveStream* stream,
- const Config& new_config,
- bool first_time);
+ // TODO(tommi): Remove this method.
+ void ReconfigureForTesting(const webrtc::AudioReceiveStream::Config& config);
+ private:
AudioState* audio_state() const;
- SequenceChecker worker_thread_checker_;
+ RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_thread_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
+ // that work is ongoing, this checker may in practice represent the worker
+ // thread, but still serves as a mechanism of grouping together concepts
+ // that belong to the network thread. Once the packets are fully delivered
+ // on the network thread, this comment will be deleted.
+ RTC_NO_UNIQUE_ADDRESS SequenceChecker packet_sequence_checker_;
webrtc::AudioReceiveStream::Config config_;
rtc::scoped_refptr<webrtc::AudioState> audio_state_;
SourceTracker source_tracker_;
const std::unique_ptr<voe::ChannelReceiveInterface> channel_receive_;
- AudioSendStream* associated_send_stream_ = nullptr;
+ AudioSendStream* associated_send_stream_
+ RTC_GUARDED_BY(packet_sequence_checker_) = nullptr;
bool playing_ RTC_GUARDED_BY(worker_thread_checker_) = false;
- std::unique_ptr<RtpStreamReceiverInterface> rtp_stream_receiver_;
+ std::unique_ptr<RtpStreamReceiverInterface> rtp_stream_receiver_
+ RTC_GUARDED_BY(packet_sequence_checker_);
};
} // namespace internal
} // namespace webrtc
diff --git a/audio/audio_receive_stream_unittest.cc b/audio/audio_receive_stream_unittest.cc
index 99e3a56e1b..fb5f1cb876 100644
--- a/audio/audio_receive_stream_unittest.cc
+++ b/audio/audio_receive_stream_unittest.cc
@@ -74,7 +74,7 @@ const AudioDecodingCallStats kAudioDecodeStats = MakeAudioDecodeStatsForTest();
struct ConfigHelper {
explicit ConfigHelper(bool use_null_audio_processing)
- : ConfigHelper(new rtc::RefCountedObject<MockAudioMixer>(),
+ : ConfigHelper(rtc::make_ref_counted<MockAudioMixer>(),
use_null_audio_processing) {}
ConfigHelper(rtc::scoped_refptr<MockAudioMixer> audio_mixer,
@@ -87,9 +87,9 @@ struct ConfigHelper {
config.audio_processing =
use_null_audio_processing
? nullptr
- : new rtc::RefCountedObject<NiceMock<MockAudioProcessing>>();
+ : rtc::make_ref_counted<NiceMock<MockAudioProcessing>>();
config.audio_device_module =
- new rtc::RefCountedObject<testing::NiceMock<MockAudioDeviceModule>>();
+ rtc::make_ref_counted<testing::NiceMock<MockAudioDeviceModule>>();
audio_state_ = AudioState::Create(config);
channel_receive_ = new ::testing::StrictMock<MockChannelReceive>();
@@ -104,8 +104,6 @@ struct ConfigHelper {
.WillRepeatedly(Invoke([](const std::map<int, SdpAudioFormat>& codecs) {
EXPECT_THAT(codecs, ::testing::IsEmpty());
}));
- EXPECT_CALL(*channel_receive_, SetDepacketizerToDecoderFrameTransformer(_))
- .Times(1);
EXPECT_CALL(*channel_receive_, SetSourceTracker(_));
stream_config_.rtp.local_ssrc = kLocalSsrc;
@@ -117,15 +115,16 @@ struct ConfigHelper {
RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId));
stream_config_.rtcp_send_transport = &rtcp_send_transport_;
stream_config_.decoder_factory =
- new rtc::RefCountedObject<MockAudioDecoderFactory>;
+ rtc::make_ref_counted<MockAudioDecoderFactory>();
}
std::unique_ptr<internal::AudioReceiveStream> CreateAudioReceiveStream() {
- return std::unique_ptr<internal::AudioReceiveStream>(
- new internal::AudioReceiveStream(
- Clock::GetRealTimeClock(), &rtp_stream_receiver_controller_,
- &packet_router_, stream_config_, audio_state_, &event_log_,
- std::unique_ptr<voe::ChannelReceiveInterface>(channel_receive_)));
+ auto ret = std::make_unique<internal::AudioReceiveStream>(
+ Clock::GetRealTimeClock(), &packet_router_, stream_config_,
+ audio_state_, &event_log_,
+ std::unique_ptr<voe::ChannelReceiveInterface>(channel_receive_));
+ ret->RegisterWithTransport(&rtp_stream_receiver_controller_);
+ return ret;
}
AudioReceiveStream::Config& config() { return stream_config_; }
@@ -199,6 +198,7 @@ TEST(AudioReceiveStreamTest, ConstructDestruct) {
for (bool use_null_audio_processing : {false, true}) {
ConfigHelper helper(use_null_audio_processing);
auto recv_stream = helper.CreateAudioReceiveStream();
+ recv_stream->UnregisterFromTransport();
}
}
@@ -212,6 +212,7 @@ TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) {
ReceivedRTCPPacket(&rtcp_packet[0], rtcp_packet.size()))
.WillOnce(Return());
recv_stream->DeliverRtcp(&rtcp_packet[0], rtcp_packet.size());
+ recv_stream->UnregisterFromTransport();
}
}
@@ -276,6 +277,7 @@ TEST(AudioReceiveStreamTest, GetStats) {
EXPECT_EQ(kCallStats.capture_start_ntp_time_ms_,
stats.capture_start_ntp_time_ms);
EXPECT_EQ(kPlayoutNtpTimestampMs, stats.estimated_playout_ntp_timestamp_ms);
+ recv_stream->UnregisterFromTransport();
}
}
@@ -286,6 +288,7 @@ TEST(AudioReceiveStreamTest, SetGain) {
EXPECT_CALL(*helper.channel_receive(),
SetChannelOutputVolumeScaling(FloatEq(0.765f)));
recv_stream->SetGain(0.765f);
+ recv_stream->UnregisterFromTransport();
}
}
@@ -317,14 +320,9 @@ TEST(AudioReceiveStreamTest, StreamsShouldBeAddedToMixerOnceOnStart) {
// Stop stream before it is being destructed.
recv_stream2->Stop();
- }
-}
-TEST(AudioReceiveStreamTest, ReconfigureWithSameConfig) {
- for (bool use_null_audio_processing : {false, true}) {
- ConfigHelper helper(use_null_audio_processing);
- auto recv_stream = helper.CreateAudioReceiveStream();
- recv_stream->Reconfigure(helper.config());
+ recv_stream1->UnregisterFromTransport();
+ recv_stream2->UnregisterFromTransport();
}
}
@@ -334,20 +332,32 @@ TEST(AudioReceiveStreamTest, ReconfigureWithUpdatedConfig) {
auto recv_stream = helper.CreateAudioReceiveStream();
auto new_config = helper.config();
- new_config.rtp.nack.rtp_history_ms = 300 + 20;
+
new_config.rtp.extensions.clear();
new_config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId + 1));
new_config.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberId + 1));
- new_config.decoder_map.emplace(1, SdpAudioFormat("foo", 8000, 1));
MockChannelReceive& channel_receive = *helper.channel_receive();
- EXPECT_CALL(channel_receive, SetNACKStatus(true, 15 + 1)).Times(1);
+
+ // TODO(tommi, nisse): This applies new extensions to the internal config,
+ // but there's nothing that actually verifies that the changes take effect.
+ // In fact Call manages the extensions separately in Call::ReceiveRtpConfig
+ // and changing this config value (there seem to be a few copies), doesn't
+ // affect that logic.
+ recv_stream->ReconfigureForTesting(new_config);
+
+ new_config.decoder_map.emplace(1, SdpAudioFormat("foo", 8000, 1));
EXPECT_CALL(channel_receive, SetReceiveCodecs(new_config.decoder_map));
+ recv_stream->SetDecoderMap(new_config.decoder_map);
+
+ EXPECT_CALL(channel_receive, SetNACKStatus(true, 15 + 1)).Times(1);
+ recv_stream->SetUseTransportCcAndNackHistory(new_config.rtp.transport_cc,
+ 300 + 20);
- recv_stream->Reconfigure(new_config);
+ recv_stream->UnregisterFromTransport();
}
}
@@ -358,17 +368,23 @@ TEST(AudioReceiveStreamTest, ReconfigureWithFrameDecryptor) {
auto new_config_0 = helper.config();
rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_0(
- new rtc::RefCountedObject<MockFrameDecryptor>());
+ rtc::make_ref_counted<MockFrameDecryptor>());
new_config_0.frame_decryptor = mock_frame_decryptor_0;
- recv_stream->Reconfigure(new_config_0);
+ // TODO(tommi): While this changes the internal config value, it doesn't
+ // actually change what frame_decryptor is used. WebRtcAudioReceiveStream
+ // recreates the whole instance in order to change this value.
+ // So, it's not clear if changing this post initialization needs to be
+ // supported.
+ recv_stream->ReconfigureForTesting(new_config_0);
auto new_config_1 = helper.config();
rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_1(
- new rtc::RefCountedObject<MockFrameDecryptor>());
+ rtc::make_ref_counted<MockFrameDecryptor>());
new_config_1.frame_decryptor = mock_frame_decryptor_1;
new_config_1.crypto_options.sframe.require_frame_encryption = true;
- recv_stream->Reconfigure(new_config_1);
+ recv_stream->ReconfigureForTesting(new_config_1);
+ recv_stream->UnregisterFromTransport();
}
}
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index b769569fd5..aca7cd38b8 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -142,7 +142,7 @@ AudioSendStream::AudioSendStream(
const absl::optional<RtpState>& suspended_rtp_state,
std::unique_ptr<voe::ChannelSendInterface> channel_send)
: clock_(clock),
- worker_queue_(rtp_transport->GetWorkerQueue()),
+ rtp_transport_queue_(rtp_transport->GetWorkerQueue()),
allocate_audio_without_feedback_(
field_trial::IsEnabled("WebRTC-Audio-ABWENoTWCC")),
enable_audio_alr_probing_(
@@ -160,7 +160,7 @@ AudioSendStream::AudioSendStream(
rtp_rtcp_module_(channel_send_->GetRtpRtcp()),
suspended_rtp_state_(suspended_rtp_state) {
RTC_LOG(LS_INFO) << "AudioSendStream: " << config.rtp.ssrc;
- RTC_DCHECK(worker_queue_);
+ RTC_DCHECK(rtp_transport_queue_);
RTC_DCHECK(audio_state_);
RTC_DCHECK(channel_send_);
RTC_DCHECK(bitrate_allocator_);
@@ -182,7 +182,7 @@ AudioSendStream::~AudioSendStream() {
// Blocking call to synchronize state with worker queue to ensure that there
// are no pending tasks left that keeps references to audio.
rtc::Event thread_sync_event;
- worker_queue_->PostTask([&] { thread_sync_event.Set(); });
+ rtp_transport_queue_->PostTask([&] { thread_sync_event.Set(); });
thread_sync_event.Wait(rtc::Event::kForever);
}
@@ -517,7 +517,7 @@ void AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
}
uint32_t AudioSendStream::OnBitrateUpdated(BitrateAllocationUpdate update) {
- RTC_DCHECK_RUN_ON(worker_queue_);
+ RTC_DCHECK_RUN_ON(rtp_transport_queue_);
// Pick a target bitrate between the constraints. Overrules the allocator if
// it 1) allocated a bitrate of zero to disable the stream or 2) allocated a
@@ -855,9 +855,10 @@ void AudioSendStream::ConfigureBitrateObserver() {
if (allocation_settings_.priority_bitrate_raw)
priority_bitrate = *allocation_settings_.priority_bitrate_raw;
- worker_queue_->PostTask([this, constraints, priority_bitrate,
- config_bitrate_priority = config_.bitrate_priority] {
- RTC_DCHECK_RUN_ON(worker_queue_);
+ rtp_transport_queue_->PostTask([this, constraints, priority_bitrate,
+ config_bitrate_priority =
+ config_.bitrate_priority] {
+ RTC_DCHECK_RUN_ON(rtp_transport_queue_);
bitrate_allocator_->AddObserver(
this,
MediaStreamAllocationConfig{
@@ -872,8 +873,8 @@ void AudioSendStream::ConfigureBitrateObserver() {
void AudioSendStream::RemoveBitrateObserver() {
registered_with_allocator_ = false;
rtc::Event thread_sync_event;
- worker_queue_->PostTask([this, &thread_sync_event] {
- RTC_DCHECK_RUN_ON(worker_queue_);
+ rtp_transport_queue_->PostTask([this, &thread_sync_event] {
+ RTC_DCHECK_RUN_ON(rtp_transport_queue_);
bitrate_allocator_->RemoveObserver(this);
thread_sync_event.Set();
});
@@ -940,8 +941,8 @@ void AudioSendStream::UpdateCachedTargetAudioBitrateConstraints() {
if (!new_constraints.has_value()) {
return;
}
- worker_queue_->PostTask([this, new_constraints]() {
- RTC_DCHECK_RUN_ON(worker_queue_);
+ rtp_transport_queue_->PostTask([this, new_constraints]() {
+ RTC_DCHECK_RUN_ON(rtp_transport_queue_);
cached_constraints_ = new_constraints;
});
}
diff --git a/audio/audio_send_stream.h b/audio/audio_send_stream.h
index 25346ae373..223328b26b 100644
--- a/audio/audio_send_stream.h
+++ b/audio/audio_send_stream.h
@@ -165,7 +165,7 @@ class AudioSendStream final : public webrtc::AudioSendStream,
SequenceChecker worker_thread_checker_;
SequenceChecker pacer_thread_checker_;
rtc::RaceChecker audio_capture_race_checker_;
- rtc::TaskQueue* worker_queue_;
+ rtc::TaskQueue* rtp_transport_queue_;
const bool allocate_audio_without_feedback_;
const bool force_no_audio_feedback_ = allocate_audio_without_feedback_;
@@ -189,10 +189,10 @@ class AudioSendStream final : public webrtc::AudioSendStream,
webrtc::voe::AudioLevel audio_level_ RTC_GUARDED_BY(audio_level_lock_);
BitrateAllocatorInterface* const bitrate_allocator_
- RTC_GUARDED_BY(worker_queue_);
- // Constrains cached to be accessed from |worker_queue_|.
+ RTC_GUARDED_BY(rtp_transport_queue_);
+ // Constrains cached to be accessed from |rtp_transport_queue_|.
absl::optional<AudioSendStream::TargetAudioBitrateConstraints>
- cached_constraints_ RTC_GUARDED_BY(worker_queue_) = absl::nullopt;
+ cached_constraints_ RTC_GUARDED_BY(rtp_transport_queue_) = absl::nullopt;
RtpTransportControllerSendInterface* const rtp_transport_;
RtpRtcpInterface* const rtp_rtcp_module_;
diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc
index f76a8fa255..357e08040c 100644
--- a/audio/audio_send_stream_unittest.cc
+++ b/audio/audio_send_stream_unittest.cc
@@ -121,7 +121,7 @@ std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() {
rtc::scoped_refptr<MockAudioEncoderFactory> factory =
- new rtc::RefCountedObject<MockAudioEncoderFactory>();
+ rtc::make_ref_counted<MockAudioEncoderFactory>();
ON_CALL(*factory.get(), GetSupportedEncoders())
.WillByDefault(Return(std::vector<AudioCodecSpec>(
std::begin(kCodecSpecs), std::end(kCodecSpecs))));
@@ -154,7 +154,7 @@ struct ConfigHelper {
audio_processing_(
use_null_audio_processing
? nullptr
- : new rtc::RefCountedObject<NiceMock<MockAudioProcessing>>()),
+ : rtc::make_ref_counted<NiceMock<MockAudioProcessing>>()),
bitrate_allocator_(&limit_observer_),
worker_queue_(task_queue_factory_->CreateTaskQueue(
"ConfigHelper_worker_queue",
@@ -165,8 +165,7 @@ struct ConfigHelper {
AudioState::Config config;
config.audio_mixer = AudioMixerImpl::Create();
config.audio_processing = audio_processing_;
- config.audio_device_module =
- new rtc::RefCountedObject<MockAudioDeviceModule>();
+ config.audio_device_module = rtc::make_ref_counted<MockAudioDeviceModule>();
audio_state_ = AudioState::Create(config);
SetupDefaultChannelSend(audio_bwe_enabled);
@@ -923,7 +922,7 @@ TEST(AudioSendStreamTest, ReconfigureWithFrameEncryptor) {
auto new_config = helper.config();
rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_0(
- new rtc::RefCountedObject<MockFrameEncryptor>());
+ rtc::make_ref_counted<MockFrameEncryptor>());
new_config.frame_encryptor = mock_frame_encryptor_0;
EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr)))
.Times(1);
@@ -936,7 +935,7 @@ TEST(AudioSendStreamTest, ReconfigureWithFrameEncryptor) {
// Updating frame encryptor to a new object should force a call to the
// proxy.
rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_1(
- new rtc::RefCountedObject<MockFrameEncryptor>());
+ rtc::make_ref_counted<MockFrameEncryptor>());
new_config.frame_encryptor = mock_frame_encryptor_1;
new_config.crypto_options.sframe.require_frame_encryption = true;
EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr)))
diff --git a/audio/audio_state.cc b/audio/audio_state.cc
index 566bae1311..0e60f0372b 100644
--- a/audio/audio_state.cc
+++ b/audio/audio_state.cc
@@ -187,6 +187,6 @@ void AudioState::UpdateNullAudioPollerState() {
rtc::scoped_refptr<AudioState> AudioState::Create(
const AudioState::Config& config) {
- return new rtc::RefCountedObject<internal::AudioState>(config);
+ return rtc::make_ref_counted<internal::AudioState>(config);
}
} // namespace webrtc
diff --git a/audio/audio_state_unittest.cc b/audio/audio_state_unittest.cc
index 02fc04e6dc..5f07a7b339 100644
--- a/audio/audio_state_unittest.cc
+++ b/audio/audio_state_unittest.cc
@@ -90,7 +90,7 @@ struct FakeAsyncAudioProcessingHelper {
FakeTaskQueueFactory task_queue_factory_;
rtc::scoped_refptr<AsyncAudioProcessing::Factory> CreateFactory() {
- return new rtc::RefCountedObject<AsyncAudioProcessing::Factory>(
+ return rtc::make_ref_counted<AsyncAudioProcessing::Factory>(
audio_frame_processor_, task_queue_factory_);
}
};
@@ -107,10 +107,9 @@ struct ConfigHelper {
audio_state_config.audio_processing =
params.use_null_audio_processing
? nullptr
- : new rtc::RefCountedObject<
- testing::NiceMock<MockAudioProcessing>>();
+ : rtc::make_ref_counted<testing::NiceMock<MockAudioProcessing>>();
audio_state_config.audio_device_module =
- new rtc::RefCountedObject<NiceMock<MockAudioDeviceModule>>();
+ rtc::make_ref_counted<NiceMock<MockAudioDeviceModule>>();
if (params.use_async_audio_processing) {
audio_state_config.async_audio_processing_factory =
async_audio_processing_helper_.CreateFactory();
@@ -183,7 +182,7 @@ TEST_P(AudioStateTest, Create) {
TEST_P(AudioStateTest, ConstructDestruct) {
ConfigHelper helper(GetParam());
rtc::scoped_refptr<internal::AudioState> audio_state(
- new rtc::RefCountedObject<internal::AudioState>(helper.config()));
+ rtc::make_ref_counted<internal::AudioState>(helper.config()));
}
TEST_P(AudioStateTest, RecordedAudioArrivesAtSingleStream) {
@@ -196,7 +195,7 @@ TEST_P(AudioStateTest, RecordedAudioArrivesAtSingleStream) {
}
rtc::scoped_refptr<internal::AudioState> audio_state(
- new rtc::RefCountedObject<internal::AudioState>(helper.config()));
+ rtc::make_ref_counted<internal::AudioState>(helper.config()));
MockAudioSendStream stream;
audio_state->AddSendingStream(&stream, 8000, 2);
@@ -245,7 +244,7 @@ TEST_P(AudioStateTest, RecordedAudioArrivesAtMultipleStreams) {
}
rtc::scoped_refptr<internal::AudioState> audio_state(
- new rtc::RefCountedObject<internal::AudioState>(helper.config()));
+ rtc::make_ref_counted<internal::AudioState>(helper.config()));
MockAudioSendStream stream_1;
MockAudioSendStream stream_2;
@@ -308,7 +307,7 @@ TEST_P(AudioStateTest, EnableChannelSwap) {
}
rtc::scoped_refptr<internal::AudioState> audio_state(
- new rtc::RefCountedObject<internal::AudioState>(helper.config()));
+ rtc::make_ref_counted<internal::AudioState>(helper.config()));
audio_state->SetStereoChannelSwapping(true);
diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc
index 44a647b7a6..150e2074e4 100644
--- a/audio/channel_receive.cc
+++ b/audio/channel_receive.cc
@@ -10,8 +10,6 @@
#include "audio/channel_receive.h"
-#include <assert.h>
-
#include <algorithm>
#include <map>
#include <memory>
@@ -23,6 +21,7 @@
#include "api/frame_transformer_interface.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "api/sequence_checker.h"
+#include "api/task_queue/task_queue_base.h"
#include "audio/audio_level.h"
#include "audio/channel_receive_frame_transformer_delegate.h"
#include "audio/channel_send.h"
@@ -34,7 +33,8 @@
#include "modules/pacing/packet_router.h"
#include "modules/rtp_rtcp/include/receive_statistics.h"
#include "modules/rtp_rtcp/include/remote_ntp_time_estimator.h"
-#include "modules/rtp_rtcp/source/absolute_capture_time_receiver.h"
+#include "modules/rtp_rtcp/source/absolute_capture_time_interpolator.h"
+#include "modules/rtp_rtcp/source/capture_clock_offset_updater.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
@@ -47,6 +47,9 @@
#include "rtc_base/numerics/safe_minmax.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/synchronization/mutex.h"
+#include "rtc_base/system/no_unique_address.h"
+#include "rtc_base/task_utils/pending_task_safety_flag.h"
+#include "rtc_base/task_utils/to_queued_task.h"
#include "rtc_base/time_utils.h"
#include "system_wrappers/include/metrics.h"
@@ -174,44 +177,51 @@ class ChannelReceive : public ChannelReceiveInterface {
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override;
+ void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
+ frame_decryptor) override;
+
+ void OnLocalSsrcChange(uint32_t local_ssrc) override;
+ uint32_t GetLocalSsrc() const override;
+
private:
void ReceivePacket(const uint8_t* packet,
size_t packet_length,
- const RTPHeader& header);
+ const RTPHeader& header)
+ RTC_RUN_ON(worker_thread_checker_);
int ResendPackets(const uint16_t* sequence_numbers, int length);
- void UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms);
+ void UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms)
+ RTC_RUN_ON(worker_thread_checker_);
int GetRtpTimestampRateHz() const;
int64_t GetRTT() const;
void OnReceivedPayloadData(rtc::ArrayView<const uint8_t> payload,
- const RTPHeader& rtpHeader);
+ const RTPHeader& rtpHeader)
+ RTC_RUN_ON(worker_thread_checker_);
void InitFrameTransformerDelegate(
- rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer);
-
- bool Playing() const {
- MutexLock lock(&playing_lock_);
- return playing_;
- }
+ rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+ RTC_RUN_ON(worker_thread_checker_);
// Thread checkers document and lock usage of some methods to specific threads
// we know about. The goal is to eventually split up voe::ChannelReceive into
// parts with single-threaded semantics, and thereby reduce the need for
// locks.
- SequenceChecker worker_thread_checker_;
+ RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_thread_checker_;
+ RTC_NO_UNIQUE_ADDRESS SequenceChecker network_thread_checker_;
+
+ TaskQueueBase* const worker_thread_;
+ ScopedTaskSafety worker_safety_;
// 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
// audio thread to another, but access is still sequential.
rtc::RaceChecker audio_thread_race_checker_;
- rtc::RaceChecker video_capture_thread_race_checker_;
Mutex callback_mutex_;
Mutex volume_settings_mutex_;
- mutable Mutex playing_lock_;
- bool playing_ RTC_GUARDED_BY(&playing_lock_) = false;
+ bool playing_ RTC_GUARDED_BY(worker_thread_checker_) = false;
RtcEventLog* const event_log_;
@@ -225,11 +235,10 @@ class ChannelReceive : public ChannelReceiveInterface {
// Info for GetSyncInfo is updated on network or worker thread, and queried on
// the worker thread.
- mutable Mutex sync_info_lock_;
absl::optional<uint32_t> last_received_rtp_timestamp_
- RTC_GUARDED_BY(&sync_info_lock_);
+ RTC_GUARDED_BY(&worker_thread_checker_);
absl::optional<int64_t> last_received_rtp_system_time_ms_
- RTC_GUARDED_BY(&sync_info_lock_);
+ RTC_GUARDED_BY(&worker_thread_checker_);
// The AcmReceiver is thread safe, using its own lock.
acm2::AcmReceiver acm_receiver_;
@@ -242,15 +251,14 @@ class ChannelReceive : public ChannelReceiveInterface {
// Timestamp of the audio pulled from NetEq.
absl::optional<uint32_t> jitter_buffer_playout_timestamp_;
- mutable Mutex video_sync_lock_;
- uint32_t playout_timestamp_rtp_ RTC_GUARDED_BY(video_sync_lock_);
+ uint32_t playout_timestamp_rtp_ RTC_GUARDED_BY(worker_thread_checker_);
absl::optional<int64_t> playout_timestamp_rtp_time_ms_
- RTC_GUARDED_BY(video_sync_lock_);
- uint32_t playout_delay_ms_ RTC_GUARDED_BY(video_sync_lock_);
+ RTC_GUARDED_BY(worker_thread_checker_);
+ uint32_t playout_delay_ms_ RTC_GUARDED_BY(worker_thread_checker_);
absl::optional<int64_t> playout_timestamp_ntp_
- RTC_GUARDED_BY(video_sync_lock_);
+ RTC_GUARDED_BY(worker_thread_checker_);
absl::optional<int64_t> playout_timestamp_ntp_time_ms_
- RTC_GUARDED_BY(video_sync_lock_);
+ RTC_GUARDED_BY(worker_thread_checker_);
mutable Mutex ts_stats_lock_;
@@ -266,26 +274,39 @@ class ChannelReceive : public ChannelReceiveInterface {
float _outputGain RTC_GUARDED_BY(volume_settings_mutex_);
const ChannelSendInterface* associated_send_channel_
- RTC_GUARDED_BY(worker_thread_checker_);
+ RTC_GUARDED_BY(network_thread_checker_);
PacketRouter* packet_router_ = nullptr;
SequenceChecker construction_thread_;
// E2EE Audio Frame Decryption
- rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_;
+ rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_
+ RTC_GUARDED_BY(worker_thread_checker_);
webrtc::CryptoOptions crypto_options_;
- webrtc::AbsoluteCaptureTimeReceiver absolute_capture_time_receiver_;
+ webrtc::AbsoluteCaptureTimeInterpolator absolute_capture_time_interpolator_
+ RTC_GUARDED_BY(worker_thread_checker_);
+
+ webrtc::CaptureClockOffsetUpdater capture_clock_offset_updater_;
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate>
frame_transformer_delegate_;
+
+ // Counter that's used to control the frequency of reporting histograms
+ // from the `GetAudioFrameWithInfo` callback.
+ int audio_frame_interval_count_ RTC_GUARDED_BY(audio_thread_race_checker_) =
+ 0;
+ // Controls how many callbacks we let pass by before reporting callback stats.
+ // A value of 100 means 100 callbacks, each one of which represents 10ms worth
+ // of data, so the stats reporting frequency will be 1Hz (modulo failures).
+ constexpr static int kHistogramReportingInterval = 100;
};
void ChannelReceive::OnReceivedPayloadData(
rtc::ArrayView<const uint8_t> payload,
const RTPHeader& rtpHeader) {
- if (!Playing()) {
+ if (!playing_) {
// Avoid inserting into NetEQ when we are not playing. Count the
// packet as discarded.
@@ -299,7 +320,7 @@ void ChannelReceive::OnReceivedPayloadData(
// updating RtpSource information.
if (source_tracker_) {
RtpPacketInfos::vector_type packet_vector = {
- RtpPacketInfo(rtpHeader, clock_->TimeInMilliseconds())};
+ RtpPacketInfo(rtpHeader, clock_->CurrentTime())};
source_tracker_->OnFrameDelivered(RtpPacketInfos(packet_vector));
}
@@ -328,18 +349,20 @@ void ChannelReceive::InitFrameTransformerDelegate(
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
RTC_DCHECK(frame_transformer);
RTC_DCHECK(!frame_transformer_delegate_);
+ RTC_DCHECK(worker_thread_->IsCurrent());
// Pass a callback to ChannelReceive::OnReceivedPayloadData, to be called by
// the delegate to receive transformed audio.
ChannelReceiveFrameTransformerDelegate::ReceiveFrameCallback
receive_audio_callback = [this](rtc::ArrayView<const uint8_t> packet,
const RTPHeader& header) {
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
OnReceivedPayloadData(packet, header);
};
frame_transformer_delegate_ =
- new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
std::move(receive_audio_callback), std::move(frame_transformer),
- rtc::Thread::Current());
+ worker_thread_);
frame_transformer_delegate_->Init();
}
@@ -434,17 +457,37 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
}
}
- {
- RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.TargetJitterBufferDelayMs",
- acm_receiver_.TargetDelayMs());
- const int jitter_buffer_delay = acm_receiver_.FilteredCurrentDelayMs();
- MutexLock lock(&video_sync_lock_);
- RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverDelayEstimateMs",
- jitter_buffer_delay + playout_delay_ms_);
- RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverJitterBufferDelayMs",
- jitter_buffer_delay);
- RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverDeviceDelayMs",
- playout_delay_ms_);
+ // Fill in local capture clock offset in |audio_frame->packet_infos_|.
+ RtpPacketInfos::vector_type packet_infos;
+ for (auto& packet_info : audio_frame->packet_infos_) {
+ absl::optional<int64_t> local_capture_clock_offset;
+ if (packet_info.absolute_capture_time().has_value()) {
+ local_capture_clock_offset =
+ capture_clock_offset_updater_.AdjustEstimatedCaptureClockOffset(
+ packet_info.absolute_capture_time()
+ ->estimated_capture_clock_offset);
+ }
+ RtpPacketInfo new_packet_info(packet_info);
+ new_packet_info.set_local_capture_clock_offset(local_capture_clock_offset);
+ packet_infos.push_back(std::move(new_packet_info));
+ }
+ audio_frame->packet_infos_ = RtpPacketInfos(packet_infos);
+
+ ++audio_frame_interval_count_;
+ if (audio_frame_interval_count_ >= kHistogramReportingInterval) {
+ audio_frame_interval_count_ = 0;
+ worker_thread_->PostTask(ToQueuedTask(worker_safety_, [this]() {
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.TargetJitterBufferDelayMs",
+ acm_receiver_.TargetDelayMs());
+ const int jitter_buffer_delay = acm_receiver_.FilteredCurrentDelayMs();
+ RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverDelayEstimateMs",
+ jitter_buffer_delay + playout_delay_ms_);
+ RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverJitterBufferDelayMs",
+ jitter_buffer_delay);
+ RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverDeviceDelayMs",
+ playout_delay_ms_);
+ }));
}
return muted ? AudioMixer::Source::AudioFrameInfo::kMuted
@@ -480,7 +523,8 @@ ChannelReceive::ChannelReceive(
rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor,
const webrtc::CryptoOptions& crypto_options,
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer)
- : event_log_(rtc_event_log),
+ : worker_thread_(TaskQueueBase::Current()),
+ event_log_(rtc_event_log),
rtp_receive_statistics_(ReceiveStatistics::Create(clock)),
remote_ssrc_(remote_ssrc),
acm_receiver_(AcmConfig(neteq_factory,
@@ -502,10 +546,13 @@ ChannelReceive::ChannelReceive(
associated_send_channel_(nullptr),
frame_decryptor_(frame_decryptor),
crypto_options_(crypto_options),
- absolute_capture_time_receiver_(clock) {
+ absolute_capture_time_interpolator_(clock) {
+ RTC_DCHECK(worker_thread_);
RTC_DCHECK(module_process_thread_);
RTC_DCHECK(audio_device_module);
+ network_thread_checker_.Detach();
+
acm_receiver_.ResetInitialDelay();
acm_receiver_.SetMinimumDelay(0);
acm_receiver_.SetMaximumDelay(0);
@@ -540,7 +587,7 @@ ChannelReceive::ChannelReceive(
}
ChannelReceive::~ChannelReceive() {
- RTC_DCHECK(construction_thread_.IsCurrent());
+ RTC_DCHECK_RUN_ON(&construction_thread_);
// Unregister the module before stopping playout etc, to match the order
// things were set up in the ctor.
@@ -561,13 +608,11 @@ void ChannelReceive::SetSink(AudioSinkInterface* sink) {
void ChannelReceive::StartPlayout() {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
- MutexLock lock(&playing_lock_);
playing_ = true;
}
void ChannelReceive::StopPlayout() {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
- MutexLock lock(&playing_lock_);
playing_ = false;
_outputAudioLevel.ResetLevelFullRange();
}
@@ -595,11 +640,8 @@ void ChannelReceive::OnRtpPacket(const RtpPacketReceived& packet) {
// UpdatePlayoutTimestamp and
int64_t now_ms = rtc::TimeMillis();
- {
- MutexLock lock(&sync_info_lock_);
- last_received_rtp_timestamp_ = packet.Timestamp();
- last_received_rtp_system_time_ms_ = now_ms;
- }
+ last_received_rtp_timestamp_ = packet.Timestamp();
+ last_received_rtp_system_time_ms_ = now_ms;
// Store playout timestamp for the received RTP packet
UpdatePlayoutTimestamp(false, now_ms);
@@ -618,9 +660,9 @@ void ChannelReceive::OnRtpPacket(const RtpPacketReceived& packet) {
// Interpolates absolute capture timestamp RTP header extension.
header.extension.absolute_capture_time =
- absolute_capture_time_receiver_.OnReceivePacket(
- AbsoluteCaptureTimeReceiver::GetSource(header.ssrc,
- header.arrOfCSRCs),
+ absolute_capture_time_interpolator_.OnReceivePacket(
+ AbsoluteCaptureTimeInterpolator::GetSource(header.ssrc,
+ header.arrOfCSRCs),
header.timestamp,
rtc::saturated_cast<uint32_t>(packet_copy.payload_type_frequency()),
header.extension.absolute_capture_time);
@@ -632,7 +674,7 @@ void ChannelReceive::ReceivePacket(const uint8_t* packet,
size_t packet_length,
const RTPHeader& header) {
const uint8_t* payload = packet + header.headerLength;
- assert(packet_length >= header.headerLength);
+ RTC_DCHECK_GE(packet_length, header.headerLength);
size_t payload_length = packet_length - header.headerLength;
size_t payload_data_length = payload_length - header.paddingLength;
@@ -713,7 +755,7 @@ void ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
absl::optional<int64_t> remote_to_local_clock_offset_ms =
ntp_estimator_.EstimateRemoteToLocalClockOffsetMs();
if (remote_to_local_clock_offset_ms.has_value()) {
- absolute_capture_time_receiver_.SetRemoteToLocalClockOffset(
+ capture_clock_offset_updater_.SetRemoteToLocalClockOffset(
Int64MsToQ32x32(*remote_to_local_clock_offset_ms));
}
}
@@ -838,8 +880,7 @@ int ChannelReceive::ResendPackets(const uint16_t* sequence_numbers,
void ChannelReceive::SetAssociatedSendChannel(
const ChannelSendInterface* channel) {
- // TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
- RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ RTC_DCHECK_RUN_ON(&network_thread_checker_);
associated_send_channel_ = channel;
}
@@ -848,11 +889,33 @@ void ChannelReceive::SetDepacketizerToDecoderFrameTransformer(
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
// Depending on when the channel is created, the transformer might be set
// twice. Don't replace the delegate if it was already initialized.
- if (!frame_transformer || frame_transformer_delegate_)
+ if (!frame_transformer || frame_transformer_delegate_) {
+ RTC_NOTREACHED() << "Not setting the transformer?";
return;
+ }
+
InitFrameTransformerDelegate(std::move(frame_transformer));
}
+void ChannelReceive::SetFrameDecryptor(
+ rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
+ // TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ frame_decryptor_ = std::move(frame_decryptor);
+}
+
+void ChannelReceive::OnLocalSsrcChange(uint32_t local_ssrc) {
+ // TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ rtp_rtcp_->SetLocalSsrc(local_ssrc);
+}
+
+uint32_t ChannelReceive::GetLocalSsrc() const {
+ // TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ return rtp_rtcp_->local_media_ssrc();
+}
+
NetworkStatistics ChannelReceive::GetNetworkStatistics(
bool get_and_clear_legacy_stats) const {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
@@ -870,14 +933,8 @@ AudioDecodingCallStats ChannelReceive::GetDecodingCallStatistics() const {
uint32_t ChannelReceive::GetDelayEstimate() const {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-
- uint32_t playout_delay;
- {
- MutexLock lock(&video_sync_lock_);
- playout_delay = playout_delay_ms_;
- }
// Return the current jitter buffer delay + playout delay.
- return acm_receiver_.FilteredCurrentDelayMs() + playout_delay;
+ return acm_receiver_.FilteredCurrentDelayMs() + playout_delay_ms_;
}
bool ChannelReceive::SetMinimumPlayoutDelay(int delay_ms) {
@@ -899,21 +956,17 @@ bool ChannelReceive::SetMinimumPlayoutDelay(int delay_ms) {
bool ChannelReceive::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
int64_t* time_ms) const {
- RTC_DCHECK_RUNS_SERIALIZED(&video_capture_thread_race_checker_);
- {
- MutexLock lock(&video_sync_lock_);
- if (!playout_timestamp_rtp_time_ms_)
- return false;
- *rtp_timestamp = playout_timestamp_rtp_;
- *time_ms = playout_timestamp_rtp_time_ms_.value();
- return true;
- }
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ if (!playout_timestamp_rtp_time_ms_)
+ return false;
+ *rtp_timestamp = playout_timestamp_rtp_;
+ *time_ms = playout_timestamp_rtp_time_ms_.value();
+ return true;
}
void ChannelReceive::SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
int64_t time_ms) {
- RTC_DCHECK_RUNS_SERIALIZED(&video_capture_thread_race_checker_);
- MutexLock lock(&video_sync_lock_);
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
playout_timestamp_ntp_ = ntp_timestamp_ms;
playout_timestamp_ntp_time_ms_ = time_ms;
}
@@ -921,7 +974,6 @@ void ChannelReceive::SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
absl::optional<int64_t>
ChannelReceive::GetCurrentEstimatedPlayoutNtpTimestampMs(int64_t now_ms) const {
RTC_DCHECK_RUN_ON(&worker_thread_checker_);
- MutexLock lock(&video_sync_lock_);
if (!playout_timestamp_ntp_ || !playout_timestamp_ntp_time_ms_)
return absl::nullopt;
@@ -951,24 +1003,19 @@ absl::optional<Syncable::Info> ChannelReceive::GetSyncInfo() const {
return absl::nullopt;
}
- {
- MutexLock lock(&sync_info_lock_);
- if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_ms_) {
- return absl::nullopt;
- }
- info.latest_received_capture_timestamp = *last_received_rtp_timestamp_;
- info.latest_receive_time_ms = *last_received_rtp_system_time_ms_;
+ if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_ms_) {
+ return absl::nullopt;
}
+ info.latest_received_capture_timestamp = *last_received_rtp_timestamp_;
+ info.latest_receive_time_ms = *last_received_rtp_system_time_ms_;
int jitter_buffer_delay = acm_receiver_.FilteredCurrentDelayMs();
- {
- MutexLock lock(&video_sync_lock_);
- info.current_delay_ms = jitter_buffer_delay + playout_delay_ms_;
- }
+ info.current_delay_ms = jitter_buffer_delay + playout_delay_ms_;
return info;
}
+// RTC_RUN_ON(worker_thread_checker_)
void ChannelReceive::UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms) {
// TODO(bugs.webrtc.org/11993): Expect to be called exclusively on the
// network thread. Once that's done, we won't need video_sync_lock_.
@@ -995,14 +1042,11 @@ void ChannelReceive::UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms) {
// Remove the playout delay.
playout_timestamp -= (delay_ms * (GetRtpTimestampRateHz() / 1000));
- {
- MutexLock lock(&video_sync_lock_);
- if (!rtcp && playout_timestamp != playout_timestamp_rtp_) {
- playout_timestamp_rtp_ = playout_timestamp;
- playout_timestamp_rtp_time_ms_ = now_ms;
- }
- playout_delay_ms_ = delay_ms;
+ if (!rtcp && playout_timestamp != playout_timestamp_rtp_) {
+ playout_timestamp_rtp_ = playout_timestamp;
+ playout_timestamp_rtp_time_ms_ = now_ms;
}
+ playout_delay_ms_ = delay_ms;
}
int ChannelReceive::GetRtpTimestampRateHz() const {
@@ -1020,7 +1064,7 @@ int ChannelReceive::GetRtpTimestampRateHz() const {
}
int64_t ChannelReceive::GetRTT() const {
- RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+ RTC_DCHECK_RUN_ON(&network_thread_checker_);
std::vector<ReportBlockData> report_blocks =
rtp_rtcp_->GetLatestReportBlockData();
@@ -1067,8 +1111,8 @@ std::unique_ptr<ChannelReceiveInterface> CreateChannelReceive(
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, frame_decryptor, crypto_options,
- std::move(frame_transformer));
+ 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 c55968b55f..196e441fac 100644
--- a/audio/channel_receive.h
+++ b/audio/channel_receive.h
@@ -159,6 +159,12 @@ class ChannelReceiveInterface : public RtpPacketSinkInterface {
virtual void SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<webrtc::FrameTransformerInterface>
frame_transformer) = 0;
+
+ virtual void SetFrameDecryptor(
+ rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) = 0;
+
+ virtual void OnLocalSsrcChange(uint32_t local_ssrc) = 0;
+ virtual uint32_t GetLocalSsrc() const = 0;
};
std::unique_ptr<ChannelReceiveInterface> CreateChannelReceive(
diff --git a/audio/channel_receive_frame_transformer_delegate.cc b/audio/channel_receive_frame_transformer_delegate.cc
index 261afbb100..7e617df780 100644
--- a/audio/channel_receive_frame_transformer_delegate.cc
+++ b/audio/channel_receive_frame_transformer_delegate.cc
@@ -47,7 +47,7 @@ class TransformableAudioFrame : public TransformableAudioFrameInterface {
ChannelReceiveFrameTransformerDelegate::ChannelReceiveFrameTransformerDelegate(
ReceiveFrameCallback receive_frame_callback,
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
- rtc::Thread* channel_receive_thread)
+ TaskQueueBase* channel_receive_thread)
: receive_frame_callback_(receive_frame_callback),
frame_transformer_(std::move(frame_transformer)),
channel_receive_thread_(channel_receive_thread) {}
diff --git a/audio/channel_receive_frame_transformer_delegate.h b/audio/channel_receive_frame_transformer_delegate.h
index 0af748e37f..f59834d24e 100644
--- a/audio/channel_receive_frame_transformer_delegate.h
+++ b/audio/channel_receive_frame_transformer_delegate.h
@@ -32,7 +32,7 @@ class ChannelReceiveFrameTransformerDelegate : public TransformedFrameCallback {
ChannelReceiveFrameTransformerDelegate(
ReceiveFrameCallback receive_frame_callback,
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
- rtc::Thread* channel_receive_thread);
+ TaskQueueBase* channel_receive_thread);
// Registers |this| as callback for |frame_transformer_|, to get the
// transformed frames.
@@ -67,7 +67,7 @@ class ChannelReceiveFrameTransformerDelegate : public TransformedFrameCallback {
RTC_GUARDED_BY(sequence_checker_);
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_
RTC_GUARDED_BY(sequence_checker_);
- rtc::Thread* channel_receive_thread_;
+ TaskQueueBase* const channel_receive_thread_;
};
} // namespace webrtc
diff --git a/audio/channel_receive_frame_transformer_delegate_unittest.cc b/audio/channel_receive_frame_transformer_delegate_unittest.cc
index e7f5a454b8..01aac45b24 100644
--- a/audio/channel_receive_frame_transformer_delegate_unittest.cc
+++ b/audio/channel_receive_frame_transformer_delegate_unittest.cc
@@ -41,9 +41,9 @@ class MockChannelReceive {
TEST(ChannelReceiveFrameTransformerDelegateTest,
RegisterTransformedFrameCallbackOnInit) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
- new rtc::RefCountedObject<MockFrameTransformer>();
+ rtc::make_ref_counted<MockFrameTransformer>();
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate =
- new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
ChannelReceiveFrameTransformerDelegate::ReceiveFrameCallback(),
mock_frame_transformer, nullptr);
EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback);
@@ -55,9 +55,9 @@ TEST(ChannelReceiveFrameTransformerDelegateTest,
TEST(ChannelReceiveFrameTransformerDelegateTest,
UnregisterTransformedFrameCallbackOnReset) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
- new rtc::RefCountedObject<MockFrameTransformer>();
+ rtc::make_ref_counted<MockFrameTransformer>();
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate =
- new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
ChannelReceiveFrameTransformerDelegate::ReceiveFrameCallback(),
mock_frame_transformer, nullptr);
EXPECT_CALL(*mock_frame_transformer, UnregisterTransformedFrameCallback);
@@ -69,10 +69,10 @@ TEST(ChannelReceiveFrameTransformerDelegateTest,
TEST(ChannelReceiveFrameTransformerDelegateTest,
TransformRunsChannelReceiveCallback) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
- new rtc::RefCountedObject<NiceMock<MockFrameTransformer>>();
+ rtc::make_ref_counted<NiceMock<MockFrameTransformer>>();
MockChannelReceive mock_channel;
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate =
- new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
mock_channel.callback(), mock_frame_transformer,
rtc::Thread::Current());
rtc::scoped_refptr<TransformedFrameCallback> callback;
@@ -100,10 +100,10 @@ TEST(ChannelReceiveFrameTransformerDelegateTest,
TEST(ChannelReceiveFrameTransformerDelegateTest,
OnTransformedDoesNotRunChannelReceiveCallbackAfterReset) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
- new rtc::RefCountedObject<testing::NiceMock<MockFrameTransformer>>();
+ rtc::make_ref_counted<testing::NiceMock<MockFrameTransformer>>();
MockChannelReceive mock_channel;
rtc::scoped_refptr<ChannelReceiveFrameTransformerDelegate> delegate =
- new rtc::RefCountedObject<ChannelReceiveFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelReceiveFrameTransformerDelegate>(
mock_channel.callback(), mock_frame_transformer,
rtc::Thread::Current());
diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 0434e484cb..47afc7982b 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -919,7 +919,7 @@ void ChannelSend::InitFrameTransformerDelegate(
absolute_capture_timestamp_ms);
};
frame_transformer_delegate_ =
- new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
std::move(send_audio_callback), std::move(frame_transformer),
&encoder_queue_);
frame_transformer_delegate_->Init();
diff --git a/audio/channel_send_frame_transformer_delegate_unittest.cc b/audio/channel_send_frame_transformer_delegate_unittest.cc
index e2f3647c0a..2ec78f8922 100644
--- a/audio/channel_send_frame_transformer_delegate_unittest.cc
+++ b/audio/channel_send_frame_transformer_delegate_unittest.cc
@@ -53,9 +53,9 @@ class MockChannelSend {
TEST(ChannelSendFrameTransformerDelegateTest,
RegisterTransformedFrameCallbackOnInit) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
- new rtc::RefCountedObject<MockFrameTransformer>();
+ rtc::make_ref_counted<MockFrameTransformer>();
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate =
- new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
ChannelSendFrameTransformerDelegate::SendFrameCallback(),
mock_frame_transformer, nullptr);
EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback);
@@ -67,9 +67,9 @@ TEST(ChannelSendFrameTransformerDelegateTest,
TEST(ChannelSendFrameTransformerDelegateTest,
UnregisterTransformedFrameCallbackOnReset) {
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
- new rtc::RefCountedObject<MockFrameTransformer>();
+ rtc::make_ref_counted<MockFrameTransformer>();
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate =
- new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
ChannelSendFrameTransformerDelegate::SendFrameCallback(),
mock_frame_transformer, nullptr);
EXPECT_CALL(*mock_frame_transformer, UnregisterTransformedFrameCallback);
@@ -82,10 +82,10 @@ TEST(ChannelSendFrameTransformerDelegateTest,
TransformRunsChannelSendCallback) {
TaskQueueForTest channel_queue("channel_queue");
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
- new rtc::RefCountedObject<NiceMock<MockFrameTransformer>>();
+ rtc::make_ref_counted<NiceMock<MockFrameTransformer>>();
MockChannelSend mock_channel;
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate =
- new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
mock_channel.callback(), mock_frame_transformer, &channel_queue);
rtc::scoped_refptr<TransformedFrameCallback> callback;
EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameCallback)
@@ -112,10 +112,10 @@ TEST(ChannelSendFrameTransformerDelegateTest,
OnTransformedDoesNotRunChannelSendCallbackAfterReset) {
TaskQueueForTest channel_queue("channel_queue");
rtc::scoped_refptr<MockFrameTransformer> mock_frame_transformer =
- new rtc::RefCountedObject<testing::NiceMock<MockFrameTransformer>>();
+ rtc::make_ref_counted<testing::NiceMock<MockFrameTransformer>>();
MockChannelSend mock_channel;
rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate =
- new rtc::RefCountedObject<ChannelSendFrameTransformerDelegate>(
+ rtc::make_ref_counted<ChannelSendFrameTransformerDelegate>(
mock_channel.callback(), mock_frame_transformer, &channel_queue);
delegate->Reset();
diff --git a/audio/mock_voe_channel_proxy.h b/audio/mock_voe_channel_proxy.h
index 7f140d400d..ea2a2ac3f0 100644
--- a/audio/mock_voe_channel_proxy.h
+++ b/audio/mock_voe_channel_proxy.h
@@ -17,6 +17,7 @@
#include <utility>
#include <vector>
+#include "api/crypto/frame_decryptor_interface.h"
#include "api/test/mock_frame_encryptor.h"
#include "audio/channel_receive.h"
#include "audio/channel_send.h"
@@ -98,6 +99,13 @@ class MockChannelReceive : public voe::ChannelReceiveInterface {
SetDepacketizerToDecoderFrameTransformer,
(rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer),
(override));
+ MOCK_METHOD(
+ void,
+ SetFrameDecryptor,
+ (rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor),
+ (override));
+ MOCK_METHOD(void, OnLocalSsrcChange, (uint32_t local_ssrc), (override));
+ MOCK_METHOD(uint32_t, GetLocalSsrc, (), (const, override));
};
class MockChannelSend : public voe::ChannelSendInterface {
diff --git a/audio/voip/test/audio_channel_unittest.cc b/audio/voip/test/audio_channel_unittest.cc
index e0244c76b7..f99d163022 100644
--- a/audio/voip/test/audio_channel_unittest.cc
+++ b/audio/voip/test/audio_channel_unittest.cc
@@ -65,7 +65,7 @@ class AudioChannelTest : public ::testing::Test {
// Also this uses the same transport object for different audio channel to
// simplify network routing logic.
rtc::scoped_refptr<AudioChannel> audio_channel =
- new rtc::RefCountedObject<AudioChannel>(
+ rtc::make_ref_counted<AudioChannel>(
&transport_, ssrc, task_queue_factory_.get(), process_thread_.get(),
audio_mixer_.get(), decoder_factory_);
audio_channel->SetEncoder(kPcmuPayload, kPcmuFormat,
diff --git a/audio/voip/test/voip_core_unittest.cc b/audio/voip/test/voip_core_unittest.cc
index d290bd6ec3..0d407601a3 100644
--- a/audio/voip/test/voip_core_unittest.cc
+++ b/audio/voip/test/voip_core_unittest.cc
@@ -39,7 +39,7 @@ class VoipCoreTest : public ::testing::Test {
auto encoder_factory = CreateBuiltinAudioEncoderFactory();
auto decoder_factory = CreateBuiltinAudioDecoderFactory();
rtc::scoped_refptr<AudioProcessing> audio_processing =
- new rtc::RefCountedObject<NiceMock<test::MockAudioProcessing>>();
+ rtc::make_ref_counted<NiceMock<test::MockAudioProcessing>>();
auto process_thread = std::make_unique<NiceMock<MockProcessThread>>();
// Hold the pointer to use for testing.
diff --git a/audio/voip/voip_core.cc b/audio/voip/voip_core.cc
index 33dadbc9af..67ae4c6521 100644
--- a/audio/voip/voip_core.cc
+++ b/audio/voip/voip_core.cc
@@ -138,7 +138,7 @@ ChannelId VoipCore::CreateChannel(Transport* transport,
}
rtc::scoped_refptr<AudioChannel> channel =
- new rtc::RefCountedObject<AudioChannel>(
+ rtc::make_ref_counted<AudioChannel>(
transport, local_ssrc.value(), task_queue_factory_.get(),
process_thread_.get(), audio_mixer_.get(), decoder_factory_);
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-28 09:22:45 +0000