Windows + Initial WebRTC sys & Safe WebRTC + Initial livekit-core

crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.cpp

@@ -0,0 +1,166 @@
+//
+// Created by Théo Monnom on 30/08/2022.
+//
+
+#include "livekit/peer_connection.h"
+#include "libwebrtc-sys/src/peer_connection.rs.h"
+
+namespace livekit {
+
+    inline webrtc::PeerConnectionInterface::RTCOfferAnswerOptions toNativeOfferAnswerOptions(const RTCOfferAnswerOptions& options) {
+        webrtc::PeerConnectionInterface::RTCOfferAnswerOptions rtc_options;
+        rtc_options.offer_to_receive_video =  options.offer_to_receive_video;
+        rtc_options.offer_to_receive_audio =  options.offer_to_receive_audio;
+        rtc_options.voice_activity_detection = options.voice_activity_detection;
+        rtc_options.ice_restart = options.ice_restart;
+        rtc_options.use_rtp_mux = options.use_rtp_mux;
+        rtc_options.raw_packetization_for_video = options.raw_packetization_for_video;
+        rtc_options.num_simulcast_layers = options.num_simulcast_layers;
+        rtc_options.use_obsolete_sctp_sdp = options.use_obsolete_sctp_sdp;
+        return rtc_options;
+    }
+
+    PeerConnection::PeerConnection(rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection,
+                                   std::unique_ptr<NativePeerConnectionObserver> observer) : peer_connection_(
+            std::move(peer_connection)), observer_(std::move(observer)) {
+
+    }
+
+    void PeerConnection::close() {
+        peer_connection_->Close();
+    }
+
+    void PeerConnection::create_offer(std::unique_ptr<NativeCreateSdpObserverHandle> observer_handle, RTCOfferAnswerOptions options) {
+        peer_connection_->CreateOffer(observer_handle->observer.get(), toNativeOfferAnswerOptions(options));
+    }
+
+    void PeerConnection::create_answer(std::unique_ptr<NativeCreateSdpObserverHandle> observer_handle, RTCOfferAnswerOptions options) {
+        peer_connection_->CreateAnswer(observer_handle->observer.get(), toNativeOfferAnswerOptions(options));
+    }
+
+    void PeerConnection::set_local_description(std::unique_ptr<SessionDescription> desc, std::unique_ptr<NativeSetLocalSdpObserverHandle> observer) {
+        peer_connection_->SetLocalDescription(desc->clone()->release(), observer->observer);
+    }
+
+    void PeerConnection::set_remote_description(std::unique_ptr<SessionDescription> desc, std::unique_ptr<NativeSetRemoteSdpObserverHandle> observer) {
+        peer_connection_->SetRemoteDescription(desc->clone()->release(), observer->observer);
+    }
+
+    /* Observer */
+
+    NativePeerConnectionObserver::NativePeerConnectionObserver(rust::Box<PeerConnectionObserverWrapper> observer) : observer_(std::move(observer)) {
+
+    }
+
+    void NativePeerConnectionObserver::OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) {
+        observer_->on_signaling_change(static_cast<SignalingState>(new_state));
+    }
+
+    void NativePeerConnectionObserver::OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+        observer_->on_add_stream(std::make_unique<MediaStreamInterface>(stream));
+    }
+
+    void NativePeerConnectionObserver::OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+        observer_->on_remove_stream(std::make_unique<MediaStreamInterface>(stream));
+    }
+
+    void NativePeerConnectionObserver::OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
+        observer_->on_data_channel(std::make_unique<DataChannel>(data_channel));
+    }
+
+    void NativePeerConnectionObserver::OnRenegotiationNeeded() {
+        observer_->on_renegotiation_needed();
+    }
+
+    void NativePeerConnectionObserver::OnNegotiationNeededEvent(uint32_t event_id) {
+        observer_->on_negotiation_needed_event(event_id);
+    }
+
+    void
+    NativePeerConnectionObserver::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) {
+        observer_->on_ice_connection_change(static_cast<IceConnectionState>(new_state));
+    }
+
+    void NativePeerConnectionObserver::OnStandardizedIceConnectionChange(
+            webrtc::PeerConnectionInterface::IceConnectionState new_state) {
+        observer_->on_standardized_ice_connection_change(static_cast<IceConnectionState>(new_state));
+    }
+
+    void
+    NativePeerConnectionObserver::OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state) {
+        observer_->on_connection_change(static_cast<PeerConnectionState>(new_state));
+    }
+
+    void
+    NativePeerConnectionObserver::OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) {
+        observer_->on_ice_gathering_change(static_cast<IceGatheringState>(new_state));
+    }
+
+    void NativePeerConnectionObserver::OnIceCandidate(const webrtc::IceCandidateInterface *candidate) {
+        auto new_candidate = webrtc::CreateIceCandidate(candidate->sdp_mid(), candidate->sdp_mline_index(),
+                                                        candidate->candidate());
+        observer_->on_ice_candidate(std::make_unique<IceCandidate>(std::move(new_candidate)));
+    }
+
+    void NativePeerConnectionObserver::OnIceCandidateError(const std::string &address, int port, const std::string &url,
+                                                           int error_code, const std::string &error_text) {
+        observer_->on_ice_candidate_error(address, port, url, error_code, error_text);
+    }
+
+    void NativePeerConnectionObserver::OnIceCandidatesRemoved(const std::vector<cricket::Candidate> &candidates) {
+        rust::Vec<CandidatePtr> vec;
+
+        for (const auto &item: candidates) {
+            vec.push_back(CandidatePtr{
+                    std::make_unique<Candidate>(item)
+            });
+        }
+
+        observer_->on_ice_candidates_removed(std::move(vec));
+    }
+
+    void NativePeerConnectionObserver::OnIceConnectionReceivingChange(bool receiving) {
+        observer_->on_ice_connection_receiving_change(receiving);
+    }
+
+    void
+    NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged(const cricket::CandidatePairChangeEvent &event) {
+        CandidatePairChangeEvent e;
+        e.selected_candidate_pair.local = std::make_unique<Candidate>(event.selected_candidate_pair.local);
+        e.selected_candidate_pair.remote = std::make_unique<Candidate>(event.selected_candidate_pair.remote);
+        e.last_data_received_ms = event.last_data_received_ms;
+        e.reason = event.reason;
+        e.estimated_disconnected_time_ms = event.estimated_disconnected_time_ms;
+
+        observer_->on_ice_selected_candidate_pair_changed(std::move(e));
+    }
+
+    void NativePeerConnectionObserver::OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+                                                  const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>> &streams) {
+        rust::Vec<MediaStreamPtr> vec;
+
+        for (const auto &item: streams) {
+            vec.push_back(MediaStreamPtr{
+                    std::make_unique<MediaStreamInterface>(item)
+            });
+        }
+
+        observer_->on_add_track(std::make_unique<RtpReceiver>(receiver), std::move(vec));
+    }
+
+    void NativePeerConnectionObserver::OnTrack(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+        observer_->on_track(std::make_unique<RtpTransceiver>(transceiver));
+    }
+
+    void NativePeerConnectionObserver::OnRemoveTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) {
+        observer_->on_remove_track(std::make_unique<RtpReceiver>(receiver));
+    }
+
+    void NativePeerConnectionObserver::OnInterestingUsage(int usage_pattern) {
+        observer_->on_interesting_usage(usage_pattern);
+    }
+
+    std::unique_ptr<NativePeerConnectionObserver> create_native_peer_connection_observer(rust::Box<PeerConnectionObserverWrapper> observer) {
+        return std::make_unique<NativePeerConnectionObserver>(std::move(observer));
+    }
+} // livekit