mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-16 23:30:48 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Replaces static modifier functions in AudioSendStream.

Browse source 
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}
This commit is contained in:
Sebastian Jansson 2019-10-04 09:30:32 +02:00 committed by Commit Bot
parent db0b3bcbfe
commit 35cf9e76a8
2 changed files with 117 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

180
audio/audio_send_stream.cc
View file

@ -192,7 +192,7 @@ AudioSendStream::AudioSendStream(
rtp_rtcp_module_ = channel_send_->GetRtpRtcp(); rtp_rtcp_module_ = channel_send_->GetRtpRtcp();
RTC_DCHECK(rtp_rtcp_module_); RTC_DCHECK(rtp_rtcp_module_);
ConfigureStream(this, config, true); ConfigureStream(config, true);
pacer_thread_checker_.Detach(); pacer_thread_checker_.Detach();
if (rtp_transport_) { if (rtp_transport_) {
@ -225,7 +225,7 @@ const webrtc::AudioSendStream::Config& AudioSendStream::GetConfig() const {
void AudioSendStream::Reconfigure( void AudioSendStream::Reconfigure(
const webrtc::AudioSendStream::Config& new_config) { const webrtc::AudioSendStream::Config& new_config) {
RTC_DCHECK(worker_thread_checker_.IsCurrent()); RTC_DCHECK(worker_thread_checker_.IsCurrent());
ConfigureStream(this, new_config, false); ConfigureStream(new_config, false);
} }
AudioSendStream::ExtensionIds AudioSendStream::FindExtensionIds( AudioSendStream::ExtensionIds AudioSendStream::FindExtensionIds(
@ -254,116 +254,114 @@ int AudioSendStream::TransportSeqNumId(const AudioSendStream::Config& config) {
} }
void AudioSendStream::ConfigureStream( void AudioSendStream::ConfigureStream(
webrtc::internal::AudioSendStream* stream,
const webrtc::AudioSendStream::Config& new_config, const webrtc::AudioSendStream::Config& new_config,
bool first_time) { bool first_time) {
RTC_LOG(LS_INFO) << "AudioSendStream::ConfigureStream: " RTC_LOG(LS_INFO) << "AudioSendStream::ConfigureStream: "
<< new_config.ToString(); << new_config.ToString();
UpdateEventLogStreamConfig(stream->event_log_, new_config, UpdateEventLogStreamConfig(event_log_, new_config,
first_time ? nullptr : &stream->config_); first_time ? nullptr : &config_);
const auto& channel_send = stream->channel_send_; const auto& old_config = config_;
const auto& old_config = stream->config_;
stream->config_cs_.Enter(); config_cs_.Enter();
// Configuration parameters which cannot be changed. // Configuration parameters which cannot be changed.
RTC_DCHECK(first_time || RTC_DCHECK(first_time ||
old_config.send_transport == new_config.send_transport); old_config.send_transport == new_config.send_transport);
RTC_DCHECK(first_time || old_config.rtp.ssrc == new_config.rtp.ssrc); RTC_DCHECK(first_time || old_config.rtp.ssrc == new_config.rtp.ssrc);
if (stream->suspended_rtp_state_ && first_time) { if (suspended_rtp_state_ && first_time) {
stream->rtp_rtcp_module_->SetRtpState(*stream->suspended_rtp_state_); rtp_rtcp_module_->SetRtpState(*suspended_rtp_state_);
} }
if (first_time || old_config.rtp.c_name != new_config.rtp.c_name) { 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. // Enable the frame encryptor if a new frame encryptor has been provided.
if (first_time || new_config.frame_encryptor != old_config.frame_encryptor) { 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 || if (first_time ||
new_config.rtp.extmap_allow_mixed != old_config.rtp.extmap_allow_mixed) { 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 old_ids = FindExtensionIds(old_config.rtp.extensions);
const ExtensionIds new_ids = FindExtensionIds(new_config.rtp.extensions); const ExtensionIds new_ids = FindExtensionIds(new_config.rtp.extensions);
stream->config_cs_.Leave(); config_cs_.Leave();
// Audio level indication // Audio level indication
if (first_time || new_ids.audio_level != old_ids.audio_level) { if (first_time || new_ids.audio_level != old_ids.audio_level) {
channel_send->SetSendAudioLevelIndicationStatus(new_ids.audio_level != 0, channel_send_->SetSendAudioLevelIndicationStatus(new_ids.audio_level != 0,
new_ids.audio_level); new_ids.audio_level);
} }
if (first_time || new_ids.abs_send_time != old_ids.abs_send_time) { if (first_time || new_ids.abs_send_time != old_ids.abs_send_time) {
channel_send->GetRtpRtcp()->DeregisterSendRtpHeaderExtension( channel_send_->GetRtpRtcp()->DeregisterSendRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime); kRtpExtensionAbsoluteSendTime);
if (new_ids.abs_send_time) { if (new_ids.abs_send_time) {
channel_send->GetRtpRtcp()->RegisterSendRtpHeaderExtension( channel_send_->GetRtpRtcp()->RegisterSendRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, new_ids.abs_send_time); kRtpExtensionAbsoluteSendTime, new_ids.abs_send_time);
} }
} }
bool transport_seq_num_id_changed = bool transport_seq_num_id_changed =
new_ids.transport_sequence_number != old_ids.transport_sequence_number; new_ids.transport_sequence_number != old_ids.transport_sequence_number;
if (first_time || (transport_seq_num_id_changed && if (first_time ||
!stream->allocate_audio_without_feedback_)) { (transport_seq_num_id_changed && !allocate_audio_without_feedback_)) {
if (!first_time) { if (!first_time) {
channel_send->ResetSenderCongestionControlObjects(); channel_send_->ResetSenderCongestionControlObjects();
} }
RtcpBandwidthObserver* bandwidth_observer = nullptr; RtcpBandwidthObserver* bandwidth_observer = nullptr;
if (stream->audio_send_side_bwe_ && if (audio_send_side_bwe_ && !allocate_audio_without_feedback_ &&
!stream->allocate_audio_without_feedback_ &&
new_ids.transport_sequence_number != 0) { new_ids.transport_sequence_number != 0) {
channel_send->EnableSendTransportSequenceNumber( channel_send_->EnableSendTransportSequenceNumber(
new_ids.transport_sequence_number); new_ids.transport_sequence_number);
// Probing in application limited region is only used in combination with // Probing in application limited region is only used in combination with
// send side congestion control, wich depends on feedback packets which // send side congestion control, wich depends on feedback packets which
// requires transport sequence numbers to be enabled. // requires transport sequence numbers to be enabled.
if (stream->rtp_transport_) { if (rtp_transport_) {
// Optionally request ALR probing but do not override any existing // Optionally request ALR probing but do not override any existing
// request from other streams. // request from other streams.
if (stream->enable_audio_alr_probing_) { if (enable_audio_alr_probing_) {
stream->rtp_transport_->EnablePeriodicAlrProbing(true); rtp_transport_->EnablePeriodicAlrProbing(true);
} }
bandwidth_observer = stream->rtp_transport_->GetBandwidthObserver(); bandwidth_observer = rtp_transport_->GetBandwidthObserver();
} }
} }
if (stream->rtp_transport_) { if (rtp_transport_) {
channel_send->RegisterSenderCongestionControlObjects( channel_send_->RegisterSenderCongestionControlObjects(rtp_transport_,
stream->rtp_transport_, bandwidth_observer); bandwidth_observer);
} }
} }
stream->config_cs_.Enter(); config_cs_.Enter();
// MID RTP header extension. // MID RTP header extension.
if ((first_time || new_ids.mid != old_ids.mid || if ((first_time || new_ids.mid != old_ids.mid ||
new_config.rtp.mid != old_config.rtp.mid) && new_config.rtp.mid != old_config.rtp.mid) &&
new_ids.mid != 0 && !new_config.rtp.mid.empty()) { 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 // RID RTP header extension
if ((first_time || new_ids.rid != old_ids.rid || if ((first_time || new_ids.rid != old_ids.rid ||
new_ids.repaired_rid != old_ids.repaired_rid || new_ids.repaired_rid != old_ids.repaired_rid ||
new_config.rtp.rid != old_config.rtp.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."; RTC_LOG(LS_ERROR) << "Failed to set up send codec state.";
} }
if (stream->sending_) { if (sending_) {
ReconfigureBitrateObserver(stream, new_config); ReconfigureBitrateObserver(new_config);
} }
stream->config_ = new_config; config_ = new_config;
stream->config_cs_.Leave(); config_cs_.Leave();
} }
void AudioSendStream::Start() { void AudioSendStream::Start() {
@ -642,8 +640,7 @@ void AudioSendStream::StoreEncoderProperties(int sample_rate_hz,
} }
// Apply current codec settings to a single voe::Channel used for sending. // Apply current codec settings to a single voe::Channel used for sending.
bool AudioSendStream::SetupSendCodec(AudioSendStream* stream, bool AudioSendStream::SetupSendCodec(const Config& new_config) {
const Config& new_config) {
RTC_DCHECK(new_config.send_codec_spec); RTC_DCHECK(new_config.send_codec_spec);
const auto& spec = *new_config.send_codec_spec; const auto& spec = *new_config.send_codec_spec;
@ -667,7 +664,7 @@ bool AudioSendStream::SetupSendCodec(AudioSendStream* stream,
// Enable ANA if configured (currently only used by Opus). // Enable ANA if configured (currently only used by Opus).
if (new_config.audio_network_adaptor_config) { if (new_config.audio_network_adaptor_config) {
if (encoder->EnableAudioNetworkAdaptor( 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 " RTC_DLOG(LS_INFO) << "Audio network adaptor enabled on SSRC "
<< new_config.rtp.ssrc; << new_config.rtp.ssrc;
} else { } else {
@ -684,36 +681,33 @@ bool AudioSendStream::SetupSendCodec(AudioSendStream* stream,
cng_config.vad_mode = Vad::kVadNormal; cng_config.vad_mode = Vad::kVadNormal;
encoder = CreateComfortNoiseEncoder(std::move(cng_config)); encoder = CreateComfortNoiseEncoder(std::move(cng_config));
stream->RegisterCngPayloadType( RegisterCngPayloadType(*spec.cng_payload_type,
*spec.cng_payload_type,
new_config.send_codec_spec->format.clockrate_hz); new_config.send_codec_spec->format.clockrate_hz);
} }
// Set currently known overhead (used in ANA, opus only). // Set currently known overhead (used in ANA, opus only).
// If overhead changes later, it will be updated in UpdateOverheadForEncoder. // If overhead changes later, it will be updated in UpdateOverheadForEncoder.
{ {
rtc::CritScope cs(&stream->overhead_per_packet_lock_); rtc::CritScope cs(&overhead_per_packet_lock_);
if (stream->GetPerPacketOverheadBytes() > 0) { if (GetPerPacketOverheadBytes() > 0) {
encoder->OnReceivedOverhead(stream->GetPerPacketOverheadBytes()); encoder->OnReceivedOverhead(GetPerPacketOverheadBytes());
} }
} }
stream->worker_queue_->PostTask( worker_queue_->PostTask(
[stream, length_range = encoder->GetFrameLengthRange()] { [this, length_range = encoder->GetFrameLengthRange()] {
RTC_DCHECK_RUN_ON(stream->worker_queue_); RTC_DCHECK_RUN_ON(worker_queue_);
stream->frame_length_range_ = length_range; frame_length_range_ = length_range;
}); });
stream->StoreEncoderProperties(encoder->SampleRateHz(), StoreEncoderProperties(encoder->SampleRateHz(), encoder->NumChannels());
encoder->NumChannels()); channel_send_->SetEncoder(new_config.send_codec_spec->payload_type,
stream->channel_send_->SetEncoder(new_config.send_codec_spec->payload_type,
std::move(encoder)); std::move(encoder));
return true; return true;
} }
bool AudioSendStream::ReconfigureSendCodec(AudioSendStream* stream, bool AudioSendStream::ReconfigureSendCodec(const Config& new_config) {
const Config& new_config) { const auto& old_config = config_;
const auto& old_config = stream->config_;
if (!new_config.send_codec_spec) { if (!new_config.send_codec_spec) {
// We cannot de-configure a send codec. So we will do nothing. // We cannot de-configure a send codec. So we will do nothing.
@ -735,7 +729,7 @@ bool AudioSendStream::ReconfigureSendCodec(AudioSendStream* stream,
old_config.send_codec_spec->format || old_config.send_codec_spec->format ||
new_config.send_codec_spec->payload_type != new_config.send_codec_spec->payload_type !=
old_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 = const absl::optional<int>& new_target_bitrate_bps =
@ -745,33 +739,32 @@ bool AudioSendStream::ReconfigureSendCodec(AudioSendStream* stream,
if (new_target_bitrate_bps && if (new_target_bitrate_bps &&
new_target_bitrate_bps != new_target_bitrate_bps !=
old_config.send_codec_spec->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); encoder->OnReceivedTargetAudioBitrate(*new_target_bitrate_bps);
}); });
} }
ReconfigureANA(stream, new_config); ReconfigureANA(new_config);
ReconfigureCNG(stream, new_config); ReconfigureCNG(new_config);
// Set currently known overhead (used in ANA, opus only). // Set currently known overhead (used in ANA, opus only).
{ {
rtc::CritScope cs(&stream->overhead_per_packet_lock_); rtc::CritScope cs(&overhead_per_packet_lock_);
stream->UpdateOverheadForEncoder(); UpdateOverheadForEncoder();
} }
return true; return true;
} }
void AudioSendStream::ReconfigureANA(AudioSendStream* stream, void AudioSendStream::ReconfigureANA(const Config& new_config) {
const Config& new_config) {
if (new_config.audio_network_adaptor_config == if (new_config.audio_network_adaptor_config ==
stream->config_.audio_network_adaptor_config) { config_.audio_network_adaptor_config) {
return; return;
} }
if (new_config.audio_network_adaptor_config) { if (new_config.audio_network_adaptor_config) {
stream->channel_send_->CallEncoder([&](AudioEncoder* encoder) { channel_send_->CallEncoder([&](AudioEncoder* encoder) {
if (encoder->EnableAudioNetworkAdaptor( 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 " RTC_DLOG(LS_INFO) << "Audio network adaptor enabled on SSRC "
<< new_config.rtp.ssrc; << new_config.rtp.ssrc;
} else { } else {
@ -779,31 +772,28 @@ void AudioSendStream::ReconfigureANA(AudioSendStream* stream,
} }
}); });
} else { } else {
stream->channel_send_->CallEncoder( channel_send_->CallEncoder(
[&](AudioEncoder* encoder) { encoder->DisableAudioNetworkAdaptor(); }); [&](AudioEncoder* encoder) { encoder->DisableAudioNetworkAdaptor(); });
RTC_DLOG(LS_INFO) << "Audio network adaptor disabled on SSRC " RTC_DLOG(LS_INFO) << "Audio network adaptor disabled on SSRC "
<< new_config.rtp.ssrc; << new_config.rtp.ssrc;
} }
} }
void AudioSendStream::ReconfigureCNG(AudioSendStream* stream, void AudioSendStream::ReconfigureCNG(const Config& new_config) {
const Config& new_config) {
if (new_config.send_codec_spec->cng_payload_type == 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; return;
} }
// Register the CNG payload type if it's been added, don't do anything if CNG // Register the CNG payload type if it's been added, don't do anything if CNG
// is removed. Payload types must not be redefined. // is removed. Payload types must not be redefined.
if (new_config.send_codec_spec->cng_payload_type) { if (new_config.send_codec_spec->cng_payload_type) {
stream->RegisterCngPayloadType( RegisterCngPayloadType(*new_config.send_codec_spec->cng_payload_type,
*new_config.send_codec_spec->cng_payload_type,
new_config.send_codec_spec->format.clockrate_hz); new_config.send_codec_spec->format.clockrate_hz);
} }
// Wrap or unwrap the encoder in an AudioEncoderCNG. // Wrap or unwrap the encoder in an AudioEncoderCNG.
stream->channel_send_->ModifyEncoder( channel_send_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder_ptr) {
[&](std::unique_ptr<AudioEncoder>* encoder_ptr) {
std::unique_ptr<AudioEncoder> old_encoder(std::move(*encoder_ptr)); std::unique_ptr<AudioEncoder> old_encoder(std::move(*encoder_ptr));
auto sub_encoders = old_encoder->ReclaimContainedEncoders(); auto sub_encoders = old_encoder->ReclaimContainedEncoders();
if (!sub_encoders.empty()) { if (!sub_encoders.empty()) {
@ -829,18 +819,17 @@ void AudioSendStream::ReconfigureCNG(AudioSendStream* stream,
} }
void AudioSendStream::ReconfigureBitrateObserver( void AudioSendStream::ReconfigureBitrateObserver(
AudioSendStream* stream,
const webrtc::AudioSendStream::Config& new_config) { 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 // 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 // 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 // limits set, but would only have us call RemoveBitrateObserver if we were
// previously configured with bitrate limits. // previously configured with bitrate limits.
if (stream->config_.min_bitrate_bps == new_config.min_bitrate_bps && if (config_.min_bitrate_bps == new_config.min_bitrate_bps &&
stream->config_.max_bitrate_bps == new_config.max_bitrate_bps && config_.max_bitrate_bps == new_config.max_bitrate_bps &&
stream->config_.bitrate_priority == new_config.bitrate_priority && config_.bitrate_priority == new_config.bitrate_priority &&
(TransportSeqNumId(stream->config_) == TransportSeqNumId(new_config) || (TransportSeqNumId(config_) == TransportSeqNumId(new_config) ||
!stream->audio_send_side_bwe_)) { !audio_send_side_bwe_)) {
return; return;
} }
@ -848,27 +837,28 @@ void AudioSendStream::ReconfigureBitrateObserver(
// audio_send_side_bwe_ is false. // audio_send_side_bwe_ is false.
if (!new_config.has_dscp && new_config.min_bitrate_bps != -1 && if (!new_config.has_dscp && new_config.min_bitrate_bps != -1 &&
new_config.max_bitrate_bps != -1 && new_config.max_bitrate_bps != -1 &&
(TransportSeqNumId(new_config) != 0 || !stream->audio_send_side_bwe_)) { (TransportSeqNumId(new_config) != 0 || !audio_send_side_bwe_)) {
stream->rtp_transport_->AccountForAudioPacketsInPacedSender(true); rtp_transport_->AccountForAudioPacketsInPacedSender(true);
rtc::Event thread_sync_event; rtc::Event thread_sync_event;
stream->worker_queue_->PostTask([&] { worker_queue_->PostTask([&] {
RTC_DCHECK_RUN_ON(stream->worker_queue_); RTC_DCHECK_RUN_ON(worker_queue_);
stream->registered_with_allocator_ = true; registered_with_allocator_ = true;
// We may get a callback immediately as the observer is registered, so // We may get a callback immediately as the observer is registered, so
// make // make
// sure the bitrate limits in config_ are up-to-date. // sure the bitrate limits in config_ are up-to-date.
stream->config_.min_bitrate_bps = new_config.min_bitrate_bps; config_.min_bitrate_bps = new_config.min_bitrate_bps;
stream->config_.max_bitrate_bps = new_config.max_bitrate_bps; config_.max_bitrate_bps = new_config.max_bitrate_bps;
stream->config_.bitrate_priority = new_config.bitrate_priority;
stream->ConfigureBitrateObserver(); config_.bitrate_priority = new_config.bitrate_priority;
ConfigureBitrateObserver();
thread_sync_event.Set(); thread_sync_event.Set();
}); });
thread_sync_event.Wait(rtc::Event::kForever); thread_sync_event.Wait(rtc::Event::kForever);
stream->rtp_rtcp_module_->SetAsPartOfAllocation(true); rtp_rtcp_module_->SetAsPartOfAllocation(true);
} else { } else {
stream->rtp_transport_->AccountForAudioPacketsInPacedSender(false); rtp_transport_->AccountForAudioPacketsInPacedSender(false);
stream->RemoveBitrateObserver(); RemoveBitrateObserver();
stream->rtp_rtcp_module_->SetAsPartOfAllocation(false); rtp_rtcp_module_->SetAsPartOfAllocation(false);
} }
} }

18
audio/audio_send_stream.h
View file

@ -131,18 +131,12 @@ class AudioSendStream final : public webrtc::AudioSendStream,
void StoreEncoderProperties(int sample_rate_hz, size_t num_channels); void StoreEncoderProperties(int sample_rate_hz, size_t num_channels);
// These are all static to make it less likely that (the old) config_ is void ConfigureStream(const Config& new_config, bool first_time);
// accessed unintentionally. bool SetupSendCodec(const Config& new_config);
static void ConfigureStream(AudioSendStream* stream, bool ReconfigureSendCodec(const Config& new_config);
const Config& new_config, void ReconfigureANA(const Config& new_config);
bool first_time); void ReconfigureCNG(const Config& new_config);
static bool SetupSendCodec(AudioSendStream* stream, const Config& new_config); void ReconfigureBitrateObserver(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 ConfigureBitrateObserver() RTC_RUN_ON(worker_queue_); void ConfigureBitrateObserver() RTC_RUN_ON(worker_queue_);
void RemoveBitrateObserver(); void RemoveBitrateObserver();