blob: 5c46a48f14e30760e702369dd118f434997b0073 [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>
12
pbos@webrtc.org29d58392013-05-16 12:08:03 +000013#include <map>
14#include <vector>
15
Peter Boström5c389d32015-09-25 13:58:30 +020016#include "webrtc/audio/audio_receive_stream.h"
solenbergc7a8b082015-10-16 14:35:07 -070017#include "webrtc/audio/audio_send_stream.h"
solenberg566ef242015-11-06 15:34:49 -080018#include "webrtc/audio/audio_state.h"
19#include "webrtc/audio/scoped_voe_interface.h"
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +000020#include "webrtc/base/checks.h"
Peter Boström7c704b82015-12-04 16:13:05 +010021#include "webrtc/base/logging.h"
kwiberg@webrtc.org00b8f6b2015-02-26 14:34:55 +000022#include "webrtc/base/scoped_ptr.h"
pbos@webrtc.org38344ed2014-09-24 06:05:00 +000023#include "webrtc/base/thread_annotations.h"
solenberg5a289392015-10-19 03:39:20 -070024#include "webrtc/base/thread_checker.h"
tommie4f96502015-10-20 23:00:48 -070025#include "webrtc/base/trace_event.h"
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000026#include "webrtc/call.h"
mflodman0e7e2592015-11-12 21:02:42 -080027#include "webrtc/call/bitrate_allocator.h"
mflodman0c478b32015-10-21 15:52:16 +020028#include "webrtc/call/congestion_controller.h"
Peter Boström5c389d32015-09-25 13:58:30 +020029#include "webrtc/call/rtc_event_log.h"
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +000030#include "webrtc/common.h"
pbos@webrtc.orgc49d5b72013-12-05 12:11:47 +000031#include "webrtc/config.h"
mflodman0e7e2592015-11-12 21:02:42 -080032#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
Henrik Kjellander0b9e29c2015-11-16 11:12:24 +010033#include "webrtc/modules/pacing/paced_sender.h"
Henrik Kjellanderff761fb2015-11-04 08:31:52 +010034#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
sprang@webrtc.org2a6558c2015-01-28 12:37:36 +000035#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
Henrik Kjellanderff761fb2015-11-04 08:31:52 +010036#include "webrtc/modules/utility/include/process_thread.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010037#include "webrtc/system_wrappers/include/cpu_info.h"
38#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
stefan91d92602015-11-11 10:13:02 -080039#include "webrtc/system_wrappers/include/metrics.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010040#include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
41#include "webrtc/system_wrappers/include/trace.h"
Peter Boström7623ce42015-12-09 12:13:30 +010042#include "webrtc/video/call_stats.h"
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000043#include "webrtc/video/video_receive_stream.h"
44#include "webrtc/video/video_send_stream.h"
ivocb04965c2015-09-09 00:09:43 -070045#include "webrtc/voice_engine/include/voe_codec.h"
pbos@webrtc.org29d58392013-05-16 12:08:03 +000046
47namespace webrtc {
pbos@webrtc.orgab990ae2014-09-17 09:02:25 +000048
pbos@webrtc.orga73a6782014-10-14 11:52:10 +000049const int Call::Config::kDefaultStartBitrateBps = 300000;
50
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000051namespace internal {
asapersson@webrtc.orgbdc5ed22014-01-31 10:05:07 +000052
mflodman0e7e2592015-11-12 21:02:42 -080053class Call : public webrtc::Call, public PacketReceiver,
54 public BitrateObserver {
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000055 public:
Peter Boström45553ae2015-05-08 13:54:38 +020056 explicit Call(const Call::Config& config);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000057 virtual ~Call();
58
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000059 PacketReceiver* Receiver() override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000060
Fredrik Solenberg04f49312015-06-08 13:04:56 +020061 webrtc::AudioSendStream* CreateAudioSendStream(
62 const webrtc::AudioSendStream::Config& config) override;
63 void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override;
64
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +020065 webrtc::AudioReceiveStream* CreateAudioReceiveStream(
66 const webrtc::AudioReceiveStream::Config& config) override;
67 void DestroyAudioReceiveStream(
68 webrtc::AudioReceiveStream* receive_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000069
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +020070 webrtc::VideoSendStream* CreateVideoSendStream(
71 const webrtc::VideoSendStream::Config& config,
72 const VideoEncoderConfig& encoder_config) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000073 void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000074
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +020075 webrtc::VideoReceiveStream* CreateVideoReceiveStream(
76 const webrtc::VideoReceiveStream::Config& config) override;
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000077 void DestroyVideoReceiveStream(
78 webrtc::VideoReceiveStream* receive_stream) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000079
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000080 Stats GetStats() const override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000081
stefan68786d22015-09-08 05:36:15 -070082 DeliveryStatus DeliverPacket(MediaType media_type,
83 const uint8_t* packet,
84 size_t length,
85 const PacketTime& packet_time) override;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000086
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000087 void SetBitrateConfig(
88 const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
89 void SignalNetworkState(NetworkState state) override;
pbos@webrtc.org26c0c412014-09-03 16:17:12 +000090
stefanc1aeaf02015-10-15 07:26:07 -070091 void OnSentPacket(const rtc::SentPacket& sent_packet) override;
92
mflodman0e7e2592015-11-12 21:02:42 -080093 // Implements BitrateObserver.
94 void OnNetworkChanged(uint32_t bitrate_bps, uint8_t fraction_loss,
95 int64_t rtt_ms) override;
96
pbos@webrtc.org16e03b72013-10-28 16:32:01 +000097 private:
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +020098 DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet,
99 size_t length);
stefan68786d22015-09-08 05:36:15 -0700100 DeliveryStatus DeliverRtp(MediaType media_type,
101 const uint8_t* packet,
102 size_t length,
103 const PacketTime& packet_time);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000104
pbos8fc7fa72015-07-15 08:02:58 -0700105 void ConfigureSync(const std::string& sync_group)
106 EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
107
solenberg566ef242015-11-06 15:34:49 -0800108 VoiceEngine* voice_engine() {
109 internal::AudioState* audio_state =
110 static_cast<internal::AudioState*>(config_.audio_state.get());
111 if (audio_state)
112 return audio_state->voice_engine();
113 else
114 return nullptr;
115 }
116
Stefan Holmer226befe2015-11-26 15:36:48 +0100117 void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
stefan18adf0a2015-11-17 06:24:56 -0800118 void UpdateReceiveHistograms();
stefan91d92602015-11-11 10:13:02 -0800119
Peter Boströmd3c94472015-12-09 11:20:58 +0100120 Clock* const clock_;
stefan91d92602015-11-11 10:13:02 -0800121
Peter Boström45553ae2015-05-08 13:54:38 +0200122 const int num_cpu_cores_;
123 const rtc::scoped_ptr<ProcessThread> module_process_thread_;
mflodmane3787022015-10-21 13:24:28 +0200124 const rtc::scoped_ptr<CallStats> call_stats_;
mflodman0e7e2592015-11-12 21:02:42 -0800125 const rtc::scoped_ptr<BitrateAllocator> bitrate_allocator_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000126 Call::Config config_;
solenberg5a289392015-10-19 03:39:20 -0700127 rtc::ThreadChecker configuration_thread_checker_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000128
Fredrik Solenbergea073732015-12-01 11:26:34 +0100129 bool network_enabled_;
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000130
kwiberg@webrtc.org00b8f6b2015-02-26 14:34:55 +0000131 rtc::scoped_ptr<RWLockWrapper> receive_crit_;
solenbergc7a8b082015-10-16 14:35:07 -0700132 // Audio and Video receive streams are owned by the client that creates them.
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200133 std::map<uint32_t, AudioReceiveStream*> audio_receive_ssrcs_
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000134 GUARDED_BY(receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200135 std::map<uint32_t, VideoReceiveStream*> video_receive_ssrcs_
136 GUARDED_BY(receive_crit_);
137 std::set<VideoReceiveStream*> video_receive_streams_
138 GUARDED_BY(receive_crit_);
pbos8fc7fa72015-07-15 08:02:58 -0700139 std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
140 GUARDED_BY(receive_crit_);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000141
kwiberg@webrtc.org00b8f6b2015-02-26 14:34:55 +0000142 rtc::scoped_ptr<RWLockWrapper> send_crit_;
solenbergc7a8b082015-10-16 14:35:07 -0700143 // Audio and Video send streams are owned by the client that creates them.
144 std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200145 std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
146 std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000147
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200148 VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000149
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +0200150 RtcEventLog* event_log_ = nullptr;
ivocb04965c2015-09-09 00:09:43 -0700151
stefan18adf0a2015-11-17 06:24:56 -0800152 // The following members are only accessed (exclusively) from one thread and
153 // from the destructor, and therefore doesn't need any explicit
154 // synchronization.
Stefan Holmer226befe2015-11-26 15:36:48 +0100155 int64_t received_video_bytes_;
156 int64_t received_audio_bytes_;
157 int64_t received_rtcp_bytes_;
stefan91d92602015-11-11 10:13:02 -0800158 int64_t first_rtp_packet_received_ms_;
Stefan Holmer226befe2015-11-26 15:36:48 +0100159 int64_t last_rtp_packet_received_ms_;
160 int64_t first_packet_sent_ms_;
stefan91d92602015-11-11 10:13:02 -0800161
stefan18adf0a2015-11-17 06:24:56 -0800162 // TODO(holmer): Remove this lock once BitrateController no longer calls
163 // OnNetworkChanged from multiple threads.
164 rtc::CriticalSection bitrate_crit_;
Stefan Holmer226befe2015-11-26 15:36:48 +0100165 int64_t estimated_send_bitrate_sum_kbits_ GUARDED_BY(&bitrate_crit_);
166 int64_t pacer_bitrate_sum_kbits_ GUARDED_BY(&bitrate_crit_);
167 int64_t num_bitrate_updates_ GUARDED_BY(&bitrate_crit_);
stefan18adf0a2015-11-17 06:24:56 -0800168
mflodman0e7e2592015-11-12 21:02:42 -0800169 const rtc::scoped_ptr<CongestionController> congestion_controller_;
170
henrikg3c089d72015-09-16 05:37:44 -0700171 RTC_DISALLOW_COPY_AND_ASSIGN(Call);
pbos@webrtc.org16e03b72013-10-28 16:32:01 +0000172};
pbos@webrtc.orgc49d5b72013-12-05 12:11:47 +0000173} // namespace internal
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000174
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000175Call* Call::Create(const Call::Config& config) {
Peter Boström45553ae2015-05-08 13:54:38 +0200176 return new internal::Call(config);
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000177}
pbos@webrtc.orgfd39e132013-08-14 13:52:52 +0000178
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000179namespace internal {
180
Peter Boström45553ae2015-05-08 13:54:38 +0200181Call::Call(const Call::Config& config)
stefan91d92602015-11-11 10:13:02 -0800182 : clock_(Clock::GetRealTimeClock()),
183 num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
stefan847855b2015-09-11 09:52:15 -0700184 module_process_thread_(ProcessThread::Create("ModuleProcessThread")),
Peter Boströmd3c94472015-12-09 11:20:58 +0100185 call_stats_(new CallStats(clock_)),
mflodman0e7e2592015-11-12 21:02:42 -0800186 bitrate_allocator_(new BitrateAllocator()),
Peter Boström45553ae2015-05-08 13:54:38 +0200187 config_(config),
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000188 network_enabled_(true),
189 receive_crit_(RWLockWrapper::CreateRWLock()),
stefan91d92602015-11-11 10:13:02 -0800190 send_crit_(RWLockWrapper::CreateRWLock()),
Stefan Holmer226befe2015-11-26 15:36:48 +0100191 received_video_bytes_(0),
192 received_audio_bytes_(0),
193 received_rtcp_bytes_(0),
mflodman0e7e2592015-11-12 21:02:42 -0800194 first_rtp_packet_received_ms_(-1),
Stefan Holmer226befe2015-11-26 15:36:48 +0100195 last_rtp_packet_received_ms_(-1),
196 first_packet_sent_ms_(-1),
197 estimated_send_bitrate_sum_kbits_(0),
198 pacer_bitrate_sum_kbits_(0),
199 num_bitrate_updates_(0),
stefan18adf0a2015-11-17 06:24:56 -0800200 congestion_controller_(
201 new CongestionController(module_process_thread_.get(),
202 call_stats_.get(),
203 this)) {
solenberg56a34df2015-11-12 08:24:41 -0800204 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 00:24:34 -0700205 RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
206 RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps,
207 config.bitrate_config.min_bitrate_bps);
Stefan Holmere5904162015-03-26 11:11:06 +0100208 if (config.bitrate_config.max_bitrate_bps != -1) {
henrikg91d6ede2015-09-17 00:24:34 -0700209 RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
210 config.bitrate_config.start_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000211 }
solenberg566ef242015-11-06 15:34:49 -0800212 if (config.audio_state.get()) {
213 ScopedVoEInterface<VoECodec> voe_codec(voice_engine());
214 event_log_ = voe_codec->GetEventLog();
ivocb04965c2015-09-09 00:09:43 -0700215 }
pbos@webrtc.org00873182014-11-25 14:03:34 +0000216
Peter Boström45553ae2015-05-08 13:54:38 +0200217 Trace::CreateTrace();
218 module_process_thread_->Start();
mflodmane3787022015-10-21 13:24:28 +0200219 module_process_thread_->RegisterModule(call_stats_.get());
Peter Boström45553ae2015-05-08 13:54:38 +0200220
mflodman0c478b32015-10-21 15:52:16 +0200221 congestion_controller_->SetBweBitrates(
222 config_.bitrate_config.min_bitrate_bps,
223 config_.bitrate_config.start_bitrate_bps,
224 config_.bitrate_config.max_bitrate_bps);
terelius006d93d2015-11-05 12:02:15 -0800225
226 congestion_controller_->GetBitrateController()->SetEventLog(event_log_);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000227}
228
pbos@webrtc.org841c8a42013-09-09 15:04:25 +0000229Call::~Call() {
solenberg5a289392015-10-19 03:39:20 -0700230 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
stefan18adf0a2015-11-17 06:24:56 -0800231 UpdateSendHistograms();
232 UpdateReceiveHistograms();
solenbergc7a8b082015-10-16 14:35:07 -0700233 RTC_CHECK(audio_send_ssrcs_.empty());
234 RTC_CHECK(video_send_ssrcs_.empty());
235 RTC_CHECK(video_send_streams_.empty());
236 RTC_CHECK(audio_receive_ssrcs_.empty());
237 RTC_CHECK(video_receive_ssrcs_.empty());
238 RTC_CHECK(video_receive_streams_.empty());
pbos@webrtc.org9e4e5242015-02-12 10:48:23 +0000239
mflodmane3787022015-10-21 13:24:28 +0200240 module_process_thread_->DeRegisterModule(call_stats_.get());
Peter Boström45553ae2015-05-08 13:54:38 +0200241 module_process_thread_->Stop();
242 Trace::ReturnTrace();
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000243}
244
stefan18adf0a2015-11-17 06:24:56 -0800245void Call::UpdateSendHistograms() {
Stefan Holmer226befe2015-11-26 15:36:48 +0100246 if (num_bitrate_updates_ == 0 || first_packet_sent_ms_ == -1)
stefan18adf0a2015-11-17 06:24:56 -0800247 return;
248 int64_t elapsed_sec =
249 (clock_->TimeInMilliseconds() - first_packet_sent_ms_) / 1000;
250 if (elapsed_sec < metrics::kMinRunTimeInSeconds)
251 return;
Stefan Holmer226befe2015-11-26 15:36:48 +0100252 int send_bitrate_kbps =
253 estimated_send_bitrate_sum_kbits_ / num_bitrate_updates_;
254 int pacer_bitrate_kbps = pacer_bitrate_sum_kbits_ / num_bitrate_updates_;
stefan18adf0a2015-11-17 06:24:56 -0800255 if (send_bitrate_kbps > 0) {
asapersson53805322015-12-21 01:46:20 -0800256 RTC_HISTOGRAM_COUNTS_SPARSE_100000("WebRTC.Call.EstimatedSendBitrateInKbps",
257 send_bitrate_kbps);
stefan18adf0a2015-11-17 06:24:56 -0800258 }
259 if (pacer_bitrate_kbps > 0) {
asapersson53805322015-12-21 01:46:20 -0800260 RTC_HISTOGRAM_COUNTS_SPARSE_100000("WebRTC.Call.PacerBitrateInKbps",
261 pacer_bitrate_kbps);
stefan18adf0a2015-11-17 06:24:56 -0800262 }
263}
264
265void Call::UpdateReceiveHistograms() {
stefan91d92602015-11-11 10:13:02 -0800266 if (first_rtp_packet_received_ms_ == -1)
267 return;
268 int64_t elapsed_sec =
Stefan Holmer226befe2015-11-26 15:36:48 +0100269 (last_rtp_packet_received_ms_ - first_rtp_packet_received_ms_) / 1000;
stefan91d92602015-11-11 10:13:02 -0800270 if (elapsed_sec < metrics::kMinRunTimeInSeconds)
271 return;
Stefan Holmer226befe2015-11-26 15:36:48 +0100272 int audio_bitrate_kbps = received_audio_bytes_ * 8 / elapsed_sec / 1000;
273 int video_bitrate_kbps = received_video_bytes_ * 8 / elapsed_sec / 1000;
274 int rtcp_bitrate_bps = received_rtcp_bytes_ * 8 / elapsed_sec;
stefan91d92602015-11-11 10:13:02 -0800275 if (video_bitrate_kbps > 0) {
asapersson53805322015-12-21 01:46:20 -0800276 RTC_HISTOGRAM_COUNTS_SPARSE_100000("WebRTC.Call.VideoBitrateReceivedInKbps",
277 video_bitrate_kbps);
stefan91d92602015-11-11 10:13:02 -0800278 }
279 if (audio_bitrate_kbps > 0) {
asapersson53805322015-12-21 01:46:20 -0800280 RTC_HISTOGRAM_COUNTS_SPARSE_100000("WebRTC.Call.AudioBitrateReceivedInKbps",
281 audio_bitrate_kbps);
stefan91d92602015-11-11 10:13:02 -0800282 }
283 if (rtcp_bitrate_bps > 0) {
asapersson53805322015-12-21 01:46:20 -0800284 RTC_HISTOGRAM_COUNTS_SPARSE_100000("WebRTC.Call.RtcpBitrateReceivedInBps",
285 rtcp_bitrate_bps);
stefan91d92602015-11-11 10:13:02 -0800286 }
asapersson53805322015-12-21 01:46:20 -0800287 RTC_HISTOGRAM_COUNTS_SPARSE_100000(
stefan91d92602015-11-11 10:13:02 -0800288 "WebRTC.Call.BitrateReceivedInKbps",
289 audio_bitrate_kbps + video_bitrate_kbps + rtcp_bitrate_bps / 1000);
290}
291
solenberg5a289392015-10-19 03:39:20 -0700292PacketReceiver* Call::Receiver() {
293 // TODO(solenberg): Some test cases in EndToEndTest use this from a different
294 // thread. Re-enable once that is fixed.
295 // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
296 return this;
297}
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000298
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200299webrtc::AudioSendStream* Call::CreateAudioSendStream(
300 const webrtc::AudioSendStream::Config& config) {
solenbergc7a8b082015-10-16 14:35:07 -0700301 TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
solenberg5a289392015-10-19 03:39:20 -0700302 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100303 AudioSendStream* send_stream = new AudioSendStream(
304 config, config_.audio_state, congestion_controller_.get());
mflodman717432f2015-10-26 16:34:46 +0100305 if (!network_enabled_)
306 send_stream->SignalNetworkState(kNetworkDown);
solenbergc7a8b082015-10-16 14:35:07 -0700307 {
solenbergc7a8b082015-10-16 14:35:07 -0700308 WriteLockScoped write_lock(*send_crit_);
309 RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) ==
310 audio_send_ssrcs_.end());
311 audio_send_ssrcs_[config.rtp.ssrc] = send_stream;
solenbergc7a8b082015-10-16 14:35:07 -0700312 }
313 return send_stream;
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200314}
315
316void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
solenbergc7a8b082015-10-16 14:35:07 -0700317 TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream");
solenberg5a289392015-10-19 03:39:20 -0700318 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
solenbergc7a8b082015-10-16 14:35:07 -0700319 RTC_DCHECK(send_stream != nullptr);
320
321 send_stream->Stop();
322
323 webrtc::internal::AudioSendStream* audio_send_stream =
324 static_cast<webrtc::internal::AudioSendStream*>(send_stream);
325 {
326 WriteLockScoped write_lock(*send_crit_);
327 size_t num_deleted = audio_send_ssrcs_.erase(
328 audio_send_stream->config().rtp.ssrc);
329 RTC_DCHECK(num_deleted == 1);
330 }
331 delete audio_send_stream;
Fredrik Solenberg04f49312015-06-08 13:04:56 +0200332}
333
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200334webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
335 const webrtc::AudioReceiveStream::Config& config) {
336 TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
solenberg5a289392015-10-19 03:39:20 -0700337 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200338 AudioReceiveStream* receive_stream = new AudioReceiveStream(
Stefan Holmer3842c5c2016-01-12 13:55:00 +0100339 congestion_controller_.get(), config, config_.audio_state);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200340 {
341 WriteLockScoped write_lock(*receive_crit_);
henrikg91d6ede2015-09-17 00:24:34 -0700342 RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
343 audio_receive_ssrcs_.end());
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200344 audio_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
pbos8fc7fa72015-07-15 08:02:58 -0700345 ConfigureSync(config.sync_group);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200346 }
347 return receive_stream;
348}
349
350void Call::DestroyAudioReceiveStream(
351 webrtc::AudioReceiveStream* receive_stream) {
352 TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream");
solenberg5a289392015-10-19 03:39:20 -0700353 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 00:24:34 -0700354 RTC_DCHECK(receive_stream != nullptr);
solenbergc7a8b082015-10-16 14:35:07 -0700355 webrtc::internal::AudioReceiveStream* audio_receive_stream =
356 static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200357 {
358 WriteLockScoped write_lock(*receive_crit_);
359 size_t num_deleted = audio_receive_ssrcs_.erase(
360 audio_receive_stream->config().rtp.remote_ssrc);
henrikg91d6ede2015-09-17 00:24:34 -0700361 RTC_DCHECK(num_deleted == 1);
pbos8fc7fa72015-07-15 08:02:58 -0700362 const std::string& sync_group = audio_receive_stream->config().sync_group;
363 const auto it = sync_stream_mapping_.find(sync_group);
364 if (it != sync_stream_mapping_.end() &&
365 it->second == audio_receive_stream) {
366 sync_stream_mapping_.erase(it);
367 ConfigureSync(sync_group);
368 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200369 }
370 delete audio_receive_stream;
371}
372
373webrtc::VideoSendStream* Call::CreateVideoSendStream(
374 const webrtc::VideoSendStream::Config& config,
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000375 const VideoEncoderConfig& encoder_config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000376 TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream");
solenberg5a289392015-10-19 03:39:20 -0700377 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org1819fd72013-06-10 13:48:26 +0000378
mflodman@webrtc.orgeb16b812014-06-16 08:57:39 +0000379 // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
380 // the call has already started.
mflodman0c478b32015-10-21 15:52:16 +0200381 VideoSendStream* send_stream = new VideoSendStream(
382 num_cpu_cores_, module_process_thread_.get(), call_stats_.get(),
mflodman0e7e2592015-11-12 21:02:42 -0800383 congestion_controller_.get(), bitrate_allocator_.get(), config,
384 encoder_config, suspended_video_send_ssrcs_);
pbos@webrtc.org1819fd72013-06-10 13:48:26 +0000385
mflodman717432f2015-10-26 16:34:46 +0100386 if (!network_enabled_)
387 send_stream->SignalNetworkState(kNetworkDown);
388
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000389 WriteLockScoped write_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200390 for (uint32_t ssrc : config.rtp.ssrcs) {
henrikg91d6ede2015-09-17 00:24:34 -0700391 RTC_DCHECK(video_send_ssrcs_.find(ssrc) == video_send_ssrcs_.end());
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200392 video_send_ssrcs_[ssrc] = send_stream;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000393 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200394 video_send_streams_.insert(send_stream);
395
ivocb04965c2015-09-09 00:09:43 -0700396 if (event_log_)
397 event_log_->LogVideoSendStreamConfig(config);
398
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000399 return send_stream;
400}
401
pbos@webrtc.org2c46f8d2013-11-21 13:49:43 +0000402void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000403 TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream");
henrikg91d6ede2015-09-17 00:24:34 -0700404 RTC_DCHECK(send_stream != nullptr);
solenberg5a289392015-10-19 03:39:20 -0700405 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000406
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000407 send_stream->Stop();
408
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000409 VideoSendStream* send_stream_impl = nullptr;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000410 {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000411 WriteLockScoped write_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200412 auto it = video_send_ssrcs_.begin();
413 while (it != video_send_ssrcs_.end()) {
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000414 if (it->second == static_cast<VideoSendStream*>(send_stream)) {
415 send_stream_impl = it->second;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200416 video_send_ssrcs_.erase(it++);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000417 } else {
418 ++it;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000419 }
420 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200421 video_send_streams_.erase(send_stream_impl);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000422 }
henrikg91d6ede2015-09-17 00:24:34 -0700423 RTC_CHECK(send_stream_impl != nullptr);
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000424
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000425 VideoSendStream::RtpStateMap rtp_state = send_stream_impl->GetRtpStates();
426
427 for (VideoSendStream::RtpStateMap::iterator it = rtp_state.begin();
428 it != rtp_state.end();
429 ++it) {
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200430 suspended_video_send_ssrcs_[it->first] = it->second;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000431 }
432
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000433 delete send_stream_impl;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000434}
435
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200436webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
437 const webrtc::VideoReceiveStream::Config& config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000438 TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
solenberg5a289392015-10-19 03:39:20 -0700439 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
Peter Boströmc4188fd2015-04-24 15:16:03 +0200440 VideoReceiveStream* receive_stream = new VideoReceiveStream(
mflodman0c478b32015-10-21 15:52:16 +0200441 num_cpu_cores_, congestion_controller_.get(), config,
solenberg566ef242015-11-06 15:34:49 -0800442 voice_engine(), module_process_thread_.get(), call_stats_.get());
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000443
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000444 WriteLockScoped write_lock(*receive_crit_);
henrikg91d6ede2015-09-17 00:24:34 -0700445 RTC_DCHECK(video_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
446 video_receive_ssrcs_.end());
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200447 video_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
pbos@webrtc.orgc279a5d2014-01-24 09:30:53 +0000448 // TODO(pbos): Configure different RTX payloads per receive payload.
449 VideoReceiveStream::Config::Rtp::RtxMap::const_iterator it =
450 config.rtp.rtx.begin();
451 if (it != config.rtp.rtx.end())
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200452 video_receive_ssrcs_[it->second.ssrc] = receive_stream;
453 video_receive_streams_.insert(receive_stream);
pbos@webrtc.orgc279a5d2014-01-24 09:30:53 +0000454
pbos8fc7fa72015-07-15 08:02:58 -0700455 ConfigureSync(config.sync_group);
456
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000457 if (!network_enabled_)
458 receive_stream->SignalNetworkState(kNetworkDown);
pbos8fc7fa72015-07-15 08:02:58 -0700459
ivocb04965c2015-09-09 00:09:43 -0700460 if (event_log_)
461 event_log_->LogVideoReceiveStreamConfig(config);
462
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000463 return receive_stream;
464}
465
pbos@webrtc.org2c46f8d2013-11-21 13:49:43 +0000466void Call::DestroyVideoReceiveStream(
467 webrtc::VideoReceiveStream* receive_stream) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000468 TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
solenberg5a289392015-10-19 03:39:20 -0700469 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 00:24:34 -0700470 RTC_DCHECK(receive_stream != nullptr);
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000471 VideoReceiveStream* receive_stream_impl = nullptr;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000472 {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000473 WriteLockScoped write_lock(*receive_crit_);
pbos@webrtc.orgc279a5d2014-01-24 09:30:53 +0000474 // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a
475 // separate SSRC there can be either one or two.
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200476 auto it = video_receive_ssrcs_.begin();
477 while (it != video_receive_ssrcs_.end()) {
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000478 if (it->second == static_cast<VideoReceiveStream*>(receive_stream)) {
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000479 if (receive_stream_impl != nullptr)
henrikg91d6ede2015-09-17 00:24:34 -0700480 RTC_DCHECK(receive_stream_impl == it->second);
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000481 receive_stream_impl = it->second;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200482 video_receive_ssrcs_.erase(it++);
pbos@webrtc.orgc279a5d2014-01-24 09:30:53 +0000483 } else {
484 ++it;
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000485 }
486 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200487 video_receive_streams_.erase(receive_stream_impl);
henrikg91d6ede2015-09-17 00:24:34 -0700488 RTC_CHECK(receive_stream_impl != nullptr);
pbos8fc7fa72015-07-15 08:02:58 -0700489 ConfigureSync(receive_stream_impl->config().sync_group);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000490 }
pbos@webrtc.org95e51f52013-09-05 12:38:54 +0000491 delete receive_stream_impl;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000492}
493
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000494Call::Stats Call::GetStats() const {
solenberg5a289392015-10-19 03:39:20 -0700495 // TODO(solenberg): Some test cases in EndToEndTest use this from a different
496 // thread. Re-enable once that is fixed.
497 // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000498 Stats stats;
Peter Boström45553ae2015-05-08 13:54:38 +0200499 // Fetch available send/receive bitrates.
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000500 uint32_t send_bandwidth = 0;
mflodman0c478b32015-10-21 15:52:16 +0200501 congestion_controller_->GetBitrateController()->AvailableBandwidth(
502 &send_bandwidth);
Peter Boström45553ae2015-05-08 13:54:38 +0200503 std::vector<unsigned int> ssrcs;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000504 uint32_t recv_bandwidth = 0;
mflodman0c478b32015-10-21 15:52:16 +0200505 congestion_controller_->GetRemoteBitrateEstimator(false)->LatestEstimate(
mflodmana20de202015-10-18 22:08:19 -0700506 &ssrcs, &recv_bandwidth);
Peter Boström45553ae2015-05-08 13:54:38 +0200507 stats.send_bandwidth_bps = send_bandwidth;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000508 stats.recv_bandwidth_bps = recv_bandwidth;
mflodman0c478b32015-10-21 15:52:16 +0200509 stats.pacer_delay_ms = congestion_controller_->GetPacerQueuingDelayMs();
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000510 {
511 ReadLockScoped read_lock(*send_crit_);
solenbergc7a8b082015-10-16 14:35:07 -0700512 // TODO(solenberg): Add audio send streams.
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200513 for (const auto& kv : video_send_ssrcs_) {
514 int rtt_ms = kv.second->GetRtt();
pbos@webrtc.org2b19f062014-12-11 13:26:09 +0000515 if (rtt_ms > 0)
516 stats.rtt_ms = rtt_ms;
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000517 }
518 }
519 return stats;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000520}
521
pbos@webrtc.org00873182014-11-25 14:03:34 +0000522void Call::SetBitrateConfig(
523 const webrtc::Call::Config::BitrateConfig& bitrate_config) {
pbos@webrtc.org50fe3592015-01-29 12:33:07 +0000524 TRACE_EVENT0("webrtc", "Call::SetBitrateConfig");
solenberg5a289392015-10-19 03:39:20 -0700525 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
henrikg91d6ede2015-09-17 00:24:34 -0700526 RTC_DCHECK_GE(bitrate_config.min_bitrate_bps, 0);
pbos@webrtc.org2b4ce3a2015-03-23 13:12:24 +0000527 if (bitrate_config.max_bitrate_bps != -1)
henrikg91d6ede2015-09-17 00:24:34 -0700528 RTC_DCHECK_GT(bitrate_config.max_bitrate_bps, 0);
Stefan Holmere5904162015-03-26 11:11:06 +0100529 if (config_.bitrate_config.min_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34 +0000530 bitrate_config.min_bitrate_bps &&
531 (bitrate_config.start_bitrate_bps <= 0 ||
Stefan Holmere5904162015-03-26 11:11:06 +0100532 config_.bitrate_config.start_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34 +0000533 bitrate_config.start_bitrate_bps) &&
Stefan Holmere5904162015-03-26 11:11:06 +0100534 config_.bitrate_config.max_bitrate_bps ==
pbos@webrtc.org00873182014-11-25 14:03:34 +0000535 bitrate_config.max_bitrate_bps) {
536 // Nothing new to set, early abort to avoid encoder reconfigurations.
537 return;
538 }
Stefan Holmere5904162015-03-26 11:11:06 +0100539 config_.bitrate_config = bitrate_config;
mflodman0c478b32015-10-21 15:52:16 +0200540 congestion_controller_->SetBweBitrates(bitrate_config.min_bitrate_bps,
541 bitrate_config.start_bitrate_bps,
542 bitrate_config.max_bitrate_bps);
pbos@webrtc.org00873182014-11-25 14:03:34 +0000543}
544
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000545void Call::SignalNetworkState(NetworkState state) {
solenberg5a289392015-10-19 03:39:20 -0700546 RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000547 network_enabled_ = state == kNetworkUp;
mflodman0c478b32015-10-21 15:52:16 +0200548 congestion_controller_->SignalNetworkState(state);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000549 {
550 ReadLockScoped write_lock(*send_crit_);
solenbergc7a8b082015-10-16 14:35:07 -0700551 for (auto& kv : audio_send_ssrcs_) {
552 kv.second->SignalNetworkState(state);
553 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200554 for (auto& kv : video_send_ssrcs_) {
555 kv.second->SignalNetworkState(state);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000556 }
557 }
558 {
559 ReadLockScoped write_lock(*receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200560 for (auto& kv : video_receive_ssrcs_) {
561 kv.second->SignalNetworkState(state);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000562 }
563 }
564}
565
stefanc1aeaf02015-10-15 07:26:07 -0700566void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
stefan18adf0a2015-11-17 06:24:56 -0800567 if (first_packet_sent_ms_ == -1)
568 first_packet_sent_ms_ = clock_->TimeInMilliseconds();
mflodman0c478b32015-10-21 15:52:16 +0200569 congestion_controller_->OnSentPacket(sent_packet);
stefanc1aeaf02015-10-15 07:26:07 -0700570}
571
mflodman0e7e2592015-11-12 21:02:42 -0800572void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
573 int64_t rtt_ms) {
574 uint32_t allocated_bitrate_bps = bitrate_allocator_->OnNetworkChanged(
575 target_bitrate_bps, fraction_loss, rtt_ms);
576
577 int pad_up_to_bitrate_bps = 0;
578 {
579 ReadLockScoped read_lock(*send_crit_);
580 // No need to update as long as we're not sending.
581 if (video_send_streams_.empty())
582 return;
583
584 for (VideoSendStream* stream : video_send_streams_)
585 pad_up_to_bitrate_bps += stream->GetPaddingNeededBps();
586 }
587 // Allocated bitrate might be higher than bitrate estimate if enforcing min
588 // bitrate, or lower if estimate is higher than the sum of max bitrates, so
589 // set the pacer bitrate to the maximum of the two.
590 uint32_t pacer_bitrate_bps =
591 std::max(target_bitrate_bps, allocated_bitrate_bps);
stefan18adf0a2015-11-17 06:24:56 -0800592 {
593 rtc::CritScope lock(&bitrate_crit_);
Stefan Holmer226befe2015-11-26 15:36:48 +0100594 // We only update these stats if we have send streams, and assume that
595 // OnNetworkChanged is called roughly with a fixed frequency.
596 estimated_send_bitrate_sum_kbits_ += target_bitrate_bps / 1000;
597 pacer_bitrate_sum_kbits_ += pacer_bitrate_bps / 1000;
598 ++num_bitrate_updates_;
stefan18adf0a2015-11-17 06:24:56 -0800599 }
mflodman0e7e2592015-11-12 21:02:42 -0800600 congestion_controller_->UpdatePacerBitrate(
601 target_bitrate_bps / 1000,
602 PacedSender::kDefaultPaceMultiplier * pacer_bitrate_bps / 1000,
603 pad_up_to_bitrate_bps / 1000);
604}
605
pbos8fc7fa72015-07-15 08:02:58 -0700606void Call::ConfigureSync(const std::string& sync_group) {
607 // Set sync only if there was no previous one.
solenberg566ef242015-11-06 15:34:49 -0800608 if (voice_engine() == nullptr || sync_group.empty())
pbos8fc7fa72015-07-15 08:02:58 -0700609 return;
610
611 AudioReceiveStream* sync_audio_stream = nullptr;
612 // Find existing audio stream.
613 const auto it = sync_stream_mapping_.find(sync_group);
614 if (it != sync_stream_mapping_.end()) {
615 sync_audio_stream = it->second;
616 } else {
617 // No configured audio stream, see if we can find one.
618 for (const auto& kv : audio_receive_ssrcs_) {
619 if (kv.second->config().sync_group == sync_group) {
620 if (sync_audio_stream != nullptr) {
621 LOG(LS_WARNING) << "Attempting to sync more than one audio stream "
622 "within the same sync group. This is not "
623 "supported in the current implementation.";
624 break;
625 }
626 sync_audio_stream = kv.second;
627 }
628 }
629 }
630 if (sync_audio_stream)
631 sync_stream_mapping_[sync_group] = sync_audio_stream;
632 size_t num_synced_streams = 0;
633 for (VideoReceiveStream* video_stream : video_receive_streams_) {
634 if (video_stream->config().sync_group != sync_group)
635 continue;
636 ++num_synced_streams;
637 if (num_synced_streams > 1) {
638 // TODO(pbos): Support synchronizing more than one A/V pair.
639 // https://code.google.com/p/webrtc/issues/detail?id=4762
640 LOG(LS_WARNING) << "Attempting to sync more than one audio/video pair "
641 "within the same sync group. This is not supported in "
642 "the current implementation.";
643 }
644 // Only sync the first A/V pair within this sync group.
645 if (sync_audio_stream != nullptr && num_synced_streams == 1) {
solenberg566ef242015-11-06 15:34:49 -0800646 video_stream->SetSyncChannel(voice_engine(),
pbos8fc7fa72015-07-15 08:02:58 -0700647 sync_audio_stream->config().voe_channel_id);
648 } else {
solenberg566ef242015-11-06 15:34:49 -0800649 video_stream->SetSyncChannel(voice_engine(), -1);
pbos8fc7fa72015-07-15 08:02:58 -0700650 }
651 }
652}
653
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200654PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
655 const uint8_t* packet,
656 size_t length) {
Peter Boström6f28cf02015-12-07 23:17:15 +0100657 TRACE_EVENT0("webrtc", "Call::DeliverRtcp");
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000658 // TODO(pbos): Figure out what channel needs it actually.
659 // Do NOT broadcast! Also make sure it's a valid packet.
pbos@webrtc.orgcaba2d22014-05-14 13:57:12 +0000660 // Return DELIVERY_UNKNOWN_SSRC if it can be determined that
661 // there's no receiver of the packet.
Stefan Holmer226befe2015-11-26 15:36:48 +0100662 received_rtcp_bytes_ += length;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000663 bool rtcp_delivered = false;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200664 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000665 ReadLockScoped read_lock(*receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200666 for (VideoReceiveStream* stream : video_receive_streams_) {
ivocb04965c2015-09-09 00:09:43 -0700667 if (stream->DeliverRtcp(packet, length)) {
pbos@webrtc.org40523702013-08-05 12:49:22 +0000668 rtcp_delivered = true;
ivocb04965c2015-09-09 00:09:43 -0700669 if (event_log_)
670 event_log_->LogRtcpPacket(true, media_type, packet, length);
671 }
pbos@webrtc.orgbbb07e62013-08-05 12:01:36 +0000672 }
673 }
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200674 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000675 ReadLockScoped read_lock(*send_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200676 for (VideoSendStream* stream : video_send_streams_) {
ivocb04965c2015-09-09 00:09:43 -0700677 if (stream->DeliverRtcp(packet, length)) {
pbos@webrtc.org40523702013-08-05 12:49:22 +0000678 rtcp_delivered = true;
ivocb04965c2015-09-09 00:09:43 -0700679 if (event_log_)
680 event_log_->LogRtcpPacket(false, media_type, packet, length);
681 }
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000682 }
683 }
pbos@webrtc.orgcaba2d22014-05-14 13:57:12 +0000684 return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000685}
686
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200687PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
688 const uint8_t* packet,
stefan68786d22015-09-08 05:36:15 -0700689 size_t length,
690 const PacketTime& packet_time) {
Peter Boström6f28cf02015-12-07 23:17:15 +0100691 TRACE_EVENT0("webrtc", "Call::DeliverRtp");
pbos@webrtc.orgaf38f4e2014-07-08 07:38:12 +0000692 // Minimum RTP header size.
693 if (length < 12)
694 return DELIVERY_PACKET_ERROR;
695
Stefan Holmer226befe2015-11-26 15:36:48 +0100696 last_rtp_packet_received_ms_ = clock_->TimeInMilliseconds();
stefan91d92602015-11-11 10:13:02 -0800697 if (first_rtp_packet_received_ms_ == -1)
Stefan Holmer226befe2015-11-26 15:36:48 +0100698 first_rtp_packet_received_ms_ = last_rtp_packet_received_ms_;
pbos@webrtc.orgaf38f4e2014-07-08 07:38:12 +0000699
stefan91d92602015-11-11 10:13:02 -0800700 uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
pbos@webrtc.org26c0c412014-09-03 16:17:12 +0000701 ReadLockScoped read_lock(*receive_crit_);
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200702 if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
703 auto it = audio_receive_ssrcs_.find(ssrc);
704 if (it != audio_receive_ssrcs_.end()) {
Stefan Holmer226befe2015-11-26 15:36:48 +0100705 received_audio_bytes_ += length;
ivocb04965c2015-09-09 00:09:43 -0700706 auto status = it->second->DeliverRtp(packet, length, packet_time)
707 ? DELIVERY_OK
708 : DELIVERY_PACKET_ERROR;
709 if (status == DELIVERY_OK && event_log_)
710 event_log_->LogRtpHeader(true, media_type, packet, length);
711 return status;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200712 }
713 }
714 if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
715 auto it = video_receive_ssrcs_.find(ssrc);
716 if (it != video_receive_ssrcs_.end()) {
Stefan Holmer226befe2015-11-26 15:36:48 +0100717 received_video_bytes_ += length;
ivocb04965c2015-09-09 00:09:43 -0700718 auto status = it->second->DeliverRtp(packet, length, packet_time)
719 ? DELIVERY_OK
720 : DELIVERY_PACKET_ERROR;
721 if (status == DELIVERY_OK && event_log_)
722 event_log_->LogRtpHeader(true, media_type, packet, length);
723 return status;
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200724 }
725 }
726 return DELIVERY_UNKNOWN_SSRC;
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000727}
728
stefan68786d22015-09-08 05:36:15 -0700729PacketReceiver::DeliveryStatus Call::DeliverPacket(
730 MediaType media_type,
731 const uint8_t* packet,
732 size_t length,
733 const PacketTime& packet_time) {
solenberg5a289392015-10-19 03:39:20 -0700734 // TODO(solenberg): Tests call this function on a network thread, libjingle
735 // calls on the worker thread. We should move towards always using a network
736 // thread. Then this check can be enabled.
737 // RTC_DCHECK(!configuration_thread_checker_.CalledOnValidThread());
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000738 if (RtpHeaderParser::IsRtcp(packet, length))
Fredrik Solenberg23fba1f2015-04-29 15:24:01 +0200739 return DeliverRtcp(media_type, packet, length);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000740
stefan68786d22015-09-08 05:36:15 -0700741 return DeliverRtp(media_type, packet, length, packet_time);
pbos@webrtc.org29d58392013-05-16 12:08:03 +0000742}
743
744} // namespace internal
745} // namespace webrtc