Replaces static modifier functions in AudioSendStream.
The pattern of using a static function rather than a regular function is
not very well motivated and we don't do that in other places.
To maintain consistency over the code base this Cl replaces those static
modifier functions with regular member functions.
Bug: webrtc:9883
Change-Id: I8edd1781d98905de82722458a0d272af90689a2f
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/155522
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29391}
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index 22bd983..401e859 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -192,7 +192,7 @@
rtp_rtcp_module_ = channel_send_->GetRtpRtcp();
RTC_DCHECK(rtp_rtcp_module_);
- ConfigureStream(this, config, true);
+ ConfigureStream(config, true);
pacer_thread_checker_.Detach();
if (rtp_transport_) {
@@ -225,7 +225,7 @@
void AudioSendStream::Reconfigure(
const webrtc::AudioSendStream::Config& new_config) {
RTC_DCHECK(worker_thread_checker_.IsCurrent());
- ConfigureStream(this, new_config, false);
+ ConfigureStream(new_config, false);
}
AudioSendStream::ExtensionIds AudioSendStream::FindExtensionIds(
@@ -254,116 +254,114 @@
}
void AudioSendStream::ConfigureStream(
- webrtc::internal::AudioSendStream* stream,
const webrtc::AudioSendStream::Config& new_config,
bool first_time) {
RTC_LOG(LS_INFO) << "AudioSendStream::ConfigureStream: "
<< new_config.ToString();
- UpdateEventLogStreamConfig(stream->event_log_, new_config,
- first_time ? nullptr : &stream->config_);
+ UpdateEventLogStreamConfig(event_log_, new_config,
+ first_time ? nullptr : &config_);
- const auto& channel_send = stream->channel_send_;
- const auto& old_config = stream->config_;
+ const auto& old_config = config_;
- stream->config_cs_.Enter();
+ config_cs_.Enter();
// Configuration parameters which cannot be changed.
RTC_DCHECK(first_time ||
old_config.send_transport == new_config.send_transport);
RTC_DCHECK(first_time || old_config.rtp.ssrc == new_config.rtp.ssrc);
- if (stream->suspended_rtp_state_ && first_time) {
- stream->rtp_rtcp_module_->SetRtpState(*stream->suspended_rtp_state_);
+ if (suspended_rtp_state_ && first_time) {
+ rtp_rtcp_module_->SetRtpState(*suspended_rtp_state_);
}
if (first_time || old_config.rtp.c_name != new_config.rtp.c_name) {
- channel_send->SetRTCP_CNAME(new_config.rtp.c_name);
+ channel_send_->SetRTCP_CNAME(new_config.rtp.c_name);
}
// Enable the frame encryptor if a new frame encryptor has been provided.
if (first_time || new_config.frame_encryptor != old_config.frame_encryptor) {
- channel_send->SetFrameEncryptor(new_config.frame_encryptor);
+ channel_send_->SetFrameEncryptor(new_config.frame_encryptor);
}
if (first_time ||
new_config.rtp.extmap_allow_mixed != old_config.rtp.extmap_allow_mixed) {
- channel_send->SetExtmapAllowMixed(new_config.rtp.extmap_allow_mixed);
+ channel_send_->SetExtmapAllowMixed(new_config.rtp.extmap_allow_mixed);
}
const ExtensionIds old_ids = FindExtensionIds(old_config.rtp.extensions);
const ExtensionIds new_ids = FindExtensionIds(new_config.rtp.extensions);
- stream->config_cs_.Leave();
+ config_cs_.Leave();
// Audio level indication
if (first_time || new_ids.audio_level != old_ids.audio_level) {
- channel_send->SetSendAudioLevelIndicationStatus(new_ids.audio_level != 0,
- new_ids.audio_level);
+ channel_send_->SetSendAudioLevelIndicationStatus(new_ids.audio_level != 0,
+ new_ids.audio_level);
}
if (first_time || new_ids.abs_send_time != old_ids.abs_send_time) {
- channel_send->GetRtpRtcp()->DeregisterSendRtpHeaderExtension(
+ channel_send_->GetRtpRtcp()->DeregisterSendRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime);
if (new_ids.abs_send_time) {
- channel_send->GetRtpRtcp()->RegisterSendRtpHeaderExtension(
+ channel_send_->GetRtpRtcp()->RegisterSendRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, new_ids.abs_send_time);
}
}
bool transport_seq_num_id_changed =
new_ids.transport_sequence_number != old_ids.transport_sequence_number;
- if (first_time || (transport_seq_num_id_changed &&
- !stream->allocate_audio_without_feedback_)) {
+ if (first_time ||
+ (transport_seq_num_id_changed && !allocate_audio_without_feedback_)) {
if (!first_time) {
- channel_send->ResetSenderCongestionControlObjects();
+ channel_send_->ResetSenderCongestionControlObjects();
}
RtcpBandwidthObserver* bandwidth_observer = nullptr;
- if (stream->audio_send_side_bwe_ &&
- !stream->allocate_audio_without_feedback_ &&
+ if (audio_send_side_bwe_ && !allocate_audio_without_feedback_ &&
new_ids.transport_sequence_number != 0) {
- channel_send->EnableSendTransportSequenceNumber(
+ channel_send_->EnableSendTransportSequenceNumber(
new_ids.transport_sequence_number);
// Probing in application limited region is only used in combination with
// send side congestion control, wich depends on feedback packets which
// requires transport sequence numbers to be enabled.
- if (stream->rtp_transport_) {
+ if (rtp_transport_) {
// Optionally request ALR probing but do not override any existing
// request from other streams.
- if (stream->enable_audio_alr_probing_) {
- stream->rtp_transport_->EnablePeriodicAlrProbing(true);
+ if (enable_audio_alr_probing_) {
+ rtp_transport_->EnablePeriodicAlrProbing(true);
}
- bandwidth_observer = stream->rtp_transport_->GetBandwidthObserver();
+ bandwidth_observer = rtp_transport_->GetBandwidthObserver();
}
}
- if (stream->rtp_transport_) {
- channel_send->RegisterSenderCongestionControlObjects(
- stream->rtp_transport_, bandwidth_observer);
+ if (rtp_transport_) {
+ channel_send_->RegisterSenderCongestionControlObjects(rtp_transport_,
+ bandwidth_observer);
}
}
- stream->config_cs_.Enter();
+ config_cs_.Enter();
// MID RTP header extension.
if ((first_time || new_ids.mid != old_ids.mid ||
new_config.rtp.mid != old_config.rtp.mid) &&
new_ids.mid != 0 && !new_config.rtp.mid.empty()) {
- channel_send->SetMid(new_config.rtp.mid, new_ids.mid);
+ channel_send_->SetMid(new_config.rtp.mid, new_ids.mid);
}
// RID RTP header extension
if ((first_time || new_ids.rid != old_ids.rid ||
new_ids.repaired_rid != old_ids.repaired_rid ||
new_config.rtp.rid != old_config.rtp.rid)) {
- channel_send->SetRid(new_config.rtp.rid, new_ids.rid, new_ids.repaired_rid);
+ channel_send_->SetRid(new_config.rtp.rid, new_ids.rid,
+ new_ids.repaired_rid);
}
- if (!ReconfigureSendCodec(stream, new_config)) {
+ if (!ReconfigureSendCodec(new_config)) {
RTC_LOG(LS_ERROR) << "Failed to set up send codec state.";
}
- if (stream->sending_) {
- ReconfigureBitrateObserver(stream, new_config);
+ if (sending_) {
+ ReconfigureBitrateObserver(new_config);
}
- stream->config_ = new_config;
- stream->config_cs_.Leave();
+ config_ = new_config;
+ config_cs_.Leave();
}
void AudioSendStream::Start() {
@@ -642,8 +640,7 @@
}
// Apply current codec settings to a single voe::Channel used for sending.
-bool AudioSendStream::SetupSendCodec(AudioSendStream* stream,
- const Config& new_config) {
+bool AudioSendStream::SetupSendCodec(const Config& new_config) {
RTC_DCHECK(new_config.send_codec_spec);
const auto& spec = *new_config.send_codec_spec;
@@ -667,7 +664,7 @@
// Enable ANA if configured (currently only used by Opus).
if (new_config.audio_network_adaptor_config) {
if (encoder->EnableAudioNetworkAdaptor(
- *new_config.audio_network_adaptor_config, stream->event_log_)) {
+ *new_config.audio_network_adaptor_config, event_log_)) {
RTC_DLOG(LS_INFO) << "Audio network adaptor enabled on SSRC "
<< new_config.rtp.ssrc;
} else {
@@ -684,36 +681,33 @@
cng_config.vad_mode = Vad::kVadNormal;
encoder = CreateComfortNoiseEncoder(std::move(cng_config));
- stream->RegisterCngPayloadType(
- *spec.cng_payload_type,
- new_config.send_codec_spec->format.clockrate_hz);
+ RegisterCngPayloadType(*spec.cng_payload_type,
+ new_config.send_codec_spec->format.clockrate_hz);
}
// Set currently known overhead (used in ANA, opus only).
// If overhead changes later, it will be updated in UpdateOverheadForEncoder.
{
- rtc::CritScope cs(&stream->overhead_per_packet_lock_);
- if (stream->GetPerPacketOverheadBytes() > 0) {
- encoder->OnReceivedOverhead(stream->GetPerPacketOverheadBytes());
+ rtc::CritScope cs(&overhead_per_packet_lock_);
+ if (GetPerPacketOverheadBytes() > 0) {
+ encoder->OnReceivedOverhead(GetPerPacketOverheadBytes());
}
}
- stream->worker_queue_->PostTask(
- [stream, length_range = encoder->GetFrameLengthRange()] {
- RTC_DCHECK_RUN_ON(stream->worker_queue_);
- stream->frame_length_range_ = length_range;
+ worker_queue_->PostTask(
+ [this, length_range = encoder->GetFrameLengthRange()] {
+ RTC_DCHECK_RUN_ON(worker_queue_);
+ frame_length_range_ = length_range;
});
- stream->StoreEncoderProperties(encoder->SampleRateHz(),
- encoder->NumChannels());
- stream->channel_send_->SetEncoder(new_config.send_codec_spec->payload_type,
- std::move(encoder));
+ StoreEncoderProperties(encoder->SampleRateHz(), encoder->NumChannels());
+ channel_send_->SetEncoder(new_config.send_codec_spec->payload_type,
+ std::move(encoder));
return true;
}
-bool AudioSendStream::ReconfigureSendCodec(AudioSendStream* stream,
- const Config& new_config) {
- const auto& old_config = stream->config_;
+bool AudioSendStream::ReconfigureSendCodec(const Config& new_config) {
+ const auto& old_config = config_;
if (!new_config.send_codec_spec) {
// We cannot de-configure a send codec. So we will do nothing.
@@ -735,7 +729,7 @@
old_config.send_codec_spec->format ||
new_config.send_codec_spec->payload_type !=
old_config.send_codec_spec->payload_type) {
- return SetupSendCodec(stream, new_config);
+ return SetupSendCodec(new_config);
}
const absl::optional<int>& new_target_bitrate_bps =
@@ -745,33 +739,32 @@
if (new_target_bitrate_bps &&
new_target_bitrate_bps !=
old_config.send_codec_spec->target_bitrate_bps) {
- stream->channel_send_->CallEncoder([&](AudioEncoder* encoder) {
+ channel_send_->CallEncoder([&](AudioEncoder* encoder) {
encoder->OnReceivedTargetAudioBitrate(*new_target_bitrate_bps);
});
}
- ReconfigureANA(stream, new_config);
- ReconfigureCNG(stream, new_config);
+ ReconfigureANA(new_config);
+ ReconfigureCNG(new_config);
// Set currently known overhead (used in ANA, opus only).
{
- rtc::CritScope cs(&stream->overhead_per_packet_lock_);
- stream->UpdateOverheadForEncoder();
+ rtc::CritScope cs(&overhead_per_packet_lock_);
+ UpdateOverheadForEncoder();
}
return true;
}
-void AudioSendStream::ReconfigureANA(AudioSendStream* stream,
- const Config& new_config) {
+void AudioSendStream::ReconfigureANA(const Config& new_config) {
if (new_config.audio_network_adaptor_config ==
- stream->config_.audio_network_adaptor_config) {
+ config_.audio_network_adaptor_config) {
return;
}
if (new_config.audio_network_adaptor_config) {
- stream->channel_send_->CallEncoder([&](AudioEncoder* encoder) {
+ channel_send_->CallEncoder([&](AudioEncoder* encoder) {
if (encoder->EnableAudioNetworkAdaptor(
- *new_config.audio_network_adaptor_config, stream->event_log_)) {
+ *new_config.audio_network_adaptor_config, event_log_)) {
RTC_DLOG(LS_INFO) << "Audio network adaptor enabled on SSRC "
<< new_config.rtp.ssrc;
} else {
@@ -779,68 +772,64 @@
}
});
} else {
- stream->channel_send_->CallEncoder(
+ channel_send_->CallEncoder(
[&](AudioEncoder* encoder) { encoder->DisableAudioNetworkAdaptor(); });
RTC_DLOG(LS_INFO) << "Audio network adaptor disabled on SSRC "
<< new_config.rtp.ssrc;
}
}
-void AudioSendStream::ReconfigureCNG(AudioSendStream* stream,
- const Config& new_config) {
+void AudioSendStream::ReconfigureCNG(const Config& new_config) {
if (new_config.send_codec_spec->cng_payload_type ==
- stream->config_.send_codec_spec->cng_payload_type) {
+ config_.send_codec_spec->cng_payload_type) {
return;
}
// Register the CNG payload type if it's been added, don't do anything if CNG
// is removed. Payload types must not be redefined.
if (new_config.send_codec_spec->cng_payload_type) {
- stream->RegisterCngPayloadType(
- *new_config.send_codec_spec->cng_payload_type,
- new_config.send_codec_spec->format.clockrate_hz);
+ RegisterCngPayloadType(*new_config.send_codec_spec->cng_payload_type,
+ new_config.send_codec_spec->format.clockrate_hz);
}
// Wrap or unwrap the encoder in an AudioEncoderCNG.
- stream->channel_send_->ModifyEncoder(
- [&](std::unique_ptr<AudioEncoder>* encoder_ptr) {
- std::unique_ptr<AudioEncoder> old_encoder(std::move(*encoder_ptr));
- auto sub_encoders = old_encoder->ReclaimContainedEncoders();
- if (!sub_encoders.empty()) {
- // Replace enc with its sub encoder. We need to put the sub
- // encoder in a temporary first, since otherwise the old value
- // of enc would be destroyed before the new value got assigned,
- // which would be bad since the new value is a part of the old
- // value.
- auto tmp = std::move(sub_encoders[0]);
- old_encoder = std::move(tmp);
- }
- if (new_config.send_codec_spec->cng_payload_type) {
- AudioEncoderCngConfig config;
- config.speech_encoder = std::move(old_encoder);
- config.num_channels = config.speech_encoder->NumChannels();
- config.payload_type = *new_config.send_codec_spec->cng_payload_type;
- config.vad_mode = Vad::kVadNormal;
- *encoder_ptr = CreateComfortNoiseEncoder(std::move(config));
- } else {
- *encoder_ptr = std::move(old_encoder);
- }
- });
+ channel_send_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder_ptr) {
+ std::unique_ptr<AudioEncoder> old_encoder(std::move(*encoder_ptr));
+ auto sub_encoders = old_encoder->ReclaimContainedEncoders();
+ if (!sub_encoders.empty()) {
+ // Replace enc with its sub encoder. We need to put the sub
+ // encoder in a temporary first, since otherwise the old value
+ // of enc would be destroyed before the new value got assigned,
+ // which would be bad since the new value is a part of the old
+ // value.
+ auto tmp = std::move(sub_encoders[0]);
+ old_encoder = std::move(tmp);
+ }
+ if (new_config.send_codec_spec->cng_payload_type) {
+ AudioEncoderCngConfig config;
+ config.speech_encoder = std::move(old_encoder);
+ config.num_channels = config.speech_encoder->NumChannels();
+ config.payload_type = *new_config.send_codec_spec->cng_payload_type;
+ config.vad_mode = Vad::kVadNormal;
+ *encoder_ptr = CreateComfortNoiseEncoder(std::move(config));
+ } else {
+ *encoder_ptr = std::move(old_encoder);
+ }
+ });
}
void AudioSendStream::ReconfigureBitrateObserver(
- AudioSendStream* stream,
const webrtc::AudioSendStream::Config& new_config) {
- RTC_DCHECK_RUN_ON(&stream->worker_thread_checker_);
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
// Since the Config's default is for both of these to be -1, this test will
// allow us to configure the bitrate observer if the new config has bitrate
// limits set, but would only have us call RemoveBitrateObserver if we were
// previously configured with bitrate limits.
- if (stream->config_.min_bitrate_bps == new_config.min_bitrate_bps &&
- stream->config_.max_bitrate_bps == new_config.max_bitrate_bps &&
- stream->config_.bitrate_priority == new_config.bitrate_priority &&
- (TransportSeqNumId(stream->config_) == TransportSeqNumId(new_config) ||
- !stream->audio_send_side_bwe_)) {
+ if (config_.min_bitrate_bps == new_config.min_bitrate_bps &&
+ config_.max_bitrate_bps == new_config.max_bitrate_bps &&
+ config_.bitrate_priority == new_config.bitrate_priority &&
+ (TransportSeqNumId(config_) == TransportSeqNumId(new_config) ||
+ !audio_send_side_bwe_)) {
return;
}
@@ -848,27 +837,28 @@
// audio_send_side_bwe_ is false.
if (!new_config.has_dscp && new_config.min_bitrate_bps != -1 &&
new_config.max_bitrate_bps != -1 &&
- (TransportSeqNumId(new_config) != 0 || !stream->audio_send_side_bwe_)) {
- stream->rtp_transport_->AccountForAudioPacketsInPacedSender(true);
+ (TransportSeqNumId(new_config) != 0 || !audio_send_side_bwe_)) {
+ rtp_transport_->AccountForAudioPacketsInPacedSender(true);
rtc::Event thread_sync_event;
- stream->worker_queue_->PostTask([&] {
- RTC_DCHECK_RUN_ON(stream->worker_queue_);
- stream->registered_with_allocator_ = true;
+ worker_queue_->PostTask([&] {
+ RTC_DCHECK_RUN_ON(worker_queue_);
+ registered_with_allocator_ = true;
// We may get a callback immediately as the observer is registered, so
// make
// sure the bitrate limits in config_ are up-to-date.
- stream->config_.min_bitrate_bps = new_config.min_bitrate_bps;
- stream->config_.max_bitrate_bps = new_config.max_bitrate_bps;
- stream->config_.bitrate_priority = new_config.bitrate_priority;
- stream->ConfigureBitrateObserver();
+ config_.min_bitrate_bps = new_config.min_bitrate_bps;
+ config_.max_bitrate_bps = new_config.max_bitrate_bps;
+
+ config_.bitrate_priority = new_config.bitrate_priority;
+ ConfigureBitrateObserver();
thread_sync_event.Set();
});
thread_sync_event.Wait(rtc::Event::kForever);
- stream->rtp_rtcp_module_->SetAsPartOfAllocation(true);
+ rtp_rtcp_module_->SetAsPartOfAllocation(true);
} else {
- stream->rtp_transport_->AccountForAudioPacketsInPacedSender(false);
- stream->RemoveBitrateObserver();
- stream->rtp_rtcp_module_->SetAsPartOfAllocation(false);
+ rtp_transport_->AccountForAudioPacketsInPacedSender(false);
+ RemoveBitrateObserver();
+ rtp_rtcp_module_->SetAsPartOfAllocation(false);
}
}
diff --git a/audio/audio_send_stream.h b/audio/audio_send_stream.h
index 3cd3a6c..336a041 100644
--- a/audio/audio_send_stream.h
+++ b/audio/audio_send_stream.h
@@ -131,18 +131,12 @@
void StoreEncoderProperties(int sample_rate_hz, size_t num_channels);
- // These are all static to make it less likely that (the old) config_ is
- // accessed unintentionally.
- static void ConfigureStream(AudioSendStream* stream,
- const Config& new_config,
- bool first_time);
- static bool SetupSendCodec(AudioSendStream* stream, const Config& new_config);
- static bool ReconfigureSendCodec(AudioSendStream* stream,
- const Config& new_config);
- static void ReconfigureANA(AudioSendStream* stream, const Config& new_config);
- static void ReconfigureCNG(AudioSendStream* stream, const Config& new_config);
- static void ReconfigureBitrateObserver(AudioSendStream* stream,
- const Config& new_config);
+ void ConfigureStream(const Config& new_config, bool first_time);
+ bool SetupSendCodec(const Config& new_config);
+ bool ReconfigureSendCodec(const Config& new_config);
+ void ReconfigureANA(const Config& new_config);
+ void ReconfigureCNG(const Config& new_config);
+ void ReconfigureBitrateObserver(const Config& new_config);
void ConfigureBitrateObserver() RTC_RUN_ON(worker_queue_);
void RemoveBitrateObserver();
