blob: ae04409d6e5cc150165a76f426ae20fa68fe62fd [file] [log] [blame]
pbos@webrtc.org29d58392013-05-16 12:08:031/*
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:5311#include <string.h>
mflodman101f2502016-06-09 15:21:1912#include <algorithm>
pbos@webrtc.org29d58392013-05-16 12:08:0313#include <map>
kwibergb25345e2016-03-12 14:10:4414#include <memory>
brandtr25445d32016-10-24 06:37:1415#include <utility>
pbos@webrtc.org29d58392013-05-16 12:08:0316#include <vector>
17
Peter Boström5c389d32015-09-25 11:58:3018#include "webrtc/audio/audio_receive_stream.h"
solenbergc7a8b082015-10-16 21:35:0719#include "webrtc/audio/audio_send_stream.h"
solenberg566ef242015-11-06 23:34:4920#include "webrtc/audio/audio_state.h"
21#include "webrtc/audio/scoped_voe_interface.h"
brandtr4e523862016-10-19 06:50:4522#include "webrtc/base/basictypes.h"
pbos@webrtc.org2b4ce3a2015-03-23 13:12:2423#include "webrtc/base/checks.h"
kwiberg4485ffb2016-04-26 15:14:3924#include "webrtc/base/constructormagic.h"
Peter Boström7c704b82015-12-04 15:13:0525#include "webrtc/base/logging.h"
perkj26091b12016-09-01 08:17:4026#include "webrtc/base/task_queue.h"
pbos@webrtc.org38344ed2014-09-24 06:05:0027#include "webrtc/base/thread_annotations.h"
solenberg5a289392015-10-19 10:39:2028#include "webrtc/base/thread_checker.h"
tommie4f96502015-10-21 06:00:4829#include "webrtc/base/trace_event.h"
pbos@webrtc.org16e03b72013-10-28 16:32:0130#include "webrtc/call.h"
mflodman0e7e2592015-11-13 05:02:4231#include "webrtc/call/bitrate_allocator.h"
brandtr25445d32016-10-24 06:37:1432#include "webrtc/call/flexfec_receive_stream.h"
pbos@webrtc.orgc49d5b72013-12-05 12:11:4733#include "webrtc/config.h"
skvladcc91d282016-10-04 01:31:2234#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
mflodman0e7e2592015-11-13 05:02:4235#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
Stefan Holmer80e12072016-02-23 12:30:4236#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
Henrik Kjellander0b9e29c2015-11-16 10:12:2437#include "webrtc/modules/pacing/paced_sender.h"
brandtr4e523862016-10-19 06:50:4538#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
Henrik Kjellanderff761fb2015-11-04 07:31:5239#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
sprang@webrtc.org2a6558c2015-01-28 12:37:3640#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
Henrik Kjellanderff761fb2015-11-04 07:31:5241#include "webrtc/modules/utility/include/process_thread.h"
ivoc14d5dbe2016-07-04 14:06:5542#include "webrtc/system_wrappers/include/clock.h"
Henrik Kjellander98f53512015-10-28 17:17:4043#include "webrtc/system_wrappers/include/cpu_info.h"
44#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
stefan91d92602015-11-11 18:13:0245#include "webrtc/system_wrappers/include/metrics.h"
Henrik Kjellander98f53512015-10-28 17:17:4046#include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
47#include "webrtc/system_wrappers/include/trace.h"
Peter Boström7623ce42015-12-09 11:13:3048#include "webrtc/video/call_stats.h"
asapersson35151f32016-05-03 06:44:0149#include "webrtc/video/send_delay_stats.h"
asapersson250fd972016-09-08 07:07:2150#include "webrtc/video/stats_counter.h"
pbos@webrtc.org16e03b72013-10-28 16:32:0151#include "webrtc/video/video_receive_stream.h"
52#include "webrtc/video/video_send_stream.h"
Stefan Holmer58c664c2016-02-08 13:31:3053#include "webrtc/video/vie_remb.h"
ivocb04965c2015-09-09 07:09:4354#include "webrtc/voice_engine/include/voe_codec.h"
pbos@webrtc.org29d58392013-05-16 12:08:0355
56namespace webrtc {
pbos@webrtc.orgab990ae2014-09-17 09:02:2557
pbos@webrtc.orga73a6782014-10-14 11:52:1058const int Call::Config::kDefaultStartBitrateBps = 300000;
59
pbos@webrtc.org16e03b72013-10-28 16:32:0160namespace internal {
asapersson@webrtc.orgbdc5ed22014-01-31 10:05:0761
perkjec81bcd2016-05-11 13:01:1362class Call : public webrtc::Call,
63 public PacketReceiver,
brandtr4e523862016-10-19 06:50:4564 public RecoveredPacketReceiver,
perkj71ee44c2016-06-15 07:47:5365 public CongestionController::Observer,
66 public BitrateAllocator::LimitObserver {
pbos@webrtc.org16e03b72013-10-28 16:32:0167 public:
Peter Boström45553ae2015-05-08 11:54:3868 explicit Call(const Call::Config& config);
pbos@webrtc.org16e03b72013-10-28 16:32:0169 virtual ~Call();
70
brandtr25445d32016-10-24 06:37:1471 // Implements webrtc::Call.
kjellander@webrtc.org14665ff2015-03-04 12:58:3572 PacketReceiver* Receiver() override;
pbos@webrtc.org16e03b72013-10-28 16:32:0173
Fredrik Solenberg04f49312015-06-08 11:04:5674 webrtc::AudioSendStream* CreateAudioSendStream(
75 const webrtc::AudioSendStream::Config& config) override;
76 void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override;
77
Fredrik Solenberg23fba1f2015-04-29 13:24:0178 webrtc::AudioReceiveStream* CreateAudioReceiveStream(
79 const webrtc::AudioReceiveStream::Config& config) override;
80 void DestroyAudioReceiveStream(
81 webrtc::AudioReceiveStream* receive_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:0182
Fredrik Solenberg23fba1f2015-04-29 13:24:0183 webrtc::VideoSendStream* CreateVideoSendStream(
perkj26091b12016-09-01 08:17:4084 webrtc::VideoSendStream::Config config,
85 VideoEncoderConfig encoder_config) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:3586 void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:0187
Fredrik Solenberg23fba1f2015-04-29 13:24:0188 webrtc::VideoReceiveStream* CreateVideoReceiveStream(
Tommi733b5472016-06-10 15:58:0189 webrtc::VideoReceiveStream::Config configuration) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:3590 void DestroyVideoReceiveStream(
91 webrtc::VideoReceiveStream* receive_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:0192
brandtr25445d32016-10-24 06:37:1493 webrtc::FlexfecReceiveStream* CreateFlexfecReceiveStream(
94 webrtc::FlexfecReceiveStream::Config configuration) override;
95 void DestroyFlexfecReceiveStream(
96 webrtc::FlexfecReceiveStream* receive_stream) override;
97
kjellander@webrtc.org14665ff2015-03-04 12:58:3598 Stats GetStats() const override;
pbos@webrtc.org16e03b72013-10-28 16:32:0199
brandtr25445d32016-10-24 06:37:14100 // Implements PacketReceiver.
stefan68786d22015-09-08 12:36:15101 DeliveryStatus DeliverPacket(MediaType media_type,
102 const uint8_t* packet,
103 size_t length,
104 const PacketTime& packet_time) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01105
brandtr4e523862016-10-19 06:50:45106 // Implements RecoveredPacketReceiver.
107 bool OnRecoveredPacket(const uint8_t* packet, size_t length) override;
108
kjellander@webrtc.org14665ff2015-03-04 12:58:35109 void SetBitrateConfig(
110 const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
skvlad7a43d252016-03-22 22:32:27111
112 void SignalChannelNetworkState(MediaType media, NetworkState state) override;
pbos@webrtc.org26c0c412014-09-03 16:17:12113
michaelt79e05882016-11-08 10:50:09114 void OnTransportOverheadChanged(MediaType media,
115 int transport_overhead_per_packet) override;
116
Honghai Zhang0e533ef2016-04-19 22:41:36117 void OnNetworkRouteChanged(const std::string& transport_name,
118 const rtc::NetworkRoute& network_route) override;
119
stefanc1aeaf02015-10-15 14:26:07120 void OnSentPacket(const rtc::SentPacket& sent_packet) override;
121
minyue78b4d562016-11-30 12:47:39122
123 // TODO(minyue): remove this when old OnNetworkChanged is deprecated. See
124 // https://bugs.chromium.org/p/webrtc/issues/detail?id=6796
125 using CongestionController::Observer::OnNetworkChanged;
126
mflodman0e7e2592015-11-13 05:02:42127 // Implements BitrateObserver.
minyue78b4d562016-11-30 12:47:39128 void OnNetworkChanged(uint32_t bitrate_bps,
129 uint8_t fraction_loss,
130 int64_t rtt_ms,
131 int64_t probing_interval_ms) override;
mflodman0e7e2592015-11-13 05:02:42132
perkj71ee44c2016-06-15 07:47:53133 // Implements BitrateAllocator::LimitObserver.
134 void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
135 uint32_t max_padding_bitrate_bps) override;
136
pbos@webrtc.org16e03b72013-10-28 16:32:01137 private:
Fredrik Solenberg23fba1f2015-04-29 13:24:01138 DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet,
139 size_t length);
stefan68786d22015-09-08 12:36:15140 DeliveryStatus DeliverRtp(MediaType media_type,
141 const uint8_t* packet,
142 size_t length,
143 const PacketTime& packet_time);
pbos8fc7fa72015-07-15 15:02:58144 void ConfigureSync(const std::string& sync_group)
145 EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
146
solenberg566ef242015-11-06 23:34:49147 VoiceEngine* voice_engine() {
148 internal::AudioState* audio_state =
149 static_cast<internal::AudioState*>(config_.audio_state.get());
150 if (audio_state)
151 return audio_state->voice_engine();
152 else
153 return nullptr;
154 }
155
Stefan Holmer226befe2015-11-26 14:36:48156 void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
stefan18adf0a2015-11-17 14:24:56157 void UpdateReceiveHistograms();
asapersson4374a092016-07-27 07:39:09158 void UpdateHistograms();
skvlad7a43d252016-03-22 22:32:27159 void UpdateAggregateNetworkState();
stefan91d92602015-11-11 18:13:02160
Peter Boströmd3c94472015-12-09 10:20:58161 Clock* const clock_;
stefan91d92602015-11-11 18:13:02162
Peter Boström45553ae2015-05-08 11:54:38163 const int num_cpu_cores_;
kwibergb25345e2016-03-12 14:10:44164 const std::unique_ptr<ProcessThread> module_process_thread_;
165 const std::unique_ptr<ProcessThread> pacer_thread_;
166 const std::unique_ptr<CallStats> call_stats_;
167 const std::unique_ptr<BitrateAllocator> bitrate_allocator_;
pbos@webrtc.org16e03b72013-10-28 16:32:01168 Call::Config config_;
solenberg5a289392015-10-19 10:39:20169 rtc::ThreadChecker configuration_thread_checker_;
pbos@webrtc.org16e03b72013-10-28 16:32:01170
skvlad7a43d252016-03-22 22:32:27171 NetworkState audio_network_state_;
172 NetworkState video_network_state_;
pbos@webrtc.org16e03b72013-10-28 16:32:01173
kwibergb25345e2016-03-12 14:10:44174 std::unique_ptr<RWLockWrapper> receive_crit_;
brandtr25445d32016-10-24 06:37:14175 // Audio, Video, and FlexFEC receive streams are owned by the client that
176 // creates them.
Fredrik Solenberg23fba1f2015-04-29 13:24:01177 std::map<uint32_t, AudioReceiveStream*> audio_receive_ssrcs_
pbos@webrtc.org26c0c412014-09-03 16:17:12178 GUARDED_BY(receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 13:24:01179 std::map<uint32_t, VideoReceiveStream*> video_receive_ssrcs_
180 GUARDED_BY(receive_crit_);
181 std::set<VideoReceiveStream*> video_receive_streams_
182 GUARDED_BY(receive_crit_);
brandtr25445d32016-10-24 06:37:14183 // Each media stream could conceivably be protected by multiple FlexFEC
184 // streams.
185 std::multimap<uint32_t, FlexfecReceiveStream*> flexfec_receive_ssrcs_media_
186 GUARDED_BY(receive_crit_);
187 std::map<uint32_t, FlexfecReceiveStream*> flexfec_receive_ssrcs_protection_
188 GUARDED_BY(receive_crit_);
189 std::set<FlexfecReceiveStream*> flexfec_receive_streams_
190 GUARDED_BY(receive_crit_);
pbos8fc7fa72015-07-15 15:02:58191 std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
192 GUARDED_BY(receive_crit_);
pbos@webrtc.org26c0c412014-09-03 16:17:12193
kwibergb25345e2016-03-12 14:10:44194 std::unique_ptr<RWLockWrapper> send_crit_;
solenbergc7a8b082015-10-16 21:35:07195 // Audio and Video send streams are owned by the client that creates them.
196 std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
Fredrik Solenberg23fba1f2015-04-29 13:24:01197 std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
198 std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
pbos@webrtc.org16e03b72013-10-28 16:32:01199
Fredrik Solenberg23fba1f2015-04-29 13:24:01200 VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
skvlad11a9cbf2016-10-07 18:53:05201 webrtc::RtcEventLog* event_log_;
ivocb04965c2015-09-09 07:09:43202
stefan18adf0a2015-11-17 14:24:56203 // The following members are only accessed (exclusively) from one thread and
204 // from the destructor, and therefore doesn't need any explicit
205 // synchronization.
Stefan Holmer226befe2015-11-26 14:36:48206 int64_t first_packet_sent_ms_;
asapersson250fd972016-09-08 07:07:21207 RateCounter received_bytes_per_second_counter_;
208 RateCounter received_audio_bytes_per_second_counter_;
209 RateCounter received_video_bytes_per_second_counter_;
210 RateCounter received_rtcp_bytes_per_second_counter_;
stefan91d92602015-11-11 18:13:02211
stefan18adf0a2015-11-17 14:24:56212 // TODO(holmer): Remove this lock once BitrateController no longer calls
213 // OnNetworkChanged from multiple threads.
214 rtc::CriticalSection bitrate_crit_;
perkj71ee44c2016-06-15 07:47:53215 uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
sprang9c0b5512016-07-06 07:54:28216 uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
asaperssonce2e1362016-09-09 07:13:35217 AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
218 AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
stefan18adf0a2015-11-17 14:24:56219
Honghai Zhang0e533ef2016-04-19 22:41:36220 std::map<std::string, rtc::NetworkRoute> network_routes_;
221
Stefan Holmer58c664c2016-02-08 13:31:30222 VieRemb remb_;
nisse0245da02016-11-30 11:35:20223 PacketRouter packet_router_;
224 // TODO(nisse): Could be a direct member, except for constness
225 // issues with GetRemoteBitrateEstimator (and maybe others).
kwibergb25345e2016-03-12 14:10:44226 const std::unique_ptr<CongestionController> congestion_controller_;
asapersson35151f32016-05-03 06:44:01227 const std::unique_ptr<SendDelayStats> video_send_delay_stats_;
asapersson4374a092016-07-27 07:39:09228 const int64_t start_ms_;
perkj26091b12016-09-01 08:17:40229 // TODO(perkj): |worker_queue_| is supposed to replace
230 // |module_process_thread_|.
231 // |worker_queue| is defined last to ensure all pending tasks are cancelled
232 // and deleted before any other members.
233 rtc::TaskQueue worker_queue_;
mflodman0e7e2592015-11-13 05:02:42234
henrikg3c089d72015-09-16 12:37:44235 RTC_DISALLOW_COPY_AND_ASSIGN(Call);
pbos@webrtc.org16e03b72013-10-28 16:32:01236};
pbos@webrtc.orgc49d5b72013-12-05 12:11:47237} // namespace internal
pbos@webrtc.orgfd39e132013-08-14 13:52:52238
asapersson2e5cfcd2016-08-11 15:41:18239std::string Call::Stats::ToString(int64_t time_ms) const {
240 std::stringstream ss;
241 ss << "Call stats: " << time_ms << ", {";
242 ss << "send_bw_bps: " << send_bandwidth_bps << ", ";
243 ss << "recv_bw_bps: " << recv_bandwidth_bps << ", ";
244 ss << "max_pad_bps: " << max_padding_bitrate_bps << ", ";
245 ss << "pacer_delay_ms: " << pacer_delay_ms << ", ";
246 ss << "rtt_ms: " << rtt_ms;
247 ss << '}';
248 return ss.str();
249}
250
stefan@webrtc.org7e9315b2013-12-04 10:24:26251Call* Call::Create(const Call::Config& config) {
Peter Boström45553ae2015-05-08 11:54:38252 return new internal::Call(config);
pbos@webrtc.orgfd39e132013-08-14 13:52:52253}
pbos@webrtc.orgfd39e132013-08-14 13:52:52254
pbos@webrtc.org29d58392013-05-16 12:08:03255namespace internal {
256
Peter Boström45553ae2015-05-08 11:54:38257Call::Call(const Call::Config& config)
stefan91d92602015-11-11 18:13:02258 : clock_(Clock::GetRealTimeClock()),
259 num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
kwiberg1c7fdd82016-04-26 15:18:04260 module_process_thread_(ProcessThread::Create("ModuleProcessThread")),
261 pacer_thread_(ProcessThread::Create("PacerThread")),
Peter Boströmd3c94472015-12-09 10:20:58262 call_stats_(new CallStats(clock_)),
perkj71ee44c2016-06-15 07:47:53263 bitrate_allocator_(new BitrateAllocator(this)),
Peter Boström45553ae2015-05-08 11:54:38264 config_(config),
Sergey Ulanove2b15012016-11-23 00:08:30265 audio_network_state_(kNetworkDown),
266 video_network_state_(kNetworkDown),
pbos@webrtc.org26c0c412014-09-03 16:17:12267 receive_crit_(RWLockWrapper::CreateRWLock()),
stefan91d92602015-11-11 18:13:02268 send_crit_(RWLockWrapper::CreateRWLock()),
skvlad11a9cbf2016-10-07 18:53:05269 event_log_(config.event_log),
Stefan Holmer226befe2015-11-26 14:36:48270 first_packet_sent_ms_(-1),
asapersson250fd972016-09-08 07:07:21271 received_bytes_per_second_counter_(clock_, nullptr, true),
272 received_audio_bytes_per_second_counter_(clock_, nullptr, true),
273 received_video_bytes_per_second_counter_(clock_, nullptr, true),
274 received_rtcp_bytes_per_second_counter_(clock_, nullptr, true),
perkj71ee44c2016-06-15 07:47:53275 min_allocated_send_bitrate_bps_(0),
sprang9c0b5512016-07-06 07:54:28276 configured_max_padding_bitrate_bps_(0),
asaperssonce2e1362016-09-09 07:13:35277 estimated_send_bitrate_kbps_counter_(clock_, nullptr, true),
278 pacer_bitrate_kbps_counter_(clock_, nullptr, true),
Stefan Holmer58c664c2016-02-08 13:31:30279 remb_(clock_),
nisse0245da02016-11-30 11:35:20280 congestion_controller_(new CongestionController(clock_,
281 this,
282 &remb_,
283 event_log_,
284 &packet_router_)),
asapersson4374a092016-07-27 07:39:09285 video_send_delay_stats_(new SendDelayStats(clock_)),
perkj26091b12016-09-01 08:17:40286 start_ms_(clock_->TimeInMilliseconds()),
287 worker_queue_("call_worker_queue") {
solenberg56a34df2015-11-12 16:24:41288 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
skvlad11a9cbf2016-10-07 18:53:05289 RTC_DCHECK(config.event_log != nullptr);
henrikg91d6ede2015-09-17 07:24:34290 RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
291 RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps,
292 config.bitrate_config.min_bitrate_bps);
Stefan Holmere5904162015-03-26 10:11:06293 if (config.bitrate_config.max_bitrate_bps != -1) {
henrikg91d6ede2015-09-17 07:24:34294 RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
295 config.bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34296 }
Peter Boström45553ae2015-05-08 11:54:38297 Trace::CreateTrace();
Stefan Holmer789ba922016-02-17 14:52:17298 call_stats_->RegisterStatsObserver(congestion_controller_.get());
Peter Boström45553ae2015-05-08 11:54:38299
Sergey Ulanove2b15012016-11-23 00:08:30300 congestion_controller_->SignalNetworkState(kNetworkDown);
mflodman0c478b32015-10-21 13:52:16301 congestion_controller_->SetBweBitrates(
302 config_.bitrate_config.min_bitrate_bps,
303 config_.bitrate_config.start_bitrate_bps,
304 config_.bitrate_config.max_bitrate_bps);
Stefan Holmerc379fcb2016-02-24 15:02:55305
306 module_process_thread_->Start();
307 module_process_thread_->RegisterModule(call_stats_.get());
308 module_process_thread_->RegisterModule(congestion_controller_.get());
309 pacer_thread_->RegisterModule(congestion_controller_->pacer());
310 pacer_thread_->RegisterModule(
311 congestion_controller_->GetRemoteBitrateEstimator(true));
312 pacer_thread_->Start();
pbos@webrtc.org29d58392013-05-16 12:08:03313}
314
pbos@webrtc.org841c8a42013-09-09 15:04:25315Call::~Call() {
Stefan Holmer58c664c2016-02-08 13:31:30316 RTC_DCHECK(!remb_.InUse());
solenberg5a289392015-10-19 10:39:20317 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
perkj26091b12016-09-01 08:17:40318
solenbergc7a8b082015-10-16 21:35:07319 RTC_CHECK(audio_send_ssrcs_.empty());
320 RTC_CHECK(video_send_ssrcs_.empty());
321 RTC_CHECK(video_send_streams_.empty());
322 RTC_CHECK(audio_receive_ssrcs_.empty());
323 RTC_CHECK(video_receive_ssrcs_.empty());
324 RTC_CHECK(video_receive_streams_.empty());
pbos@webrtc.org9e4e5242015-02-12 10:48:23325
Stefan Holmerc379fcb2016-02-24 15:02:55326 pacer_thread_->Stop();
327 pacer_thread_->DeRegisterModule(congestion_controller_->pacer());
328 pacer_thread_->DeRegisterModule(
329 congestion_controller_->GetRemoteBitrateEstimator(true));
Stefan Holmer789ba922016-02-17 14:52:17330 module_process_thread_->DeRegisterModule(congestion_controller_.get());
mflodmane3787022015-10-21 11:24:28331 module_process_thread_->DeRegisterModule(call_stats_.get());
Peter Boström45553ae2015-05-08 11:54:38332 module_process_thread_->Stop();
Stefan Holmerc379fcb2016-02-24 15:02:55333 call_stats_->DeregisterStatsObserver(congestion_controller_.get());
sprang6d6122b2016-07-13 13:37:09334
335 // Only update histograms after process threads have been shut down, so that
336 // they won't try to concurrently update stats.
perkj26091b12016-09-01 08:17:40337 {
338 rtc::CritScope lock(&bitrate_crit_);
339 UpdateSendHistograms();
340 }
sprang6d6122b2016-07-13 13:37:09341 UpdateReceiveHistograms();
asapersson4374a092016-07-27 07:39:09342 UpdateHistograms();
sprang6d6122b2016-07-13 13:37:09343
Peter Boström45553ae2015-05-08 11:54:38344 Trace::ReturnTrace();
pbos@webrtc.org29d58392013-05-16 12:08:03345}
346
asapersson4374a092016-07-27 07:39:09347void Call::UpdateHistograms() {
asapersson1d02d3e2016-09-10 05:40:25348 RTC_HISTOGRAM_COUNTS_100000(
asapersson4374a092016-07-27 07:39:09349 "WebRTC.Call.LifetimeInSeconds",
350 (clock_->TimeInMilliseconds() - start_ms_) / 1000);
351}
352
stefan18adf0a2015-11-17 14:24:56353void Call::UpdateSendHistograms() {
asaperssonce2e1362016-09-09 07:13:35354 if (first_packet_sent_ms_ == -1)
stefan18adf0a2015-11-17 14:24:56355 return;
356 int64_t elapsed_sec =
357 (clock_->TimeInMilliseconds() - first_packet_sent_ms_) / 1000;
358 if (elapsed_sec < metrics::kMinRunTimeInSeconds)
359 return;
asaperssonce2e1362016-09-09 07:13:35360 const int kMinRequiredPeriodicSamples = 5;
361 AggregatedStats send_bitrate_stats =
362 estimated_send_bitrate_kbps_counter_.ProcessAndGetStats();
363 if (send_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-10 05:40:25364 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps",
365 send_bitrate_stats.average);
asapersson43cb7162016-11-15 16:20:48366 LOG(LS_INFO) << "WebRTC.Call.EstimatedSendBitrateInKbps, "
367 << send_bitrate_stats.ToString();
stefan18adf0a2015-11-17 14:24:56368 }
asaperssonce2e1362016-09-09 07:13:35369 AggregatedStats pacer_bitrate_stats =
370 pacer_bitrate_kbps_counter_.ProcessAndGetStats();
371 if (pacer_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-10 05:40:25372 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.PacerBitrateInKbps",
373 pacer_bitrate_stats.average);
asapersson43cb7162016-11-15 16:20:48374 LOG(LS_INFO) << "WebRTC.Call.PacerBitrateInKbps, "
375 << pacer_bitrate_stats.ToString();
stefan18adf0a2015-11-17 14:24:56376 }
377}
378
379void Call::UpdateReceiveHistograms() {
asapersson250fd972016-09-08 07:07:21380 const int kMinRequiredPeriodicSamples = 5;
381 AggregatedStats video_bytes_per_sec =
382 received_video_bytes_per_second_counter_.GetStats();
383 if (video_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-10 05:40:25384 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.VideoBitrateReceivedInKbps",
385 video_bytes_per_sec.average * 8 / 1000);
Åsa Perssona8149412016-11-16 08:57:53386 LOG(LS_INFO) << "WebRTC.Call.VideoBitrateReceivedInBytesPerSec, "
asapersson43cb7162016-11-15 16:20:48387 << video_bytes_per_sec.ToString();
stefan91d92602015-11-11 18:13:02388 }
asapersson250fd972016-09-08 07:07:21389 AggregatedStats audio_bytes_per_sec =
390 received_audio_bytes_per_second_counter_.GetStats();
391 if (audio_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-10 05:40:25392 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.AudioBitrateReceivedInKbps",
393 audio_bytes_per_sec.average * 8 / 1000);
Åsa Perssona8149412016-11-16 08:57:53394 LOG(LS_INFO) << "WebRTC.Call.AudioBitrateReceivedInBytesPerSec, "
asapersson43cb7162016-11-15 16:20:48395 << audio_bytes_per_sec.ToString();
stefan91d92602015-11-11 18:13:02396 }
asapersson250fd972016-09-08 07:07:21397 AggregatedStats rtcp_bytes_per_sec =
398 received_rtcp_bytes_per_second_counter_.GetStats();
399 if (rtcp_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-10 05:40:25400 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.RtcpBitrateReceivedInBps",
401 rtcp_bytes_per_sec.average * 8);
Åsa Perssona8149412016-11-16 08:57:53402 LOG(LS_INFO) << "WebRTC.Call.RtcpBitrateReceivedInBytesPerSec, "
asapersson43cb7162016-11-15 16:20:48403 << rtcp_bytes_per_sec.ToString();
stefan91d92602015-11-11 18:13:02404 }
asapersson250fd972016-09-08 07:07:21405 AggregatedStats recv_bytes_per_sec =
406 received_bytes_per_second_counter_.GetStats();
407 if (recv_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
asapersson1d02d3e2016-09-10 05:40:25408 RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.BitrateReceivedInKbps",
409 recv_bytes_per_sec.average * 8 / 1000);
Åsa Perssona8149412016-11-16 08:57:53410 LOG(LS_INFO) << "WebRTC.Call.BitrateReceivedInBytesPerSec, "
asapersson43cb7162016-11-15 16:20:48411 << recv_bytes_per_sec.ToString();
asapersson250fd972016-09-08 07:07:21412 }
stefan91d92602015-11-11 18:13:02413}
414
solenberg5a289392015-10-19 10:39:20415PacketReceiver* Call::Receiver() {
416 // TODO(solenberg): Some test cases in EndToEndTest use this from a different
417 // thread. Re-enable once that is fixed.
418 // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
419 return this;
420}
pbos@webrtc.org29d58392013-05-16 12:08:03421
Fredrik Solenberg04f49312015-06-08 11:04:56422webrtc::AudioSendStream* Call::CreateAudioSendStream(
423 const webrtc::AudioSendStream::Config& config) {
solenbergc7a8b082015-10-16 21:35:07424 TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
solenberg5a289392015-10-19 10:39:20425 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
ivoce0928d82016-10-10 12:12:51426 event_log_->LogAudioSendStreamConfig(config);
Stefan Holmerb86d4e42015-12-07 09:26:18427 AudioSendStream* send_stream = new AudioSendStream(
nisse0245da02016-11-30 11:35:20428 config, config_.audio_state, &worker_queue_, &packet_router_,
429 congestion_controller_.get(), bitrate_allocator_.get(), event_log_);
solenbergc7a8b082015-10-16 21:35:07430 {
solenbergc7a8b082015-10-16 21:35:07431 WriteLockScoped write_lock(*send_crit_);
432 RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) ==
433 audio_send_ssrcs_.end());
434 audio_send_ssrcs_[config.rtp.ssrc] = send_stream;
solenbergc7a8b082015-10-16 21:35:07435 }
solenberg7602aab2016-11-14 19:30:07436 {
437 ReadLockScoped read_lock(*receive_crit_);
438 for (const auto& kv : audio_receive_ssrcs_) {
439 if (kv.second->config().rtp.local_ssrc == config.rtp.ssrc) {
440 kv.second->AssociateSendStream(send_stream);
441 }
442 }
443 }
skvlad7a43d252016-03-22 22:32:27444 send_stream->SignalNetworkState(audio_network_state_);
445 UpdateAggregateNetworkState();
solenbergc7a8b082015-10-16 21:35:07446 return send_stream;
Fredrik Solenberg04f49312015-06-08 11:04:56447}
448
449void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
solenbergc7a8b082015-10-16 21:35:07450 TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream");
solenberg5a289392015-10-19 10:39:20451 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
solenbergc7a8b082015-10-16 21:35:07452 RTC_DCHECK(send_stream != nullptr);
453
454 send_stream->Stop();
455
456 webrtc::internal::AudioSendStream* audio_send_stream =
457 static_cast<webrtc::internal::AudioSendStream*>(send_stream);
solenberg7602aab2016-11-14 19:30:07458 uint32_t ssrc = audio_send_stream->config().rtp.ssrc;
solenbergc7a8b082015-10-16 21:35:07459 {
460 WriteLockScoped write_lock(*send_crit_);
solenberg7602aab2016-11-14 19:30:07461 size_t num_deleted = audio_send_ssrcs_.erase(ssrc);
462 RTC_DCHECK_EQ(1, num_deleted);
463 }
464 {
465 ReadLockScoped read_lock(*receive_crit_);
466 for (const auto& kv : audio_receive_ssrcs_) {
467 if (kv.second->config().rtp.local_ssrc == ssrc) {
468 kv.second->AssociateSendStream(nullptr);
469 }
470 }
solenbergc7a8b082015-10-16 21:35:07471 }
skvlad7a43d252016-03-22 22:32:27472 UpdateAggregateNetworkState();
solenbergc7a8b082015-10-16 21:35:07473 delete audio_send_stream;
Fredrik Solenberg04f49312015-06-08 11:04:56474}
475
Fredrik Solenberg23fba1f2015-04-29 13:24:01476webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
477 const webrtc::AudioReceiveStream::Config& config) {
478 TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
solenberg5a289392015-10-19 10:39:20479 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
ivoce0928d82016-10-10 12:12:51480 event_log_->LogAudioReceiveStreamConfig(config);
skvlad11a9cbf2016-10-07 18:53:05481 AudioReceiveStream* receive_stream = new AudioReceiveStream(
nisse0245da02016-11-30 11:35:20482 &packet_router_,
483 // TODO(nisse): Used only when UseSendSideBwe(config) is true.
484 congestion_controller_->GetRemoteBitrateEstimator(true), config,
485 config_.audio_state, event_log_);
Fredrik Solenberg23fba1f2015-04-29 13:24:01486 {
487 WriteLockScoped write_lock(*receive_crit_);
henrikg91d6ede2015-09-17 07:24:34488 RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
489 audio_receive_ssrcs_.end());
Fredrik Solenberg23fba1f2015-04-29 13:24:01490 audio_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
pbos8fc7fa72015-07-15 15:02:58491 ConfigureSync(config.sync_group);
Fredrik Solenberg23fba1f2015-04-29 13:24:01492 }
solenberg7602aab2016-11-14 19:30:07493 {
494 ReadLockScoped read_lock(*send_crit_);
495 auto it = audio_send_ssrcs_.find(config.rtp.local_ssrc);
496 if (it != audio_send_ssrcs_.end()) {
497 receive_stream->AssociateSendStream(it->second);
498 }
499 }
skvlad7a43d252016-03-22 22:32:27500 receive_stream->SignalNetworkState(audio_network_state_);
501 UpdateAggregateNetworkState();
Fredrik Solenberg23fba1f2015-04-29 13:24:01502 return receive_stream;
503}
504
505void Call::DestroyAudioReceiveStream(
506 webrtc::AudioReceiveStream* receive_stream) {
507 TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream");
solenberg5a289392015-10-19 10:39:20508 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 07:24:34509 RTC_DCHECK(receive_stream != nullptr);
solenbergc7a8b082015-10-16 21:35:07510 webrtc::internal::AudioReceiveStream* audio_receive_stream =
511 static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream);
Fredrik Solenberg23fba1f2015-04-29 13:24:01512 {
513 WriteLockScoped write_lock(*receive_crit_);
514 size_t num_deleted = audio_receive_ssrcs_.erase(
515 audio_receive_stream->config().rtp.remote_ssrc);
henrikg91d6ede2015-09-17 07:24:34516 RTC_DCHECK(num_deleted == 1);
pbos8fc7fa72015-07-15 15:02:58517 const std::string& sync_group = audio_receive_stream->config().sync_group;
518 const auto it = sync_stream_mapping_.find(sync_group);
519 if (it != sync_stream_mapping_.end() &&
520 it->second == audio_receive_stream) {
521 sync_stream_mapping_.erase(it);
522 ConfigureSync(sync_group);
523 }
Fredrik Solenberg23fba1f2015-04-29 13:24:01524 }
skvlad7a43d252016-03-22 22:32:27525 UpdateAggregateNetworkState();
Fredrik Solenberg23fba1f2015-04-29 13:24:01526 delete audio_receive_stream;
527}
528
529webrtc::VideoSendStream* Call::CreateVideoSendStream(
perkj26091b12016-09-01 08:17:40530 webrtc::VideoSendStream::Config config,
531 VideoEncoderConfig encoder_config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07532 TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream");
solenberg5a289392015-10-19 10:39:20533 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org1819fd72013-06-10 13:48:26534
asapersson35151f32016-05-03 06:44:01535 video_send_delay_stats_->AddSsrcs(config);
perkj26091b12016-09-01 08:17:40536 event_log_->LogVideoSendStreamConfig(config);
537
mflodman@webrtc.orgeb16b812014-06-16 08:57:39538 // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
539 // the call has already started.
perkj26091b12016-09-01 08:17:40540 // Copy ssrcs from |config| since |config| is moved.
541 std::vector<uint32_t> ssrcs = config.rtp.ssrcs;
mflodman0c478b32015-10-21 13:52:16542 VideoSendStream* send_stream = new VideoSendStream(
perkj26091b12016-09-01 08:17:40543 num_cpu_cores_, module_process_thread_.get(), &worker_queue_,
nisse0245da02016-11-30 11:35:20544 call_stats_.get(), congestion_controller_.get(), &packet_router_,
545 bitrate_allocator_.get(), video_send_delay_stats_.get(), &remb_,
546 event_log_, std::move(config), std::move(encoder_config),
547 suspended_video_send_ssrcs_);
perkj26091b12016-09-01 08:17:40548
skvlad7a43d252016-03-22 22:32:27549 {
550 WriteLockScoped write_lock(*send_crit_);
perkj26091b12016-09-01 08:17:40551 for (uint32_t ssrc : ssrcs) {
skvlad7a43d252016-03-22 22:32:27552 RTC_DCHECK(video_send_ssrcs_.find(ssrc) == video_send_ssrcs_.end());
553 video_send_ssrcs_[ssrc] = send_stream;
554 }
555 video_send_streams_.insert(send_stream);
pbos@webrtc.org29d58392013-05-16 12:08:03556 }
skvlad7a43d252016-03-22 22:32:27557 send_stream->SignalNetworkState(video_network_state_);
558 UpdateAggregateNetworkState();
perkj26091b12016-09-01 08:17:40559
pbos@webrtc.org29d58392013-05-16 12:08:03560 return send_stream;
561}
562
pbos@webrtc.org2c46f8d2013-11-21 13:49:43563void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
pbos@webrtc.org50fe3592015-01-29 12:33:07564 TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream");
henrikg91d6ede2015-09-17 07:24:34565 RTC_DCHECK(send_stream != nullptr);
solenberg5a289392015-10-19 10:39:20566 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org95e51f52013-09-05 12:38:54567
pbos@webrtc.org2bb1bda2014-07-07 13:06:48568 send_stream->Stop();
569
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24570 VideoSendStream* send_stream_impl = nullptr;
pbos@webrtc.org95e51f52013-09-05 12:38:54571 {
pbos@webrtc.org26c0c412014-09-03 16:17:12572 WriteLockScoped write_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 13:24:01573 auto it = video_send_ssrcs_.begin();
574 while (it != video_send_ssrcs_.end()) {
pbos@webrtc.org95e51f52013-09-05 12:38:54575 if (it->second == static_cast<VideoSendStream*>(send_stream)) {
576 send_stream_impl = it->second;
Fredrik Solenberg23fba1f2015-04-29 13:24:01577 video_send_ssrcs_.erase(it++);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48578 } else {
579 ++it;
pbos@webrtc.org95e51f52013-09-05 12:38:54580 }
581 }
Fredrik Solenberg23fba1f2015-04-29 13:24:01582 video_send_streams_.erase(send_stream_impl);
pbos@webrtc.org29d58392013-05-16 12:08:03583 }
henrikg91d6ede2015-09-17 07:24:34584 RTC_CHECK(send_stream_impl != nullptr);
pbos@webrtc.org95e51f52013-09-05 12:38:54585
perkj26091b12016-09-01 08:17:40586 VideoSendStream::RtpStateMap rtp_state =
587 send_stream_impl->StopPermanentlyAndGetRtpStates();
pbos@webrtc.org2bb1bda2014-07-07 13:06:48588
589 for (VideoSendStream::RtpStateMap::iterator it = rtp_state.begin();
perkj26091b12016-09-01 08:17:40590 it != rtp_state.end(); ++it) {
Fredrik Solenberg23fba1f2015-04-29 13:24:01591 suspended_video_send_ssrcs_[it->first] = it->second;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48592 }
593
skvlad7a43d252016-03-22 22:32:27594 UpdateAggregateNetworkState();
pbos@webrtc.org95e51f52013-09-05 12:38:54595 delete send_stream_impl;
pbos@webrtc.org29d58392013-05-16 12:08:03596}
597
Fredrik Solenberg23fba1f2015-04-29 13:24:01598webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
Tommi733b5472016-06-10 15:58:01599 webrtc::VideoReceiveStream::Config configuration) {
pbos@webrtc.org50fe3592015-01-29 12:33:07600 TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
solenberg5a289392015-10-19 10:39:20601 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
Peter Boströmc4188fd2015-04-24 13:16:03602 VideoReceiveStream* receive_stream = new VideoReceiveStream(
nisse0245da02016-11-30 11:35:20603 num_cpu_cores_, congestion_controller_.get(), &packet_router_,
604 std::move(configuration), voice_engine(), module_process_thread_.get(),
605 call_stats_.get(), &remb_);
Tommi733b5472016-06-10 15:58:01606
607 const webrtc::VideoReceiveStream::Config& config = receive_stream->config();
skvlad7a43d252016-03-22 22:32:27608 {
609 WriteLockScoped write_lock(*receive_crit_);
610 RTC_DCHECK(video_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
611 video_receive_ssrcs_.end());
612 video_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
613 // TODO(pbos): Configure different RTX payloads per receive payload.
614 VideoReceiveStream::Config::Rtp::RtxMap::const_iterator it =
615 config.rtp.rtx.begin();
616 if (it != config.rtp.rtx.end())
617 video_receive_ssrcs_[it->second.ssrc] = receive_stream;
618 video_receive_streams_.insert(receive_stream);
skvlad7a43d252016-03-22 22:32:27619 ConfigureSync(config.sync_group);
620 }
621 receive_stream->SignalNetworkState(video_network_state_);
622 UpdateAggregateNetworkState();
ivoc14d5dbe2016-07-04 14:06:55623 event_log_->LogVideoReceiveStreamConfig(config);
pbos@webrtc.org29d58392013-05-16 12:08:03624 return receive_stream;
625}
626
pbos@webrtc.org2c46f8d2013-11-21 13:49:43627void Call::DestroyVideoReceiveStream(
628 webrtc::VideoReceiveStream* receive_stream) {
pbos@webrtc.org50fe3592015-01-29 12:33:07629 TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
solenberg5a289392015-10-19 10:39:20630 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 07:24:34631 RTC_DCHECK(receive_stream != nullptr);
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24632 VideoReceiveStream* receive_stream_impl = nullptr;
pbos@webrtc.org95e51f52013-09-05 12:38:54633 {
pbos@webrtc.org26c0c412014-09-03 16:17:12634 WriteLockScoped write_lock(*receive_crit_);
pbos@webrtc.orgc279a5d2014-01-24 09:30:53635 // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a
636 // separate SSRC there can be either one or two.
Fredrik Solenberg23fba1f2015-04-29 13:24:01637 auto it = video_receive_ssrcs_.begin();
638 while (it != video_receive_ssrcs_.end()) {
pbos@webrtc.org95e51f52013-09-05 12:38:54639 if (it->second == static_cast<VideoReceiveStream*>(receive_stream)) {
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24640 if (receive_stream_impl != nullptr)
henrikg91d6ede2015-09-17 07:24:34641 RTC_DCHECK(receive_stream_impl == it->second);
pbos@webrtc.org95e51f52013-09-05 12:38:54642 receive_stream_impl = it->second;
Fredrik Solenberg23fba1f2015-04-29 13:24:01643 video_receive_ssrcs_.erase(it++);
pbos@webrtc.orgc279a5d2014-01-24 09:30:53644 } else {
645 ++it;
pbos@webrtc.org95e51f52013-09-05 12:38:54646 }
647 }
Fredrik Solenberg23fba1f2015-04-29 13:24:01648 video_receive_streams_.erase(receive_stream_impl);
henrikg91d6ede2015-09-17 07:24:34649 RTC_CHECK(receive_stream_impl != nullptr);
pbos8fc7fa72015-07-15 15:02:58650 ConfigureSync(receive_stream_impl->config().sync_group);
pbos@webrtc.org29d58392013-05-16 12:08:03651 }
skvlad7a43d252016-03-22 22:32:27652 UpdateAggregateNetworkState();
pbos@webrtc.org95e51f52013-09-05 12:38:54653 delete receive_stream_impl;
pbos@webrtc.org29d58392013-05-16 12:08:03654}
655
brandtr25445d32016-10-24 06:37:14656webrtc::FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
657 webrtc::FlexfecReceiveStream::Config configuration) {
658 TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream");
659 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
660 FlexfecReceiveStream* receive_stream =
661 new FlexfecReceiveStream(std::move(configuration), this);
662
663 const webrtc::FlexfecReceiveStream::Config& config = receive_stream->config();
664 {
665 WriteLockScoped write_lock(*receive_crit_);
666 for (auto ssrc : config.protected_media_ssrcs)
667 flexfec_receive_ssrcs_media_.insert(std::make_pair(ssrc, receive_stream));
668 RTC_DCHECK(flexfec_receive_ssrcs_protection_.find(config.flexfec_ssrc) ==
669 flexfec_receive_ssrcs_protection_.end());
670 flexfec_receive_ssrcs_protection_[config.flexfec_ssrc] = receive_stream;
671 flexfec_receive_streams_.insert(receive_stream);
672 }
673 // TODO(brandtr): Store config in RtcEventLog here.
674 return receive_stream;
675}
676
677void Call::DestroyFlexfecReceiveStream(
678 webrtc::FlexfecReceiveStream* receive_stream) {
679 TRACE_EVENT0("webrtc", "Call::DestroyFlexfecReceiveStream");
680 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
681 RTC_DCHECK(receive_stream != nullptr);
682 // There exist no other derived classes of webrtc::FlexfecReceiveStream,
683 // so this downcast is safe.
684 FlexfecReceiveStream* receive_stream_impl =
685 static_cast<FlexfecReceiveStream*>(receive_stream);
686 {
687 WriteLockScoped write_lock(*receive_crit_);
688 // Remove all SSRCs pointing to the FlexfecReceiveStream to be destroyed.
689 auto media_it = flexfec_receive_ssrcs_media_.begin();
690 while (media_it != flexfec_receive_ssrcs_media_.end()) {
691 if (media_it->second == receive_stream_impl)
692 media_it = flexfec_receive_ssrcs_media_.erase(media_it);
693 else
694 ++media_it;
695 }
696 auto prot_it = flexfec_receive_ssrcs_protection_.begin();
697 while (prot_it != flexfec_receive_ssrcs_protection_.end()) {
698 if (prot_it->second == receive_stream_impl)
699 prot_it = flexfec_receive_ssrcs_protection_.erase(prot_it);
700 else
701 ++prot_it;
702 }
703 flexfec_receive_streams_.erase(receive_stream_impl);
704 }
705 delete receive_stream_impl;
706}
707
stefan@webrtc.org0bae1fa2014-11-05 14:05:29708Call::Stats Call::GetStats() const {
solenberg5a289392015-10-19 10:39:20709 // TODO(solenberg): Some test cases in EndToEndTest use this from a different
710 // thread. Re-enable once that is fixed.
711 // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
stefan@webrtc.org0bae1fa2014-11-05 14:05:29712 Stats stats;
Peter Boström45553ae2015-05-08 11:54:38713 // Fetch available send/receive bitrates.
stefan@webrtc.org0bae1fa2014-11-05 14:05:29714 uint32_t send_bandwidth = 0;
mflodman0c478b32015-10-21 13:52:16715 congestion_controller_->GetBitrateController()->AvailableBandwidth(
716 &send_bandwidth);
Peter Boström45553ae2015-05-08 11:54:38717 std::vector<unsigned int> ssrcs;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29718 uint32_t recv_bandwidth = 0;
mflodman0c478b32015-10-21 13:52:16719 congestion_controller_->GetRemoteBitrateEstimator(false)->LatestEstimate(
mflodmana20de202015-10-19 05:08:19720 &ssrcs, &recv_bandwidth);
Peter Boström45553ae2015-05-08 11:54:38721 stats.send_bandwidth_bps = send_bandwidth;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29722 stats.recv_bandwidth_bps = recv_bandwidth;
mflodman0c478b32015-10-21 13:52:16723 stats.pacer_delay_ms = congestion_controller_->GetPacerQueuingDelayMs();
sprange2d83d62016-02-19 17:03:26724 stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt();
sprang9c0b5512016-07-06 07:54:28725 {
726 rtc::CritScope cs(&bitrate_crit_);
727 stats.max_padding_bitrate_bps = configured_max_padding_bitrate_bps_;
728 }
stefan@webrtc.org0bae1fa2014-11-05 14:05:29729 return stats;
pbos@webrtc.org29d58392013-05-16 12:08:03730}
731
pbos@webrtc.org00873182014-11-25 14:03:34732void Call::SetBitrateConfig(
733 const webrtc::Call::Config::BitrateConfig& bitrate_config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07734 TRACE_EVENT0("webrtc", "Call::SetBitrateConfig");
solenberg5a289392015-10-19 10:39:20735 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 07:24:34736 RTC_DCHECK_GE(bitrate_config.min_bitrate_bps, 0);
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24737 if (bitrate_config.max_bitrate_bps != -1)
henrikg91d6ede2015-09-17 07:24:34738 RTC_DCHECK_GT(bitrate_config.max_bitrate_bps, 0);
Stefan Holmere5904162015-03-26 10:11:06739 if (config_.bitrate_config.min_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34740 bitrate_config.min_bitrate_bps &&
741 (bitrate_config.start_bitrate_bps <= 0 ||
Stefan Holmere5904162015-03-26 10:11:06742 config_.bitrate_config.start_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34743 bitrate_config.start_bitrate_bps) &&
Stefan Holmere5904162015-03-26 10:11:06744 config_.bitrate_config.max_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34745 bitrate_config.max_bitrate_bps) {
746 // Nothing new to set, early abort to avoid encoder reconfigurations.
747 return;
748 }
Stefan Holmerbe402962016-07-08 14:16:41749 config_.bitrate_config.min_bitrate_bps = bitrate_config.min_bitrate_bps;
750 // Start bitrate of -1 means we should keep the old bitrate, which there is
751 // no point in remembering for the future.
752 if (bitrate_config.start_bitrate_bps > 0)
753 config_.bitrate_config.start_bitrate_bps = bitrate_config.start_bitrate_bps;
754 config_.bitrate_config.max_bitrate_bps = bitrate_config.max_bitrate_bps;
mflodman0c478b32015-10-21 13:52:16755 congestion_controller_->SetBweBitrates(bitrate_config.min_bitrate_bps,
756 bitrate_config.start_bitrate_bps,
757 bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34758}
759
skvlad7a43d252016-03-22 22:32:27760void Call::SignalChannelNetworkState(MediaType media, NetworkState state) {
solenberg5a289392015-10-19 10:39:20761 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
skvlad7a43d252016-03-22 22:32:27762 switch (media) {
763 case MediaType::AUDIO:
764 audio_network_state_ = state;
765 break;
766 case MediaType::VIDEO:
767 video_network_state_ = state;
768 break;
769 case MediaType::ANY:
770 case MediaType::DATA:
771 RTC_NOTREACHED();
772 break;
773 }
774
775 UpdateAggregateNetworkState();
pbos@webrtc.org26c0c412014-09-03 16:17:12776 {
skvlad7a43d252016-03-22 22:32:27777 ReadLockScoped read_lock(*send_crit_);
solenbergc7a8b082015-10-16 21:35:07778 for (auto& kv : audio_send_ssrcs_) {
skvlad7a43d252016-03-22 22:32:27779 kv.second->SignalNetworkState(audio_network_state_);
solenbergc7a8b082015-10-16 21:35:07780 }
Fredrik Solenberg23fba1f2015-04-29 13:24:01781 for (auto& kv : video_send_ssrcs_) {
skvlad7a43d252016-03-22 22:32:27782 kv.second->SignalNetworkState(video_network_state_);
pbos@webrtc.org26c0c412014-09-03 16:17:12783 }
784 }
785 {
skvlad7a43d252016-03-22 22:32:27786 ReadLockScoped read_lock(*receive_crit_);
787 for (auto& kv : audio_receive_ssrcs_) {
788 kv.second->SignalNetworkState(audio_network_state_);
789 }
Fredrik Solenberg23fba1f2015-04-29 13:24:01790 for (auto& kv : video_receive_ssrcs_) {
skvlad7a43d252016-03-22 22:32:27791 kv.second->SignalNetworkState(video_network_state_);
pbos@webrtc.org26c0c412014-09-03 16:17:12792 }
793 }
794}
795
michaelt79e05882016-11-08 10:50:09796void Call::OnTransportOverheadChanged(MediaType media,
797 int transport_overhead_per_packet) {
798 switch (media) {
799 case MediaType::AUDIO: {
800 ReadLockScoped read_lock(*send_crit_);
801 for (auto& kv : audio_send_ssrcs_) {
802 kv.second->SetTransportOverhead(transport_overhead_per_packet);
803 }
804 break;
805 }
806 case MediaType::VIDEO: {
807 ReadLockScoped read_lock(*send_crit_);
808 for (auto& kv : video_send_ssrcs_) {
809 kv.second->SetTransportOverhead(transport_overhead_per_packet);
810 }
811 break;
812 }
813 case MediaType::ANY:
814 case MediaType::DATA:
815 RTC_NOTREACHED();
816 break;
817 }
818}
819
Honghai Zhang0e533ef2016-04-19 22:41:36820// TODO(honghaiz): Add tests for this method.
821void Call::OnNetworkRouteChanged(const std::string& transport_name,
822 const rtc::NetworkRoute& network_route) {
823 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
824 // Check if the network route is connected.
825 if (!network_route.connected) {
826 LOG(LS_INFO) << "Transport " << transport_name << " is disconnected";
827 // TODO(honghaiz): Perhaps handle this in SignalChannelNetworkState and
828 // consider merging these two methods.
829 return;
830 }
831
832 // Check whether the network route has changed on each transport.
833 auto result =
834 network_routes_.insert(std::make_pair(transport_name, network_route));
835 auto kv = result.first;
836 bool inserted = result.second;
837 if (inserted) {
838 // No need to reset BWE if this is the first time the network connects.
839 return;
840 }
841 if (kv->second != network_route) {
842 kv->second = network_route;
843 LOG(LS_INFO) << "Network route changed on transport " << transport_name
844 << ": new local network id " << network_route.local_network_id
honghaiz059e1832016-06-24 18:03:55845 << " new remote network id " << network_route.remote_network_id
Stefan Holmer52200d02016-09-20 12:14:23846 << " Reset bitrates to min: "
847 << config_.bitrate_config.min_bitrate_bps
848 << " bps, start: " << config_.bitrate_config.start_bitrate_bps
849 << " bps, max: " << config_.bitrate_config.start_bitrate_bps
850 << " bps.";
honghaiz059e1832016-06-24 18:03:55851 congestion_controller_->ResetBweAndBitrates(
852 config_.bitrate_config.start_bitrate_bps,
853 config_.bitrate_config.min_bitrate_bps,
854 config_.bitrate_config.max_bitrate_bps);
Honghai Zhang0e533ef2016-04-19 22:41:36855 }
856}
857
skvlad7a43d252016-03-22 22:32:27858void Call::UpdateAggregateNetworkState() {
859 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
860
861 bool have_audio = false;
862 bool have_video = false;
863 {
864 ReadLockScoped read_lock(*send_crit_);
865 if (audio_send_ssrcs_.size() > 0)
866 have_audio = true;
867 if (video_send_ssrcs_.size() > 0)
868 have_video = true;
869 }
870 {
871 ReadLockScoped read_lock(*receive_crit_);
872 if (audio_receive_ssrcs_.size() > 0)
873 have_audio = true;
874 if (video_receive_ssrcs_.size() > 0)
875 have_video = true;
876 }
877
878 NetworkState aggregate_state = kNetworkDown;
879 if ((have_video && video_network_state_ == kNetworkUp) ||
880 (have_audio && audio_network_state_ == kNetworkUp)) {
881 aggregate_state = kNetworkUp;
882 }
883
884 LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state="
885 << (aggregate_state == kNetworkUp ? "up" : "down");
886
887 congestion_controller_->SignalNetworkState(aggregate_state);
888}
889
stefanc1aeaf02015-10-15 14:26:07890void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
stefan18adf0a2015-11-17 14:24:56891 if (first_packet_sent_ms_ == -1)
892 first_packet_sent_ms_ = clock_->TimeInMilliseconds();
asapersson35151f32016-05-03 06:44:01893 video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
894 clock_->TimeInMilliseconds());
mflodman0c478b32015-10-21 13:52:16895 congestion_controller_->OnSentPacket(sent_packet);
stefanc1aeaf02015-10-15 14:26:07896}
897
minyue78b4d562016-11-30 12:47:39898void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
899 uint8_t fraction_loss,
900 int64_t rtt_ms,
901 int64_t probing_interval_ms) {
perkj26091b12016-09-01 08:17:40902 // TODO(perkj): Consider making sure CongestionController operates on
903 // |worker_queue_|.
904 if (!worker_queue_.IsCurrent()) {
minyue78b4d562016-11-30 12:47:39905 worker_queue_.PostTask(
906 [this, target_bitrate_bps, fraction_loss, rtt_ms, probing_interval_ms] {
907 OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt_ms,
908 probing_interval_ms);
909 });
perkj26091b12016-09-01 08:17:40910 return;
911 }
912 RTC_DCHECK_RUN_ON(&worker_queue_);
perkj71ee44c2016-06-15 07:47:53913 bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, fraction_loss,
minyue78b4d562016-11-30 12:47:39914 rtt_ms, probing_interval_ms);
mflodman0e7e2592015-11-13 05:02:42915
asaperssonce2e1362016-09-09 07:13:35916 // Ignore updates if bitrate is zero (the aggregate network state is down).
917 if (target_bitrate_bps == 0) {
stefan18adf0a2015-11-17 14:24:56918 rtc::CritScope lock(&bitrate_crit_);
asaperssonce2e1362016-09-09 07:13:35919 estimated_send_bitrate_kbps_counter_.ProcessAndPause();
920 pacer_bitrate_kbps_counter_.ProcessAndPause();
921 return;
stefan18adf0a2015-11-17 14:24:56922 }
asaperssonce2e1362016-09-09 07:13:35923
924 bool sending_video;
925 {
926 ReadLockScoped read_lock(*send_crit_);
927 sending_video = !video_send_streams_.empty();
928 }
929
930 rtc::CritScope lock(&bitrate_crit_);
931 if (!sending_video) {
932 // Do not update the stats if we are not sending video.
933 estimated_send_bitrate_kbps_counter_.ProcessAndPause();
934 pacer_bitrate_kbps_counter_.ProcessAndPause();
935 return;
936 }
937 estimated_send_bitrate_kbps_counter_.Add(target_bitrate_bps / 1000);
938 // Pacer bitrate may be higher than bitrate estimate if enforcing min bitrate.
939 uint32_t pacer_bitrate_bps =
940 std::max(target_bitrate_bps, min_allocated_send_bitrate_bps_);
941 pacer_bitrate_kbps_counter_.Add(pacer_bitrate_bps / 1000);
perkj71ee44c2016-06-15 07:47:53942}
mflodman101f2502016-06-09 15:21:19943
perkj71ee44c2016-06-15 07:47:53944void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
945 uint32_t max_padding_bitrate_bps) {
946 congestion_controller_->SetAllocatedSendBitrateLimits(
947 min_send_bitrate_bps, max_padding_bitrate_bps);
948 rtc::CritScope lock(&bitrate_crit_);
949 min_allocated_send_bitrate_bps_ = min_send_bitrate_bps;
sprang9c0b5512016-07-06 07:54:28950 configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps;
mflodman0e7e2592015-11-13 05:02:42951}
952
pbos8fc7fa72015-07-15 15:02:58953void Call::ConfigureSync(const std::string& sync_group) {
954 // Set sync only if there was no previous one.
solenberg566ef242015-11-06 23:34:49955 if (voice_engine() == nullptr || sync_group.empty())
pbos8fc7fa72015-07-15 15:02:58956 return;
957
958 AudioReceiveStream* sync_audio_stream = nullptr;
959 // Find existing audio stream.
960 const auto it = sync_stream_mapping_.find(sync_group);
961 if (it != sync_stream_mapping_.end()) {
962 sync_audio_stream = it->second;
963 } else {
964 // No configured audio stream, see if we can find one.
965 for (const auto& kv : audio_receive_ssrcs_) {
966 if (kv.second->config().sync_group == sync_group) {
967 if (sync_audio_stream != nullptr) {
968 LOG(LS_WARNING) << "Attempting to sync more than one audio stream "
969 "within the same sync group. This is not "
970 "supported in the current implementation.";
971 break;
972 }
973 sync_audio_stream = kv.second;
974 }
975 }
976 }
977 if (sync_audio_stream)
978 sync_stream_mapping_[sync_group] = sync_audio_stream;
979 size_t num_synced_streams = 0;
980 for (VideoReceiveStream* video_stream : video_receive_streams_) {
981 if (video_stream->config().sync_group != sync_group)
982 continue;
983 ++num_synced_streams;
984 if (num_synced_streams > 1) {
985 // TODO(pbos): Support synchronizing more than one A/V pair.
986 // https://code.google.com/p/webrtc/issues/detail?id=4762
987 LOG(LS_WARNING) << "Attempting to sync more than one audio/video pair "
988 "within the same sync group. This is not supported in "
989 "the current implementation.";
990 }
991 // Only sync the first A/V pair within this sync group.
992 if (sync_audio_stream != nullptr && num_synced_streams == 1) {
solenberg566ef242015-11-06 23:34:49993 video_stream->SetSyncChannel(voice_engine(),
pbos8fc7fa72015-07-15 15:02:58994 sync_audio_stream->config().voe_channel_id);
995 } else {
solenberg566ef242015-11-06 23:34:49996 video_stream->SetSyncChannel(voice_engine(), -1);
pbos8fc7fa72015-07-15 15:02:58997 }
998 }
999}
1000
Fredrik Solenberg23fba1f2015-04-29 13:24:011001PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
1002 const uint8_t* packet,
1003 size_t length) {
Peter Boström6f28cf02015-12-07 22:17:151004 TRACE_EVENT0("webrtc", "Call::DeliverRtcp");
mflodman3d7db262016-04-29 07:57:131005 // TODO(pbos): Make sure it's a valid packet.
pbos@webrtc.orgcaba2d22014-05-14 13:57:121006 // Return DELIVERY_UNKNOWN_SSRC if it can be determined that
1007 // there's no receiver of the packet.
asapersson250fd972016-09-08 07:07:211008 if (received_bytes_per_second_counter_.HasSample()) {
1009 // First RTP packet has been received.
1010 received_bytes_per_second_counter_.Add(static_cast<int>(length));
1011 received_rtcp_bytes_per_second_counter_.Add(static_cast<int>(length));
1012 }
pbos@webrtc.org29d58392013-05-16 12:08:031013 bool rtcp_delivered = false;
Fredrik Solenberg23fba1f2015-04-29 13:24:011014 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
pbos@webrtc.org26c0c412014-09-03 16:17:121015 ReadLockScoped read_lock(*receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 13:24:011016 for (VideoReceiveStream* stream : video_receive_streams_) {
mflodman3d7db262016-04-29 07:57:131017 if (stream->DeliverRtcp(packet, length))
pbos@webrtc.org40523702013-08-05 12:49:221018 rtcp_delivered = true;
mflodman3d7db262016-04-29 07:57:131019 }
1020 }
1021 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
1022 ReadLockScoped read_lock(*receive_crit_);
1023 for (auto& kv : audio_receive_ssrcs_) {
1024 if (kv.second->DeliverRtcp(packet, length))
1025 rtcp_delivered = true;
pbos@webrtc.orgbbb07e62013-08-05 12:01:361026 }
1027 }
Fredrik Solenberg23fba1f2015-04-29 13:24:011028 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
pbos@webrtc.org26c0c412014-09-03 16:17:121029 ReadLockScoped read_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 13:24:011030 for (VideoSendStream* stream : video_send_streams_) {
mflodman3d7db262016-04-29 07:57:131031 if (stream->DeliverRtcp(packet, length))
pbos@webrtc.org40523702013-08-05 12:49:221032 rtcp_delivered = true;
pbos@webrtc.org29d58392013-05-16 12:08:031033 }
1034 }
mflodman3d7db262016-04-29 07:57:131035 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
1036 ReadLockScoped read_lock(*send_crit_);
1037 for (auto& kv : audio_send_ssrcs_) {
1038 if (kv.second->DeliverRtcp(packet, length))
1039 rtcp_delivered = true;
1040 }
1041 }
1042
skvlad11a9cbf2016-10-07 18:53:051043 if (rtcp_delivered)
mflodman3d7db262016-04-29 07:57:131044 event_log_->LogRtcpPacket(kIncomingPacket, media_type, packet, length);
1045
pbos@webrtc.orgcaba2d22014-05-14 13:57:121046 return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
pbos@webrtc.org29d58392013-05-16 12:08:031047}
1048
Fredrik Solenberg23fba1f2015-04-29 13:24:011049PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
1050 const uint8_t* packet,
stefan68786d22015-09-08 12:36:151051 size_t length,
1052 const PacketTime& packet_time) {
Peter Boström6f28cf02015-12-07 22:17:151053 TRACE_EVENT0("webrtc", "Call::DeliverRtp");
pbos@webrtc.orgaf38f4e2014-07-08 07:38:121054 // Minimum RTP header size.
1055 if (length < 12)
1056 return DELIVERY_PACKET_ERROR;
1057
stefan91d92602015-11-11 18:13:021058 uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
pbos@webrtc.org26c0c412014-09-03 16:17:121059 ReadLockScoped read_lock(*receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 13:24:011060 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
1061 auto it = audio_receive_ssrcs_.find(ssrc);
1062 if (it != audio_receive_ssrcs_.end()) {
asapersson250fd972016-09-08 07:07:211063 received_bytes_per_second_counter_.Add(static_cast<int>(length));
1064 received_audio_bytes_per_second_counter_.Add(static_cast<int>(length));
ivocb04965c2015-09-09 07:09:431065 auto status = it->second->DeliverRtp(packet, length, packet_time)
1066 ? DELIVERY_OK
1067 : DELIVERY_PACKET_ERROR;
ivoc14d5dbe2016-07-04 14:06:551068 if (status == DELIVERY_OK)
terelius429c3452016-01-21 13:42:041069 event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
ivocb04965c2015-09-09 07:09:431070 return status;
Fredrik Solenberg23fba1f2015-04-29 13:24:011071 }
1072 }
1073 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
1074 auto it = video_receive_ssrcs_.find(ssrc);
1075 if (it != video_receive_ssrcs_.end()) {
asapersson250fd972016-09-08 07:07:211076 received_bytes_per_second_counter_.Add(static_cast<int>(length));
1077 received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
ivocb04965c2015-09-09 07:09:431078 auto status = it->second->DeliverRtp(packet, length, packet_time)
1079 ? DELIVERY_OK
1080 : DELIVERY_PACKET_ERROR;
brandtr25445d32016-10-24 06:37:141081 // Deliver media packets to FlexFEC subsystem.
1082 auto it_bounds = flexfec_receive_ssrcs_media_.equal_range(ssrc);
1083 for (auto it = it_bounds.first; it != it_bounds.second; ++it)
1084 it->second->AddAndProcessReceivedPacket(packet, length);
1085 if (status == DELIVERY_OK)
1086 event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
1087 return status;
1088 }
1089 }
1090 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
1091 auto it = flexfec_receive_ssrcs_protection_.find(ssrc);
1092 if (it != flexfec_receive_ssrcs_protection_.end()) {
1093 auto status = it->second->AddAndProcessReceivedPacket(packet, length)
1094 ? DELIVERY_OK
1095 : DELIVERY_PACKET_ERROR;
ivoc14d5dbe2016-07-04 14:06:551096 if (status == DELIVERY_OK)
terelius429c3452016-01-21 13:42:041097 event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
ivocb04965c2015-09-09 07:09:431098 return status;
Fredrik Solenberg23fba1f2015-04-29 13:24:011099 }
1100 }
1101 return DELIVERY_UNKNOWN_SSRC;
pbos@webrtc.org29d58392013-05-16 12:08:031102}
1103
stefan68786d22015-09-08 12:36:151104PacketReceiver::DeliveryStatus Call::DeliverPacket(
1105 MediaType media_type,
1106 const uint8_t* packet,
1107 size_t length,
1108 const PacketTime& packet_time) {
solenberg5a289392015-10-19 10:39:201109 // TODO(solenberg): Tests call this function on a network thread, libjingle
1110 // calls on the worker thread. We should move towards always using a network
1111 // thread. Then this check can be enabled.
1112 // RTC_DCHECK(!configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org62bafae2014-07-08 12:10:511113 if (RtpHeaderParser::IsRtcp(packet, length))
Fredrik Solenberg23fba1f2015-04-29 13:24:011114 return DeliverRtcp(media_type, packet, length);
pbos@webrtc.org29d58392013-05-16 12:08:031115
stefan68786d22015-09-08 12:36:151116 return DeliverRtp(media_type, packet, length, packet_time);
pbos@webrtc.org29d58392013-05-16 12:08:031117}
1118
brandtr4e523862016-10-19 06:50:451119// TODO(brandtr): Update this member function when we support protecting
1120// audio packets with FlexFEC.
1121bool Call::OnRecoveredPacket(const uint8_t* packet, size_t length) {
1122 uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
1123 ReadLockScoped read_lock(*receive_crit_);
1124 auto it = video_receive_ssrcs_.find(ssrc);
1125 if (it == video_receive_ssrcs_.end())
1126 return false;
1127 return it->second->OnRecoveredPacket(packet, length);
1128}
1129
pbos@webrtc.org29d58392013-05-16 12:08:031130} // namespace internal
1131} // namespace webrtc