blob: 16ee1cde7814dd064da156ddb6ae2a3a5216fd72 [file] [log] [blame]
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001/*
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.org12dc1a32013-08-05 16:22:53 +000011#include <string.h>
mflodman101f2502016-06-09 17:21:19 +020012#include <algorithm>
pbos@webrtc.org29d58392013-05-16 12:08:03 +000013#include <map>
kwibergb25345e2016-03-12 06:10:44 -080014#include <memory>
ossuf515ab82016-12-07 04:52:58 -080015#include <set>
brandtr25445d32016-10-23 23:37:14 -070016#include <utility>
pbos@webrtc.org29d58392013-05-16 12:08:03 +000017#include <vector>
18
Peter Boström5c389d32015-09-25 13:58:30 +020019#include "webrtc/audio/audio_receive_stream.h"
solenbergc7a8b082015-10-16 14:35:07 -070020#include "webrtc/audio/audio_send_stream.h"
solenberg566ef242015-11-06 15:34:49 -080021#include "webrtc/audio/audio_state.h"
22#include "webrtc/audio/scoped_voe_interface.h"
sazac58f8c02017-07-19 00:39:19 -070023#include "webrtc/audio/time_interval.h"
mflodman0e7e2592015-11-12 21:02:42 -080024#include "webrtc/call/bitrate_allocator.h"
ossuf515ab82016-12-07 04:52:58 -080025#include "webrtc/call/call.h"
brandtr7250b392016-12-19 01:13:46 -080026#include "webrtc/call/flexfec_receive_stream_impl.h"
nisse0f15f922017-06-21 01:05:22 -070027#include "webrtc/call/rtp_stream_receiver_controller.h"
nisseb8f9a322017-03-27 05:36:15 -070028#include "webrtc/call/rtp_transport_controller_send.h"
pbos@webrtc.orgc49d5b72013-12-05 12:11:47 +000029#include "webrtc/config.h"
skvladcc91d282016-10-03 18:31:22 -070030#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
mflodman0e7e2592015-11-12 21:02:42 -080031#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
nisse559af382017-03-21 06:41:12 -070032#include "webrtc/modules/congestion_controller/include/receive_side_congestion_controller.h"
brandtr4e523862016-10-18 23:50:45 -070033#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
Danil Chapovalov84b4d2c2017-06-12 15:05:44 +020034#include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h"
Henrik Kjellanderff761fb2015-11-04 08:31:52 +010035#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
sprang@webrtc.org2a6558c2015-01-28 12:37:36 +000036#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
brandtrb29e6522016-12-21 06:37:18 -080037#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
Henrik Kjellanderff761fb2015-11-04 08:31:52 +010038#include "webrtc/modules/utility/include/process_thread.h"
Edward Lemurc20978e2017-07-06 19:44:34 +020039#include "webrtc/rtc_base/basictypes.h"
40#include "webrtc/rtc_base/checks.h"
41#include "webrtc/rtc_base/constructormagic.h"
42#include "webrtc/rtc_base/location.h"
43#include "webrtc/rtc_base/logging.h"
44#include "webrtc/rtc_base/optional.h"
45#include "webrtc/rtc_base/ptr_util.h"
eladalonf3f5c0e2017-08-18 02:47:08 -070046#include "webrtc/rtc_base/sequenced_task_checker.h"
Edward Lemurc20978e2017-07-06 19:44:34 +020047#include "webrtc/rtc_base/task_queue.h"
48#include "webrtc/rtc_base/thread_annotations.h"
Edward Lemurc20978e2017-07-06 19:44:34 +020049#include "webrtc/rtc_base/trace_event.h"
ivoc14d5dbe2016-07-04 07:06:55 -070050#include "webrtc/system_wrappers/include/clock.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010051#include "webrtc/system_wrappers/include/cpu_info.h"
stefan91d92602015-11-11 10:13:02 -080052#include "webrtc/system_wrappers/include/metrics.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010053#include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
54#include "webrtc/system_wrappers/include/trace.h"
Peter Boström7623ce42015-12-09 12:13:30 +010055#include "webrtc/video/call_stats.h"
asapersson35151f32016-05-02 23:44:01 -070056#include "webrtc/video/send_delay_stats.h"
asapersson250fd972016-09-08 00:07:21 -070057#include "webrtc/video/stats_counter.h"
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000058#include "webrtc/video/video_receive_stream.h"
59#include "webrtc/video/video_send_stream.h"
pbos@webrtc.org29d58392013-05-16 12:08:03 +000060
61namespace webrtc {
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +000062
nisse4709e892017-02-07 01:18:43 -080063namespace {
64
65// TODO(nisse): This really begs for a shared context struct.
66bool UseSendSideBwe(const std::vector<RtpExtension>& extensions,
67 bool transport_cc) {
68 if (!transport_cc)
69 return false;
70 for (const auto& extension : extensions) {
71 if (extension.uri == RtpExtension::kTransportSequenceNumberUri)
72 return true;
73 }
74 return false;
75}
76
77bool UseSendSideBwe(const VideoReceiveStream::Config& config) {
78 return UseSendSideBwe(config.rtp.extensions, config.rtp.transport_cc);
79}
80
81bool UseSendSideBwe(const AudioReceiveStream::Config& config) {
82 return UseSendSideBwe(config.rtp.extensions, config.rtp.transport_cc);
83}
84
85bool UseSendSideBwe(const FlexfecReceiveStream::Config& config) {
86 return UseSendSideBwe(config.rtp_header_extensions, config.transport_cc);
87}
88
perkj09e71da2017-05-22 03:26:49 -070089rtclog::StreamConfig CreateRtcLogStreamConfig(
90 const VideoReceiveStream::Config& config) {
91 rtclog::StreamConfig rtclog_config;
92 rtclog_config.remote_ssrc = config.rtp.remote_ssrc;
93 rtclog_config.local_ssrc = config.rtp.local_ssrc;
94 rtclog_config.rtx_ssrc = config.rtp.rtx_ssrc;
95 rtclog_config.rtcp_mode = config.rtp.rtcp_mode;
96 rtclog_config.remb = config.rtp.remb;
97 rtclog_config.rtp_extensions = config.rtp.extensions;
98
99 for (const auto& d : config.decoders) {
100 auto search = config.rtp.rtx_payload_types.find(d.payload_type);
101 rtclog_config.codecs.emplace_back(
102 d.payload_name, d.payload_type,
103 search != config.rtp.rtx_payload_types.end() ? search->second : 0);
104 }
105 return rtclog_config;
106}
107
perkjc0876aa2017-05-22 04:08:28 -0700108rtclog::StreamConfig CreateRtcLogStreamConfig(
109 const VideoSendStream::Config& config,
110 size_t ssrc_index) {
111 rtclog::StreamConfig rtclog_config;
112 rtclog_config.local_ssrc = config.rtp.ssrcs[ssrc_index];
113 if (ssrc_index < config.rtp.rtx.ssrcs.size()) {
114 rtclog_config.rtx_ssrc = config.rtp.rtx.ssrcs[ssrc_index];
115 }
116 rtclog_config.rtcp_mode = config.rtp.rtcp_mode;
117 rtclog_config.rtp_extensions = config.rtp.extensions;
118
119 rtclog_config.codecs.emplace_back(config.encoder_settings.payload_name,
120 config.encoder_settings.payload_type,
121 config.rtp.rtx.payload_type);
122 return rtclog_config;
123}
124
perkjac8f52d2017-05-22 09:36:28 -0700125rtclog::StreamConfig CreateRtcLogStreamConfig(
126 const AudioReceiveStream::Config& config) {
127 rtclog::StreamConfig rtclog_config;
128 rtclog_config.remote_ssrc = config.rtp.remote_ssrc;
129 rtclog_config.local_ssrc = config.rtp.local_ssrc;
130 rtclog_config.rtp_extensions = config.rtp.extensions;
131 return rtclog_config;
132}
133
perkjf4726992017-05-22 10:12:26 -0700134rtclog::StreamConfig CreateRtcLogStreamConfig(
135 const AudioSendStream::Config& config) {
136 rtclog::StreamConfig rtclog_config;
137 rtclog_config.local_ssrc = config.rtp.ssrc;
138 rtclog_config.rtp_extensions = config.rtp.extensions;
139 if (config.send_codec_spec) {
140 rtclog_config.codecs.emplace_back(config.send_codec_spec->format.name,
141 config.send_codec_spec->payload_type, 0);
142 }
143 return rtclog_config;
144}
145
nisse4709e892017-02-07 01:18:43 -0800146} // namespace
147
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000148namespace internal {
asapersson@webrtc.orgbdc5ed22014-01-31 10:05:07 +0000149
perkjec81bcd2016-05-11 06:01:13 -0700150class Call : public webrtc::Call,
151 public PacketReceiver,
brandtr4e523862016-10-18 23:50:45 -0700152 public RecoveredPacketReceiver,
nisse559af382017-03-21 06:41:12 -0700153 public SendSideCongestionController::Observer,
perkj71ee44c2016-06-15 00:47:53 -0700154 public BitrateAllocator::LimitObserver {
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000155 public:
nisseb8f9a322017-03-27 05:36:15 -0700156 Call(const Call::Config& config,
zstein7cb69d52017-05-08 11:52:38 -0700157 std::unique_ptr<RtpTransportControllerSendInterface> transport_send);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000158 virtual ~Call();
159
brandtr25445d32016-10-23 23:37:14 -0700160 // Implements webrtc::Call.
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000161 PacketReceiver* Receiver() override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000162
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200163 webrtc::AudioSendStream* CreateAudioSendStream(
164 const webrtc::AudioSendStream::Config& config) override;
165 void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override;
166
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200167 webrtc::AudioReceiveStream* CreateAudioReceiveStream(
168 const webrtc::AudioReceiveStream::Config& config) override;
169 void DestroyAudioReceiveStream(
170 webrtc::AudioReceiveStream* receive_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000171
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200172 webrtc::VideoSendStream* CreateVideoSendStream(
perkj26091b12016-09-01 01:17:40 -0700173 webrtc::VideoSendStream::Config config,
174 VideoEncoderConfig encoder_config) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000175 void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000176
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200177 webrtc::VideoReceiveStream* CreateVideoReceiveStream(
Tommi733b5472016-06-10 17:58:01 +0200178 webrtc::VideoReceiveStream::Config configuration) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000179 void DestroyVideoReceiveStream(
180 webrtc::VideoReceiveStream* receive_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000181
brandtr7250b392016-12-19 01:13:46 -0800182 FlexfecReceiveStream* CreateFlexfecReceiveStream(
183 const FlexfecReceiveStream::Config& config) override;
brandtr25445d32016-10-23 23:37:14 -0700184 void DestroyFlexfecReceiveStream(
brandtr7250b392016-12-19 01:13:46 -0800185 FlexfecReceiveStream* receive_stream) override;
brandtr25445d32016-10-23 23:37:14 -0700186
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000187 Stats GetStats() const override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000188
brandtr25445d32016-10-23 23:37:14 -0700189 // Implements PacketReceiver.
stefan68786d22015-09-08 05:36:15 -0700190 DeliveryStatus DeliverPacket(MediaType media_type,
191 const uint8_t* packet,
192 size_t length,
193 const PacketTime& packet_time) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000194
brandtr4e523862016-10-18 23:50:45 -0700195 // Implements RecoveredPacketReceiver.
nissed2ef3142017-05-11 08:00:58 -0700196 void OnRecoveredPacket(const uint8_t* packet, size_t length) override;
brandtr4e523862016-10-18 23:50:45 -0700197
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000198 void SetBitrateConfig(
199 const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
skvlad7a43d252016-03-22 15:32:27 -0700200
zstein4b979802017-06-02 14:37:37 -0700201 void SetBitrateConfigMask(
202 const webrtc::Call::Config::BitrateConfigMask& bitrate_config) override;
203
skvlad7a43d252016-03-22 15:32:27 -0700204 void SignalChannelNetworkState(MediaType media, NetworkState state) override;
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000205
michaelt79e05882016-11-08 02:50:09 -0800206 void OnTransportOverheadChanged(MediaType media,
207 int transport_overhead_per_packet) override;
208
Honghai Zhang0e533ef2016-04-19 15:41:36 -0700209 void OnNetworkRouteChanged(const std::string& transport_name,
210 const rtc::NetworkRoute& network_route) override;
211
stefanc1aeaf02015-10-15 07:26:07 -0700212 void OnSentPacket(const rtc::SentPacket& sent_packet) override;
213
mflodman0e7e2592015-11-12 21:02:42 -0800214 // Implements BitrateObserver.
minyue78b4d562016-11-30 04:47:39 -0800215 void OnNetworkChanged(uint32_t bitrate_bps,
216 uint8_t fraction_loss,
217 int64_t rtt_ms,
218 int64_t probing_interval_ms) override;
mflodman0e7e2592015-11-12 21:02:42 -0800219
perkj71ee44c2016-06-15 00:47:53 -0700220 // Implements BitrateAllocator::LimitObserver.
221 void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
222 uint32_t max_padding_bitrate_bps) override;
223
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000224 private:
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200225 DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet,
226 size_t length);
stefan68786d22015-09-08 05:36:15 -0700227 DeliveryStatus DeliverRtp(MediaType media_type,
228 const uint8_t* packet,
229 size_t length,
230 const PacketTime& packet_time);
pbos8fc7fa72015-07-15 08:02:58 -0700231 void ConfigureSync(const std::string& sync_group)
232 EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
233
nissed44ce052017-02-06 02:23:00 -0800234 void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
235 MediaType media_type)
236 SHARED_LOCKS_REQUIRED(receive_crit_);
237
sprangc1abde72017-07-11 03:56:21 -0700238 rtc::Optional<RtpPacketReceived> ParseRtpPacket(
239 const uint8_t* packet,
240 size_t length,
241 const PacketTime* packet_time) const;
brandtrb29e6522016-12-21 06:37:18 -0800242
asaperssonfc5e81c2017-04-19 23:28:53 -0700243 void UpdateSendHistograms(int64_t first_sent_packet_ms)
244 EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
stefan18adf0a2015-11-17 06:24:56 -0800245 void UpdateReceiveHistograms();
asapersson4374a092016-07-27 00:39:09 -0700246 void UpdateHistograms();
skvlad7a43d252016-03-22 15:32:27 -0700247 void UpdateAggregateNetworkState();
stefan91d92602015-11-11 10:13:02 -0800248
zstein4b979802017-06-02 14:37:37 -0700249 // Applies update to the BitrateConfig cached in |config_|, restarting
250 // bandwidth estimation from |new_start| if set.
251 void UpdateCurrentBitrateConfig(const rtc::Optional<int>& new_start);
252
Peter Boströmd3c94472015-12-09 11:20:58 +0100253 Clock* const clock_;
stefan91d92602015-11-11 10:13:02 -0800254
Peter Boström45553ae2015-05-08 13:54:38 +0200255 const int num_cpu_cores_;
kwibergb25345e2016-03-12 06:10:44 -0800256 const std::unique_ptr<ProcessThread> module_process_thread_;
nisseb9359842017-01-19 05:41:25 -0800257 const std::unique_ptr<ProcessThread> pacer_thread_;
kwibergb25345e2016-03-12 06:10:44 -0800258 const std::unique_ptr<CallStats> call_stats_;
259 const std::unique_ptr<BitrateAllocator> bitrate_allocator_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000260 Call::Config config_;
eladalonf3f5c0e2017-08-18 02:47:08 -0700261 rtc::SequencedTaskChecker configuration_sequence_checker_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000262
skvlad7a43d252016-03-22 15:32:27 -0700263 NetworkState audio_network_state_;
264 NetworkState video_network_state_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000265
kwibergb25345e2016-03-12 06:10:44 -0800266 std::unique_ptr<RWLockWrapper> receive_crit_;
brandtr25445d32016-10-23 23:37:14 -0700267 // Audio, Video, and FlexFEC receive streams are owned by the client that
268 // creates them.
nissee4bcd6d2017-05-16 04:47:04 -0700269 std::set<AudioReceiveStream*> audio_receive_streams_
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200270 GUARDED_BY(receive_crit_);
271 std::set<VideoReceiveStream*> video_receive_streams_
272 GUARDED_BY(receive_crit_);
nissee4bcd6d2017-05-16 04:47:04 -0700273
pbos8fc7fa72015-07-15 08:02:58 -0700274 std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
275 GUARDED_BY(receive_crit_);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000276
nisse0f15f922017-06-21 01:05:22 -0700277 // TODO(nisse): Should eventually be injected at creation,
278 // with a single object in the bundled case.
eladalon2a2b2972017-07-03 09:25:27 -0700279 RtpStreamReceiverController audio_receiver_controller_;
280 RtpStreamReceiverController video_receiver_controller_;
nissee4bcd6d2017-05-16 04:47:04 -0700281
nissed44ce052017-02-06 02:23:00 -0800282 // This extra map is used for receive processing which is
283 // independent of media type.
284
285 // TODO(nisse): In the RTP transport refactoring, we should have a
286 // single mapping from ssrc to a more abstract receive stream, with
287 // accessor methods for all configuration we need at this level.
288 struct ReceiveRtpConfig {
289 ReceiveRtpConfig() = default; // Needed by std::map
290 ReceiveRtpConfig(const std::vector<RtpExtension>& extensions,
nisse4709e892017-02-07 01:18:43 -0800291 bool use_send_side_bwe)
292 : extensions(extensions), use_send_side_bwe(use_send_side_bwe) {}
nissed44ce052017-02-06 02:23:00 -0800293
294 // Registered RTP header extensions for each stream. Note that RTP header
295 // extensions are negotiated per track ("m= line") in the SDP, but we have
296 // no notion of tracks at the Call level. We therefore store the RTP header
297 // extensions per SSRC instead, which leads to some storage overhead.
298 RtpHeaderExtensionMap extensions;
nisse4709e892017-02-07 01:18:43 -0800299 // Set if both RTP extension the RTCP feedback message needed for
300 // send side BWE are negotiated.
301 bool use_send_side_bwe = false;
nissed44ce052017-02-06 02:23:00 -0800302 };
303 std::map<uint32_t, ReceiveRtpConfig> receive_rtp_config_
brandtrb29e6522016-12-21 06:37:18 -0800304 GUARDED_BY(receive_crit_);
305
kwibergb25345e2016-03-12 06:10:44 -0800306 std::unique_ptr<RWLockWrapper> send_crit_;
solenbergc7a8b082015-10-16 14:35:07 -0700307 // Audio and Video send streams are owned by the client that creates them.
308 std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200309 std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
310 std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000311
ossuc3d4b482017-05-23 06:07:11 -0700312 using RtpStateMap = std::map<uint32_t, RtpState>;
313 RtpStateMap suspended_audio_send_ssrcs_
eladalonf3f5c0e2017-08-18 02:47:08 -0700314 GUARDED_BY(configuration_sequence_checker_);
ossuc3d4b482017-05-23 06:07:11 -0700315 RtpStateMap suspended_video_send_ssrcs_
eladalonf3f5c0e2017-08-18 02:47:08 -0700316 GUARDED_BY(configuration_sequence_checker_);
ossuc3d4b482017-05-23 06:07:11 -0700317
skvlad11a9cbf2016-10-07 11:53:05 -0700318 webrtc::RtcEventLog* event_log_;
ivocb04965c2015-09-09 00:09:43 -0700319
stefan18adf0a2015-11-17 06:24:56 -0800320 // The following members are only accessed (exclusively) from one thread and
321 // from the destructor, and therefore doesn't need any explicit
322 // synchronization.
asapersson250fd972016-09-08 00:07:21 -0700323 RateCounter received_bytes_per_second_counter_;
324 RateCounter received_audio_bytes_per_second_counter_;
325 RateCounter received_video_bytes_per_second_counter_;
326 RateCounter received_rtcp_bytes_per_second_counter_;
saza0d7f04d2017-07-04 04:05:06 -0700327 rtc::Optional<int64_t> first_received_rtp_audio_ms_;
328 rtc::Optional<int64_t> last_received_rtp_audio_ms_;
329 rtc::Optional<int64_t> first_received_rtp_video_ms_;
330 rtc::Optional<int64_t> last_received_rtp_video_ms_;
sazac58f8c02017-07-19 00:39:19 -0700331 TimeInterval sent_rtp_audio_timer_ms_;
stefan91d92602015-11-11 10:13:02 -0800332
stefan18adf0a2015-11-17 06:24:56 -0800333 // TODO(holmer): Remove this lock once BitrateController no longer calls
334 // OnNetworkChanged from multiple threads.
335 rtc::CriticalSection bitrate_crit_;
perkj71ee44c2016-06-15 00:47:53 -0700336 uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
sprang9c0b5512016-07-06 00:54:28 -0700337 uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
asaperssonce2e1362016-09-09 00:13:35 -0700338 AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
339 AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
stefan18adf0a2015-11-17 06:24:56 -0800340
Honghai Zhang0e533ef2016-04-19 15:41:36 -0700341 std::map<std::string, rtc::NetworkRoute> network_routes_;
342
nisse6167b262017-04-06 06:34:25 -0700343 std::unique_ptr<RtpTransportControllerSendInterface> transport_send_;
nisse559af382017-03-21 06:41:12 -0700344 ReceiveSideCongestionController receive_side_cc_;
asapersson35151f32016-05-02 23:44:01 -0700345 const std::unique_ptr<SendDelayStats> video_send_delay_stats_;
asapersson4374a092016-07-27 00:39:09 -0700346 const int64_t start_ms_;
perkj26091b12016-09-01 01:17:40 -0700347 // TODO(perkj): |worker_queue_| is supposed to replace
348 // |module_process_thread_|.
349 // |worker_queue| is defined last to ensure all pending tasks are cancelled
350 // and deleted before any other members.
351 rtc::TaskQueue worker_queue_;
mflodman0e7e2592015-11-12 21:02:42 -0800352
zstein4b979802017-06-02 14:37:37 -0700353 // The config mask set by SetBitrateConfigMask.
354 // 0 <= min <= start <= max
355 Config::BitrateConfigMask bitrate_config_mask_;
356
357 // The config set by SetBitrateConfig.
358 // min >= 0, start != 0, max == -1 || max > 0
359 Config::BitrateConfig base_bitrate_config_;
360
henrikg3c089d72015-09-16 05:37:44 -0700361 RTC_DISALLOW_COPY_AND_ASSIGN(Call);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000362};
pbos@webrtc.orgc49d5b72013-12-05 12:11:47 +0000363} // namespace internal
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000364
asapersson2e5cfcd2016-08-11 08:41:18 -0700365std::string Call::Stats::ToString(int64_t time_ms) const {
366 std::stringstream ss;
367 ss << "Call stats: " << time_ms << ", {";
368 ss << "send_bw_bps: " << send_bandwidth_bps << ", ";
369 ss << "recv_bw_bps: " << recv_bandwidth_bps << ", ";
370 ss << "max_pad_bps: " << max_padding_bitrate_bps << ", ";
371 ss << "pacer_delay_ms: " << pacer_delay_ms << ", ";
372 ss << "rtt_ms: " << rtt_ms;
373 ss << '}';
374 return ss.str();
375}
376
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000377Call* Call::Create(const Call::Config& config) {
zstein7cb69d52017-05-08 11:52:38 -0700378 return new internal::Call(config,
379 rtc::MakeUnique<RtpTransportControllerSend>(
380 Clock::GetRealTimeClock(), config.event_log));
381}
382
383Call* Call::Create(
384 const Call::Config& config,
385 std::unique_ptr<RtpTransportControllerSendInterface> transport_send) {
386 return new internal::Call(config, std::move(transport_send));
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000387}
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000388
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000389namespace internal {
390
nisseb8f9a322017-03-27 05:36:15 -0700391Call::Call(const Call::Config& config,
zstein7cb69d52017-05-08 11:52:38 -0700392 std::unique_ptr<RtpTransportControllerSendInterface> transport_send)
stefan91d92602015-11-11 10:13:02 -0800393 : clock_(Clock::GetRealTimeClock()),
394 num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
kwiberg1c7fdd82016-04-26 08:18:04 -0700395 module_process_thread_(ProcessThread::Create("ModuleProcessThread")),
nisseb9359842017-01-19 05:41:25 -0800396 pacer_thread_(ProcessThread::Create("PacerThread")),
Peter Boströmd3c94472015-12-09 11:20:58 +0100397 call_stats_(new CallStats(clock_)),
perkj71ee44c2016-06-15 00:47:53 -0700398 bitrate_allocator_(new BitrateAllocator(this)),
Peter Boström45553ae2015-05-08 13:54:38 +0200399 config_(config),
Sergey Ulanove2b15012016-11-22 16:08:30 -0800400 audio_network_state_(kNetworkDown),
401 video_network_state_(kNetworkDown),
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000402 receive_crit_(RWLockWrapper::CreateRWLock()),
stefan91d92602015-11-11 10:13:02 -0800403 send_crit_(RWLockWrapper::CreateRWLock()),
skvlad11a9cbf2016-10-07 11:53:05 -0700404 event_log_(config.event_log),
asapersson250fd972016-09-08 00:07:21 -0700405 received_bytes_per_second_counter_(clock_, nullptr, true),
406 received_audio_bytes_per_second_counter_(clock_, nullptr, true),
407 received_video_bytes_per_second_counter_(clock_, nullptr, true),
408 received_rtcp_bytes_per_second_counter_(clock_, nullptr, true),
perkj71ee44c2016-06-15 00:47:53 -0700409 min_allocated_send_bitrate_bps_(0),
sprang9c0b5512016-07-06 00:54:28 -0700410 configured_max_padding_bitrate_bps_(0),
asaperssonce2e1362016-09-09 00:13:35 -0700411 estimated_send_bitrate_kbps_counter_(clock_, nullptr, true),
412 pacer_bitrate_kbps_counter_(clock_, nullptr, true),
nisse05843312017-04-18 23:38:35 -0700413 receive_side_cc_(clock_, transport_send->packet_router()),
asapersson4374a092016-07-27 00:39:09 -0700414 video_send_delay_stats_(new SendDelayStats(clock_)),
perkj26091b12016-09-01 01:17:40 -0700415 start_ms_(clock_->TimeInMilliseconds()),
zstein4b979802017-06-02 14:37:37 -0700416 worker_queue_("call_worker_queue"),
417 base_bitrate_config_(config.bitrate_config) {
skvlad11a9cbf2016-10-07 11:53:05 -0700418 RTC_DCHECK(config.event_log != nullptr);
henrikg91d6ede2015-09-17 00:24:34 -0700419 RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
stefanfca900a2017-04-10 03:53:00 -0700420 RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps,
henrikg91d6ede2015-09-17 00:24:34 -0700421 config.bitrate_config.min_bitrate_bps);
Stefan Holmere5904162015-03-26 11:11:06 +0100422 if (config.bitrate_config.max_bitrate_bps != -1) {
henrikg91d6ede2015-09-17 00:24:34 -0700423 RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
424 config.bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000425 }
Peter Boström45553ae2015-05-08 13:54:38 +0200426 Trace::CreateTrace();
zstein7cb69d52017-05-08 11:52:38 -0700427 transport_send->send_side_cc()->RegisterNetworkObserver(this);
nisse6167b262017-04-06 06:34:25 -0700428 transport_send_ = std::move(transport_send);
nisseb8f9a322017-03-27 05:36:15 -0700429 transport_send_->send_side_cc()->SignalNetworkState(kNetworkDown);
430 transport_send_->send_side_cc()->SetBweBitrates(
431 config_.bitrate_config.min_bitrate_bps,
432 config_.bitrate_config.start_bitrate_bps,
433 config_.bitrate_config.max_bitrate_bps);
nissebcbaf742017-03-28 01:16:25 -0700434 call_stats_->RegisterStatsObserver(&receive_side_cc_);
nisseb8f9a322017-03-27 05:36:15 -0700435 call_stats_->RegisterStatsObserver(transport_send_->send_side_cc());
Stefan Holmerc379fcb2016-02-24 16:02:55 +0100436
stefan9e117c5e12017-08-16 08:16:25 -0700437 // We have to attach the pacer to the pacer thread before starting the
438 // module process thread to avoid a race accessing the process thread
439 // both from the process thread and the pacer thread.
Stefan Holmer5c8942a2017-08-22 16:16:44 +0200440 pacer_thread_->RegisterModule(transport_send_->pacer(), RTC_FROM_HERE);
stefan64136af2017-08-14 08:03:17 -0700441 pacer_thread_->RegisterModule(
442 receive_side_cc_.GetRemoteBitrateEstimator(true), RTC_FROM_HERE);
stefan64136af2017-08-14 08:03:17 -0700443 pacer_thread_->Start();
stefan9e117c5e12017-08-16 08:16:25 -0700444
445 module_process_thread_->RegisterModule(call_stats_.get(), RTC_FROM_HERE);
446 module_process_thread_->RegisterModule(&receive_side_cc_, RTC_FROM_HERE);
447 module_process_thread_->RegisterModule(transport_send_->send_side_cc(),
448 RTC_FROM_HERE);
449 module_process_thread_->Start();
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000450}
451
pbos@webrtc.org841c8a42013-09-09 15:04:25 +0000452Call::~Call() {
eladalonf3f5c0e2017-08-18 02:47:08 -0700453 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
perkj26091b12016-09-01 01:17:40 -0700454
solenbergc7a8b082015-10-16 14:35:07 -0700455 RTC_CHECK(audio_send_ssrcs_.empty());
456 RTC_CHECK(video_send_ssrcs_.empty());
457 RTC_CHECK(video_send_streams_.empty());
nissee4bcd6d2017-05-16 04:47:04 -0700458 RTC_CHECK(audio_receive_streams_.empty());
solenbergc7a8b082015-10-16 14:35:07 -0700459 RTC_CHECK(video_receive_streams_.empty());
pbos@webrtc.org9e4e5242015-02-12 10:48:23 +0000460
stefan9e117c5e12017-08-16 08:16:25 -0700461 // The send-side congestion controller must be de-registered prior to
462 // the pacer thread being stopped to avoid a race when accessing the
463 // pacer thread object on the module process thread at the same time as
464 // the pacer thread is stopped.
465 module_process_thread_->DeRegisterModule(transport_send_->send_side_cc());
nisseb9359842017-01-19 05:41:25 -0800466 pacer_thread_->Stop();
Stefan Holmer5c8942a2017-08-22 16:16:44 +0200467 pacer_thread_->DeRegisterModule(transport_send_->pacer());
nisseb9359842017-01-19 05:41:25 -0800468 pacer_thread_->DeRegisterModule(
nisse559af382017-03-21 06:41:12 -0700469 receive_side_cc_.GetRemoteBitrateEstimator(true));
nisse559af382017-03-21 06:41:12 -0700470 module_process_thread_->DeRegisterModule(&receive_side_cc_);
mflodmane3787022015-10-21 13:24:28 +0200471 module_process_thread_->DeRegisterModule(call_stats_.get());
Peter Boström45553ae2015-05-08 13:54:38 +0200472 module_process_thread_->Stop();
nissebcbaf742017-03-28 01:16:25 -0700473 call_stats_->DeregisterStatsObserver(&receive_side_cc_);
nisseb8f9a322017-03-27 05:36:15 -0700474 call_stats_->DeregisterStatsObserver(transport_send_->send_side_cc());
sprang6d6122b2016-07-13 06:37:09 -0700475
asaperssonfc5e81c2017-04-19 23:28:53 -0700476 int64_t first_sent_packet_ms =
477 transport_send_->send_side_cc()->GetFirstPacketTimeMs();
sprang6d6122b2016-07-13 06:37:09 -0700478 // Only update histograms after process threads have been shut down, so that
479 // they won't try to concurrently update stats.
perkj26091b12016-09-01 01:17:40 -0700480 {
481 rtc::CritScope lock(&bitrate_crit_);
asaperssonfc5e81c2017-04-19 23:28:53 -0700482 UpdateSendHistograms(first_sent_packet_ms);
perkj26091b12016-09-01 01:17:40 -0700483 }
sprang6d6122b2016-07-13 06:37:09 -0700484 UpdateReceiveHistograms();
asapersson4374a092016-07-27 00:39:09 -0700485 UpdateHistograms();
sprang6d6122b2016-07-13 06:37:09 -0700486
Peter Boström45553ae2015-05-08 13:54:38 +0200487 Trace::ReturnTrace();
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000488}
489
brandtrb29e6522016-12-21 06:37:18 -0800490rtc::Optional<RtpPacketReceived> Call::ParseRtpPacket(
491 const uint8_t* packet,
492 size_t length,
sprangc1abde72017-07-11 03:56:21 -0700493 const PacketTime* packet_time) const {
brandtrb29e6522016-12-21 06:37:18 -0800494 RtpPacketReceived parsed_packet;
495 if (!parsed_packet.Parse(packet, length))
496 return rtc::Optional<RtpPacketReceived>();
497
brandtrb29e6522016-12-21 06:37:18 -0800498 int64_t arrival_time_ms;
nissed2ef3142017-05-11 08:00:58 -0700499 if (packet_time && packet_time->timestamp != -1) {
500 arrival_time_ms = (packet_time->timestamp + 500) / 1000;
brandtrb29e6522016-12-21 06:37:18 -0800501 } else {
502 arrival_time_ms = clock_->TimeInMilliseconds();
503 }
504 parsed_packet.set_arrival_time_ms(arrival_time_ms);
505
506 return rtc::Optional<RtpPacketReceived>(std::move(parsed_packet));
507}
508
asapersson4374a092016-07-27 00:39:09 -0700509void Call::UpdateHistograms() {
asapersson1d02d3e2016-09-09 22:40:25 -0700510 RTC_HISTOGRAM_COUNTS_100000(
asapersson4374a092016-07-27 00:39:09 -0700511 "WebRTC.Call.LifetimeInSeconds",
512 (clock_->TimeInMilliseconds() - start_ms_) / 1000);
513}
514
asaperssonfc5e81c2017-04-19 23:28:53 -0700515void Call::UpdateSendHistograms(int64_t first_sent_packet_ms) {
516 if (first_sent_packet_ms == -1)
stefan18adf0a2015-11-17 06:24:56 -0800517 return;
sazac58f8c02017-07-19 00:39:19 -0700518 if (!sent_rtp_audio_timer_ms_.Empty()) {
519 RTC_HISTOGRAM_COUNTS_100000(
520 "WebRTC.Call.TimeSendingAudioRtpPacketsInSeconds",
521 sent_rtp_audio_timer_ms_.Length() / 1000);
522 }
stefan18adf0a2015-11-17 06:24:56 -0800523 int64_t elapsed_sec =
asaperssonfc5e81c2017-04-19 23:28:53 -0700524 (clock_->TimeInMilliseconds() - first_sent_packet_ms) / 1000;
stefan18adf0a2015-11-17 06:24:56 -0800525 if (elapsed_sec < metrics::kMinRunTimeInSeconds)
526 return;
asaperssonce2e1362016-09-09 00:13:35 -0700527 const int kMinRequiredPeriodicSamples = 5;
528 AggregatedStats send_bitrate_stats =
529 estimated_send_bitrate_kbps_counter_.ProcessAndGetStats();
530 if (send_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700531 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps",
532 send_bitrate_stats.average);
asapersson43cb7162016-11-15 08:20:48 -0800533 LOG(LS_INFO) << "WebRTC.Call.EstimatedSendBitrateInKbps, "
534 << send_bitrate_stats.ToString();
stefan18adf0a2015-11-17 06:24:56 -0800535 }
asaperssonce2e1362016-09-09 00:13:35 -0700536 AggregatedStats pacer_bitrate_stats =
537 pacer_bitrate_kbps_counter_.ProcessAndGetStats();
538 if (pacer_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700539 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.PacerBitrateInKbps",
540 pacer_bitrate_stats.average);
asapersson43cb7162016-11-15 08:20:48 -0800541 LOG(LS_INFO) << "WebRTC.Call.PacerBitrateInKbps, "
542 << pacer_bitrate_stats.ToString();
stefan18adf0a2015-11-17 06:24:56 -0800543 }
544}
545
546void Call::UpdateReceiveHistograms() {
saza0d7f04d2017-07-04 04:05:06 -0700547 if (first_received_rtp_audio_ms_) {
548 RTC_HISTOGRAM_COUNTS_100000(
549 "WebRTC.Call.TimeReceivingAudioRtpPacketsInSeconds",
550 (*last_received_rtp_audio_ms_ - *first_received_rtp_audio_ms_) / 1000);
551 }
552 if (first_received_rtp_video_ms_) {
553 RTC_HISTOGRAM_COUNTS_100000(
554 "WebRTC.Call.TimeReceivingVideoRtpPacketsInSeconds",
555 (*last_received_rtp_video_ms_ - *first_received_rtp_video_ms_) / 1000);
556 }
asapersson250fd972016-09-08 00:07:21 -0700557 const int kMinRequiredPeriodicSamples = 5;
558 AggregatedStats video_bytes_per_sec =
559 received_video_bytes_per_second_counter_.GetStats();
560 if (video_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700561 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.VideoBitrateReceivedInKbps",
562 video_bytes_per_sec.average * 8 / 1000);
asapersson076c0112016-11-30 05:17:16 -0800563 LOG(LS_INFO) << "WebRTC.Call.VideoBitrateReceivedInBps, "
564 << video_bytes_per_sec.ToStringWithMultiplier(8);
stefan91d92602015-11-11 10:13:02 -0800565 }
asapersson250fd972016-09-08 00:07:21 -0700566 AggregatedStats audio_bytes_per_sec =
567 received_audio_bytes_per_second_counter_.GetStats();
568 if (audio_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700569 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.AudioBitrateReceivedInKbps",
570 audio_bytes_per_sec.average * 8 / 1000);
asapersson076c0112016-11-30 05:17:16 -0800571 LOG(LS_INFO) << "WebRTC.Call.AudioBitrateReceivedInBps, "
572 << audio_bytes_per_sec.ToStringWithMultiplier(8);
stefan91d92602015-11-11 10:13:02 -0800573 }
asapersson250fd972016-09-08 00:07:21 -0700574 AggregatedStats rtcp_bytes_per_sec =
575 received_rtcp_bytes_per_second_counter_.GetStats();
576 if (rtcp_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700577 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.RtcpBitrateReceivedInBps",
578 rtcp_bytes_per_sec.average * 8);
asapersson076c0112016-11-30 05:17:16 -0800579 LOG(LS_INFO) << "WebRTC.Call.RtcpBitrateReceivedInBps, "
580 << rtcp_bytes_per_sec.ToStringWithMultiplier(8);
stefan91d92602015-11-11 10:13:02 -0800581 }
asapersson250fd972016-09-08 00:07:21 -0700582 AggregatedStats recv_bytes_per_sec =
583 received_bytes_per_second_counter_.GetStats();
584 if (recv_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700585 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.BitrateReceivedInKbps",
586 recv_bytes_per_sec.average * 8 / 1000);
asapersson076c0112016-11-30 05:17:16 -0800587 LOG(LS_INFO) << "WebRTC.Call.BitrateReceivedInBps, "
588 << recv_bytes_per_sec.ToStringWithMultiplier(8);
asapersson250fd972016-09-08 00:07:21 -0700589 }
stefan91d92602015-11-11 10:13:02 -0800590}
591
solenberg5a289392015-10-19 03:39:20 -0700592PacketReceiver* Call::Receiver() {
593 // TODO(solenberg): Some test cases in EndToEndTest use this from a different
594 // thread. Re-enable once that is fixed.
eladalonf3f5c0e2017-08-18 02:47:08 -0700595 // RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
solenberg5a289392015-10-19 03:39:20 -0700596 return this;
597}
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000598
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200599webrtc::AudioSendStream* Call::CreateAudioSendStream(
600 const webrtc::AudioSendStream::Config& config) {
solenbergc7a8b082015-10-16 14:35:07 -0700601 TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700602 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
perkjf4726992017-05-22 10:12:26 -0700603 event_log_->LogAudioSendStreamConfig(CreateRtcLogStreamConfig(config));
ossuc3d4b482017-05-23 06:07:11 -0700604
605 rtc::Optional<RtpState> suspended_rtp_state;
606 {
607 const auto& iter = suspended_audio_send_ssrcs_.find(config.rtp.ssrc);
608 if (iter != suspended_audio_send_ssrcs_.end()) {
609 suspended_rtp_state.emplace(iter->second);
610 }
611 }
612
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100613 AudioSendStream* send_stream = new AudioSendStream(
nisseb8f9a322017-03-27 05:36:15 -0700614 config, config_.audio_state, &worker_queue_, transport_send_.get(),
ossuc3d4b482017-05-23 06:07:11 -0700615 bitrate_allocator_.get(), event_log_, call_stats_->rtcp_rtt_stats(),
616 suspended_rtp_state);
solenbergc7a8b082015-10-16 14:35:07 -0700617 {
solenbergc7a8b082015-10-16 14:35:07 -0700618 WriteLockScoped write_lock(*send_crit_);
619 RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) ==
620 audio_send_ssrcs_.end());
621 audio_send_ssrcs_[config.rtp.ssrc] = send_stream;
solenbergc7a8b082015-10-16 14:35:07 -0700622 }
solenberg7602aab2016-11-14 11:30:07 -0800623 {
624 ReadLockScoped read_lock(*receive_crit_);
nissee4bcd6d2017-05-16 04:47:04 -0700625 for (AudioReceiveStream* stream : audio_receive_streams_) {
626 if (stream->config().rtp.local_ssrc == config.rtp.ssrc) {
627 stream->AssociateSendStream(send_stream);
solenberg7602aab2016-11-14 11:30:07 -0800628 }
629 }
630 }
skvlad7a43d252016-03-22 15:32:27 -0700631 send_stream->SignalNetworkState(audio_network_state_);
632 UpdateAggregateNetworkState();
solenbergc7a8b082015-10-16 14:35:07 -0700633 return send_stream;
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200634}
635
636void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
solenbergc7a8b082015-10-16 14:35:07 -0700637 TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700638 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
solenbergc7a8b082015-10-16 14:35:07 -0700639 RTC_DCHECK(send_stream != nullptr);
640
641 send_stream->Stop();
642
eladalonabbc4302017-07-26 02:09:44 -0700643 const uint32_t ssrc = send_stream->GetConfig().rtp.ssrc;
solenbergc7a8b082015-10-16 14:35:07 -0700644 webrtc::internal::AudioSendStream* audio_send_stream =
645 static_cast<webrtc::internal::AudioSendStream*>(send_stream);
ossuc3d4b482017-05-23 06:07:11 -0700646 suspended_audio_send_ssrcs_[ssrc] = audio_send_stream->GetRtpState();
solenbergc7a8b082015-10-16 14:35:07 -0700647 {
648 WriteLockScoped write_lock(*send_crit_);
solenberg7602aab2016-11-14 11:30:07 -0800649 size_t num_deleted = audio_send_ssrcs_.erase(ssrc);
650 RTC_DCHECK_EQ(1, num_deleted);
651 }
652 {
653 ReadLockScoped read_lock(*receive_crit_);
nissee4bcd6d2017-05-16 04:47:04 -0700654 for (AudioReceiveStream* stream : audio_receive_streams_) {
655 if (stream->config().rtp.local_ssrc == ssrc) {
656 stream->AssociateSendStream(nullptr);
solenberg7602aab2016-11-14 11:30:07 -0800657 }
658 }
solenbergc7a8b082015-10-16 14:35:07 -0700659 }
skvlad7a43d252016-03-22 15:32:27 -0700660 UpdateAggregateNetworkState();
sazac58f8c02017-07-19 00:39:19 -0700661 sent_rtp_audio_timer_ms_.Extend(audio_send_stream->GetActiveLifetime());
eladalonabbc4302017-07-26 02:09:44 -0700662 delete send_stream;
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200663}
664
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200665webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
666 const webrtc::AudioReceiveStream::Config& config) {
667 TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700668 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
perkjac8f52d2017-05-22 09:36:28 -0700669 event_log_->LogAudioReceiveStreamConfig(CreateRtcLogStreamConfig(config));
nisse0f15f922017-06-21 01:05:22 -0700670 AudioReceiveStream* receive_stream = new AudioReceiveStream(
eladalon2a2b2972017-07-03 09:25:27 -0700671 &audio_receiver_controller_, transport_send_->packet_router(), config,
nisse0f15f922017-06-21 01:05:22 -0700672 config_.audio_state, event_log_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200673 {
674 WriteLockScoped write_lock(*receive_crit_);
nissed44ce052017-02-06 02:23:00 -0800675 receive_rtp_config_[config.rtp.remote_ssrc] =
nisse4709e892017-02-07 01:18:43 -0800676 ReceiveRtpConfig(config.rtp.extensions, UseSendSideBwe(config));
nissee4bcd6d2017-05-16 04:47:04 -0700677 audio_receive_streams_.insert(receive_stream);
nissed44ce052017-02-06 02:23:00 -0800678
pbos8fc7fa72015-07-15 08:02:58 -0700679 ConfigureSync(config.sync_group);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200680 }
solenberg7602aab2016-11-14 11:30:07 -0800681 {
682 ReadLockScoped read_lock(*send_crit_);
683 auto it = audio_send_ssrcs_.find(config.rtp.local_ssrc);
684 if (it != audio_send_ssrcs_.end()) {
685 receive_stream->AssociateSendStream(it->second);
686 }
687 }
skvlad7a43d252016-03-22 15:32:27 -0700688 receive_stream->SignalNetworkState(audio_network_state_);
689 UpdateAggregateNetworkState();
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200690 return receive_stream;
691}
692
693void Call::DestroyAudioReceiveStream(
694 webrtc::AudioReceiveStream* receive_stream) {
695 TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700696 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
henrikg91d6ede2015-09-17 00:24:34 -0700697 RTC_DCHECK(receive_stream != nullptr);
solenbergc7a8b082015-10-16 14:35:07 -0700698 webrtc::internal::AudioReceiveStream* audio_receive_stream =
699 static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200700 {
701 WriteLockScoped write_lock(*receive_crit_);
nisse4709e892017-02-07 01:18:43 -0800702 const AudioReceiveStream::Config& config = audio_receive_stream->config();
703 uint32_t ssrc = config.rtp.remote_ssrc;
nisse559af382017-03-21 06:41:12 -0700704 receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config))
nisse4709e892017-02-07 01:18:43 -0800705 ->RemoveStream(ssrc);
nissee4bcd6d2017-05-16 04:47:04 -0700706 audio_receive_streams_.erase(audio_receive_stream);
pbos8fc7fa72015-07-15 08:02:58 -0700707 const std::string& sync_group = audio_receive_stream->config().sync_group;
708 const auto it = sync_stream_mapping_.find(sync_group);
709 if (it != sync_stream_mapping_.end() &&
710 it->second == audio_receive_stream) {
711 sync_stream_mapping_.erase(it);
712 ConfigureSync(sync_group);
713 }
nissed44ce052017-02-06 02:23:00 -0800714 receive_rtp_config_.erase(ssrc);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200715 }
skvlad7a43d252016-03-22 15:32:27 -0700716 UpdateAggregateNetworkState();
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200717 delete audio_receive_stream;
718}
719
720webrtc::VideoSendStream* Call::CreateVideoSendStream(
perkj26091b12016-09-01 01:17:40 -0700721 webrtc::VideoSendStream::Config config,
722 VideoEncoderConfig encoder_config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000723 TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700724 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
pbos@webrtc.org1819fd72013-06-10 13:48:26 +0000725
asapersson35151f32016-05-02 23:44:01 -0700726 video_send_delay_stats_->AddSsrcs(config);
perkjc0876aa2017-05-22 04:08:28 -0700727 for (size_t ssrc_index = 0; ssrc_index < config.rtp.ssrcs.size();
728 ++ssrc_index) {
729 event_log_->LogVideoSendStreamConfig(
730 CreateRtcLogStreamConfig(config, ssrc_index));
731 }
perkj26091b12016-09-01 01:17:40 -0700732
mflodman@webrtc.orgeb16b812014-06-16 08:57:39 +0000733 // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
734 // the call has already started.
perkj26091b12016-09-01 01:17:40 -0700735 // Copy ssrcs from |config| since |config| is moved.
736 std::vector<uint32_t> ssrcs = config.rtp.ssrcs;
mflodman0c478b32015-10-21 15:52:16 +0200737 VideoSendStream* send_stream = new VideoSendStream(
perkj26091b12016-09-01 01:17:40 -0700738 num_cpu_cores_, module_process_thread_.get(), &worker_queue_,
nisseb8f9a322017-03-27 05:36:15 -0700739 call_stats_.get(), transport_send_.get(), bitrate_allocator_.get(),
nisse05843312017-04-18 23:38:35 -0700740 video_send_delay_stats_.get(), event_log_, std::move(config),
sprangdb2a9fc2017-08-09 06:42:32 -0700741 std::move(encoder_config), suspended_video_send_ssrcs_);
perkj26091b12016-09-01 01:17:40 -0700742
skvlad7a43d252016-03-22 15:32:27 -0700743 {
744 WriteLockScoped write_lock(*send_crit_);
perkj26091b12016-09-01 01:17:40 -0700745 for (uint32_t ssrc : ssrcs) {
skvlad7a43d252016-03-22 15:32:27 -0700746 RTC_DCHECK(video_send_ssrcs_.find(ssrc) == video_send_ssrcs_.end());
747 video_send_ssrcs_[ssrc] = send_stream;
748 }
749 video_send_streams_.insert(send_stream);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000750 }
skvlad7a43d252016-03-22 15:32:27 -0700751 send_stream->SignalNetworkState(video_network_state_);
752 UpdateAggregateNetworkState();
perkj26091b12016-09-01 01:17:40 -0700753
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000754 return send_stream;
755}
756
pbos@webrtc.org2c46f8d2013-11-21 13:49:43 +0000757void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000758 TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream");
henrikg91d6ede2015-09-17 00:24:34 -0700759 RTC_DCHECK(send_stream != nullptr);
eladalonf3f5c0e2017-08-18 02:47:08 -0700760 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000761
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000762 send_stream->Stop();
763
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000764 VideoSendStream* send_stream_impl = nullptr;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000765 {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000766 WriteLockScoped write_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200767 auto it = video_send_ssrcs_.begin();
768 while (it != video_send_ssrcs_.end()) {
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000769 if (it->second == static_cast<VideoSendStream*>(send_stream)) {
770 send_stream_impl = it->second;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200771 video_send_ssrcs_.erase(it++);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000772 } else {
773 ++it;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000774 }
775 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200776 video_send_streams_.erase(send_stream_impl);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000777 }
henrikg91d6ede2015-09-17 00:24:34 -0700778 RTC_CHECK(send_stream_impl != nullptr);
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000779
perkj26091b12016-09-01 01:17:40 -0700780 VideoSendStream::RtpStateMap rtp_state =
781 send_stream_impl->StopPermanentlyAndGetRtpStates();
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000782
783 for (VideoSendStream::RtpStateMap::iterator it = rtp_state.begin();
perkj26091b12016-09-01 01:17:40 -0700784 it != rtp_state.end(); ++it) {
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200785 suspended_video_send_ssrcs_[it->first] = it->second;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000786 }
787
skvlad7a43d252016-03-22 15:32:27 -0700788 UpdateAggregateNetworkState();
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000789 delete send_stream_impl;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000790}
791
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200792webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
Tommi733b5472016-06-10 17:58:01 +0200793 webrtc::VideoReceiveStream::Config configuration) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000794 TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700795 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
brandtrfb45c6c2017-01-27 06:47:55 -0800796
nisse0f15f922017-06-21 01:05:22 -0700797 VideoReceiveStream* receive_stream = new VideoReceiveStream(
eladalon2a2b2972017-07-03 09:25:27 -0700798 &video_receiver_controller_, num_cpu_cores_,
nisse0f15f922017-06-21 01:05:22 -0700799 transport_send_->packet_router(), std::move(configuration),
800 module_process_thread_.get(), call_stats_.get());
Tommi733b5472016-06-10 17:58:01 +0200801
802 const webrtc::VideoReceiveStream::Config& config = receive_stream->config();
nissed44ce052017-02-06 02:23:00 -0800803 ReceiveRtpConfig receive_config(config.rtp.extensions,
nisse4709e892017-02-07 01:18:43 -0800804 UseSendSideBwe(config));
skvlad7a43d252016-03-22 15:32:27 -0700805 {
806 WriteLockScoped write_lock(*receive_crit_);
nissed44ce052017-02-06 02:23:00 -0800807 if (config.rtp.rtx_ssrc) {
nissed44ce052017-02-06 02:23:00 -0800808 // We record identical config for the rtx stream as for the main
nisseb8f9a322017-03-27 05:36:15 -0700809 // stream. Since the transport_send_cc negotiation is per payload
nissed44ce052017-02-06 02:23:00 -0800810 // type, we may get an incorrect value for the rtx stream, but
811 // that is unlikely to matter in practice.
812 receive_rtp_config_[config.rtp.rtx_ssrc] = receive_config;
813 }
814 receive_rtp_config_[config.rtp.remote_ssrc] = receive_config;
skvlad7a43d252016-03-22 15:32:27 -0700815 video_receive_streams_.insert(receive_stream);
skvlad7a43d252016-03-22 15:32:27 -0700816 ConfigureSync(config.sync_group);
817 }
818 receive_stream->SignalNetworkState(video_network_state_);
819 UpdateAggregateNetworkState();
perkj09e71da2017-05-22 03:26:49 -0700820 event_log_->LogVideoReceiveStreamConfig(CreateRtcLogStreamConfig(config));
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000821 return receive_stream;
822}
823
pbos@webrtc.org2c46f8d2013-11-21 13:49:43 +0000824void Call::DestroyVideoReceiveStream(
825 webrtc::VideoReceiveStream* receive_stream) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000826 TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700827 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
henrikg91d6ede2015-09-17 00:24:34 -0700828 RTC_DCHECK(receive_stream != nullptr);
nissee4bcd6d2017-05-16 04:47:04 -0700829 VideoReceiveStream* receive_stream_impl =
830 static_cast<VideoReceiveStream*>(receive_stream);
831 const VideoReceiveStream::Config& config = receive_stream_impl->config();
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000832 {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000833 WriteLockScoped write_lock(*receive_crit_);
pbos@webrtc.orgc279a5d2014-01-24 09:30:53 +0000834 // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a
835 // separate SSRC there can be either one or two.
nissee4bcd6d2017-05-16 04:47:04 -0700836 receive_rtp_config_.erase(config.rtp.remote_ssrc);
837 if (config.rtp.rtx_ssrc) {
838 receive_rtp_config_.erase(config.rtp.rtx_ssrc);
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000839 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200840 video_receive_streams_.erase(receive_stream_impl);
nissee4bcd6d2017-05-16 04:47:04 -0700841 ConfigureSync(config.sync_group);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000842 }
nisse4709e892017-02-07 01:18:43 -0800843
nisse559af382017-03-21 06:41:12 -0700844 receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config))
nisse4709e892017-02-07 01:18:43 -0800845 ->RemoveStream(config.rtp.remote_ssrc);
846
skvlad7a43d252016-03-22 15:32:27 -0700847 UpdateAggregateNetworkState();
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000848 delete receive_stream_impl;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000849}
850
brandtr7250b392016-12-19 01:13:46 -0800851FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
852 const FlexfecReceiveStream::Config& config) {
brandtr25445d32016-10-23 23:37:14 -0700853 TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700854 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
brandtrb29e6522016-12-21 06:37:18 -0800855
856 RecoveredPacketReceiver* recovered_packet_receiver = this;
brandtr25445d32016-10-23 23:37:14 -0700857
nisse0f15f922017-06-21 01:05:22 -0700858 FlexfecReceiveStreamImpl* receive_stream;
brandtr25445d32016-10-23 23:37:14 -0700859 {
860 WriteLockScoped write_lock(*receive_crit_);
nisse0f15f922017-06-21 01:05:22 -0700861 // Unlike the video and audio receive streams,
862 // FlexfecReceiveStream implements RtpPacketSinkInterface itself,
863 // and hence its constructor passes its |this| pointer to
eladalon2a2b2972017-07-03 09:25:27 -0700864 // video_receiver_controller_->CreateStream(). Calling the
nisse0f15f922017-06-21 01:05:22 -0700865 // constructor while holding |receive_crit_| ensures that we don't
866 // call OnRtpPacket until the constructor is finished and the
867 // object is in a valid state.
868 // TODO(nisse): Fix constructor so that it can be moved outside of
869 // this locked scope.
870 receive_stream = new FlexfecReceiveStreamImpl(
eladalon2a2b2972017-07-03 09:25:27 -0700871 &video_receiver_controller_, config, recovered_packet_receiver,
nisse0f15f922017-06-21 01:05:22 -0700872 call_stats_->rtcp_rtt_stats(), module_process_thread_.get());
brandtrb29e6522016-12-21 06:37:18 -0800873
nissed44ce052017-02-06 02:23:00 -0800874 RTC_DCHECK(receive_rtp_config_.find(config.remote_ssrc) ==
875 receive_rtp_config_.end());
876 receive_rtp_config_[config.remote_ssrc] =
nisse4709e892017-02-07 01:18:43 -0800877 ReceiveRtpConfig(config.rtp_header_extensions, UseSendSideBwe(config));
brandtr25445d32016-10-23 23:37:14 -0700878 }
brandtrb29e6522016-12-21 06:37:18 -0800879
brandtr25445d32016-10-23 23:37:14 -0700880 // TODO(brandtr): Store config in RtcEventLog here.
brandtrb29e6522016-12-21 06:37:18 -0800881
brandtr25445d32016-10-23 23:37:14 -0700882 return receive_stream;
883}
884
brandtr7250b392016-12-19 01:13:46 -0800885void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) {
brandtr25445d32016-10-23 23:37:14 -0700886 TRACE_EVENT0("webrtc", "Call::DestroyFlexfecReceiveStream");
eladalonf3f5c0e2017-08-18 02:47:08 -0700887 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
brandtrb29e6522016-12-21 06:37:18 -0800888
brandtr25445d32016-10-23 23:37:14 -0700889 RTC_DCHECK(receive_stream != nullptr);
brandtr25445d32016-10-23 23:37:14 -0700890 {
891 WriteLockScoped write_lock(*receive_crit_);
brandtrb29e6522016-12-21 06:37:18 -0800892
eladalon42f44f92017-07-25 06:40:06 -0700893 const FlexfecReceiveStream::Config& config = receive_stream->GetConfig();
nisse4709e892017-02-07 01:18:43 -0800894 uint32_t ssrc = config.remote_ssrc;
nissed44ce052017-02-06 02:23:00 -0800895 receive_rtp_config_.erase(ssrc);
brandtrb29e6522016-12-21 06:37:18 -0800896
brandtr7250b392016-12-19 01:13:46 -0800897 // Remove all SSRCs pointing to the FlexfecReceiveStreamImpl to be
898 // destroyed.
nisse559af382017-03-21 06:41:12 -0700899 receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config))
nisse4709e892017-02-07 01:18:43 -0800900 ->RemoveStream(ssrc);
brandtr25445d32016-10-23 23:37:14 -0700901 }
brandtrb29e6522016-12-21 06:37:18 -0800902
eladalon42f44f92017-07-25 06:40:06 -0700903 delete receive_stream;
brandtr25445d32016-10-23 23:37:14 -0700904}
905
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000906Call::Stats Call::GetStats() const {
solenberg5a289392015-10-19 03:39:20 -0700907 // TODO(solenberg): Some test cases in EndToEndTest use this from a different
908 // thread. Re-enable once that is fixed.
eladalonf3f5c0e2017-08-18 02:47:08 -0700909 // RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000910 Stats stats;
Peter Boström45553ae2015-05-08 13:54:38 +0200911 // Fetch available send/receive bitrates.
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000912 uint32_t send_bandwidth = 0;
nisseb8f9a322017-03-27 05:36:15 -0700913 transport_send_->send_side_cc()->GetBitrateController()->AvailableBandwidth(
914 &send_bandwidth);
Peter Boström45553ae2015-05-08 13:54:38 +0200915 std::vector<unsigned int> ssrcs;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000916 uint32_t recv_bandwidth = 0;
nisse559af382017-03-21 06:41:12 -0700917 receive_side_cc_.GetRemoteBitrateEstimator(false)->LatestEstimate(
mflodmana20de202015-10-18 22:08:19 -0700918 &ssrcs, &recv_bandwidth);
Peter Boström45553ae2015-05-08 13:54:38 +0200919 stats.send_bandwidth_bps = send_bandwidth;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000920 stats.recv_bandwidth_bps = recv_bandwidth;
nisseb8f9a322017-03-27 05:36:15 -0700921 stats.pacer_delay_ms =
922 transport_send_->send_side_cc()->GetPacerQueuingDelayMs();
sprange2d83d62016-02-19 09:03:26 -0800923 stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt();
sprang9c0b5512016-07-06 00:54:28 -0700924 {
925 rtc::CritScope cs(&bitrate_crit_);
926 stats.max_padding_bitrate_bps = configured_max_padding_bitrate_bps_;
927 }
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000928 return stats;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000929}
930
pbos@webrtc.org00873182014-11-25 14:03:34 +0000931void Call::SetBitrateConfig(
932 const webrtc::Call::Config::BitrateConfig& bitrate_config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000933 TRACE_EVENT0("webrtc", "Call::SetBitrateConfig");
eladalonf3f5c0e2017-08-18 02:47:08 -0700934 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
henrikg91d6ede2015-09-17 00:24:34 -0700935 RTC_DCHECK_GE(bitrate_config.min_bitrate_bps, 0);
zstein4b979802017-06-02 14:37:37 -0700936 RTC_DCHECK_NE(bitrate_config.start_bitrate_bps, 0);
937 if (bitrate_config.max_bitrate_bps != -1) {
henrikg91d6ede2015-09-17 00:24:34 -0700938 RTC_DCHECK_GT(bitrate_config.max_bitrate_bps, 0);
zstein4b979802017-06-02 14:37:37 -0700939 }
940
941 rtc::Optional<int> new_start;
942 // Only update the "start" bitrate if it's set, and different from the old
943 // value. In practice, this value comes from the x-google-start-bitrate codec
944 // parameter in SDP, and setting the same remote description twice shouldn't
945 // restart bandwidth estimation.
946 if (bitrate_config.start_bitrate_bps != -1 &&
947 bitrate_config.start_bitrate_bps !=
948 base_bitrate_config_.start_bitrate_bps) {
949 new_start.emplace(bitrate_config.start_bitrate_bps);
950 }
951 base_bitrate_config_ = bitrate_config;
952 UpdateCurrentBitrateConfig(new_start);
953}
954
955void Call::SetBitrateConfigMask(
956 const webrtc::Call::Config::BitrateConfigMask& mask) {
957 TRACE_EVENT0("webrtc", "Call::SetBitrateConfigMask");
eladalonf3f5c0e2017-08-18 02:47:08 -0700958 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
zstein4b979802017-06-02 14:37:37 -0700959
960 bitrate_config_mask_ = mask;
961 UpdateCurrentBitrateConfig(mask.start_bitrate_bps);
962}
963
zstein4b979802017-06-02 14:37:37 -0700964void Call::UpdateCurrentBitrateConfig(const rtc::Optional<int>& new_start) {
965 Config::BitrateConfig updated;
966 updated.min_bitrate_bps =
967 std::max(bitrate_config_mask_.min_bitrate_bps.value_or(0),
968 base_bitrate_config_.min_bitrate_bps);
969
970 updated.max_bitrate_bps =
971 MinPositive(bitrate_config_mask_.max_bitrate_bps.value_or(-1),
972 base_bitrate_config_.max_bitrate_bps);
973
974 // If the combined min ends up greater than the combined max, the max takes
975 // priority.
976 if (updated.max_bitrate_bps != -1 &&
977 updated.min_bitrate_bps > updated.max_bitrate_bps) {
978 updated.min_bitrate_bps = updated.max_bitrate_bps;
979 }
980
981 // If there is nothing to update (min/max unchanged, no new bandwidth
982 // estimation start value), return early.
983 if (updated.min_bitrate_bps == config_.bitrate_config.min_bitrate_bps &&
984 updated.max_bitrate_bps == config_.bitrate_config.max_bitrate_bps &&
985 !new_start) {
986 LOG(LS_VERBOSE) << "WebRTC.Call.UpdateCurrentBitrateConfig: "
987 << "nothing to update";
pbos@webrtc.org00873182014-11-25 14:03:34 +0000988 return;
989 }
zstein4b979802017-06-02 14:37:37 -0700990
991 if (new_start) {
992 // Clamp start by min and max.
993 updated.start_bitrate_bps = MinPositive(
994 std::max(*new_start, updated.min_bitrate_bps), updated.max_bitrate_bps);
995 } else {
996 updated.start_bitrate_bps = -1;
997 }
998
999 LOG(INFO) << "WebRTC.Call.UpdateCurrentBitrateConfig: "
1000 << "calling SetBweBitrates with args (" << updated.min_bitrate_bps
1001 << ", " << updated.start_bitrate_bps << ", "
1002 << updated.max_bitrate_bps << ")";
1003 transport_send_->send_side_cc()->SetBweBitrates(updated.min_bitrate_bps,
1004 updated.start_bitrate_bps,
1005 updated.max_bitrate_bps);
1006 if (!new_start) {
1007 updated.start_bitrate_bps = config_.bitrate_config.start_bitrate_bps;
1008 }
1009 config_.bitrate_config = updated;
pbos@webrtc.org00873182014-11-25 14:03:34 +00001010}
1011
skvlad7a43d252016-03-22 15:32:27 -07001012void Call::SignalChannelNetworkState(MediaType media, NetworkState state) {
eladalonf3f5c0e2017-08-18 02:47:08 -07001013 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
skvlad7a43d252016-03-22 15:32:27 -07001014 switch (media) {
1015 case MediaType::AUDIO:
1016 audio_network_state_ = state;
1017 break;
1018 case MediaType::VIDEO:
1019 video_network_state_ = state;
1020 break;
1021 case MediaType::ANY:
1022 case MediaType::DATA:
1023 RTC_NOTREACHED();
1024 break;
1025 }
1026
1027 UpdateAggregateNetworkState();
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001028 {
skvlad7a43d252016-03-22 15:32:27 -07001029 ReadLockScoped read_lock(*send_crit_);
solenbergc7a8b082015-10-16 14:35:07 -07001030 for (auto& kv : audio_send_ssrcs_) {
skvlad7a43d252016-03-22 15:32:27 -07001031 kv.second->SignalNetworkState(audio_network_state_);
solenbergc7a8b082015-10-16 14:35:07 -07001032 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001033 for (auto& kv : video_send_ssrcs_) {
skvlad7a43d252016-03-22 15:32:27 -07001034 kv.second->SignalNetworkState(video_network_state_);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001035 }
1036 }
1037 {
skvlad7a43d252016-03-22 15:32:27 -07001038 ReadLockScoped read_lock(*receive_crit_);
nissee4bcd6d2017-05-16 04:47:04 -07001039 for (AudioReceiveStream* audio_receive_stream : audio_receive_streams_) {
1040 audio_receive_stream->SignalNetworkState(audio_network_state_);
skvlad7a43d252016-03-22 15:32:27 -07001041 }
nissee4bcd6d2017-05-16 04:47:04 -07001042 for (VideoReceiveStream* video_receive_stream : video_receive_streams_) {
1043 video_receive_stream->SignalNetworkState(video_network_state_);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001044 }
1045 }
1046}
1047
michaelt79e05882016-11-08 02:50:09 -08001048void Call::OnTransportOverheadChanged(MediaType media,
1049 int transport_overhead_per_packet) {
1050 switch (media) {
1051 case MediaType::AUDIO: {
1052 ReadLockScoped read_lock(*send_crit_);
1053 for (auto& kv : audio_send_ssrcs_) {
1054 kv.second->SetTransportOverhead(transport_overhead_per_packet);
1055 }
1056 break;
1057 }
1058 case MediaType::VIDEO: {
1059 ReadLockScoped read_lock(*send_crit_);
1060 for (auto& kv : video_send_ssrcs_) {
1061 kv.second->SetTransportOverhead(transport_overhead_per_packet);
1062 }
1063 break;
1064 }
1065 case MediaType::ANY:
1066 case MediaType::DATA:
1067 RTC_NOTREACHED();
1068 break;
1069 }
1070}
1071
Honghai Zhang0e533ef2016-04-19 15:41:36 -07001072// TODO(honghaiz): Add tests for this method.
1073void Call::OnNetworkRouteChanged(const std::string& transport_name,
1074 const rtc::NetworkRoute& network_route) {
eladalonf3f5c0e2017-08-18 02:47:08 -07001075 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
Honghai Zhang0e533ef2016-04-19 15:41:36 -07001076 // Check if the network route is connected.
1077 if (!network_route.connected) {
1078 LOG(LS_INFO) << "Transport " << transport_name << " is disconnected";
1079 // TODO(honghaiz): Perhaps handle this in SignalChannelNetworkState and
1080 // consider merging these two methods.
1081 return;
1082 }
1083
1084 // Check whether the network route has changed on each transport.
1085 auto result =
1086 network_routes_.insert(std::make_pair(transport_name, network_route));
1087 auto kv = result.first;
1088 bool inserted = result.second;
1089 if (inserted) {
1090 // No need to reset BWE if this is the first time the network connects.
1091 return;
1092 }
1093 if (kv->second != network_route) {
1094 kv->second = network_route;
1095 LOG(LS_INFO) << "Network route changed on transport " << transport_name
1096 << ": new local network id " << network_route.local_network_id
honghaiz059e1832016-06-24 11:03:55 -07001097 << " new remote network id " << network_route.remote_network_id
Stefan Holmer52200d02016-09-20 14:14:23 +02001098 << " Reset bitrates to min: "
1099 << config_.bitrate_config.min_bitrate_bps
1100 << " bps, start: " << config_.bitrate_config.start_bitrate_bps
1101 << " bps, max: " << config_.bitrate_config.start_bitrate_bps
1102 << " bps.";
stefan5a2c5062017-01-27 06:43:18 -08001103 RTC_DCHECK_GT(config_.bitrate_config.start_bitrate_bps, 0);
nisseb8f9a322017-03-27 05:36:15 -07001104 transport_send_->send_side_cc()->OnNetworkRouteChanged(
Stefan Holmer9ea46b52017-03-15 12:40:25 +01001105 network_route, config_.bitrate_config.start_bitrate_bps,
honghaiz059e1832016-06-24 11:03:55 -07001106 config_.bitrate_config.min_bitrate_bps,
1107 config_.bitrate_config.max_bitrate_bps);
Honghai Zhang0e533ef2016-04-19 15:41:36 -07001108 }
1109}
1110
skvlad7a43d252016-03-22 15:32:27 -07001111void Call::UpdateAggregateNetworkState() {
eladalonf3f5c0e2017-08-18 02:47:08 -07001112 RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
skvlad7a43d252016-03-22 15:32:27 -07001113
1114 bool have_audio = false;
1115 bool have_video = false;
1116 {
1117 ReadLockScoped read_lock(*send_crit_);
1118 if (audio_send_ssrcs_.size() > 0)
1119 have_audio = true;
1120 if (video_send_ssrcs_.size() > 0)
1121 have_video = true;
1122 }
1123 {
1124 ReadLockScoped read_lock(*receive_crit_);
nissee4bcd6d2017-05-16 04:47:04 -07001125 if (audio_receive_streams_.size() > 0)
skvlad7a43d252016-03-22 15:32:27 -07001126 have_audio = true;
nissee4bcd6d2017-05-16 04:47:04 -07001127 if (video_receive_streams_.size() > 0)
skvlad7a43d252016-03-22 15:32:27 -07001128 have_video = true;
1129 }
1130
1131 NetworkState aggregate_state = kNetworkDown;
1132 if ((have_video && video_network_state_ == kNetworkUp) ||
1133 (have_audio && audio_network_state_ == kNetworkUp)) {
1134 aggregate_state = kNetworkUp;
1135 }
1136
1137 LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state="
1138 << (aggregate_state == kNetworkUp ? "up" : "down");
1139
nisseb8f9a322017-03-27 05:36:15 -07001140 transport_send_->send_side_cc()->SignalNetworkState(aggregate_state);
skvlad7a43d252016-03-22 15:32:27 -07001141}
1142
stefanc1aeaf02015-10-15 07:26:07 -07001143void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
asapersson35151f32016-05-02 23:44:01 -07001144 video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
1145 clock_->TimeInMilliseconds());
nisseb8f9a322017-03-27 05:36:15 -07001146 transport_send_->send_side_cc()->OnSentPacket(sent_packet);
stefanc1aeaf02015-10-15 07:26:07 -07001147}
1148
minyue78b4d562016-11-30 04:47:39 -08001149void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
1150 uint8_t fraction_loss,
1151 int64_t rtt_ms,
1152 int64_t probing_interval_ms) {
perkj26091b12016-09-01 01:17:40 -07001153 // TODO(perkj): Consider making sure CongestionController operates on
1154 // |worker_queue_|.
1155 if (!worker_queue_.IsCurrent()) {
minyue78b4d562016-11-30 04:47:39 -08001156 worker_queue_.PostTask(
1157 [this, target_bitrate_bps, fraction_loss, rtt_ms, probing_interval_ms] {
1158 OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt_ms,
1159 probing_interval_ms);
1160 });
perkj26091b12016-09-01 01:17:40 -07001161 return;
1162 }
1163 RTC_DCHECK_RUN_ON(&worker_queue_);
nisse559af382017-03-21 06:41:12 -07001164 // For controlling the rate of feedback messages.
1165 receive_side_cc_.OnBitrateChanged(target_bitrate_bps);
perkj71ee44c2016-06-15 00:47:53 -07001166 bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, fraction_loss,
minyue78b4d562016-11-30 04:47:39 -08001167 rtt_ms, probing_interval_ms);
mflodman0e7e2592015-11-12 21:02:42 -08001168
asaperssonce2e1362016-09-09 00:13:35 -07001169 // Ignore updates if bitrate is zero (the aggregate network state is down).
1170 if (target_bitrate_bps == 0) {
stefan18adf0a2015-11-17 06:24:56 -08001171 rtc::CritScope lock(&bitrate_crit_);
asaperssonce2e1362016-09-09 00:13:35 -07001172 estimated_send_bitrate_kbps_counter_.ProcessAndPause();
1173 pacer_bitrate_kbps_counter_.ProcessAndPause();
1174 return;
stefan18adf0a2015-11-17 06:24:56 -08001175 }
asaperssonce2e1362016-09-09 00:13:35 -07001176
1177 bool sending_video;
1178 {
1179 ReadLockScoped read_lock(*send_crit_);
1180 sending_video = !video_send_streams_.empty();
1181 }
1182
1183 rtc::CritScope lock(&bitrate_crit_);
1184 if (!sending_video) {
1185 // Do not update the stats if we are not sending video.
1186 estimated_send_bitrate_kbps_counter_.ProcessAndPause();
1187 pacer_bitrate_kbps_counter_.ProcessAndPause();
1188 return;
1189 }
1190 estimated_send_bitrate_kbps_counter_.Add(target_bitrate_bps / 1000);
1191 // Pacer bitrate may be higher than bitrate estimate if enforcing min bitrate.
1192 uint32_t pacer_bitrate_bps =
1193 std::max(target_bitrate_bps, min_allocated_send_bitrate_bps_);
1194 pacer_bitrate_kbps_counter_.Add(pacer_bitrate_bps / 1000);
perkj71ee44c2016-06-15 00:47:53 -07001195}
mflodman101f2502016-06-09 17:21:19 +02001196
perkj71ee44c2016-06-15 00:47:53 -07001197void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
1198 uint32_t max_padding_bitrate_bps) {
Stefan Holmer5c8942a2017-08-22 16:16:44 +02001199 transport_send_->SetAllocatedSendBitrateLimits(min_send_bitrate_bps,
1200 max_padding_bitrate_bps);
perkj71ee44c2016-06-15 00:47:53 -07001201 rtc::CritScope lock(&bitrate_crit_);
1202 min_allocated_send_bitrate_bps_ = min_send_bitrate_bps;
sprang9c0b5512016-07-06 00:54:28 -07001203 configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps;
mflodman0e7e2592015-11-12 21:02:42 -08001204}
1205
pbos8fc7fa72015-07-15 08:02:58 -07001206void Call::ConfigureSync(const std::string& sync_group) {
1207 // Set sync only if there was no previous one.
solenberg3ebbcb52017-01-31 03:58:40 -08001208 if (sync_group.empty())
pbos8fc7fa72015-07-15 08:02:58 -07001209 return;
1210
1211 AudioReceiveStream* sync_audio_stream = nullptr;
1212 // Find existing audio stream.
1213 const auto it = sync_stream_mapping_.find(sync_group);
1214 if (it != sync_stream_mapping_.end()) {
1215 sync_audio_stream = it->second;
1216 } else {
1217 // No configured audio stream, see if we can find one.
nissee4bcd6d2017-05-16 04:47:04 -07001218 for (AudioReceiveStream* stream : audio_receive_streams_) {
1219 if (stream->config().sync_group == sync_group) {
pbos8fc7fa72015-07-15 08:02:58 -07001220 if (sync_audio_stream != nullptr) {
1221 LOG(LS_WARNING) << "Attempting to sync more than one audio stream "
1222 "within the same sync group. This is not "
1223 "supported in the current implementation.";
1224 break;
1225 }
nissee4bcd6d2017-05-16 04:47:04 -07001226 sync_audio_stream = stream;
pbos8fc7fa72015-07-15 08:02:58 -07001227 }
1228 }
1229 }
1230 if (sync_audio_stream)
1231 sync_stream_mapping_[sync_group] = sync_audio_stream;
1232 size_t num_synced_streams = 0;
1233 for (VideoReceiveStream* video_stream : video_receive_streams_) {
1234 if (video_stream->config().sync_group != sync_group)
1235 continue;
1236 ++num_synced_streams;
1237 if (num_synced_streams > 1) {
1238 // TODO(pbos): Support synchronizing more than one A/V pair.
1239 // https://code.google.com/p/webrtc/issues/detail?id=4762
1240 LOG(LS_WARNING) << "Attempting to sync more than one audio/video pair "
1241 "within the same sync group. This is not supported in "
1242 "the current implementation.";
1243 }
1244 // Only sync the first A/V pair within this sync group.
solenberg3ebbcb52017-01-31 03:58:40 -08001245 if (num_synced_streams == 1) {
1246 // sync_audio_stream may be null and that's ok.
1247 video_stream->SetSync(sync_audio_stream);
pbos8fc7fa72015-07-15 08:02:58 -07001248 } else {
solenberg3ebbcb52017-01-31 03:58:40 -08001249 video_stream->SetSync(nullptr);
pbos8fc7fa72015-07-15 08:02:58 -07001250 }
1251 }
1252}
1253
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001254PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
1255 const uint8_t* packet,
1256 size_t length) {
Peter Boström6f28cf02015-12-07 23:17:15 +01001257 TRACE_EVENT0("webrtc", "Call::DeliverRtcp");
mflodman3d7db262016-04-29 00:57:13 -07001258 // TODO(pbos): Make sure it's a valid packet.
pbos@webrtc.orgcaba2d22014-05-14 13:57:12 +00001259 // Return DELIVERY_UNKNOWN_SSRC if it can be determined that
1260 // there's no receiver of the packet.
asapersson250fd972016-09-08 00:07:21 -07001261 if (received_bytes_per_second_counter_.HasSample()) {
1262 // First RTP packet has been received.
1263 received_bytes_per_second_counter_.Add(static_cast<int>(length));
1264 received_rtcp_bytes_per_second_counter_.Add(static_cast<int>(length));
1265 }
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001266 bool rtcp_delivered = false;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001267 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001268 ReadLockScoped read_lock(*receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001269 for (VideoReceiveStream* stream : video_receive_streams_) {
mflodman3d7db262016-04-29 00:57:13 -07001270 if (stream->DeliverRtcp(packet, length))
pbos@webrtc.org40523702013-08-05 12:49:22 +00001271 rtcp_delivered = true;
mflodman3d7db262016-04-29 00:57:13 -07001272 }
1273 }
1274 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
1275 ReadLockScoped read_lock(*receive_crit_);
nissee4bcd6d2017-05-16 04:47:04 -07001276 for (AudioReceiveStream* stream : audio_receive_streams_) {
1277 if (stream->DeliverRtcp(packet, length))
mflodman3d7db262016-04-29 00:57:13 -07001278 rtcp_delivered = true;
pbos@webrtc.orgbbb07e62013-08-05 12:01:36 +00001279 }
1280 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001281 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +00001282 ReadLockScoped read_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001283 for (VideoSendStream* stream : video_send_streams_) {
mflodman3d7db262016-04-29 00:57:13 -07001284 if (stream->DeliverRtcp(packet, length))
pbos@webrtc.org40523702013-08-05 12:49:22 +00001285 rtcp_delivered = true;
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001286 }
1287 }
mflodman3d7db262016-04-29 00:57:13 -07001288 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
1289 ReadLockScoped read_lock(*send_crit_);
1290 for (auto& kv : audio_send_ssrcs_) {
1291 if (kv.second->DeliverRtcp(packet, length))
1292 rtcp_delivered = true;
1293 }
1294 }
1295
skvlad11a9cbf2016-10-07 11:53:05 -07001296 if (rtcp_delivered)
perkj77cd58e2017-05-30 03:52:10 -07001297 event_log_->LogRtcpPacket(kIncomingPacket, packet, length);
mflodman3d7db262016-04-29 00:57:13 -07001298
pbos@webrtc.orgcaba2d22014-05-14 13:57:12 +00001299 return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001300}
1301
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001302PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
1303 const uint8_t* packet,
stefan68786d22015-09-08 05:36:15 -07001304 size_t length,
1305 const PacketTime& packet_time) {
Peter Boström6f28cf02015-12-07 23:17:15 +01001306 TRACE_EVENT0("webrtc", "Call::DeliverRtp");
nissed44ce052017-02-06 02:23:00 -08001307
nissed44ce052017-02-06 02:23:00 -08001308 // TODO(nisse): We should parse the RTP header only here, and pass
1309 // on parsed_packet to the receive streams.
1310 rtc::Optional<RtpPacketReceived> parsed_packet =
nissed2ef3142017-05-11 08:00:58 -07001311 ParseRtpPacket(packet, length, &packet_time);
nissed44ce052017-02-06 02:23:00 -08001312
sprangc1abde72017-07-11 03:56:21 -07001313 // We might get RTP keep-alive packets in accordance with RFC6263 section 4.6.
1314 // These are empty (zero length payload) RTP packets with an unsignaled
1315 // payload type.
1316 const bool is_keep_alive_packet =
1317 parsed_packet && parsed_packet->payload_size() == 0;
1318
1319 RTC_DCHECK(media_type == MediaType::AUDIO || media_type == MediaType::VIDEO ||
1320 is_keep_alive_packet);
1321
nissed44ce052017-02-06 02:23:00 -08001322 if (!parsed_packet)
pbos@webrtc.orgaf38f4e2014-07-08 07:38:12 +00001323 return DELIVERY_PACKET_ERROR;
1324
sprangc1abde72017-07-11 03:56:21 -07001325 ReadLockScoped read_lock(*receive_crit_);
nisse0f15f922017-06-21 01:05:22 -07001326 auto it = receive_rtp_config_.find(parsed_packet->Ssrc());
1327 if (it == receive_rtp_config_.end()) {
1328 LOG(LS_ERROR) << "receive_rtp_config_ lookup failed for ssrc "
1329 << parsed_packet->Ssrc();
1330 // Destruction of the receive stream, including deregistering from the
1331 // RtpDemuxer, is not protected by the |receive_crit_| lock. But
1332 // deregistering in the |receive_rtp_config_| map is protected by that lock.
1333 // So by not passing the packet on to demuxing in this case, we prevent
1334 // incoming packets to be passed on via the demuxer to a receive stream
1335 // which is being torned down.
1336 return DELIVERY_UNKNOWN_SSRC;
1337 }
1338 parsed_packet->IdentifyExtensions(it->second.extensions);
1339
nissed44ce052017-02-06 02:23:00 -08001340 NotifyBweOfReceivedPacket(*parsed_packet, media_type);
1341
nissee5ad5ca2017-03-29 23:57:43 -07001342 if (media_type == MediaType::AUDIO) {
eladalon2a2b2972017-07-03 09:25:27 -07001343 if (audio_receiver_controller_.OnRtpPacket(*parsed_packet)) {
asapersson250fd972016-09-08 00:07:21 -07001344 received_bytes_per_second_counter_.Add(static_cast<int>(length));
1345 received_audio_bytes_per_second_counter_.Add(static_cast<int>(length));
perkj77cd58e2017-05-30 03:52:10 -07001346 event_log_->LogRtpHeader(kIncomingPacket, packet, length);
saza0d7f04d2017-07-04 04:05:06 -07001347 const int64_t arrival_time_ms = parsed_packet->arrival_time_ms();
1348 if (!first_received_rtp_audio_ms_) {
1349 first_received_rtp_audio_ms_.emplace(arrival_time_ms);
1350 }
1351 last_received_rtp_audio_ms_.emplace(arrival_time_ms);
nisse657bab22017-02-21 06:28:10 -08001352 return DELIVERY_OK;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001353 }
nissee4bcd6d2017-05-16 04:47:04 -07001354 } else if (media_type == MediaType::VIDEO) {
eladalon2a2b2972017-07-03 09:25:27 -07001355 if (video_receiver_controller_.OnRtpPacket(*parsed_packet)) {
asapersson250fd972016-09-08 00:07:21 -07001356 received_bytes_per_second_counter_.Add(static_cast<int>(length));
1357 received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
perkj77cd58e2017-05-30 03:52:10 -07001358 event_log_->LogRtpHeader(kIncomingPacket, packet, length);
saza0d7f04d2017-07-04 04:05:06 -07001359 const int64_t arrival_time_ms = parsed_packet->arrival_time_ms();
1360 if (!first_received_rtp_video_ms_) {
1361 first_received_rtp_video_ms_.emplace(arrival_time_ms);
1362 }
1363 last_received_rtp_video_ms_.emplace(arrival_time_ms);
nisse5c29a7a2017-02-16 06:52:32 -08001364 return DELIVERY_OK;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001365 }
1366 }
1367 return DELIVERY_UNKNOWN_SSRC;
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001368}
1369
stefan68786d22015-09-08 05:36:15 -07001370PacketReceiver::DeliveryStatus Call::DeliverPacket(
1371 MediaType media_type,
1372 const uint8_t* packet,
1373 size_t length,
1374 const PacketTime& packet_time) {
solenberg5a289392015-10-19 03:39:20 -07001375 // TODO(solenberg): Tests call this function on a network thread, libjingle
1376 // calls on the worker thread. We should move towards always using a network
1377 // thread. Then this check can be enabled.
eladalonf3f5c0e2017-08-18 02:47:08 -07001378 // RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
pbos@webrtc.org62bafae2014-07-08 12:10:51 +00001379 if (RtpHeaderParser::IsRtcp(packet, length))
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +02001380 return DeliverRtcp(media_type, packet, length);
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001381
stefan68786d22015-09-08 05:36:15 -07001382 return DeliverRtp(media_type, packet, length, packet_time);
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001383}
1384
brandtr4e523862016-10-18 23:50:45 -07001385// TODO(brandtr): Update this member function when we support protecting
1386// audio packets with FlexFEC.
nissed2ef3142017-05-11 08:00:58 -07001387void Call::OnRecoveredPacket(const uint8_t* packet, size_t length) {
brandtr4e523862016-10-18 23:50:45 -07001388 ReadLockScoped read_lock(*receive_crit_);
nissed2ef3142017-05-11 08:00:58 -07001389 rtc::Optional<RtpPacketReceived> parsed_packet =
1390 ParseRtpPacket(packet, length, nullptr);
1391 if (!parsed_packet)
1392 return;
1393
1394 parsed_packet->set_recovered(true);
1395
eladalon2a2b2972017-07-03 09:25:27 -07001396 video_receiver_controller_.OnRtpPacket(*parsed_packet);
brandtr4e523862016-10-18 23:50:45 -07001397}
1398
nissed44ce052017-02-06 02:23:00 -08001399void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
1400 MediaType media_type) {
1401 auto it = receive_rtp_config_.find(packet.Ssrc());
nisse4709e892017-02-07 01:18:43 -08001402 bool use_send_side_bwe =
1403 (it != receive_rtp_config_.end()) && it->second.use_send_side_bwe;
nissed44ce052017-02-06 02:23:00 -08001404
brandtrb29e6522016-12-21 06:37:18 -08001405 RTPHeader header;
1406 packet.GetHeader(&header);
nissed44ce052017-02-06 02:23:00 -08001407
nisse4709e892017-02-07 01:18:43 -08001408 if (!use_send_side_bwe && header.extension.hasTransportSequenceNumber) {
nissed44ce052017-02-06 02:23:00 -08001409 // Inconsistent configuration of send side BWE. Do nothing.
1410 // TODO(nisse): Without this check, we may produce RTCP feedback
1411 // packets even when not negotiated. But it would be cleaner to
1412 // move the check down to RTCPSender::SendFeedbackPacket, which
1413 // would also help the PacketRouter to select an appropriate rtp
1414 // module in the case that some, but not all, have RTCP feedback
1415 // enabled.
1416 return;
1417 }
1418 // For audio, we only support send side BWE.
nissee5ad5ca2017-03-29 23:57:43 -07001419 if (media_type == MediaType::VIDEO ||
nisse4709e892017-02-07 01:18:43 -08001420 (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
nisse559af382017-03-21 06:41:12 -07001421 receive_side_cc_.OnReceivedPacket(
nissed44ce052017-02-06 02:23:00 -08001422 packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
1423 header);
1424 }
brandtrb29e6522016-12-21 06:37:18 -08001425}
1426
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001427} // namespace internal
nisseb8f9a322017-03-27 05:36:15 -07001428
pbos@webrtc.org29d58392013-05-16 12:08:03 +00001429} // namespace webrtc