blob: ff8098cd57a277235a9cd72e01823503c740efda [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001/*
kjellanderb24317b2016-02-10 07:54:43 -08002 * Copyright 2004 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003 *
kjellanderb24317b2016-02-10 07:54:43 -08004 * 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:36 +00009 */
10
Henrik Kjellander15583c12016-02-10 10:53:12 +010011#include "webrtc/api/peerconnectionfactory.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000012
kwiberg0eb15ed2015-12-17 03:04:15 -080013#include <utility>
14
Henrik Kjellander15583c12016-02-10 10:53:12 +010015#include "webrtc/api/audiotrack.h"
16#include "webrtc/api/localaudiosource.h"
htaa2a49d92016-03-04 02:51:39 -080017#include "webrtc/api/mediaconstraintsinterface.h"
Henrik Kjellander15583c12016-02-10 10:53:12 +010018#include "webrtc/api/mediastream.h"
19#include "webrtc/api/mediastreamproxy.h"
20#include "webrtc/api/mediastreamtrackproxy.h"
21#include "webrtc/api/peerconnection.h"
22#include "webrtc/api/peerconnectionfactoryproxy.h"
23#include "webrtc/api/peerconnectionproxy.h"
perkja3ede6c2016-03-08 01:27:48 +010024#include "webrtc/api/videocapturertracksource.h"
Henrik Kjellander15583c12016-02-10 10:53:12 +010025#include "webrtc/api/videosourceproxy.h"
26#include "webrtc/api/videotrack.h"
jiayl@webrtc.org3987b6d2014-09-24 17:14:05 +000027#include "webrtc/base/bind.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010028#include "webrtc/media/engine/webrtcmediaengine.h"
29#include "webrtc/media/engine/webrtcvideodecoderfactory.h"
30#include "webrtc/media/engine/webrtcvideoencoderfactory.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000031#include "webrtc/modules/audio_device/include/audio_device.h"
deadbeef41b07982015-12-01 15:01:24 -080032#include "webrtc/p2p/base/basicpacketsocketfactory.h"
33#include "webrtc/p2p/client/basicportallocator.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000034
henrike@webrtc.org28e20752013-07-10 00:45:36 +000035namespace webrtc {
36
Henrik Boström5e56c592015-08-11 10:33:13 +020037namespace {
38
39// Passes down the calls to |store_|. See usage in CreatePeerConnection.
40class DtlsIdentityStoreWrapper : public DtlsIdentityStoreInterface {
41 public:
42 DtlsIdentityStoreWrapper(
43 const rtc::scoped_refptr<RefCountedDtlsIdentityStore>& store)
44 : store_(store) {
henrikg91d6ede2015-09-17 00:24:34 -070045 RTC_DCHECK(store_);
Henrik Boström5e56c592015-08-11 10:33:13 +020046 }
47
48 void RequestIdentity(
hbos52913932016-03-07 15:14:40 -080049 const rtc::KeyParams& key_params,
50 const rtc::Optional<uint64_t>& expires_ms,
Henrik Boström5e56c592015-08-11 10:33:13 +020051 const rtc::scoped_refptr<webrtc::DtlsIdentityRequestObserver>&
52 observer) override {
hbos52913932016-03-07 15:14:40 -080053 store_->RequestIdentity(key_params, expires_ms, observer);
Henrik Boström5e56c592015-08-11 10:33:13 +020054 }
55
56 private:
57 rtc::scoped_refptr<RefCountedDtlsIdentityStore> store_;
58};
59
60} // anonymous namespace
61
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000062rtc::scoped_refptr<PeerConnectionFactoryInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +000063CreatePeerConnectionFactory() {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000064 rtc::scoped_refptr<PeerConnectionFactory> pc_factory(
65 new rtc::RefCountedObject<PeerConnectionFactory>());
henrike@webrtc.org28e20752013-07-10 00:45:36 +000066
Taylor Brandstettera8415fe2016-03-23 10:38:07 -070067 RTC_CHECK(rtc::Thread::Current() == pc_factory->signaling_thread());
68 // The signaling thread is the current thread so we can
69 // safely call Initialize directly.
70 if (!pc_factory->Initialize()) {
71 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000072 }
perkj@webrtc.org81134d02015-01-12 08:30:16 +000073 return PeerConnectionFactoryProxy::Create(pc_factory->signaling_thread(),
74 pc_factory);
henrike@webrtc.org28e20752013-07-10 00:45:36 +000075}
76
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000077rtc::scoped_refptr<PeerConnectionFactoryInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +000078CreatePeerConnectionFactory(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000079 rtc::Thread* worker_thread,
80 rtc::Thread* signaling_thread,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000081 AudioDeviceModule* default_adm,
82 cricket::WebRtcVideoEncoderFactory* encoder_factory,
83 cricket::WebRtcVideoDecoderFactory* decoder_factory) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000084 rtc::scoped_refptr<PeerConnectionFactory> pc_factory(
85 new rtc::RefCountedObject<PeerConnectionFactory>(worker_thread,
perkj@webrtc.org81134d02015-01-12 08:30:16 +000086 signaling_thread,
87 default_adm,
88 encoder_factory,
89 decoder_factory));
90
91 // Call Initialize synchronously but make sure its executed on
92 // |signaling_thread|.
93 MethodCall0<PeerConnectionFactory, bool> call(
94 pc_factory.get(),
95 &PeerConnectionFactory::Initialize);
96 bool result = call.Marshal(signaling_thread);
97
98 if (!result) {
Taylor Brandstettera8415fe2016-03-23 10:38:07 -070099 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000100 }
perkj@webrtc.org81134d02015-01-12 08:30:16 +0000101 return PeerConnectionFactoryProxy::Create(signaling_thread, pc_factory);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000102}
103
104PeerConnectionFactory::PeerConnectionFactory()
105 : owns_ptrs_(true),
perkj@webrtc.org81134d02015-01-12 08:30:16 +0000106 wraps_current_thread_(false),
107 signaling_thread_(rtc::ThreadManager::Instance()->CurrentThread()),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000108 worker_thread_(new rtc::Thread) {
perkj@webrtc.org81134d02015-01-12 08:30:16 +0000109 if (!signaling_thread_) {
110 signaling_thread_ = rtc::ThreadManager::Instance()->WrapCurrentThread();
111 wraps_current_thread_ = true;
112 }
113 worker_thread_->Start();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000114}
115
116PeerConnectionFactory::PeerConnectionFactory(
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000117 rtc::Thread* worker_thread,
118 rtc::Thread* signaling_thread,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000119 AudioDeviceModule* default_adm,
120 cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
121 cricket::WebRtcVideoDecoderFactory* video_decoder_factory)
122 : owns_ptrs_(false),
perkj@webrtc.org81134d02015-01-12 08:30:16 +0000123 wraps_current_thread_(false),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000124 signaling_thread_(signaling_thread),
125 worker_thread_(worker_thread),
126 default_adm_(default_adm),
127 video_encoder_factory_(video_encoder_factory),
128 video_decoder_factory_(video_decoder_factory) {
129 ASSERT(worker_thread != NULL);
130 ASSERT(signaling_thread != NULL);
131 // TODO: Currently there is no way creating an external adm in
132 // libjingle source tree. So we can 't currently assert if this is NULL.
133 // ASSERT(default_adm != NULL);
134}
135
136PeerConnectionFactory::~PeerConnectionFactory() {
henrikg91d6ede2015-09-17 00:24:34 -0700137 RTC_DCHECK(signaling_thread_->IsCurrent());
Henrik Boström5e56c592015-08-11 10:33:13 +0200138 channel_manager_.reset(nullptr);
jiayl@webrtc.orgd83f4ef2015-03-13 21:26:12 +0000139
140 // Make sure |worker_thread_| and |signaling_thread_| outlive
deadbeef41b07982015-12-01 15:01:24 -0800141 // |dtls_identity_store_|, |default_socket_factory_| and
142 // |default_network_manager_|.
Henrik Boström5e56c592015-08-11 10:33:13 +0200143 dtls_identity_store_ = nullptr;
deadbeef41b07982015-12-01 15:01:24 -0800144 default_socket_factory_ = nullptr;
145 default_network_manager_ = nullptr;
jiayl@webrtc.orgd83f4ef2015-03-13 21:26:12 +0000146
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000147 if (owns_ptrs_) {
perkj@webrtc.org81134d02015-01-12 08:30:16 +0000148 if (wraps_current_thread_)
149 rtc::ThreadManager::Instance()->UnwrapCurrentThread();
fischman@webrtc.org29540b12014-04-17 22:54:30 +0000150 delete worker_thread_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000151 }
152}
153
154bool PeerConnectionFactory::Initialize() {
henrikg91d6ede2015-09-17 00:24:34 -0700155 RTC_DCHECK(signaling_thread_->IsCurrent());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000156 rtc::InitRandom(rtc::Time());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000157
deadbeef41b07982015-12-01 15:01:24 -0800158 default_network_manager_.reset(new rtc::BasicNetworkManager());
159 if (!default_network_manager_) {
160 return false;
161 }
162
163 default_socket_factory_.reset(
164 new rtc::BasicPacketSocketFactory(worker_thread_));
165 if (!default_socket_factory_) {
166 return false;
167 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000168
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000169 // TODO: Need to make sure only one VoE is created inside
170 // WebRtcMediaEngine.
henrika@webrtc.org62f6e752015-02-11 08:38:35 +0000171 cricket::MediaEngineInterface* media_engine =
172 worker_thread_->Invoke<cricket::MediaEngineInterface*>(rtc::Bind(
173 &PeerConnectionFactory::CreateMediaEngine_w, this));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000174
solenbergfacbbec2015-09-24 00:41:50 -0700175 channel_manager_.reset(
176 new cricket::ChannelManager(media_engine, worker_thread_));
henrika@webrtc.org62f6e752015-02-11 08:38:35 +0000177
stefan@webrtc.org85d27942014-06-09 12:51:39 +0000178 channel_manager_->SetVideoRtxEnabled(true);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000179 if (!channel_manager_->Init()) {
180 return false;
181 }
jiayl@webrtc.org61e00b02015-03-04 22:17:38 +0000182
Henrik Boström5e56c592015-08-11 10:33:13 +0200183 dtls_identity_store_ = new RefCountedDtlsIdentityStore(
184 signaling_thread_, worker_thread_);
jiayl@webrtc.org61e00b02015-03-04 22:17:38 +0000185
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000186 return true;
187}
188
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000189rtc::scoped_refptr<AudioSourceInterface>
perkj@webrtc.org81134d02015-01-12 08:30:16 +0000190PeerConnectionFactory::CreateAudioSource(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000191 const MediaConstraintsInterface* constraints) {
henrikg91d6ede2015-09-17 00:24:34 -0700192 RTC_DCHECK(signaling_thread_->IsCurrent());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000193 rtc::scoped_refptr<LocalAudioSource> source(
wu@webrtc.org97077a32013-10-25 21:18:33 +0000194 LocalAudioSource::Create(options_, constraints));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000195 return source;
196}
197
htaa2a49d92016-03-04 02:51:39 -0800198rtc::scoped_refptr<AudioSourceInterface>
199PeerConnectionFactory::CreateAudioSource(const cricket::AudioOptions& options) {
200 RTC_DCHECK(signaling_thread_->IsCurrent());
201 rtc::scoped_refptr<LocalAudioSource> source(
202 LocalAudioSource::Create(options_, &options));
203 return source;
204}
205
perkja3ede6c2016-03-08 01:27:48 +0100206rtc::scoped_refptr<VideoTrackSourceInterface>
perkj@webrtc.org81134d02015-01-12 08:30:16 +0000207PeerConnectionFactory::CreateVideoSource(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000208 cricket::VideoCapturer* capturer,
209 const MediaConstraintsInterface* constraints) {
henrikg91d6ede2015-09-17 00:24:34 -0700210 RTC_DCHECK(signaling_thread_->IsCurrent());
perkja3ede6c2016-03-08 01:27:48 +0100211 rtc::scoped_refptr<VideoTrackSourceInterface> source(
212 VideoCapturerTrackSource::Create(worker_thread_, capturer, constraints,
213 false));
nisse5b68ab52016-04-07 07:45:54 -0700214 return VideoTrackSourceProxy::Create(signaling_thread_, worker_thread_,
215 source);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000216}
217
perkja3ede6c2016-03-08 01:27:48 +0100218rtc::scoped_refptr<VideoTrackSourceInterface>
htaa2a49d92016-03-04 02:51:39 -0800219PeerConnectionFactory::CreateVideoSource(cricket::VideoCapturer* capturer) {
220 RTC_DCHECK(signaling_thread_->IsCurrent());
perkja3ede6c2016-03-08 01:27:48 +0100221 rtc::scoped_refptr<VideoTrackSourceInterface> source(
222 VideoCapturerTrackSource::Create(worker_thread_, capturer, false));
nisse5b68ab52016-04-07 07:45:54 -0700223 return VideoTrackSourceProxy::Create(signaling_thread_, worker_thread_,
224 source);
htaa2a49d92016-03-04 02:51:39 -0800225}
226
ivocd66b44d2016-01-15 03:06:36 -0800227bool PeerConnectionFactory::StartAecDump(rtc::PlatformFile file,
228 int64_t max_size_bytes) {
henrikg91d6ede2015-09-17 00:24:34 -0700229 RTC_DCHECK(signaling_thread_->IsCurrent());
ivocd66b44d2016-01-15 03:06:36 -0800230 return channel_manager_->StartAecDump(file, max_size_bytes);
wu@webrtc.orga9890802013-12-13 00:21:03 +0000231}
232
ivoc797ef122015-10-22 03:25:41 -0700233void PeerConnectionFactory::StopAecDump() {
234 RTC_DCHECK(signaling_thread_->IsCurrent());
235 channel_manager_->StopAecDump();
236}
237
ivoc112a3d82015-10-16 02:22:18 -0700238bool PeerConnectionFactory::StartRtcEventLog(rtc::PlatformFile file) {
239 RTC_DCHECK(signaling_thread_->IsCurrent());
240 return channel_manager_->StartRtcEventLog(file);
241}
242
243void PeerConnectionFactory::StopRtcEventLog() {
244 RTC_DCHECK(signaling_thread_->IsCurrent());
245 channel_manager_->StopRtcEventLog();
246}
247
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000248rtc::scoped_refptr<PeerConnectionInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000249PeerConnectionFactory::CreatePeerConnection(
htaa2a49d92016-03-04 02:51:39 -0800250 const PeerConnectionInterface::RTCConfiguration& configuration_in,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000251 const MediaConstraintsInterface* constraints,
kwibergd1fe2812016-04-27 06:47:29 -0700252 std::unique_ptr<cricket::PortAllocator> allocator,
253 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
deadbeef41b07982015-12-01 15:01:24 -0800254 PeerConnectionObserver* observer) {
255 RTC_DCHECK(signaling_thread_->IsCurrent());
256
htaa2a49d92016-03-04 02:51:39 -0800257 // We merge constraints and configuration into a single configuration.
258 PeerConnectionInterface::RTCConfiguration configuration = configuration_in;
259 CopyConstraintsIntoRtcConfiguration(constraints, &configuration);
260
261 return CreatePeerConnection(configuration, std::move(allocator),
262 std::move(dtls_identity_store), observer);
263}
264
265rtc::scoped_refptr<PeerConnectionInterface>
266PeerConnectionFactory::CreatePeerConnection(
267 const PeerConnectionInterface::RTCConfiguration& configuration,
kwibergd1fe2812016-04-27 06:47:29 -0700268 std::unique_ptr<cricket::PortAllocator> allocator,
269 std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
htaa2a49d92016-03-04 02:51:39 -0800270 PeerConnectionObserver* observer) {
271 RTC_DCHECK(signaling_thread_->IsCurrent());
272
deadbeef41b07982015-12-01 15:01:24 -0800273 if (!dtls_identity_store.get()) {
274 // Because |pc|->Initialize takes ownership of the store we need a new
275 // wrapper object that can be deleted without deleting the underlying
276 // |dtls_identity_store_|, protecting it from being deleted multiple times.
277 dtls_identity_store.reset(
278 new DtlsIdentityStoreWrapper(dtls_identity_store_));
279 }
280
281 if (!allocator) {
282 allocator.reset(new cricket::BasicPortAllocator(
283 default_network_manager_.get(), default_socket_factory_.get()));
284 }
Taylor Brandstetter0c7e9f52015-12-29 14:14:52 -0800285 allocator->SetNetworkIgnoreMask(options_.network_ignore_mask);
deadbeef41b07982015-12-01 15:01:24 -0800286
287 rtc::scoped_refptr<PeerConnection> pc(
288 new rtc::RefCountedObject<PeerConnection>(this));
htaa2a49d92016-03-04 02:51:39 -0800289
nissec36b31b2016-04-11 23:25:29 -0700290 if (!pc->Initialize(configuration, std::move(allocator),
deadbeef41b07982015-12-01 15:01:24 -0800291 std::move(dtls_identity_store), observer)) {
292 return nullptr;
293 }
294 return PeerConnectionProxy::Create(signaling_thread(), pc);
295}
296
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000297rtc::scoped_refptr<MediaStreamInterface>
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000298PeerConnectionFactory::CreateLocalMediaStream(const std::string& label) {
henrikg91d6ede2015-09-17 00:24:34 -0700299 RTC_DCHECK(signaling_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000300 return MediaStreamProxy::Create(signaling_thread_,
301 MediaStream::Create(label));
302}
303
perkja3ede6c2016-03-08 01:27:48 +0100304rtc::scoped_refptr<VideoTrackInterface> PeerConnectionFactory::CreateVideoTrack(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000305 const std::string& id,
perkja3ede6c2016-03-08 01:27:48 +0100306 VideoTrackSourceInterface* source) {
henrikg91d6ede2015-09-17 00:24:34 -0700307 RTC_DCHECK(signaling_thread_->IsCurrent());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000308 rtc::scoped_refptr<VideoTrackInterface> track(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000309 VideoTrack::Create(id, source));
nisse5b68ab52016-04-07 07:45:54 -0700310 return VideoTrackProxy::Create(signaling_thread_, worker_thread_, track);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000311}
312
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000313rtc::scoped_refptr<AudioTrackInterface>
pbos@webrtc.orgb5a22b12014-05-13 11:07:01 +0000314PeerConnectionFactory::CreateAudioTrack(const std::string& id,
315 AudioSourceInterface* source) {
henrikg91d6ede2015-09-17 00:24:34 -0700316 RTC_DCHECK(signaling_thread_->IsCurrent());
tommi6eca7e32015-12-15 04:27:11 -0800317 rtc::scoped_refptr<AudioTrackInterface> track(AudioTrack::Create(id, source));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000318 return AudioTrackProxy::Create(signaling_thread_, track);
319}
320
nisse51542be2016-02-12 02:27:06 -0800321webrtc::MediaControllerInterface* PeerConnectionFactory::CreateMediaController(
322 const cricket::MediaConfig& config) const {
henrikg91d6ede2015-09-17 00:24:34 -0700323 RTC_DCHECK(signaling_thread_->IsCurrent());
nisse51542be2016-02-12 02:27:06 -0800324 return MediaControllerInterface::Create(config, worker_thread_,
stefanc1aeaf02015-10-15 07:26:07 -0700325 channel_manager_.get());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000326}
327
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000328rtc::Thread* PeerConnectionFactory::signaling_thread() {
perkj@webrtc.org81134d02015-01-12 08:30:16 +0000329 // This method can be called on a different thread when the factory is
330 // created in CreatePeerConnectionFactory().
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000331 return signaling_thread_;
332}
333
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000334rtc::Thread* PeerConnectionFactory::worker_thread() {
henrikg91d6ede2015-09-17 00:24:34 -0700335 RTC_DCHECK(signaling_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000336 return worker_thread_;
337}
338
henrika@webrtc.org62f6e752015-02-11 08:38:35 +0000339cricket::MediaEngineInterface* PeerConnectionFactory::CreateMediaEngine_w() {
340 ASSERT(worker_thread_ == rtc::Thread::Current());
341 return cricket::WebRtcMediaEngineFactory::Create(
Fredrik Solenbergccb49e72015-05-19 11:37:56 +0200342 default_adm_.get(), video_encoder_factory_.get(),
henrika@webrtc.org62f6e752015-02-11 08:38:35 +0000343 video_decoder_factory_.get());
344}
345
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000346} // namespace webrtc