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