pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
pbos@webrtc.org | 12dc1a3 | 2013-08-05 16:22:53 +0000 | [diff] [blame] | 11 | #include <string.h> |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 12 | #include <algorithm> |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 13 | #include <map> |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 14 | #include <memory> |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 15 | #include <vector> |
| 16 | |
Peter Boström | 5c389d3 | 2015-09-25 13:58:30 +0200 | [diff] [blame] | 17 | #include "webrtc/audio/audio_receive_stream.h" |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 18 | #include "webrtc/audio/audio_send_stream.h" |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 19 | #include "webrtc/audio/audio_state.h" |
| 20 | #include "webrtc/audio/scoped_voe_interface.h" |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 +0000 | [diff] [blame] | 21 | #include "webrtc/base/checks.h" |
kwiberg | 4485ffb | 2016-04-26 08:14:39 -0700 | [diff] [blame] | 22 | #include "webrtc/base/constructormagic.h" |
Peter Boström | 7c704b8 | 2015-12-04 16:13:05 +0100 | [diff] [blame] | 23 | #include "webrtc/base/logging.h" |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 24 | #include "webrtc/base/task_queue.h" |
pbos@webrtc.org | 38344ed | 2014-09-24 06:05:00 +0000 | [diff] [blame] | 25 | #include "webrtc/base/thread_annotations.h" |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 26 | #include "webrtc/base/thread_checker.h" |
tommi | e4f9650 | 2015-10-20 23:00:48 -0700 | [diff] [blame] | 27 | #include "webrtc/base/trace_event.h" |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 28 | #include "webrtc/call.h" |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 29 | #include "webrtc/call/bitrate_allocator.h" |
pbos@webrtc.org | c49d5b7 | 2013-12-05 12:11:47 +0000 | [diff] [blame] | 30 | #include "webrtc/config.h" |
skvlad | cc91d28 | 2016-10-03 18:31:22 -0700 | [diff] [blame] | 31 | #include "webrtc/logging/rtc_event_log/rtc_event_log.h" |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 32 | #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" |
Stefan Holmer | 80e1207 | 2016-02-23 13:30:42 +0100 | [diff] [blame] | 33 | #include "webrtc/modules/congestion_controller/include/congestion_controller.h" |
Henrik Kjellander | 0b9e29c | 2015-11-16 11:12:24 +0100 | [diff] [blame] | 34 | #include "webrtc/modules/pacing/paced_sender.h" |
Henrik Kjellander | ff761fb | 2015-11-04 08:31:52 +0100 | [diff] [blame] | 35 | #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" |
sprang@webrtc.org | 2a6558c | 2015-01-28 12:37:36 +0000 | [diff] [blame] | 36 | #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
Henrik Kjellander | ff761fb | 2015-11-04 08:31:52 +0100 | [diff] [blame] | 37 | #include "webrtc/modules/utility/include/process_thread.h" |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 38 | #include "webrtc/system_wrappers/include/clock.h" |
Henrik Kjellander | 98f5351 | 2015-10-28 18:17:40 +0100 | [diff] [blame] | 39 | #include "webrtc/system_wrappers/include/cpu_info.h" |
| 40 | #include "webrtc/system_wrappers/include/critical_section_wrapper.h" |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 41 | #include "webrtc/system_wrappers/include/metrics.h" |
Henrik Kjellander | 98f5351 | 2015-10-28 18:17:40 +0100 | [diff] [blame] | 42 | #include "webrtc/system_wrappers/include/rw_lock_wrapper.h" |
| 43 | #include "webrtc/system_wrappers/include/trace.h" |
Peter Boström | 7623ce4 | 2015-12-09 12:13:30 +0100 | [diff] [blame] | 44 | #include "webrtc/video/call_stats.h" |
asapersson | 35151f3 | 2016-05-02 23:44:01 -0700 | [diff] [blame] | 45 | #include "webrtc/video/send_delay_stats.h" |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 46 | #include "webrtc/video/stats_counter.h" |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 47 | #include "webrtc/video/video_receive_stream.h" |
| 48 | #include "webrtc/video/video_send_stream.h" |
Stefan Holmer | 58c664c | 2016-02-08 14:31:30 +0100 | [diff] [blame] | 49 | #include "webrtc/video/vie_remb.h" |
ivoc | b04965c | 2015-09-09 00:09:43 -0700 | [diff] [blame] | 50 | #include "webrtc/voice_engine/include/voe_codec.h" |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 51 | |
| 52 | namespace webrtc { |
pbos@webrtc.org | ab990ae | 2014-09-17 09:02:25 +0000 | [diff] [blame] | 53 | |
pbos@webrtc.org | a73a678 | 2014-10-14 11:52:10 +0000 | [diff] [blame] | 54 | const int Call::Config::kDefaultStartBitrateBps = 300000; |
| 55 | |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 56 | namespace internal { |
asapersson@webrtc.org | bdc5ed2 | 2014-01-31 10:05:07 +0000 | [diff] [blame] | 57 | |
perkj | ec81bcd | 2016-05-11 06:01:13 -0700 | [diff] [blame] | 58 | class Call : public webrtc::Call, |
| 59 | public PacketReceiver, |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 60 | public CongestionController::Observer, |
| 61 | public BitrateAllocator::LimitObserver { |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 62 | public: |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 63 | explicit Call(const Call::Config& config); |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 64 | virtual ~Call(); |
| 65 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 66 | PacketReceiver* Receiver() override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 67 | |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 68 | webrtc::AudioSendStream* CreateAudioSendStream( |
| 69 | const webrtc::AudioSendStream::Config& config) override; |
| 70 | void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override; |
| 71 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 72 | webrtc::AudioReceiveStream* CreateAudioReceiveStream( |
| 73 | const webrtc::AudioReceiveStream::Config& config) override; |
| 74 | void DestroyAudioReceiveStream( |
| 75 | webrtc::AudioReceiveStream* receive_stream) override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 76 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 77 | webrtc::VideoSendStream* CreateVideoSendStream( |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 78 | webrtc::VideoSendStream::Config config, |
| 79 | VideoEncoderConfig encoder_config) override; |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 80 | void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 81 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 82 | webrtc::VideoReceiveStream* CreateVideoReceiveStream( |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 83 | webrtc::VideoReceiveStream::Config configuration) override; |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 84 | void DestroyVideoReceiveStream( |
| 85 | webrtc::VideoReceiveStream* receive_stream) override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 86 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 87 | Stats GetStats() const override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 88 | |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 89 | DeliveryStatus DeliverPacket(MediaType media_type, |
| 90 | const uint8_t* packet, |
| 91 | size_t length, |
| 92 | const PacketTime& packet_time) override; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 93 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 94 | void SetBitrateConfig( |
| 95 | const webrtc::Call::Config::BitrateConfig& bitrate_config) override; |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 96 | |
| 97 | void SignalChannelNetworkState(MediaType media, NetworkState state) override; |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 98 | |
Honghai Zhang | 0e533ef | 2016-04-19 15:41:36 -0700 | [diff] [blame] | 99 | void OnNetworkRouteChanged(const std::string& transport_name, |
| 100 | const rtc::NetworkRoute& network_route) override; |
| 101 | |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 102 | void OnSentPacket(const rtc::SentPacket& sent_packet) override; |
| 103 | |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 104 | // Implements BitrateObserver. |
| 105 | void OnNetworkChanged(uint32_t bitrate_bps, uint8_t fraction_loss, |
| 106 | int64_t rtt_ms) override; |
| 107 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 108 | // Implements BitrateAllocator::LimitObserver. |
| 109 | void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps, |
| 110 | uint32_t max_padding_bitrate_bps) override; |
| 111 | |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 112 | private: |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 113 | DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet, |
| 114 | size_t length); |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 115 | DeliveryStatus DeliverRtp(MediaType media_type, |
| 116 | const uint8_t* packet, |
| 117 | size_t length, |
| 118 | const PacketTime& packet_time); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 119 | void ConfigureSync(const std::string& sync_group) |
| 120 | EXCLUSIVE_LOCKS_REQUIRED(receive_crit_); |
| 121 | |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 122 | VoiceEngine* voice_engine() { |
| 123 | internal::AudioState* audio_state = |
| 124 | static_cast<internal::AudioState*>(config_.audio_state.get()); |
| 125 | if (audio_state) |
| 126 | return audio_state->voice_engine(); |
| 127 | else |
| 128 | return nullptr; |
| 129 | } |
| 130 | |
Stefan Holmer | 226befe | 2015-11-26 15:36:48 +0100 | [diff] [blame] | 131 | void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 132 | void UpdateReceiveHistograms(); |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 133 | void UpdateHistograms(); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 134 | void UpdateAggregateNetworkState(); |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 135 | |
Peter Boström | d3c9447 | 2015-12-09 11:20:58 +0100 | [diff] [blame] | 136 | Clock* const clock_; |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 137 | |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 138 | const int num_cpu_cores_; |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 139 | const std::unique_ptr<ProcessThread> module_process_thread_; |
| 140 | const std::unique_ptr<ProcessThread> pacer_thread_; |
| 141 | const std::unique_ptr<CallStats> call_stats_; |
| 142 | const std::unique_ptr<BitrateAllocator> bitrate_allocator_; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 143 | Call::Config config_; |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 144 | rtc::ThreadChecker configuration_thread_checker_; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 145 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 146 | NetworkState audio_network_state_; |
| 147 | NetworkState video_network_state_; |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 148 | |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 149 | std::unique_ptr<RWLockWrapper> receive_crit_; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 150 | // Audio and Video receive streams are owned by the client that creates them. |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 151 | std::map<uint32_t, AudioReceiveStream*> audio_receive_ssrcs_ |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 152 | GUARDED_BY(receive_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 153 | std::map<uint32_t, VideoReceiveStream*> video_receive_ssrcs_ |
| 154 | GUARDED_BY(receive_crit_); |
| 155 | std::set<VideoReceiveStream*> video_receive_streams_ |
| 156 | GUARDED_BY(receive_crit_); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 157 | std::map<std::string, AudioReceiveStream*> sync_stream_mapping_ |
| 158 | GUARDED_BY(receive_crit_); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 159 | |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 160 | std::unique_ptr<RWLockWrapper> send_crit_; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 161 | // Audio and Video send streams are owned by the client that creates them. |
| 162 | std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 163 | std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_); |
| 164 | std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_); |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 165 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 166 | VideoSendStream::RtpStateMap suspended_video_send_ssrcs_; |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame^] | 167 | webrtc::RtcEventLog* event_log_; |
ivoc | b04965c | 2015-09-09 00:09:43 -0700 | [diff] [blame] | 168 | |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 169 | // The following members are only accessed (exclusively) from one thread and |
| 170 | // from the destructor, and therefore doesn't need any explicit |
| 171 | // synchronization. |
Stefan Holmer | 226befe | 2015-11-26 15:36:48 +0100 | [diff] [blame] | 172 | int64_t first_packet_sent_ms_; |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 173 | RateCounter received_bytes_per_second_counter_; |
| 174 | RateCounter received_audio_bytes_per_second_counter_; |
| 175 | RateCounter received_video_bytes_per_second_counter_; |
| 176 | RateCounter received_rtcp_bytes_per_second_counter_; |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 177 | |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 178 | // TODO(holmer): Remove this lock once BitrateController no longer calls |
| 179 | // OnNetworkChanged from multiple threads. |
| 180 | rtc::CriticalSection bitrate_crit_; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 181 | uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_); |
sprang | 9c0b551 | 2016-07-06 00:54:28 -0700 | [diff] [blame] | 182 | uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_); |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 183 | AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_); |
| 184 | AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 185 | |
Honghai Zhang | 0e533ef | 2016-04-19 15:41:36 -0700 | [diff] [blame] | 186 | std::map<std::string, rtc::NetworkRoute> network_routes_; |
| 187 | |
Stefan Holmer | 58c664c | 2016-02-08 14:31:30 +0100 | [diff] [blame] | 188 | VieRemb remb_; |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 189 | const std::unique_ptr<CongestionController> congestion_controller_; |
asapersson | 35151f3 | 2016-05-02 23:44:01 -0700 | [diff] [blame] | 190 | const std::unique_ptr<SendDelayStats> video_send_delay_stats_; |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 191 | const int64_t start_ms_; |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 192 | // TODO(perkj): |worker_queue_| is supposed to replace |
| 193 | // |module_process_thread_|. |
| 194 | // |worker_queue| is defined last to ensure all pending tasks are cancelled |
| 195 | // and deleted before any other members. |
| 196 | rtc::TaskQueue worker_queue_; |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 197 | |
henrikg | 3c089d7 | 2015-09-16 05:37:44 -0700 | [diff] [blame] | 198 | RTC_DISALLOW_COPY_AND_ASSIGN(Call); |
pbos@webrtc.org | 16e03b7 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 199 | }; |
pbos@webrtc.org | c49d5b7 | 2013-12-05 12:11:47 +0000 | [diff] [blame] | 200 | } // namespace internal |
pbos@webrtc.org | fd39e13 | 2013-08-14 13:52:52 +0000 | [diff] [blame] | 201 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 202 | std::string Call::Stats::ToString(int64_t time_ms) const { |
| 203 | std::stringstream ss; |
| 204 | ss << "Call stats: " << time_ms << ", {"; |
| 205 | ss << "send_bw_bps: " << send_bandwidth_bps << ", "; |
| 206 | ss << "recv_bw_bps: " << recv_bandwidth_bps << ", "; |
| 207 | ss << "max_pad_bps: " << max_padding_bitrate_bps << ", "; |
| 208 | ss << "pacer_delay_ms: " << pacer_delay_ms << ", "; |
| 209 | ss << "rtt_ms: " << rtt_ms; |
| 210 | ss << '}'; |
| 211 | return ss.str(); |
| 212 | } |
| 213 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 214 | Call* Call::Create(const Call::Config& config) { |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 215 | return new internal::Call(config); |
pbos@webrtc.org | fd39e13 | 2013-08-14 13:52:52 +0000 | [diff] [blame] | 216 | } |
pbos@webrtc.org | fd39e13 | 2013-08-14 13:52:52 +0000 | [diff] [blame] | 217 | |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 218 | namespace internal { |
| 219 | |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 220 | Call::Call(const Call::Config& config) |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 221 | : clock_(Clock::GetRealTimeClock()), |
| 222 | num_cpu_cores_(CpuInfo::DetectNumberOfCores()), |
kwiberg | 1c7fdd8 | 2016-04-26 08:18:04 -0700 | [diff] [blame] | 223 | module_process_thread_(ProcessThread::Create("ModuleProcessThread")), |
| 224 | pacer_thread_(ProcessThread::Create("PacerThread")), |
Peter Boström | d3c9447 | 2015-12-09 11:20:58 +0100 | [diff] [blame] | 225 | call_stats_(new CallStats(clock_)), |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 226 | bitrate_allocator_(new BitrateAllocator(this)), |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 227 | config_(config), |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 228 | audio_network_state_(kNetworkUp), |
| 229 | video_network_state_(kNetworkUp), |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 230 | receive_crit_(RWLockWrapper::CreateRWLock()), |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 231 | send_crit_(RWLockWrapper::CreateRWLock()), |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame^] | 232 | event_log_(config.event_log), |
Stefan Holmer | 226befe | 2015-11-26 15:36:48 +0100 | [diff] [blame] | 233 | first_packet_sent_ms_(-1), |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 234 | received_bytes_per_second_counter_(clock_, nullptr, true), |
| 235 | received_audio_bytes_per_second_counter_(clock_, nullptr, true), |
| 236 | received_video_bytes_per_second_counter_(clock_, nullptr, true), |
| 237 | received_rtcp_bytes_per_second_counter_(clock_, nullptr, true), |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 238 | min_allocated_send_bitrate_bps_(0), |
sprang | 9c0b551 | 2016-07-06 00:54:28 -0700 | [diff] [blame] | 239 | configured_max_padding_bitrate_bps_(0), |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 240 | estimated_send_bitrate_kbps_counter_(clock_, nullptr, true), |
| 241 | pacer_bitrate_kbps_counter_(clock_, nullptr, true), |
Stefan Holmer | 58c664c | 2016-02-08 14:31:30 +0100 | [diff] [blame] | 242 | remb_(clock_), |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 243 | congestion_controller_( |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame^] | 244 | new CongestionController(clock_, this, &remb_, event_log_)), |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 245 | video_send_delay_stats_(new SendDelayStats(clock_)), |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 246 | start_ms_(clock_->TimeInMilliseconds()), |
| 247 | worker_queue_("call_worker_queue") { |
solenberg | 56a34df | 2015-11-12 08:24:41 -0800 | [diff] [blame] | 248 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame^] | 249 | RTC_DCHECK(config.event_log != nullptr); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 250 | RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0); |
| 251 | RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps, |
| 252 | config.bitrate_config.min_bitrate_bps); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 253 | if (config.bitrate_config.max_bitrate_bps != -1) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 254 | RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps, |
| 255 | config.bitrate_config.start_bitrate_bps); |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 256 | } |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 257 | Trace::CreateTrace(); |
Stefan Holmer | 789ba92 | 2016-02-17 15:52:17 +0100 | [diff] [blame] | 258 | call_stats_->RegisterStatsObserver(congestion_controller_.get()); |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 259 | |
mflodman | 0c478b3 | 2015-10-21 15:52:16 +0200 | [diff] [blame] | 260 | congestion_controller_->SetBweBitrates( |
| 261 | config_.bitrate_config.min_bitrate_bps, |
| 262 | config_.bitrate_config.start_bitrate_bps, |
| 263 | config_.bitrate_config.max_bitrate_bps); |
Stefan Holmer | c379fcb | 2016-02-24 16:02:55 +0100 | [diff] [blame] | 264 | |
| 265 | module_process_thread_->Start(); |
| 266 | module_process_thread_->RegisterModule(call_stats_.get()); |
| 267 | module_process_thread_->RegisterModule(congestion_controller_.get()); |
| 268 | pacer_thread_->RegisterModule(congestion_controller_->pacer()); |
| 269 | pacer_thread_->RegisterModule( |
| 270 | congestion_controller_->GetRemoteBitrateEstimator(true)); |
| 271 | pacer_thread_->Start(); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 272 | } |
| 273 | |
pbos@webrtc.org | 841c8a4 | 2013-09-09 15:04:25 +0000 | [diff] [blame] | 274 | Call::~Call() { |
Stefan Holmer | 58c664c | 2016-02-08 14:31:30 +0100 | [diff] [blame] | 275 | RTC_DCHECK(!remb_.InUse()); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 276 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 277 | |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 278 | RTC_CHECK(audio_send_ssrcs_.empty()); |
| 279 | RTC_CHECK(video_send_ssrcs_.empty()); |
| 280 | RTC_CHECK(video_send_streams_.empty()); |
| 281 | RTC_CHECK(audio_receive_ssrcs_.empty()); |
| 282 | RTC_CHECK(video_receive_ssrcs_.empty()); |
| 283 | RTC_CHECK(video_receive_streams_.empty()); |
pbos@webrtc.org | 9e4e524 | 2015-02-12 10:48:23 +0000 | [diff] [blame] | 284 | |
Stefan Holmer | c379fcb | 2016-02-24 16:02:55 +0100 | [diff] [blame] | 285 | pacer_thread_->Stop(); |
| 286 | pacer_thread_->DeRegisterModule(congestion_controller_->pacer()); |
| 287 | pacer_thread_->DeRegisterModule( |
| 288 | congestion_controller_->GetRemoteBitrateEstimator(true)); |
Stefan Holmer | 789ba92 | 2016-02-17 15:52:17 +0100 | [diff] [blame] | 289 | module_process_thread_->DeRegisterModule(congestion_controller_.get()); |
mflodman | e378702 | 2015-10-21 13:24:28 +0200 | [diff] [blame] | 290 | module_process_thread_->DeRegisterModule(call_stats_.get()); |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 291 | module_process_thread_->Stop(); |
Stefan Holmer | c379fcb | 2016-02-24 16:02:55 +0100 | [diff] [blame] | 292 | call_stats_->DeregisterStatsObserver(congestion_controller_.get()); |
sprang | 6d6122b | 2016-07-13 06:37:09 -0700 | [diff] [blame] | 293 | |
| 294 | // Only update histograms after process threads have been shut down, so that |
| 295 | // they won't try to concurrently update stats. |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 296 | { |
| 297 | rtc::CritScope lock(&bitrate_crit_); |
| 298 | UpdateSendHistograms(); |
| 299 | } |
sprang | 6d6122b | 2016-07-13 06:37:09 -0700 | [diff] [blame] | 300 | UpdateReceiveHistograms(); |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 301 | UpdateHistograms(); |
sprang | 6d6122b | 2016-07-13 06:37:09 -0700 | [diff] [blame] | 302 | |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 303 | Trace::ReturnTrace(); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 304 | } |
| 305 | |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 306 | void Call::UpdateHistograms() { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 307 | RTC_HISTOGRAM_COUNTS_100000( |
asapersson | 4374a09 | 2016-07-27 00:39:09 -0700 | [diff] [blame] | 308 | "WebRTC.Call.LifetimeInSeconds", |
| 309 | (clock_->TimeInMilliseconds() - start_ms_) / 1000); |
| 310 | } |
| 311 | |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 312 | void Call::UpdateSendHistograms() { |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 313 | if (first_packet_sent_ms_ == -1) |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 314 | return; |
| 315 | int64_t elapsed_sec = |
| 316 | (clock_->TimeInMilliseconds() - first_packet_sent_ms_) / 1000; |
| 317 | if (elapsed_sec < metrics::kMinRunTimeInSeconds) |
| 318 | return; |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 319 | const int kMinRequiredPeriodicSamples = 5; |
| 320 | AggregatedStats send_bitrate_stats = |
| 321 | estimated_send_bitrate_kbps_counter_.ProcessAndGetStats(); |
| 322 | if (send_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 323 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps", |
| 324 | send_bitrate_stats.average); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 325 | } |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 326 | AggregatedStats pacer_bitrate_stats = |
| 327 | pacer_bitrate_kbps_counter_.ProcessAndGetStats(); |
| 328 | if (pacer_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 329 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.PacerBitrateInKbps", |
| 330 | pacer_bitrate_stats.average); |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 331 | } |
| 332 | } |
| 333 | |
| 334 | void Call::UpdateReceiveHistograms() { |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 335 | const int kMinRequiredPeriodicSamples = 5; |
| 336 | AggregatedStats video_bytes_per_sec = |
| 337 | received_video_bytes_per_second_counter_.GetStats(); |
| 338 | if (video_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 339 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.VideoBitrateReceivedInKbps", |
| 340 | video_bytes_per_sec.average * 8 / 1000); |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 341 | } |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 342 | AggregatedStats audio_bytes_per_sec = |
| 343 | received_audio_bytes_per_second_counter_.GetStats(); |
| 344 | if (audio_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 345 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.AudioBitrateReceivedInKbps", |
| 346 | audio_bytes_per_sec.average * 8 / 1000); |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 347 | } |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 348 | AggregatedStats rtcp_bytes_per_sec = |
| 349 | received_rtcp_bytes_per_second_counter_.GetStats(); |
| 350 | if (rtcp_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 351 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.RtcpBitrateReceivedInBps", |
| 352 | rtcp_bytes_per_sec.average * 8); |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 353 | } |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 354 | AggregatedStats recv_bytes_per_sec = |
| 355 | received_bytes_per_second_counter_.GetStats(); |
| 356 | if (recv_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 357 | RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.BitrateReceivedInKbps", |
| 358 | recv_bytes_per_sec.average * 8 / 1000); |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 359 | } |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 360 | } |
| 361 | |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 362 | PacketReceiver* Call::Receiver() { |
| 363 | // TODO(solenberg): Some test cases in EndToEndTest use this from a different |
| 364 | // thread. Re-enable once that is fixed. |
| 365 | // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
| 366 | return this; |
| 367 | } |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 368 | |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 369 | webrtc::AudioSendStream* Call::CreateAudioSendStream( |
| 370 | const webrtc::AudioSendStream::Config& config) { |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 371 | TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream"); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 372 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
Stefan Holmer | b86d4e4 | 2015-12-07 10:26:18 +0100 | [diff] [blame] | 373 | AudioSendStream* send_stream = new AudioSendStream( |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 374 | config, config_.audio_state, &worker_queue_, congestion_controller_.get(), |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame^] | 375 | bitrate_allocator_.get(), event_log_); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 376 | { |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 377 | WriteLockScoped write_lock(*send_crit_); |
| 378 | RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) == |
| 379 | audio_send_ssrcs_.end()); |
| 380 | audio_send_ssrcs_[config.rtp.ssrc] = send_stream; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 381 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 382 | send_stream->SignalNetworkState(audio_network_state_); |
| 383 | UpdateAggregateNetworkState(); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 384 | return send_stream; |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 385 | } |
| 386 | |
| 387 | void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) { |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 388 | TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream"); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 389 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 390 | RTC_DCHECK(send_stream != nullptr); |
| 391 | |
| 392 | send_stream->Stop(); |
| 393 | |
| 394 | webrtc::internal::AudioSendStream* audio_send_stream = |
| 395 | static_cast<webrtc::internal::AudioSendStream*>(send_stream); |
| 396 | { |
| 397 | WriteLockScoped write_lock(*send_crit_); |
| 398 | size_t num_deleted = audio_send_ssrcs_.erase( |
| 399 | audio_send_stream->config().rtp.ssrc); |
| 400 | RTC_DCHECK(num_deleted == 1); |
| 401 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 402 | UpdateAggregateNetworkState(); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 403 | delete audio_send_stream; |
Fredrik Solenberg | 04f4931 | 2015-06-08 13:04:56 +0200 | [diff] [blame] | 404 | } |
| 405 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 406 | webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream( |
| 407 | const webrtc::AudioReceiveStream::Config& config) { |
| 408 | TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream"); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 409 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame^] | 410 | AudioReceiveStream* receive_stream = new AudioReceiveStream( |
| 411 | congestion_controller_.get(), config, config_.audio_state, event_log_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 412 | { |
| 413 | WriteLockScoped write_lock(*receive_crit_); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 414 | RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) == |
| 415 | audio_receive_ssrcs_.end()); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 416 | audio_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream; |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 417 | ConfigureSync(config.sync_group); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 418 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 419 | receive_stream->SignalNetworkState(audio_network_state_); |
| 420 | UpdateAggregateNetworkState(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 421 | return receive_stream; |
| 422 | } |
| 423 | |
| 424 | void Call::DestroyAudioReceiveStream( |
| 425 | webrtc::AudioReceiveStream* receive_stream) { |
| 426 | TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream"); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 427 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 428 | RTC_DCHECK(receive_stream != nullptr); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 429 | webrtc::internal::AudioReceiveStream* audio_receive_stream = |
| 430 | static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 431 | { |
| 432 | WriteLockScoped write_lock(*receive_crit_); |
| 433 | size_t num_deleted = audio_receive_ssrcs_.erase( |
| 434 | audio_receive_stream->config().rtp.remote_ssrc); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 435 | RTC_DCHECK(num_deleted == 1); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 436 | const std::string& sync_group = audio_receive_stream->config().sync_group; |
| 437 | const auto it = sync_stream_mapping_.find(sync_group); |
| 438 | if (it != sync_stream_mapping_.end() && |
| 439 | it->second == audio_receive_stream) { |
| 440 | sync_stream_mapping_.erase(it); |
| 441 | ConfigureSync(sync_group); |
| 442 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 443 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 444 | UpdateAggregateNetworkState(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 445 | delete audio_receive_stream; |
| 446 | } |
| 447 | |
| 448 | webrtc::VideoSendStream* Call::CreateVideoSendStream( |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 449 | webrtc::VideoSendStream::Config config, |
| 450 | VideoEncoderConfig encoder_config) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 451 | TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream"); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 452 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
pbos@webrtc.org | 1819fd7 | 2013-06-10 13:48:26 +0000 | [diff] [blame] | 453 | |
asapersson | 35151f3 | 2016-05-02 23:44:01 -0700 | [diff] [blame] | 454 | video_send_delay_stats_->AddSsrcs(config); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 455 | event_log_->LogVideoSendStreamConfig(config); |
| 456 | |
mflodman@webrtc.org | eb16b81 | 2014-06-16 08:57:39 +0000 | [diff] [blame] | 457 | // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if |
| 458 | // the call has already started. |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 459 | // Copy ssrcs from |config| since |config| is moved. |
| 460 | std::vector<uint32_t> ssrcs = config.rtp.ssrcs; |
mflodman | 0c478b3 | 2015-10-21 15:52:16 +0200 | [diff] [blame] | 461 | VideoSendStream* send_stream = new VideoSendStream( |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 462 | num_cpu_cores_, module_process_thread_.get(), &worker_queue_, |
| 463 | call_stats_.get(), congestion_controller_.get(), bitrate_allocator_.get(), |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame^] | 464 | video_send_delay_stats_.get(), &remb_, event_log_, std::move(config), |
| 465 | std::move(encoder_config), suspended_video_send_ssrcs_); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 466 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 467 | { |
| 468 | WriteLockScoped write_lock(*send_crit_); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 469 | for (uint32_t ssrc : ssrcs) { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 470 | RTC_DCHECK(video_send_ssrcs_.find(ssrc) == video_send_ssrcs_.end()); |
| 471 | video_send_ssrcs_[ssrc] = send_stream; |
| 472 | } |
| 473 | video_send_streams_.insert(send_stream); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 474 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 475 | send_stream->SignalNetworkState(video_network_state_); |
| 476 | UpdateAggregateNetworkState(); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 477 | |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 478 | return send_stream; |
| 479 | } |
| 480 | |
pbos@webrtc.org | 2c46f8d | 2013-11-21 13:49:43 +0000 | [diff] [blame] | 481 | void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 482 | TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream"); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 483 | RTC_DCHECK(send_stream != nullptr); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 484 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 485 | |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 486 | send_stream->Stop(); |
| 487 | |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 +0000 | [diff] [blame] | 488 | VideoSendStream* send_stream_impl = nullptr; |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 489 | { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 490 | WriteLockScoped write_lock(*send_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 491 | auto it = video_send_ssrcs_.begin(); |
| 492 | while (it != video_send_ssrcs_.end()) { |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 493 | if (it->second == static_cast<VideoSendStream*>(send_stream)) { |
| 494 | send_stream_impl = it->second; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 495 | video_send_ssrcs_.erase(it++); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 496 | } else { |
| 497 | ++it; |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 498 | } |
| 499 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 500 | video_send_streams_.erase(send_stream_impl); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 501 | } |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 502 | RTC_CHECK(send_stream_impl != nullptr); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 503 | |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 504 | VideoSendStream::RtpStateMap rtp_state = |
| 505 | send_stream_impl->StopPermanentlyAndGetRtpStates(); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 506 | |
| 507 | for (VideoSendStream::RtpStateMap::iterator it = rtp_state.begin(); |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 508 | it != rtp_state.end(); ++it) { |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 509 | suspended_video_send_ssrcs_[it->first] = it->second; |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 510 | } |
| 511 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 512 | UpdateAggregateNetworkState(); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 513 | delete send_stream_impl; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 514 | } |
| 515 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 516 | webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream( |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 517 | webrtc::VideoReceiveStream::Config configuration) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 518 | TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream"); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 519 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
Peter Boström | c4188fd | 2015-04-24 15:16:03 +0200 | [diff] [blame] | 520 | VideoReceiveStream* receive_stream = new VideoReceiveStream( |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 521 | num_cpu_cores_, congestion_controller_.get(), std::move(configuration), |
| 522 | voice_engine(), module_process_thread_.get(), call_stats_.get(), &remb_); |
| 523 | |
| 524 | const webrtc::VideoReceiveStream::Config& config = receive_stream->config(); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 525 | { |
| 526 | WriteLockScoped write_lock(*receive_crit_); |
| 527 | RTC_DCHECK(video_receive_ssrcs_.find(config.rtp.remote_ssrc) == |
| 528 | video_receive_ssrcs_.end()); |
| 529 | video_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream; |
| 530 | // TODO(pbos): Configure different RTX payloads per receive payload. |
| 531 | VideoReceiveStream::Config::Rtp::RtxMap::const_iterator it = |
| 532 | config.rtp.rtx.begin(); |
| 533 | if (it != config.rtp.rtx.end()) |
| 534 | video_receive_ssrcs_[it->second.ssrc] = receive_stream; |
| 535 | video_receive_streams_.insert(receive_stream); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 536 | ConfigureSync(config.sync_group); |
| 537 | } |
| 538 | receive_stream->SignalNetworkState(video_network_state_); |
| 539 | UpdateAggregateNetworkState(); |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 540 | event_log_->LogVideoReceiveStreamConfig(config); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 541 | return receive_stream; |
| 542 | } |
| 543 | |
pbos@webrtc.org | 2c46f8d | 2013-11-21 13:49:43 +0000 | [diff] [blame] | 544 | void Call::DestroyVideoReceiveStream( |
| 545 | webrtc::VideoReceiveStream* receive_stream) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 546 | TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream"); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 547 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 548 | RTC_DCHECK(receive_stream != nullptr); |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 +0000 | [diff] [blame] | 549 | VideoReceiveStream* receive_stream_impl = nullptr; |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 550 | { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 551 | WriteLockScoped write_lock(*receive_crit_); |
pbos@webrtc.org | c279a5d | 2014-01-24 09:30:53 +0000 | [diff] [blame] | 552 | // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a |
| 553 | // separate SSRC there can be either one or two. |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 554 | auto it = video_receive_ssrcs_.begin(); |
| 555 | while (it != video_receive_ssrcs_.end()) { |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 556 | if (it->second == static_cast<VideoReceiveStream*>(receive_stream)) { |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 +0000 | [diff] [blame] | 557 | if (receive_stream_impl != nullptr) |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 558 | RTC_DCHECK(receive_stream_impl == it->second); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 559 | receive_stream_impl = it->second; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 560 | video_receive_ssrcs_.erase(it++); |
pbos@webrtc.org | c279a5d | 2014-01-24 09:30:53 +0000 | [diff] [blame] | 561 | } else { |
| 562 | ++it; |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 563 | } |
| 564 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 565 | video_receive_streams_.erase(receive_stream_impl); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 566 | RTC_CHECK(receive_stream_impl != nullptr); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 567 | ConfigureSync(receive_stream_impl->config().sync_group); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 568 | } |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 569 | UpdateAggregateNetworkState(); |
pbos@webrtc.org | 95e51f5 | 2013-09-05 12:38:54 +0000 | [diff] [blame] | 570 | delete receive_stream_impl; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 571 | } |
| 572 | |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 573 | Call::Stats Call::GetStats() const { |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 574 | // TODO(solenberg): Some test cases in EndToEndTest use this from a different |
| 575 | // thread. Re-enable once that is fixed. |
| 576 | // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 577 | Stats stats; |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 578 | // Fetch available send/receive bitrates. |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 579 | uint32_t send_bandwidth = 0; |
mflodman | 0c478b3 | 2015-10-21 15:52:16 +0200 | [diff] [blame] | 580 | congestion_controller_->GetBitrateController()->AvailableBandwidth( |
| 581 | &send_bandwidth); |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 582 | std::vector<unsigned int> ssrcs; |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 583 | uint32_t recv_bandwidth = 0; |
mflodman | 0c478b3 | 2015-10-21 15:52:16 +0200 | [diff] [blame] | 584 | congestion_controller_->GetRemoteBitrateEstimator(false)->LatestEstimate( |
mflodman | a20de20 | 2015-10-18 22:08:19 -0700 | [diff] [blame] | 585 | &ssrcs, &recv_bandwidth); |
Peter Boström | 45553ae | 2015-05-08 13:54:38 +0200 | [diff] [blame] | 586 | stats.send_bandwidth_bps = send_bandwidth; |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 587 | stats.recv_bandwidth_bps = recv_bandwidth; |
mflodman | 0c478b3 | 2015-10-21 15:52:16 +0200 | [diff] [blame] | 588 | stats.pacer_delay_ms = congestion_controller_->GetPacerQueuingDelayMs(); |
sprang | e2d83d6 | 2016-02-19 09:03:26 -0800 | [diff] [blame] | 589 | stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt(); |
sprang | 9c0b551 | 2016-07-06 00:54:28 -0700 | [diff] [blame] | 590 | { |
| 591 | rtc::CritScope cs(&bitrate_crit_); |
| 592 | stats.max_padding_bitrate_bps = configured_max_padding_bitrate_bps_; |
| 593 | } |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 594 | return stats; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 595 | } |
| 596 | |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 597 | void Call::SetBitrateConfig( |
| 598 | const webrtc::Call::Config::BitrateConfig& bitrate_config) { |
pbos@webrtc.org | 50fe359 | 2015-01-29 12:33:07 +0000 | [diff] [blame] | 599 | TRACE_EVENT0("webrtc", "Call::SetBitrateConfig"); |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 600 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 601 | RTC_DCHECK_GE(bitrate_config.min_bitrate_bps, 0); |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 +0000 | [diff] [blame] | 602 | if (bitrate_config.max_bitrate_bps != -1) |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 603 | RTC_DCHECK_GT(bitrate_config.max_bitrate_bps, 0); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 604 | if (config_.bitrate_config.min_bitrate_bps == |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 605 | bitrate_config.min_bitrate_bps && |
| 606 | (bitrate_config.start_bitrate_bps <= 0 || |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 607 | config_.bitrate_config.start_bitrate_bps == |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 608 | bitrate_config.start_bitrate_bps) && |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 609 | config_.bitrate_config.max_bitrate_bps == |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 610 | bitrate_config.max_bitrate_bps) { |
| 611 | // Nothing new to set, early abort to avoid encoder reconfigurations. |
| 612 | return; |
| 613 | } |
Stefan Holmer | be40296 | 2016-07-08 16:16:41 +0200 | [diff] [blame] | 614 | config_.bitrate_config.min_bitrate_bps = bitrate_config.min_bitrate_bps; |
| 615 | // Start bitrate of -1 means we should keep the old bitrate, which there is |
| 616 | // no point in remembering for the future. |
| 617 | if (bitrate_config.start_bitrate_bps > 0) |
| 618 | config_.bitrate_config.start_bitrate_bps = bitrate_config.start_bitrate_bps; |
| 619 | config_.bitrate_config.max_bitrate_bps = bitrate_config.max_bitrate_bps; |
mflodman | 0c478b3 | 2015-10-21 15:52:16 +0200 | [diff] [blame] | 620 | congestion_controller_->SetBweBitrates(bitrate_config.min_bitrate_bps, |
| 621 | bitrate_config.start_bitrate_bps, |
| 622 | bitrate_config.max_bitrate_bps); |
pbos@webrtc.org | 0087318 | 2014-11-25 14:03:34 +0000 | [diff] [blame] | 623 | } |
| 624 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 625 | void Call::SignalChannelNetworkState(MediaType media, NetworkState state) { |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 626 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 627 | switch (media) { |
| 628 | case MediaType::AUDIO: |
| 629 | audio_network_state_ = state; |
| 630 | break; |
| 631 | case MediaType::VIDEO: |
| 632 | video_network_state_ = state; |
| 633 | break; |
| 634 | case MediaType::ANY: |
| 635 | case MediaType::DATA: |
| 636 | RTC_NOTREACHED(); |
| 637 | break; |
| 638 | } |
| 639 | |
| 640 | UpdateAggregateNetworkState(); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 641 | { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 642 | ReadLockScoped read_lock(*send_crit_); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 643 | for (auto& kv : audio_send_ssrcs_) { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 644 | kv.second->SignalNetworkState(audio_network_state_); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 645 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 646 | for (auto& kv : video_send_ssrcs_) { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 647 | kv.second->SignalNetworkState(video_network_state_); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 648 | } |
| 649 | } |
| 650 | { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 651 | ReadLockScoped read_lock(*receive_crit_); |
| 652 | for (auto& kv : audio_receive_ssrcs_) { |
| 653 | kv.second->SignalNetworkState(audio_network_state_); |
| 654 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 655 | for (auto& kv : video_receive_ssrcs_) { |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 656 | kv.second->SignalNetworkState(video_network_state_); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 657 | } |
| 658 | } |
| 659 | } |
| 660 | |
Honghai Zhang | 0e533ef | 2016-04-19 15:41:36 -0700 | [diff] [blame] | 661 | // TODO(honghaiz): Add tests for this method. |
| 662 | void Call::OnNetworkRouteChanged(const std::string& transport_name, |
| 663 | const rtc::NetworkRoute& network_route) { |
| 664 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
| 665 | // Check if the network route is connected. |
| 666 | if (!network_route.connected) { |
| 667 | LOG(LS_INFO) << "Transport " << transport_name << " is disconnected"; |
| 668 | // TODO(honghaiz): Perhaps handle this in SignalChannelNetworkState and |
| 669 | // consider merging these two methods. |
| 670 | return; |
| 671 | } |
| 672 | |
| 673 | // Check whether the network route has changed on each transport. |
| 674 | auto result = |
| 675 | network_routes_.insert(std::make_pair(transport_name, network_route)); |
| 676 | auto kv = result.first; |
| 677 | bool inserted = result.second; |
| 678 | if (inserted) { |
| 679 | // No need to reset BWE if this is the first time the network connects. |
| 680 | return; |
| 681 | } |
| 682 | if (kv->second != network_route) { |
| 683 | kv->second = network_route; |
| 684 | LOG(LS_INFO) << "Network route changed on transport " << transport_name |
| 685 | << ": new local network id " << network_route.local_network_id |
honghaiz | 059e183 | 2016-06-24 11:03:55 -0700 | [diff] [blame] | 686 | << " new remote network id " << network_route.remote_network_id |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 687 | << " Reset bitrates to min: " |
| 688 | << config_.bitrate_config.min_bitrate_bps |
| 689 | << " bps, start: " << config_.bitrate_config.start_bitrate_bps |
| 690 | << " bps, max: " << config_.bitrate_config.start_bitrate_bps |
| 691 | << " bps."; |
honghaiz | 059e183 | 2016-06-24 11:03:55 -0700 | [diff] [blame] | 692 | congestion_controller_->ResetBweAndBitrates( |
| 693 | config_.bitrate_config.start_bitrate_bps, |
| 694 | config_.bitrate_config.min_bitrate_bps, |
| 695 | config_.bitrate_config.max_bitrate_bps); |
Honghai Zhang | 0e533ef | 2016-04-19 15:41:36 -0700 | [diff] [blame] | 696 | } |
| 697 | } |
| 698 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 699 | void Call::UpdateAggregateNetworkState() { |
| 700 | RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread()); |
| 701 | |
| 702 | bool have_audio = false; |
| 703 | bool have_video = false; |
| 704 | { |
| 705 | ReadLockScoped read_lock(*send_crit_); |
| 706 | if (audio_send_ssrcs_.size() > 0) |
| 707 | have_audio = true; |
| 708 | if (video_send_ssrcs_.size() > 0) |
| 709 | have_video = true; |
| 710 | } |
| 711 | { |
| 712 | ReadLockScoped read_lock(*receive_crit_); |
| 713 | if (audio_receive_ssrcs_.size() > 0) |
| 714 | have_audio = true; |
| 715 | if (video_receive_ssrcs_.size() > 0) |
| 716 | have_video = true; |
| 717 | } |
| 718 | |
| 719 | NetworkState aggregate_state = kNetworkDown; |
| 720 | if ((have_video && video_network_state_ == kNetworkUp) || |
| 721 | (have_audio && audio_network_state_ == kNetworkUp)) { |
| 722 | aggregate_state = kNetworkUp; |
| 723 | } |
| 724 | |
| 725 | LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state=" |
| 726 | << (aggregate_state == kNetworkUp ? "up" : "down"); |
| 727 | |
| 728 | congestion_controller_->SignalNetworkState(aggregate_state); |
| 729 | } |
| 730 | |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 731 | void Call::OnSentPacket(const rtc::SentPacket& sent_packet) { |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 732 | if (first_packet_sent_ms_ == -1) |
| 733 | first_packet_sent_ms_ = clock_->TimeInMilliseconds(); |
asapersson | 35151f3 | 2016-05-02 23:44:01 -0700 | [diff] [blame] | 734 | video_send_delay_stats_->OnSentPacket(sent_packet.packet_id, |
| 735 | clock_->TimeInMilliseconds()); |
mflodman | 0c478b3 | 2015-10-21 15:52:16 +0200 | [diff] [blame] | 736 | congestion_controller_->OnSentPacket(sent_packet); |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 737 | } |
| 738 | |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 739 | void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss, |
| 740 | int64_t rtt_ms) { |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 741 | // TODO(perkj): Consider making sure CongestionController operates on |
| 742 | // |worker_queue_|. |
| 743 | if (!worker_queue_.IsCurrent()) { |
| 744 | worker_queue_.PostTask([this, target_bitrate_bps, fraction_loss, rtt_ms] { |
| 745 | OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt_ms); |
| 746 | }); |
| 747 | return; |
| 748 | } |
| 749 | RTC_DCHECK_RUN_ON(&worker_queue_); |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 750 | bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, fraction_loss, |
| 751 | rtt_ms); |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 752 | |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 753 | // Ignore updates if bitrate is zero (the aggregate network state is down). |
| 754 | if (target_bitrate_bps == 0) { |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 755 | rtc::CritScope lock(&bitrate_crit_); |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 756 | estimated_send_bitrate_kbps_counter_.ProcessAndPause(); |
| 757 | pacer_bitrate_kbps_counter_.ProcessAndPause(); |
| 758 | return; |
stefan | 18adf0a | 2015-11-17 06:24:56 -0800 | [diff] [blame] | 759 | } |
asapersson | ce2e136 | 2016-09-09 00:13:35 -0700 | [diff] [blame] | 760 | |
| 761 | bool sending_video; |
| 762 | { |
| 763 | ReadLockScoped read_lock(*send_crit_); |
| 764 | sending_video = !video_send_streams_.empty(); |
| 765 | } |
| 766 | |
| 767 | rtc::CritScope lock(&bitrate_crit_); |
| 768 | if (!sending_video) { |
| 769 | // Do not update the stats if we are not sending video. |
| 770 | estimated_send_bitrate_kbps_counter_.ProcessAndPause(); |
| 771 | pacer_bitrate_kbps_counter_.ProcessAndPause(); |
| 772 | return; |
| 773 | } |
| 774 | estimated_send_bitrate_kbps_counter_.Add(target_bitrate_bps / 1000); |
| 775 | // Pacer bitrate may be higher than bitrate estimate if enforcing min bitrate. |
| 776 | uint32_t pacer_bitrate_bps = |
| 777 | std::max(target_bitrate_bps, min_allocated_send_bitrate_bps_); |
| 778 | pacer_bitrate_kbps_counter_.Add(pacer_bitrate_bps / 1000); |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 779 | } |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 780 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 781 | void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps, |
| 782 | uint32_t max_padding_bitrate_bps) { |
| 783 | congestion_controller_->SetAllocatedSendBitrateLimits( |
| 784 | min_send_bitrate_bps, max_padding_bitrate_bps); |
| 785 | rtc::CritScope lock(&bitrate_crit_); |
| 786 | min_allocated_send_bitrate_bps_ = min_send_bitrate_bps; |
sprang | 9c0b551 | 2016-07-06 00:54:28 -0700 | [diff] [blame] | 787 | configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps; |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 788 | } |
| 789 | |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 790 | void Call::ConfigureSync(const std::string& sync_group) { |
| 791 | // Set sync only if there was no previous one. |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 792 | if (voice_engine() == nullptr || sync_group.empty()) |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 793 | return; |
| 794 | |
| 795 | AudioReceiveStream* sync_audio_stream = nullptr; |
| 796 | // Find existing audio stream. |
| 797 | const auto it = sync_stream_mapping_.find(sync_group); |
| 798 | if (it != sync_stream_mapping_.end()) { |
| 799 | sync_audio_stream = it->second; |
| 800 | } else { |
| 801 | // No configured audio stream, see if we can find one. |
| 802 | for (const auto& kv : audio_receive_ssrcs_) { |
| 803 | if (kv.second->config().sync_group == sync_group) { |
| 804 | if (sync_audio_stream != nullptr) { |
| 805 | LOG(LS_WARNING) << "Attempting to sync more than one audio stream " |
| 806 | "within the same sync group. This is not " |
| 807 | "supported in the current implementation."; |
| 808 | break; |
| 809 | } |
| 810 | sync_audio_stream = kv.second; |
| 811 | } |
| 812 | } |
| 813 | } |
| 814 | if (sync_audio_stream) |
| 815 | sync_stream_mapping_[sync_group] = sync_audio_stream; |
| 816 | size_t num_synced_streams = 0; |
| 817 | for (VideoReceiveStream* video_stream : video_receive_streams_) { |
| 818 | if (video_stream->config().sync_group != sync_group) |
| 819 | continue; |
| 820 | ++num_synced_streams; |
| 821 | if (num_synced_streams > 1) { |
| 822 | // TODO(pbos): Support synchronizing more than one A/V pair. |
| 823 | // https://code.google.com/p/webrtc/issues/detail?id=4762 |
| 824 | LOG(LS_WARNING) << "Attempting to sync more than one audio/video pair " |
| 825 | "within the same sync group. This is not supported in " |
| 826 | "the current implementation."; |
| 827 | } |
| 828 | // Only sync the first A/V pair within this sync group. |
| 829 | if (sync_audio_stream != nullptr && num_synced_streams == 1) { |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 830 | video_stream->SetSyncChannel(voice_engine(), |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 831 | sync_audio_stream->config().voe_channel_id); |
| 832 | } else { |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 833 | video_stream->SetSyncChannel(voice_engine(), -1); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 834 | } |
| 835 | } |
| 836 | } |
| 837 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 838 | PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type, |
| 839 | const uint8_t* packet, |
| 840 | size_t length) { |
Peter Boström | 6f28cf0 | 2015-12-07 23:17:15 +0100 | [diff] [blame] | 841 | TRACE_EVENT0("webrtc", "Call::DeliverRtcp"); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 842 | // TODO(pbos): Make sure it's a valid packet. |
pbos@webrtc.org | caba2d2 | 2014-05-14 13:57:12 +0000 | [diff] [blame] | 843 | // Return DELIVERY_UNKNOWN_SSRC if it can be determined that |
| 844 | // there's no receiver of the packet. |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 845 | if (received_bytes_per_second_counter_.HasSample()) { |
| 846 | // First RTP packet has been received. |
| 847 | received_bytes_per_second_counter_.Add(static_cast<int>(length)); |
| 848 | received_rtcp_bytes_per_second_counter_.Add(static_cast<int>(length)); |
| 849 | } |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 850 | bool rtcp_delivered = false; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 851 | if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 852 | ReadLockScoped read_lock(*receive_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 853 | for (VideoReceiveStream* stream : video_receive_streams_) { |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 854 | if (stream->DeliverRtcp(packet, length)) |
pbos@webrtc.org | 4052370 | 2013-08-05 12:49:22 +0000 | [diff] [blame] | 855 | rtcp_delivered = true; |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 856 | } |
| 857 | } |
| 858 | if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { |
| 859 | ReadLockScoped read_lock(*receive_crit_); |
| 860 | for (auto& kv : audio_receive_ssrcs_) { |
| 861 | if (kv.second->DeliverRtcp(packet, length)) |
| 862 | rtcp_delivered = true; |
pbos@webrtc.org | bbb07e6 | 2013-08-05 12:01:36 +0000 | [diff] [blame] | 863 | } |
| 864 | } |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 865 | if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 866 | ReadLockScoped read_lock(*send_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 867 | for (VideoSendStream* stream : video_send_streams_) { |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 868 | if (stream->DeliverRtcp(packet, length)) |
pbos@webrtc.org | 4052370 | 2013-08-05 12:49:22 +0000 | [diff] [blame] | 869 | rtcp_delivered = true; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 870 | } |
| 871 | } |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 872 | if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { |
| 873 | ReadLockScoped read_lock(*send_crit_); |
| 874 | for (auto& kv : audio_send_ssrcs_) { |
| 875 | if (kv.second->DeliverRtcp(packet, length)) |
| 876 | rtcp_delivered = true; |
| 877 | } |
| 878 | } |
| 879 | |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame^] | 880 | if (rtcp_delivered) |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 881 | event_log_->LogRtcpPacket(kIncomingPacket, media_type, packet, length); |
| 882 | |
pbos@webrtc.org | caba2d2 | 2014-05-14 13:57:12 +0000 | [diff] [blame] | 883 | return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 884 | } |
| 885 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 886 | PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type, |
| 887 | const uint8_t* packet, |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 888 | size_t length, |
| 889 | const PacketTime& packet_time) { |
Peter Boström | 6f28cf0 | 2015-12-07 23:17:15 +0100 | [diff] [blame] | 890 | TRACE_EVENT0("webrtc", "Call::DeliverRtp"); |
pbos@webrtc.org | af38f4e | 2014-07-08 07:38:12 +0000 | [diff] [blame] | 891 | // Minimum RTP header size. |
| 892 | if (length < 12) |
| 893 | return DELIVERY_PACKET_ERROR; |
| 894 | |
stefan | 91d9260 | 2015-11-11 10:13:02 -0800 | [diff] [blame] | 895 | uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]); |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 896 | ReadLockScoped read_lock(*receive_crit_); |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 897 | if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { |
| 898 | auto it = audio_receive_ssrcs_.find(ssrc); |
| 899 | if (it != audio_receive_ssrcs_.end()) { |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 900 | received_bytes_per_second_counter_.Add(static_cast<int>(length)); |
| 901 | received_audio_bytes_per_second_counter_.Add(static_cast<int>(length)); |
ivoc | b04965c | 2015-09-09 00:09:43 -0700 | [diff] [blame] | 902 | auto status = it->second->DeliverRtp(packet, length, packet_time) |
| 903 | ? DELIVERY_OK |
| 904 | : DELIVERY_PACKET_ERROR; |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 905 | if (status == DELIVERY_OK) |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 906 | event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length); |
ivoc | b04965c | 2015-09-09 00:09:43 -0700 | [diff] [blame] | 907 | return status; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 908 | } |
| 909 | } |
| 910 | if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { |
| 911 | auto it = video_receive_ssrcs_.find(ssrc); |
| 912 | if (it != video_receive_ssrcs_.end()) { |
asapersson | 250fd97 | 2016-09-08 00:07:21 -0700 | [diff] [blame] | 913 | received_bytes_per_second_counter_.Add(static_cast<int>(length)); |
| 914 | received_video_bytes_per_second_counter_.Add(static_cast<int>(length)); |
ivoc | b04965c | 2015-09-09 00:09:43 -0700 | [diff] [blame] | 915 | auto status = it->second->DeliverRtp(packet, length, packet_time) |
| 916 | ? DELIVERY_OK |
| 917 | : DELIVERY_PACKET_ERROR; |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 918 | if (status == DELIVERY_OK) |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 919 | event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length); |
ivoc | b04965c | 2015-09-09 00:09:43 -0700 | [diff] [blame] | 920 | return status; |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 921 | } |
| 922 | } |
| 923 | return DELIVERY_UNKNOWN_SSRC; |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 924 | } |
| 925 | |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 926 | PacketReceiver::DeliveryStatus Call::DeliverPacket( |
| 927 | MediaType media_type, |
| 928 | const uint8_t* packet, |
| 929 | size_t length, |
| 930 | const PacketTime& packet_time) { |
solenberg | 5a28939 | 2015-10-19 03:39:20 -0700 | [diff] [blame] | 931 | // TODO(solenberg): Tests call this function on a network thread, libjingle |
| 932 | // calls on the worker thread. We should move towards always using a network |
| 933 | // thread. Then this check can be enabled. |
| 934 | // RTC_DCHECK(!configuration_thread_checker_.CalledOnValidThread()); |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 935 | if (RtpHeaderParser::IsRtcp(packet, length)) |
Fredrik Solenberg | 23fba1f | 2015-04-29 15:24:01 +0200 | [diff] [blame] | 936 | return DeliverRtcp(media_type, packet, length); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 937 | |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 938 | return DeliverRtp(media_type, packet, length, packet_time); |
pbos@webrtc.org | 29d5839 | 2013-05-16 12:08:03 +0000 | [diff] [blame] | 939 | } |
| 940 | |
| 941 | } // namespace internal |
| 942 | } // namespace webrtc |