blob: 5d6bbabdbd456846cec009240f7b17f84800aaad [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>
pbos@webrtc.org29d58392013-05-16 12:08:03 +000015#include <vector>
16
Peter Boström5c389d32015-09-25 13:58:30 +020017#include "webrtc/audio/audio_receive_stream.h"
solenbergc7a8b082015-10-16 14:35:07 -070018#include "webrtc/audio/audio_send_stream.h"
solenberg566ef242015-11-06 15:34:49 -080019#include "webrtc/audio/audio_state.h"
20#include "webrtc/audio/scoped_voe_interface.h"
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +000021#include "webrtc/base/checks.h"
kwiberg4485ffb2016-04-26 08:14:39 -070022#include "webrtc/base/constructormagic.h"
Peter Boström7c704b82015-12-04 16:13:05 +010023#include "webrtc/base/logging.h"
perkj26091b12016-09-01 01:17:40 -070024#include "webrtc/base/task_queue.h"
pbos@webrtc.org38344ed2014-09-24 06:05:00 +000025#include "webrtc/base/thread_annotations.h"
solenberg5a289392015-10-19 03:39:20 -070026#include "webrtc/base/thread_checker.h"
tommie4f96502015-10-20 23:00:48 -070027#include "webrtc/base/trace_event.h"
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000028#include "webrtc/call.h"
mflodman0e7e2592015-11-12 21:02:42 -080029#include "webrtc/call/bitrate_allocator.h"
pbos@webrtc.orgc49d5b72013-12-05 12:11:47 +000030#include "webrtc/config.h"
skvladcc91d282016-10-03 18:31:22 -070031#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
mflodman0e7e2592015-11-12 21:02:42 -080032#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
Stefan Holmer80e12072016-02-23 13:30:42 +010033#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
Henrik Kjellander0b9e29c2015-11-16 11:12:24 +010034#include "webrtc/modules/pacing/paced_sender.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"
Henrik Kjellanderff761fb2015-11-04 08:31:52 +010037#include "webrtc/modules/utility/include/process_thread.h"
ivoc14d5dbe2016-07-04 07:06:55 -070038#include "webrtc/system_wrappers/include/clock.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010039#include "webrtc/system_wrappers/include/cpu_info.h"
40#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
stefan91d92602015-11-11 10:13:02 -080041#include "webrtc/system_wrappers/include/metrics.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010042#include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
43#include "webrtc/system_wrappers/include/trace.h"
Peter Boström7623ce42015-12-09 12:13:30 +010044#include "webrtc/video/call_stats.h"
asapersson35151f32016-05-02 23:44:01 -070045#include "webrtc/video/send_delay_stats.h"
asapersson250fd972016-09-08 00:07:21 -070046#include "webrtc/video/stats_counter.h"
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000047#include "webrtc/video/video_receive_stream.h"
48#include "webrtc/video/video_send_stream.h"
Stefan Holmer58c664c2016-02-08 14:31:30 +010049#include "webrtc/video/vie_remb.h"
ivocb04965c2015-09-09 00:09:43 -070050#include "webrtc/voice_engine/include/voe_codec.h"
pbos@webrtc.org29d58392013-05-16 12:08:03 +000051
52namespace webrtc {
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +000053
pbos@webrtc.orga73a6782014-10-14 11:52:10 +000054const int Call::Config::kDefaultStartBitrateBps = 300000;
55
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000056namespace internal {
asapersson@webrtc.orgbdc5ed22014-01-31 10:05:07 +000057
perkjec81bcd2016-05-11 06:01:13 -070058class Call : public webrtc::Call,
59 public PacketReceiver,
perkj71ee44c2016-06-15 00:47:53 -070060 public CongestionController::Observer,
61 public BitrateAllocator::LimitObserver {
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000062 public:
Peter Boström45553ae2015-05-08 13:54:38 +020063 explicit Call(const Call::Config& config);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000064 virtual ~Call();
65
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000066 PacketReceiver* Receiver() override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000067
Fredrik Solenberg04f49312015-06-08 13:04:56 +020068 webrtc::AudioSendStream* CreateAudioSendStream(
69 const webrtc::AudioSendStream::Config& config) override;
70 void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override;
71
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +020072 webrtc::AudioReceiveStream* CreateAudioReceiveStream(
73 const webrtc::AudioReceiveStream::Config& config) override;
74 void DestroyAudioReceiveStream(
75 webrtc::AudioReceiveStream* receive_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000076
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +020077 webrtc::VideoSendStream* CreateVideoSendStream(
perkj26091b12016-09-01 01:17:40 -070078 webrtc::VideoSendStream::Config config,
79 VideoEncoderConfig encoder_config) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000080 void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000081
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +020082 webrtc::VideoReceiveStream* CreateVideoReceiveStream(
Tommi733b5472016-06-10 17:58:01 +020083 webrtc::VideoReceiveStream::Config configuration) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000084 void DestroyVideoReceiveStream(
85 webrtc::VideoReceiveStream* receive_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000086
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000087 Stats GetStats() const override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000088
stefan68786d22015-09-08 05:36:15 -070089 DeliveryStatus DeliverPacket(MediaType media_type,
90 const uint8_t* packet,
91 size_t length,
92 const PacketTime& packet_time) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000093
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000094 void SetBitrateConfig(
95 const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
skvlad7a43d252016-03-22 15:32:27 -070096
97 void SignalChannelNetworkState(MediaType media, NetworkState state) override;
pbos@webrtc.org26c0c412014-09-03 16:17:12 +000098
Honghai Zhang0e533ef2016-04-19 15:41:36 -070099 void OnNetworkRouteChanged(const std::string& transport_name,
100 const rtc::NetworkRoute& network_route) override;
101
stefanc1aeaf02015-10-15 07:26:07 -0700102 void OnSentPacket(const rtc::SentPacket& sent_packet) override;
103
mflodman0e7e2592015-11-12 21:02:42 -0800104 // Implements BitrateObserver.
105 void OnNetworkChanged(uint32_t bitrate_bps, uint8_t fraction_loss,
106 int64_t rtt_ms) override;
107
perkj71ee44c2016-06-15 00:47:53 -0700108 // Implements BitrateAllocator::LimitObserver.
109 void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
110 uint32_t max_padding_bitrate_bps) override;
111
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000112 private:
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200113 DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet,
114 size_t length);
stefan68786d22015-09-08 05:36:15 -0700115 DeliveryStatus DeliverRtp(MediaType media_type,
116 const uint8_t* packet,
117 size_t length,
118 const PacketTime& packet_time);
pbos8fc7fa72015-07-15 08:02:58 -0700119 void ConfigureSync(const std::string& sync_group)
120 EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
121
solenberg566ef242015-11-06 15:34:49 -0800122 VoiceEngine* voice_engine() {
123 internal::AudioState* audio_state =
124 static_cast<internal::AudioState*>(config_.audio_state.get());
125 if (audio_state)
126 return audio_state->voice_engine();
127 else
128 return nullptr;
129 }
130
Stefan Holmer226befe2015-11-26 15:36:48 +0100131 void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
stefan18adf0a2015-11-17 06:24:56 -0800132 void UpdateReceiveHistograms();
asapersson4374a092016-07-27 00:39:09 -0700133 void UpdateHistograms();
skvlad7a43d252016-03-22 15:32:27 -0700134 void UpdateAggregateNetworkState();
stefan91d92602015-11-11 10:13:02 -0800135
Peter Boströmd3c94472015-12-09 11:20:58 +0100136 Clock* const clock_;
stefan91d92602015-11-11 10:13:02 -0800137
Peter Boström45553ae2015-05-08 13:54:38 +0200138 const int num_cpu_cores_;
kwibergb25345e2016-03-12 06:10:44 -0800139 const std::unique_ptr<ProcessThread> module_process_thread_;
140 const std::unique_ptr<ProcessThread> pacer_thread_;
141 const std::unique_ptr<CallStats> call_stats_;
142 const std::unique_ptr<BitrateAllocator> bitrate_allocator_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000143 Call::Config config_;
solenberg5a289392015-10-19 03:39:20 -0700144 rtc::ThreadChecker configuration_thread_checker_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000145
skvlad7a43d252016-03-22 15:32:27 -0700146 NetworkState audio_network_state_;
147 NetworkState video_network_state_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000148
kwibergb25345e2016-03-12 06:10:44 -0800149 std::unique_ptr<RWLockWrapper> receive_crit_;
solenbergc7a8b082015-10-16 14:35:07 -0700150 // Audio and Video receive streams are owned by the client that creates them.
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200151 std::map<uint32_t, AudioReceiveStream*> audio_receive_ssrcs_
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000152 GUARDED_BY(receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200153 std::map<uint32_t, VideoReceiveStream*> video_receive_ssrcs_
154 GUARDED_BY(receive_crit_);
155 std::set<VideoReceiveStream*> video_receive_streams_
156 GUARDED_BY(receive_crit_);
pbos8fc7fa72015-07-15 08:02:58 -0700157 std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
158 GUARDED_BY(receive_crit_);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000159
kwibergb25345e2016-03-12 06:10:44 -0800160 std::unique_ptr<RWLockWrapper> send_crit_;
solenbergc7a8b082015-10-16 14:35:07 -0700161 // Audio and Video send streams are owned by the client that creates them.
162 std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200163 std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
164 std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000165
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200166 VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
skvlad11a9cbf2016-10-07 11:53:05 -0700167 webrtc::RtcEventLog* event_log_;
ivocb04965c2015-09-09 00:09:43 -0700168
stefan18adf0a2015-11-17 06:24:56 -0800169 // The following members are only accessed (exclusively) from one thread and
170 // from the destructor, and therefore doesn't need any explicit
171 // synchronization.
Stefan Holmer226befe2015-11-26 15:36:48 +0100172 int64_t first_packet_sent_ms_;
asapersson250fd972016-09-08 00:07:21 -0700173 RateCounter received_bytes_per_second_counter_;
174 RateCounter received_audio_bytes_per_second_counter_;
175 RateCounter received_video_bytes_per_second_counter_;
176 RateCounter received_rtcp_bytes_per_second_counter_;
stefan91d92602015-11-11 10:13:02 -0800177
stefan18adf0a2015-11-17 06:24:56 -0800178 // TODO(holmer): Remove this lock once BitrateController no longer calls
179 // OnNetworkChanged from multiple threads.
180 rtc::CriticalSection bitrate_crit_;
perkj71ee44c2016-06-15 00:47:53 -0700181 uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
sprang9c0b5512016-07-06 00:54:28 -0700182 uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
asaperssonce2e1362016-09-09 00:13:35 -0700183 AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
184 AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
stefan18adf0a2015-11-17 06:24:56 -0800185
Honghai Zhang0e533ef2016-04-19 15:41:36 -0700186 std::map<std::string, rtc::NetworkRoute> network_routes_;
187
Stefan Holmer58c664c2016-02-08 14:31:30 +0100188 VieRemb remb_;
kwibergb25345e2016-03-12 06:10:44 -0800189 const std::unique_ptr<CongestionController> congestion_controller_;
asapersson35151f32016-05-02 23:44:01 -0700190 const std::unique_ptr<SendDelayStats> video_send_delay_stats_;
asapersson4374a092016-07-27 00:39:09 -0700191 const int64_t start_ms_;
perkj26091b12016-09-01 01:17:40 -0700192 // TODO(perkj): |worker_queue_| is supposed to replace
193 // |module_process_thread_|.
194 // |worker_queue| is defined last to ensure all pending tasks are cancelled
195 // and deleted before any other members.
196 rtc::TaskQueue worker_queue_;
mflodman0e7e2592015-11-12 21:02:42 -0800197
henrikg3c089d72015-09-16 05:37:44 -0700198 RTC_DISALLOW_COPY_AND_ASSIGN(Call);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000199};
pbos@webrtc.orgc49d5b72013-12-05 12:11:47 +0000200} // namespace internal
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000201
asapersson2e5cfcd2016-08-11 08:41:18 -0700202std::string Call::Stats::ToString(int64_t time_ms) const {
203 std::stringstream ss;
204 ss << "Call stats: " << time_ms << ", {";
205 ss << "send_bw_bps: " << send_bandwidth_bps << ", ";
206 ss << "recv_bw_bps: " << recv_bandwidth_bps << ", ";
207 ss << "max_pad_bps: " << max_padding_bitrate_bps << ", ";
208 ss << "pacer_delay_ms: " << pacer_delay_ms << ", ";
209 ss << "rtt_ms: " << rtt_ms;
210 ss << '}';
211 return ss.str();
212}
213
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000214Call* Call::Create(const Call::Config& config) {
Peter Boström45553ae2015-05-08 13:54:38 +0200215 return new internal::Call(config);
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000216}
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000217
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000218namespace internal {
219
Peter Boström45553ae2015-05-08 13:54:38 +0200220Call::Call(const Call::Config& config)
stefan91d92602015-11-11 10:13:02 -0800221 : clock_(Clock::GetRealTimeClock()),
222 num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
kwiberg1c7fdd82016-04-26 08:18:04 -0700223 module_process_thread_(ProcessThread::Create("ModuleProcessThread")),
224 pacer_thread_(ProcessThread::Create("PacerThread")),
Peter Boströmd3c94472015-12-09 11:20:58 +0100225 call_stats_(new CallStats(clock_)),
perkj71ee44c2016-06-15 00:47:53 -0700226 bitrate_allocator_(new BitrateAllocator(this)),
Peter Boström45553ae2015-05-08 13:54:38 +0200227 config_(config),
skvlad7a43d252016-03-22 15:32:27 -0700228 audio_network_state_(kNetworkUp),
229 video_network_state_(kNetworkUp),
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000230 receive_crit_(RWLockWrapper::CreateRWLock()),
stefan91d92602015-11-11 10:13:02 -0800231 send_crit_(RWLockWrapper::CreateRWLock()),
skvlad11a9cbf2016-10-07 11:53:05 -0700232 event_log_(config.event_log),
Stefan Holmer226befe2015-11-26 15:36:48 +0100233 first_packet_sent_ms_(-1),
asapersson250fd972016-09-08 00:07:21 -0700234 received_bytes_per_second_counter_(clock_, nullptr, true),
235 received_audio_bytes_per_second_counter_(clock_, nullptr, true),
236 received_video_bytes_per_second_counter_(clock_, nullptr, true),
237 received_rtcp_bytes_per_second_counter_(clock_, nullptr, true),
perkj71ee44c2016-06-15 00:47:53 -0700238 min_allocated_send_bitrate_bps_(0),
sprang9c0b5512016-07-06 00:54:28 -0700239 configured_max_padding_bitrate_bps_(0),
asaperssonce2e1362016-09-09 00:13:35 -0700240 estimated_send_bitrate_kbps_counter_(clock_, nullptr, true),
241 pacer_bitrate_kbps_counter_(clock_, nullptr, true),
Stefan Holmer58c664c2016-02-08 14:31:30 +0100242 remb_(clock_),
ivoc14d5dbe2016-07-04 07:06:55 -0700243 congestion_controller_(
skvlad11a9cbf2016-10-07 11:53:05 -0700244 new CongestionController(clock_, this, &remb_, event_log_)),
asapersson4374a092016-07-27 00:39:09 -0700245 video_send_delay_stats_(new SendDelayStats(clock_)),
perkj26091b12016-09-01 01:17:40 -0700246 start_ms_(clock_->TimeInMilliseconds()),
247 worker_queue_("call_worker_queue") {
solenberg56a34df2015-11-12 08:24:41 -0800248 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
skvlad11a9cbf2016-10-07 11:53:05 -0700249 RTC_DCHECK(config.event_log != nullptr);
henrikg91d6ede2015-09-17 00:24:34 -0700250 RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
251 RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps,
252 config.bitrate_config.min_bitrate_bps);
Stefan Holmere5904162015-03-26 11:11:06 +0100253 if (config.bitrate_config.max_bitrate_bps != -1) {
henrikg91d6ede2015-09-17 00:24:34 -0700254 RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
255 config.bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000256 }
Peter Boström45553ae2015-05-08 13:54:38 +0200257 Trace::CreateTrace();
Stefan Holmer789ba922016-02-17 15:52:17 +0100258 call_stats_->RegisterStatsObserver(congestion_controller_.get());
Peter Boström45553ae2015-05-08 13:54:38 +0200259
mflodman0c478b32015-10-21 15:52:16 +0200260 congestion_controller_->SetBweBitrates(
261 config_.bitrate_config.min_bitrate_bps,
262 config_.bitrate_config.start_bitrate_bps,
263 config_.bitrate_config.max_bitrate_bps);
Stefan Holmerc379fcb2016-02-24 16:02:55 +0100264
265 module_process_thread_->Start();
266 module_process_thread_->RegisterModule(call_stats_.get());
267 module_process_thread_->RegisterModule(congestion_controller_.get());
268 pacer_thread_->RegisterModule(congestion_controller_->pacer());
269 pacer_thread_->RegisterModule(
270 congestion_controller_->GetRemoteBitrateEstimator(true));
271 pacer_thread_->Start();
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000272}
273
pbos@webrtc.org841c8a42013-09-09 15:04:25 +0000274Call::~Call() {
Stefan Holmer58c664c2016-02-08 14:31:30 +0100275 RTC_DCHECK(!remb_.InUse());
solenberg5a289392015-10-19 03:39:20 -0700276 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
perkj26091b12016-09-01 01:17:40 -0700277
solenbergc7a8b082015-10-16 14:35:07 -0700278 RTC_CHECK(audio_send_ssrcs_.empty());
279 RTC_CHECK(video_send_ssrcs_.empty());
280 RTC_CHECK(video_send_streams_.empty());
281 RTC_CHECK(audio_receive_ssrcs_.empty());
282 RTC_CHECK(video_receive_ssrcs_.empty());
283 RTC_CHECK(video_receive_streams_.empty());
pbos@webrtc.org9e4e5242015-02-12 10:48:23 +0000284
Stefan Holmerc379fcb2016-02-24 16:02:55 +0100285 pacer_thread_->Stop();
286 pacer_thread_->DeRegisterModule(congestion_controller_->pacer());
287 pacer_thread_->DeRegisterModule(
288 congestion_controller_->GetRemoteBitrateEstimator(true));
Stefan Holmer789ba922016-02-17 15:52:17 +0100289 module_process_thread_->DeRegisterModule(congestion_controller_.get());
mflodmane3787022015-10-21 13:24:28 +0200290 module_process_thread_->DeRegisterModule(call_stats_.get());
Peter Boström45553ae2015-05-08 13:54:38 +0200291 module_process_thread_->Stop();
Stefan Holmerc379fcb2016-02-24 16:02:55 +0100292 call_stats_->DeregisterStatsObserver(congestion_controller_.get());
sprang6d6122b2016-07-13 06:37:09 -0700293
294 // Only update histograms after process threads have been shut down, so that
295 // they won't try to concurrently update stats.
perkj26091b12016-09-01 01:17:40 -0700296 {
297 rtc::CritScope lock(&bitrate_crit_);
298 UpdateSendHistograms();
299 }
sprang6d6122b2016-07-13 06:37:09 -0700300 UpdateReceiveHistograms();
asapersson4374a092016-07-27 00:39:09 -0700301 UpdateHistograms();
sprang6d6122b2016-07-13 06:37:09 -0700302
Peter Boström45553ae2015-05-08 13:54:38 +0200303 Trace::ReturnTrace();
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000304}
305
asapersson4374a092016-07-27 00:39:09 -0700306void Call::UpdateHistograms() {
asapersson1d02d3e2016-09-09 22:40:25 -0700307 RTC_HISTOGRAM_COUNTS_100000(
asapersson4374a092016-07-27 00:39:09 -0700308 "WebRTC.Call.LifetimeInSeconds",
309 (clock_->TimeInMilliseconds() - start_ms_) / 1000);
310}
311
stefan18adf0a2015-11-17 06:24:56 -0800312void Call::UpdateSendHistograms() {
asaperssonce2e1362016-09-09 00:13:35 -0700313 if (first_packet_sent_ms_ == -1)
stefan18adf0a2015-11-17 06:24:56 -0800314 return;
315 int64_t elapsed_sec =
316 (clock_->TimeInMilliseconds() - first_packet_sent_ms_) / 1000;
317 if (elapsed_sec < metrics::kMinRunTimeInSeconds)
318 return;
asaperssonce2e1362016-09-09 00:13:35 -0700319 const int kMinRequiredPeriodicSamples = 5;
320 AggregatedStats send_bitrate_stats =
321 estimated_send_bitrate_kbps_counter_.ProcessAndGetStats();
322 if (send_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700323 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps",
324 send_bitrate_stats.average);
stefan18adf0a2015-11-17 06:24:56 -0800325 }
asaperssonce2e1362016-09-09 00:13:35 -0700326 AggregatedStats pacer_bitrate_stats =
327 pacer_bitrate_kbps_counter_.ProcessAndGetStats();
328 if (pacer_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700329 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.PacerBitrateInKbps",
330 pacer_bitrate_stats.average);
stefan18adf0a2015-11-17 06:24:56 -0800331 }
332}
333
334void Call::UpdateReceiveHistograms() {
asapersson250fd972016-09-08 00:07:21 -0700335 const int kMinRequiredPeriodicSamples = 5;
336 AggregatedStats video_bytes_per_sec =
337 received_video_bytes_per_second_counter_.GetStats();
338 if (video_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700339 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.VideoBitrateReceivedInKbps",
340 video_bytes_per_sec.average * 8 / 1000);
stefan91d92602015-11-11 10:13:02 -0800341 }
asapersson250fd972016-09-08 00:07:21 -0700342 AggregatedStats audio_bytes_per_sec =
343 received_audio_bytes_per_second_counter_.GetStats();
344 if (audio_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700345 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.AudioBitrateReceivedInKbps",
346 audio_bytes_per_sec.average * 8 / 1000);
stefan91d92602015-11-11 10:13:02 -0800347 }
asapersson250fd972016-09-08 00:07:21 -0700348 AggregatedStats rtcp_bytes_per_sec =
349 received_rtcp_bytes_per_second_counter_.GetStats();
350 if (rtcp_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700351 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.RtcpBitrateReceivedInBps",
352 rtcp_bytes_per_sec.average * 8);
stefan91d92602015-11-11 10:13:02 -0800353 }
asapersson250fd972016-09-08 00:07:21 -0700354 AggregatedStats recv_bytes_per_sec =
355 received_bytes_per_second_counter_.GetStats();
356 if (recv_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-09 22:40:25 -0700357 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.BitrateReceivedInKbps",
358 recv_bytes_per_sec.average * 8 / 1000);
asapersson250fd972016-09-08 00:07:21 -0700359 }
stefan91d92602015-11-11 10:13:02 -0800360}
361
solenberg5a289392015-10-19 03:39:20 -0700362PacketReceiver* Call::Receiver() {
363 // TODO(solenberg): Some test cases in EndToEndTest use this from a different
364 // thread. Re-enable once that is fixed.
365 // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
366 return this;
367}
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000368
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200369webrtc::AudioSendStream* Call::CreateAudioSendStream(
370 const webrtc::AudioSendStream::Config& config) {
solenbergc7a8b082015-10-16 14:35:07 -0700371 TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
solenberg5a289392015-10-19 03:39:20 -0700372 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100373 AudioSendStream* send_stream = new AudioSendStream(
perkj26091b12016-09-01 01:17:40 -0700374 config, config_.audio_state, &worker_queue_, congestion_controller_.get(),
skvlad11a9cbf2016-10-07 11:53:05 -0700375 bitrate_allocator_.get(), event_log_);
solenbergc7a8b082015-10-16 14:35:07 -0700376 {
solenbergc7a8b082015-10-16 14:35:07 -0700377 WriteLockScoped write_lock(*send_crit_);
378 RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) ==
379 audio_send_ssrcs_.end());
380 audio_send_ssrcs_[config.rtp.ssrc] = send_stream;
solenbergc7a8b082015-10-16 14:35:07 -0700381 }
skvlad7a43d252016-03-22 15:32:27 -0700382 send_stream->SignalNetworkState(audio_network_state_);
383 UpdateAggregateNetworkState();
solenbergc7a8b082015-10-16 14:35:07 -0700384 return send_stream;
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200385}
386
387void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
solenbergc7a8b082015-10-16 14:35:07 -0700388 TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream");
solenberg5a289392015-10-19 03:39:20 -0700389 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
solenbergc7a8b082015-10-16 14:35:07 -0700390 RTC_DCHECK(send_stream != nullptr);
391
392 send_stream->Stop();
393
394 webrtc::internal::AudioSendStream* audio_send_stream =
395 static_cast<webrtc::internal::AudioSendStream*>(send_stream);
396 {
397 WriteLockScoped write_lock(*send_crit_);
398 size_t num_deleted = audio_send_ssrcs_.erase(
399 audio_send_stream->config().rtp.ssrc);
400 RTC_DCHECK(num_deleted == 1);
401 }
skvlad7a43d252016-03-22 15:32:27 -0700402 UpdateAggregateNetworkState();
solenbergc7a8b082015-10-16 14:35:07 -0700403 delete audio_send_stream;
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200404}
405
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200406webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
407 const webrtc::AudioReceiveStream::Config& config) {
408 TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
solenberg5a289392015-10-19 03:39:20 -0700409 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
skvlad11a9cbf2016-10-07 11:53:05 -0700410 AudioReceiveStream* receive_stream = new AudioReceiveStream(
411 congestion_controller_.get(), config, config_.audio_state, event_log_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200412 {
413 WriteLockScoped write_lock(*receive_crit_);
henrikg91d6ede2015-09-17 00:24:34 -0700414 RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
415 audio_receive_ssrcs_.end());
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200416 audio_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
pbos8fc7fa72015-07-15 08:02:58 -0700417 ConfigureSync(config.sync_group);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200418 }
skvlad7a43d252016-03-22 15:32:27 -0700419 receive_stream->SignalNetworkState(audio_network_state_);
420 UpdateAggregateNetworkState();
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200421 return receive_stream;
422}
423
424void Call::DestroyAudioReceiveStream(
425 webrtc::AudioReceiveStream* receive_stream) {
426 TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream");
solenberg5a289392015-10-19 03:39:20 -0700427 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 00:24:34 -0700428 RTC_DCHECK(receive_stream != nullptr);
solenbergc7a8b082015-10-16 14:35:07 -0700429 webrtc::internal::AudioReceiveStream* audio_receive_stream =
430 static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200431 {
432 WriteLockScoped write_lock(*receive_crit_);
433 size_t num_deleted = audio_receive_ssrcs_.erase(
434 audio_receive_stream->config().rtp.remote_ssrc);
henrikg91d6ede2015-09-17 00:24:34 -0700435 RTC_DCHECK(num_deleted == 1);
pbos8fc7fa72015-07-15 08:02:58 -0700436 const std::string& sync_group = audio_receive_stream->config().sync_group;
437 const auto it = sync_stream_mapping_.find(sync_group);
438 if (it != sync_stream_mapping_.end() &&
439 it->second == audio_receive_stream) {
440 sync_stream_mapping_.erase(it);
441 ConfigureSync(sync_group);
442 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200443 }
skvlad7a43d252016-03-22 15:32:27 -0700444 UpdateAggregateNetworkState();
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200445 delete audio_receive_stream;
446}
447
448webrtc::VideoSendStream* Call::CreateVideoSendStream(
perkj26091b12016-09-01 01:17:40 -0700449 webrtc::VideoSendStream::Config config,
450 VideoEncoderConfig encoder_config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000451 TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream");
solenberg5a289392015-10-19 03:39:20 -0700452 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org1819fd72013-06-10 13:48:26 +0000453
asapersson35151f32016-05-02 23:44:01 -0700454 video_send_delay_stats_->AddSsrcs(config);
perkj26091b12016-09-01 01:17:40 -0700455 event_log_->LogVideoSendStreamConfig(config);
456
mflodman@webrtc.orgeb16b812014-06-16 08:57:39 +0000457 // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
458 // the call has already started.
perkj26091b12016-09-01 01:17:40 -0700459 // Copy ssrcs from |config| since |config| is moved.
460 std::vector<uint32_t> ssrcs = config.rtp.ssrcs;
mflodman0c478b32015-10-21 15:52:16 +0200461 VideoSendStream* send_stream = new VideoSendStream(
perkj26091b12016-09-01 01:17:40 -0700462 num_cpu_cores_, module_process_thread_.get(), &worker_queue_,
463 call_stats_.get(), congestion_controller_.get(), bitrate_allocator_.get(),
skvlad11a9cbf2016-10-07 11:53:05 -0700464 video_send_delay_stats_.get(), &remb_, event_log_, std::move(config),
465 std::move(encoder_config), suspended_video_send_ssrcs_);
perkj26091b12016-09-01 01:17:40 -0700466
skvlad7a43d252016-03-22 15:32:27 -0700467 {
468 WriteLockScoped write_lock(*send_crit_);
perkj26091b12016-09-01 01:17:40 -0700469 for (uint32_t ssrc : ssrcs) {
skvlad7a43d252016-03-22 15:32:27 -0700470 RTC_DCHECK(video_send_ssrcs_.find(ssrc) == video_send_ssrcs_.end());
471 video_send_ssrcs_[ssrc] = send_stream;
472 }
473 video_send_streams_.insert(send_stream);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000474 }
skvlad7a43d252016-03-22 15:32:27 -0700475 send_stream->SignalNetworkState(video_network_state_);
476 UpdateAggregateNetworkState();
perkj26091b12016-09-01 01:17:40 -0700477
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000478 return send_stream;
479}
480
pbos@webrtc.org2c46f8d2013-11-21 13:49:43 +0000481void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000482 TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream");
henrikg91d6ede2015-09-17 00:24:34 -0700483 RTC_DCHECK(send_stream != nullptr);
solenberg5a289392015-10-19 03:39:20 -0700484 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000485
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000486 send_stream->Stop();
487
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000488 VideoSendStream* send_stream_impl = nullptr;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000489 {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000490 WriteLockScoped write_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200491 auto it = video_send_ssrcs_.begin();
492 while (it != video_send_ssrcs_.end()) {
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000493 if (it->second == static_cast<VideoSendStream*>(send_stream)) {
494 send_stream_impl = it->second;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200495 video_send_ssrcs_.erase(it++);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000496 } else {
497 ++it;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000498 }
499 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200500 video_send_streams_.erase(send_stream_impl);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000501 }
henrikg91d6ede2015-09-17 00:24:34 -0700502 RTC_CHECK(send_stream_impl != nullptr);
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000503
perkj26091b12016-09-01 01:17:40 -0700504 VideoSendStream::RtpStateMap rtp_state =
505 send_stream_impl->StopPermanentlyAndGetRtpStates();
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000506
507 for (VideoSendStream::RtpStateMap::iterator it = rtp_state.begin();
perkj26091b12016-09-01 01:17:40 -0700508 it != rtp_state.end(); ++it) {
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200509 suspended_video_send_ssrcs_[it->first] = it->second;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000510 }
511
skvlad7a43d252016-03-22 15:32:27 -0700512 UpdateAggregateNetworkState();
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000513 delete send_stream_impl;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000514}
515
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200516webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
Tommi733b5472016-06-10 17:58:01 +0200517 webrtc::VideoReceiveStream::Config configuration) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000518 TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
solenberg5a289392015-10-19 03:39:20 -0700519 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
Peter Boströmc4188fd2015-04-24 15:16:03 +0200520 VideoReceiveStream* receive_stream = new VideoReceiveStream(
Tommi733b5472016-06-10 17:58:01 +0200521 num_cpu_cores_, congestion_controller_.get(), std::move(configuration),
522 voice_engine(), module_process_thread_.get(), call_stats_.get(), &remb_);
523
524 const webrtc::VideoReceiveStream::Config& config = receive_stream->config();
skvlad7a43d252016-03-22 15:32:27 -0700525 {
526 WriteLockScoped write_lock(*receive_crit_);
527 RTC_DCHECK(video_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
528 video_receive_ssrcs_.end());
529 video_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
530 // TODO(pbos): Configure different RTX payloads per receive payload.
531 VideoReceiveStream::Config::Rtp::RtxMap::const_iterator it =
532 config.rtp.rtx.begin();
533 if (it != config.rtp.rtx.end())
534 video_receive_ssrcs_[it->second.ssrc] = receive_stream;
535 video_receive_streams_.insert(receive_stream);
skvlad7a43d252016-03-22 15:32:27 -0700536 ConfigureSync(config.sync_group);
537 }
538 receive_stream->SignalNetworkState(video_network_state_);
539 UpdateAggregateNetworkState();
ivoc14d5dbe2016-07-04 07:06:55 -0700540 event_log_->LogVideoReceiveStreamConfig(config);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000541 return receive_stream;
542}
543
pbos@webrtc.org2c46f8d2013-11-21 13:49:43 +0000544void Call::DestroyVideoReceiveStream(
545 webrtc::VideoReceiveStream* receive_stream) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000546 TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
solenberg5a289392015-10-19 03:39:20 -0700547 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 00:24:34 -0700548 RTC_DCHECK(receive_stream != nullptr);
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000549 VideoReceiveStream* receive_stream_impl = nullptr;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000550 {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000551 WriteLockScoped write_lock(*receive_crit_);
pbos@webrtc.orgc279a5d2014-01-24 09:30:53 +0000552 // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a
553 // separate SSRC there can be either one or two.
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200554 auto it = video_receive_ssrcs_.begin();
555 while (it != video_receive_ssrcs_.end()) {
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000556 if (it->second == static_cast<VideoReceiveStream*>(receive_stream)) {
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000557 if (receive_stream_impl != nullptr)
henrikg91d6ede2015-09-17 00:24:34 -0700558 RTC_DCHECK(receive_stream_impl == it->second);
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000559 receive_stream_impl = it->second;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200560 video_receive_ssrcs_.erase(it++);
pbos@webrtc.orgc279a5d2014-01-24 09:30:53 +0000561 } else {
562 ++it;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000563 }
564 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200565 video_receive_streams_.erase(receive_stream_impl);
henrikg91d6ede2015-09-17 00:24:34 -0700566 RTC_CHECK(receive_stream_impl != nullptr);
pbos8fc7fa72015-07-15 08:02:58 -0700567 ConfigureSync(receive_stream_impl->config().sync_group);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000568 }
skvlad7a43d252016-03-22 15:32:27 -0700569 UpdateAggregateNetworkState();
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000570 delete receive_stream_impl;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000571}
572
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000573Call::Stats Call::GetStats() const {
solenberg5a289392015-10-19 03:39:20 -0700574 // TODO(solenberg): Some test cases in EndToEndTest use this from a different
575 // thread. Re-enable once that is fixed.
576 // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000577 Stats stats;
Peter Boström45553ae2015-05-08 13:54:38 +0200578 // Fetch available send/receive bitrates.
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000579 uint32_t send_bandwidth = 0;
mflodman0c478b32015-10-21 15:52:16 +0200580 congestion_controller_->GetBitrateController()->AvailableBandwidth(
581 &send_bandwidth);
Peter Boström45553ae2015-05-08 13:54:38 +0200582 std::vector<unsigned int> ssrcs;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000583 uint32_t recv_bandwidth = 0;
mflodman0c478b32015-10-21 15:52:16 +0200584 congestion_controller_->GetRemoteBitrateEstimator(false)->LatestEstimate(
mflodmana20de202015-10-18 22:08:19 -0700585 &ssrcs, &recv_bandwidth);
Peter Boström45553ae2015-05-08 13:54:38 +0200586 stats.send_bandwidth_bps = send_bandwidth;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000587 stats.recv_bandwidth_bps = recv_bandwidth;
mflodman0c478b32015-10-21 15:52:16 +0200588 stats.pacer_delay_ms = congestion_controller_->GetPacerQueuingDelayMs();
sprange2d83d62016-02-19 09:03:26 -0800589 stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt();
sprang9c0b5512016-07-06 00:54:28 -0700590 {
591 rtc::CritScope cs(&bitrate_crit_);
592 stats.max_padding_bitrate_bps = configured_max_padding_bitrate_bps_;
593 }
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000594 return stats;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000595}
596
pbos@webrtc.org00873182014-11-25 14:03:34 +0000597void Call::SetBitrateConfig(
598 const webrtc::Call::Config::BitrateConfig& bitrate_config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000599 TRACE_EVENT0("webrtc", "Call::SetBitrateConfig");
solenberg5a289392015-10-19 03:39:20 -0700600 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 00:24:34 -0700601 RTC_DCHECK_GE(bitrate_config.min_bitrate_bps, 0);
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000602 if (bitrate_config.max_bitrate_bps != -1)
henrikg91d6ede2015-09-17 00:24:34 -0700603 RTC_DCHECK_GT(bitrate_config.max_bitrate_bps, 0);
Stefan Holmere5904162015-03-26 11:11:06 +0100604 if (config_.bitrate_config.min_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34 +0000605 bitrate_config.min_bitrate_bps &&
606 (bitrate_config.start_bitrate_bps <= 0 ||
Stefan Holmere5904162015-03-26 11:11:06 +0100607 config_.bitrate_config.start_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34 +0000608 bitrate_config.start_bitrate_bps) &&
Stefan Holmere5904162015-03-26 11:11:06 +0100609 config_.bitrate_config.max_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34 +0000610 bitrate_config.max_bitrate_bps) {
611 // Nothing new to set, early abort to avoid encoder reconfigurations.
612 return;
613 }
Stefan Holmerbe402962016-07-08 16:16:41 +0200614 config_.bitrate_config.min_bitrate_bps = bitrate_config.min_bitrate_bps;
615 // Start bitrate of -1 means we should keep the old bitrate, which there is
616 // no point in remembering for the future.
617 if (bitrate_config.start_bitrate_bps > 0)
618 config_.bitrate_config.start_bitrate_bps = bitrate_config.start_bitrate_bps;
619 config_.bitrate_config.max_bitrate_bps = bitrate_config.max_bitrate_bps;
mflodman0c478b32015-10-21 15:52:16 +0200620 congestion_controller_->SetBweBitrates(bitrate_config.min_bitrate_bps,
621 bitrate_config.start_bitrate_bps,
622 bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000623}
624
skvlad7a43d252016-03-22 15:32:27 -0700625void Call::SignalChannelNetworkState(MediaType media, NetworkState state) {
solenberg5a289392015-10-19 03:39:20 -0700626 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
skvlad7a43d252016-03-22 15:32:27 -0700627 switch (media) {
628 case MediaType::AUDIO:
629 audio_network_state_ = state;
630 break;
631 case MediaType::VIDEO:
632 video_network_state_ = state;
633 break;
634 case MediaType::ANY:
635 case MediaType::DATA:
636 RTC_NOTREACHED();
637 break;
638 }
639
640 UpdateAggregateNetworkState();
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000641 {
skvlad7a43d252016-03-22 15:32:27 -0700642 ReadLockScoped read_lock(*send_crit_);
solenbergc7a8b082015-10-16 14:35:07 -0700643 for (auto& kv : audio_send_ssrcs_) {
skvlad7a43d252016-03-22 15:32:27 -0700644 kv.second->SignalNetworkState(audio_network_state_);
solenbergc7a8b082015-10-16 14:35:07 -0700645 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200646 for (auto& kv : video_send_ssrcs_) {
skvlad7a43d252016-03-22 15:32:27 -0700647 kv.second->SignalNetworkState(video_network_state_);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000648 }
649 }
650 {
skvlad7a43d252016-03-22 15:32:27 -0700651 ReadLockScoped read_lock(*receive_crit_);
652 for (auto& kv : audio_receive_ssrcs_) {
653 kv.second->SignalNetworkState(audio_network_state_);
654 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200655 for (auto& kv : video_receive_ssrcs_) {
skvlad7a43d252016-03-22 15:32:27 -0700656 kv.second->SignalNetworkState(video_network_state_);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000657 }
658 }
659}
660
Honghai Zhang0e533ef2016-04-19 15:41:36 -0700661// TODO(honghaiz): Add tests for this method.
662void Call::OnNetworkRouteChanged(const std::string& transport_name,
663 const rtc::NetworkRoute& network_route) {
664 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
665 // Check if the network route is connected.
666 if (!network_route.connected) {
667 LOG(LS_INFO) << "Transport " << transport_name << " is disconnected";
668 // TODO(honghaiz): Perhaps handle this in SignalChannelNetworkState and
669 // consider merging these two methods.
670 return;
671 }
672
673 // Check whether the network route has changed on each transport.
674 auto result =
675 network_routes_.insert(std::make_pair(transport_name, network_route));
676 auto kv = result.first;
677 bool inserted = result.second;
678 if (inserted) {
679 // No need to reset BWE if this is the first time the network connects.
680 return;
681 }
682 if (kv->second != network_route) {
683 kv->second = network_route;
684 LOG(LS_INFO) << "Network route changed on transport " << transport_name
685 << ": new local network id " << network_route.local_network_id
honghaiz059e1832016-06-24 11:03:55 -0700686 << " new remote network id " << network_route.remote_network_id
Stefan Holmer52200d02016-09-20 14:14:23 +0200687 << " Reset bitrates to min: "
688 << config_.bitrate_config.min_bitrate_bps
689 << " bps, start: " << config_.bitrate_config.start_bitrate_bps
690 << " bps, max: " << config_.bitrate_config.start_bitrate_bps
691 << " bps.";
honghaiz059e1832016-06-24 11:03:55 -0700692 congestion_controller_->ResetBweAndBitrates(
693 config_.bitrate_config.start_bitrate_bps,
694 config_.bitrate_config.min_bitrate_bps,
695 config_.bitrate_config.max_bitrate_bps);
Honghai Zhang0e533ef2016-04-19 15:41:36 -0700696 }
697}
698
skvlad7a43d252016-03-22 15:32:27 -0700699void Call::UpdateAggregateNetworkState() {
700 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
701
702 bool have_audio = false;
703 bool have_video = false;
704 {
705 ReadLockScoped read_lock(*send_crit_);
706 if (audio_send_ssrcs_.size() > 0)
707 have_audio = true;
708 if (video_send_ssrcs_.size() > 0)
709 have_video = true;
710 }
711 {
712 ReadLockScoped read_lock(*receive_crit_);
713 if (audio_receive_ssrcs_.size() > 0)
714 have_audio = true;
715 if (video_receive_ssrcs_.size() > 0)
716 have_video = true;
717 }
718
719 NetworkState aggregate_state = kNetworkDown;
720 if ((have_video && video_network_state_ == kNetworkUp) ||
721 (have_audio && audio_network_state_ == kNetworkUp)) {
722 aggregate_state = kNetworkUp;
723 }
724
725 LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state="
726 << (aggregate_state == kNetworkUp ? "up" : "down");
727
728 congestion_controller_->SignalNetworkState(aggregate_state);
729}
730
stefanc1aeaf02015-10-15 07:26:07 -0700731void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
stefan18adf0a2015-11-17 06:24:56 -0800732 if (first_packet_sent_ms_ == -1)
733 first_packet_sent_ms_ = clock_->TimeInMilliseconds();
asapersson35151f32016-05-02 23:44:01 -0700734 video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
735 clock_->TimeInMilliseconds());
mflodman0c478b32015-10-21 15:52:16 +0200736 congestion_controller_->OnSentPacket(sent_packet);
stefanc1aeaf02015-10-15 07:26:07 -0700737}
738
mflodman0e7e2592015-11-12 21:02:42 -0800739void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
740 int64_t rtt_ms) {
perkj26091b12016-09-01 01:17:40 -0700741 // TODO(perkj): Consider making sure CongestionController operates on
742 // |worker_queue_|.
743 if (!worker_queue_.IsCurrent()) {
744 worker_queue_.PostTask([this, target_bitrate_bps, fraction_loss, rtt_ms] {
745 OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt_ms);
746 });
747 return;
748 }
749 RTC_DCHECK_RUN_ON(&worker_queue_);
perkj71ee44c2016-06-15 00:47:53 -0700750 bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, fraction_loss,
751 rtt_ms);
mflodman0e7e2592015-11-12 21:02:42 -0800752
asaperssonce2e1362016-09-09 00:13:35 -0700753 // Ignore updates if bitrate is zero (the aggregate network state is down).
754 if (target_bitrate_bps == 0) {
stefan18adf0a2015-11-17 06:24:56 -0800755 rtc::CritScope lock(&bitrate_crit_);
asaperssonce2e1362016-09-09 00:13:35 -0700756 estimated_send_bitrate_kbps_counter_.ProcessAndPause();
757 pacer_bitrate_kbps_counter_.ProcessAndPause();
758 return;
stefan18adf0a2015-11-17 06:24:56 -0800759 }
asaperssonce2e1362016-09-09 00:13:35 -0700760
761 bool sending_video;
762 {
763 ReadLockScoped read_lock(*send_crit_);
764 sending_video = !video_send_streams_.empty();
765 }
766
767 rtc::CritScope lock(&bitrate_crit_);
768 if (!sending_video) {
769 // Do not update the stats if we are not sending video.
770 estimated_send_bitrate_kbps_counter_.ProcessAndPause();
771 pacer_bitrate_kbps_counter_.ProcessAndPause();
772 return;
773 }
774 estimated_send_bitrate_kbps_counter_.Add(target_bitrate_bps / 1000);
775 // Pacer bitrate may be higher than bitrate estimate if enforcing min bitrate.
776 uint32_t pacer_bitrate_bps =
777 std::max(target_bitrate_bps, min_allocated_send_bitrate_bps_);
778 pacer_bitrate_kbps_counter_.Add(pacer_bitrate_bps / 1000);
perkj71ee44c2016-06-15 00:47:53 -0700779}
mflodman101f2502016-06-09 17:21:19 +0200780
perkj71ee44c2016-06-15 00:47:53 -0700781void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
782 uint32_t max_padding_bitrate_bps) {
783 congestion_controller_->SetAllocatedSendBitrateLimits(
784 min_send_bitrate_bps, max_padding_bitrate_bps);
785 rtc::CritScope lock(&bitrate_crit_);
786 min_allocated_send_bitrate_bps_ = min_send_bitrate_bps;
sprang9c0b5512016-07-06 00:54:28 -0700787 configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps;
mflodman0e7e2592015-11-12 21:02:42 -0800788}
789
pbos8fc7fa72015-07-15 08:02:58 -0700790void Call::ConfigureSync(const std::string& sync_group) {
791 // Set sync only if there was no previous one.
solenberg566ef242015-11-06 15:34:49 -0800792 if (voice_engine() == nullptr || sync_group.empty())
pbos8fc7fa72015-07-15 08:02:58 -0700793 return;
794
795 AudioReceiveStream* sync_audio_stream = nullptr;
796 // Find existing audio stream.
797 const auto it = sync_stream_mapping_.find(sync_group);
798 if (it != sync_stream_mapping_.end()) {
799 sync_audio_stream = it->second;
800 } else {
801 // No configured audio stream, see if we can find one.
802 for (const auto& kv : audio_receive_ssrcs_) {
803 if (kv.second->config().sync_group == sync_group) {
804 if (sync_audio_stream != nullptr) {
805 LOG(LS_WARNING) << "Attempting to sync more than one audio stream "
806 "within the same sync group. This is not "
807 "supported in the current implementation.";
808 break;
809 }
810 sync_audio_stream = kv.second;
811 }
812 }
813 }
814 if (sync_audio_stream)
815 sync_stream_mapping_[sync_group] = sync_audio_stream;
816 size_t num_synced_streams = 0;
817 for (VideoReceiveStream* video_stream : video_receive_streams_) {
818 if (video_stream->config().sync_group != sync_group)
819 continue;
820 ++num_synced_streams;
821 if (num_synced_streams > 1) {
822 // TODO(pbos): Support synchronizing more than one A/V pair.
823 // https://code.google.com/p/webrtc/issues/detail?id=4762
824 LOG(LS_WARNING) << "Attempting to sync more than one audio/video pair "
825 "within the same sync group. This is not supported in "
826 "the current implementation.";
827 }
828 // Only sync the first A/V pair within this sync group.
829 if (sync_audio_stream != nullptr && num_synced_streams == 1) {
solenberg566ef242015-11-06 15:34:49 -0800830 video_stream->SetSyncChannel(voice_engine(),
pbos8fc7fa72015-07-15 08:02:58 -0700831 sync_audio_stream->config().voe_channel_id);
832 } else {
solenberg566ef242015-11-06 15:34:49 -0800833 video_stream->SetSyncChannel(voice_engine(), -1);
pbos8fc7fa72015-07-15 08:02:58 -0700834 }
835 }
836}
837
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200838PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
839 const uint8_t* packet,
840 size_t length) {
Peter Boström6f28cf02015-12-07 23:17:15 +0100841 TRACE_EVENT0("webrtc", "Call::DeliverRtcp");
mflodman3d7db262016-04-29 00:57:13 -0700842 // TODO(pbos): Make sure it's a valid packet.
pbos@webrtc.orgcaba2d22014-05-14 13:57:12 +0000843 // Return DELIVERY_UNKNOWN_SSRC if it can be determined that
844 // there's no receiver of the packet.
asapersson250fd972016-09-08 00:07:21 -0700845 if (received_bytes_per_second_counter_.HasSample()) {
846 // First RTP packet has been received.
847 received_bytes_per_second_counter_.Add(static_cast<int>(length));
848 received_rtcp_bytes_per_second_counter_.Add(static_cast<int>(length));
849 }
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000850 bool rtcp_delivered = false;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200851 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000852 ReadLockScoped read_lock(*receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200853 for (VideoReceiveStream* stream : video_receive_streams_) {
mflodman3d7db262016-04-29 00:57:13 -0700854 if (stream->DeliverRtcp(packet, length))
pbos@webrtc.org40523702013-08-05 12:49:22 +0000855 rtcp_delivered = true;
mflodman3d7db262016-04-29 00:57:13 -0700856 }
857 }
858 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
859 ReadLockScoped read_lock(*receive_crit_);
860 for (auto& kv : audio_receive_ssrcs_) {
861 if (kv.second->DeliverRtcp(packet, length))
862 rtcp_delivered = true;
pbos@webrtc.orgbbb07e62013-08-05 12:01:36 +0000863 }
864 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200865 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000866 ReadLockScoped read_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200867 for (VideoSendStream* stream : video_send_streams_) {
mflodman3d7db262016-04-29 00:57:13 -0700868 if (stream->DeliverRtcp(packet, length))
pbos@webrtc.org40523702013-08-05 12:49:22 +0000869 rtcp_delivered = true;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000870 }
871 }
mflodman3d7db262016-04-29 00:57:13 -0700872 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
873 ReadLockScoped read_lock(*send_crit_);
874 for (auto& kv : audio_send_ssrcs_) {
875 if (kv.second->DeliverRtcp(packet, length))
876 rtcp_delivered = true;
877 }
878 }
879
skvlad11a9cbf2016-10-07 11:53:05 -0700880 if (rtcp_delivered)
mflodman3d7db262016-04-29 00:57:13 -0700881 event_log_->LogRtcpPacket(kIncomingPacket, media_type, packet, length);
882
pbos@webrtc.orgcaba2d22014-05-14 13:57:12 +0000883 return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000884}
885
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200886PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
887 const uint8_t* packet,
stefan68786d22015-09-08 05:36:15 -0700888 size_t length,
889 const PacketTime& packet_time) {
Peter Boström6f28cf02015-12-07 23:17:15 +0100890 TRACE_EVENT0("webrtc", "Call::DeliverRtp");
pbos@webrtc.orgaf38f4e2014-07-08 07:38:12 +0000891 // Minimum RTP header size.
892 if (length < 12)
893 return DELIVERY_PACKET_ERROR;
894
stefan91d92602015-11-11 10:13:02 -0800895 uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000896 ReadLockScoped read_lock(*receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200897 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
898 auto it = audio_receive_ssrcs_.find(ssrc);
899 if (it != audio_receive_ssrcs_.end()) {
asapersson250fd972016-09-08 00:07:21 -0700900 received_bytes_per_second_counter_.Add(static_cast<int>(length));
901 received_audio_bytes_per_second_counter_.Add(static_cast<int>(length));
ivocb04965c2015-09-09 00:09:43 -0700902 auto status = it->second->DeliverRtp(packet, length, packet_time)
903 ? DELIVERY_OK
904 : DELIVERY_PACKET_ERROR;
ivoc14d5dbe2016-07-04 07:06:55 -0700905 if (status == DELIVERY_OK)
terelius429c3452016-01-21 05:42:04 -0800906 event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
ivocb04965c2015-09-09 00:09:43 -0700907 return status;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200908 }
909 }
910 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
911 auto it = video_receive_ssrcs_.find(ssrc);
912 if (it != video_receive_ssrcs_.end()) {
asapersson250fd972016-09-08 00:07:21 -0700913 received_bytes_per_second_counter_.Add(static_cast<int>(length));
914 received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
ivocb04965c2015-09-09 00:09:43 -0700915 auto status = it->second->DeliverRtp(packet, length, packet_time)
916 ? DELIVERY_OK
917 : DELIVERY_PACKET_ERROR;
ivoc14d5dbe2016-07-04 07:06:55 -0700918 if (status == DELIVERY_OK)
terelius429c3452016-01-21 05:42:04 -0800919 event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
ivocb04965c2015-09-09 00:09:43 -0700920 return status;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200921 }
922 }
923 return DELIVERY_UNKNOWN_SSRC;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000924}
925
stefan68786d22015-09-08 05:36:15 -0700926PacketReceiver::DeliveryStatus Call::DeliverPacket(
927 MediaType media_type,
928 const uint8_t* packet,
929 size_t length,
930 const PacketTime& packet_time) {
solenberg5a289392015-10-19 03:39:20 -0700931 // TODO(solenberg): Tests call this function on a network thread, libjingle
932 // calls on the worker thread. We should move towards always using a network
933 // thread. Then this check can be enabled.
934 // RTC_DCHECK(!configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000935 if (RtpHeaderParser::IsRtcp(packet, length))
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200936 return DeliverRtcp(media_type, packet, length);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000937
stefan68786d22015-09-08 05:36:15 -0700938 return DeliverRtp(media_type, packet, length, packet_time);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000939}
940
941} // namespace internal
942} // namespace webrtc