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