Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 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 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "audio/audio_receive_stream.h" |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 12 | |
| 13 | #include <string> |
Tommi | f888bb5 | 2015-12-12 01:37:01 +0100 | [diff] [blame] | 14 | #include <utility> |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 15 | |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 16 | #include "absl/memory/memory.h" |
| 17 | #include "api/array_view.h" |
| 18 | #include "api/audio_codecs/audio_format.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "api/call/audio_sink.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 20 | #include "api/rtp_parameters.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 21 | #include "audio/audio_send_stream.h" |
| 22 | #include "audio/audio_state.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 23 | #include "audio/channel_receive.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "audio/conversion.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 25 | #include "call/rtp_config.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 26 | #include "call/rtp_stream_receiver_controller_interface.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 27 | #include "rtc_base/checks.h" |
| 28 | #include "rtc_base/logging.h" |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 29 | #include "rtc_base/strings/string_builder.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 30 | #include "rtc_base/time_utils.h" |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 31 | |
| 32 | namespace webrtc { |
Stefan Holmer | 3842c5c | 2016-01-12 13:55:00 +0100 | [diff] [blame] | 33 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 34 | std::string AudioReceiveStream::Config::Rtp::ToString() const { |
Karl Wiberg | 881f168 | 2018-03-08 15:03:23 +0100 | [diff] [blame] | 35 | char ss_buf[1024]; |
| 36 | rtc::SimpleStringBuilder ss(ss_buf); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 37 | ss << "{remote_ssrc: " << remote_ssrc; |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 38 | ss << ", local_ssrc: " << local_ssrc; |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 39 | ss << ", transport_cc: " << (transport_cc ? "on" : "off"); |
| 40 | ss << ", nack: " << nack.ToString(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 41 | ss << ", extensions: ["; |
| 42 | for (size_t i = 0; i < extensions.size(); ++i) { |
| 43 | ss << extensions[i].ToString(); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 44 | if (i != extensions.size() - 1) { |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 45 | ss << ", "; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 46 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 47 | } |
| 48 | ss << ']'; |
| 49 | ss << '}'; |
| 50 | return ss.str(); |
| 51 | } |
| 52 | |
| 53 | std::string AudioReceiveStream::Config::ToString() const { |
Karl Wiberg | 881f168 | 2018-03-08 15:03:23 +0100 | [diff] [blame] | 54 | char ss_buf[1024]; |
| 55 | rtc::SimpleStringBuilder ss(ss_buf); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 56 | ss << "{rtp: " << rtp.ToString(); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 57 | ss << ", rtcp_send_transport: " |
deadbeef | 922246a | 2017-02-26 04:18:12 -0800 | [diff] [blame] | 58 | << (rtcp_send_transport ? "(Transport)" : "null"); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 59 | if (!sync_group.empty()) { |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 60 | ss << ", sync_group: " << sync_group; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 61 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 62 | ss << '}'; |
| 63 | return ss.str(); |
| 64 | } |
| 65 | |
| 66 | namespace internal { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 67 | namespace { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 68 | std::unique_ptr<voe::ChannelReceiveInterface> CreateChannelReceive( |
Sebastian Jansson | 977b335 | 2019-03-04 17:43:34 +0100 | [diff] [blame] | 69 | Clock* clock, |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 70 | webrtc::AudioState* audio_state, |
| 71 | ProcessThread* module_process_thread, |
Ivo Creusen | c3d1f9b | 2019-11-01 11:47:51 +0100 | [diff] [blame] | 72 | NetEqFactory* neteq_factory, |
Niels Möller | fa4e185 | 2018-08-14 09:43:34 +0200 | [diff] [blame] | 73 | const webrtc::AudioReceiveStream::Config& config, |
| 74 | RtcEventLog* event_log) { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 75 | RTC_DCHECK(audio_state); |
| 76 | internal::AudioState* internal_audio_state = |
| 77 | static_cast<internal::AudioState*>(audio_state); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 78 | return voe::CreateChannelReceive( |
Ivo Creusen | c3d1f9b | 2019-11-01 11:47:51 +0100 | [diff] [blame] | 79 | clock, module_process_thread, neteq_factory, |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 80 | internal_audio_state->audio_device_module(), config.rtcp_send_transport, |
| 81 | event_log, config.rtp.local_ssrc, config.rtp.remote_ssrc, |
Erik Språng | 70efdde | 2019-08-21 13:36:20 +0200 | [diff] [blame] | 82 | config.jitter_buffer_max_packets, config.jitter_buffer_fast_accelerate, |
| 83 | config.jitter_buffer_min_delay_ms, |
Jakob Ivarsson | 53eae87 | 2019-01-10 15:58:36 +0100 | [diff] [blame] | 84 | config.jitter_buffer_enable_rtx_handling, config.decoder_factory, |
Marina Ciocea | 3e9af7f | 2020-04-01 07:46:16 +0200 | [diff] [blame] | 85 | config.codec_pair_id, config.frame_decryptor, config.crypto_options, |
| 86 | std::move(config.frame_transformer)); |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 87 | } |
| 88 | } // namespace |
| 89 | |
| 90 | AudioReceiveStream::AudioReceiveStream( |
Sebastian Jansson | 977b335 | 2019-03-04 17:43:34 +0100 | [diff] [blame] | 91 | Clock* clock, |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 92 | RtpStreamReceiverControllerInterface* receiver_controller, |
| 93 | PacketRouter* packet_router, |
| 94 | ProcessThread* module_process_thread, |
Ivo Creusen | c3d1f9b | 2019-11-01 11:47:51 +0100 | [diff] [blame] | 95 | NetEqFactory* neteq_factory, |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 96 | const webrtc::AudioReceiveStream::Config& config, |
| 97 | const rtc::scoped_refptr<webrtc::AudioState>& audio_state, |
| 98 | webrtc::RtcEventLog* event_log) |
Sebastian Jansson | 977b335 | 2019-03-04 17:43:34 +0100 | [diff] [blame] | 99 | : AudioReceiveStream(clock, |
| 100 | receiver_controller, |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 101 | packet_router, |
| 102 | config, |
| 103 | audio_state, |
| 104 | event_log, |
Sebastian Jansson | 977b335 | 2019-03-04 17:43:34 +0100 | [diff] [blame] | 105 | CreateChannelReceive(clock, |
| 106 | audio_state.get(), |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 107 | module_process_thread, |
Ivo Creusen | c3d1f9b | 2019-11-01 11:47:51 +0100 | [diff] [blame] | 108 | neteq_factory, |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 109 | config, |
| 110 | event_log)) {} |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 111 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 112 | AudioReceiveStream::AudioReceiveStream( |
Sebastian Jansson | 977b335 | 2019-03-04 17:43:34 +0100 | [diff] [blame] | 113 | Clock* clock, |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 114 | RtpStreamReceiverControllerInterface* receiver_controller, |
nisse | 0245da0 | 2016-11-30 03:35:20 -0800 | [diff] [blame] | 115 | PacketRouter* packet_router, |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 116 | const webrtc::AudioReceiveStream::Config& config, |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 117 | const rtc::scoped_refptr<webrtc::AudioState>& audio_state, |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 118 | webrtc::RtcEventLog* event_log, |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 119 | std::unique_ptr<voe::ChannelReceiveInterface> channel_receive) |
Chen Xing | 054e3bb | 2019-08-02 10:29:26 +0000 | [diff] [blame] | 120 | : audio_state_(audio_state), |
| 121 | channel_receive_(std::move(channel_receive)), |
| 122 | source_tracker_(clock) { |
Jonas Olsson | 24ea822 | 2018-01-25 10:14:29 +0100 | [diff] [blame] | 123 | RTC_LOG(LS_INFO) << "AudioReceiveStream: " << config.rtp.remote_ssrc; |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 124 | RTC_DCHECK(config.decoder_factory); |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 125 | RTC_DCHECK(config.rtcp_send_transport); |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 126 | RTC_DCHECK(audio_state_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 127 | RTC_DCHECK(channel_receive_); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 128 | |
Sebastian Jansson | c01367d | 2019-04-08 15:20:44 +0200 | [diff] [blame] | 129 | module_process_thread_checker_.Detach(); |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 130 | |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 131 | RTC_DCHECK(receiver_controller); |
| 132 | RTC_DCHECK(packet_router); |
| 133 | // Configure bandwidth estimation. |
| 134 | channel_receive_->RegisterReceiverCongestionControlObjects(packet_router); |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 135 | |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 136 | // Register with transport. |
| 137 | rtp_stream_receiver_ = receiver_controller->CreateReceiver( |
| 138 | config.rtp.remote_ssrc, channel_receive_.get()); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 139 | ConfigureStream(this, config, true); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 140 | } |
| 141 | |
pbos | a2f30de | 2015-10-15 05:22:13 -0700 | [diff] [blame] | 142 | AudioReceiveStream::~AudioReceiveStream() { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 143 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Jonas Olsson | 24ea822 | 2018-01-25 10:14:29 +0100 | [diff] [blame] | 144 | RTC_LOG(LS_INFO) << "~AudioReceiveStream: " << config_.rtp.remote_ssrc; |
Fredrik Solenberg | d524751 | 2017-12-18 22:41:03 +0100 | [diff] [blame] | 145 | Stop(); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 146 | channel_receive_->SetAssociatedSendChannel(nullptr); |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 147 | channel_receive_->ResetReceiverCongestionControlObjects(); |
pbos | a2f30de | 2015-10-15 05:22:13 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 150 | void AudioReceiveStream::Reconfigure( |
| 151 | const webrtc::AudioReceiveStream::Config& config) { |
Sebastian Jansson | c01367d | 2019-04-08 15:20:44 +0200 | [diff] [blame] | 152 | RTC_DCHECK(worker_thread_checker_.IsCurrent()); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 153 | ConfigureStream(this, config, false); |
| 154 | } |
| 155 | |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 156 | void AudioReceiveStream::Start() { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 157 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 158 | if (playing_) { |
| 159 | return; |
| 160 | } |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 161 | channel_receive_->StartPlayout(); |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 162 | playing_ = true; |
Fredrik Solenberg | d524751 | 2017-12-18 22:41:03 +0100 | [diff] [blame] | 163 | audio_state()->AddReceivingStream(this); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 164 | } |
| 165 | |
| 166 | void AudioReceiveStream::Stop() { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 167 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 168 | if (!playing_) { |
| 169 | return; |
| 170 | } |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 171 | channel_receive_->StopPlayout(); |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 172 | playing_ = false; |
Fredrik Solenberg | d524751 | 2017-12-18 22:41:03 +0100 | [diff] [blame] | 173 | audio_state()->RemoveReceivingStream(this); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 174 | } |
| 175 | |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 176 | webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats() const { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 177 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 178 | webrtc::AudioReceiveStream::Stats stats; |
| 179 | stats.remote_ssrc = config_.rtp.remote_ssrc; |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 180 | |
Niels Möller | 530ead4 | 2018-10-04 14:28:39 +0200 | [diff] [blame] | 181 | webrtc::CallReceiveStatistics call_stats = |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 182 | channel_receive_->GetRTCPStatistics(); |
solenberg | bd9a77f | 2017-02-06 12:53:57 -0800 | [diff] [blame] | 183 | // TODO(solenberg): Don't return here if we can't get the codec - return the |
| 184 | // stats we *can* get. |
Fredrik Solenberg | f693bfa | 2018-12-11 12:22:10 +0100 | [diff] [blame] | 185 | auto receive_codec = channel_receive_->GetReceiveCodec(); |
| 186 | if (!receive_codec) { |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 187 | return stats; |
| 188 | } |
| 189 | |
Niels Möller | ac0a4cb | 2019-10-09 15:01:33 +0200 | [diff] [blame] | 190 | stats.payload_bytes_rcvd = call_stats.payload_bytes_rcvd; |
| 191 | stats.header_and_padding_bytes_rcvd = |
| 192 | call_stats.header_and_padding_bytes_rcvd; |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 193 | stats.packets_rcvd = call_stats.packetsReceived; |
| 194 | stats.packets_lost = call_stats.cumulativeLost; |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 195 | stats.capture_start_ntp_time_ms = call_stats.capture_start_ntp_time_ms_; |
Henrik Boström | 01738c6 | 2019-04-15 17:32:00 +0200 | [diff] [blame] | 196 | stats.last_packet_received_timestamp_ms = |
| 197 | call_stats.last_packet_received_timestamp_ms; |
Fredrik Solenberg | f693bfa | 2018-12-11 12:22:10 +0100 | [diff] [blame] | 198 | stats.codec_name = receive_codec->second.name; |
| 199 | stats.codec_payload_type = receive_codec->first; |
Fredrik Solenberg | f693bfa | 2018-12-11 12:22:10 +0100 | [diff] [blame] | 200 | int clockrate_khz = receive_codec->second.clockrate_hz / 1000; |
| 201 | if (clockrate_khz > 0) { |
| 202 | stats.jitter_ms = call_stats.jitterSamples / clockrate_khz; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 203 | } |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 204 | stats.delay_estimate_ms = channel_receive_->GetDelayEstimate(); |
| 205 | stats.audio_level = channel_receive_->GetSpeechOutputLevelFullRange(); |
| 206 | stats.total_output_energy = channel_receive_->GetTotalOutputEnergy(); |
| 207 | stats.total_output_duration = channel_receive_->GetTotalOutputDuration(); |
Åsa Persson | fcf79cc | 2019-10-22 15:23:44 +0200 | [diff] [blame] | 208 | stats.estimated_playout_ntp_timestamp_ms = |
| 209 | channel_receive_->GetCurrentEstimatedPlayoutNtpTimestampMs( |
| 210 | rtc::TimeMillis()); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 211 | |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 212 | // Get jitter buffer and total delay (alg + jitter + playout) stats. |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 213 | auto ns = channel_receive_->GetNetworkStatistics(); |
Ivo Creusen | 8d8ffdb | 2019-04-30 09:45:21 +0200 | [diff] [blame] | 214 | stats.fec_packets_received = ns.fecPacketsReceived; |
| 215 | stats.fec_packets_discarded = ns.fecPacketsDiscarded; |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 216 | stats.jitter_buffer_ms = ns.currentBufferSize; |
| 217 | stats.jitter_buffer_preferred_ms = ns.preferredBufferSize; |
Steve Anton | 2dbc69f | 2017-08-24 17:15:13 -0700 | [diff] [blame] | 218 | stats.total_samples_received = ns.totalSamplesReceived; |
| 219 | stats.concealed_samples = ns.concealedSamples; |
Ivo Creusen | 8d8ffdb | 2019-04-30 09:45:21 +0200 | [diff] [blame] | 220 | stats.silent_concealed_samples = ns.silentConcealedSamples; |
Gustaf Ullberg | 9a2e906 | 2017-09-18 09:28:20 +0200 | [diff] [blame] | 221 | stats.concealment_events = ns.concealmentEvents; |
Gustaf Ullberg | b0a0207 | 2017-10-02 12:00:34 +0200 | [diff] [blame] | 222 | stats.jitter_buffer_delay_seconds = |
| 223 | static_cast<double>(ns.jitterBufferDelayMs) / |
| 224 | static_cast<double>(rtc::kNumMillisecsPerSec); |
Chen Xing | 0acffb5 | 2019-01-15 15:46:29 +0100 | [diff] [blame] | 225 | stats.jitter_buffer_emitted_count = ns.jitterBufferEmittedCount; |
Artem Titov | e618cc9 | 2020-03-11 11:18:54 +0100 | [diff] [blame] | 226 | stats.jitter_buffer_target_delay_seconds = |
| 227 | static_cast<double>(ns.jitterBufferTargetDelayMs) / |
| 228 | static_cast<double>(rtc::kNumMillisecsPerSec); |
Ivo Creusen | 8d8ffdb | 2019-04-30 09:45:21 +0200 | [diff] [blame] | 229 | stats.inserted_samples_for_deceleration = ns.insertedSamplesForDeceleration; |
| 230 | stats.removed_samples_for_acceleration = ns.removedSamplesForAcceleration; |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 231 | stats.expand_rate = Q14ToFloat(ns.currentExpandRate); |
| 232 | stats.speech_expand_rate = Q14ToFloat(ns.currentSpeechExpandRate); |
| 233 | stats.secondary_decoded_rate = Q14ToFloat(ns.currentSecondaryDecodedRate); |
minyue-webrtc | 0e320ec | 2017-08-28 13:51:27 +0200 | [diff] [blame] | 234 | stats.secondary_discarded_rate = Q14ToFloat(ns.currentSecondaryDiscardedRate); |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 235 | stats.accelerate_rate = Q14ToFloat(ns.currentAccelerateRate); |
| 236 | stats.preemptive_expand_rate = Q14ToFloat(ns.currentPreemptiveRate); |
Ruslan Burakov | 8af8896 | 2018-11-22 17:21:10 +0100 | [diff] [blame] | 237 | stats.jitter_buffer_flushes = ns.packetBufferFlushes; |
Jakob Ivarsson | 352ce5c | 2018-11-27 12:52:16 +0100 | [diff] [blame] | 238 | stats.delayed_packet_outage_samples = ns.delayedPacketOutageSamples; |
Jakob Ivarsson | 232b3fd | 2019-03-06 09:18:40 +0100 | [diff] [blame] | 239 | stats.relative_packet_arrival_delay_seconds = |
| 240 | static_cast<double>(ns.relativePacketArrivalDelayMs) / |
| 241 | static_cast<double>(rtc::kNumMillisecsPerSec); |
Henrik Lundin | 44125fa | 2019-04-29 17:00:46 +0200 | [diff] [blame] | 242 | stats.interruption_count = ns.interruptionCount; |
| 243 | stats.total_interruption_duration_ms = ns.totalInterruptionDurationMs; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 244 | |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 245 | auto ds = channel_receive_->GetDecodingCallStatistics(); |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 246 | stats.decoding_calls_to_silence_generator = ds.calls_to_silence_generator; |
| 247 | stats.decoding_calls_to_neteq = ds.calls_to_neteq; |
| 248 | stats.decoding_normal = ds.decoded_normal; |
Alex Narest | 5b5d97c | 2019-08-07 18:15:08 +0200 | [diff] [blame] | 249 | stats.decoding_plc = ds.decoded_neteq_plc; |
| 250 | stats.decoding_codec_plc = ds.decoded_codec_plc; |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 251 | stats.decoding_cng = ds.decoded_cng; |
| 252 | stats.decoding_plc_cng = ds.decoded_plc_cng; |
henrik.lundin | 6348978 | 2016-09-20 01:47:12 -0700 | [diff] [blame] | 253 | stats.decoding_muted_output = ds.decoded_muted_output; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 254 | |
| 255 | return stats; |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 256 | } |
| 257 | |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 258 | void AudioReceiveStream::SetSink(AudioSinkInterface* sink) { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 259 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 260 | channel_receive_->SetSink(sink); |
Tommi | f888bb5 | 2015-12-12 01:37:01 +0100 | [diff] [blame] | 261 | } |
| 262 | |
solenberg | 217fb66 | 2016-06-17 08:30:54 -0700 | [diff] [blame] | 263 | void AudioReceiveStream::SetGain(float gain) { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 264 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 265 | channel_receive_->SetChannelOutputVolumeScaling(gain); |
solenberg | 217fb66 | 2016-06-17 08:30:54 -0700 | [diff] [blame] | 266 | } |
| 267 | |
Ruslan Burakov | 3b50f9f | 2019-02-06 09:45:56 +0100 | [diff] [blame] | 268 | bool AudioReceiveStream::SetBaseMinimumPlayoutDelayMs(int delay_ms) { |
| 269 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 270 | return channel_receive_->SetBaseMinimumPlayoutDelayMs(delay_ms); |
| 271 | } |
| 272 | |
| 273 | int AudioReceiveStream::GetBaseMinimumPlayoutDelayMs() const { |
| 274 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 275 | return channel_receive_->GetBaseMinimumPlayoutDelayMs(); |
| 276 | } |
| 277 | |
hbos | 8d609f6 | 2017-04-10 07:39:05 -0700 | [diff] [blame] | 278 | std::vector<RtpSource> AudioReceiveStream::GetSources() const { |
| 279 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Chen Xing | 054e3bb | 2019-08-02 10:29:26 +0000 | [diff] [blame] | 280 | return source_tracker_.GetSources(); |
hbos | 8d609f6 | 2017-04-10 07:39:05 -0700 | [diff] [blame] | 281 | } |
| 282 | |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 283 | AudioMixer::Source::AudioFrameInfo AudioReceiveStream::GetAudioFrameWithInfo( |
| 284 | int sample_rate_hz, |
| 285 | AudioFrame* audio_frame) { |
Chen Xing | 054e3bb | 2019-08-02 10:29:26 +0000 | [diff] [blame] | 286 | AudioMixer::Source::AudioFrameInfo audio_frame_info = |
| 287 | channel_receive_->GetAudioFrameWithInfo(sample_rate_hz, audio_frame); |
| 288 | if (audio_frame_info != AudioMixer::Source::AudioFrameInfo::kError) { |
| 289 | source_tracker_.OnFrameDelivered(audio_frame->packet_infos_); |
| 290 | } |
| 291 | return audio_frame_info; |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 292 | } |
| 293 | |
| 294 | int AudioReceiveStream::Ssrc() const { |
| 295 | return config_.rtp.remote_ssrc; |
| 296 | } |
| 297 | |
| 298 | int AudioReceiveStream::PreferredSampleRate() const { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 299 | return channel_receive_->PreferredSampleRate(); |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 300 | } |
| 301 | |
Åsa Persson | 74d2b1d | 2020-02-10 16:33:29 +0100 | [diff] [blame] | 302 | uint32_t AudioReceiveStream::id() const { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 303 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 304 | return config_.rtp.remote_ssrc; |
| 305 | } |
| 306 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 307 | absl::optional<Syncable::Info> AudioReceiveStream::GetInfo() const { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 308 | RTC_DCHECK_RUN_ON(&module_process_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 309 | absl::optional<Syncable::Info> info = channel_receive_->GetSyncInfo(); |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 310 | |
Niels Möller | 848d6d3 | 2018-08-08 10:49:16 +0200 | [diff] [blame] | 311 | if (!info) |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 312 | return absl::nullopt; |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 313 | |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 314 | info->current_delay_ms = channel_receive_->GetDelayEstimate(); |
Oskar Sundbom | 2707fb2 | 2017-11-16 10:57:35 +0100 | [diff] [blame] | 315 | return info; |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 316 | } |
| 317 | |
Åsa Persson | fcf79cc | 2019-10-22 15:23:44 +0200 | [diff] [blame] | 318 | bool AudioReceiveStream::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp, |
| 319 | int64_t* time_ms) const { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 320 | // Called on video capture thread. |
Åsa Persson | fcf79cc | 2019-10-22 15:23:44 +0200 | [diff] [blame] | 321 | return channel_receive_->GetPlayoutRtpTimestamp(rtp_timestamp, time_ms); |
| 322 | } |
| 323 | |
| 324 | void AudioReceiveStream::SetEstimatedPlayoutNtpTimestampMs( |
| 325 | int64_t ntp_timestamp_ms, |
| 326 | int64_t time_ms) { |
| 327 | // Called on video capture thread. |
| 328 | channel_receive_->SetEstimatedPlayoutNtpTimestampMs(ntp_timestamp_ms, |
| 329 | time_ms); |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 330 | } |
| 331 | |
| 332 | void AudioReceiveStream::SetMinimumPlayoutDelay(int delay_ms) { |
| 333 | RTC_DCHECK_RUN_ON(&module_process_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 334 | return channel_receive_->SetMinimumPlayoutDelay(delay_ms); |
pbos | a2f30de | 2015-10-15 05:22:13 -0700 | [diff] [blame] | 335 | } |
| 336 | |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 337 | void AudioReceiveStream::AssociateSendStream(AudioSendStream* send_stream) { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 338 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 339 | channel_receive_->SetAssociatedSendChannel( |
| 340 | send_stream ? send_stream->GetChannel() : nullptr); |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 341 | associated_send_stream_ = send_stream; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 342 | } |
| 343 | |
Niels Möller | 8fb1a6a | 2019-03-05 14:29:42 +0100 | [diff] [blame] | 344 | void AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 345 | // TODO(solenberg): Tests call this function on a network thread, libjingle |
| 346 | // calls on the worker thread. We should move towards always using a network |
| 347 | // thread. Then this check can be enabled. |
Sebastian Jansson | c01367d | 2019-04-08 15:20:44 +0200 | [diff] [blame] | 348 | // RTC_DCHECK(!thread_checker_.IsCurrent()); |
Niels Möller | 8fb1a6a | 2019-03-05 14:29:42 +0100 | [diff] [blame] | 349 | channel_receive_->ReceivedRTCPPacket(packet, length); |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 350 | } |
| 351 | |
nisse | 657bab2 | 2017-02-21 06:28:10 -0800 | [diff] [blame] | 352 | void AudioReceiveStream::OnRtpPacket(const RtpPacketReceived& packet) { |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 353 | // TODO(solenberg): Tests call this function on a network thread, libjingle |
| 354 | // calls on the worker thread. We should move towards always using a network |
| 355 | // thread. Then this check can be enabled. |
Sebastian Jansson | c01367d | 2019-04-08 15:20:44 +0200 | [diff] [blame] | 356 | // RTC_DCHECK(!thread_checker_.IsCurrent()); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 357 | channel_receive_->OnRtpPacket(packet); |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 358 | } |
| 359 | |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 360 | const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const { |
| 361 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 362 | return config_; |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 363 | } |
| 364 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 365 | const AudioSendStream* AudioReceiveStream::GetAssociatedSendStreamForTesting() |
| 366 | const { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 367 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 368 | return associated_send_stream_; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 369 | } |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 370 | |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 371 | internal::AudioState* AudioReceiveStream::audio_state() const { |
| 372 | auto* audio_state = static_cast<internal::AudioState*>(audio_state_.get()); |
| 373 | RTC_DCHECK(audio_state); |
| 374 | return audio_state; |
| 375 | } |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 376 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 377 | void AudioReceiveStream::ConfigureStream(AudioReceiveStream* stream, |
| 378 | const Config& new_config, |
| 379 | bool first_time) { |
Jonas Olsson | 24ea822 | 2018-01-25 10:14:29 +0100 | [diff] [blame] | 380 | RTC_LOG(LS_INFO) << "AudioReceiveStream::ConfigureStream: " |
| 381 | << new_config.ToString(); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 382 | RTC_DCHECK(stream); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 383 | const auto& channel_receive = stream->channel_receive_; |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 384 | const auto& old_config = stream->config_; |
| 385 | |
| 386 | // Configuration parameters which cannot be changed. |
| 387 | RTC_DCHECK(first_time || |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 388 | old_config.rtp.remote_ssrc == new_config.rtp.remote_ssrc); |
| 389 | RTC_DCHECK(first_time || |
| 390 | old_config.rtcp_send_transport == new_config.rtcp_send_transport); |
| 391 | // Decoder factory cannot be changed because it is configured at |
| 392 | // voe::Channel construction time. |
| 393 | RTC_DCHECK(first_time || |
| 394 | old_config.decoder_factory == new_config.decoder_factory); |
| 395 | |
Niels Möller | 30b4839 | 2018-08-15 15:05:26 +0200 | [diff] [blame] | 396 | if (!first_time) { |
Erik Språng | 70efdde | 2019-08-21 13:36:20 +0200 | [diff] [blame] | 397 | // SSRC can't be changed mid-stream. |
| 398 | RTC_DCHECK_EQ(old_config.rtp.local_ssrc, new_config.rtp.local_ssrc); |
Niels Möller | f782492 | 2018-05-25 13:41:10 +0200 | [diff] [blame] | 399 | RTC_DCHECK_EQ(old_config.rtp.remote_ssrc, new_config.rtp.remote_ssrc); |
| 400 | } |
| 401 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 402 | // TODO(solenberg): Config NACK history window (which is a packet count), |
| 403 | // using the actual packet size for the configured codec. |
| 404 | if (first_time || old_config.rtp.nack.rtp_history_ms != |
| 405 | new_config.rtp.nack.rtp_history_ms) { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 406 | channel_receive->SetNACKStatus(new_config.rtp.nack.rtp_history_ms != 0, |
| 407 | new_config.rtp.nack.rtp_history_ms / 20); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 408 | } |
| 409 | if (first_time || old_config.decoder_map != new_config.decoder_map) { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 410 | channel_receive->SetReceiveCodecs(new_config.decoder_map); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 411 | } |
| 412 | |
Marina Ciocea | 3e9af7f | 2020-04-01 07:46:16 +0200 | [diff] [blame] | 413 | if (first_time || |
| 414 | old_config.frame_transformer != new_config.frame_transformer) { |
| 415 | channel_receive->SetDepacketizerToDecoderFrameTransformer( |
| 416 | new_config.frame_transformer); |
| 417 | } |
| 418 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 419 | stream->config_ = new_config; |
| 420 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 421 | } // namespace internal |
| 422 | } // namespace webrtc |