1 /*
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "audio/audio_send_stream.h"
12
13 #include <string>
14 #include <utility>
15 #include <vector>
16
17 #include "audio/audio_state.h"
18 #include "audio/conversion.h"
19 #include "audio/scoped_voe_interface.h"
20 #include "call/rtp_transport_controller_send_interface.h"
21 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
22 #include "modules/bitrate_controller/include/bitrate_controller.h"
23 #include "modules/congestion_controller/include/send_side_congestion_controller.h"
24 #include "modules/pacing/paced_sender.h"
25 #include "rtc_base/checks.h"
26 #include "rtc_base/event.h"
27 #include "rtc_base/function_view.h"
28 #include "rtc_base/logging.h"
29 #include "rtc_base/task_queue.h"
30 #include "rtc_base/timeutils.h"
31 #include "voice_engine/channel_proxy.h"
32 #include "voice_engine/include/voe_base.h"
33 #include "voice_engine/transmit_mixer.h"
34 #include "voice_engine/voice_engine_impl.h"
35
36 namespace webrtc {
37
38 namespace internal {
39 // TODO(eladalon): Subsequent CL will make these values experiment-dependent.
40 constexpr size_t kPacketLossTrackerMaxWindowSizeMs = 15000;
41 constexpr size_t kPacketLossRateMinNumAckedPackets = 50;
42 constexpr size_t kRecoverablePacketLossRateMinNumAckedPairs = 40;
43
44 namespace {
CallEncoder(const std::unique_ptr<voe::ChannelProxy> & channel_proxy,rtc::FunctionView<void (AudioEncoder *)> lambda)45 void CallEncoder(const std::unique_ptr<voe::ChannelProxy>& channel_proxy,
46 rtc::FunctionView<void(AudioEncoder*)> lambda) {
47 channel_proxy->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder_ptr) {
48 RTC_DCHECK(encoder_ptr);
49 lambda(encoder_ptr->get());
50 });
51 }
52 } // namespace
53
54 // TODO(saza): Move this declaration further down when we can use
55 // std::make_unique.
56 class AudioSendStream::TimedTransport : public Transport {
57 public:
TimedTransport(Transport * transport,TimeInterval * time_interval)58 TimedTransport(Transport* transport, TimeInterval* time_interval)
59 : transport_(transport), lifetime_(time_interval) {}
SendRtp(const uint8_t * packet,size_t length,const PacketOptions & options)60 bool SendRtp(const uint8_t* packet,
61 size_t length,
62 const PacketOptions& options) {
63 if (lifetime_) {
64 lifetime_->Extend();
65 }
66 return transport_->SendRtp(packet, length, options);
67 }
SendRtcp(const uint8_t * packet,size_t length)68 bool SendRtcp(const uint8_t* packet, size_t length) {
69 return transport_->SendRtcp(packet, length);
70 }
~TimedTransport()71 ~TimedTransport() {}
72
73 private:
74 Transport* transport_;
75 TimeInterval* lifetime_;
76 };
77
AudioSendStream(const webrtc::AudioSendStream::Config & config,const rtc::scoped_refptr<webrtc::AudioState> & audio_state,rtc::TaskQueue * worker_queue,RtpTransportControllerSendInterface * transport,BitrateAllocator * bitrate_allocator,RtcEventLog * event_log,RtcpRttStats * rtcp_rtt_stats,const rtc::Optional<RtpState> & suspended_rtp_state)78 AudioSendStream::AudioSendStream(
79 const webrtc::AudioSendStream::Config& config,
80 const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
81 rtc::TaskQueue* worker_queue,
82 RtpTransportControllerSendInterface* transport,
83 BitrateAllocator* bitrate_allocator,
84 RtcEventLog* event_log,
85 RtcpRttStats* rtcp_rtt_stats,
86 const rtc::Optional<RtpState>& suspended_rtp_state)
87 : worker_queue_(worker_queue),
88 config_(Config(nullptr)),
89 audio_state_(audio_state),
90 event_log_(event_log),
91 bitrate_allocator_(bitrate_allocator),
92 transport_(transport),
93 packet_loss_tracker_(kPacketLossTrackerMaxWindowSizeMs,
94 kPacketLossRateMinNumAckedPackets,
95 kRecoverablePacketLossRateMinNumAckedPairs),
96 rtp_rtcp_module_(nullptr),
97 suspended_rtp_state_(suspended_rtp_state) {
98 RTC_LOG(LS_INFO) << "AudioSendStream: " << config.ToString();
99 RTC_DCHECK_NE(config.voe_channel_id, -1);
100 RTC_DCHECK(audio_state_.get());
101 RTC_DCHECK(transport);
102 RTC_DCHECK(transport->send_side_cc());
103
104 VoiceEngineImpl* voe_impl = static_cast<VoiceEngineImpl*>(voice_engine());
105 channel_proxy_ = voe_impl->GetChannelProxy(config.voe_channel_id);
106 channel_proxy_->SetRtcEventLog(event_log_);
107 channel_proxy_->SetRtcpRttStats(rtcp_rtt_stats);
108 channel_proxy_->SetRTCPStatus(true);
109 RtpReceiver* rtpReceiver = nullptr; // Unused, but required for call.
110 channel_proxy_->GetRtpRtcp(&rtp_rtcp_module_, &rtpReceiver);
111 RTC_DCHECK(rtp_rtcp_module_);
112
113 ConfigureStream(this, config, true);
114
115 pacer_thread_checker_.DetachFromThread();
116 // Signal congestion controller this object is ready for OnPacket* callbacks.
117 transport_->send_side_cc()->RegisterPacketFeedbackObserver(this);
118 }
119
~AudioSendStream()120 AudioSendStream::~AudioSendStream() {
121 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
122 RTC_LOG(LS_INFO) << "~AudioSendStream: " << config_.ToString();
123 transport_->send_side_cc()->DeRegisterPacketFeedbackObserver(this);
124 channel_proxy_->RegisterTransport(nullptr);
125 channel_proxy_->ResetSenderCongestionControlObjects();
126 channel_proxy_->SetRtcEventLog(nullptr);
127 channel_proxy_->SetRtcpRttStats(nullptr);
128 }
129
GetConfig() const130 const webrtc::AudioSendStream::Config& AudioSendStream::GetConfig() const {
131 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
132 return config_;
133 }
134
Reconfigure(const webrtc::AudioSendStream::Config & new_config)135 void AudioSendStream::Reconfigure(
136 const webrtc::AudioSendStream::Config& new_config) {
137 ConfigureStream(this, new_config, false);
138 }
139
ConfigureStream(webrtc::internal::AudioSendStream * stream,const webrtc::AudioSendStream::Config & new_config,bool first_time)140 void AudioSendStream::ConfigureStream(
141 webrtc::internal::AudioSendStream* stream,
142 const webrtc::AudioSendStream::Config& new_config,
143 bool first_time) {
144 RTC_LOG(LS_INFO) << "AudioSendStream::Configuring: " << new_config.ToString();
145 const auto& channel_proxy = stream->channel_proxy_;
146 const auto& old_config = stream->config_;
147
148 if (first_time || old_config.rtp.ssrc != new_config.rtp.ssrc) {
149 channel_proxy->SetLocalSSRC(new_config.rtp.ssrc);
150 if (stream->suspended_rtp_state_) {
151 stream->rtp_rtcp_module_->SetRtpState(*stream->suspended_rtp_state_);
152 }
153 }
154 if (first_time || old_config.rtp.c_name != new_config.rtp.c_name) {
155 channel_proxy->SetRTCP_CNAME(new_config.rtp.c_name);
156 }
157 // TODO(solenberg): Config NACK history window (which is a packet count),
158 // using the actual packet size for the configured codec.
159 if (first_time || old_config.rtp.nack.rtp_history_ms !=
160 new_config.rtp.nack.rtp_history_ms) {
161 channel_proxy->SetNACKStatus(new_config.rtp.nack.rtp_history_ms != 0,
162 new_config.rtp.nack.rtp_history_ms / 20);
163 }
164
165 if (first_time ||
166 new_config.send_transport != old_config.send_transport) {
167 if (old_config.send_transport) {
168 channel_proxy->RegisterTransport(nullptr);
169 }
170 if (new_config.send_transport) {
171 stream->timed_send_transport_adapter_.reset(new TimedTransport(
172 new_config.send_transport, &stream->active_lifetime_));
173 } else {
174 stream->timed_send_transport_adapter_.reset(nullptr);
175 }
176 channel_proxy->RegisterTransport(
177 stream->timed_send_transport_adapter_.get());
178 }
179
180 // RFC 5285: Each distinct extension MUST have a unique ID. The value 0 is
181 // reserved for padding and MUST NOT be used as a local identifier.
182 // So it should be safe to use 0 here to indicate "not configured".
183 struct ExtensionIds {
184 int audio_level = 0;
185 int transport_sequence_number = 0;
186 };
187
188 auto find_extension_ids = [](const std::vector<RtpExtension>& extensions) {
189 ExtensionIds ids;
190 for (const auto& extension : extensions) {
191 if (extension.uri == RtpExtension::kAudioLevelUri) {
192 ids.audio_level = extension.id;
193 } else if (extension.uri == RtpExtension::kTransportSequenceNumberUri) {
194 ids.transport_sequence_number = extension.id;
195 }
196 }
197 return ids;
198 };
199
200 const ExtensionIds old_ids = find_extension_ids(old_config.rtp.extensions);
201 const ExtensionIds new_ids = find_extension_ids(new_config.rtp.extensions);
202 // Audio level indication
203 if (first_time || new_ids.audio_level != old_ids.audio_level) {
204 channel_proxy->SetSendAudioLevelIndicationStatus(new_ids.audio_level != 0,
205 new_ids.audio_level);
206 }
207 bool transport_seq_num_id_changed =
208 new_ids.transport_sequence_number != old_ids.transport_sequence_number;
209 if (first_time || transport_seq_num_id_changed) {
210 if (!first_time) {
211 channel_proxy->ResetSenderCongestionControlObjects();
212 }
213
214 RtcpBandwidthObserver* bandwidth_observer = nullptr;
215 bool has_transport_sequence_number = new_ids.transport_sequence_number != 0;
216 if (has_transport_sequence_number) {
217 channel_proxy->EnableSendTransportSequenceNumber(
218 new_ids.transport_sequence_number);
219 // Probing in application limited region is only used in combination with
220 // send side congestion control, wich depends on feedback packets which
221 // requires transport sequence numbers to be enabled.
222 stream->transport_->send_side_cc()->EnablePeriodicAlrProbing(true);
223 bandwidth_observer =
224 stream->transport_->send_side_cc()->GetBandwidthObserver();
225 }
226
227 channel_proxy->RegisterSenderCongestionControlObjects(stream->transport_,
228 bandwidth_observer);
229 }
230
231 if (!ReconfigureSendCodec(stream, new_config)) {
232 RTC_LOG(LS_ERROR) << "Failed to set up send codec state.";
233 }
234
235 ReconfigureBitrateObserver(stream, new_config);
236 stream->config_ = new_config;
237 }
238
Start()239 void AudioSendStream::Start() {
240 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
241 if (config_.min_bitrate_bps != -1 && config_.max_bitrate_bps != -1) {
242 // Audio BWE is enabled.
243 transport_->packet_sender()->SetAccountForAudioPackets(true);
244 ConfigureBitrateObserver(config_.min_bitrate_bps, config_.max_bitrate_bps);
245 }
246
247 ScopedVoEInterface<VoEBase> base(voice_engine());
248 int error = base->StartSend(config_.voe_channel_id);
249 if (error != 0) {
250 RTC_LOG(LS_ERROR) << "AudioSendStream::Start failed with error: " << error;
251 }
252 }
253
Stop()254 void AudioSendStream::Stop() {
255 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
256 RemoveBitrateObserver();
257
258 ScopedVoEInterface<VoEBase> base(voice_engine());
259 int error = base->StopSend(config_.voe_channel_id);
260 if (error != 0) {
261 RTC_LOG(LS_ERROR) << "AudioSendStream::Stop failed with error: " << error;
262 }
263 }
264
SendTelephoneEvent(int payload_type,int payload_frequency,int event,int duration_ms)265 bool AudioSendStream::SendTelephoneEvent(int payload_type,
266 int payload_frequency, int event,
267 int duration_ms) {
268 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
269 return channel_proxy_->SetSendTelephoneEventPayloadType(payload_type,
270 payload_frequency) &&
271 channel_proxy_->SendTelephoneEventOutband(event, duration_ms);
272 }
273
SetMuted(bool muted)274 void AudioSendStream::SetMuted(bool muted) {
275 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
276 channel_proxy_->SetInputMute(muted);
277 }
278
GetStats() const279 webrtc::AudioSendStream::Stats AudioSendStream::GetStats() const {
280 return GetStats(true);
281 }
282
GetStats(bool has_remote_tracks) const283 webrtc::AudioSendStream::Stats AudioSendStream::GetStats(
284 bool has_remote_tracks) const {
285 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
286 webrtc::AudioSendStream::Stats stats;
287 stats.local_ssrc = config_.rtp.ssrc;
288
289 webrtc::CallStatistics call_stats = channel_proxy_->GetRTCPStatistics();
290 stats.bytes_sent = call_stats.bytesSent;
291 stats.packets_sent = call_stats.packetsSent;
292 // RTT isn't known until a RTCP report is received. Until then, VoiceEngine
293 // returns 0 to indicate an error value.
294 if (call_stats.rttMs > 0) {
295 stats.rtt_ms = call_stats.rttMs;
296 }
297 if (config_.send_codec_spec) {
298 const auto& spec = *config_.send_codec_spec;
299 stats.codec_name = spec.format.name;
300 stats.codec_payload_type = spec.payload_type;
301
302 // Get data from the last remote RTCP report.
303 for (const auto& block : channel_proxy_->GetRemoteRTCPReportBlocks()) {
304 // Lookup report for send ssrc only.
305 if (block.source_SSRC == stats.local_ssrc) {
306 stats.packets_lost = block.cumulative_num_packets_lost;
307 stats.fraction_lost = Q8ToFloat(block.fraction_lost);
308 stats.ext_seqnum = block.extended_highest_sequence_number;
309 // Convert timestamps to milliseconds.
310 if (spec.format.clockrate_hz / 1000 > 0) {
311 stats.jitter_ms =
312 block.interarrival_jitter / (spec.format.clockrate_hz / 1000);
313 }
314 break;
315 }
316 }
317 }
318
319 ScopedVoEInterface<VoEBase> base(voice_engine());
320 RTC_DCHECK(base->transmit_mixer());
321 stats.audio_level = base->transmit_mixer()->AudioLevelFullRange();
322 RTC_DCHECK_LE(0, stats.audio_level);
323
324 stats.total_input_energy = base->transmit_mixer()->GetTotalInputEnergy();
325 stats.total_input_duration = base->transmit_mixer()->GetTotalInputDuration();
326
327 internal::AudioState* audio_state =
328 static_cast<internal::AudioState*>(audio_state_.get());
329 stats.typing_noise_detected = audio_state->typing_noise_detected();
330 stats.ana_statistics = channel_proxy_->GetANAStatistics();
331 RTC_DCHECK(audio_state_->audio_processing());
332 stats.apm_statistics =
333 audio_state_->audio_processing()->GetStatistics(has_remote_tracks);
334
335 return stats;
336 }
337
SignalNetworkState(NetworkState state)338 void AudioSendStream::SignalNetworkState(NetworkState state) {
339 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
340 }
341
DeliverRtcp(const uint8_t * packet,size_t length)342 bool AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
343 // TODO(solenberg): Tests call this function on a network thread, libjingle
344 // calls on the worker thread. We should move towards always using a network
345 // thread. Then this check can be enabled.
346 // RTC_DCHECK(!worker_thread_checker_.CalledOnValidThread());
347 return channel_proxy_->ReceivedRTCPPacket(packet, length);
348 }
349
OnBitrateUpdated(uint32_t bitrate_bps,uint8_t fraction_loss,int64_t rtt,int64_t bwe_period_ms)350 uint32_t AudioSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
351 uint8_t fraction_loss,
352 int64_t rtt,
353 int64_t bwe_period_ms) {
354 // A send stream may be allocated a bitrate of zero if the allocator decides
355 // to disable it. For now we ignore this decision and keep sending on min
356 // bitrate.
357 if (bitrate_bps == 0) {
358 bitrate_bps = config_.min_bitrate_bps;
359 }
360 RTC_DCHECK_GE(bitrate_bps,
361 static_cast<uint32_t>(config_.min_bitrate_bps));
362 // The bitrate allocator might allocate an higher than max configured bitrate
363 // if there is room, to allow for, as example, extra FEC. Ignore that for now.
364 const uint32_t max_bitrate_bps = config_.max_bitrate_bps;
365 if (bitrate_bps > max_bitrate_bps)
366 bitrate_bps = max_bitrate_bps;
367
368 channel_proxy_->SetBitrate(bitrate_bps, bwe_period_ms);
369
370 // The amount of audio protection is not exposed by the encoder, hence
371 // always returning 0.
372 return 0;
373 }
374
OnPacketAdded(uint32_t ssrc,uint16_t seq_num)375 void AudioSendStream::OnPacketAdded(uint32_t ssrc, uint16_t seq_num) {
376 RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
377 // Only packets that belong to this stream are of interest.
378 if (ssrc == config_.rtp.ssrc) {
379 rtc::CritScope lock(&packet_loss_tracker_cs_);
380 // TODO(eladalon): This function call could potentially reset the window,
381 // setting both PLR and RPLR to unknown. Consider (during upcoming
382 // refactoring) passing an indication of such an event.
383 packet_loss_tracker_.OnPacketAdded(seq_num, rtc::TimeMillis());
384 }
385 }
386
OnPacketFeedbackVector(const std::vector<PacketFeedback> & packet_feedback_vector)387 void AudioSendStream::OnPacketFeedbackVector(
388 const std::vector<PacketFeedback>& packet_feedback_vector) {
389 //Called on STS Thread as a result of delivering a packet.
390 //The functions below are protected by locks, so this should be safe.
391 //RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
392 rtc::Optional<float> plr;
393 rtc::Optional<float> rplr;
394 {
395 rtc::CritScope lock(&packet_loss_tracker_cs_);
396 packet_loss_tracker_.OnPacketFeedbackVector(packet_feedback_vector);
397 plr = packet_loss_tracker_.GetPacketLossRate();
398 rplr = packet_loss_tracker_.GetRecoverablePacketLossRate();
399 }
400 // TODO(eladalon): If R/PLR go back to unknown, no indication is given that
401 // the previously sent value is no longer relevant. This will be taken care
402 // of with some refactoring which is now being done.
403 if (plr) {
404 channel_proxy_->OnTwccBasedUplinkPacketLossRate(*plr);
405 }
406 if (rplr) {
407 channel_proxy_->OnRecoverableUplinkPacketLossRate(*rplr);
408 }
409 }
410
SetTransportOverhead(int transport_overhead_per_packet)411 void AudioSendStream::SetTransportOverhead(int transport_overhead_per_packet) {
412 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
413 transport_->send_side_cc()->SetTransportOverhead(
414 transport_overhead_per_packet);
415 channel_proxy_->SetTransportOverhead(transport_overhead_per_packet);
416 }
417
GetRtpState() const418 RtpState AudioSendStream::GetRtpState() const {
419 return rtp_rtcp_module_->GetRtpState();
420 }
421
GetActiveLifetime() const422 const TimeInterval& AudioSendStream::GetActiveLifetime() const {
423 return active_lifetime_;
424 }
425
voice_engine() const426 VoiceEngine* AudioSendStream::voice_engine() const {
427 internal::AudioState* audio_state =
428 static_cast<internal::AudioState*>(audio_state_.get());
429 VoiceEngine* voice_engine = audio_state->voice_engine();
430 RTC_DCHECK(voice_engine);
431 return voice_engine;
432 }
433
434 // Apply current codec settings to a single voe::Channel used for sending.
SetupSendCodec(AudioSendStream * stream,const Config & new_config)435 bool AudioSendStream::SetupSendCodec(AudioSendStream* stream,
436 const Config& new_config) {
437 RTC_DCHECK(new_config.send_codec_spec);
438 const auto& spec = *new_config.send_codec_spec;
439
440 RTC_DCHECK(new_config.encoder_factory);
441 std::unique_ptr<AudioEncoder> encoder =
442 new_config.encoder_factory->MakeAudioEncoder(spec.payload_type,
443 spec.format);
444
445 if (!encoder) {
446 RTC_LOG(LS_ERROR) << "Unable to create encoder for " << spec.format;
447 return false;
448 }
449 // If a bitrate has been specified for the codec, use it over the
450 // codec's default.
451 if (spec.target_bitrate_bps) {
452 encoder->OnReceivedTargetAudioBitrate(*spec.target_bitrate_bps);
453 }
454
455 // Enable ANA if configured (currently only used by Opus).
456 if (new_config.audio_network_adaptor_config) {
457 if (encoder->EnableAudioNetworkAdaptor(
458 *new_config.audio_network_adaptor_config, stream->event_log_)) {
459 RTC_LOG(LS_INFO) << "Audio network adaptor enabled on SSRC "
460 << new_config.rtp.ssrc;
461 } else {
462 RTC_NOTREACHED();
463 }
464 }
465
466 // Wrap the encoder in a an AudioEncoderCNG, if VAD is enabled.
467 if (spec.cng_payload_type) {
468 AudioEncoderCng::Config cng_config;
469 cng_config.num_channels = encoder->NumChannels();
470 cng_config.payload_type = *spec.cng_payload_type;
471 cng_config.speech_encoder = std::move(encoder);
472 cng_config.vad_mode = Vad::kVadNormal;
473 encoder.reset(new AudioEncoderCng(std::move(cng_config)));
474
475 stream->RegisterCngPayloadType(
476 *spec.cng_payload_type,
477 new_config.send_codec_spec->format.clockrate_hz);
478 }
479
480 stream->channel_proxy_->SetEncoder(new_config.send_codec_spec->payload_type,
481 std::move(encoder));
482 return true;
483 }
484
ReconfigureSendCodec(AudioSendStream * stream,const Config & new_config)485 bool AudioSendStream::ReconfigureSendCodec(AudioSendStream* stream,
486 const Config& new_config) {
487 const auto& old_config = stream->config_;
488
489 if (!new_config.send_codec_spec) {
490 // We cannot de-configure a send codec. So we will do nothing.
491 // By design, the send codec should have not been configured.
492 RTC_DCHECK(!old_config.send_codec_spec);
493 return true;
494 }
495
496 if (new_config.send_codec_spec == old_config.send_codec_spec &&
497 new_config.audio_network_adaptor_config ==
498 old_config.audio_network_adaptor_config) {
499 return true;
500 }
501
502 // If we have no encoder, or the format or payload type's changed, create a
503 // new encoder.
504 if (!old_config.send_codec_spec ||
505 new_config.send_codec_spec->format !=
506 old_config.send_codec_spec->format ||
507 new_config.send_codec_spec->payload_type !=
508 old_config.send_codec_spec->payload_type) {
509 return SetupSendCodec(stream, new_config);
510 }
511
512 const rtc::Optional<int>& new_target_bitrate_bps =
513 new_config.send_codec_spec->target_bitrate_bps;
514 // If a bitrate has been specified for the codec, use it over the
515 // codec's default.
516 if (new_target_bitrate_bps &&
517 new_target_bitrate_bps !=
518 old_config.send_codec_spec->target_bitrate_bps) {
519 CallEncoder(stream->channel_proxy_, [&](AudioEncoder* encoder) {
520 encoder->OnReceivedTargetAudioBitrate(*new_target_bitrate_bps);
521 });
522 }
523
524 ReconfigureANA(stream, new_config);
525 ReconfigureCNG(stream, new_config);
526
527 return true;
528 }
529
ReconfigureANA(AudioSendStream * stream,const Config & new_config)530 void AudioSendStream::ReconfigureANA(AudioSendStream* stream,
531 const Config& new_config) {
532 if (new_config.audio_network_adaptor_config ==
533 stream->config_.audio_network_adaptor_config) {
534 return;
535 }
536 if (new_config.audio_network_adaptor_config) {
537 CallEncoder(stream->channel_proxy_, [&](AudioEncoder* encoder) {
538 if (encoder->EnableAudioNetworkAdaptor(
539 *new_config.audio_network_adaptor_config, stream->event_log_)) {
540 RTC_LOG(LS_INFO) << "Audio network adaptor enabled on SSRC "
541 << new_config.rtp.ssrc;
542 } else {
543 RTC_NOTREACHED();
544 }
545 });
546 } else {
547 CallEncoder(stream->channel_proxy_, [&](AudioEncoder* encoder) {
548 encoder->DisableAudioNetworkAdaptor();
549 });
550 RTC_LOG(LS_INFO) << "Audio network adaptor disabled on SSRC "
551 << new_config.rtp.ssrc;
552 }
553 }
554
ReconfigureCNG(AudioSendStream * stream,const Config & new_config)555 void AudioSendStream::ReconfigureCNG(AudioSendStream* stream,
556 const Config& new_config) {
557 if (new_config.send_codec_spec->cng_payload_type ==
558 stream->config_.send_codec_spec->cng_payload_type) {
559 return;
560 }
561
562 // Register the CNG payload type if it's been added, don't do anything if CNG
563 // is removed. Payload types must not be redefined.
564 if (new_config.send_codec_spec->cng_payload_type) {
565 stream->RegisterCngPayloadType(
566 *new_config.send_codec_spec->cng_payload_type,
567 new_config.send_codec_spec->format.clockrate_hz);
568 }
569
570 // Wrap or unwrap the encoder in an AudioEncoderCNG.
571 stream->channel_proxy_->ModifyEncoder(
572 [&](std::unique_ptr<AudioEncoder>* encoder_ptr) {
573 std::unique_ptr<AudioEncoder> old_encoder(std::move(*encoder_ptr));
574 auto sub_encoders = old_encoder->ReclaimContainedEncoders();
575 if (!sub_encoders.empty()) {
576 // Replace enc with its sub encoder. We need to put the sub
577 // encoder in a temporary first, since otherwise the old value
578 // of enc would be destroyed before the new value got assigned,
579 // which would be bad since the new value is a part of the old
580 // value.
581 auto tmp = std::move(sub_encoders[0]);
582 old_encoder = std::move(tmp);
583 }
584 if (new_config.send_codec_spec->cng_payload_type) {
585 AudioEncoderCng::Config config;
586 config.speech_encoder = std::move(old_encoder);
587 config.num_channels = config.speech_encoder->NumChannels();
588 config.payload_type = *new_config.send_codec_spec->cng_payload_type;
589 config.vad_mode = Vad::kVadNormal;
590 encoder_ptr->reset(new AudioEncoderCng(std::move(config)));
591 } else {
592 *encoder_ptr = std::move(old_encoder);
593 }
594 });
595 }
596
ReconfigureBitrateObserver(AudioSendStream * stream,const webrtc::AudioSendStream::Config & new_config)597 void AudioSendStream::ReconfigureBitrateObserver(
598 AudioSendStream* stream,
599 const webrtc::AudioSendStream::Config& new_config) {
600 // Since the Config's default is for both of these to be -1, this test will
601 // allow us to configure the bitrate observer if the new config has bitrate
602 // limits set, but would only have us call RemoveBitrateObserver if we were
603 // previously configured with bitrate limits.
604 if (stream->config_.min_bitrate_bps == new_config.min_bitrate_bps &&
605 stream->config_.max_bitrate_bps == new_config.max_bitrate_bps) {
606 return;
607 }
608
609 if (new_config.min_bitrate_bps != -1 && new_config.max_bitrate_bps != -1) {
610 stream->ConfigureBitrateObserver(new_config.min_bitrate_bps,
611 new_config.max_bitrate_bps);
612 } else {
613 stream->RemoveBitrateObserver();
614 }
615 }
616
ConfigureBitrateObserver(int min_bitrate_bps,int max_bitrate_bps)617 void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
618 int max_bitrate_bps) {
619 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
620 RTC_DCHECK_GE(max_bitrate_bps, min_bitrate_bps);
621 rtc::Event thread_sync_event(false /* manual_reset */, false);
622 worker_queue_->PostTask([&] {
623 // We may get a callback immediately as the observer is registered, so make
624 // sure the bitrate limits in config_ are up-to-date.
625 config_.min_bitrate_bps = min_bitrate_bps;
626 config_.max_bitrate_bps = max_bitrate_bps;
627 bitrate_allocator_->AddObserver(this, min_bitrate_bps, max_bitrate_bps, 0,
628 true, config_.track_id);
629 thread_sync_event.Set();
630 });
631 thread_sync_event.Wait(rtc::Event::kForever);
632 }
633
RemoveBitrateObserver()634 void AudioSendStream::RemoveBitrateObserver() {
635 RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
636 rtc::Event thread_sync_event(false /* manual_reset */, false);
637 worker_queue_->PostTask([this, &thread_sync_event] {
638 bitrate_allocator_->RemoveObserver(this);
639 thread_sync_event.Set();
640 });
641 thread_sync_event.Wait(rtc::Event::kForever);
642 }
643
RegisterCngPayloadType(int payload_type,int clockrate_hz)644 void AudioSendStream::RegisterCngPayloadType(int payload_type,
645 int clockrate_hz) {
646 const CodecInst codec = {payload_type, "CN", clockrate_hz, 0, 1, 0};
647 if (rtp_rtcp_module_->RegisterSendPayload(codec) != 0) {
648 rtp_rtcp_module_->DeRegisterSendPayload(codec.pltype);
649 if (rtp_rtcp_module_->RegisterSendPayload(codec) != 0) {
650 RTC_LOG(LS_ERROR) << "RegisterCngPayloadType() failed to register CN to "
651 "RTP/RTCP module";
652 }
653 }
654 }
655
656
657 } // namespace internal
658 } // namespace webrtc
659