fork/rust-sdks

git clone https://git.julia.blue/fork/rust-sdks

aoife cassidychore(webrtc-sys): bump to m125_release (#505)a1b926e

livekit/livekit-ffi@0.13.0
5.3 KiB143 linesraw
1/*
2 * Copyright 2023 LiveKit
3 *
4 * Licensed under the Apache License, Version 2.0 (the “License”);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an “AS IS” BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "livekit/peer_connection_factory.h"
18
19#include <memory>
20#include <utility>
21
22#include "api/audio_codecs/builtin_audio_decoder_factory.h"
23#include "api/audio_codecs/builtin_audio_encoder_factory.h"
24#include "api/peer_connection_interface.h"
25#include "api/rtc_error.h"
26#include "api/enable_media.h"
27#include "api/rtc_event_log/rtc_event_log_factory.h"
28#include "api/task_queue/default_task_queue_factory.h"
29#include "api/video_codecs/builtin_video_decoder_factory.h"
30#include "api/video_codecs/builtin_video_encoder_factory.h"
31#include "livekit/audio_device.h"
32#include "livekit/audio_track.h"
33#include "livekit/peer_connection.h"
34#include "livekit/rtc_error.h"
35#include "livekit/rtp_parameters.h"
36#include "livekit/video_decoder_factory.h"
37#include "livekit/video_encoder_factory.h"
38#include "livekit/webrtc.h"
39#include "rtc_base/thread.h"
40#include "webrtc-sys/src/peer_connection.rs.h"
41#include "webrtc-sys/src/peer_connection_factory.rs.h"
42
43namespace livekit {
44
45class PeerConnectionObserver;
46
47PeerConnectionFactory::PeerConnectionFactory(
48    std::shared_ptr<RtcRuntime> rtc_runtime)
49    : rtc_runtime_(rtc_runtime) {
50  RTC_LOG(LS_VERBOSE) << "PeerConnectionFactory::PeerConnectionFactory()";
51
52  webrtc::PeerConnectionFactoryDependencies dependencies;
53  dependencies.network_thread = rtc_runtime_->network_thread();
54  dependencies.worker_thread = rtc_runtime_->worker_thread();
55  dependencies.signaling_thread = rtc_runtime_->signaling_thread();
56  dependencies.socket_factory = rtc_runtime_->network_thread()->socketserver();
57  dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
58  dependencies.event_log_factory = std::make_unique<webrtc::RtcEventLogFactory>();
59  dependencies.trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
60
61  audio_device_ = rtc_runtime_->worker_thread()->BlockingCall([&] {
62    return rtc::make_ref_counted<livekit::AudioDevice>(
63        dependencies.task_queue_factory.get());
64  });
65
66  dependencies.adm = audio_device_;
67
68  dependencies.video_encoder_factory =
69      std::move(std::make_unique<livekit::VideoEncoderFactory>());
70  dependencies.video_decoder_factory =
71      std::move(std::make_unique<livekit::VideoDecoderFactory>());
72  dependencies.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
73  dependencies.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
74  dependencies.audio_processing = webrtc::AudioProcessingBuilder().Create();
75
76  webrtc::EnableMedia(dependencies);
77  peer_factory_ =
78      webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
79
80
81  task_queue_factory_ = dependencies.task_queue_factory.get();
82
83  if (peer_factory_.get() == nullptr) {
84    RTC_LOG_ERR(LS_ERROR) << "Failed to create PeerConnectionFactory";
85    return;
86  }
87}
88
89PeerConnectionFactory::~PeerConnectionFactory() {
90  RTC_LOG(LS_VERBOSE) << "PeerConnectionFactory::~PeerConnectionFactory()";
91
92  peer_factory_ = nullptr;
93  rtc_runtime_->worker_thread()->BlockingCall(
94      [this] { audio_device_ = nullptr; });
95}
96
97std::shared_ptr<PeerConnection> PeerConnectionFactory::create_peer_connection(
98    RtcConfiguration config,
99    rust::Box<PeerConnectionObserverWrapper> observer) const {
100  std::shared_ptr<PeerConnection> pc = std::make_shared<PeerConnection>(
101      rtc_runtime_, peer_factory_, std::move(observer));
102
103  if (!pc->Initialize(to_native_rtc_configuration(config))) {
104    throw std::runtime_error(serialize_error(to_error(webrtc::RTCError(
105        webrtc::RTCErrorType::INTERNAL_ERROR, "failed to initialize pc"))));
106  }
107
108  return pc;
109}
110
111std::shared_ptr<VideoTrack> PeerConnectionFactory::create_video_track(
112    rust::String label,
113    std::shared_ptr<VideoTrackSource> source) const {
114  return std::static_pointer_cast<VideoTrack>(
115      rtc_runtime_->get_or_create_media_stream_track(
116          peer_factory_->CreateVideoTrack(source->get(), label.c_str())));
117}
118
119std::shared_ptr<AudioTrack> PeerConnectionFactory::create_audio_track(
120    rust::String label,
121    std::shared_ptr<AudioTrackSource> source) const {
122  return std::static_pointer_cast<AudioTrack>(
123      rtc_runtime_->get_or_create_media_stream_track(
124          peer_factory_->CreateAudioTrack(label.c_str(), source->get().get())));
125}
126
127RtpCapabilities PeerConnectionFactory::rtp_sender_capabilities(
128    MediaType type) const {
129  return to_rust_rtp_capabilities(peer_factory_->GetRtpSenderCapabilities(
130      static_cast<cricket::MediaType>(type)));
131}
132
133RtpCapabilities PeerConnectionFactory::rtp_receiver_capabilities(
134    MediaType type) const {
135  return to_rust_rtp_capabilities(peer_factory_->GetRtpReceiverCapabilities(
136      static_cast<cricket::MediaType>(type)));
137}
138
139std::shared_ptr<PeerConnectionFactory> create_peer_connection_factory() {
140  return std::make_shared<PeerConnectionFactory>(RtcRuntime::create());
141}
142
143}  // namespace livekit