pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2013 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 | |
pbos@webrtc.org | 12dc1a3 | 2013-08-05 16:22:53 +0000 | [diff] [blame] | 11 | #include <string.h> |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 12 | #include <algorithm> |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 13 | #include <map> |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 14 | #include <memory> |
ossu | f515ab8 | 2016-12-07 04:52:58 -0800 | [diff] [blame] | 15 | #include <set> |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 16 | #include <utility> |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 17 | #include <vector> |
| 18 | |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 19 | #include "absl/memory/memory.h" |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 20 | #include "absl/types/optional.h" |
Sebastian Jansson | 74682c1 | 2019-03-01 11:50:20 +0100 | [diff] [blame] | 21 | #include "api/task_queue/global_task_queue_factory.h" |
Sebastian Jansson | c6c4426 | 2018-05-09 10:33:39 +0200 | [diff] [blame] | 22 | #include "api/transport/network_control.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 23 | #include "audio/audio_receive_stream.h" |
| 24 | #include "audio/audio_send_stream.h" |
| 25 | #include "audio/audio_state.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 26 | #include "call/bitrate_allocator.h" |
| 27 | #include "call/call.h" |
| 28 | #include "call/flexfec_receive_stream_impl.h" |
Sebastian Jansson | b34556e | 2018-03-21 14:38:32 +0100 | [diff] [blame] | 29 | #include "call/receive_time_calculator.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 30 | #include "call/rtp_stream_receiver_controller.h" |
| 31 | #include "call/rtp_transport_controller_send.h" |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 32 | #include "logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h" |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 33 | #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h" |
| 34 | #include "logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h" |
| 35 | #include "logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h" |
| 36 | #include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 37 | #include "logging/rtc_event_log/rtc_event_log.h" |
Elad Alon | 99a81b6 | 2017-09-21 10:25:29 +0200 | [diff] [blame] | 38 | #include "logging/rtc_event_log/rtc_stream_config.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 39 | #include "modules/bitrate_controller/include/bitrate_controller.h" |
| 40 | #include "modules/congestion_controller/include/receive_side_congestion_controller.h" |
| 41 | #include "modules/rtp_rtcp/include/flexfec_receiver.h" |
| 42 | #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" |
| 43 | #include "modules/rtp_rtcp/include/rtp_header_parser.h" |
| 44 | #include "modules/rtp_rtcp/source/byte_io.h" |
| 45 | #include "modules/rtp_rtcp/source/rtp_packet_received.h" |
| 46 | #include "modules/utility/include/process_thread.h" |
Ying Wang | 3b790f3 | 2018-01-19 17:58:57 +0100 | [diff] [blame] | 47 | #include "modules/video_coding/fec_controller_default.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 48 | #include "rtc_base/checks.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 49 | #include "rtc_base/constructor_magic.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 50 | #include "rtc_base/location.h" |
| 51 | #include "rtc_base/logging.h" |
Sebastian Jansson | 19704ec | 2018-03-12 15:59:12 +0100 | [diff] [blame] | 52 | #include "rtc_base/numerics/safe_minmax.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 53 | #include "rtc_base/sequenced_task_checker.h" |
Jonas Olsson | 0a713b6 | 2018-04-04 15:49:32 +0200 | [diff] [blame] | 54 | #include "rtc_base/strings/string_builder.h" |
Sebastian Jansson | c6c4426 | 2018-05-09 10:33:39 +0200 | [diff] [blame] | 55 | #include "rtc_base/synchronization/rw_lock_wrapper.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 56 | #include "rtc_base/thread_annotations.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 57 | #include "rtc_base/time_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 58 | #include "rtc_base/trace_event.h" |
| 59 | #include "system_wrappers/include/clock.h" |
| 60 | #include "system_wrappers/include/cpu_info.h" |
| 61 | #include "system_wrappers/include/metrics.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 62 | #include "video/call_stats.h" |
| 63 | #include "video/send_delay_stats.h" |
| 64 | #include "video/stats_counter.h" |
| 65 | #include "video/video_receive_stream.h" |
| 66 | #include "video/video_send_stream.h" |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 67 | |
| 68 | namespace webrtc { |
pbos@webrtc.org | ab990ae | 2014-09-17 09:02:25 +0000 | [diff] [blame] | 69 | |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 70 | namespace { |
Johannes Kron | 7ff164e | 2019-02-07 12:50:18 +0100 | [diff] [blame] | 71 | bool SendFeedbackOnRequestOnly(const std::vector<RtpExtension>& extensions) { |
| 72 | for (const auto& extension : extensions) { |
| 73 | if (extension.uri == RtpExtension::kTransportSequenceNumberV2Uri) |
| 74 | return true; |
| 75 | } |
| 76 | return false; |
| 77 | } |
| 78 | |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 79 | // TODO(nisse): This really begs for a shared context struct. |
| 80 | bool UseSendSideBwe(const std::vector<RtpExtension>& extensions, |
| 81 | bool transport_cc) { |
| 82 | if (!transport_cc) |
| 83 | return false; |
| 84 | for (const auto& extension : extensions) { |
Johannes Kron | 7ff164e | 2019-02-07 12:50:18 +0100 | [diff] [blame] | 85 | if (extension.uri == RtpExtension::kTransportSequenceNumberUri || |
| 86 | extension.uri == RtpExtension::kTransportSequenceNumberV2Uri) |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 87 | return true; |
| 88 | } |
| 89 | return false; |
| 90 | } |
| 91 | |
| 92 | bool UseSendSideBwe(const VideoReceiveStream::Config& config) { |
| 93 | return UseSendSideBwe(config.rtp.extensions, config.rtp.transport_cc); |
| 94 | } |
| 95 | |
| 96 | bool UseSendSideBwe(const AudioReceiveStream::Config& config) { |
| 97 | return UseSendSideBwe(config.rtp.extensions, config.rtp.transport_cc); |
| 98 | } |
| 99 | |
| 100 | bool UseSendSideBwe(const FlexfecReceiveStream::Config& config) { |
| 101 | return UseSendSideBwe(config.rtp_header_extensions, config.transport_cc); |
| 102 | } |
| 103 | |
nisse | 26e3abb | 2017-08-25 04:44:25 -0700 | [diff] [blame] | 104 | const int* FindKeyByValue(const std::map<int, int>& m, int v) { |
| 105 | for (const auto& kv : m) { |
| 106 | if (kv.second == v) |
| 107 | return &kv.first; |
| 108 | } |
| 109 | return nullptr; |
| 110 | } |
| 111 | |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 112 | std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig( |
perkj | 09e71da | 2017-05-22 03:26:49 -0700 | [diff] [blame] | 113 | const VideoReceiveStream::Config& config) { |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 114 | auto rtclog_config = absl::make_unique<rtclog::StreamConfig>(); |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 115 | rtclog_config->remote_ssrc = config.rtp.remote_ssrc; |
| 116 | rtclog_config->local_ssrc = config.rtp.local_ssrc; |
| 117 | rtclog_config->rtx_ssrc = config.rtp.rtx_ssrc; |
| 118 | rtclog_config->rtcp_mode = config.rtp.rtcp_mode; |
| 119 | rtclog_config->remb = config.rtp.remb; |
| 120 | rtclog_config->rtp_extensions = config.rtp.extensions; |
perkj | 09e71da | 2017-05-22 03:26:49 -0700 | [diff] [blame] | 121 | |
| 122 | for (const auto& d : config.decoders) { |
nisse | 26e3abb | 2017-08-25 04:44:25 -0700 | [diff] [blame] | 123 | const int* search = |
| 124 | FindKeyByValue(config.rtp.rtx_associated_payload_types, d.payload_type); |
Niels Möller | cb7e1d2 | 2018-09-11 15:56:04 +0200 | [diff] [blame] | 125 | rtclog_config->codecs.emplace_back(d.video_format.name, d.payload_type, |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 126 | search ? *search : 0); |
perkj | 09e71da | 2017-05-22 03:26:49 -0700 | [diff] [blame] | 127 | } |
| 128 | return rtclog_config; |
| 129 | } |
| 130 | |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 131 | std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig( |
perkj | c0876aa | 2017-05-22 04:08:28 -0700 | [diff] [blame] | 132 | const VideoSendStream::Config& config, |
| 133 | size_t ssrc_index) { |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 134 | auto rtclog_config = absl::make_unique<rtclog::StreamConfig>(); |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 135 | rtclog_config->local_ssrc = config.rtp.ssrcs[ssrc_index]; |
perkj | c0876aa | 2017-05-22 04:08:28 -0700 | [diff] [blame] | 136 | if (ssrc_index < config.rtp.rtx.ssrcs.size()) { |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 137 | rtclog_config->rtx_ssrc = config.rtp.rtx.ssrcs[ssrc_index]; |
perkj | c0876aa | 2017-05-22 04:08:28 -0700 | [diff] [blame] | 138 | } |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 139 | rtclog_config->rtcp_mode = config.rtp.rtcp_mode; |
| 140 | rtclog_config->rtp_extensions = config.rtp.extensions; |
perkj | c0876aa | 2017-05-22 04:08:28 -0700 | [diff] [blame] | 141 | |
Niels Möller | 259a497 | 2018-04-05 15:36:51 +0200 | [diff] [blame] | 142 | rtclog_config->codecs.emplace_back(config.rtp.payload_name, |
| 143 | config.rtp.payload_type, |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 144 | config.rtp.rtx.payload_type); |
perkj | c0876aa | 2017-05-22 04:08:28 -0700 | [diff] [blame] | 145 | return rtclog_config; |
| 146 | } |
| 147 | |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 148 | std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig( |
perkj | ac8f52d | 2017-05-22 09:36:28 -0700 | [diff] [blame] | 149 | const AudioReceiveStream::Config& config) { |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 150 | auto rtclog_config = absl::make_unique<rtclog::StreamConfig>(); |
eladalon | 8ec568a | 2017-09-08 06:15:52 -0700 | [diff] [blame] | 151 | rtclog_config->remote_ssrc = config.rtp.remote_ssrc; |
| 152 | rtclog_config->local_ssrc = config.rtp.local_ssrc; |
| 153 | rtclog_config->rtp_extensions = config.rtp.extensions; |
perkj | ac8f52d | 2017-05-22 09:36:28 -0700 | [diff] [blame] | 154 | return rtclog_config; |
| 155 | } |
| 156 | |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 157 | } // namespace |
| 158 | |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 159 | namespace internal { |
asapersson@webrtc.org | bdc5ed2 | 2014-01-31 10:05:07 +0000 | [diff] [blame] | 160 | |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 161 | class Call final : public webrtc::Call, |
| 162 | public PacketReceiver, |
| 163 | public RecoveredPacketReceiver, |
| 164 | public TargetTransferRateObserver, |
| 165 | public BitrateAllocator::LimitObserver { |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 166 | public: |
nisse | b8f9a32 | 2017-03-27 05:36:15 -0700 | [diff] [blame] | 167 | Call(const Call::Config& config, |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 168 | std::unique_ptr<RtpTransportControllerSendInterface> transport_send, |
| 169 | std::unique_ptr<ProcessThread> module_process_thread, |
| 170 | TaskQueueFactory* task_queue_factory); |
Mirko Bonadei | 8fdcac3 | 2018-08-28 16:30:18 +0200 | [diff] [blame] | 171 | ~Call() override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 172 | |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 173 | // Implements webrtc::Call. |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 174 | PacketReceiver* Receiver() override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 175 | |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 176 | webrtc::AudioSendStream* CreateAudioSendStream( |
| 177 | const webrtc::AudioSendStream::Config& config) override; |
| 178 | void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override; |
| 179 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 180 | webrtc::AudioReceiveStream* CreateAudioReceiveStream( |
| 181 | const webrtc::AudioReceiveStream::Config& config) override; |
| 182 | void DestroyAudioReceiveStream( |
| 183 | webrtc::AudioReceiveStream* receive_stream) override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 184 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 185 | webrtc::VideoSendStream* CreateVideoSendStream( |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 186 | webrtc::VideoSendStream::Config config, |
| 187 | VideoEncoderConfig encoder_config) override; |
Ying Wang | 3b790f3 | 2018-01-19 17:58:57 +0100 | [diff] [blame] | 188 | webrtc::VideoSendStream* CreateVideoSendStream( |
| 189 | webrtc::VideoSendStream::Config config, |
| 190 | VideoEncoderConfig encoder_config, |
| 191 | std::unique_ptr<FecController> fec_controller) override; |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 192 | void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 193 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 194 | webrtc::VideoReceiveStream* CreateVideoReceiveStream( |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 195 | webrtc::VideoReceiveStream::Config configuration) override; |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 196 | void DestroyVideoReceiveStream( |
| 197 | webrtc::VideoReceiveStream* receive_stream) override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 198 | |
brandtr | 7250b39 | 2016-12-19 01:13:46 -0800 | [diff] [blame] | 199 | FlexfecReceiveStream* CreateFlexfecReceiveStream( |
| 200 | const FlexfecReceiveStream::Config& config) override; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 201 | void DestroyFlexfecReceiveStream( |
brandtr | 7250b39 | 2016-12-19 01:13:46 -0800 | [diff] [blame] | 202 | FlexfecReceiveStream* receive_stream) override; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 203 | |
Sebastian Jansson | 8f83b42 | 2018-02-21 13:07:13 +0100 | [diff] [blame] | 204 | RtpTransportControllerSendInterface* GetTransportControllerSend() override; |
| 205 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 206 | Stats GetStats() const override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 207 | |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 208 | // Implements PacketReceiver. |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 209 | DeliveryStatus DeliverPacket(MediaType media_type, |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 210 | rtc::CopyOnWriteBuffer packet, |
Niels Möller | 7008287 | 2018-08-07 11:03:12 +0200 | [diff] [blame] | 211 | int64_t packet_time_us) override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 212 | |
brandtr | 4e52386 | 2016-10-18 23:50:45 -0700 | [diff] [blame] | 213 | // Implements RecoveredPacketReceiver. |
nisse | d2ef314 | 2017-05-11 08:00:58 -0700 | [diff] [blame] | 214 | void OnRecoveredPacket(const uint8_t* packet, size_t length) override; |
brandtr | 4e52386 | 2016-10-18 23:50:45 -0700 | [diff] [blame] | 215 | |
Alex Narest | 78609d5 | 2017-10-20 10:37:47 +0200 | [diff] [blame] | 216 | void SetBitrateAllocationStrategy( |
| 217 | std::unique_ptr<rtc::BitrateAllocationStrategy> |
| 218 | bitrate_allocation_strategy) override; |
| 219 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 220 | void SignalChannelNetworkState(MediaType media, NetworkState state) override; |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 221 | |
Stefan Holmer | 64be7fa | 2018-10-04 15:21:55 +0200 | [diff] [blame] | 222 | void OnAudioTransportOverheadChanged( |
| 223 | int transport_overhead_per_packet) override; |
michaelt | 79e0588 | 2016-11-08 02:50:09 -0800 | [diff] [blame] | 224 | |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 225 | void OnSentPacket(const rtc::SentPacket& sent_packet) override; |
| 226 | |
Sebastian Jansson | 19704ec | 2018-03-12 15:59:12 +0100 | [diff] [blame] | 227 | // Implements TargetTransferRateObserver, |
| 228 | void OnTargetTransferRate(TargetTransferRate msg) override; |
Sebastian Jansson | 2701bc9 | 2018-12-11 15:02:47 +0100 | [diff] [blame] | 229 | void OnStartRateUpdate(DataRate start_rate) override; |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 230 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 231 | // Implements BitrateAllocator::LimitObserver. |
| 232 | void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps, |
philipel | f69e768 | 2018-02-28 13:06:28 +0100 | [diff] [blame] | 233 | uint32_t max_padding_bitrate_bps, |
Sebastian Jansson | 79f0d4d | 2019-01-23 09:41:43 +0100 | [diff] [blame] | 234 | uint32_t total_bitrate_bps) override; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 235 | |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 236 | // This method is invoked when the media transport is created and when the |
| 237 | // media transport is being destructed. |
| 238 | // We only allow one media transport per connection. |
| 239 | // |
| 240 | // It should be called with non-null argument at most once, and if it was |
| 241 | // called with non-null argument, it has to be called with a null argument |
| 242 | // at least once after that. |
| 243 | void MediaTransportChange(MediaTransportInterface* media_transport) override; |
| 244 | |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 245 | private: |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 246 | DeliveryStatus DeliverRtcp(MediaType media_type, |
| 247 | const uint8_t* packet, |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 248 | size_t length); |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 249 | DeliveryStatus DeliverRtp(MediaType media_type, |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 250 | rtc::CopyOnWriteBuffer packet, |
Niels Möller | 7008287 | 2018-08-07 11:03:12 +0200 | [diff] [blame] | 251 | int64_t packet_time_us); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 252 | void ConfigureSync(const std::string& sync_group) |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 253 | RTC_EXCLUSIVE_LOCKS_REQUIRED(receive_crit_); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 254 | |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 255 | void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet, |
| 256 | MediaType media_type) |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 257 | RTC_SHARED_LOCKS_REQUIRED(receive_crit_); |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 258 | |
asapersson | fc5e81c | 2017-04-19 23:28:53 -0700 | [diff] [blame] | 259 | void UpdateSendHistograms(int64_t first_sent_packet_ms) |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 260 | RTC_EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 261 | void UpdateReceiveHistograms(); |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 262 | void UpdateHistograms(); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 263 | void UpdateAggregateNetworkState(); |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 264 | |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 265 | // If |media_transport| is not null, it registers the rate observer for the |
| 266 | // media transport. |
| 267 | void RegisterRateObserver() RTC_LOCKS_EXCLUDED(target_observer_crit_); |
| 268 | |
Niels Möller | 4687915 | 2019-01-07 15:54:47 +0100 | [diff] [blame] | 269 | // Intended for DCHECKs, to avoid locking in production builds. |
| 270 | MediaTransportInterface* media_transport() |
| 271 | RTC_LOCKS_EXCLUDED(target_observer_crit_); |
| 272 | |
Peter Boström | d3c9447 | 2015-12-09 11:20:58 +0100 | [diff] [blame] | 273 | Clock* const clock_; |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 274 | TaskQueueFactory* const task_queue_factory_; |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 275 | |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 276 | const int num_cpu_cores_; |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 277 | const std::unique_ptr<ProcessThread> module_process_thread_; |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 278 | const std::unique_ptr<CallStats> call_stats_; |
| 279 | const std::unique_ptr<BitrateAllocator> bitrate_allocator_; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 280 | Call::Config config_; |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 281 | rtc::SequencedTaskChecker configuration_sequence_checker_; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 282 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 283 | NetworkState audio_network_state_; |
| 284 | NetworkState video_network_state_; |
Sebastian Jansson | a06e919 | 2018-03-07 18:49:55 +0100 | [diff] [blame] | 285 | rtc::CriticalSection aggregate_network_up_crit_; |
| 286 | bool aggregate_network_up_ RTC_GUARDED_BY(aggregate_network_up_crit_); |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 287 | |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 288 | std::unique_ptr<RWLockWrapper> receive_crit_; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 289 | // Audio, Video, and FlexFEC receive streams are owned by the client that |
| 290 | // creates them. |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 291 | std::set<AudioReceiveStream*> audio_receive_streams_ |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 292 | RTC_GUARDED_BY(receive_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 293 | std::set<VideoReceiveStream*> video_receive_streams_ |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 294 | RTC_GUARDED_BY(receive_crit_); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 295 | |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 296 | std::map<std::string, AudioReceiveStream*> sync_stream_mapping_ |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 297 | RTC_GUARDED_BY(receive_crit_); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 298 | |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 299 | // TODO(nisse): Should eventually be injected at creation, |
| 300 | // with a single object in the bundled case. |
eladalon | 2a2b297 | 2017-07-03 09:25:27 -0700 | [diff] [blame] | 301 | RtpStreamReceiverController audio_receiver_controller_; |
| 302 | RtpStreamReceiverController video_receiver_controller_; |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 303 | |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 304 | // This extra map is used for receive processing which is |
| 305 | // independent of media type. |
| 306 | |
| 307 | // TODO(nisse): In the RTP transport refactoring, we should have a |
| 308 | // single mapping from ssrc to a more abstract receive stream, with |
| 309 | // accessor methods for all configuration we need at this level. |
| 310 | struct ReceiveRtpConfig { |
Erik Språng | 0970851 | 2018-03-14 15:16:50 +0100 | [diff] [blame] | 311 | explicit ReceiveRtpConfig(const webrtc::AudioReceiveStream::Config& config) |
| 312 | : extensions(config.rtp.extensions), |
| 313 | use_send_side_bwe(UseSendSideBwe(config)) {} |
| 314 | explicit ReceiveRtpConfig(const webrtc::VideoReceiveStream::Config& config) |
| 315 | : extensions(config.rtp.extensions), |
| 316 | use_send_side_bwe(UseSendSideBwe(config)) {} |
| 317 | explicit ReceiveRtpConfig(const FlexfecReceiveStream::Config& config) |
| 318 | : extensions(config.rtp_header_extensions), |
| 319 | use_send_side_bwe(UseSendSideBwe(config)) {} |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 320 | |
| 321 | // Registered RTP header extensions for each stream. Note that RTP header |
| 322 | // extensions are negotiated per track ("m= line") in the SDP, but we have |
| 323 | // no notion of tracks at the Call level. We therefore store the RTP header |
| 324 | // extensions per SSRC instead, which leads to some storage overhead. |
Erik Språng | 0970851 | 2018-03-14 15:16:50 +0100 | [diff] [blame] | 325 | const RtpHeaderExtensionMap extensions; |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 326 | // Set if both RTP extension the RTCP feedback message needed for |
| 327 | // send side BWE are negotiated. |
Erik Språng | 0970851 | 2018-03-14 15:16:50 +0100 | [diff] [blame] | 328 | const bool use_send_side_bwe; |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 329 | }; |
| 330 | std::map<uint32_t, ReceiveRtpConfig> receive_rtp_config_ |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 331 | RTC_GUARDED_BY(receive_crit_); |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 332 | |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 333 | std::unique_ptr<RWLockWrapper> send_crit_; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 334 | // Audio and Video send streams are owned by the client that creates them. |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 335 | std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ |
| 336 | RTC_GUARDED_BY(send_crit_); |
| 337 | std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ |
| 338 | RTC_GUARDED_BY(send_crit_); |
| 339 | std::set<VideoSendStream*> video_send_streams_ RTC_GUARDED_BY(send_crit_); |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 340 | |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 341 | using RtpStateMap = std::map<uint32_t, RtpState>; |
| 342 | RtpStateMap suspended_audio_send_ssrcs_ |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 343 | RTC_GUARDED_BY(configuration_sequence_checker_); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 344 | RtpStateMap suspended_video_send_ssrcs_ |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 345 | RTC_GUARDED_BY(configuration_sequence_checker_); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 346 | |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 347 | using RtpPayloadStateMap = std::map<uint32_t, RtpPayloadState>; |
| 348 | RtpPayloadStateMap suspended_video_payload_states_ |
| 349 | RTC_GUARDED_BY(configuration_sequence_checker_); |
| 350 | |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame] | 351 | webrtc::RtcEventLog* event_log_; |
ivoc | b04965c | 2015-09-09 00:09:43 -0700 | [diff] [blame] | 352 | |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 353 | // The following members are only accessed (exclusively) from one thread and |
| 354 | // from the destructor, and therefore doesn't need any explicit |
| 355 | // synchronization. |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 356 | RateCounter received_bytes_per_second_counter_; |
| 357 | RateCounter received_audio_bytes_per_second_counter_; |
| 358 | RateCounter received_video_bytes_per_second_counter_; |
| 359 | RateCounter received_rtcp_bytes_per_second_counter_; |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 360 | absl::optional<int64_t> first_received_rtp_audio_ms_; |
| 361 | absl::optional<int64_t> last_received_rtp_audio_ms_; |
| 362 | absl::optional<int64_t> first_received_rtp_video_ms_; |
| 363 | absl::optional<int64_t> last_received_rtp_video_ms_; |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 364 | |
Sebastian Jansson | 19704ec | 2018-03-12 15:59:12 +0100 | [diff] [blame] | 365 | rtc::CriticalSection last_bandwidth_bps_crit_; |
| 366 | uint32_t last_bandwidth_bps_ RTC_GUARDED_BY(&last_bandwidth_bps_crit_); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 367 | // TODO(holmer): Remove this lock once BitrateController no longer calls |
| 368 | // OnNetworkChanged from multiple threads. |
| 369 | rtc::CriticalSection bitrate_crit_; |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 370 | uint32_t min_allocated_send_bitrate_bps_ RTC_GUARDED_BY(&bitrate_crit_); |
| 371 | uint32_t configured_max_padding_bitrate_bps_ RTC_GUARDED_BY(&bitrate_crit_); |
| 372 | AvgCounter estimated_send_bitrate_kbps_counter_ |
| 373 | RTC_GUARDED_BY(&bitrate_crit_); |
| 374 | AvgCounter pacer_bitrate_kbps_counter_ RTC_GUARDED_BY(&bitrate_crit_); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 375 | |
nisse | 559af38 | 2017-03-21 06:41:12 -0700 | [diff] [blame] | 376 | ReceiveSideCongestionController receive_side_cc_; |
Sebastian Jansson | b34556e | 2018-03-21 14:38:32 +0100 | [diff] [blame] | 377 | |
| 378 | const std::unique_ptr<ReceiveTimeCalculator> receive_time_calculator_; |
| 379 | |
asapersson | 35151f3 | 2016-05-02 23:44:01 -0700 | [diff] [blame] | 380 | const std::unique_ptr<SendDelayStats> video_send_delay_stats_; |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 381 | const int64_t start_ms_; |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 382 | |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 383 | // Caches transport_send_.get(), to avoid racing with destructor. |
| 384 | // Note that this is declared before transport_send_ to ensure that it is not |
| 385 | // invalidated until no more tasks can be running on the transport_send_ task |
| 386 | // queue. |
| 387 | RtpTransportControllerSendInterface* transport_send_ptr_; |
| 388 | // Declared last since it will issue callbacks from a task queue. Declaring it |
| 389 | // last ensures that it is destroyed first and any running tasks are finished. |
| 390 | std::unique_ptr<RtpTransportControllerSendInterface> transport_send_; |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 391 | |
| 392 | // This is a precaution, since |MediaTransportChange| is not guaranteed to be |
| 393 | // invoked on a particular thread. |
| 394 | rtc::CriticalSection target_observer_crit_; |
| 395 | bool is_target_rate_observer_registered_ |
| 396 | RTC_GUARDED_BY(&target_observer_crit_) = false; |
| 397 | MediaTransportInterface* media_transport_ |
| 398 | RTC_GUARDED_BY(&target_observer_crit_) = nullptr; |
| 399 | |
henrikg | 3c089d7 | 2015-09-16 05:37:44 -0700 | [diff] [blame] | 400 | RTC_DISALLOW_COPY_AND_ASSIGN(Call); |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 401 | }; |
pbos@webrtc.org | c49d5b7 | 2013-12-05 12:11:47 +0000 | [diff] [blame] | 402 | } // namespace internal |
pbos@webrtc.org | fd39e13 | 2013-08-14 13:52:52 +0000 | [diff] [blame] | 403 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 404 | std::string Call::Stats::ToString(int64_t time_ms) const { |
Jonas Olsson | 0a713b6 | 2018-04-04 15:49:32 +0200 | [diff] [blame] | 405 | char buf[1024]; |
| 406 | rtc::SimpleStringBuilder ss(buf); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 407 | ss << "Call stats: " << time_ms << ", {"; |
| 408 | ss << "send_bw_bps: " << send_bandwidth_bps << ", "; |
| 409 | ss << "recv_bw_bps: " << recv_bandwidth_bps << ", "; |
| 410 | ss << "max_pad_bps: " << max_padding_bitrate_bps << ", "; |
| 411 | ss << "pacer_delay_ms: " << pacer_delay_ms << ", "; |
| 412 | ss << "rtt_ms: " << rtt_ms; |
| 413 | ss << '}'; |
| 414 | return ss.str(); |
| 415 | } |
| 416 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 417 | Call* Call::Create(const Call::Config& config) { |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 418 | return Create(config, ProcessThread::Create("PacerThread"), |
| 419 | ProcessThread::Create("ModuleProcessThread"), |
| 420 | &GlobalTaskQueueFactory()); |
| 421 | } |
| 422 | |
| 423 | Call* Call::Create(const Call::Config& config, |
| 424 | std::unique_ptr<ProcessThread> call_thread, |
| 425 | std::unique_ptr<ProcessThread> pacer_thread, |
| 426 | TaskQueueFactory* task_queue_factory) { |
Sebastian Jansson | 97f61ea | 2018-02-21 13:01:55 +0100 | [diff] [blame] | 427 | return new internal::Call( |
Sebastian Jansson | ed50e6c | 2019-03-01 14:45:21 +0100 | [diff] [blame] | 428 | config, |
| 429 | absl::make_unique<RtpTransportControllerSend>( |
| 430 | Clock::GetRealTimeClock(), config.event_log, |
| 431 | config.network_controller_factory, config.bitrate_config, |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 432 | std::move(pacer_thread), task_queue_factory), |
| 433 | std::move(call_thread), task_queue_factory); |
zstein | 7cb69d5 | 2017-05-08 11:52:38 -0700 | [diff] [blame] | 434 | } |
| 435 | |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 436 | // This method here to avoid subclasses has to implement this method. |
| 437 | // Call perf test will use Internal::Call::CreateVideoSendStream() to inject |
| 438 | // FecController. |
Ying Wang | 3b790f3 | 2018-01-19 17:58:57 +0100 | [diff] [blame] | 439 | VideoSendStream* Call::CreateVideoSendStream( |
| 440 | VideoSendStream::Config config, |
| 441 | VideoEncoderConfig encoder_config, |
| 442 | std::unique_ptr<FecController> fec_controller) { |
| 443 | return nullptr; |
| 444 | } |
| 445 | |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 446 | namespace internal { |
| 447 | |
nisse | b8f9a32 | 2017-03-27 05:36:15 -0700 | [diff] [blame] | 448 | Call::Call(const Call::Config& config, |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 449 | std::unique_ptr<RtpTransportControllerSendInterface> transport_send, |
| 450 | std::unique_ptr<ProcessThread> module_process_thread, |
| 451 | TaskQueueFactory* task_queue_factory) |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 452 | : clock_(Clock::GetRealTimeClock()), |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 453 | task_queue_factory_(task_queue_factory), |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 454 | num_cpu_cores_(CpuInfo::DetectNumberOfCores()), |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 455 | module_process_thread_(std::move(module_process_thread)), |
Tommi | 38c5d93 | 2018-03-27 23:11:09 +0200 | [diff] [blame] | 456 | call_stats_(new CallStats(clock_, module_process_thread_.get())), |
Sebastian Jansson | da6806c | 2019-03-04 17:05:12 +0100 | [diff] [blame] | 457 | bitrate_allocator_(new BitrateAllocator(clock_, this)), |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 458 | config_(config), |
Sergey Ulanov | e2b1501 | 2016-11-22 16:08:30 -0800 | [diff] [blame] | 459 | audio_network_state_(kNetworkDown), |
| 460 | video_network_state_(kNetworkDown), |
Sebastian Jansson | a06e919 | 2018-03-07 18:49:55 +0100 | [diff] [blame] | 461 | aggregate_network_up_(false), |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 462 | receive_crit_(RWLockWrapper::CreateRWLock()), |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 463 | send_crit_(RWLockWrapper::CreateRWLock()), |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame] | 464 | event_log_(config.event_log), |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 465 | received_bytes_per_second_counter_(clock_, nullptr, true), |
| 466 | received_audio_bytes_per_second_counter_(clock_, nullptr, true), |
| 467 | received_video_bytes_per_second_counter_(clock_, nullptr, true), |
| 468 | received_rtcp_bytes_per_second_counter_(clock_, nullptr, true), |
Sebastian Jansson | 19704ec | 2018-03-12 15:59:12 +0100 | [diff] [blame] | 469 | last_bandwidth_bps_(0), |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 470 | min_allocated_send_bitrate_bps_(0), |
sprang | 9c0b551 | 2016-07-06 00:54:28 -0700 | [diff] [blame] | 471 | configured_max_padding_bitrate_bps_(0), |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 472 | estimated_send_bitrate_kbps_counter_(clock_, nullptr, true), |
| 473 | pacer_bitrate_kbps_counter_(clock_, nullptr, true), |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 474 | receive_side_cc_(clock_, transport_send->packet_router()), |
Sebastian Jansson | b34556e | 2018-03-21 14:38:32 +0100 | [diff] [blame] | 475 | receive_time_calculator_(ReceiveTimeCalculator::CreateFromFieldTrial()), |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 476 | video_send_delay_stats_(new SendDelayStats(clock_)), |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 477 | start_ms_(clock_->TimeInMilliseconds()) { |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame] | 478 | RTC_DCHECK(config.event_log != nullptr); |
nisse | 6167b26 | 2017-04-06 06:34:25 -0700 | [diff] [blame] | 479 | transport_send_ = std::move(transport_send); |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 480 | transport_send_ptr_ = transport_send_.get(); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 481 | } |
| 482 | |
pbos@webrtc.org | 841c8a4 | 2013-09-09 15:04:25 +0000 | [diff] [blame] | 483 | Call::~Call() { |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 484 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 485 | |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 486 | RTC_CHECK(audio_send_ssrcs_.empty()); |
| 487 | RTC_CHECK(video_send_ssrcs_.empty()); |
| 488 | RTC_CHECK(video_send_streams_.empty()); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 489 | RTC_CHECK(audio_receive_streams_.empty()); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 490 | RTC_CHECK(video_receive_streams_.empty()); |
pbos@webrtc.org | 9e4e524 | 2015-02-12 10:48:23 +0000 | [diff] [blame] | 491 | |
Piotr (Peter) Slatala | b275788 | 2018-12-18 11:17:09 -0800 | [diff] [blame] | 492 | if (!media_transport_) { |
| 493 | module_process_thread_->DeRegisterModule( |
| 494 | receive_side_cc_.GetRemoteBitrateEstimator(true)); |
| 495 | module_process_thread_->DeRegisterModule(&receive_side_cc_); |
| 496 | module_process_thread_->DeRegisterModule(call_stats_.get()); |
| 497 | module_process_thread_->Stop(); |
| 498 | call_stats_->DeregisterStatsObserver(&receive_side_cc_); |
Piotr (Peter) Slatala | b275788 | 2018-12-18 11:17:09 -0800 | [diff] [blame] | 499 | } |
sprang | 6d6122b | 2016-07-13 06:37:09 -0700 | [diff] [blame] | 500 | |
Sebastian Jansson | e4be6da | 2018-02-15 16:51:41 +0100 | [diff] [blame] | 501 | int64_t first_sent_packet_ms = transport_send_->GetFirstPacketTimeMs(); |
sprang | 6d6122b | 2016-07-13 06:37:09 -0700 | [diff] [blame] | 502 | // Only update histograms after process threads have been shut down, so that |
| 503 | // they won't try to concurrently update stats. |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 504 | { |
| 505 | rtc::CritScope lock(&bitrate_crit_); |
asapersson | fc5e81c | 2017-04-19 23:28:53 -0700 | [diff] [blame] | 506 | UpdateSendHistograms(first_sent_packet_ms); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 507 | } |
sprang | 6d6122b | 2016-07-13 06:37:09 -0700 | [diff] [blame] | 508 | UpdateReceiveHistograms(); |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 509 | UpdateHistograms(); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 510 | } |
| 511 | |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 512 | void Call::RegisterRateObserver() { |
| 513 | rtc::CritScope lock(&target_observer_crit_); |
| 514 | |
| 515 | if (is_target_rate_observer_registered_) { |
| 516 | return; |
| 517 | } |
| 518 | |
| 519 | is_target_rate_observer_registered_ = true; |
| 520 | |
| 521 | if (media_transport_) { |
Piotr (Peter) Slatala | b275788 | 2018-12-18 11:17:09 -0800 | [diff] [blame] | 522 | // TODO(bugs.webrtc.org/9719): We should report call_stats_ from |
| 523 | // media transport (at least Rtt). We should extend media transport |
| 524 | // interface to include "receive_side bwe" if needed. |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 525 | media_transport_->AddTargetTransferRateObserver(this); |
| 526 | } else { |
| 527 | transport_send_ptr_->RegisterTargetTransferRateObserver(this); |
Piotr (Peter) Slatala | b275788 | 2018-12-18 11:17:09 -0800 | [diff] [blame] | 528 | |
| 529 | call_stats_->RegisterStatsObserver(&receive_side_cc_); |
Piotr (Peter) Slatala | b275788 | 2018-12-18 11:17:09 -0800 | [diff] [blame] | 530 | |
| 531 | module_process_thread_->RegisterModule( |
| 532 | receive_side_cc_.GetRemoteBitrateEstimator(true), RTC_FROM_HERE); |
| 533 | module_process_thread_->RegisterModule(call_stats_.get(), RTC_FROM_HERE); |
| 534 | module_process_thread_->RegisterModule(&receive_side_cc_, RTC_FROM_HERE); |
| 535 | module_process_thread_->Start(); |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 536 | } |
| 537 | } |
| 538 | |
Niels Möller | 4687915 | 2019-01-07 15:54:47 +0100 | [diff] [blame] | 539 | MediaTransportInterface* Call::media_transport() { |
| 540 | rtc::CritScope lock(&target_observer_crit_); |
| 541 | return media_transport_; |
| 542 | } |
| 543 | |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 544 | void Call::MediaTransportChange(MediaTransportInterface* media_transport) { |
| 545 | rtc::CritScope lock(&target_observer_crit_); |
| 546 | |
| 547 | if (is_target_rate_observer_registered_) { |
| 548 | // Only used to unregister rate observer from media transport. Registration |
| 549 | // happens when the stream is created. |
| 550 | if (!media_transport && media_transport_) { |
| 551 | media_transport_->RemoveTargetTransferRateObserver(this); |
| 552 | media_transport_ = nullptr; |
| 553 | is_target_rate_observer_registered_ = false; |
| 554 | } |
| 555 | } else if (media_transport) { |
| 556 | RTC_DCHECK(media_transport_ == nullptr || |
| 557 | media_transport_ == media_transport) |
| 558 | << "media_transport_=" << (media_transport_ != nullptr) |
| 559 | << ", (media_transport_==media_transport)=" |
| 560 | << (media_transport_ == media_transport); |
| 561 | media_transport_ = media_transport; |
| 562 | } |
| 563 | } |
| 564 | |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 565 | void Call::UpdateHistograms() { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 566 | RTC_HISTOGRAM_COUNTS_100000( |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 567 | "WebRTC.Call.LifetimeInSeconds", |
| 568 | (clock_->TimeInMilliseconds() - start_ms_) / 1000); |
| 569 | } |
| 570 | |
asapersson | fc5e81c | 2017-04-19 23:28:53 -0700 | [diff] [blame] | 571 | void Call::UpdateSendHistograms(int64_t first_sent_packet_ms) { |
| 572 | if (first_sent_packet_ms == -1) |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 573 | return; |
| 574 | int64_t elapsed_sec = |
asapersson | fc5e81c | 2017-04-19 23:28:53 -0700 | [diff] [blame] | 575 | (clock_->TimeInMilliseconds() - first_sent_packet_ms) / 1000; |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 576 | if (elapsed_sec < metrics::kMinRunTimeInSeconds) |
| 577 | return; |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 578 | const int kMinRequiredPeriodicSamples = 5; |
| 579 | AggregatedStats send_bitrate_stats = |
| 580 | estimated_send_bitrate_kbps_counter_.ProcessAndGetStats(); |
| 581 | if (send_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 582 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps", |
| 583 | send_bitrate_stats.average); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 584 | RTC_LOG(LS_INFO) << "WebRTC.Call.EstimatedSendBitrateInKbps, " |
| 585 | << send_bitrate_stats.ToString(); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 586 | } |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 587 | AggregatedStats pacer_bitrate_stats = |
| 588 | pacer_bitrate_kbps_counter_.ProcessAndGetStats(); |
| 589 | if (pacer_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 590 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.PacerBitrateInKbps", |
| 591 | pacer_bitrate_stats.average); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 592 | RTC_LOG(LS_INFO) << "WebRTC.Call.PacerBitrateInKbps, " |
| 593 | << pacer_bitrate_stats.ToString(); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 594 | } |
| 595 | } |
| 596 | |
| 597 | void Call::UpdateReceiveHistograms() { |
saza | 0d7f04d | 2017-07-04 04:05:06 -0700 | [diff] [blame] | 598 | if (first_received_rtp_audio_ms_) { |
| 599 | RTC_HISTOGRAM_COUNTS_100000( |
| 600 | "WebRTC.Call.TimeReceivingAudioRtpPacketsInSeconds", |
| 601 | (*last_received_rtp_audio_ms_ - *first_received_rtp_audio_ms_) / 1000); |
| 602 | } |
| 603 | if (first_received_rtp_video_ms_) { |
| 604 | RTC_HISTOGRAM_COUNTS_100000( |
| 605 | "WebRTC.Call.TimeReceivingVideoRtpPacketsInSeconds", |
| 606 | (*last_received_rtp_video_ms_ - *first_received_rtp_video_ms_) / 1000); |
| 607 | } |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 608 | const int kMinRequiredPeriodicSamples = 5; |
| 609 | AggregatedStats video_bytes_per_sec = |
| 610 | received_video_bytes_per_second_counter_.GetStats(); |
| 611 | if (video_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 612 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.VideoBitrateReceivedInKbps", |
| 613 | video_bytes_per_sec.average * 8 / 1000); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 614 | RTC_LOG(LS_INFO) << "WebRTC.Call.VideoBitrateReceivedInBps, " |
| 615 | << video_bytes_per_sec.ToStringWithMultiplier(8); |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 616 | } |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 617 | AggregatedStats audio_bytes_per_sec = |
| 618 | received_audio_bytes_per_second_counter_.GetStats(); |
| 619 | if (audio_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 620 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.AudioBitrateReceivedInKbps", |
| 621 | audio_bytes_per_sec.average * 8 / 1000); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 622 | RTC_LOG(LS_INFO) << "WebRTC.Call.AudioBitrateReceivedInBps, " |
| 623 | << audio_bytes_per_sec.ToStringWithMultiplier(8); |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 624 | } |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 625 | AggregatedStats rtcp_bytes_per_sec = |
| 626 | received_rtcp_bytes_per_second_counter_.GetStats(); |
| 627 | if (rtcp_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 628 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.RtcpBitrateReceivedInBps", |
| 629 | rtcp_bytes_per_sec.average * 8); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 630 | RTC_LOG(LS_INFO) << "WebRTC.Call.RtcpBitrateReceivedInBps, " |
| 631 | << rtcp_bytes_per_sec.ToStringWithMultiplier(8); |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 632 | } |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 633 | AggregatedStats recv_bytes_per_sec = |
| 634 | received_bytes_per_second_counter_.GetStats(); |
| 635 | if (recv_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 636 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.BitrateReceivedInKbps", |
| 637 | recv_bytes_per_sec.average * 8 / 1000); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 638 | RTC_LOG(LS_INFO) << "WebRTC.Call.BitrateReceivedInBps, " |
| 639 | << recv_bytes_per_sec.ToStringWithMultiplier(8); |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 640 | } |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 641 | } |
| 642 | |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 643 | PacketReceiver* Call::Receiver() { |
eladalon | d1dd2f7 | 2017-08-25 02:55:57 -0700 | [diff] [blame] | 644 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 645 | return this; |
| 646 | } |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 647 | |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 648 | webrtc::AudioSendStream* Call::CreateAudioSendStream( |
| 649 | const webrtc::AudioSendStream::Config& config) { |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 650 | TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 651 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 652 | |
Niels Möller | 4687915 | 2019-01-07 15:54:47 +0100 | [diff] [blame] | 653 | RTC_DCHECK(media_transport() == config.media_transport); |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 654 | |
| 655 | RegisterRateObserver(); |
| 656 | |
Oskar Sundbom | 56ef305 | 2018-10-30 16:11:02 +0100 | [diff] [blame] | 657 | // Stream config is logged in AudioSendStream::ConfigureStream, as it may |
| 658 | // change during the stream's lifetime. |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 659 | absl::optional<RtpState> suspended_rtp_state; |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 660 | { |
| 661 | const auto& iter = suspended_audio_send_ssrcs_.find(config.rtp.ssrc); |
| 662 | if (iter != suspended_audio_send_ssrcs_.end()) { |
| 663 | suspended_rtp_state.emplace(iter->second); |
| 664 | } |
| 665 | } |
| 666 | |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 667 | // TODO(srte): AudioSendStream should call GetWorkerQueue directly rather than |
| 668 | // having it injected. |
| 669 | |
Stefan Holmer | b86d4e4 | 2015-12-07 10:26:18 +0100 | [diff] [blame] | 670 | AudioSendStream* send_stream = new AudioSendStream( |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 671 | config, config_.audio_state, transport_send_ptr_->GetWorkerQueue(), |
| 672 | module_process_thread_.get(), transport_send_ptr_, |
| 673 | bitrate_allocator_.get(), event_log_, call_stats_.get(), |
Sam Zackrisson | ff05816 | 2018-11-20 17:15:13 +0100 | [diff] [blame] | 674 | suspended_rtp_state); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 675 | { |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 676 | WriteLockScoped write_lock(*send_crit_); |
| 677 | RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) == |
| 678 | audio_send_ssrcs_.end()); |
| 679 | audio_send_ssrcs_[config.rtp.ssrc] = send_stream; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 680 | } |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 681 | { |
| 682 | ReadLockScoped read_lock(*receive_crit_); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 683 | for (AudioReceiveStream* stream : audio_receive_streams_) { |
| 684 | if (stream->config().rtp.local_ssrc == config.rtp.ssrc) { |
| 685 | stream->AssociateSendStream(send_stream); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 686 | } |
| 687 | } |
| 688 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 689 | send_stream->SignalNetworkState(audio_network_state_); |
| 690 | UpdateAggregateNetworkState(); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 691 | return send_stream; |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 692 | } |
| 693 | |
| 694 | void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) { |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 695 | TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 696 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 697 | RTC_DCHECK(send_stream != nullptr); |
| 698 | |
| 699 | send_stream->Stop(); |
| 700 | |
eladalon | abbc430 | 2017-07-26 02:09:44 -0700 | [diff] [blame] | 701 | const uint32_t ssrc = send_stream->GetConfig().rtp.ssrc; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 702 | webrtc::internal::AudioSendStream* audio_send_stream = |
| 703 | static_cast<webrtc::internal::AudioSendStream*>(send_stream); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 704 | suspended_audio_send_ssrcs_[ssrc] = audio_send_stream->GetRtpState(); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 705 | { |
| 706 | WriteLockScoped write_lock(*send_crit_); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 707 | size_t num_deleted = audio_send_ssrcs_.erase(ssrc); |
| 708 | RTC_DCHECK_EQ(1, num_deleted); |
| 709 | } |
| 710 | { |
| 711 | ReadLockScoped read_lock(*receive_crit_); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 712 | for (AudioReceiveStream* stream : audio_receive_streams_) { |
| 713 | if (stream->config().rtp.local_ssrc == ssrc) { |
| 714 | stream->AssociateSendStream(nullptr); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 715 | } |
| 716 | } |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 717 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 718 | UpdateAggregateNetworkState(); |
eladalon | abbc430 | 2017-07-26 02:09:44 -0700 | [diff] [blame] | 719 | delete send_stream; |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 720 | } |
| 721 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 722 | webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream( |
| 723 | const webrtc::AudioReceiveStream::Config& config) { |
| 724 | TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 725 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
Piotr (Peter) Slatala | b275788 | 2018-12-18 11:17:09 -0800 | [diff] [blame] | 726 | RegisterRateObserver(); |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 727 | event_log_->Log(absl::make_unique<RtcEventAudioReceiveStreamConfig>( |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 728 | CreateRtcLogStreamConfig(config))); |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 729 | AudioReceiveStream* receive_stream = new AudioReceiveStream( |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 730 | &audio_receiver_controller_, transport_send_ptr_->packet_router(), |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 731 | module_process_thread_.get(), config, config_.audio_state, event_log_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 732 | { |
| 733 | WriteLockScoped write_lock(*receive_crit_); |
Erik Språng | 0970851 | 2018-03-14 15:16:50 +0100 | [diff] [blame] | 734 | receive_rtp_config_.emplace(config.rtp.remote_ssrc, |
| 735 | ReceiveRtpConfig(config)); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 736 | audio_receive_streams_.insert(receive_stream); |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 737 | |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 738 | ConfigureSync(config.sync_group); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 739 | } |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 740 | { |
| 741 | ReadLockScoped read_lock(*send_crit_); |
| 742 | auto it = audio_send_ssrcs_.find(config.rtp.local_ssrc); |
| 743 | if (it != audio_send_ssrcs_.end()) { |
| 744 | receive_stream->AssociateSendStream(it->second); |
| 745 | } |
| 746 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 747 | receive_stream->SignalNetworkState(audio_network_state_); |
| 748 | UpdateAggregateNetworkState(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 749 | return receive_stream; |
| 750 | } |
| 751 | |
| 752 | void Call::DestroyAudioReceiveStream( |
| 753 | webrtc::AudioReceiveStream* receive_stream) { |
| 754 | TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 755 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 756 | RTC_DCHECK(receive_stream != nullptr); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 757 | webrtc::internal::AudioReceiveStream* audio_receive_stream = |
| 758 | static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 759 | { |
| 760 | WriteLockScoped write_lock(*receive_crit_); |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 761 | const AudioReceiveStream::Config& config = audio_receive_stream->config(); |
| 762 | uint32_t ssrc = config.rtp.remote_ssrc; |
nisse | 559af38 | 2017-03-21 06:41:12 -0700 | [diff] [blame] | 763 | receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config)) |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 764 | ->RemoveStream(ssrc); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 765 | audio_receive_streams_.erase(audio_receive_stream); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 766 | const std::string& sync_group = audio_receive_stream->config().sync_group; |
| 767 | const auto it = sync_stream_mapping_.find(sync_group); |
| 768 | if (it != sync_stream_mapping_.end() && |
| 769 | it->second == audio_receive_stream) { |
| 770 | sync_stream_mapping_.erase(it); |
| 771 | ConfigureSync(sync_group); |
| 772 | } |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 773 | receive_rtp_config_.erase(ssrc); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 774 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 775 | UpdateAggregateNetworkState(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 776 | delete audio_receive_stream; |
| 777 | } |
| 778 | |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 779 | // This method can be used for Call tests with external fec controller factory. |
Ying Wang | 3b790f3 | 2018-01-19 17:58:57 +0100 | [diff] [blame] | 780 | webrtc::VideoSendStream* Call::CreateVideoSendStream( |
| 781 | webrtc::VideoSendStream::Config config, |
| 782 | VideoEncoderConfig encoder_config, |
| 783 | std::unique_ptr<FecController> fec_controller) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 784 | TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 785 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
pbos@webrtc.org | 1819fd7 | 2013-06-10 13:48:26 +0000 | [diff] [blame] | 786 | |
Niels Möller | 4687915 | 2019-01-07 15:54:47 +0100 | [diff] [blame] | 787 | RTC_DCHECK(media_transport() == config.media_transport); |
| 788 | |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 789 | RegisterRateObserver(); |
| 790 | |
asapersson | 35151f3 | 2016-05-02 23:44:01 -0700 | [diff] [blame] | 791 | video_send_delay_stats_->AddSsrcs(config); |
perkj | c0876aa | 2017-05-22 04:08:28 -0700 | [diff] [blame] | 792 | for (size_t ssrc_index = 0; ssrc_index < config.rtp.ssrcs.size(); |
| 793 | ++ssrc_index) { |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 794 | event_log_->Log(absl::make_unique<RtcEventVideoSendStreamConfig>( |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 795 | CreateRtcLogStreamConfig(config, ssrc_index))); |
perkj | c0876aa | 2017-05-22 04:08:28 -0700 | [diff] [blame] | 796 | } |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 797 | |
mflodman@webrtc.org | eb16b81 | 2014-06-16 08:57:39 +0000 | [diff] [blame] | 798 | // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if |
| 799 | // the call has already started. |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 800 | // Copy ssrcs from |config| since |config| is moved. |
| 801 | std::vector<uint32_t> ssrcs = config.rtp.ssrcs; |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 802 | |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 803 | // TODO(srte): VideoSendStream should call GetWorkerQueue directly rather than |
| 804 | // having it injected. |
mflodman | 0c478b3 | 2015-10-21 15:52:16 +0200 | [diff] [blame] | 805 | VideoSendStream* send_stream = new VideoSendStream( |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 806 | num_cpu_cores_, module_process_thread_.get(), |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 807 | transport_send_ptr_->GetWorkerQueue(), task_queue_factory_, |
Sebastian Jansson | 74682c1 | 2019-03-01 11:50:20 +0100 | [diff] [blame] | 808 | call_stats_.get(), transport_send_ptr_, bitrate_allocator_.get(), |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 809 | video_send_delay_stats_.get(), event_log_, std::move(config), |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 810 | std::move(encoder_config), suspended_video_send_ssrcs_, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 811 | suspended_video_payload_states_, std::move(fec_controller)); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 812 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 813 | { |
| 814 | WriteLockScoped write_lock(*send_crit_); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 815 | for (uint32_t ssrc : ssrcs) { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 816 | RTC_DCHECK(video_send_ssrcs_.find(ssrc) == video_send_ssrcs_.end()); |
| 817 | video_send_ssrcs_[ssrc] = send_stream; |
| 818 | } |
| 819 | video_send_streams_.insert(send_stream); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 820 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 821 | UpdateAggregateNetworkState(); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 822 | |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 823 | return send_stream; |
| 824 | } |
| 825 | |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 826 | webrtc::VideoSendStream* Call::CreateVideoSendStream( |
| 827 | webrtc::VideoSendStream::Config config, |
| 828 | VideoEncoderConfig encoder_config) { |
Ying Wang | 012b7e7 | 2018-03-05 15:44:23 +0100 | [diff] [blame] | 829 | if (config_.fec_controller_factory) { |
| 830 | RTC_LOG(LS_INFO) << "External FEC Controller will be used."; |
| 831 | } |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 832 | std::unique_ptr<FecController> fec_controller = |
| 833 | config_.fec_controller_factory |
| 834 | ? config_.fec_controller_factory->CreateFecController() |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 835 | : absl::make_unique<FecControllerDefault>(Clock::GetRealTimeClock()); |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 836 | return CreateVideoSendStream(std::move(config), std::move(encoder_config), |
| 837 | std::move(fec_controller)); |
| 838 | } |
| 839 | |
pbos@webrtc.org | 2c46f8d | 2013-11-21 13:49:43 +0000 | [diff] [blame] | 840 | void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 841 | TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream"); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 842 | RTC_DCHECK(send_stream != nullptr); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 843 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 844 | |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 845 | send_stream->Stop(); |
| 846 | |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 +0000 | [diff] [blame] | 847 | VideoSendStream* send_stream_impl = nullptr; |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 848 | { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 849 | WriteLockScoped write_lock(*send_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 850 | auto it = video_send_ssrcs_.begin(); |
| 851 | while (it != video_send_ssrcs_.end()) { |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 852 | if (it->second == static_cast<VideoSendStream*>(send_stream)) { |
| 853 | send_stream_impl = it->second; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 854 | video_send_ssrcs_.erase(it++); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 855 | } else { |
| 856 | ++it; |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 857 | } |
| 858 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 859 | video_send_streams_.erase(send_stream_impl); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 860 | } |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 861 | RTC_CHECK(send_stream_impl != nullptr); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 862 | |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 863 | VideoSendStream::RtpStateMap rtp_states; |
| 864 | VideoSendStream::RtpPayloadStateMap rtp_payload_states; |
| 865 | send_stream_impl->StopPermanentlyAndGetRtpStates(&rtp_states, |
| 866 | &rtp_payload_states); |
| 867 | for (const auto& kv : rtp_states) { |
| 868 | suspended_video_send_ssrcs_[kv.first] = kv.second; |
| 869 | } |
| 870 | for (const auto& kv : rtp_payload_states) { |
| 871 | suspended_video_payload_states_[kv.first] = kv.second; |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 872 | } |
| 873 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 874 | UpdateAggregateNetworkState(); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 875 | delete send_stream_impl; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 876 | } |
| 877 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 878 | webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream( |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 879 | webrtc::VideoReceiveStream::Config configuration) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 880 | TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 881 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
brandtr | fb45c6c | 2017-01-27 06:47:55 -0800 | [diff] [blame] | 882 | |
Johannes Kron | 7ff164e | 2019-02-07 12:50:18 +0100 | [diff] [blame] | 883 | receive_side_cc_.SetSendFeedbackOnRequestOnly( |
| 884 | SendFeedbackOnRequestOnly(configuration.rtp.extensions)); |
| 885 | |
Piotr (Peter) Slatala | b275788 | 2018-12-18 11:17:09 -0800 | [diff] [blame] | 886 | RegisterRateObserver(); |
| 887 | |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 888 | VideoReceiveStream* receive_stream = new VideoReceiveStream( |
Sebastian Jansson | 896b47c | 2019-03-01 18:48:16 +0100 | [diff] [blame] | 889 | task_queue_factory_, &video_receiver_controller_, num_cpu_cores_, |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 890 | transport_send_ptr_->packet_router(), std::move(configuration), |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 891 | module_process_thread_.get(), call_stats_.get()); |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 892 | |
| 893 | const webrtc::VideoReceiveStream::Config& config = receive_stream->config(); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 894 | { |
| 895 | WriteLockScoped write_lock(*receive_crit_); |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 896 | if (config.rtp.rtx_ssrc) { |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 897 | // We record identical config for the rtx stream as for the main |
nisse | b8f9a32 | 2017-03-27 05:36:15 -0700 | [diff] [blame] | 898 | // stream. Since the transport_send_cc negotiation is per payload |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 899 | // type, we may get an incorrect value for the rtx stream, but |
| 900 | // that is unlikely to matter in practice. |
Erik Språng | 0970851 | 2018-03-14 15:16:50 +0100 | [diff] [blame] | 901 | receive_rtp_config_.emplace(config.rtp.rtx_ssrc, |
| 902 | ReceiveRtpConfig(config)); |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 903 | } |
Erik Språng | 0970851 | 2018-03-14 15:16:50 +0100 | [diff] [blame] | 904 | receive_rtp_config_.emplace(config.rtp.remote_ssrc, |
| 905 | ReceiveRtpConfig(config)); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 906 | video_receive_streams_.insert(receive_stream); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 907 | ConfigureSync(config.sync_group); |
| 908 | } |
| 909 | receive_stream->SignalNetworkState(video_network_state_); |
| 910 | UpdateAggregateNetworkState(); |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 911 | event_log_->Log(absl::make_unique<RtcEventVideoReceiveStreamConfig>( |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 912 | CreateRtcLogStreamConfig(config))); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 913 | return receive_stream; |
| 914 | } |
| 915 | |
pbos@webrtc.org | 2c46f8d | 2013-11-21 13:49:43 +0000 | [diff] [blame] | 916 | void Call::DestroyVideoReceiveStream( |
| 917 | webrtc::VideoReceiveStream* receive_stream) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 918 | TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 919 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 920 | RTC_DCHECK(receive_stream != nullptr); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 921 | VideoReceiveStream* receive_stream_impl = |
| 922 | static_cast<VideoReceiveStream*>(receive_stream); |
| 923 | const VideoReceiveStream::Config& config = receive_stream_impl->config(); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 924 | { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 925 | WriteLockScoped write_lock(*receive_crit_); |
pbos@webrtc.org | c279a5d | 2014-01-24 09:30:53 +0000 | [diff] [blame] | 926 | // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a |
| 927 | // separate SSRC there can be either one or two. |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 928 | receive_rtp_config_.erase(config.rtp.remote_ssrc); |
| 929 | if (config.rtp.rtx_ssrc) { |
| 930 | receive_rtp_config_.erase(config.rtp.rtx_ssrc); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 931 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 932 | video_receive_streams_.erase(receive_stream_impl); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 933 | ConfigureSync(config.sync_group); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 934 | } |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 935 | |
nisse | 559af38 | 2017-03-21 06:41:12 -0700 | [diff] [blame] | 936 | receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config)) |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 937 | ->RemoveStream(config.rtp.remote_ssrc); |
| 938 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 939 | UpdateAggregateNetworkState(); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 940 | delete receive_stream_impl; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 941 | } |
| 942 | |
brandtr | 7250b39 | 2016-12-19 01:13:46 -0800 | [diff] [blame] | 943 | FlexfecReceiveStream* Call::CreateFlexfecReceiveStream( |
| 944 | const FlexfecReceiveStream::Config& config) { |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 945 | TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 946 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 947 | |
| 948 | RecoveredPacketReceiver* recovered_packet_receiver = this; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 949 | |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 950 | FlexfecReceiveStreamImpl* receive_stream; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 951 | { |
| 952 | WriteLockScoped write_lock(*receive_crit_); |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 953 | // Unlike the video and audio receive streams, |
| 954 | // FlexfecReceiveStream implements RtpPacketSinkInterface itself, |
| 955 | // and hence its constructor passes its |this| pointer to |
eladalon | 2a2b297 | 2017-07-03 09:25:27 -0700 | [diff] [blame] | 956 | // video_receiver_controller_->CreateStream(). Calling the |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 957 | // constructor while holding |receive_crit_| ensures that we don't |
| 958 | // call OnRtpPacket until the constructor is finished and the |
| 959 | // object is in a valid state. |
| 960 | // TODO(nisse): Fix constructor so that it can be moved outside of |
| 961 | // this locked scope. |
| 962 | receive_stream = new FlexfecReceiveStreamImpl( |
eladalon | 2a2b297 | 2017-07-03 09:25:27 -0700 | [diff] [blame] | 963 | &video_receiver_controller_, config, recovered_packet_receiver, |
Tommi | 38c5d93 | 2018-03-27 23:11:09 +0200 | [diff] [blame] | 964 | call_stats_.get(), module_process_thread_.get()); |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 965 | |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 966 | RTC_DCHECK(receive_rtp_config_.find(config.remote_ssrc) == |
| 967 | receive_rtp_config_.end()); |
Erik Språng | 0970851 | 2018-03-14 15:16:50 +0100 | [diff] [blame] | 968 | receive_rtp_config_.emplace(config.remote_ssrc, ReceiveRtpConfig(config)); |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 969 | } |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 970 | |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 971 | // TODO(brandtr): Store config in RtcEventLog here. |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 972 | |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 973 | return receive_stream; |
| 974 | } |
| 975 | |
brandtr | 7250b39 | 2016-12-19 01:13:46 -0800 | [diff] [blame] | 976 | void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) { |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 977 | TRACE_EVENT0("webrtc", "Call::DestroyFlexfecReceiveStream"); |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 978 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 979 | |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 980 | RTC_DCHECK(receive_stream != nullptr); |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 981 | { |
| 982 | WriteLockScoped write_lock(*receive_crit_); |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 983 | |
eladalon | 42f44f9 | 2017-07-25 06:40:06 -0700 | [diff] [blame] | 984 | const FlexfecReceiveStream::Config& config = receive_stream->GetConfig(); |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 985 | uint32_t ssrc = config.remote_ssrc; |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 986 | receive_rtp_config_.erase(ssrc); |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 987 | |
brandtr | 7250b39 | 2016-12-19 01:13:46 -0800 | [diff] [blame] | 988 | // Remove all SSRCs pointing to the FlexfecReceiveStreamImpl to be |
| 989 | // destroyed. |
nisse | 559af38 | 2017-03-21 06:41:12 -0700 | [diff] [blame] | 990 | receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config)) |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 991 | ->RemoveStream(ssrc); |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 992 | } |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 993 | |
eladalon | 42f44f9 | 2017-07-25 06:40:06 -0700 | [diff] [blame] | 994 | delete receive_stream; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 995 | } |
| 996 | |
Sebastian Jansson | 8f83b42 | 2018-02-21 13:07:13 +0100 | [diff] [blame] | 997 | RtpTransportControllerSendInterface* Call::GetTransportControllerSend() { |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 998 | return transport_send_ptr_; |
Sebastian Jansson | 8f83b42 | 2018-02-21 13:07:13 +0100 | [diff] [blame] | 999 | } |
| 1000 | |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1001 | Call::Stats Call::GetStats() const { |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 1002 | // TODO(solenberg): Some test cases in EndToEndTest use this from a different |
| 1003 | // thread. Re-enable once that is fixed. |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 1004 | // RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1005 | Stats stats; |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 1006 | // Fetch available send/receive bitrates. |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 1007 | std::vector<unsigned int> ssrcs; |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1008 | uint32_t recv_bandwidth = 0; |
nisse | 559af38 | 2017-03-21 06:41:12 -0700 | [diff] [blame] | 1009 | receive_side_cc_.GetRemoteBitrateEstimator(false)->LatestEstimate( |
mflodman | a20de20 | 2015-10-18 22:08:19 -0700 | [diff] [blame] | 1010 | &ssrcs, &recv_bandwidth); |
Sebastian Jansson | 19704ec | 2018-03-12 15:59:12 +0100 | [diff] [blame] | 1011 | |
| 1012 | { |
| 1013 | rtc::CritScope cs(&last_bandwidth_bps_crit_); |
| 1014 | stats.send_bandwidth_bps = last_bandwidth_bps_; |
| 1015 | } |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1016 | stats.recv_bandwidth_bps = recv_bandwidth; |
Sebastian Jansson | a06e919 | 2018-03-07 18:49:55 +0100 | [diff] [blame] | 1017 | // TODO(srte): It is unclear if we only want to report queues if network is |
| 1018 | // available. |
| 1019 | { |
| 1020 | rtc::CritScope cs(&aggregate_network_up_crit_); |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 1021 | stats.pacer_delay_ms = aggregate_network_up_ |
| 1022 | ? transport_send_ptr_->GetPacerQueuingDelayMs() |
| 1023 | : 0; |
Sebastian Jansson | a06e919 | 2018-03-07 18:49:55 +0100 | [diff] [blame] | 1024 | } |
| 1025 | |
Tommi | 38c5d93 | 2018-03-27 23:11:09 +0200 | [diff] [blame] | 1026 | stats.rtt_ms = call_stats_->LastProcessedRtt(); |
sprang | 9c0b551 | 2016-07-06 00:54:28 -0700 | [diff] [blame] | 1027 | { |
| 1028 | rtc::CritScope cs(&bitrate_crit_); |
| 1029 | stats.max_padding_bitrate_bps = configured_max_padding_bitrate_bps_; |
| 1030 | } |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1031 | return stats; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1032 | } |
| 1033 | |
Alex Narest | 78609d5 | 2017-10-20 10:37:47 +0200 | [diff] [blame] | 1034 | void Call::SetBitrateAllocationStrategy( |
| 1035 | std::unique_ptr<rtc::BitrateAllocationStrategy> |
| 1036 | bitrate_allocation_strategy) { |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 1037 | // TODO(srte): This function should be moved to RtpTransportControllerSend |
| 1038 | // when BitrateAllocator is moved there. |
| 1039 | struct Functor { |
| 1040 | void operator()() { |
| 1041 | bitrate_allocator_->SetBitrateAllocationStrategy( |
| 1042 | std::move(bitrate_allocation_strategy_)); |
| 1043 | } |
| 1044 | BitrateAllocator* bitrate_allocator_; |
| 1045 | std::unique_ptr<rtc::BitrateAllocationStrategy> |
| 1046 | bitrate_allocation_strategy_; |
| 1047 | }; |
| 1048 | transport_send_ptr_->GetWorkerQueue()->PostTask(Functor{ |
| 1049 | bitrate_allocator_.get(), std::move(bitrate_allocation_strategy)}); |
Alex Narest | 78609d5 | 2017-10-20 10:37:47 +0200 | [diff] [blame] | 1050 | } |
| 1051 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1052 | void Call::SignalChannelNetworkState(MediaType media, NetworkState state) { |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 1053 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1054 | switch (media) { |
| 1055 | case MediaType::AUDIO: |
| 1056 | audio_network_state_ = state; |
| 1057 | break; |
| 1058 | case MediaType::VIDEO: |
| 1059 | video_network_state_ = state; |
| 1060 | break; |
| 1061 | case MediaType::ANY: |
| 1062 | case MediaType::DATA: |
| 1063 | RTC_NOTREACHED(); |
| 1064 | break; |
| 1065 | } |
| 1066 | |
| 1067 | UpdateAggregateNetworkState(); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 1068 | { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1069 | ReadLockScoped read_lock(*send_crit_); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 1070 | for (auto& kv : audio_send_ssrcs_) { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1071 | kv.second->SignalNetworkState(audio_network_state_); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 1072 | } |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 1073 | } |
| 1074 | { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1075 | ReadLockScoped read_lock(*receive_crit_); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 1076 | for (AudioReceiveStream* audio_receive_stream : audio_receive_streams_) { |
| 1077 | audio_receive_stream->SignalNetworkState(audio_network_state_); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1078 | } |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 1079 | for (VideoReceiveStream* video_receive_stream : video_receive_streams_) { |
| 1080 | video_receive_stream->SignalNetworkState(video_network_state_); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 1081 | } |
| 1082 | } |
| 1083 | } |
| 1084 | |
Stefan Holmer | 64be7fa | 2018-10-04 15:21:55 +0200 | [diff] [blame] | 1085 | void Call::OnAudioTransportOverheadChanged(int transport_overhead_per_packet) { |
| 1086 | ReadLockScoped read_lock(*send_crit_); |
| 1087 | for (auto& kv : audio_send_ssrcs_) { |
| 1088 | kv.second->SetTransportOverhead(transport_overhead_per_packet); |
michaelt | 79e0588 | 2016-11-08 02:50:09 -0800 | [diff] [blame] | 1089 | } |
| 1090 | } |
| 1091 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1092 | void Call::UpdateAggregateNetworkState() { |
eladalon | f3f5c0e | 2017-08-18 02:47:08 -0700 | [diff] [blame] | 1093 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1094 | |
| 1095 | bool have_audio = false; |
| 1096 | bool have_video = false; |
| 1097 | { |
| 1098 | ReadLockScoped read_lock(*send_crit_); |
| 1099 | if (audio_send_ssrcs_.size() > 0) |
| 1100 | have_audio = true; |
| 1101 | if (video_send_ssrcs_.size() > 0) |
| 1102 | have_video = true; |
| 1103 | } |
| 1104 | { |
| 1105 | ReadLockScoped read_lock(*receive_crit_); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 1106 | if (audio_receive_streams_.size() > 0) |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1107 | have_audio = true; |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 1108 | if (video_receive_streams_.size() > 0) |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1109 | have_video = true; |
| 1110 | } |
| 1111 | |
Sebastian Jansson | a06e919 | 2018-03-07 18:49:55 +0100 | [diff] [blame] | 1112 | bool aggregate_network_up = |
| 1113 | ((have_video && video_network_state_ == kNetworkUp) || |
| 1114 | (have_audio && audio_network_state_ == kNetworkUp)); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1115 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1116 | RTC_LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state=" |
Sebastian Jansson | a06e919 | 2018-03-07 18:49:55 +0100 | [diff] [blame] | 1117 | << (aggregate_network_up ? "up" : "down"); |
| 1118 | { |
| 1119 | rtc::CritScope cs(&aggregate_network_up_crit_); |
| 1120 | aggregate_network_up_ = aggregate_network_up; |
| 1121 | } |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 1122 | transport_send_ptr_->OnNetworkAvailability(aggregate_network_up); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1123 | } |
| 1124 | |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 1125 | void Call::OnSentPacket(const rtc::SentPacket& sent_packet) { |
asapersson | 35151f3 | 2016-05-02 23:44:01 -0700 | [diff] [blame] | 1126 | video_send_delay_stats_->OnSentPacket(sent_packet.packet_id, |
| 1127 | clock_->TimeInMilliseconds()); |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 1128 | transport_send_ptr_->OnSentPacket(sent_packet); |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 1129 | } |
| 1130 | |
Sebastian Jansson | 2701bc9 | 2018-12-11 15:02:47 +0100 | [diff] [blame] | 1131 | void Call::OnStartRateUpdate(DataRate start_rate) { |
| 1132 | if (!transport_send_ptr_->GetWorkerQueue()->IsCurrent()) { |
| 1133 | transport_send_ptr_->GetWorkerQueue()->PostTask( |
| 1134 | [this, start_rate] { this->OnStartRateUpdate(start_rate); }); |
| 1135 | return; |
| 1136 | } |
| 1137 | bitrate_allocator_->UpdateStartRate(start_rate.bps<uint32_t>()); |
| 1138 | } |
| 1139 | |
Sebastian Jansson | 19704ec | 2018-03-12 15:59:12 +0100 | [diff] [blame] | 1140 | void Call::OnTargetTransferRate(TargetTransferRate msg) { |
Piotr (Peter) Slatala | cc8e8bb | 2018-11-15 08:26:19 -0800 | [diff] [blame] | 1141 | // TODO(bugs.webrtc.org/9719) |
| 1142 | // Call::OnTargetTransferRate requires that on target transfer rate is invoked |
| 1143 | // from the worker queue (because bitrate_allocator_ requires it). Media |
| 1144 | // transport does not guarantee the callback on the worker queue. |
| 1145 | // When the threading model for MediaTransportInterface is update, reconsider |
| 1146 | // changing this implementation. |
| 1147 | if (!transport_send_ptr_->GetWorkerQueue()->IsCurrent()) { |
| 1148 | transport_send_ptr_->GetWorkerQueue()->PostTask( |
| 1149 | [this, msg] { this->OnTargetTransferRate(msg); }); |
| 1150 | return; |
| 1151 | } |
| 1152 | |
Sebastian Jansson | 19704ec | 2018-03-12 15:59:12 +0100 | [diff] [blame] | 1153 | uint32_t target_bitrate_bps = msg.target_rate.bps(); |
| 1154 | int loss_ratio_255 = msg.network_estimate.loss_rate_ratio * 255; |
| 1155 | uint8_t fraction_loss = |
| 1156 | rtc::dchecked_cast<uint8_t>(rtc::SafeClamp(loss_ratio_255, 0, 255)); |
| 1157 | int64_t rtt_ms = msg.network_estimate.round_trip_time.ms(); |
| 1158 | int64_t probing_interval_ms = msg.network_estimate.bwe_period.ms(); |
| 1159 | uint32_t bandwidth_bps = msg.network_estimate.bandwidth.bps(); |
| 1160 | { |
| 1161 | rtc::CritScope cs(&last_bandwidth_bps_crit_); |
| 1162 | last_bandwidth_bps_ = bandwidth_bps; |
| 1163 | } |
nisse | 559af38 | 2017-03-21 06:41:12 -0700 | [diff] [blame] | 1164 | // For controlling the rate of feedback messages. |
| 1165 | receive_side_cc_.OnBitrateChanged(target_bitrate_bps); |
Sebastian Jansson | 89c94b9 | 2018-11-20 17:16:36 +0100 | [diff] [blame] | 1166 | bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, bandwidth_bps, |
| 1167 | fraction_loss, rtt_ms, |
| 1168 | probing_interval_ms); |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 1169 | |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 1170 | // Ignore updates if bitrate is zero (the aggregate network state is down). |
| 1171 | if (target_bitrate_bps == 0) { |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 1172 | rtc::CritScope lock(&bitrate_crit_); |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 1173 | estimated_send_bitrate_kbps_counter_.ProcessAndPause(); |
| 1174 | pacer_bitrate_kbps_counter_.ProcessAndPause(); |
| 1175 | return; |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 1176 | } |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 1177 | |
| 1178 | bool sending_video; |
| 1179 | { |
| 1180 | ReadLockScoped read_lock(*send_crit_); |
| 1181 | sending_video = !video_send_streams_.empty(); |
| 1182 | } |
| 1183 | |
| 1184 | rtc::CritScope lock(&bitrate_crit_); |
| 1185 | if (!sending_video) { |
| 1186 | // Do not update the stats if we are not sending video. |
| 1187 | estimated_send_bitrate_kbps_counter_.ProcessAndPause(); |
| 1188 | pacer_bitrate_kbps_counter_.ProcessAndPause(); |
| 1189 | return; |
| 1190 | } |
| 1191 | estimated_send_bitrate_kbps_counter_.Add(target_bitrate_bps / 1000); |
| 1192 | // Pacer bitrate may be higher than bitrate estimate if enforcing min bitrate. |
| 1193 | uint32_t pacer_bitrate_bps = |
| 1194 | std::max(target_bitrate_bps, min_allocated_send_bitrate_bps_); |
| 1195 | pacer_bitrate_kbps_counter_.Add(pacer_bitrate_bps / 1000); |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 1196 | } |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 1197 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 1198 | void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps, |
philipel | f69e768 | 2018-02-28 13:06:28 +0100 | [diff] [blame] | 1199 | uint32_t max_padding_bitrate_bps, |
Sebastian Jansson | 79f0d4d | 2019-01-23 09:41:43 +0100 | [diff] [blame] | 1200 | uint32_t total_bitrate_bps) { |
Sebastian Jansson | e625605 | 2018-05-04 14:08:15 +0200 | [diff] [blame] | 1201 | transport_send_ptr_->SetAllocatedSendBitrateLimits( |
Oleh Prypin | 04d4950 | 2018-03-19 13:29:42 +0000 | [diff] [blame] | 1202 | min_send_bitrate_bps, max_padding_bitrate_bps, total_bitrate_bps); |
Sebastian Jansson | 35fa280 | 2018-10-01 09:16:12 +0200 | [diff] [blame] | 1203 | |
Piotr (Peter) Slatala | 48c5493 | 2019-01-28 06:50:38 -0800 | [diff] [blame] | 1204 | { |
| 1205 | rtc::CritScope lock(&target_observer_crit_); |
| 1206 | if (media_transport_) { |
| 1207 | MediaTransportAllocatedBitrateLimits limits; |
| 1208 | limits.min_pacing_rate = DataRate::bps(min_send_bitrate_bps); |
| 1209 | limits.max_padding_bitrate = DataRate::bps(max_padding_bitrate_bps); |
| 1210 | limits.max_total_allocated_bitrate = DataRate::bps(total_bitrate_bps); |
| 1211 | media_transport_->SetAllocatedBitrateLimits(limits); |
| 1212 | } |
| 1213 | } |
| 1214 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 1215 | rtc::CritScope lock(&bitrate_crit_); |
| 1216 | min_allocated_send_bitrate_bps_ = min_send_bitrate_bps; |
sprang | 9c0b551 | 2016-07-06 00:54:28 -0700 | [diff] [blame] | 1217 | configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps; |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 1218 | } |
| 1219 | |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1220 | void Call::ConfigureSync(const std::string& sync_group) { |
| 1221 | // Set sync only if there was no previous one. |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 1222 | if (sync_group.empty()) |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1223 | return; |
| 1224 | |
| 1225 | AudioReceiveStream* sync_audio_stream = nullptr; |
| 1226 | // Find existing audio stream. |
| 1227 | const auto it = sync_stream_mapping_.find(sync_group); |
| 1228 | if (it != sync_stream_mapping_.end()) { |
| 1229 | sync_audio_stream = it->second; |
| 1230 | } else { |
| 1231 | // No configured audio stream, see if we can find one. |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 1232 | for (AudioReceiveStream* stream : audio_receive_streams_) { |
| 1233 | if (stream->config().sync_group == sync_group) { |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1234 | if (sync_audio_stream != nullptr) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1235 | RTC_LOG(LS_WARNING) |
| 1236 | << "Attempting to sync more than one audio stream " |
| 1237 | "within the same sync group. This is not " |
| 1238 | "supported in the current implementation."; |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1239 | break; |
| 1240 | } |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 1241 | sync_audio_stream = stream; |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1242 | } |
| 1243 | } |
| 1244 | } |
| 1245 | if (sync_audio_stream) |
| 1246 | sync_stream_mapping_[sync_group] = sync_audio_stream; |
| 1247 | size_t num_synced_streams = 0; |
| 1248 | for (VideoReceiveStream* video_stream : video_receive_streams_) { |
| 1249 | if (video_stream->config().sync_group != sync_group) |
| 1250 | continue; |
| 1251 | ++num_synced_streams; |
| 1252 | if (num_synced_streams > 1) { |
| 1253 | // TODO(pbos): Support synchronizing more than one A/V pair. |
| 1254 | // https://code.google.com/p/webrtc/issues/detail?id=4762 |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1255 | RTC_LOG(LS_WARNING) |
| 1256 | << "Attempting to sync more than one audio/video pair " |
| 1257 | "within the same sync group. This is not supported in " |
| 1258 | "the current implementation."; |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1259 | } |
| 1260 | // Only sync the first A/V pair within this sync group. |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 1261 | if (num_synced_streams == 1) { |
| 1262 | // sync_audio_stream may be null and that's ok. |
| 1263 | video_stream->SetSync(sync_audio_stream); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1264 | } else { |
solenberg | 3ebbcb5 | 2017-01-31 03:58:40 -0800 | [diff] [blame] | 1265 | video_stream->SetSync(nullptr); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1266 | } |
| 1267 | } |
| 1268 | } |
| 1269 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 1270 | PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type, |
| 1271 | const uint8_t* packet, |
| 1272 | size_t length) { |
Peter Boström | 6f28cf0 | 2015-12-07 23:17:15 +0100 | [diff] [blame] | 1273 | TRACE_EVENT0("webrtc", "Call::DeliverRtcp"); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 1274 | // TODO(pbos): Make sure it's a valid packet. |
pbos@webrtc.org | caba2d2 | 2014-05-14 13:57:12 +0000 | [diff] [blame] | 1275 | // Return DELIVERY_UNKNOWN_SSRC if it can be determined that |
| 1276 | // there's no receiver of the packet. |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 1277 | if (received_bytes_per_second_counter_.HasSample()) { |
| 1278 | // First RTP packet has been received. |
| 1279 | received_bytes_per_second_counter_.Add(static_cast<int>(length)); |
| 1280 | received_rtcp_bytes_per_second_counter_.Add(static_cast<int>(length)); |
| 1281 | } |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1282 | bool rtcp_delivered = false; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 1283 | if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 1284 | ReadLockScoped read_lock(*receive_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 1285 | for (VideoReceiveStream* stream : video_receive_streams_) { |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 1286 | if (stream->DeliverRtcp(packet, length)) |
pbos@webrtc.org | 4052370 | 2013-08-05 12:49:22 +0000 | [diff] [blame] | 1287 | rtcp_delivered = true; |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 1288 | } |
| 1289 | } |
| 1290 | if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { |
| 1291 | ReadLockScoped read_lock(*receive_crit_); |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 1292 | for (AudioReceiveStream* stream : audio_receive_streams_) { |
| 1293 | if (stream->DeliverRtcp(packet, length)) |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 1294 | rtcp_delivered = true; |
pbos@webrtc.org | bbb07e6 | 2013-08-05 12:01:36 +0000 | [diff] [blame] | 1295 | } |
| 1296 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 1297 | if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 1298 | ReadLockScoped read_lock(*send_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 1299 | for (VideoSendStream* stream : video_send_streams_) { |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 1300 | if (stream->DeliverRtcp(packet, length)) |
pbos@webrtc.org | 4052370 | 2013-08-05 12:49:22 +0000 | [diff] [blame] | 1301 | rtcp_delivered = true; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1302 | } |
| 1303 | } |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 1304 | if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { |
| 1305 | ReadLockScoped read_lock(*send_crit_); |
| 1306 | for (auto& kv : audio_send_ssrcs_) { |
| 1307 | if (kv.second->DeliverRtcp(packet, length)) |
| 1308 | rtcp_delivered = true; |
| 1309 | } |
| 1310 | } |
| 1311 | |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 1312 | if (rtcp_delivered) { |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 1313 | event_log_->Log(absl::make_unique<RtcEventRtcpPacketIncoming>( |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 1314 | rtc::MakeArrayView(packet, length))); |
| 1315 | } |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 1316 | |
pbos@webrtc.org | caba2d2 | 2014-05-14 13:57:12 +0000 | [diff] [blame] | 1317 | return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1318 | } |
| 1319 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 1320 | PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type, |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 1321 | rtc::CopyOnWriteBuffer packet, |
Niels Möller | 7008287 | 2018-08-07 11:03:12 +0200 | [diff] [blame] | 1322 | int64_t packet_time_us) { |
Peter Boström | 6f28cf0 | 2015-12-07 23:17:15 +0100 | [diff] [blame] | 1323 | TRACE_EVENT0("webrtc", "Call::DeliverRtp"); |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 1324 | |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1325 | RtpPacketReceived parsed_packet; |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 1326 | if (!parsed_packet.Parse(std::move(packet))) |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1327 | return DELIVERY_PACKET_ERROR; |
| 1328 | |
Niels Möller | 7008287 | 2018-08-07 11:03:12 +0200 | [diff] [blame] | 1329 | if (packet_time_us != -1) { |
Sebastian Jansson | b34556e | 2018-03-21 14:38:32 +0100 | [diff] [blame] | 1330 | if (receive_time_calculator_) { |
Christoffer Rodbro | 992a868 | 2018-10-30 15:14:36 +0100 | [diff] [blame] | 1331 | // Repair packet_time_us for clock resets by comparing a new read of |
| 1332 | // the same clock (TimeUTCMicros) to a monotonic clock reading. |
Niels Möller | 7008287 | 2018-08-07 11:03:12 +0200 | [diff] [blame] | 1333 | packet_time_us = receive_time_calculator_->ReconcileReceiveTimes( |
Christoffer Rodbro | 992a868 | 2018-10-30 15:14:36 +0100 | [diff] [blame] | 1334 | packet_time_us, rtc::TimeUTCMicros(), clock_->TimeInMicroseconds()); |
Sebastian Jansson | b34556e | 2018-03-21 14:38:32 +0100 | [diff] [blame] | 1335 | } |
Niels Möller | 7008287 | 2018-08-07 11:03:12 +0200 | [diff] [blame] | 1336 | parsed_packet.set_arrival_time_ms((packet_time_us + 500) / 1000); |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1337 | } else { |
| 1338 | parsed_packet.set_arrival_time_ms(clock_->TimeInMilliseconds()); |
| 1339 | } |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 1340 | |
sprang | c1abde7 | 2017-07-11 03:56:21 -0700 | [diff] [blame] | 1341 | // We might get RTP keep-alive packets in accordance with RFC6263 section 4.6. |
| 1342 | // These are empty (zero length payload) RTP packets with an unsignaled |
| 1343 | // payload type. |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1344 | const bool is_keep_alive_packet = parsed_packet.payload_size() == 0; |
sprang | c1abde7 | 2017-07-11 03:56:21 -0700 | [diff] [blame] | 1345 | |
| 1346 | RTC_DCHECK(media_type == MediaType::AUDIO || media_type == MediaType::VIDEO || |
| 1347 | is_keep_alive_packet); |
| 1348 | |
sprang | c1abde7 | 2017-07-11 03:56:21 -0700 | [diff] [blame] | 1349 | ReadLockScoped read_lock(*receive_crit_); |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1350 | auto it = receive_rtp_config_.find(parsed_packet.Ssrc()); |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 1351 | if (it == receive_rtp_config_.end()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1352 | RTC_LOG(LS_ERROR) << "receive_rtp_config_ lookup failed for ssrc " |
| 1353 | << parsed_packet.Ssrc(); |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 1354 | // Destruction of the receive stream, including deregistering from the |
| 1355 | // RtpDemuxer, is not protected by the |receive_crit_| lock. But |
| 1356 | // deregistering in the |receive_rtp_config_| map is protected by that lock. |
| 1357 | // So by not passing the packet on to demuxing in this case, we prevent |
| 1358 | // incoming packets to be passed on via the demuxer to a receive stream |
| 1359 | // which is being torned down. |
| 1360 | return DELIVERY_UNKNOWN_SSRC; |
| 1361 | } |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1362 | parsed_packet.IdentifyExtensions(it->second.extensions); |
nisse | 0f15f92 | 2017-06-21 01:05:22 -0700 | [diff] [blame] | 1363 | |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1364 | NotifyBweOfReceivedPacket(parsed_packet, media_type); |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 1365 | |
Danil Chapovalov | cbf5b73 | 2017-12-08 14:05:20 +0100 | [diff] [blame] | 1366 | // RateCounters expect input parameter as int, save it as int, |
| 1367 | // instead of converting each time it is passed to RateCounter::Add below. |
| 1368 | int length = static_cast<int>(parsed_packet.size()); |
nisse | e5ad5ca | 2017-03-29 23:57:43 -0700 | [diff] [blame] | 1369 | if (media_type == MediaType::AUDIO) { |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1370 | if (audio_receiver_controller_.OnRtpPacket(parsed_packet)) { |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 1371 | received_bytes_per_second_counter_.Add(length); |
| 1372 | received_audio_bytes_per_second_counter_.Add(length); |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 1373 | event_log_->Log( |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 1374 | absl::make_unique<RtcEventRtpPacketIncoming>(parsed_packet)); |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1375 | const int64_t arrival_time_ms = parsed_packet.arrival_time_ms(); |
saza | 0d7f04d | 2017-07-04 04:05:06 -0700 | [diff] [blame] | 1376 | if (!first_received_rtp_audio_ms_) { |
| 1377 | first_received_rtp_audio_ms_.emplace(arrival_time_ms); |
| 1378 | } |
| 1379 | last_received_rtp_audio_ms_.emplace(arrival_time_ms); |
nisse | 657bab2 | 2017-02-21 06:28:10 -0800 | [diff] [blame] | 1380 | return DELIVERY_OK; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 1381 | } |
nisse | e4bcd6d | 2017-05-16 04:47:04 -0700 | [diff] [blame] | 1382 | } else if (media_type == MediaType::VIDEO) { |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 1383 | parsed_packet.set_payload_type_frequency(kVideoPayloadTypeFrequency); |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1384 | if (video_receiver_controller_.OnRtpPacket(parsed_packet)) { |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 1385 | received_bytes_per_second_counter_.Add(length); |
| 1386 | received_video_bytes_per_second_counter_.Add(length); |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 1387 | event_log_->Log( |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 1388 | absl::make_unique<RtcEventRtpPacketIncoming>(parsed_packet)); |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1389 | const int64_t arrival_time_ms = parsed_packet.arrival_time_ms(); |
saza | 0d7f04d | 2017-07-04 04:05:06 -0700 | [diff] [blame] | 1390 | if (!first_received_rtp_video_ms_) { |
| 1391 | first_received_rtp_video_ms_.emplace(arrival_time_ms); |
| 1392 | } |
| 1393 | last_received_rtp_video_ms_.emplace(arrival_time_ms); |
nisse | 5c29a7a | 2017-02-16 06:52:32 -0800 | [diff] [blame] | 1394 | return DELIVERY_OK; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 1395 | } |
| 1396 | } |
| 1397 | return DELIVERY_UNKNOWN_SSRC; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1398 | } |
| 1399 | |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 1400 | PacketReceiver::DeliveryStatus Call::DeliverPacket( |
| 1401 | MediaType media_type, |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 1402 | rtc::CopyOnWriteBuffer packet, |
Niels Möller | 7008287 | 2018-08-07 11:03:12 +0200 | [diff] [blame] | 1403 | int64_t packet_time_us) { |
eladalon | d1dd2f7 | 2017-08-25 02:55:57 -0700 | [diff] [blame] | 1404 | RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 1405 | if (RtpHeaderParser::IsRtcp(packet.cdata(), packet.size())) |
| 1406 | return DeliverRtcp(media_type, packet.cdata(), packet.size()); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1407 | |
Niels Möller | 7008287 | 2018-08-07 11:03:12 +0200 | [diff] [blame] | 1408 | return DeliverRtp(media_type, std::move(packet), packet_time_us); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1409 | } |
| 1410 | |
nisse | d2ef314 | 2017-05-11 08:00:58 -0700 | [diff] [blame] | 1411 | void Call::OnRecoveredPacket(const uint8_t* packet, size_t length) { |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1412 | RtpPacketReceived parsed_packet; |
| 1413 | if (!parsed_packet.Parse(packet, length)) |
nisse | d2ef314 | 2017-05-11 08:00:58 -0700 | [diff] [blame] | 1414 | return; |
| 1415 | |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1416 | parsed_packet.set_recovered(true); |
nisse | d2ef314 | 2017-05-11 08:00:58 -0700 | [diff] [blame] | 1417 | |
brandtr | caea68f | 2017-08-23 00:55:17 -0700 | [diff] [blame] | 1418 | ReadLockScoped read_lock(*receive_crit_); |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1419 | auto it = receive_rtp_config_.find(parsed_packet.Ssrc()); |
brandtr | caea68f | 2017-08-23 00:55:17 -0700 | [diff] [blame] | 1420 | if (it == receive_rtp_config_.end()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1421 | RTC_LOG(LS_ERROR) << "receive_rtp_config_ lookup failed for ssrc " |
| 1422 | << parsed_packet.Ssrc(); |
brandtr | caea68f | 2017-08-23 00:55:17 -0700 | [diff] [blame] | 1423 | // Destruction of the receive stream, including deregistering from the |
| 1424 | // RtpDemuxer, is not protected by the |receive_crit_| lock. But |
| 1425 | // deregistering in the |receive_rtp_config_| map is protected by that lock. |
| 1426 | // So by not passing the packet on to demuxing in this case, we prevent |
| 1427 | // incoming packets to be passed on via the demuxer to a receive stream |
Erik Språng | 0970851 | 2018-03-14 15:16:50 +0100 | [diff] [blame] | 1428 | // which is being torn down. |
brandtr | caea68f | 2017-08-23 00:55:17 -0700 | [diff] [blame] | 1429 | return; |
| 1430 | } |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1431 | parsed_packet.IdentifyExtensions(it->second.extensions); |
brandtr | caea68f | 2017-08-23 00:55:17 -0700 | [diff] [blame] | 1432 | |
| 1433 | // TODO(brandtr): Update here when we support protecting audio packets too. |
Niels Möller | 2ff1f2a | 2018-08-09 16:16:34 +0200 | [diff] [blame] | 1434 | parsed_packet.set_payload_type_frequency(kVideoPayloadTypeFrequency); |
Danil Chapovalov | b709cf8 | 2017-10-04 14:01:45 +0200 | [diff] [blame] | 1435 | video_receiver_controller_.OnRtpPacket(parsed_packet); |
brandtr | 4e52386 | 2016-10-18 23:50:45 -0700 | [diff] [blame] | 1436 | } |
| 1437 | |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 1438 | void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet, |
| 1439 | MediaType media_type) { |
| 1440 | auto it = receive_rtp_config_.find(packet.Ssrc()); |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 1441 | bool use_send_side_bwe = |
| 1442 | (it != receive_rtp_config_.end()) && it->second.use_send_side_bwe; |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 1443 | |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 1444 | RTPHeader header; |
| 1445 | packet.GetHeader(&header); |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 1446 | |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 1447 | if (!use_send_side_bwe && header.extension.hasTransportSequenceNumber) { |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 1448 | // Inconsistent configuration of send side BWE. Do nothing. |
| 1449 | // TODO(nisse): Without this check, we may produce RTCP feedback |
| 1450 | // packets even when not negotiated. But it would be cleaner to |
| 1451 | // move the check down to RTCPSender::SendFeedbackPacket, which |
| 1452 | // would also help the PacketRouter to select an appropriate rtp |
| 1453 | // module in the case that some, but not all, have RTCP feedback |
| 1454 | // enabled. |
| 1455 | return; |
| 1456 | } |
| 1457 | // For audio, we only support send side BWE. |
nisse | e5ad5ca | 2017-03-29 23:57:43 -0700 | [diff] [blame] | 1458 | if (media_type == MediaType::VIDEO || |
nisse | 4709e89 | 2017-02-07 01:18:43 -0800 | [diff] [blame] | 1459 | (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) { |
nisse | 559af38 | 2017-03-21 06:41:12 -0700 | [diff] [blame] | 1460 | receive_side_cc_.OnReceivedPacket( |
nisse | d44ce05 | 2017-02-06 02:23:00 -0800 | [diff] [blame] | 1461 | packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(), |
| 1462 | header); |
| 1463 | } |
brandtr | b29e652 | 2016-12-21 06:37:18 -0800 | [diff] [blame] | 1464 | } |
| 1465 | |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1466 | } // namespace internal |
nisse | b8f9a32 | 2017-03-27 05:36:15 -0700 | [diff] [blame] | 1467 | |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1468 | } // namespace webrtc |