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|. |
Guido Urdaneta | ccab06f | 2020-01-15 11:30:29 +0000 | [diff] [blame] | 58 | MethodCall<PeerConnectionFactory, bool> call( |
| 59 | pc_factory.get(), &PeerConnectionFactory::Initialize); |
| 60 | bool result = call.Marshal(RTC_FROM_HERE, pc_factory->signaling_thread()); |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 61 | |
| 62 | if (!result) { |
| 63 | return nullptr; |
| 64 | } |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 65 | return PeerConnectionFactoryProxy::Create(pc_factory->signaling_thread(), |
| 66 | pc_factory); |
kwiberg | 1e4e8cb | 2017-01-31 01:48:08 -0800 | [diff] [blame] | 67 | } |
| 68 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 69 | PeerConnectionFactory::PeerConnectionFactory( |
Danil Chapovalov | f5258be | 2019-03-19 17:45:24 +0100 | [diff] [blame] | 70 | PeerConnectionFactoryDependencies dependencies) |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 71 | : wraps_current_thread_(false), |
Danil Chapovalov | f5258be | 2019-03-19 17:45:24 +0100 | [diff] [blame] | 72 | network_thread_(dependencies.network_thread), |
| 73 | worker_thread_(dependencies.worker_thread), |
| 74 | signaling_thread_(dependencies.signaling_thread), |
Danil Chapovalov | 9435c61 | 2019-04-01 10:33:16 +0200 | [diff] [blame] | 75 | task_queue_factory_(std::move(dependencies.task_queue_factory)), |
Danil Chapovalov | f5258be | 2019-03-19 17:45:24 +0100 | [diff] [blame] | 76 | media_engine_(std::move(dependencies.media_engine)), |
| 77 | call_factory_(std::move(dependencies.call_factory)), |
| 78 | event_log_factory_(std::move(dependencies.event_log_factory)), |
| 79 | fec_controller_factory_(std::move(dependencies.fec_controller_factory)), |
Ying Wang | 0810a7c | 2019-04-10 13:48:24 +0200 | [diff] [blame] | 80 | network_state_predictor_factory_( |
| 81 | std::move(dependencies.network_state_predictor_factory)), |
Sebastian Jansson | dfce03a | 2018-05-18 18:05:10 +0200 | [diff] [blame] | 82 | injected_network_controller_factory_( |
Danil Chapovalov | f5258be | 2019-03-19 17:45:24 +0100 | [diff] [blame] | 83 | std::move(dependencies.network_controller_factory)), |
Ivo Creusen | c3d1f9b | 2019-11-01 11:47:51 +0100 | [diff] [blame] | 84 | media_transport_factory_(std::move(dependencies.media_transport_factory)), |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 85 | neteq_factory_(std::move(dependencies.neteq_factory)), |
| 86 | trials_(dependencies.trials ? std::move(dependencies.trials) |
| 87 | : std::make_unique<FieldTrialBasedConfig>()) { |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 88 | if (!network_thread_) { |
| 89 | owned_network_thread_ = rtc::Thread::CreateWithSocketServer(); |
Sebastian Jansson | 13f35ec | 2017-11-13 10:54:45 +0100 | [diff] [blame] | 90 | owned_network_thread_->SetName("pc_network_thread", nullptr); |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 91 | owned_network_thread_->Start(); |
| 92 | network_thread_ = owned_network_thread_.get(); |
| 93 | } |
| 94 | |
| 95 | if (!worker_thread_) { |
| 96 | owned_worker_thread_ = rtc::Thread::Create(); |
Sebastian Jansson | 13f35ec | 2017-11-13 10:54:45 +0100 | [diff] [blame] | 97 | owned_worker_thread_->SetName("pc_worker_thread", nullptr); |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 98 | owned_worker_thread_->Start(); |
| 99 | worker_thread_ = owned_worker_thread_.get(); |
| 100 | } |
| 101 | |
| 102 | if (!signaling_thread_) { |
| 103 | signaling_thread_ = rtc::Thread::Current(); |
| 104 | if (!signaling_thread_) { |
| 105 | // If this thread isn't already wrapped by an rtc::Thread, create a |
| 106 | // wrapper and own it in this class. |
| 107 | signaling_thread_ = rtc::ThreadManager::Instance()->WrapCurrentThread(); |
| 108 | wraps_current_thread_ = true; |
| 109 | } |
| 110 | } |
Piotr (Peter) Slatala | e0c2e97 | 2018-10-08 09:43:21 -0700 | [diff] [blame] | 111 | } |
Benjamin Wright | 5234a49 | 2018-05-29 15:04:32 -0700 | [diff] [blame] | 112 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 113 | PeerConnectionFactory::~PeerConnectionFactory() { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 114 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
Henrik Boström | 5e56c59 | 2015-08-11 10:33:13 +0200 | [diff] [blame] | 115 | channel_manager_.reset(nullptr); |
jiayl@webrtc.org | d83f4ef | 2015-03-13 21:26:12 +0000 | [diff] [blame] | 116 | |
| 117 | // Make sure |worker_thread_| and |signaling_thread_| outlive |
Henrik Boström | cebf0a2 | 2016-06-01 15:45:30 +0200 | [diff] [blame] | 118 | // |default_socket_factory_| and |default_network_manager_|. |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 119 | default_socket_factory_ = nullptr; |
| 120 | default_network_manager_ = nullptr; |
jiayl@webrtc.org | d83f4ef | 2015-03-13 21:26:12 +0000 | [diff] [blame] | 121 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 122 | if (wraps_current_thread_) |
| 123 | rtc::ThreadManager::Instance()->UnwrapCurrentThread(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 124 | } |
| 125 | |
| 126 | bool PeerConnectionFactory::Initialize() { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 127 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 128 | rtc::InitRandom(rtc::Time32()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 129 | |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 130 | default_network_manager_.reset(new rtc::BasicNetworkManager()); |
| 131 | if (!default_network_manager_) { |
| 132 | return false; |
| 133 | } |
| 134 | |
| 135 | default_socket_factory_.reset( |
danilchap | e9021a3 | 2016-05-17 01:52:02 -0700 | [diff] [blame] | 136 | new rtc::BasicPacketSocketFactory(network_thread_)); |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 137 | if (!default_socket_factory_) { |
| 138 | return false; |
| 139 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 140 | |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 141 | channel_manager_ = std::make_unique<cricket::ChannelManager>( |
| 142 | std::move(media_engine_), std::make_unique<cricket::RtpDataEngine>(), |
Steve Anton | c9e1560 | 2017-11-06 15:40:09 -0800 | [diff] [blame] | 143 | worker_thread_, network_thread_); |
henrika@webrtc.org | 62f6e75 | 2015-02-11 08:38:35 +0000 | [diff] [blame] | 144 | |
stefan@webrtc.org | 85d2794 | 2014-06-09 12:51:39 +0000 | [diff] [blame] | 145 | channel_manager_->SetVideoRtxEnabled(true); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 146 | if (!channel_manager_->Init()) { |
| 147 | return false; |
| 148 | } |
jiayl@webrtc.org | 61e00b0 | 2015-03-04 22:17:38 +0000 | [diff] [blame] | 149 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 150 | return true; |
| 151 | } |
| 152 | |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 153 | void PeerConnectionFactory::SetOptions(const Options& options) { |
| 154 | options_ = options; |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 157 | RtpCapabilities PeerConnectionFactory::GetRtpSenderCapabilities( |
| 158 | cricket::MediaType kind) const { |
| 159 | RTC_DCHECK_RUN_ON(signaling_thread_); |
| 160 | switch (kind) { |
| 161 | case cricket::MEDIA_TYPE_AUDIO: { |
| 162 | cricket::AudioCodecs cricket_codecs; |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 163 | channel_manager_->GetSupportedAudioSendCodecs(&cricket_codecs); |
Markus Handell | 0357b3e | 2020-03-16 13:40:51 +0100 | [diff] [blame] | 164 | return ToRtpCapabilities( |
| 165 | cricket_codecs, |
| 166 | channel_manager_->GetDefaultEnabledAudioRtpHeaderExtensions()); |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 167 | } |
| 168 | case cricket::MEDIA_TYPE_VIDEO: { |
| 169 | cricket::VideoCodecs cricket_codecs; |
Johannes Kron | 8e8b36a | 2020-02-07 14:23:45 +0000 | [diff] [blame] | 170 | channel_manager_->GetSupportedVideoCodecs(&cricket_codecs); |
Markus Handell | 0357b3e | 2020-03-16 13:40:51 +0100 | [diff] [blame] | 171 | return ToRtpCapabilities( |
| 172 | cricket_codecs, |
| 173 | channel_manager_->GetDefaultEnabledVideoRtpHeaderExtensions()); |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 174 | } |
| 175 | case cricket::MEDIA_TYPE_DATA: |
| 176 | return RtpCapabilities(); |
| 177 | } |
| 178 | // Not reached; avoids compile warning. |
| 179 | FATAL(); |
| 180 | } |
| 181 | |
| 182 | RtpCapabilities PeerConnectionFactory::GetRtpReceiverCapabilities( |
| 183 | cricket::MediaType kind) const { |
| 184 | RTC_DCHECK_RUN_ON(signaling_thread_); |
| 185 | switch (kind) { |
| 186 | case cricket::MEDIA_TYPE_AUDIO: { |
| 187 | cricket::AudioCodecs cricket_codecs; |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 188 | channel_manager_->GetSupportedAudioReceiveCodecs(&cricket_codecs); |
Markus Handell | 0357b3e | 2020-03-16 13:40:51 +0100 | [diff] [blame] | 189 | return ToRtpCapabilities( |
| 190 | cricket_codecs, |
| 191 | channel_manager_->GetDefaultEnabledAudioRtpHeaderExtensions()); |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 192 | } |
| 193 | case cricket::MEDIA_TYPE_VIDEO: { |
| 194 | cricket::VideoCodecs cricket_codecs; |
Johannes Kron | 8e8b36a | 2020-02-07 14:23:45 +0000 | [diff] [blame] | 195 | channel_manager_->GetSupportedVideoCodecs(&cricket_codecs); |
Markus Handell | 0357b3e | 2020-03-16 13:40:51 +0100 | [diff] [blame] | 196 | return ToRtpCapabilities( |
| 197 | cricket_codecs, |
| 198 | channel_manager_->GetDefaultEnabledVideoRtpHeaderExtensions()); |
Florent Castelli | 72b751a | 2018-06-28 14:09:33 +0200 | [diff] [blame] | 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 | |
Qingsi Wang | e8d54b9 | 2020-01-06 14:31:57 -0800 | [diff] [blame] | 270 | if (!dependencies.async_resolver_factory) { |
| 271 | dependencies.async_resolver_factory = |
| 272 | std::make_unique<webrtc::BasicAsyncResolverFactory>(); |
| 273 | } |
| 274 | |
Qingsi Wang | 25ec888 | 2019-11-15 12:33:05 -0800 | [diff] [blame] | 275 | if (!dependencies.ice_transport_factory) { |
| 276 | dependencies.ice_transport_factory = |
| 277 | std::make_unique<DefaultIceTransportFactory>(); |
| 278 | } |
| 279 | |
jonaso | c251cb1 | 2017-08-29 03:20:58 -0700 | [diff] [blame] | 280 | network_thread_->Invoke<void>( |
Benjamin Wright | 6f7e6d6 | 2018-05-02 13:46:31 -0700 | [diff] [blame] | 281 | RTC_FROM_HERE, |
| 282 | rtc::Bind(&cricket::PortAllocator::SetNetworkIgnoreMask, |
| 283 | dependencies.allocator.get(), options_.network_ignore_mask)); |
jonaso | c251cb1 | 2017-08-29 03:20:58 -0700 | [diff] [blame] | 284 | |
eladalon | 393a9f6 | 2017-09-05 04:30:30 -0700 | [diff] [blame] | 285 | std::unique_ptr<RtcEventLog> event_log = |
eladalon | 248fd4f | 2017-09-06 05:18:15 -0700 | [diff] [blame] | 286 | worker_thread_->Invoke<std::unique_ptr<RtcEventLog>>( |
| 287 | RTC_FROM_HERE, |
| 288 | rtc::Bind(&PeerConnectionFactory::CreateRtcEventLog_w, this)); |
maxmorin | e9ef907 | 2017-08-29 04:49:00 -0700 | [diff] [blame] | 289 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 290 | std::unique_ptr<Call> call = worker_thread_->Invoke<std::unique_ptr<Call>>( |
| 291 | RTC_FROM_HERE, |
| 292 | rtc::Bind(&PeerConnectionFactory::CreateCall_w, this, event_log.get())); |
| 293 | |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 294 | rtc::scoped_refptr<PeerConnection> pc( |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 295 | new rtc::RefCountedObject<PeerConnection>(this, std::move(event_log), |
| 296 | std::move(call))); |
Harald Alvestrand | 1979384 | 2018-06-25 12:03:50 +0200 | [diff] [blame] | 297 | ActionsBeforeInitializeForTesting(pc); |
Benjamin Wright | cab5888 | 2018-05-02 15:12:47 -0700 | [diff] [blame] | 298 | if (!pc->Initialize(configuration, std::move(dependencies))) { |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 299 | return nullptr; |
| 300 | } |
| 301 | return PeerConnectionProxy::Create(signaling_thread(), pc); |
| 302 | } |
| 303 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 304 | rtc::scoped_refptr<MediaStreamInterface> |
Seth Hampson | 845e878 | 2018-03-02 11:34:10 -0800 | [diff] [blame] | 305 | PeerConnectionFactory::CreateLocalMediaStream(const std::string& stream_id) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 306 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 307 | return MediaStreamProxy::Create(signaling_thread_, |
Seth Hampson | 845e878 | 2018-03-02 11:34:10 -0800 | [diff] [blame] | 308 | MediaStream::Create(stream_id)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 309 | } |
| 310 | |
perkj | a3ede6c | 2016-03-08 01:27:48 +0100 | [diff] [blame] | 311 | rtc::scoped_refptr<VideoTrackInterface> PeerConnectionFactory::CreateVideoTrack( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 312 | const std::string& id, |
perkj | a3ede6c | 2016-03-08 01:27:48 +0100 | [diff] [blame] | 313 | VideoTrackSourceInterface* source) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 314 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 315 | rtc::scoped_refptr<VideoTrackInterface> track( |
perkj | 773be36 | 2017-07-31 23:22:01 -0700 | [diff] [blame] | 316 | VideoTrack::Create(id, source, worker_thread_)); |
nisse | 5b68ab5 | 2016-04-07 07:45:54 -0700 | [diff] [blame] | 317 | return VideoTrackProxy::Create(signaling_thread_, worker_thread_, track); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 318 | } |
| 319 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 320 | rtc::scoped_refptr<AudioTrackInterface> PeerConnectionFactory::CreateAudioTrack( |
| 321 | const std::string& id, |
| 322 | AudioSourceInterface* source) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 323 | RTC_DCHECK(signaling_thread_->IsCurrent()); |
tommi | 6eca7e3 | 2015-12-15 04:27:11 -0800 | [diff] [blame] | 324 | rtc::scoped_refptr<AudioTrackInterface> track(AudioTrack::Create(id, source)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 325 | return AudioTrackProxy::Create(signaling_thread_, track); |
| 326 | } |
| 327 | |
Steve Anton | da6c095 | 2017-10-23 11:41:54 -0700 | [diff] [blame] | 328 | std::unique_ptr<cricket::SctpTransportInternalFactory> |
| 329 | PeerConnectionFactory::CreateSctpTransportInternalFactory() { |
| 330 | #ifdef HAVE_SCTP |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 331 | return std::make_unique<cricket::SctpTransportFactory>(network_thread()); |
Steve Anton | da6c095 | 2017-10-23 11:41:54 -0700 | [diff] [blame] | 332 | #else |
| 333 | return nullptr; |
| 334 | #endif |
| 335 | } |
| 336 | |
nisse | eaabdf6 | 2017-05-05 02:23:02 -0700 | [diff] [blame] | 337 | cricket::ChannelManager* PeerConnectionFactory::channel_manager() { |
| 338 | return channel_manager_.get(); |
| 339 | } |
| 340 | |
eladalon | 248fd4f | 2017-09-06 05:18:15 -0700 | [diff] [blame] | 341 | std::unique_ptr<RtcEventLog> PeerConnectionFactory::CreateRtcEventLog_w() { |
eladalon | 591753b | 2017-09-06 12:33:43 -0700 | [diff] [blame] | 342 | RTC_DCHECK_RUN_ON(worker_thread_); |
Bjorn Terelius | b26cf2f | 2018-10-26 20:39:33 +0200 | [diff] [blame] | 343 | |
| 344 | auto encoding_type = RtcEventLog::EncodingType::Legacy; |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 345 | if (IsTrialEnabled("WebRTC-RtcEventLogNewFormat")) |
Bjorn Terelius | b26cf2f | 2018-10-26 20:39:33 +0200 | [diff] [blame] | 346 | encoding_type = RtcEventLog::EncodingType::NewFormat; |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 347 | return event_log_factory_ |
| 348 | ? event_log_factory_->CreateRtcEventLog(encoding_type) |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 349 | : std::make_unique<RtcEventLogNull>(); |
eladalon | 248fd4f | 2017-09-06 05:18:15 -0700 | [diff] [blame] | 350 | } |
| 351 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 352 | std::unique_ptr<Call> PeerConnectionFactory::CreateCall_w( |
| 353 | RtcEventLog* event_log) { |
eladalon | 591753b | 2017-09-06 12:33:43 -0700 | [diff] [blame] | 354 | RTC_DCHECK_RUN_ON(worker_thread_); |
| 355 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 356 | webrtc::Call::Config call_config(event_log); |
| 357 | if (!channel_manager_->media_engine() || !call_factory_) { |
| 358 | return nullptr; |
| 359 | } |
Sebastian Jansson | 6eb8a16 | 2018-11-16 11:29:55 +0100 | [diff] [blame] | 360 | call_config.audio_state = |
| 361 | channel_manager_->media_engine()->voice().GetAudioState(); |
Elad Alon | 9cfdb20 | 2019-08-13 10:48:48 +0200 | [diff] [blame] | 362 | |
Danil Chapovalov | cad3e0e | 2020-02-17 18:46:07 +0100 | [diff] [blame] | 363 | FieldTrialParameter<DataRate> min_bandwidth("min", |
| 364 | DataRate::KilobitsPerSec(30)); |
| 365 | FieldTrialParameter<DataRate> start_bandwidth("start", |
| 366 | DataRate::KilobitsPerSec(300)); |
| 367 | FieldTrialParameter<DataRate> max_bandwidth("max", |
| 368 | DataRate::KilobitsPerSec(2000)); |
Elad Alon | 9cfdb20 | 2019-08-13 10:48:48 +0200 | [diff] [blame] | 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 |