henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [diff] [blame] | 2 | * Copyright 2004 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3 | * |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [diff] [blame] | 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. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 11 | #include "pc/peer_connection_factory.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 12 | |
Ying Wang | 0810a7c | 2019-04-10 13:48:24 +0200 | [diff] [blame] | 13 | #include <memory> |
kwiberg | 0eb15ed | 2015-12-17 03:04:15 -0800 | [diff] [blame] | 14 | #include <utility> |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 15 | #include <vector> |
kwiberg | 0eb15ed | 2015-12-17 03:04:15 -0800 | [diff] [blame] | 16 | |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 17 | #include "api/fec_controller.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 18 | #include "api/media_stream_proxy.h" |
| 19 | #include "api/media_stream_track_proxy.h" |
Ying Wang | 0810a7c | 2019-04-10 13:48:24 +0200 | [diff] [blame] | 20 | #include "api/network_state_predictor.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 21 | #include "api/peer_connection_factory_proxy.h" |
| 22 | #include "api/peer_connection_proxy.h" |
Danil Chapovalov | 83bbe91 | 2019-08-07 12:24:53 +0200 | [diff] [blame] | 23 | #include "api/rtc_event_log/rtc_event_log.h" |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 24 | #include "api/transport/field_trial_based_config.h" |
Niels Möller | 65f17ca | 2019-09-12 13:59:36 +0200 | [diff] [blame] | 25 | #include "api/transport/media/media_transport_interface.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 26 | #include "api/turn_customizer.h" |
Elad Alon | 9cfdb20 | 2019-08-13 10:48:48 +0200 | [diff] [blame] | 27 | #include "api/units/data_rate.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 28 | #include "api/video_track_source_proxy.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 29 | #include "media/base/rtp_data_engine.h" |
| 30 | #include "media/sctp/sctp_transport.h" |
Qingsi Wang | e8d54b9 | 2020-01-06 14:31:57 -0800 | [diff] [blame] | 31 | #include "p2p/base/basic_async_resolver_factory.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 32 | #include "p2p/base/basic_packet_socket_factory.h" |
Qingsi Wang | 25ec888 | 2019-11-15 12:33:05 -0800 | [diff] [blame] | 33 | #include "p2p/base/default_ice_transport_factory.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 34 | #include "p2p/client/basic_port_allocator.h" |
| 35 | #include "pc/audio_track.h" |
| 36 | #include "pc/local_audio_source.h" |
| 37 | #include "pc/media_stream.h" |
| 38 | #include "pc/peer_connection.h" |
Ying Wang | 0810a7c | 2019-04-10 13:48:24 +0200 | [diff] [blame] | 39 | #include "pc/rtp_parameters_conversion.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 40 | #include "pc/video_track.h" |
Ying Wang | 0810a7c | 2019-04-10 13:48:24 +0200 | [diff] [blame] | 41 | #include "rtc_base/bind.h" |
| 42 | #include "rtc_base/checks.h" |
Elad Alon | 9cfdb20 | 2019-08-13 10:48:48 +0200 | [diff] [blame] | 43 | #include "rtc_base/experiments/field_trial_parser.h" |
| 44 | #include "rtc_base/experiments/field_trial_units.h" |
| 45 | #include "rtc_base/numerics/safe_conversions.h" |
Niels Möller | e8e4dc4 | 2019-06-11 14:04:16 +0200 | [diff] [blame] | 46 | #include "rtc_base/system/file_wrapper.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 47 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 48 | namespace webrtc { |
| 49 | |
kwiberg | 1e4e8cb | 2017-01-31 01:48:08 -0800 | [diff] [blame] | 50 | rtc::scoped_refptr<PeerConnectionFactoryInterface> |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 51 | CreateModularPeerConnectionFactory( |
Benjamin Wright | 5234a49 | 2018-05-29 15:04:32 -0700 | [diff] [blame] | 52 | PeerConnectionFactoryDependencies dependencies) { |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 53 | rtc::scoped_refptr<PeerConnectionFactory> pc_factory( |
| 54 | new rtc::RefCountedObject<PeerConnectionFactory>( |
Benjamin Wright | 5234a49 | 2018-05-29 15:04:32 -0700 | [diff] [blame] | 55 | std::move(dependencies))); |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 56 | // Call Initialize synchronously but make sure it is executed on |
| 57 | // |signaling_thread|. |
Sebastian Jansson | b0e0728 | 2020-01-10 19:39:58 +0100 | [diff] [blame] | 58 | bool result = pc_factory->signaling_thread()->Invoke<bool>( |
| 59 | RTC_FROM_HERE, [&] { return pc_factory->Initialize(); }); |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 60 | |
| 61 | if (!result) { |
| 62 | return nullptr; |
| 63 | } |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 64 | return PeerConnectionFactoryProxy::Create(pc_factory->signaling_thread(), |
| 65 | pc_factory); |
kwiberg | 1e4e8cb | 2017-01-31 01:48:08 -0800 | [diff] [blame] | 66 | } |
| 67 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 68 | PeerConnectionFactory::PeerConnectionFactory( |
Danil Chapovalov | f5258be | 2019-03-19 17:45:24 +0100 | [diff] [blame] | 69 | PeerConnectionFactoryDependencies dependencies) |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 70 | : wraps_current_thread_(false), |
Danil Chapovalov | f5258be | 2019-03-19 17:45:24 +0100 | [diff] [blame] | 71 | network_thread_(dependencies.network_thread), |
| 72 | worker_thread_(dependencies.worker_thread), |
| 73 | signaling_thread_(dependencies.signaling_thread), |
Danil Chapovalov | 9435c61 | 2019-04-01 10:33:16 +0200 | [diff] [blame] | 74 | task_queue_factory_(std::move(dependencies.task_queue_factory)), |
Danil Chapovalov | f5258be | 2019-03-19 17:45:24 +0100 | [diff] [blame] | 75 | media_engine_(std::move(dependencies.media_engine)), |
| 76 | call_factory_(std::move(dependencies.call_factory)), |
| 77 | event_log_factory_(std::move(dependencies.event_log_factory)), |
| 78 | fec_controller_factory_(std::move(dependencies.fec_controller_factory)), |
Ying Wang | 0810a7c | 2019-04-10 13:48:24 +0200 | [diff] [blame] | 79 | network_state_predictor_factory_( |
| 80 | std::move(dependencies.network_state_predictor_factory)), |
Sebastian Jansson | dfce03a | 2018-05-18 18:05:10 +0200 | [diff] [blame] | 81 | injected_network_controller_factory_( |
Danil Chapovalov | f5258be | 2019-03-19 17:45:24 +0100 | [diff] [blame] | 82 | std::move(dependencies.network_controller_factory)), |
Ivo Creusen | c3d1f9b | 2019-11-01 11:47:51 +0100 | [diff] [blame] | 83 | media_transport_factory_(std::move(dependencies.media_transport_factory)), |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 84 | neteq_factory_(std::move(dependencies.neteq_factory)), |
| 85 | trials_(dependencies.trials ? std::move(dependencies.trials) |
| 86 | : std::make_unique<FieldTrialBasedConfig>()) { |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 87 | if (!network_thread_) { |
| 88 | owned_network_thread_ = rtc::Thread::CreateWithSocketServer(); |
Sebastian Jansson | 13f35ec | 2017-11-13 10:54:45 +0100 | [diff] [blame] | 89 | owned_network_thread_->SetName("pc_network_thread", nullptr); |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 90 | owned_network_thread_->Start(); |
| 91 | network_thread_ = owned_network_thread_.get(); |
| 92 | } |
| 93 | |
| 94 | if (!worker_thread_) { |
| 95 | owned_worker_thread_ = rtc::Thread::Create(); |
Sebastian Jansson | 13f35ec | 2017-11-13 10:54:45 +0100 | [diff] [blame] | 96 | owned_worker_thread_->SetName("pc_worker_thread", nullptr); |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 97 | owned_worker_thread_->Start(); |
| 98 | worker_thread_ = owned_worker_thread_.get(); |
| 99 | } |
| 100 | |
| 101 | if (!signaling_thread_) { |
| 102 | signaling_thread_ = rtc::Thread::Current(); |
| 103 | if (!signaling_thread_) { |
| 104 | // If this thread isn't already wrapped by an rtc::Thread, create a |
| 105 | // wrapper and own it in this class. |
| 106 | signaling_thread_ = rtc::ThreadManager::Instance()->WrapCurrentThread(); |
| 107 | wraps_current_thread_ = true; |
| 108 | } |
| 109 | } |
Piotr (Peter) Slatala | e0c2e97 | 2018-10-08 09:43:21 -0700 | [diff] [blame] | 110 | } |
Benjamin Wright | 5234a49 | 2018-05-29 15:04:32 -0700 | [diff] [blame] | 111 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 112 | PeerConnectionFactory::~PeerConnectionFactory() { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 113 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
Henrik Boström | 5e56c59 | 2015-08-11 10:33:13 +0200 | [diff] [blame] | 114 | channel_manager_.reset(nullptr); |
jiayl@webrtc.org | d83f4ef | 2015-03-13 21:26:12 +0000 | [diff] [blame] | 115 | |
| 116 | // Make sure |worker_thread_| and |signaling_thread_| outlive |
Henrik Boström | cebf0a2 | 2016-06-01 15:45:30 +0200 | [diff] [blame] | 117 | // |default_socket_factory_| and |default_network_manager_|. |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 118 | default_socket_factory_ = nullptr; |
| 119 | default_network_manager_ = nullptr; |
jiayl@webrtc.org | d83f4ef | 2015-03-13 21:26:12 +0000 | [diff] [blame] | 120 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 121 | if (wraps_current_thread_) |
| 122 | rtc::ThreadManager::Instance()->UnwrapCurrentThread(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | bool PeerConnectionFactory::Initialize() { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 126 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 127 | rtc::InitRandom(rtc::Time32()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 128 | |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 129 | default_network_manager_.reset(new rtc::BasicNetworkManager()); |
| 130 | if (!default_network_manager_) { |
| 131 | return false; |
| 132 | } |
| 133 | |
| 134 | default_socket_factory_.reset( |
danilchap | e9021a3 | 2016-05-17 01:52:02 -0700 | [diff] [blame] | 135 | new rtc::BasicPacketSocketFactory(network_thread_)); |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 136 | if (!default_socket_factory_) { |
| 137 | return false; |
| 138 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 139 | |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 140 | channel_manager_ = std::make_unique<cricket::ChannelManager>( |
| 141 | std::move(media_engine_), std::make_unique<cricket::RtpDataEngine>(), |
Steve Anton | c9e1560 | 2017-11-06 15:40:09 -0800 | [diff] [blame] | 142 | worker_thread_, network_thread_); |
henrika@webrtc.org | 62f6e75 | 2015-02-11 08:38:35 +0000 | [diff] [blame] | 143 | |
stefan@webrtc.org | 85d2794 | 2014-06-09 12:51:39 +0000 | [diff] [blame] | 144 | channel_manager_->SetVideoRtxEnabled(true); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 145 | if (!channel_manager_->Init()) { |
| 146 | return false; |
| 147 | } |
jiayl@webrtc.org | 61e00b0 | 2015-03-04 22:17:38 +0000 | [diff] [blame] | 148 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 149 | return true; |
| 150 | } |
| 151 | |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 152 | void PeerConnectionFactory::SetOptions(const Options& options) { |
| 153 | options_ = options; |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 154 | } |
| 155 | |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 156 | RtpCapabilities PeerConnectionFactory::GetRtpSenderCapabilities( |
| 157 | cricket::MediaType kind) const { |
| 158 | RTC_DCHECK_RUN_ON(signaling_thread_); |
| 159 | switch (kind) { |
| 160 | case cricket::MEDIA_TYPE_AUDIO: { |
| 161 | cricket::AudioCodecs cricket_codecs; |
| 162 | cricket::RtpHeaderExtensions cricket_extensions; |
| 163 | channel_manager_->GetSupportedAudioSendCodecs(&cricket_codecs); |
| 164 | channel_manager_->GetSupportedAudioRtpHeaderExtensions( |
| 165 | &cricket_extensions); |
| 166 | return ToRtpCapabilities(cricket_codecs, cricket_extensions); |
| 167 | } |
| 168 | case cricket::MEDIA_TYPE_VIDEO: { |
| 169 | cricket::VideoCodecs cricket_codecs; |
| 170 | cricket::RtpHeaderExtensions cricket_extensions; |
| 171 | channel_manager_->GetSupportedVideoCodecs(&cricket_codecs); |
| 172 | channel_manager_->GetSupportedVideoRtpHeaderExtensions( |
| 173 | &cricket_extensions); |
| 174 | return ToRtpCapabilities(cricket_codecs, cricket_extensions); |
| 175 | } |
| 176 | case cricket::MEDIA_TYPE_DATA: |
| 177 | return RtpCapabilities(); |
| 178 | } |
| 179 | // Not reached; avoids compile warning. |
| 180 | FATAL(); |
| 181 | } |
| 182 | |
| 183 | RtpCapabilities PeerConnectionFactory::GetRtpReceiverCapabilities( |
| 184 | cricket::MediaType kind) const { |
| 185 | RTC_DCHECK_RUN_ON(signaling_thread_); |
| 186 | switch (kind) { |
| 187 | case cricket::MEDIA_TYPE_AUDIO: { |
| 188 | cricket::AudioCodecs cricket_codecs; |
| 189 | cricket::RtpHeaderExtensions cricket_extensions; |
| 190 | channel_manager_->GetSupportedAudioReceiveCodecs(&cricket_codecs); |
| 191 | channel_manager_->GetSupportedAudioRtpHeaderExtensions( |
| 192 | &cricket_extensions); |
| 193 | return ToRtpCapabilities(cricket_codecs, cricket_extensions); |
| 194 | } |
| 195 | case cricket::MEDIA_TYPE_VIDEO: { |
| 196 | cricket::VideoCodecs cricket_codecs; |
| 197 | cricket::RtpHeaderExtensions cricket_extensions; |
| 198 | channel_manager_->GetSupportedVideoCodecs(&cricket_codecs); |
| 199 | channel_manager_->GetSupportedVideoRtpHeaderExtensions( |
| 200 | &cricket_extensions); |
| 201 | return ToRtpCapabilities(cricket_codecs, cricket_extensions); |
| 202 | } |
| 203 | case cricket::MEDIA_TYPE_DATA: |
| 204 | return RtpCapabilities(); |
| 205 | } |
| 206 | // Not reached; avoids compile warning. |
| 207 | FATAL(); |
| 208 | } |
| 209 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 210 | rtc::scoped_refptr<AudioSourceInterface> |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 211 | PeerConnectionFactory::CreateAudioSource(const cricket::AudioOptions& options) { |
| 212 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
| 213 | rtc::scoped_refptr<LocalAudioSource> source( |
deadbeef | 757146b | 2017-02-10 21:26:48 -0800 | [diff] [blame] | 214 | LocalAudioSource::Create(&options)); |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 215 | return source; |
| 216 | } |
| 217 | |
Niels Möller | e8e4dc4 | 2019-06-11 14:04:16 +0200 | [diff] [blame] | 218 | bool PeerConnectionFactory::StartAecDump(FILE* file, int64_t max_size_bytes) { |
| 219 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
| 220 | return channel_manager_->StartAecDump(FileWrapper(file), max_size_bytes); |
| 221 | } |
| 222 | |
ivoc | 797ef12 | 2015-10-22 03:25:41 -0700 | [diff] [blame] | 223 | void PeerConnectionFactory::StopAecDump() { |
| 224 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
| 225 | channel_manager_->StopAecDump(); |
| 226 | } |
| 227 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 228 | rtc::scoped_refptr<PeerConnectionInterface> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 229 | PeerConnectionFactory::CreatePeerConnection( |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 230 | const PeerConnectionInterface::RTCConfiguration& configuration, |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 231 | std::unique_ptr<cricket::PortAllocator> allocator, |
Henrik Boström | d03c23b | 2016-06-01 11:44:18 +0200 | [diff] [blame] | 232 | std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator, |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 233 | PeerConnectionObserver* observer) { |
Patrik Höglund | 662e31f | 2019-09-05 14:35:04 +0200 | [diff] [blame] | 234 | // Convert the legacy API into the new dependency structure. |
Benjamin Wright | 6f7e6d6 | 2018-05-02 13:46:31 -0700 | [diff] [blame] | 235 | PeerConnectionDependencies dependencies(observer); |
| 236 | dependencies.allocator = std::move(allocator); |
| 237 | dependencies.cert_generator = std::move(cert_generator); |
| 238 | // Pass that into the new API. |
| 239 | return CreatePeerConnection(configuration, std::move(dependencies)); |
| 240 | } |
| 241 | |
| 242 | rtc::scoped_refptr<PeerConnectionInterface> |
| 243 | PeerConnectionFactory::CreatePeerConnection( |
| 244 | const PeerConnectionInterface::RTCConfiguration& configuration, |
| 245 | PeerConnectionDependencies dependencies) { |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 246 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
Patrik Höglund | 662e31f | 2019-09-05 14:35:04 +0200 | [diff] [blame] | 247 | RTC_DCHECK(!(dependencies.allocator && dependencies.packet_socket_factory)) |
| 248 | << "You can't set both allocator and packet_socket_factory; " |
| 249 | "the former is going away (see bugs.webrtc.org/7447"; |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 250 | |
Benjamin Wright | 6f7e6d6 | 2018-05-02 13:46:31 -0700 | [diff] [blame] | 251 | // Set internal defaults if optional dependencies are not set. |
| 252 | if (!dependencies.cert_generator) { |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 253 | dependencies.cert_generator = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 254 | std::make_unique<rtc::RTCCertificateGenerator>(signaling_thread_, |
| 255 | network_thread_); |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 256 | } |
Benjamin Wright | 6f7e6d6 | 2018-05-02 13:46:31 -0700 | [diff] [blame] | 257 | if (!dependencies.allocator) { |
Patrik Höglund | 662e31f | 2019-09-05 14:35:04 +0200 | [diff] [blame] | 258 | rtc::PacketSocketFactory* packet_socket_factory; |
| 259 | if (dependencies.packet_socket_factory) |
| 260 | packet_socket_factory = dependencies.packet_socket_factory.get(); |
| 261 | else |
| 262 | packet_socket_factory = default_socket_factory_.get(); |
| 263 | |
Qingsi Wang | 7852d29 | 2018-10-31 11:17:07 -0700 | [diff] [blame] | 264 | network_thread_->Invoke<void>(RTC_FROM_HERE, [this, &configuration, |
Patrik Höglund | 662e31f | 2019-09-05 14:35:04 +0200 | [diff] [blame] | 265 | &dependencies, |
| 266 | &packet_socket_factory]() { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 267 | dependencies.allocator = std::make_unique<cricket::BasicPortAllocator>( |
Patrik Höglund | 662e31f | 2019-09-05 14:35:04 +0200 | [diff] [blame] | 268 | default_network_manager_.get(), packet_socket_factory, |
Qingsi Wang | 7852d29 | 2018-10-31 11:17:07 -0700 | [diff] [blame] | 269 | configuration.turn_customizer); |
| 270 | }); |
jonaso | c251cb1 | 2017-08-29 03:20:58 -0700 | [diff] [blame] | 271 | } |
Benjamin Wright | 6f7e6d6 | 2018-05-02 13:46:31 -0700 | [diff] [blame] | 272 | |
Qingsi Wang | e8d54b9 | 2020-01-06 14:31:57 -0800 | [diff] [blame] | 273 | if (!dependencies.async_resolver_factory) { |
| 274 | dependencies.async_resolver_factory = |
| 275 | std::make_unique<webrtc::BasicAsyncResolverFactory>(); |
| 276 | } |
| 277 | |
Qingsi Wang | 25ec888 | 2019-11-15 12:33:05 -0800 | [diff] [blame] | 278 | if (!dependencies.ice_transport_factory) { |
| 279 | dependencies.ice_transport_factory = |
| 280 | std::make_unique<DefaultIceTransportFactory>(); |
| 281 | } |
| 282 | |
jonaso | c251cb1 | 2017-08-29 03:20:58 -0700 | [diff] [blame] | 283 | network_thread_->Invoke<void>( |
Benjamin Wright | 6f7e6d6 | 2018-05-02 13:46:31 -0700 | [diff] [blame] | 284 | RTC_FROM_HERE, |
| 285 | rtc::Bind(&cricket::PortAllocator::SetNetworkIgnoreMask, |
| 286 | dependencies.allocator.get(), options_.network_ignore_mask)); |
jonaso | c251cb1 | 2017-08-29 03:20:58 -0700 | [diff] [blame] | 287 | |
eladalon | 393a9f6 | 2017-09-05 04:30:30 -0700 | [diff] [blame] | 288 | std::unique_ptr<RtcEventLog> event_log = |
eladalon | 248fd4f | 2017-09-06 05:18:15 -0700 | [diff] [blame] | 289 | worker_thread_->Invoke<std::unique_ptr<RtcEventLog>>( |
| 290 | RTC_FROM_HERE, |
| 291 | rtc::Bind(&PeerConnectionFactory::CreateRtcEventLog_w, this)); |
maxmorin | e9ef907 | 2017-08-29 04:49:00 -0700 | [diff] [blame] | 292 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 293 | std::unique_ptr<Call> call = worker_thread_->Invoke<std::unique_ptr<Call>>( |
| 294 | RTC_FROM_HERE, |
| 295 | rtc::Bind(&PeerConnectionFactory::CreateCall_w, this, event_log.get())); |
| 296 | |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 297 | rtc::scoped_refptr<PeerConnection> pc( |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 298 | new rtc::RefCountedObject<PeerConnection>(this, std::move(event_log), |
| 299 | std::move(call))); |
Harald Alvestrand | 1979384 | 2018-06-25 12:03:50 +0200 | [diff] [blame] | 300 | ActionsBeforeInitializeForTesting(pc); |
Benjamin Wright | cab5888 | 2018-05-02 15:12:47 -0700 | [diff] [blame] | 301 | if (!pc->Initialize(configuration, std::move(dependencies))) { |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 302 | return nullptr; |
| 303 | } |
| 304 | return PeerConnectionProxy::Create(signaling_thread(), pc); |
| 305 | } |
| 306 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 307 | rtc::scoped_refptr<MediaStreamInterface> |
Seth Hampson | 845e878 | 2018-03-02 11:34:10 -0800 | [diff] [blame] | 308 | PeerConnectionFactory::CreateLocalMediaStream(const std::string& stream_id) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 309 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 310 | return MediaStreamProxy::Create(signaling_thread_, |
Seth Hampson | 845e878 | 2018-03-02 11:34:10 -0800 | [diff] [blame] | 311 | MediaStream::Create(stream_id)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 312 | } |
| 313 | |
perkj | a3ede6c | 2016-03-08 01:27:48 +0100 | [diff] [blame] | 314 | rtc::scoped_refptr<VideoTrackInterface> PeerConnectionFactory::CreateVideoTrack( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 315 | const std::string& id, |
perkj | a3ede6c | 2016-03-08 01:27:48 +0100 | [diff] [blame] | 316 | VideoTrackSourceInterface* source) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 317 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 318 | rtc::scoped_refptr<VideoTrackInterface> track( |
perkj | 773be36 | 2017-07-31 23:22:01 -0700 | [diff] [blame] | 319 | VideoTrack::Create(id, source, worker_thread_)); |
nisse | 5b68ab5 | 2016-04-07 07:45:54 -0700 | [diff] [blame] | 320 | return VideoTrackProxy::Create(signaling_thread_, worker_thread_, track); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 321 | } |
| 322 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 323 | rtc::scoped_refptr<AudioTrackInterface> PeerConnectionFactory::CreateAudioTrack( |
| 324 | const std::string& id, |
| 325 | AudioSourceInterface* source) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 326 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
tommi | 6eca7e3 | 2015-12-15 04:27:11 -0800 | [diff] [blame] | 327 | rtc::scoped_refptr<AudioTrackInterface> track(AudioTrack::Create(id, source)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 328 | return AudioTrackProxy::Create(signaling_thread_, track); |
| 329 | } |
| 330 | |
Steve Anton | da6c095 | 2017-10-23 11:41:54 -0700 | [diff] [blame] | 331 | std::unique_ptr<cricket::SctpTransportInternalFactory> |
| 332 | PeerConnectionFactory::CreateSctpTransportInternalFactory() { |
| 333 | #ifdef HAVE_SCTP |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 334 | return std::make_unique<cricket::SctpTransportFactory>(network_thread()); |
Steve Anton | da6c095 | 2017-10-23 11:41:54 -0700 | [diff] [blame] | 335 | #else |
| 336 | return nullptr; |
| 337 | #endif |
| 338 | } |
| 339 | |
nisse | eaabdf6 | 2017-05-05 02:23:02 -0700 | [diff] [blame] | 340 | cricket::ChannelManager* PeerConnectionFactory::channel_manager() { |
| 341 | return channel_manager_.get(); |
| 342 | } |
| 343 | |
eladalon | 248fd4f | 2017-09-06 05:18:15 -0700 | [diff] [blame] | 344 | std::unique_ptr<RtcEventLog> PeerConnectionFactory::CreateRtcEventLog_w() { |
eladalon | 591753b | 2017-09-06 12:33:43 -0700 | [diff] [blame] | 345 | RTC_DCHECK_RUN_ON(worker_thread_); |
Bjorn Terelius | b26cf2f | 2018-10-26 20:39:33 +0200 | [diff] [blame] | 346 | |
| 347 | auto encoding_type = RtcEventLog::EncodingType::Legacy; |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 348 | if (IsTrialEnabled("WebRTC-RtcEventLogNewFormat")) |
Bjorn Terelius | b26cf2f | 2018-10-26 20:39:33 +0200 | [diff] [blame] | 349 | encoding_type = RtcEventLog::EncodingType::NewFormat; |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 350 | return event_log_factory_ |
| 351 | ? event_log_factory_->CreateRtcEventLog(encoding_type) |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 352 | : std::make_unique<RtcEventLogNull>(); |
eladalon | 248fd4f | 2017-09-06 05:18:15 -0700 | [diff] [blame] | 353 | } |
| 354 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 355 | std::unique_ptr<Call> PeerConnectionFactory::CreateCall_w( |
| 356 | RtcEventLog* event_log) { |
eladalon | 591753b | 2017-09-06 12:33:43 -0700 | [diff] [blame] | 357 | RTC_DCHECK_RUN_ON(worker_thread_); |
| 358 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 359 | webrtc::Call::Config call_config(event_log); |
| 360 | if (!channel_manager_->media_engine() || !call_factory_) { |
| 361 | return nullptr; |
| 362 | } |
Sebastian Jansson | 6eb8a16 | 2018-11-16 11:29:55 +0100 | [diff] [blame] | 363 | call_config.audio_state = |
| 364 | channel_manager_->media_engine()->voice().GetAudioState(); |
Elad Alon | 9cfdb20 | 2019-08-13 10:48:48 +0200 | [diff] [blame] | 365 | |
| 366 | FieldTrialParameter<DataRate> min_bandwidth("min", DataRate::kbps(30)); |
| 367 | FieldTrialParameter<DataRate> start_bandwidth("start", DataRate::kbps(300)); |
| 368 | FieldTrialParameter<DataRate> max_bandwidth("max", DataRate::kbps(2000)); |
| 369 | ParseFieldTrial({&min_bandwidth, &start_bandwidth, &max_bandwidth}, |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 370 | trials_->Lookup("WebRTC-PcFactoryDefaultBitrates")); |
Elad Alon | 9cfdb20 | 2019-08-13 10:48:48 +0200 | [diff] [blame] | 371 | |
| 372 | call_config.bitrate_config.min_bitrate_bps = |
| 373 | rtc::saturated_cast<int>(min_bandwidth->bps()); |
| 374 | call_config.bitrate_config.start_bitrate_bps = |
| 375 | rtc::saturated_cast<int>(start_bandwidth->bps()); |
| 376 | call_config.bitrate_config.max_bitrate_bps = |
| 377 | rtc::saturated_cast<int>(max_bandwidth->bps()); |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 378 | |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 379 | call_config.fec_controller_factory = fec_controller_factory_.get(); |
Danil Chapovalov | 9435c61 | 2019-04-01 10:33:16 +0200 | [diff] [blame] | 380 | call_config.task_queue_factory = task_queue_factory_.get(); |
Ying Wang | 0810a7c | 2019-04-10 13:48:24 +0200 | [diff] [blame] | 381 | call_config.network_state_predictor_factory = |
| 382 | network_state_predictor_factory_.get(); |
Ivo Creusen | c3d1f9b | 2019-11-01 11:47:51 +0100 | [diff] [blame] | 383 | call_config.neteq_factory = neteq_factory_.get(); |
Ying Wang | 0dd1b0a | 2018-02-20 12:50:27 +0100 | [diff] [blame] | 384 | |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 385 | if (IsTrialEnabled("WebRTC-Bwe-InjectedCongestionController")) { |
Sebastian Jansson | dfce03a | 2018-05-18 18:05:10 +0200 | [diff] [blame] | 386 | RTC_LOG(LS_INFO) << "Using injected network controller factory"; |
| 387 | call_config.network_controller_factory = |
| 388 | injected_network_controller_factory_.get(); |
| 389 | } else { |
| 390 | RTC_LOG(LS_INFO) << "Using default network controller factory"; |
| 391 | } |
| 392 | |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 393 | call_config.trials = trials_.get(); |
| 394 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 395 | return std::unique_ptr<Call>(call_factory_->CreateCall(call_config)); |
| 396 | } |
| 397 | |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 398 | bool PeerConnectionFactory::IsTrialEnabled(absl::string_view key) const { |
| 399 | RTC_DCHECK(trials_); |
| 400 | return trials_->Lookup(key).find("Enabled") == 0; |
| 401 | } |
| 402 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 403 | } // namespace webrtc |