Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [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 04:47:31 | [diff] [blame] | 11 | #include "audio/audio_receive_stream.h" |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 12 | |
| 13 | #include <string> |
Tommi | f888bb5 | 2015-12-12 00:37:01 | [diff] [blame] | 14 | #include <utility> |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 15 | |
Yves Gerey | 988cc08 | 2018-10-23 10:03:01 | [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 04:47:31 | [diff] [blame] | 19 | #include "api/call/audio_sink.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 20 | #include "api/rtp_parameters.h" |
Markus Handell | acd16af | 2021-05-29 11:21:28 | [diff] [blame] | 21 | #include "api/sequence_checker.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 22 | #include "audio/audio_send_stream.h" |
| 23 | #include "audio/audio_state.h" |
Yves Gerey | 988cc08 | 2018-10-23 10:03:01 | [diff] [blame] | 24 | #include "audio/channel_receive.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 25 | #include "audio/conversion.h" |
Yves Gerey | 988cc08 | 2018-10-23 10:03:01 | [diff] [blame] | 26 | #include "call/rtp_config.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 27 | #include "call/rtp_stream_receiver_controller_interface.h" |
Ranveer Aggarwal | dea374a | 2021-01-23 06:57:19 | [diff] [blame] | 28 | #include "modules/rtp_rtcp/source/rtp_packet_received.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 29 | #include "rtc_base/checks.h" |
| 30 | #include "rtc_base/logging.h" |
Tommi | fef0500 | 2018-02-27 12:51:08 | [diff] [blame] | 31 | #include "rtc_base/strings/string_builder.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 32 | #include "rtc_base/time_utils.h" |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 33 | |
| 34 | namespace webrtc { |
Stefan Holmer | 3842c5c | 2016-01-12 12:55:00 | [diff] [blame] | 35 | |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 36 | std::string AudioReceiveStreamInterface::Config::Rtp::ToString() const { |
Karl Wiberg | 881f168 | 2018-03-08 14:03:23 | [diff] [blame] | 37 | char ss_buf[1024]; |
| 38 | rtc::SimpleStringBuilder ss(ss_buf); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 39 | ss << "{remote_ssrc: " << remote_ssrc; |
solenberg | 85a0496 | 2015-10-27 10:35:21 | [diff] [blame] | 40 | ss << ", local_ssrc: " << local_ssrc; |
solenberg | 8189b02 | 2016-06-14 19:13:00 | [diff] [blame] | 41 | ss << ", nack: " << nack.ToString(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 42 | ss << ", extensions: ["; |
| 43 | for (size_t i = 0; i < extensions.size(); ++i) { |
| 44 | ss << extensions[i].ToString(); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 45 | if (i != extensions.size() - 1) { |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 46 | ss << ", "; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 47 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 48 | } |
| 49 | ss << ']'; |
| 50 | ss << '}'; |
| 51 | return ss.str(); |
| 52 | } |
| 53 | |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 54 | std::string AudioReceiveStreamInterface::Config::ToString() const { |
Karl Wiberg | 881f168 | 2018-03-08 14:03:23 | [diff] [blame] | 55 | char ss_buf[1024]; |
| 56 | rtc::SimpleStringBuilder ss(ss_buf); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 57 | ss << "{rtp: " << rtp.ToString(); |
solenberg | 85a0496 | 2015-10-27 10:35:21 | [diff] [blame] | 58 | ss << ", rtcp_send_transport: " |
deadbeef | 922246a | 2017-02-26 12:18:12 | [diff] [blame] | 59 | << (rtcp_send_transport ? "(Transport)" : "null"); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 60 | if (!sync_group.empty()) { |
pbos | 8fc7fa7 | 2015-07-15 15:02:58 | [diff] [blame] | 61 | ss << ", sync_group: " << sync_group; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 62 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 63 | ss << '}'; |
| 64 | return ss.str(); |
| 65 | } |
| 66 | |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 67 | namespace { |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 68 | std::unique_ptr<voe::ChannelReceiveInterface> CreateChannelReceive( |
Sebastian Jansson | 977b335 | 2019-03-04 16:43:34 | [diff] [blame] | 69 | Clock* clock, |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 70 | webrtc::AudioState* audio_state, |
Ivo Creusen | c3d1f9b | 2019-11-01 10:47:51 | [diff] [blame] | 71 | NetEqFactory* neteq_factory, |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 72 | const webrtc::AudioReceiveStreamInterface::Config& config, |
Niels Möller | fa4e185 | 2018-08-14 07:43:34 | [diff] [blame] | 73 | RtcEventLog* event_log) { |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [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 08:50:42 | [diff] [blame] | 77 | return voe::CreateChannelReceive( |
Markus Handell | eb61b7f | 2021-06-22 08:46:48 | [diff] [blame] | 78 | clock, neteq_factory, internal_audio_state->audio_device_module(), |
| 79 | config.rtcp_send_transport, event_log, config.rtp.local_ssrc, |
| 80 | config.rtp.remote_ssrc, config.jitter_buffer_max_packets, |
| 81 | config.jitter_buffer_fast_accelerate, config.jitter_buffer_min_delay_ms, |
Tommi | 1def899 | 2022-05-20 14:17:49 | [diff] [blame] | 82 | config.enable_non_sender_rtt, config.decoder_factory, |
| 83 | config.codec_pair_id, std::move(config.frame_decryptor), |
| 84 | config.crypto_options, std::move(config.frame_transformer)); |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 85 | } |
| 86 | } // namespace |
| 87 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 88 | AudioReceiveStreamImpl::AudioReceiveStreamImpl( |
Sebastian Jansson | 977b335 | 2019-03-04 16:43:34 | [diff] [blame] | 89 | Clock* clock, |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 90 | PacketRouter* packet_router, |
Ivo Creusen | c3d1f9b | 2019-11-01 10:47:51 | [diff] [blame] | 91 | NetEqFactory* neteq_factory, |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 92 | const webrtc::AudioReceiveStreamInterface::Config& config, |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 93 | const rtc::scoped_refptr<webrtc::AudioState>& audio_state, |
| 94 | webrtc::RtcEventLog* event_log) |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 95 | : AudioReceiveStreamImpl(clock, |
| 96 | packet_router, |
| 97 | config, |
| 98 | audio_state, |
| 99 | event_log, |
| 100 | CreateChannelReceive(clock, |
| 101 | audio_state.get(), |
| 102 | neteq_factory, |
| 103 | config, |
| 104 | event_log)) {} |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 105 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 106 | AudioReceiveStreamImpl::AudioReceiveStreamImpl( |
Sebastian Jansson | 977b335 | 2019-03-04 16:43:34 | [diff] [blame] | 107 | Clock* clock, |
nisse | 0245da0 | 2016-11-30 11:35:20 | [diff] [blame] | 108 | PacketRouter* packet_router, |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 109 | const webrtc::AudioReceiveStreamInterface::Config& config, |
ivoc | 14d5dbe | 2016-07-04 14:06:55 | [diff] [blame] | 110 | const rtc::scoped_refptr<webrtc::AudioState>& audio_state, |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 111 | webrtc::RtcEventLog* event_log, |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 112 | std::unique_ptr<voe::ChannelReceiveInterface> channel_receive) |
Markus Handell | acd16af | 2021-05-29 11:21:28 | [diff] [blame] | 113 | : config_(config), |
| 114 | audio_state_(audio_state), |
Ranveer Aggarwal | dea374a | 2021-01-23 06:57:19 | [diff] [blame] | 115 | source_tracker_(clock), |
| 116 | channel_receive_(std::move(channel_receive)) { |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 117 | RTC_LOG(LS_INFO) << "AudioReceiveStreamImpl: " << config.rtp.remote_ssrc; |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 118 | RTC_DCHECK(config.decoder_factory); |
Niels Möller | ae4237e | 2018-10-05 09:28:38 | [diff] [blame] | 119 | RTC_DCHECK(config.rtcp_send_transport); |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 120 | RTC_DCHECK(audio_state_); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 121 | RTC_DCHECK(channel_receive_); |
solenberg | 7add058 | 2015-11-20 17:59:34 | [diff] [blame] | 122 | |
Tommi | 90738dd | 2021-05-31 15:36:47 | [diff] [blame] | 123 | packet_sequence_checker_.Detach(); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 124 | |
Bjorn A Mellem | 7a9a092 | 2019-11-26 17:19:40 | [diff] [blame] | 125 | RTC_DCHECK(packet_router); |
| 126 | // Configure bandwidth estimation. |
| 127 | channel_receive_->RegisterReceiverCongestionControlObjects(packet_router); |
nisse | 0f15f92 | 2017-06-21 08:05:22 | [diff] [blame] | 128 | |
Ranveer Aggarwal | dea374a | 2021-01-23 06:57:19 | [diff] [blame] | 129 | // When output is muted, ChannelReceive will directly notify the source |
| 130 | // tracker of "delivered" frames, so RtpReceiver information will continue to |
| 131 | // be updated. |
| 132 | channel_receive_->SetSourceTracker(&source_tracker_); |
| 133 | |
Markus Handell | acd16af | 2021-05-29 11:21:28 | [diff] [blame] | 134 | // Complete configuration. |
| 135 | // TODO(solenberg): Config NACK history window (which is a packet count), |
| 136 | // using the actual packet size for the configured codec. |
| 137 | channel_receive_->SetNACKStatus(config.rtp.nack.rtp_history_ms != 0, |
| 138 | config.rtp.nack.rtp_history_ms / 20); |
| 139 | channel_receive_->SetReceiveCodecs(config.decoder_map); |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 140 | // `frame_transformer` and `frame_decryptor` have been given to |
| 141 | // `channel_receive_` already. |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 142 | } |
| 143 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 144 | AudioReceiveStreamImpl::~AudioReceiveStreamImpl() { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 145 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 146 | RTC_LOG(LS_INFO) << "~AudioReceiveStreamImpl: " << remote_ssrc(); |
Fredrik Solenberg | d524751 | 2017-12-18 21:41:03 | [diff] [blame] | 147 | Stop(); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 148 | channel_receive_->SetAssociatedSendChannel(nullptr); |
Bjorn A Mellem | 7a9a092 | 2019-11-26 17:19:40 | [diff] [blame] | 149 | channel_receive_->ResetReceiverCongestionControlObjects(); |
pbos | a2f30de | 2015-10-15 12:22:13 | [diff] [blame] | 150 | } |
| 151 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 152 | void AudioReceiveStreamImpl::RegisterWithTransport( |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 153 | RtpStreamReceiverControllerInterface* receiver_controller) { |
Tommi | 90738dd | 2021-05-31 15:36:47 | [diff] [blame] | 154 | RTC_DCHECK_RUN_ON(&packet_sequence_checker_); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 155 | RTC_DCHECK(!rtp_stream_receiver_); |
| 156 | rtp_stream_receiver_ = receiver_controller->CreateReceiver( |
Tommi | cc50b04 | 2022-05-09 10:22:48 | [diff] [blame] | 157 | remote_ssrc(), channel_receive_.get()); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 158 | } |
| 159 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 160 | void AudioReceiveStreamImpl::UnregisterFromTransport() { |
Tommi | 90738dd | 2021-05-31 15:36:47 | [diff] [blame] | 161 | RTC_DCHECK_RUN_ON(&packet_sequence_checker_); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 162 | rtp_stream_receiver_.reset(); |
| 163 | } |
| 164 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 165 | void AudioReceiveStreamImpl::ReconfigureForTesting( |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 166 | const webrtc::AudioReceiveStreamInterface::Config& config) { |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 167 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Andrey Logvin | 8a18e5b | 2021-06-09 10:15:47 | [diff] [blame] | 168 | |
| 169 | // SSRC can't be changed mid-stream. |
Tommi | cc50b04 | 2022-05-09 10:22:48 | [diff] [blame] | 170 | RTC_DCHECK_EQ(remote_ssrc(), config.rtp.remote_ssrc); |
| 171 | RTC_DCHECK_EQ(local_ssrc(), config.rtp.local_ssrc); |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 172 | |
| 173 | // Configuration parameters which cannot be changed. |
| 174 | RTC_DCHECK_EQ(config_.rtcp_send_transport, config.rtcp_send_transport); |
| 175 | // Decoder factory cannot be changed because it is configured at |
| 176 | // voe::Channel construction time. |
| 177 | RTC_DCHECK_EQ(config_.decoder_factory, config.decoder_factory); |
Markus Handell | acd16af | 2021-05-29 11:21:28 | [diff] [blame] | 178 | |
| 179 | // TODO(solenberg): Config NACK history window (which is a packet count), |
| 180 | // using the actual packet size for the configured codec. |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 181 | RTC_DCHECK_EQ(config_.rtp.nack.rtp_history_ms, config.rtp.nack.rtp_history_ms) |
| 182 | << "Use SetUseTransportCcAndNackHistory"; |
Markus Handell | acd16af | 2021-05-29 11:21:28 | [diff] [blame] | 183 | |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 184 | RTC_DCHECK(config_.decoder_map == config.decoder_map) << "Use SetDecoderMap"; |
| 185 | RTC_DCHECK_EQ(config_.frame_transformer, config.frame_transformer) |
| 186 | << "Use SetDepacketizerToDecoderFrameTransformer"; |
Markus Handell | acd16af | 2021-05-29 11:21:28 | [diff] [blame] | 187 | |
| 188 | config_ = config; |
Fredrik Solenberg | 3b903d0 | 2018-01-10 14:17:10 | [diff] [blame] | 189 | } |
| 190 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 191 | void AudioReceiveStreamImpl::Start() { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 192 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 193 | if (playing_) { |
| 194 | return; |
| 195 | } |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 196 | channel_receive_->StartPlayout(); |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 197 | playing_ = true; |
Fredrik Solenberg | d524751 | 2017-12-18 21:41:03 | [diff] [blame] | 198 | audio_state()->AddReceivingStream(this); |
solenberg | 7add058 | 2015-11-20 17:59:34 | [diff] [blame] | 199 | } |
| 200 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 201 | void AudioReceiveStreamImpl::Stop() { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 202 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 203 | if (!playing_) { |
| 204 | return; |
| 205 | } |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 206 | channel_receive_->StopPlayout(); |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 207 | playing_ = false; |
Fredrik Solenberg | d524751 | 2017-12-18 21:41:03 | [diff] [blame] | 208 | audio_state()->RemoveReceivingStream(this); |
solenberg | 7add058 | 2015-11-20 17:59:34 | [diff] [blame] | 209 | } |
| 210 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 211 | bool AudioReceiveStreamImpl::IsRunning() const { |
Tomas Gunnarsson | 8467cf2 | 2021-01-17 13:36:44 | [diff] [blame] | 212 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 213 | return playing_; |
| 214 | } |
| 215 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 216 | void AudioReceiveStreamImpl::SetDepacketizerToDecoderFrameTransformer( |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 217 | rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) { |
| 218 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 219 | channel_receive_->SetDepacketizerToDecoderFrameTransformer( |
| 220 | std::move(frame_transformer)); |
| 221 | } |
| 222 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 223 | void AudioReceiveStreamImpl::SetDecoderMap( |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 224 | std::map<int, SdpAudioFormat> decoder_map) { |
| 225 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 226 | config_.decoder_map = std::move(decoder_map); |
| 227 | channel_receive_->SetReceiveCodecs(config_.decoder_map); |
| 228 | } |
| 229 | |
Tommi | a136ed4 | 2022-05-30 13:08:13 | [diff] [blame] | 230 | void AudioReceiveStreamImpl::SetNackHistory(int history_ms) { |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 231 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 232 | RTC_DCHECK_GE(history_ms, 0); |
Tommi | a136ed4 | 2022-05-30 13:08:13 | [diff] [blame] | 233 | |
| 234 | if (config_.rtp.nack.rtp_history_ms == history_ms) |
| 235 | return; |
| 236 | |
| 237 | config_.rtp.nack.rtp_history_ms = history_ms; |
| 238 | // TODO(solenberg): Config NACK history window (which is a packet count), |
| 239 | // using the actual packet size for the configured codec. |
| 240 | channel_receive_->SetNACKStatus(history_ms != 0, history_ms / 20); |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 241 | } |
| 242 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 243 | void AudioReceiveStreamImpl::SetNonSenderRttMeasurement(bool enabled) { |
Ivo Creusen | 2562cf0 | 2021-09-03 14:51:22 | [diff] [blame] | 244 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 245 | config_.enable_non_sender_rtt = enabled; |
| 246 | channel_receive_->SetNonSenderRttMeasurement(enabled); |
| 247 | } |
| 248 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 249 | void AudioReceiveStreamImpl::SetFrameDecryptor( |
Tommi | e097282 | 2021-06-14 06:11:10 | [diff] [blame] | 250 | rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) { |
| 251 | // TODO(bugs.webrtc.org/11993): This is called via WebRtcAudioReceiveStream, |
| 252 | // expect to be called on the network thread. |
| 253 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 254 | channel_receive_->SetFrameDecryptor(std::move(frame_decryptor)); |
| 255 | } |
| 256 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 257 | void AudioReceiveStreamImpl::SetRtpExtensions( |
Tommi | 3008bcd | 2021-06-14 18:00:04 | [diff] [blame] | 258 | std::vector<RtpExtension> extensions) { |
| 259 | // TODO(bugs.webrtc.org/11993): This is called via WebRtcAudioReceiveStream, |
| 260 | // expect to be called on the network thread. |
| 261 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 262 | config_.rtp.extensions = std::move(extensions); |
| 263 | } |
| 264 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 265 | RtpHeaderExtensionMap AudioReceiveStreamImpl::GetRtpExtensionMap() const { |
Tommi | cf4ed15 | 2022-05-09 20:46:57 | [diff] [blame] | 266 | return RtpHeaderExtensionMap(config_.rtp.extensions); |
| 267 | } |
| 268 | |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 269 | webrtc::AudioReceiveStreamInterface::Stats AudioReceiveStreamImpl::GetStats( |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 270 | bool get_and_clear_legacy_stats) const { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 271 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 272 | webrtc::AudioReceiveStreamInterface::Stats stats; |
Tommi | cc50b04 | 2022-05-09 10:22:48 | [diff] [blame] | 273 | stats.remote_ssrc = remote_ssrc(); |
solenberg | 8b85de2 | 2015-11-16 17:48:04 | [diff] [blame] | 274 | |
Niels Möller | 530ead4 | 2018-10-04 12:28:39 | [diff] [blame] | 275 | webrtc::CallReceiveStatistics call_stats = |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 276 | channel_receive_->GetRTCPStatistics(); |
solenberg | bd9a77f | 2017-02-06 20:53:57 | [diff] [blame] | 277 | // TODO(solenberg): Don't return here if we can't get the codec - return the |
| 278 | // stats we *can* get. |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 279 | auto receive_codec = channel_receive_->GetReceiveCodec(); |
| 280 | if (!receive_codec) { |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 281 | return stats; |
| 282 | } |
| 283 | |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 284 | stats.payload_bytes_rcvd = call_stats.payload_bytes_rcvd; |
| 285 | stats.header_and_padding_bytes_rcvd = |
| 286 | call_stats.header_and_padding_bytes_rcvd; |
solenberg | 85a0496 | 2015-10-27 10:35:21 | [diff] [blame] | 287 | stats.packets_rcvd = call_stats.packetsReceived; |
| 288 | stats.packets_lost = call_stats.cumulativeLost; |
Jakob Ivarsson | e54914a | 2021-07-01 09:16:05 | [diff] [blame] | 289 | stats.nacks_sent = call_stats.nacks_sent; |
solenberg | 8b85de2 | 2015-11-16 17:48:04 | [diff] [blame] | 290 | stats.capture_start_ntp_time_ms = call_stats.capture_start_ntp_time_ms_; |
Henrik Boström | 01738c6 | 2019-04-15 15:32:00 | [diff] [blame] | 291 | stats.last_packet_received_timestamp_ms = |
| 292 | call_stats.last_packet_received_timestamp_ms; |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 293 | stats.codec_name = receive_codec->second.name; |
| 294 | stats.codec_payload_type = receive_codec->first; |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 295 | int clockrate_khz = receive_codec->second.clockrate_hz / 1000; |
| 296 | if (clockrate_khz > 0) { |
| 297 | stats.jitter_ms = call_stats.jitterSamples / clockrate_khz; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 298 | } |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 299 | stats.delay_estimate_ms = channel_receive_->GetDelayEstimate(); |
| 300 | stats.audio_level = channel_receive_->GetSpeechOutputLevelFullRange(); |
| 301 | stats.total_output_energy = channel_receive_->GetTotalOutputEnergy(); |
| 302 | stats.total_output_duration = channel_receive_->GetTotalOutputDuration(); |
Åsa Persson | fcf79cc | 2019-10-22 13:23:44 | [diff] [blame] | 303 | stats.estimated_playout_ntp_timestamp_ms = |
| 304 | channel_receive_->GetCurrentEstimatedPlayoutNtpTimestampMs( |
| 305 | rtc::TimeMillis()); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 306 | |
solenberg | 8b85de2 | 2015-11-16 17:48:04 | [diff] [blame] | 307 | // Get jitter buffer and total delay (alg + jitter + playout) stats. |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 308 | auto ns = channel_receive_->GetNetworkStatistics(get_and_clear_legacy_stats); |
Minyue Li | 28a2c63 | 2021-07-07 13:53:38 | [diff] [blame] | 309 | stats.packets_discarded = ns.packetsDiscarded; |
Ivo Creusen | 8d8ffdb | 2019-04-30 07:45:21 | [diff] [blame] | 310 | stats.fec_packets_received = ns.fecPacketsReceived; |
| 311 | stats.fec_packets_discarded = ns.fecPacketsDiscarded; |
solenberg | 8b85de2 | 2015-11-16 17:48:04 | [diff] [blame] | 312 | stats.jitter_buffer_ms = ns.currentBufferSize; |
| 313 | stats.jitter_buffer_preferred_ms = ns.preferredBufferSize; |
Steve Anton | 2dbc69f | 2017-08-25 00:15:13 | [diff] [blame] | 314 | stats.total_samples_received = ns.totalSamplesReceived; |
| 315 | stats.concealed_samples = ns.concealedSamples; |
Ivo Creusen | 8d8ffdb | 2019-04-30 07:45:21 | [diff] [blame] | 316 | stats.silent_concealed_samples = ns.silentConcealedSamples; |
Gustaf Ullberg | 9a2e906 | 2017-09-18 07:28:20 | [diff] [blame] | 317 | stats.concealment_events = ns.concealmentEvents; |
Gustaf Ullberg | b0a0207 | 2017-10-02 10:00:34 | [diff] [blame] | 318 | stats.jitter_buffer_delay_seconds = |
| 319 | static_cast<double>(ns.jitterBufferDelayMs) / |
| 320 | static_cast<double>(rtc::kNumMillisecsPerSec); |
Chen Xing | 0acffb5 | 2019-01-15 14:46:29 | [diff] [blame] | 321 | stats.jitter_buffer_emitted_count = ns.jitterBufferEmittedCount; |
Artem Titov | e618cc9 | 2020-03-11 10:18:54 | [diff] [blame] | 322 | stats.jitter_buffer_target_delay_seconds = |
| 323 | static_cast<double>(ns.jitterBufferTargetDelayMs) / |
| 324 | static_cast<double>(rtc::kNumMillisecsPerSec); |
Ivo Creusen | 1a84b56 | 2022-07-19 14:33:10 | [diff] [blame] | 325 | stats.jitter_buffer_minimum_delay_seconds = |
| 326 | static_cast<double>(ns.jitterBufferMinimumDelayMs) / |
| 327 | static_cast<double>(rtc::kNumMillisecsPerSec); |
Ivo Creusen | 8d8ffdb | 2019-04-30 07:45:21 | [diff] [blame] | 328 | stats.inserted_samples_for_deceleration = ns.insertedSamplesForDeceleration; |
| 329 | stats.removed_samples_for_acceleration = ns.removedSamplesForAcceleration; |
solenberg | 8b85de2 | 2015-11-16 17:48:04 | [diff] [blame] | 330 | stats.expand_rate = Q14ToFloat(ns.currentExpandRate); |
| 331 | stats.speech_expand_rate = Q14ToFloat(ns.currentSpeechExpandRate); |
| 332 | stats.secondary_decoded_rate = Q14ToFloat(ns.currentSecondaryDecodedRate); |
minyue-webrtc | 0e320ec | 2017-08-28 11:51:27 | [diff] [blame] | 333 | stats.secondary_discarded_rate = Q14ToFloat(ns.currentSecondaryDiscardedRate); |
solenberg | 8b85de2 | 2015-11-16 17:48:04 | [diff] [blame] | 334 | stats.accelerate_rate = Q14ToFloat(ns.currentAccelerateRate); |
| 335 | stats.preemptive_expand_rate = Q14ToFloat(ns.currentPreemptiveRate); |
Ruslan Burakov | 8af8896 | 2018-11-22 16:21:10 | [diff] [blame] | 336 | stats.jitter_buffer_flushes = ns.packetBufferFlushes; |
Jakob Ivarsson | 352ce5c | 2018-11-27 11:52:16 | [diff] [blame] | 337 | stats.delayed_packet_outage_samples = ns.delayedPacketOutageSamples; |
Jakob Ivarsson | 232b3fd | 2019-03-06 08:18:40 | [diff] [blame] | 338 | stats.relative_packet_arrival_delay_seconds = |
| 339 | static_cast<double>(ns.relativePacketArrivalDelayMs) / |
| 340 | static_cast<double>(rtc::kNumMillisecsPerSec); |
Henrik Lundin | 44125fa | 2019-04-29 15:00:46 | [diff] [blame] | 341 | stats.interruption_count = ns.interruptionCount; |
| 342 | stats.total_interruption_duration_ms = ns.totalInterruptionDurationMs; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 343 | |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 344 | auto ds = channel_receive_->GetDecodingCallStatistics(); |
solenberg | 8b85de2 | 2015-11-16 17:48:04 | [diff] [blame] | 345 | stats.decoding_calls_to_silence_generator = ds.calls_to_silence_generator; |
| 346 | stats.decoding_calls_to_neteq = ds.calls_to_neteq; |
| 347 | stats.decoding_normal = ds.decoded_normal; |
Alex Narest | 5b5d97c | 2019-08-07 16:15:08 | [diff] [blame] | 348 | stats.decoding_plc = ds.decoded_neteq_plc; |
| 349 | stats.decoding_codec_plc = ds.decoded_codec_plc; |
solenberg | 8b85de2 | 2015-11-16 17:48:04 | [diff] [blame] | 350 | stats.decoding_cng = ds.decoded_cng; |
| 351 | stats.decoding_plc_cng = ds.decoded_plc_cng; |
henrik.lundin | 6348978 | 2016-09-20 08:47:12 | [diff] [blame] | 352 | stats.decoding_muted_output = ds.decoded_muted_output; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 353 | |
Alessio Bazzica | f7b1b95 | 2021-03-23 16:23:04 | [diff] [blame] | 354 | stats.last_sender_report_timestamp_ms = |
| 355 | call_stats.last_sender_report_timestamp_ms; |
| 356 | stats.last_sender_report_remote_timestamp_ms = |
| 357 | call_stats.last_sender_report_remote_timestamp_ms; |
| 358 | stats.sender_reports_packets_sent = call_stats.sender_reports_packets_sent; |
| 359 | stats.sender_reports_bytes_sent = call_stats.sender_reports_bytes_sent; |
| 360 | stats.sender_reports_reports_count = call_stats.sender_reports_reports_count; |
Ivo Creusen | 2562cf0 | 2021-09-03 14:51:22 | [diff] [blame] | 361 | stats.round_trip_time = call_stats.round_trip_time; |
| 362 | stats.round_trip_time_measurements = call_stats.round_trip_time_measurements; |
| 363 | stats.total_round_trip_time = call_stats.total_round_trip_time; |
Alessio Bazzica | f7b1b95 | 2021-03-23 16:23:04 | [diff] [blame] | 364 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 365 | return stats; |
Fredrik Solenberg | 04f4931 | 2015-06-08 11:04:56 | [diff] [blame] | 366 | } |
| 367 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 368 | void AudioReceiveStreamImpl::SetSink(AudioSinkInterface* sink) { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 369 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 370 | channel_receive_->SetSink(sink); |
Tommi | f888bb5 | 2015-12-12 00:37:01 | [diff] [blame] | 371 | } |
| 372 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 373 | void AudioReceiveStreamImpl::SetGain(float gain) { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 374 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 375 | channel_receive_->SetChannelOutputVolumeScaling(gain); |
solenberg | 217fb66 | 2016-06-17 15:30:54 | [diff] [blame] | 376 | } |
| 377 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 378 | bool AudioReceiveStreamImpl::SetBaseMinimumPlayoutDelayMs(int delay_ms) { |
Ruslan Burakov | 3b50f9f | 2019-02-06 08:45:56 | [diff] [blame] | 379 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 380 | return channel_receive_->SetBaseMinimumPlayoutDelayMs(delay_ms); |
| 381 | } |
| 382 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 383 | int AudioReceiveStreamImpl::GetBaseMinimumPlayoutDelayMs() const { |
Ruslan Burakov | 3b50f9f | 2019-02-06 08:45:56 | [diff] [blame] | 384 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 385 | return channel_receive_->GetBaseMinimumPlayoutDelayMs(); |
| 386 | } |
| 387 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 388 | std::vector<RtpSource> AudioReceiveStreamImpl::GetSources() const { |
hbos | 8d609f6 | 2017-04-10 14:39:05 | [diff] [blame] | 389 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Chen Xing | 054e3bb | 2019-08-02 10:29:26 | [diff] [blame] | 390 | return source_tracker_.GetSources(); |
hbos | 8d609f6 | 2017-04-10 14:39:05 | [diff] [blame] | 391 | } |
| 392 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 393 | AudioMixer::Source::AudioFrameInfo |
| 394 | AudioReceiveStreamImpl::GetAudioFrameWithInfo(int sample_rate_hz, |
| 395 | AudioFrame* audio_frame) { |
Chen Xing | 054e3bb | 2019-08-02 10:29:26 | [diff] [blame] | 396 | AudioMixer::Source::AudioFrameInfo audio_frame_info = |
| 397 | channel_receive_->GetAudioFrameWithInfo(sample_rate_hz, audio_frame); |
| 398 | if (audio_frame_info != AudioMixer::Source::AudioFrameInfo::kError) { |
| 399 | source_tracker_.OnFrameDelivered(audio_frame->packet_infos_); |
| 400 | } |
| 401 | return audio_frame_info; |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 402 | } |
| 403 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 404 | int AudioReceiveStreamImpl::Ssrc() const { |
Tommi | cc50b04 | 2022-05-09 10:22:48 | [diff] [blame] | 405 | return remote_ssrc(); |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 406 | } |
| 407 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 408 | int AudioReceiveStreamImpl::PreferredSampleRate() const { |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 409 | return channel_receive_->PreferredSampleRate(); |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 410 | } |
| 411 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 412 | uint32_t AudioReceiveStreamImpl::id() const { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 413 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Tommi | cc50b04 | 2022-05-09 10:22:48 | [diff] [blame] | 414 | return remote_ssrc(); |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 415 | } |
| 416 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 417 | absl::optional<Syncable::Info> AudioReceiveStreamImpl::GetInfo() const { |
Tomas Gunnarsson | 0f030fd | 2021-04-01 18:12:04 | [diff] [blame] | 418 | // TODO(bugs.webrtc.org/11993): This is called via RtpStreamsSynchronizer, |
| 419 | // expect to be called on the network thread. |
| 420 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
| 421 | return channel_receive_->GetSyncInfo(); |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 422 | } |
| 423 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 424 | bool AudioReceiveStreamImpl::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp, |
| 425 | int64_t* time_ms) const { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 426 | // Called on video capture thread. |
Åsa Persson | fcf79cc | 2019-10-22 13:23:44 | [diff] [blame] | 427 | return channel_receive_->GetPlayoutRtpTimestamp(rtp_timestamp, time_ms); |
| 428 | } |
| 429 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 430 | void AudioReceiveStreamImpl::SetEstimatedPlayoutNtpTimestampMs( |
Åsa Persson | fcf79cc | 2019-10-22 13:23:44 | [diff] [blame] | 431 | int64_t ntp_timestamp_ms, |
| 432 | int64_t time_ms) { |
| 433 | // Called on video capture thread. |
| 434 | channel_receive_->SetEstimatedPlayoutNtpTimestampMs(ntp_timestamp_ms, |
| 435 | time_ms); |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 436 | } |
| 437 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 438 | bool AudioReceiveStreamImpl::SetMinimumPlayoutDelay(int delay_ms) { |
Tomas Gunnarsson | 0f030fd | 2021-04-01 18:12:04 | [diff] [blame] | 439 | // TODO(bugs.webrtc.org/11993): This is called via RtpStreamsSynchronizer, |
| 440 | // expect to be called on the network thread. |
| 441 | RTC_DCHECK_RUN_ON(&worker_thread_checker_); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 442 | return channel_receive_->SetMinimumPlayoutDelay(delay_ms); |
pbos | a2f30de | 2015-10-15 12:22:13 | [diff] [blame] | 443 | } |
| 444 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 445 | void AudioReceiveStreamImpl::AssociateSendStream( |
| 446 | internal::AudioSendStream* send_stream) { |
Tommi | 90738dd | 2021-05-31 15:36:47 | [diff] [blame] | 447 | RTC_DCHECK_RUN_ON(&packet_sequence_checker_); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 448 | channel_receive_->SetAssociatedSendChannel( |
| 449 | send_stream ? send_stream->GetChannel() : nullptr); |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 450 | associated_send_stream_ = send_stream; |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 451 | } |
| 452 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 453 | void AudioReceiveStreamImpl::DeliverRtcp(const uint8_t* packet, size_t length) { |
pbos | 1ba8d39 | 2016-05-02 03:18:34 | [diff] [blame] | 454 | // TODO(solenberg): Tests call this function on a network thread, libjingle |
| 455 | // calls on the worker thread. We should move towards always using a network |
| 456 | // thread. Then this check can be enabled. |
Sebastian Jansson | c01367d | 2019-04-08 13:20:44 | [diff] [blame] | 457 | // RTC_DCHECK(!thread_checker_.IsCurrent()); |
Niels Möller | 8fb1a6a | 2019-03-05 13:29:42 | [diff] [blame] | 458 | channel_receive_->ReceivedRTCPPacket(packet, length); |
pbos | 1ba8d39 | 2016-05-02 03:18:34 | [diff] [blame] | 459 | } |
| 460 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 461 | void AudioReceiveStreamImpl::SetSyncGroup(absl::string_view sync_group) { |
Tommi | 55107c8 | 2021-06-16 14:31:18 | [diff] [blame] | 462 | RTC_DCHECK_RUN_ON(&packet_sequence_checker_); |
Ali Tofigh | 4d278e2 | 2022-03-01 09:32:20 | [diff] [blame] | 463 | config_.sync_group = std::string(sync_group); |
Tommi | 55107c8 | 2021-06-16 14:31:18 | [diff] [blame] | 464 | } |
| 465 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 466 | void AudioReceiveStreamImpl::SetLocalSsrc(uint32_t local_ssrc) { |
Tommi | 08be9ba | 2021-06-15 21:01:57 | [diff] [blame] | 467 | RTC_DCHECK_RUN_ON(&packet_sequence_checker_); |
| 468 | // TODO(tommi): Consider storing local_ssrc in one place. |
| 469 | config_.rtp.local_ssrc = local_ssrc; |
| 470 | channel_receive_->OnLocalSsrcChange(local_ssrc); |
| 471 | } |
| 472 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 473 | uint32_t AudioReceiveStreamImpl::local_ssrc() const { |
Tommi | 08be9ba | 2021-06-15 21:01:57 | [diff] [blame] | 474 | RTC_DCHECK_RUN_ON(&packet_sequence_checker_); |
| 475 | RTC_DCHECK_EQ(config_.rtp.local_ssrc, channel_receive_->GetLocalSsrc()); |
| 476 | return config_.rtp.local_ssrc; |
| 477 | } |
| 478 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 479 | const std::string& AudioReceiveStreamImpl::sync_group() const { |
Tommi | cc50b04 | 2022-05-09 10:22:48 | [diff] [blame] | 480 | RTC_DCHECK_RUN_ON(&packet_sequence_checker_); |
| 481 | return config_.sync_group; |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 482 | } |
| 483 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 484 | const AudioSendStream* |
| 485 | AudioReceiveStreamImpl::GetAssociatedSendStreamForTesting() const { |
Tommi | 90738dd | 2021-05-31 15:36:47 | [diff] [blame] | 486 | RTC_DCHECK_RUN_ON(&packet_sequence_checker_); |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 487 | return associated_send_stream_; |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 488 | } |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 489 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 490 | internal::AudioState* AudioReceiveStreamImpl::audio_state() const { |
solenberg | 3ebbcb5 | 2017-01-31 11:58:40 | [diff] [blame] | 491 | auto* audio_state = static_cast<internal::AudioState*>(audio_state_.get()); |
| 492 | RTC_DCHECK(audio_state); |
| 493 | return audio_state; |
| 494 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 495 | } // namespace webrtc |