blob: c9fa223283a4fc06f63b04aeaa42c7c02036bffd [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:361/*
kjellanderb24317b2016-02-10 15:54:432 * Copyright 2004 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:363 *
kjellanderb24317b2016-02-10 15:54:434 * 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.org28e20752013-07-10 00:45:369 */
10
Mirko Bonadei92ea95e2017-09-15 04:47:3111#include "pc/peerconnectionfactory.h"
henrike@webrtc.org28e20752013-07-10 00:45:3612
kwiberg0eb15ed2015-12-17 11:04:1513#include <utility>
14
Ying Wang0dd1b0a2018-02-20 11:50:2715#include "api/fec_controller.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3116#include "api/mediaconstraintsinterface.h"
17#include "api/mediastreamproxy.h"
18#include "api/mediastreamtrackproxy.h"
19#include "api/peerconnectionfactoryproxy.h"
20#include "api/peerconnectionproxy.h"
Jonas Orelandbdcee282017-10-10 12:01:4021#include "api/turncustomizer.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3122#include "api/videosourceproxy.h"
23#include "logging/rtc_event_log/rtc_event_log.h"
Steve Antonc9e15602017-11-06 23:40:0924#include "media/base/rtpdataengine.h"
Steve Antonda6c0952017-10-23 18:41:5425#include "media/sctp/sctptransport.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3126#include "rtc_base/bind.h"
27#include "rtc_base/checks.h"
28#include "rtc_base/ptr_util.h"
Patrik Höglund42805f32018-01-18 19:15:3829// Adding 'nogncheck' to disable the gn include headers check to support modular
30// WebRTC build targets.
31// TODO(zhihuang): This wouldn't be necessary if the interface and
32// implementation of the media engine were in separate build targets.
33#include "media/engine/webrtcmediaengine.h" // nogncheck
34#include "media/engine/webrtcvideodecoderfactory.h" // nogncheck
35#include "media/engine/webrtcvideoencoderfactory.h" // nogncheck
36#include "modules/audio_device/include/audio_device.h" // nogncheck
Sebastian Janssondfce03a2018-05-18 16:05:1037#include "modules/congestion_controller/bbr/bbr_factory.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3138#include "p2p/base/basicpacketsocketfactory.h"
39#include "p2p/client/basicportallocator.h"
40#include "pc/audiotrack.h"
41#include "pc/localaudiosource.h"
42#include "pc/mediastream.h"
43#include "pc/peerconnection.h"
44#include "pc/videocapturertracksource.h"
45#include "pc/videotrack.h"
Sebastian Janssondfce03a2018-05-18 16:05:1046#include "rtc_base/experiments/congestion_controller_experiment.h"
henrike@webrtc.org28e20752013-07-10 00:45:3647
henrike@webrtc.org28e20752013-07-10 00:45:3648namespace webrtc {
49
kwiberg1e4e8cb2017-01-31 09:48:0850rtc::scoped_refptr<PeerConnectionFactoryInterface>
zhihuang38ede132017-06-15 19:52:3251CreateModularPeerConnectionFactory(
gyzhou95aa9642016-12-13 22:06:2652 rtc::Thread* network_thread,
53 rtc::Thread* worker_thread,
54 rtc::Thread* signaling_thread,
zhihuang38ede132017-06-15 19:52:3255 std::unique_ptr<cricket::MediaEngineInterface> media_engine,
56 std::unique_ptr<CallFactoryInterface> call_factory,
57 std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory) {
Benjamin Wright5234a492018-05-29 22:04:3258 PeerConnectionFactoryDependencies dependencies;
59 dependencies.network_thread = network_thread;
60 dependencies.worker_thread = worker_thread;
61 dependencies.signaling_thread = signaling_thread;
62 dependencies.media_engine = std::move(media_engine);
63 dependencies.call_factory = std::move(call_factory);
64 dependencies.event_log_factory = std::move(event_log_factory);
65 return CreateModularPeerConnectionFactory(std::move(dependencies));
Ying Wang0dd1b0a2018-02-20 11:50:2766}
67
68rtc::scoped_refptr<PeerConnectionFactoryInterface>
69CreateModularPeerConnectionFactory(
70 rtc::Thread* network_thread,
71 rtc::Thread* worker_thread,
72 rtc::Thread* signaling_thread,
73 std::unique_ptr<cricket::MediaEngineInterface> media_engine,
74 std::unique_ptr<CallFactoryInterface> call_factory,
75 std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory,
Sebastian Janssondfce03a2018-05-18 16:05:1076 std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory,
77 std::unique_ptr<NetworkControllerFactoryInterface>
78 network_controller_factory) {
Benjamin Wright5234a492018-05-29 22:04:3279 PeerConnectionFactoryDependencies dependencies;
80 dependencies.network_thread = network_thread;
81 dependencies.worker_thread = worker_thread;
82 dependencies.signaling_thread = signaling_thread;
83 dependencies.media_engine = std::move(media_engine);
84 dependencies.call_factory = std::move(call_factory);
85 dependencies.event_log_factory = std::move(event_log_factory);
86 dependencies.fec_controller_factory = std::move(fec_controller_factory);
87 dependencies.network_controller_factory =
88 std::move(network_controller_factory);
89 return CreateModularPeerConnectionFactory(std::move(dependencies));
90}
91
92rtc::scoped_refptr<PeerConnectionFactoryInterface>
93CreateModularPeerConnectionFactory(
94 PeerConnectionFactoryDependencies dependencies) {
gyzhou95aa9642016-12-13 22:06:2695 rtc::scoped_refptr<PeerConnectionFactory> pc_factory(
96 new rtc::RefCountedObject<PeerConnectionFactory>(
Benjamin Wright5234a492018-05-29 22:04:3297 std::move(dependencies)));
gyzhou95aa9642016-12-13 22:06:2698 // Call Initialize synchronously but make sure it is executed on
99 // |signaling_thread|.
100 MethodCall0<PeerConnectionFactory, bool> call(
101 pc_factory.get(), &PeerConnectionFactory::Initialize);
zhihuang38ede132017-06-15 19:52:32102 bool result = call.Marshal(RTC_FROM_HERE, pc_factory->signaling_thread());
gyzhou95aa9642016-12-13 22:06:26103
104 if (!result) {
105 return nullptr;
106 }
zhihuang38ede132017-06-15 19:52:32107 return PeerConnectionFactoryProxy::Create(pc_factory->signaling_thread(),
108 pc_factory);
kwiberg1e4e8cb2017-01-31 09:48:08109}
110
henrike@webrtc.org28e20752013-07-10 00:45:36111PeerConnectionFactory::PeerConnectionFactory(
danilchape9021a32016-05-17 08:52:02112 rtc::Thread* network_thread,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52113 rtc::Thread* worker_thread,
114 rtc::Thread* signaling_thread,
zhihuang38ede132017-06-15 19:52:32115 std::unique_ptr<cricket::MediaEngineInterface> media_engine,
116 std::unique_ptr<webrtc::CallFactoryInterface> call_factory,
117 std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory)
Ying Wang0dd1b0a2018-02-20 11:50:27118 : PeerConnectionFactory(network_thread,
119 worker_thread,
120 signaling_thread,
121 std::move(media_engine),
122 std::move(call_factory),
123 std::move(event_log_factory),
Sebastian Janssondfce03a2018-05-18 16:05:10124 nullptr,
Ying Wang0dd1b0a2018-02-20 11:50:27125 nullptr) {}
126
127PeerConnectionFactory::PeerConnectionFactory(
128 rtc::Thread* network_thread,
129 rtc::Thread* worker_thread,
130 rtc::Thread* signaling_thread,
131 std::unique_ptr<cricket::MediaEngineInterface> media_engine,
132 std::unique_ptr<webrtc::CallFactoryInterface> call_factory,
133 std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory,
Sebastian Janssondfce03a2018-05-18 16:05:10134 std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory,
135 std::unique_ptr<NetworkControllerFactoryInterface>
136 network_controller_factory)
zhihuang38ede132017-06-15 19:52:32137 : wraps_current_thread_(false),
danilchape9021a32016-05-17 08:52:02138 network_thread_(network_thread),
henrike@webrtc.org28e20752013-07-10 00:45:36139 worker_thread_(worker_thread),
danilchape9021a32016-05-17 08:52:02140 signaling_thread_(signaling_thread),
zhihuang38ede132017-06-15 19:52:32141 media_engine_(std::move(media_engine)),
142 call_factory_(std::move(call_factory)),
Ying Wang0dd1b0a2018-02-20 11:50:27143 event_log_factory_(std::move(event_log_factory)),
Sebastian Janssondfce03a2018-05-18 16:05:10144 fec_controller_factory_(std::move(fec_controller_factory)),
145 injected_network_controller_factory_(
146 std::move(network_controller_factory)),
147 bbr_network_controller_factory_(
148 rtc::MakeUnique<BbrNetworkControllerFactory>()) {
zhihuang38ede132017-06-15 19:52:32149 if (!network_thread_) {
150 owned_network_thread_ = rtc::Thread::CreateWithSocketServer();
Sebastian Jansson13f35ec32017-11-13 09:54:45151 owned_network_thread_->SetName("pc_network_thread", nullptr);
zhihuang38ede132017-06-15 19:52:32152 owned_network_thread_->Start();
153 network_thread_ = owned_network_thread_.get();
154 }
155
156 if (!worker_thread_) {
157 owned_worker_thread_ = rtc::Thread::Create();
Sebastian Jansson13f35ec32017-11-13 09:54:45158 owned_worker_thread_->SetName("pc_worker_thread", nullptr);
zhihuang38ede132017-06-15 19:52:32159 owned_worker_thread_->Start();
160 worker_thread_ = owned_worker_thread_.get();
161 }
162
163 if (!signaling_thread_) {
164 signaling_thread_ = rtc::Thread::Current();
165 if (!signaling_thread_) {
166 // If this thread isn't already wrapped by an rtc::Thread, create a
167 // wrapper and own it in this class.
168 signaling_thread_ = rtc::ThreadManager::Instance()->WrapCurrentThread();
169 wraps_current_thread_ = true;
170 }
171 }
172
Steve Anton36b29d12017-10-30 16:57:42173 // TODO(deadbeef): Currently there is no way to create an external adm in
henrike@webrtc.org28e20752013-07-10 00:45:36174 // libjingle source tree. So we can 't currently assert if this is NULL.
nisseede5da42017-01-12 13:15:36175 // RTC_DCHECK(default_adm != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36176}
177
Benjamin Wright5234a492018-05-29 22:04:32178PeerConnectionFactory::PeerConnectionFactory(
179 PeerConnectionFactoryDependencies dependencies)
180 : PeerConnectionFactory(
181 dependencies.network_thread,
182 dependencies.worker_thread,
183 dependencies.signaling_thread,
184 std::move(dependencies.media_engine),
185 std::move(dependencies.call_factory),
186 std::move(dependencies.event_log_factory),
187 std::move(dependencies.fec_controller_factory),
188 std::move(dependencies.network_controller_factory)) {}
189
henrike@webrtc.org28e20752013-07-10 00:45:36190PeerConnectionFactory::~PeerConnectionFactory() {
henrikg91d6ede2015-09-17 07:24:34191 RTC_DCHECK(signaling_thread_->IsCurrent());
Henrik Boström5e56c592015-08-11 08:33:13192 channel_manager_.reset(nullptr);
jiayl@webrtc.orgd83f4ef2015-03-13 21:26:12193
194 // Make sure |worker_thread_| and |signaling_thread_| outlive
Henrik Boströmcebf0a22016-06-01 13:45:30195 // |default_socket_factory_| and |default_network_manager_|.
deadbeef41b07982015-12-01 23:01:24196 default_socket_factory_ = nullptr;
197 default_network_manager_ = nullptr;
jiayl@webrtc.orgd83f4ef2015-03-13 21:26:12198
zhihuang38ede132017-06-15 19:52:32199 if (wraps_current_thread_)
200 rtc::ThreadManager::Instance()->UnwrapCurrentThread();
henrike@webrtc.org28e20752013-07-10 00:45:36201}
202
203bool PeerConnectionFactory::Initialize() {
henrikg91d6ede2015-09-17 07:24:34204 RTC_DCHECK(signaling_thread_->IsCurrent());
Honghai Zhang82d78622016-05-06 18:29:15205 rtc::InitRandom(rtc::Time32());
henrike@webrtc.org28e20752013-07-10 00:45:36206
deadbeef41b07982015-12-01 23:01:24207 default_network_manager_.reset(new rtc::BasicNetworkManager());
208 if (!default_network_manager_) {
209 return false;
210 }
211
212 default_socket_factory_.reset(
danilchape9021a32016-05-17 08:52:02213 new rtc::BasicPacketSocketFactory(network_thread_));
deadbeef41b07982015-12-01 23:01:24214 if (!default_socket_factory_) {
215 return false;
216 }
henrike@webrtc.org28e20752013-07-10 00:45:36217
Steve Antonc9e15602017-11-06 23:40:09218 channel_manager_ = rtc::MakeUnique<cricket::ChannelManager>(
219 std::move(media_engine_), rtc::MakeUnique<cricket::RtpDataEngine>(),
220 worker_thread_, network_thread_);
henrika@webrtc.org62f6e752015-02-11 08:38:35221
stefan@webrtc.org85d27942014-06-09 12:51:39222 channel_manager_->SetVideoRtxEnabled(true);
henrike@webrtc.org28e20752013-07-10 00:45:36223 if (!channel_manager_->Init()) {
224 return false;
225 }
jiayl@webrtc.org61e00b02015-03-04 22:17:38226
henrike@webrtc.org28e20752013-07-10 00:45:36227 return true;
228}
229
jbauchcb560652016-08-04 12:20:32230void PeerConnectionFactory::SetOptions(const Options& options) {
231 options_ = options;
jbauchcb560652016-08-04 12:20:32232}
233
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52234rtc::scoped_refptr<AudioSourceInterface>
perkj@webrtc.org81134d02015-01-12 08:30:16235PeerConnectionFactory::CreateAudioSource(
henrike@webrtc.org28e20752013-07-10 00:45:36236 const MediaConstraintsInterface* constraints) {
henrikg91d6ede2015-09-17 07:24:34237 RTC_DCHECK(signaling_thread_->IsCurrent());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52238 rtc::scoped_refptr<LocalAudioSource> source(
deadbeef757146b2017-02-11 05:26:48239 LocalAudioSource::Create(constraints));
henrike@webrtc.org28e20752013-07-10 00:45:36240 return source;
241}
242
htaa2a49d92016-03-04 10:51:39243rtc::scoped_refptr<AudioSourceInterface>
244PeerConnectionFactory::CreateAudioSource(const cricket::AudioOptions& options) {
245 RTC_DCHECK(signaling_thread_->IsCurrent());
246 rtc::scoped_refptr<LocalAudioSource> source(
deadbeef757146b2017-02-11 05:26:48247 LocalAudioSource::Create(&options));
htaa2a49d92016-03-04 10:51:39248 return source;
249}
250
perkja3ede6c2016-03-08 00:27:48251rtc::scoped_refptr<VideoTrackSourceInterface>
perkj@webrtc.org81134d02015-01-12 08:30:16252PeerConnectionFactory::CreateVideoSource(
deadbeef112b2e92017-02-11 04:13:37253 std::unique_ptr<cricket::VideoCapturer> capturer,
henrike@webrtc.org28e20752013-07-10 00:45:36254 const MediaConstraintsInterface* constraints) {
henrikg91d6ede2015-09-17 07:24:34255 RTC_DCHECK(signaling_thread_->IsCurrent());
perkja3ede6c2016-03-08 00:27:48256 rtc::scoped_refptr<VideoTrackSourceInterface> source(
deadbeef112b2e92017-02-11 04:13:37257 VideoCapturerTrackSource::Create(worker_thread_, std::move(capturer),
258 constraints, false));
nisse5b68ab52016-04-07 14:45:54259 return VideoTrackSourceProxy::Create(signaling_thread_, worker_thread_,
260 source);
henrike@webrtc.org28e20752013-07-10 00:45:36261}
262
perkja3ede6c2016-03-08 00:27:48263rtc::scoped_refptr<VideoTrackSourceInterface>
deadbeef112b2e92017-02-11 04:13:37264PeerConnectionFactory::CreateVideoSource(
265 std::unique_ptr<cricket::VideoCapturer> capturer) {
htaa2a49d92016-03-04 10:51:39266 RTC_DCHECK(signaling_thread_->IsCurrent());
perkja3ede6c2016-03-08 00:27:48267 rtc::scoped_refptr<VideoTrackSourceInterface> source(
deadbeef112b2e92017-02-11 04:13:37268 VideoCapturerTrackSource::Create(worker_thread_, std::move(capturer),
269 false));
nisse5b68ab52016-04-07 14:45:54270 return VideoTrackSourceProxy::Create(signaling_thread_, worker_thread_,
271 source);
htaa2a49d92016-03-04 10:51:39272}
273
ivocd66b44d2016-01-15 11:06:36274bool PeerConnectionFactory::StartAecDump(rtc::PlatformFile file,
275 int64_t max_size_bytes) {
henrikg91d6ede2015-09-17 07:24:34276 RTC_DCHECK(signaling_thread_->IsCurrent());
ivocd66b44d2016-01-15 11:06:36277 return channel_manager_->StartAecDump(file, max_size_bytes);
wu@webrtc.orga9890802013-12-13 00:21:03278}
279
ivoc797ef122015-10-22 10:25:41280void PeerConnectionFactory::StopAecDump() {
281 RTC_DCHECK(signaling_thread_->IsCurrent());
282 channel_manager_->StopAecDump();
283}
284
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52285rtc::scoped_refptr<PeerConnectionInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36286PeerConnectionFactory::CreatePeerConnection(
htaa2a49d92016-03-04 10:51:39287 const PeerConnectionInterface::RTCConfiguration& configuration_in,
henrike@webrtc.org28e20752013-07-10 00:45:36288 const MediaConstraintsInterface* constraints,
kwibergd1fe2812016-04-27 13:47:29289 std::unique_ptr<cricket::PortAllocator> allocator,
Henrik Boströmd03c23b2016-06-01 09:44:18290 std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
deadbeef41b07982015-12-01 23:01:24291 PeerConnectionObserver* observer) {
292 RTC_DCHECK(signaling_thread_->IsCurrent());
293
htaa2a49d92016-03-04 10:51:39294 // We merge constraints and configuration into a single configuration.
295 PeerConnectionInterface::RTCConfiguration configuration = configuration_in;
296 CopyConstraintsIntoRtcConfiguration(constraints, &configuration);
297
298 return CreatePeerConnection(configuration, std::move(allocator),
Henrik Boströmd03c23b2016-06-01 09:44:18299 std::move(cert_generator), observer);
htaa2a49d92016-03-04 10:51:39300}
301
302rtc::scoped_refptr<PeerConnectionInterface>
303PeerConnectionFactory::CreatePeerConnection(
304 const PeerConnectionInterface::RTCConfiguration& configuration,
kwibergd1fe2812016-04-27 13:47:29305 std::unique_ptr<cricket::PortAllocator> allocator,
Henrik Boströmd03c23b2016-06-01 09:44:18306 std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
htaa2a49d92016-03-04 10:51:39307 PeerConnectionObserver* observer) {
Benjamin Wright6f7e6d62018-05-02 20:46:31308 // Convert the legacy API into the new depnedency structure.
309 PeerConnectionDependencies dependencies(observer);
310 dependencies.allocator = std::move(allocator);
311 dependencies.cert_generator = std::move(cert_generator);
312 // Pass that into the new API.
313 return CreatePeerConnection(configuration, std::move(dependencies));
314}
315
316rtc::scoped_refptr<PeerConnectionInterface>
317PeerConnectionFactory::CreatePeerConnection(
318 const PeerConnectionInterface::RTCConfiguration& configuration,
319 PeerConnectionDependencies dependencies) {
htaa2a49d92016-03-04 10:51:39320 RTC_DCHECK(signaling_thread_->IsCurrent());
321
Benjamin Wright6f7e6d62018-05-02 20:46:31322 // Set internal defaults if optional dependencies are not set.
323 if (!dependencies.cert_generator) {
324 dependencies.cert_generator = rtc::MakeUnique<rtc::RTCCertificateGenerator>(
325 signaling_thread_, network_thread_);
deadbeef41b07982015-12-01 23:01:24326 }
Benjamin Wright6f7e6d62018-05-02 20:46:31327 if (!dependencies.allocator) {
328 dependencies.allocator.reset(new cricket::BasicPortAllocator(
Jonas Orelandbdcee282017-10-10 12:01:40329 default_network_manager_.get(), default_socket_factory_.get(),
330 configuration.turn_customizer));
jonasoc251cb12017-08-29 10:20:58331 }
Benjamin Wright6f7e6d62018-05-02 20:46:31332
jonasoc251cb12017-08-29 10:20:58333 network_thread_->Invoke<void>(
Benjamin Wright6f7e6d62018-05-02 20:46:31334 RTC_FROM_HERE,
335 rtc::Bind(&cricket::PortAllocator::SetNetworkIgnoreMask,
336 dependencies.allocator.get(), options_.network_ignore_mask));
jonasoc251cb12017-08-29 10:20:58337
eladalon393a9f62017-09-05 11:30:30338 std::unique_ptr<RtcEventLog> event_log =
eladalon248fd4f2017-09-06 12:18:15339 worker_thread_->Invoke<std::unique_ptr<RtcEventLog>>(
340 RTC_FROM_HERE,
341 rtc::Bind(&PeerConnectionFactory::CreateRtcEventLog_w, this));
maxmorine9ef9072017-08-29 11:49:00342
zhihuang38ede132017-06-15 19:52:32343 std::unique_ptr<Call> call = worker_thread_->Invoke<std::unique_ptr<Call>>(
344 RTC_FROM_HERE,
345 rtc::Bind(&PeerConnectionFactory::CreateCall_w, this, event_log.get()));
346
deadbeef41b07982015-12-01 23:01:24347 rtc::scoped_refptr<PeerConnection> pc(
zhihuang38ede132017-06-15 19:52:32348 new rtc::RefCountedObject<PeerConnection>(this, std::move(event_log),
349 std::move(call)));
htaa2a49d92016-03-04 10:51:39350
Benjamin Wrightcab588882018-05-02 22:12:47351 if (!pc->Initialize(configuration, std::move(dependencies))) {
deadbeef41b07982015-12-01 23:01:24352 return nullptr;
353 }
354 return PeerConnectionProxy::Create(signaling_thread(), pc);
355}
356
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52357rtc::scoped_refptr<MediaStreamInterface>
Seth Hampson845e8782018-03-02 19:34:10358PeerConnectionFactory::CreateLocalMediaStream(const std::string& stream_id) {
henrikg91d6ede2015-09-17 07:24:34359 RTC_DCHECK(signaling_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36360 return MediaStreamProxy::Create(signaling_thread_,
Seth Hampson845e8782018-03-02 19:34:10361 MediaStream::Create(stream_id));
henrike@webrtc.org28e20752013-07-10 00:45:36362}
363
perkja3ede6c2016-03-08 00:27:48364rtc::scoped_refptr<VideoTrackInterface> PeerConnectionFactory::CreateVideoTrack(
henrike@webrtc.org28e20752013-07-10 00:45:36365 const std::string& id,
perkja3ede6c2016-03-08 00:27:48366 VideoTrackSourceInterface* source) {
henrikg91d6ede2015-09-17 07:24:34367 RTC_DCHECK(signaling_thread_->IsCurrent());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52368 rtc::scoped_refptr<VideoTrackInterface> track(
perkj773be362017-08-01 06:22:01369 VideoTrack::Create(id, source, worker_thread_));
nisse5b68ab52016-04-07 14:45:54370 return VideoTrackProxy::Create(signaling_thread_, worker_thread_, track);
henrike@webrtc.org28e20752013-07-10 00:45:36371}
372
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52373rtc::scoped_refptr<AudioTrackInterface>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01374PeerConnectionFactory::CreateAudioTrack(const std::string& id,
375 AudioSourceInterface* source) {
henrikg91d6ede2015-09-17 07:24:34376 RTC_DCHECK(signaling_thread_->IsCurrent());
tommi6eca7e32015-12-15 12:27:11377 rtc::scoped_refptr<AudioTrackInterface> track(AudioTrack::Create(id, source));
henrike@webrtc.org28e20752013-07-10 00:45:36378 return AudioTrackProxy::Create(signaling_thread_, track);
379}
380
Steve Antonda6c0952017-10-23 18:41:54381std::unique_ptr<cricket::SctpTransportInternalFactory>
382PeerConnectionFactory::CreateSctpTransportInternalFactory() {
383#ifdef HAVE_SCTP
384 return rtc::MakeUnique<cricket::SctpTransportFactory>(network_thread());
385#else
386 return nullptr;
387#endif
388}
389
nisseeaabdf62017-05-05 09:23:02390cricket::ChannelManager* PeerConnectionFactory::channel_manager() {
391 return channel_manager_.get();
392}
393
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52394rtc::Thread* PeerConnectionFactory::signaling_thread() {
perkj@webrtc.org81134d02015-01-12 08:30:16395 // This method can be called on a different thread when the factory is
396 // created in CreatePeerConnectionFactory().
henrike@webrtc.org28e20752013-07-10 00:45:36397 return signaling_thread_;
398}
399
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52400rtc::Thread* PeerConnectionFactory::worker_thread() {
henrike@webrtc.org28e20752013-07-10 00:45:36401 return worker_thread_;
402}
403
danilchape9021a32016-05-17 08:52:02404rtc::Thread* PeerConnectionFactory::network_thread() {
405 return network_thread_;
406}
407
eladalon248fd4f2017-09-06 12:18:15408std::unique_ptr<RtcEventLog> PeerConnectionFactory::CreateRtcEventLog_w() {
eladalon591753b2017-09-06 19:33:43409 RTC_DCHECK_RUN_ON(worker_thread_);
Elad Alon4a87e1c2017-10-03 14:11:34410 const auto encoding_type = RtcEventLog::EncodingType::Legacy;
411 return event_log_factory_
412 ? event_log_factory_->CreateRtcEventLog(encoding_type)
413 : rtc::MakeUnique<RtcEventLogNullImpl>();
eladalon248fd4f2017-09-06 12:18:15414}
415
zhihuang38ede132017-06-15 19:52:32416std::unique_ptr<Call> PeerConnectionFactory::CreateCall_w(
417 RtcEventLog* event_log) {
eladalon591753b2017-09-06 19:33:43418 RTC_DCHECK_RUN_ON(worker_thread_);
419
zhihuang38ede132017-06-15 19:52:32420 const int kMinBandwidthBps = 30000;
421 const int kStartBandwidthBps = 300000;
422 const int kMaxBandwidthBps = 2000000;
423
424 webrtc::Call::Config call_config(event_log);
425 if (!channel_manager_->media_engine() || !call_factory_) {
426 return nullptr;
427 }
428 call_config.audio_state = channel_manager_->media_engine()->GetAudioState();
429 call_config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
430 call_config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
431 call_config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
432
Ying Wang0dd1b0a2018-02-20 11:50:27433 call_config.fec_controller_factory = fec_controller_factory_.get();
434
Sebastian Janssondfce03a2018-05-18 16:05:10435 if (CongestionControllerExperiment::BbrControllerEnabled()) {
436 RTC_LOG(LS_INFO) << "Using BBR network controller factory";
437 call_config.network_controller_factory =
438 bbr_network_controller_factory_.get();
439 } else if (CongestionControllerExperiment::InjectedControllerEnabled()) {
440 RTC_LOG(LS_INFO) << "Using injected network controller factory";
441 call_config.network_controller_factory =
442 injected_network_controller_factory_.get();
443 } else {
444 RTC_LOG(LS_INFO) << "Using default network controller factory";
445 }
446
zhihuang38ede132017-06-15 19:52:32447 return std::unique_ptr<Call>(call_factory_->CreateCall(call_config));
448}
449
henrike@webrtc.org28e20752013-07-10 00:45:36450} // namespace webrtc