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"); |
Niels Möller | 7d76a31 | 2018-10-26 12:57:07 +0200 | [diff] [blame] | 59 | ss << ", media_transport: " << (media_transport ? "(Transport)" : "null"); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 60 | if (!sync_group.empty()) { |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 61 | ss << ", sync_group: " << sync_group; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 62 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 63 | ss << '}'; |
| 64 | return ss.str(); |
| 65 | } |
| 66 | |
| 67 | namespace internal { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 68 | namespace { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 69 | std::unique_ptr<voe::ChannelReceiveInterface> CreateChannelReceive( |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 70 | webrtc::AudioState* audio_state, |
| 71 | ProcessThread* module_process_thread, |
Niels Möller | fa4e185 | 2018-08-14 09:43:34 +0200 | [diff] [blame] | 72 | const webrtc::AudioReceiveStream::Config& config, |
| 73 | RtcEventLog* event_log) { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 74 | RTC_DCHECK(audio_state); |
| 75 | internal::AudioState* internal_audio_state = |
| 76 | static_cast<internal::AudioState*>(audio_state); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 77 | return voe::CreateChannelReceive( |
| 78 | module_process_thread, internal_audio_state->audio_device_module(), |
| 79 | config.media_transport, config.rtcp_send_transport, event_log, |
| 80 | config.rtp.remote_ssrc, config.jitter_buffer_max_packets, |
Jakob Ivarsson | 10403ae | 2018-11-27 15:45:20 +0100 | [diff] [blame] | 81 | config.jitter_buffer_fast_accelerate, config.jitter_buffer_min_delay_ms, |
Jakob Ivarsson | 53eae87 | 2019-01-10 15:58:36 +0100 | [diff] [blame] | 82 | config.jitter_buffer_enable_rtx_handling, config.decoder_factory, |
| 83 | config.codec_pair_id, config.frame_decryptor, config.crypto_options); |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 84 | } |
| 85 | } // namespace |
| 86 | |
| 87 | AudioReceiveStream::AudioReceiveStream( |
| 88 | RtpStreamReceiverControllerInterface* receiver_controller, |
| 89 | PacketRouter* packet_router, |
| 90 | ProcessThread* module_process_thread, |
| 91 | const webrtc::AudioReceiveStream::Config& config, |
| 92 | const rtc::scoped_refptr<webrtc::AudioState>& audio_state, |
| 93 | webrtc::RtcEventLog* event_log) |
| 94 | : AudioReceiveStream(receiver_controller, |
| 95 | packet_router, |
| 96 | config, |
| 97 | audio_state, |
| 98 | event_log, |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 99 | CreateChannelReceive(audio_state.get(), |
| 100 | module_process_thread, |
| 101 | config, |
| 102 | event_log)) {} |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 103 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 104 | AudioReceiveStream::AudioReceiveStream( |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 105 | RtpStreamReceiverControllerInterface* receiver_controller, |
nisse | 0245da0 | 2016-11-30 03:35:20 -0800 | [diff] [blame] | 106 | PacketRouter* packet_router, |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 107 | const webrtc::AudioReceiveStream::Config& config, |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 108 | const rtc::scoped_refptr<webrtc::AudioState>& audio_state, |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 109 | webrtc::RtcEventLog* event_log, |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 110 | std::unique_ptr<voe::ChannelReceiveInterface> channel_receive) |
| 111 | : audio_state_(audio_state), channel_receive_(std::move(channel_receive)) { |
Jonas Olsson | 24ea822 | 2018-01-25 10:14:29 +0100 | [diff] [blame] | 112 | RTC_LOG(LS_INFO) << "AudioReceiveStream: " << config.rtp.remote_ssrc; |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 113 | RTC_DCHECK(config.decoder_factory); |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 114 | RTC_DCHECK(config.rtcp_send_transport); |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 115 | RTC_DCHECK(audio_state_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 116 | RTC_DCHECK(channel_receive_); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 117 | |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 118 | module_process_thread_checker_.DetachFromThread(); |
| 119 | |
Niels Möller | 7d76a31 | 2018-10-26 12:57:07 +0200 | [diff] [blame] | 120 | if (!config.media_transport) { |
| 121 | RTC_DCHECK(receiver_controller); |
| 122 | RTC_DCHECK(packet_router); |
| 123 | // Configure bandwidth estimation. |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 124 | channel_receive_->RegisterReceiverCongestionControlObjects(packet_router); |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 125 | |
Niels Möller | 7d76a31 | 2018-10-26 12:57:07 +0200 | [diff] [blame] | 126 | // Register with transport. |
| 127 | rtp_stream_receiver_ = receiver_controller->CreateReceiver( |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 128 | config.rtp.remote_ssrc, channel_receive_.get()); |
Niels Möller | 7d76a31 | 2018-10-26 12:57:07 +0200 | [diff] [blame] | 129 | } |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 130 | ConfigureStream(this, config, true); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 131 | } |
| 132 | |
pbos | a2f30de | 2015-10-15 05:22:13 -0700 | [diff] [blame] | 133 | AudioReceiveStream::~AudioReceiveStream() { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 134 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Jonas Olsson | 24ea822 | 2018-01-25 10:14:29 +0100 | [diff] [blame] | 135 | RTC_LOG(LS_INFO) << "~AudioReceiveStream: " << config_.rtp.remote_ssrc; |
Fredrik Solenberg | d524751 | 2017-12-18 22:41:03 +0100 | [diff] [blame] | 136 | Stop(); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 137 | channel_receive_->SetAssociatedSendChannel(nullptr); |
Niels Möller | 7d76a31 | 2018-10-26 12:57:07 +0200 | [diff] [blame] | 138 | if (!config_.media_transport) { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 139 | channel_receive_->ResetReceiverCongestionControlObjects(); |
Niels Möller | 7d76a31 | 2018-10-26 12:57:07 +0200 | [diff] [blame] | 140 | } |
pbos | a2f30de | 2015-10-15 05:22:13 -0700 | [diff] [blame] | 141 | } |
| 142 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 143 | void AudioReceiveStream::Reconfigure( |
| 144 | const webrtc::AudioReceiveStream::Config& config) { |
| 145 | RTC_DCHECK(worker_thread_checker_.CalledOnValidThread()); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 146 | ConfigureStream(this, config, false); |
| 147 | } |
| 148 | |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 149 | void AudioReceiveStream::Start() { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 150 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 151 | if (playing_) { |
| 152 | return; |
| 153 | } |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 154 | channel_receive_->StartPlayout(); |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 155 | playing_ = true; |
Fredrik Solenberg | d524751 | 2017-12-18 22:41:03 +0100 | [diff] [blame] | 156 | audio_state()->AddReceivingStream(this); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | void AudioReceiveStream::Stop() { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 160 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 161 | if (!playing_) { |
| 162 | return; |
| 163 | } |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 164 | channel_receive_->StopPlayout(); |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 165 | playing_ = false; |
Fredrik Solenberg | d524751 | 2017-12-18 22:41:03 +0100 | [diff] [blame] | 166 | audio_state()->RemoveReceivingStream(this); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 167 | } |
| 168 | |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 169 | webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats() const { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 170 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 171 | webrtc::AudioReceiveStream::Stats stats; |
| 172 | stats.remote_ssrc = config_.rtp.remote_ssrc; |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 173 | |
Niels Möller | 530ead4 | 2018-10-04 14:28:39 +0200 | [diff] [blame] | 174 | webrtc::CallReceiveStatistics call_stats = |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 175 | channel_receive_->GetRTCPStatistics(); |
solenberg | bd9a77f | 2017-02-06 12:53:57 -0800 | [diff] [blame] | 176 | // TODO(solenberg): Don't return here if we can't get the codec - return the |
| 177 | // stats we *can* get. |
Fredrik Solenberg | f693bfa | 2018-12-11 12:22:10 +0100 | [diff] [blame] | 178 | auto receive_codec = channel_receive_->GetReceiveCodec(); |
| 179 | if (!receive_codec) { |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 180 | return stats; |
| 181 | } |
| 182 | |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 183 | stats.bytes_rcvd = call_stats.bytesReceived; |
| 184 | stats.packets_rcvd = call_stats.packetsReceived; |
| 185 | stats.packets_lost = call_stats.cumulativeLost; |
| 186 | stats.fraction_lost = Q8ToFloat(call_stats.fractionLost); |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 187 | stats.capture_start_ntp_time_ms = call_stats.capture_start_ntp_time_ms_; |
Fredrik Solenberg | f693bfa | 2018-12-11 12:22:10 +0100 | [diff] [blame] | 188 | stats.codec_name = receive_codec->second.name; |
| 189 | stats.codec_payload_type = receive_codec->first; |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 190 | stats.ext_seqnum = call_stats.extendedMax; |
Fredrik Solenberg | f693bfa | 2018-12-11 12:22:10 +0100 | [diff] [blame] | 191 | int clockrate_khz = receive_codec->second.clockrate_hz / 1000; |
| 192 | if (clockrate_khz > 0) { |
| 193 | stats.jitter_ms = call_stats.jitterSamples / clockrate_khz; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 194 | } |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 195 | stats.delay_estimate_ms = channel_receive_->GetDelayEstimate(); |
| 196 | stats.audio_level = channel_receive_->GetSpeechOutputLevelFullRange(); |
| 197 | stats.total_output_energy = channel_receive_->GetTotalOutputEnergy(); |
| 198 | stats.total_output_duration = channel_receive_->GetTotalOutputDuration(); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 199 | |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 200 | // Get jitter buffer and total delay (alg + jitter + playout) stats. |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 201 | auto ns = channel_receive_->GetNetworkStatistics(); |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 202 | stats.jitter_buffer_ms = ns.currentBufferSize; |
| 203 | stats.jitter_buffer_preferred_ms = ns.preferredBufferSize; |
Steve Anton | 2dbc69f | 2017-08-24 17:15:13 -0700 | [diff] [blame] | 204 | stats.total_samples_received = ns.totalSamplesReceived; |
| 205 | stats.concealed_samples = ns.concealedSamples; |
Gustaf Ullberg | 9a2e906 | 2017-09-18 09:28:20 +0200 | [diff] [blame] | 206 | stats.concealment_events = ns.concealmentEvents; |
Gustaf Ullberg | b0a0207 | 2017-10-02 12:00:34 +0200 | [diff] [blame] | 207 | stats.jitter_buffer_delay_seconds = |
| 208 | static_cast<double>(ns.jitterBufferDelayMs) / |
| 209 | static_cast<double>(rtc::kNumMillisecsPerSec); |
Chen Xing | 0acffb5 | 2019-01-15 15:46:29 +0100 | [diff] [blame] | 210 | stats.jitter_buffer_emitted_count = ns.jitterBufferEmittedCount; |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 211 | stats.expand_rate = Q14ToFloat(ns.currentExpandRate); |
| 212 | stats.speech_expand_rate = Q14ToFloat(ns.currentSpeechExpandRate); |
| 213 | stats.secondary_decoded_rate = Q14ToFloat(ns.currentSecondaryDecodedRate); |
minyue-webrtc | 0e320ec | 2017-08-28 13:51:27 +0200 | [diff] [blame] | 214 | stats.secondary_discarded_rate = Q14ToFloat(ns.currentSecondaryDiscardedRate); |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 215 | stats.accelerate_rate = Q14ToFloat(ns.currentAccelerateRate); |
| 216 | stats.preemptive_expand_rate = Q14ToFloat(ns.currentPreemptiveRate); |
Ruslan Burakov | 8af8896 | 2018-11-22 17:21:10 +0100 | [diff] [blame] | 217 | stats.jitter_buffer_flushes = ns.packetBufferFlushes; |
Jakob Ivarsson | 352ce5c | 2018-11-27 12:52:16 +0100 | [diff] [blame] | 218 | stats.delayed_packet_outage_samples = ns.delayedPacketOutageSamples; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 219 | |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 220 | auto ds = channel_receive_->GetDecodingCallStatistics(); |
solenberg | 8b85de2 | 2015-11-16 09:48:04 -0800 | [diff] [blame] | 221 | stats.decoding_calls_to_silence_generator = ds.calls_to_silence_generator; |
| 222 | stats.decoding_calls_to_neteq = ds.calls_to_neteq; |
| 223 | stats.decoding_normal = ds.decoded_normal; |
| 224 | stats.decoding_plc = ds.decoded_plc; |
| 225 | stats.decoding_cng = ds.decoded_cng; |
| 226 | stats.decoding_plc_cng = ds.decoded_plc_cng; |
henrik.lundin | 6348978 | 2016-09-20 01:47:12 -0700 | [diff] [blame] | 227 | stats.decoding_muted_output = ds.decoded_muted_output; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 228 | |
| 229 | return stats; |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 230 | } |
| 231 | |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 232 | void AudioReceiveStream::SetSink(AudioSinkInterface* sink) { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 233 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 234 | channel_receive_->SetSink(sink); |
Tommi | f888bb5 | 2015-12-12 01:37:01 +0100 | [diff] [blame] | 235 | } |
| 236 | |
solenberg | 217fb66 | 2016-06-17 08:30:54 -0700 | [diff] [blame] | 237 | void AudioReceiveStream::SetGain(float gain) { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 238 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 239 | channel_receive_->SetChannelOutputVolumeScaling(gain); |
solenberg | 217fb66 | 2016-06-17 08:30:54 -0700 | [diff] [blame] | 240 | } |
| 241 | |
hbos | 8d609f6 | 2017-04-10 07:39:05 -0700 | [diff] [blame] | 242 | std::vector<RtpSource> AudioReceiveStream::GetSources() const { |
| 243 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 244 | return channel_receive_->GetSources(); |
hbos | 8d609f6 | 2017-04-10 07:39:05 -0700 | [diff] [blame] | 245 | } |
| 246 | |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 247 | AudioMixer::Source::AudioFrameInfo AudioReceiveStream::GetAudioFrameWithInfo( |
| 248 | int sample_rate_hz, |
| 249 | AudioFrame* audio_frame) { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 250 | return channel_receive_->GetAudioFrameWithInfo(sample_rate_hz, audio_frame); |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 251 | } |
| 252 | |
| 253 | int AudioReceiveStream::Ssrc() const { |
| 254 | return config_.rtp.remote_ssrc; |
| 255 | } |
| 256 | |
| 257 | int AudioReceiveStream::PreferredSampleRate() const { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 258 | return channel_receive_->PreferredSampleRate(); |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | int AudioReceiveStream::id() const { |
| 262 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 263 | return config_.rtp.remote_ssrc; |
| 264 | } |
| 265 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 266 | absl::optional<Syncable::Info> AudioReceiveStream::GetInfo() const { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 267 | RTC_DCHECK_RUN_ON(&module_process_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 268 | absl::optional<Syncable::Info> info = channel_receive_->GetSyncInfo(); |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 269 | |
Niels Möller | 848d6d3 | 2018-08-08 10:49:16 +0200 | [diff] [blame] | 270 | if (!info) |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 271 | return absl::nullopt; |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 272 | |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 273 | info->current_delay_ms = channel_receive_->GetDelayEstimate(); |
Oskar Sundbom | 2707fb2 | 2017-11-16 10:57:35 +0100 | [diff] [blame] | 274 | return info; |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 275 | } |
| 276 | |
| 277 | uint32_t AudioReceiveStream::GetPlayoutTimestamp() const { |
| 278 | // Called on video capture thread. |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 279 | return channel_receive_->GetPlayoutTimestamp(); |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | void AudioReceiveStream::SetMinimumPlayoutDelay(int delay_ms) { |
| 283 | RTC_DCHECK_RUN_ON(&module_process_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 284 | return channel_receive_->SetMinimumPlayoutDelay(delay_ms); |
pbos | a2f30de | 2015-10-15 05:22:13 -0700 | [diff] [blame] | 285 | } |
| 286 | |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 287 | void AudioReceiveStream::AssociateSendStream(AudioSendStream* send_stream) { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 288 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 289 | channel_receive_->SetAssociatedSendChannel( |
| 290 | send_stream ? send_stream->GetChannel() : nullptr); |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 291 | associated_send_stream_ = send_stream; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 292 | } |
| 293 | |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 294 | void AudioReceiveStream::SignalNetworkState(NetworkState state) { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 295 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 296 | } |
| 297 | |
| 298 | bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { |
| 299 | // TODO(solenberg): Tests call this function on a network thread, libjingle |
| 300 | // calls on the worker thread. We should move towards always using a network |
| 301 | // thread. Then this check can be enabled. |
| 302 | // RTC_DCHECK(!thread_checker_.CalledOnValidThread()); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 303 | return channel_receive_->ReceivedRTCPPacket(packet, length); |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 304 | } |
| 305 | |
nisse | 657bab2 | 2017-02-21 06:28:10 -0800 | [diff] [blame] | 306 | void AudioReceiveStream::OnRtpPacket(const RtpPacketReceived& packet) { |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 307 | // TODO(solenberg): Tests call this function on a network thread, libjingle |
| 308 | // calls on the worker thread. We should move towards always using a network |
| 309 | // thread. Then this check can be enabled. |
| 310 | // RTC_DCHECK(!thread_checker_.CalledOnValidThread()); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 311 | channel_receive_->OnRtpPacket(packet); |
pbos | 1ba8d39 | 2016-05-01 20:18:34 -0700 | [diff] [blame] | 312 | } |
| 313 | |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 314 | const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const { |
| 315 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 316 | return config_; |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 317 | } |
| 318 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 319 | const AudioSendStream* AudioReceiveStream::GetAssociatedSendStreamForTesting() |
| 320 | const { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 321 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 322 | return associated_send_stream_; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 323 | } |
aleloi | 04c0722 | 2016-11-22 06:42:53 -0800 | [diff] [blame] | 324 | |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 325 | internal::AudioState* AudioReceiveStream::audio_state() const { |
| 326 | auto* audio_state = static_cast<internal::AudioState*>(audio_state_.get()); |
| 327 | RTC_DCHECK(audio_state); |
| 328 | return audio_state; |
| 329 | } |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 330 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 331 | void AudioReceiveStream::ConfigureStream(AudioReceiveStream* stream, |
| 332 | const Config& new_config, |
| 333 | bool first_time) { |
Jonas Olsson | 24ea822 | 2018-01-25 10:14:29 +0100 | [diff] [blame] | 334 | RTC_LOG(LS_INFO) << "AudioReceiveStream::ConfigureStream: " |
| 335 | << new_config.ToString(); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 336 | RTC_DCHECK(stream); |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 337 | const auto& channel_receive = stream->channel_receive_; |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 338 | const auto& old_config = stream->config_; |
| 339 | |
| 340 | // Configuration parameters which cannot be changed. |
| 341 | RTC_DCHECK(first_time || |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 342 | old_config.rtp.remote_ssrc == new_config.rtp.remote_ssrc); |
| 343 | RTC_DCHECK(first_time || |
| 344 | old_config.rtcp_send_transport == new_config.rtcp_send_transport); |
| 345 | // Decoder factory cannot be changed because it is configured at |
| 346 | // voe::Channel construction time. |
| 347 | RTC_DCHECK(first_time || |
| 348 | old_config.decoder_factory == new_config.decoder_factory); |
| 349 | |
| 350 | if (first_time || old_config.rtp.local_ssrc != new_config.rtp.local_ssrc) { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 351 | channel_receive->SetLocalSSRC(new_config.rtp.local_ssrc); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 352 | } |
Niels Möller | f782492 | 2018-05-25 13:41:10 +0200 | [diff] [blame] | 353 | |
Niels Möller | 30b4839 | 2018-08-15 15:05:26 +0200 | [diff] [blame] | 354 | if (!first_time) { |
Niels Möller | f782492 | 2018-05-25 13:41:10 +0200 | [diff] [blame] | 355 | // Remote ssrc can't be changed mid-stream. |
| 356 | RTC_DCHECK_EQ(old_config.rtp.remote_ssrc, new_config.rtp.remote_ssrc); |
| 357 | } |
| 358 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 359 | // TODO(solenberg): Config NACK history window (which is a packet count), |
| 360 | // using the actual packet size for the configured codec. |
| 361 | if (first_time || old_config.rtp.nack.rtp_history_ms != |
| 362 | new_config.rtp.nack.rtp_history_ms) { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 363 | channel_receive->SetNACKStatus(new_config.rtp.nack.rtp_history_ms != 0, |
| 364 | new_config.rtp.nack.rtp_history_ms / 20); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 365 | } |
| 366 | if (first_time || old_config.decoder_map != new_config.decoder_map) { |
Niels Möller | 349ade3 | 2018-11-16 09:50:42 +0100 | [diff] [blame] | 367 | channel_receive->SetReceiveCodecs(new_config.decoder_map); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 368 | } |
| 369 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 15:17:10 +0100 | [diff] [blame] | 370 | stream->config_ = new_config; |
| 371 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 372 | } // namespace internal |
| 373 | } // namespace webrtc |