From e74aac70bb9d6b911cf9ab57dcb6b25be96223a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Monnom?= Date: Tue, 20 Sep 2022 22:47:47 +0200 Subject: [PATCH] Added .clang-format + reformatted code --- .../libwebrtc-sys/.clang-format | 24 ++ .../libwebrtc-sys/include/livekit/candidate.h | 23 +- .../include/livekit/data_channel.h | 67 ++-- .../libwebrtc-sys/include/livekit/jsep.h | 142 ++++---- .../include/livekit/media_stream_interface.h | 24 +- .../include/livekit/peer_connection.h | 160 ++++++--- .../include/livekit/peer_connection_factory.h | 36 +- .../libwebrtc-sys/include/livekit/rtc_error.h | 15 +- .../include/livekit/rtp_receiver.h | 24 +- .../include/livekit/rtp_transceiver.h | 24 +- .../include/livekit/rust_types.h | 29 +- .../libwebrtc-sys/include/livekit/webrtc.h | 31 +- .../libwebrtc-sys/src/candidate.cpp | 7 +- .../libwebrtc-sys/src/candidate.rs | 2 - .../libwebrtc-sys/src/data_channel.cpp | 113 +++--- .../libwebrtc-sys/src/data_channel.rs | 3 +- .../livekit-webrtc/libwebrtc-sys/src/jsep.cpp | 141 ++++---- .../livekit-webrtc/libwebrtc-sys/src/jsep.rs | 6 +- .../src/media_stream_interface.cpp | 8 +- .../src/media_stream_interface.rs | 2 - .../libwebrtc-sys/src/peer_connection.cpp | 329 ++++++++++-------- .../libwebrtc-sys/src/peer_connection.rs | 5 +- .../src/peer_connection_factory.cpp | 140 ++++---- .../src/peer_connection_factory.rs | 23 +- .../libwebrtc-sys/src/rtc_error.cpp | 77 ++-- .../libwebrtc-sys/src/rtc_error.rs | 4 +- .../libwebrtc-sys/src/rtp_receiver.cpp | 8 +- .../libwebrtc-sys/src/rtp_transceiver.cpp | 8 +- .../libwebrtc-sys/src/webrtc.cpp | 25 +- crates/livekit-webrtc/src/data_channel.rs | 10 +- crates/livekit-webrtc/src/jsep.rs | 3 +- crates/livekit-webrtc/src/peer_connection.rs | 40 ++- .../src/peer_connection_factory.rs | 4 +- crates/livekit-webrtc/src/rtc_error.rs | 3 +- crates/livekit-webrtc/src/webrtc.rs | 1 + 35 files changed, 863 insertions(+), 698 deletions(-) create mode 100644 crates/livekit-webrtc/libwebrtc-sys/.clang-format diff --git a/crates/livekit-webrtc/libwebrtc-sys/.clang-format b/crates/livekit-webrtc/libwebrtc-sys/.clang-format new file mode 100644 index 0000000..9fe4cd8 --- /dev/null +++ b/crates/livekit-webrtc/libwebrtc-sys/.clang-format @@ -0,0 +1,24 @@ +# Using the same .clang-format as libwebrtc +# https://github.com/webrtc-sdk/webrtc/blob/m104_release/.clang-format +BasedOnStyle: Chromium +--- +Language: Java +BasedOnStyle: Google +--- +Language: ObjC +BasedOnStyle: Google +BinPackParameters: false +BinPackArguments: false +ColumnLimit: 100 +ObjCBlockIndentWidth: 2 +AllowAllParametersOfDeclarationOnNextLine: true +AlignOperands: false +AlwaysBreakBeforeMultilineStrings: false +AllowShortFunctionsOnASingleLine: Inline +BreakBeforeTernaryOperators: false +IndentWrappedFunctionNames: true +ContinuationIndentWidth: 4 +ObjCSpaceBeforeProtocolList: true +--- +Language: Cpp +IncludeBlocks: Regroup \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/candidate.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/candidate.h index db35237..83749c1 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/candidate.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/candidate.h @@ -6,23 +6,24 @@ #define CLIENT_SDK_NATIVE_CANDIDATE_H #include + #include "api/candidate.h" // cricket::Candidate namespace livekit { - class Candidate { - public: - explicit Candidate(const cricket::Candidate &candidate); +class Candidate { + public: + explicit Candidate(const cricket::Candidate& candidate); - private: - cricket::Candidate candidate_; - }; + private: + cricket::Candidate candidate_; +}; - static std::unique_ptr _unique_candidate(){ - return nullptr; - } +static std::unique_ptr _unique_candidate() { + return nullptr; +} -} // livekit +} // namespace livekit -#endif //CLIENT_SDK_NATIVE_CANDIDATE_H +#endif // CLIENT_SDK_NATIVE_CANDIDATE_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/data_channel.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/data_channel.h index 52c9487..e5be7b6 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/data_channel.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/data_channel.h @@ -6,45 +6,52 @@ #define CLIENT_SDK_NATIVE_DATA_CHANNEL_H #include + #include "api/data_channel_interface.h" -#include "rust_types.h" #include "rust/cxx.h" +#include "rust_types.h" namespace livekit { - using NativeDataChannelInit = webrtc::DataChannelInit; - class NativeDataChannelObserver; +using NativeDataChannelInit = webrtc::DataChannelInit; +class NativeDataChannelObserver; - class DataChannel { - public: - explicit DataChannel(rtc::scoped_refptr data_channel); +class DataChannel { + public: + explicit DataChannel( + rtc::scoped_refptr data_channel); - void register_observer(NativeDataChannelObserver &observer); - void unregister_observer(); - bool send(const DataBuffer& buffer); - rust::String label() const; - void close(); - private: - rtc::scoped_refptr data_channel_; - }; + void register_observer(NativeDataChannelObserver& observer); + void unregister_observer(); + bool send(const DataBuffer& buffer); + rust::String label() const; + void close(); - std::unique_ptr create_data_channel_init(DataChannelInit init); + private: + rtc::scoped_refptr data_channel_; +}; - static std::unique_ptr _unique_data_channel(){ - return nullptr; // Ignore - } +std::unique_ptr create_data_channel_init( + DataChannelInit init); - class NativeDataChannelObserver : public webrtc::DataChannelObserver { - public: - explicit NativeDataChannelObserver(rust::Box observer); +static std::unique_ptr _unique_data_channel() { + return nullptr; // Ignore +} - void OnStateChange() override; - void OnMessage(const webrtc::DataBuffer& buffer) override; - void OnBufferedAmountChange(uint64_t sent_data_size) override; - private: - rust::Box observer_; - }; +class NativeDataChannelObserver : public webrtc::DataChannelObserver { + public: + explicit NativeDataChannelObserver( + rust::Box observer); - std::unique_ptr create_native_data_channel_observer(rust::Box observer); -} // livekit + void OnStateChange() override; + void OnMessage(const webrtc::DataBuffer& buffer) override; + void OnBufferedAmountChange(uint64_t sent_data_size) override; -#endif //CLIENT_SDK_NATIVE_DATA_CHANNEL_H + private: + rust::Box observer_; +}; + +std::unique_ptr create_native_data_channel_observer( + rust::Box observer); +} // namespace livekit + +#endif // CLIENT_SDK_NATIVE_DATA_CHANNEL_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h index 8ca39ce..cf97783 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h @@ -6,93 +6,111 @@ #define CLIENT_SDK_NATIVE_JSEP_H #include + #include "api/jsep.h" +#include "api/ref_counted_base.h" #include "rust/cxx.h" #include "rust_types.h" -#include "api/ref_counted_base.h" namespace livekit { - class IceCandidate { - public: - explicit IceCandidate(std::unique_ptr ice_candidate); +class IceCandidate { + public: + explicit IceCandidate( + std::unique_ptr ice_candidate); - std::unique_ptr release(); - private: - std::unique_ptr ice_candidate_; - }; + std::unique_ptr release(); - static std::unique_ptr _unique_ice_candidate(){ - return nullptr; // Ignore - } + private: + std::unique_ptr ice_candidate_; +}; - class SessionDescription { - public: - explicit SessionDescription(std::unique_ptr session_description); +static std::unique_ptr _unique_ice_candidate() { + return nullptr; // Ignore +} - rust::String stringify() const; - std::unique_ptr clone() const; - std::unique_ptr release(); +class SessionDescription { + public: + explicit SessionDescription( + std::unique_ptr session_description); - private: - std::unique_ptr session_description_; - }; + rust::String stringify() const; + std::unique_ptr clone() const; + std::unique_ptr release(); - static std::unique_ptr _unique_session_description(){ - return nullptr; // Ignore - } + private: + std::unique_ptr session_description_; +}; - // SetCreateSdpObserver +static std::unique_ptr _unique_session_description() { + return nullptr; // Ignore +} - class NativeCreateSdpObserver : public webrtc::CreateSessionDescriptionObserver { - public: - explicit NativeCreateSdpObserver(rust::Box observer); +// SetCreateSdpObserver - void OnSuccess(webrtc::SessionDescriptionInterface* desc) override; - void OnFailure(webrtc::RTCError error) override; - private: - rust::Box observer_; - }; +class NativeCreateSdpObserver + : public webrtc::CreateSessionDescriptionObserver { + public: + explicit NativeCreateSdpObserver( + rust::Box observer); - struct NativeCreateSdpObserverHandle { - rtc::scoped_refptr observer; - }; + void OnSuccess(webrtc::SessionDescriptionInterface* desc) override; + void OnFailure(webrtc::RTCError error) override; - std::unique_ptr create_native_create_sdp_observer(rust::Box observer); + private: + rust::Box observer_; +}; - // SetLocalSdpObserver +struct NativeCreateSdpObserverHandle { + rtc::scoped_refptr observer; +}; - class NativeSetLocalSdpObserver : public webrtc::SetLocalDescriptionObserverInterface{ - public: - explicit NativeSetLocalSdpObserver(rust::Box observer); +std::unique_ptr +create_native_create_sdp_observer(rust::Box observer); - void OnSetLocalDescriptionComplete(webrtc::RTCError error) override; - private: - rust::Box observer_; - }; +// SetLocalSdpObserver - struct NativeSetLocalSdpObserverHandle { - rtc::scoped_refptr observer; - }; +class NativeSetLocalSdpObserver + : public webrtc::SetLocalDescriptionObserverInterface { + public: + explicit NativeSetLocalSdpObserver( + rust::Box observer); - std::unique_ptr create_native_set_local_sdp_observer(rust::Box observer); + void OnSetLocalDescriptionComplete(webrtc::RTCError error) override; - // SetRemoteSdpObserver + private: + rust::Box observer_; +}; - class NativeSetRemoteSdpObserver : public webrtc::SetRemoteDescriptionObserverInterface{ - public: - explicit NativeSetRemoteSdpObserver(rust::Box observer); +struct NativeSetLocalSdpObserverHandle { + rtc::scoped_refptr observer; +}; - void OnSetRemoteDescriptionComplete(webrtc::RTCError error) override; - private: - rust::Box observer_; - }; +std::unique_ptr +create_native_set_local_sdp_observer( + rust::Box observer); - struct NativeSetRemoteSdpObserverHandle { - rtc::scoped_refptr observer; - }; +// SetRemoteSdpObserver - std::unique_ptr create_native_set_remote_sdp_observer(rust::Box observer); -} // livekit +class NativeSetRemoteSdpObserver + : public webrtc::SetRemoteDescriptionObserverInterface { + public: + explicit NativeSetRemoteSdpObserver( + rust::Box observer); -#endif //CLIENT_SDK_NATIVE_JSEP_H + void OnSetRemoteDescriptionComplete(webrtc::RTCError error) override; + + private: + rust::Box observer_; +}; + +struct NativeSetRemoteSdpObserverHandle { + rtc::scoped_refptr observer; +}; + +std::unique_ptr +create_native_set_remote_sdp_observer( + rust::Box observer); +} // namespace livekit + +#endif // CLIENT_SDK_NATIVE_JSEP_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/media_stream_interface.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/media_stream_interface.h index 7356f26..41f71c4 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/media_stream_interface.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/media_stream_interface.h @@ -6,21 +6,23 @@ #define CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H #include + #include "api/media_stream_interface.h" namespace livekit { - class MediaStreamInterface { - public: - explicit MediaStreamInterface(rtc::scoped_refptr stream); +class MediaStreamInterface { + public: + explicit MediaStreamInterface( + rtc::scoped_refptr stream); - private: - rtc::scoped_refptr media_stream_; - }; + private: + rtc::scoped_refptr media_stream_; +}; - static std::unique_ptr _unique_media_stream(){ - return nullptr; // Ignore - } -} // livekit +static std::unique_ptr _unique_media_stream() { + return nullptr; // Ignore +} +} // namespace livekit -#endif //CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H +#endif // CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection.h index ea47b61..7dd3afb 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection.h @@ -6,76 +6,128 @@ #define CLIENT_SDK_NATIVE_PEER_CONNECTION_H #include + #include "api/peer_connection_interface.h" -#include "rust/cxx.h" #include "data_channel.h" #include "jsep.h" +#include "rust/cxx.h" #include "rust_types.h" namespace livekit { - class NativeAddIceCandidateObserver; +class NativeAddIceCandidateObserver; - class PeerConnection { - public: - explicit PeerConnection(rtc::scoped_refptr peer_connection); +class PeerConnection { + public: + explicit PeerConnection( + rtc::scoped_refptr peer_connection); - void create_offer(NativeCreateSdpObserverHandle &observer, RTCOfferAnswerOptions options); - void create_answer(NativeCreateSdpObserverHandle &observer, RTCOfferAnswerOptions options); - void set_local_description(std::unique_ptr desc, NativeSetLocalSdpObserverHandle &observer); - void set_remote_description(std::unique_ptr desc, NativeSetRemoteSdpObserverHandle &observer); - std::unique_ptr create_data_channel(rust::String label, std::unique_ptr init); - void add_ice_candidate(std::unique_ptr candidate, NativeAddIceCandidateObserver &observer); - void close(); + void create_offer(NativeCreateSdpObserverHandle& observer, + RTCOfferAnswerOptions options); + void create_answer(NativeCreateSdpObserverHandle& observer, + RTCOfferAnswerOptions options); + void set_local_description(std::unique_ptr desc, + NativeSetLocalSdpObserverHandle& observer); + void set_remote_description(std::unique_ptr desc, + NativeSetRemoteSdpObserverHandle& observer); + std::unique_ptr create_data_channel( + rust::String label, + std::unique_ptr init); + void add_ice_candidate(std::unique_ptr candidate, + NativeAddIceCandidateObserver& observer); + void close(); - private: - rtc::scoped_refptr peer_connection_; - }; + private: + rtc::scoped_refptr peer_connection_; +}; - static std::unique_ptr _unique_peer_connection() { - return nullptr; // Ignore - } +static std::unique_ptr _unique_peer_connection() { + return nullptr; // Ignore +} - class NativeAddIceCandidateObserver { - public: - explicit NativeAddIceCandidateObserver(rust::Box observer); +class NativeAddIceCandidateObserver { + public: + explicit NativeAddIceCandidateObserver( + rust::Box observer); - void OnComplete(const RTCError &error); - private: - rust::Box observer_; - }; + void OnComplete(const RTCError& error); - std::unique_ptr create_native_add_ice_candidate_observer(rust::Box observer); + private: + rust::Box observer_; +}; - class NativePeerConnectionObserver : public webrtc::PeerConnectionObserver { - public: - explicit NativePeerConnectionObserver(rust::Box observer); +std::unique_ptr +create_native_add_ice_candidate_observer( + rust::Box observer); - void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) override; - void OnAddStream(rtc::scoped_refptr stream) override; - void OnRemoveStream(rtc::scoped_refptr stream) override; - void OnDataChannel(rtc::scoped_refptr data_channel) override; - void OnRenegotiationNeeded() override; - void OnNegotiationNeededEvent(uint32_t event_id) override; - void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) override; - void OnStandardizedIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) override; - void OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state) override; - void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) override; - void OnIceCandidate(const webrtc::IceCandidateInterface *candidate) override; - void OnIceCandidateError(const std::string &address, int port, const std::string &url, int error_code, const std::string &error_text) override; - void OnIceCandidatesRemoved(const std::vector &candidates) override; - void OnIceConnectionReceivingChange(bool receiving) override; - void OnIceSelectedCandidatePairChanged(const cricket::CandidatePairChangeEvent &event) override; - void OnAddTrack(rtc::scoped_refptr receiver, const std::vector> &streams) override; - void OnTrack(rtc::scoped_refptr transceiver) override; - void OnRemoveTrack(rtc::scoped_refptr receiver) override; - void OnInterestingUsage(int usage_pattern) override; +class NativePeerConnectionObserver : public webrtc::PeerConnectionObserver { + public: + explicit NativePeerConnectionObserver( + rust::Box observer); - private: - rust::Box observer_; - }; + void OnSignalingChange( + webrtc::PeerConnectionInterface::SignalingState new_state) override; - std::unique_ptr create_native_peer_connection_observer(rust::Box observer); -} // livekit + void OnAddStream( + rtc::scoped_refptr stream) override; -#endif //CLIENT_SDK_NATIVE_PEER_CONNECTION_H + void OnRemoveStream( + rtc::scoped_refptr stream) override; + void OnDataChannel( + rtc::scoped_refptr data_channel) override; + + void OnRenegotiationNeeded() override; + + void OnNegotiationNeededEvent(uint32_t event_id) override; + + void OnIceConnectionChange( + webrtc::PeerConnectionInterface::IceConnectionState new_state) override; + + void OnStandardizedIceConnectionChange( + webrtc::PeerConnectionInterface::IceConnectionState new_state) override; + + void OnConnectionChange( + webrtc::PeerConnectionInterface::PeerConnectionState new_state) override; + + void OnIceGatheringChange( + webrtc::PeerConnectionInterface::IceGatheringState new_state) override; + + void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override; + + void OnIceCandidateError(const std::string& address, + int port, + const std::string& url, + int error_code, + const std::string& error_text) override; + + void OnIceCandidatesRemoved( + const std::vector& candidates) override; + + void OnIceConnectionReceivingChange(bool receiving) override; + + void OnIceSelectedCandidatePairChanged( + const cricket::CandidatePairChangeEvent& event) override; + + void OnAddTrack( + rtc::scoped_refptr receiver, + const std::vector>& + streams) override; + + void OnTrack( + rtc::scoped_refptr transceiver) override; + + void OnRemoveTrack( + rtc::scoped_refptr receiver) override; + + void OnInterestingUsage(int usage_pattern) override; + + private: + rust::Box observer_; +}; + +std::unique_ptr +create_native_peer_connection_observer( + rust::Box observer); +} // namespace livekit + +#endif // CLIENT_SDK_NATIVE_PEER_CONNECTION_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection_factory.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection_factory.h index a199e60..4749b87 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection_factory.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/peer_connection_factory.h @@ -2,7 +2,6 @@ // Created by Théo Monnom on 03/08/2022. // - #ifndef PEER_CONNECTION_FACTORY_H #define PEER_CONNECTION_FACTORY_H @@ -11,25 +10,28 @@ #include "rust_types.h" namespace livekit { - using NativeRTCConfiguration = webrtc::PeerConnectionInterface::RTCConfiguration; +using NativeRTCConfiguration = + webrtc::PeerConnectionInterface::RTCConfiguration; - class PeerConnectionFactory { - public: - PeerConnectionFactory(); +class PeerConnectionFactory { + public: + PeerConnectionFactory(); - std::unique_ptr create_peer_connection(std::unique_ptr config, NativePeerConnectionObserver &observer) const; + std::unique_ptr create_peer_connection( + std::unique_ptr config, + NativePeerConnectionObserver& observer) const; - private: - std::unique_ptr network_thread_; - std::unique_ptr worker_thread_; - std::unique_ptr signaling_thread_; + private: + std::unique_ptr network_thread_; + std::unique_ptr worker_thread_; + std::unique_ptr signaling_thread_; - rtc::scoped_refptr peer_factory_; - }; + rtc::scoped_refptr peer_factory_; +}; - std::unique_ptr create_peer_connection_factory(); - std::unique_ptr create_rtc_configuration(RTCConfiguration conf); -} // livekit +std::unique_ptr create_peer_connection_factory(); +std::unique_ptr create_rtc_configuration( + RTCConfiguration conf); +} // namespace livekit - -#endif //PEER_CONNECTION_FACTORY_H +#endif // PEER_CONNECTION_FACTORY_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtc_error.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtc_error.h index 47b79f9..91ef258 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtc_error.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtc_error.h @@ -7,19 +7,20 @@ #include "api/rtc_error.h" #include "libwebrtc-sys/src/rtc_error.rs.h" -#include "rust_types.h" #include "rust/cxx.h" +#include "rust_types.h" namespace livekit { - RTCError to_error(const webrtc::RTCError &error); - std::string serialize_error(const RTCError &error); // to be used inside cxx::Exception msg +RTCError to_error(const webrtc::RTCError& error); +std::string serialize_error( + const RTCError& error); // to be used inside cxx::Exception msg #ifdef LIVEKIT_TEST - rust::String serialize_deserialize(); - void throw_error(); +rust::String serialize_deserialize(); +void throw_error(); #endif -} // livekit +} // namespace livekit -#endif //CLIENT_SDK_NATIVE_RTC_ERROR_H +#endif // CLIENT_SDK_NATIVE_RTC_ERROR_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_receiver.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_receiver.h index 03e8e31..636fb79 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_receiver.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_receiver.h @@ -6,21 +6,23 @@ #define CLIENT_SDK_NATIVE_RTP_RECEIVER_H #include + #include "api/rtp_receiver_interface.h" namespace livekit { - class RtpReceiver { - public: - explicit RtpReceiver(rtc::scoped_refptr receiver); +class RtpReceiver { + public: + explicit RtpReceiver( + rtc::scoped_refptr receiver); - private: - rtc::scoped_refptr receiver_; - }; + private: + rtc::scoped_refptr receiver_; +}; - static std::unique_ptr _unique_rtp_receiver(){ - return nullptr; // Ignore - } -} // livekit +static std::unique_ptr _unique_rtp_receiver() { + return nullptr; // Ignore +} +} // namespace livekit -#endif //CLIENT_SDK_NATIVE_RTP_RECEIVER_H +#endif // CLIENT_SDK_NATIVE_RTP_RECEIVER_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_transceiver.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_transceiver.h index f59872f..caa95e1 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_transceiver.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_transceiver.h @@ -6,21 +6,23 @@ #define CLIENT_SDK_NATIVE_RTP_TRANSCEIVER_H #include + #include "api/rtp_transceiver_interface.h" namespace livekit { - class RtpTransceiver { - public: - explicit RtpTransceiver(rtc::scoped_refptr transceiver); +class RtpTransceiver { + public: + explicit RtpTransceiver( + rtc::scoped_refptr transceiver); - private: - rtc::scoped_refptr transceiver_; - }; + private: + rtc::scoped_refptr transceiver_; +}; - static std::unique_ptr _unique_rtp_transceiver(){ - return nullptr; // Ignore - } -} // livekit +static std::unique_ptr _unique_rtp_transceiver() { + return nullptr; // Ignore +} +} // namespace livekit -#endif //CLIENT_SDK_NATIVE_RTP_TRANSCEIVER_H +#endif // CLIENT_SDK_NATIVE_RTP_TRANSCEIVER_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rust_types.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rust_types.h index 9e42d9d..ed61c54 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rust_types.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/rust_types.h @@ -2,26 +2,25 @@ // Created by Théo Monnom on 30/08/2022. // - #ifndef RUST_TYPES_H #define RUST_TYPES_H #include "api/peer_connection_interface.h" namespace livekit { - struct RTCConfiguration; - struct PeerConnectionObserverWrapper; - struct CreateSdpObserverWrapper; - struct SetLocalSdpObserverWrapper; - struct SetRemoteSdpObserverWrapper; - struct DataChannelObserverWrapper; - struct AddIceCandidateObserverWrapper; +struct RTCConfiguration; +struct PeerConnectionObserverWrapper; +struct CreateSdpObserverWrapper; +struct SetLocalSdpObserverWrapper; +struct SetRemoteSdpObserverWrapper; +struct DataChannelObserverWrapper; +struct AddIceCandidateObserverWrapper; - // Shared types - struct RTCOfferAnswerOptions; - struct RTCError; - struct DataChannelInit; - struct DataBuffer; -} +// Shared types +struct RTCOfferAnswerOptions; +struct RTCError; +struct DataChannelInit; +struct DataBuffer; +} // namespace livekit -#endif //RUST_TYPES_H +#endif // RUST_TYPES_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/webrtc.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/webrtc.h index 84667f2..0896939 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/webrtc.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/webrtc.h @@ -5,8 +5,8 @@ #ifndef LIVEKIT_WEBRTC_WEBRTC_H #define LIVEKIT_WEBRTC_WEBRTC_H -#include "rtc_base/ssl_adapter.h" #include "rtc_base/physical_socket_server.h" +#include "rtc_base/ssl_adapter.h" #ifdef WEBRTC_WIN #include "rtc_base/win32_socket_init.h" @@ -14,21 +14,22 @@ namespace livekit { - class RTCRuntime { - public: - RTCRuntime(); - ~RTCRuntime(); +class RTCRuntime { + public: + RTCRuntime(); + ~RTCRuntime(); - RTCRuntime(const RTCRuntime&) = delete; - RTCRuntime& operator=(const RTCRuntime&) = delete; - private: - #ifdef WEBRTC_WIN - rtc::WinsockInitializer winsock_; - #endif - }; + RTCRuntime(const RTCRuntime&) = delete; + RTCRuntime& operator=(const RTCRuntime&) = delete; - std::unique_ptr create_rtc_runtime(); + private: +#ifdef WEBRTC_WIN + rtc::WinsockInitializer winsock_; +#endif +}; -} // livekit +std::unique_ptr create_rtc_runtime(); -#endif //LIVEKIT_WEBRTC_WEBRTC_H +} // namespace livekit + +#endif // LIVEKIT_WEBRTC_WEBRTC_H diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/candidate.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/candidate.cpp index e06e303..970575d 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/candidate.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/candidate.cpp @@ -5,7 +5,6 @@ #include "livekit/candidate.h" namespace livekit { - Candidate::Candidate(const cricket::Candidate &candidate) : candidate_(candidate) { - - } -} // livekit \ No newline at end of file +Candidate::Candidate(const cricket::Candidate& candidate) + : candidate_(candidate) {} +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/candidate.rs b/crates/livekit-webrtc/libwebrtc-sys/src/candidate.rs index 8e442b8..d9e3b46 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/candidate.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/src/candidate.rs @@ -1,5 +1,3 @@ -use cxx::UniquePtr; - #[cxx::bridge(namespace = "livekit")] pub mod ffi { unsafe extern "C++" { diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/data_channel.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/data_channel.cpp index ad031ec..88df064 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/data_channel.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/data_channel.cpp @@ -2,78 +2,83 @@ // Created by Théo Monnom on 01/09/2022. // +#include "livekit/data_channel.h" + #include -#include "livekit/data_channel.h" #include "libwebrtc-sys/src/data_channel.rs.h" namespace livekit { - DataChannel::DataChannel(rtc::scoped_refptr data_channel) : data_channel_(std::move(data_channel)) { +DataChannel::DataChannel( + rtc::scoped_refptr data_channel) + : data_channel_(std::move(data_channel)) {} - } +void DataChannel::register_observer(NativeDataChannelObserver& observer) { + data_channel_->RegisterObserver(&observer); +} - void DataChannel::register_observer(NativeDataChannelObserver &observer) { - data_channel_->RegisterObserver(&observer); - } +void DataChannel::unregister_observer() { + data_channel_->UnregisterObserver(); +} - void DataChannel::unregister_observer() { - data_channel_->UnregisterObserver(); - } +bool DataChannel::send(const DataBuffer& buffer) { + return data_channel_->Send(webrtc::DataBuffer{ + rtc::CopyOnWriteBuffer(buffer.ptr, buffer.len), buffer.binary}); +} - bool DataChannel::send(const DataBuffer &buffer) { - return data_channel_->Send(webrtc::DataBuffer{rtc::CopyOnWriteBuffer(buffer.ptr, buffer.len), buffer.binary }); - } +rust::String DataChannel::label() const { + return data_channel_->label(); +} - rust::String DataChannel::label() const{ - return data_channel_->label(); - } +void DataChannel::close() { + return data_channel_->Close(); +} - void DataChannel::close() { - return data_channel_->Close(); - } +std::unique_ptr create_data_channel_init( + DataChannelInit init) { + auto rtc_init = std::make_unique(); + rtc_init->id = init.id; + rtc_init->negotiated = init.negotiated; + rtc_init->ordered = init.ordered; + rtc_init->protocol = init.protocol.c_str(); + rtc_init->reliable = init.reliable; - std::unique_ptr create_data_channel_init(DataChannelInit init) { - auto rtc_init = std::make_unique(); - rtc_init->id = init.id; - rtc_init->negotiated = init.negotiated; - rtc_init->ordered = init.ordered; - rtc_init->protocol = init.protocol.c_str(); - rtc_init->reliable = init.reliable; + if (init.has_max_retransmit_time) + rtc_init->maxRetransmitTime = init.max_retransmit_time; - if(init.has_max_retransmit_time) - rtc_init->maxRetransmitTime = init.max_retransmit_time; + if (init.has_max_retransmits) + rtc_init->maxRetransmits = init.max_retransmits; - if(init.has_max_retransmits) - rtc_init->maxRetransmits = init.max_retransmits; + if (init.has_priority) + rtc_init->priority = static_cast(init.priority); - if(init.has_priority) - rtc_init->priority = static_cast(init.priority); + return rtc_init; +} - return rtc_init; - } +NativeDataChannelObserver::NativeDataChannelObserver( + rust::Box observer) + : observer_(std::move(observer)) {} - NativeDataChannelObserver::NativeDataChannelObserver(rust::Box observer) : observer_(std::move(observer)){ +void NativeDataChannelObserver::OnStateChange() { + observer_->on_state_change(); +} - } +void NativeDataChannelObserver::OnMessage(const webrtc::DataBuffer& buffer) { + DataBuffer data{}; + data.ptr = buffer.data.data(); + data.len = buffer.data.size(); + data.binary = buffer.binary; + observer_->on_message(data); +} - void NativeDataChannelObserver::OnStateChange() { - observer_->on_state_change(); - } +void NativeDataChannelObserver::OnBufferedAmountChange( + uint64_t sent_data_size) { + observer_->on_buffered_amount_change(sent_data_size); +} - void NativeDataChannelObserver::OnMessage(const webrtc::DataBuffer &buffer) { - DataBuffer data{}; - data.ptr = buffer.data.data(); - data.len = buffer.data.size(); - data.binary = buffer.binary; - observer_->on_message(data); - } - - void NativeDataChannelObserver::OnBufferedAmountChange(uint64_t sent_data_size) { - observer_->on_buffered_amount_change(sent_data_size); - } - - std::unique_ptr create_native_data_channel_observer(rust::Box observer){ - return std::make_unique(std::move(observer)); - } -} // livekit \ No newline at end of file +std::unique_ptr create_native_data_channel_observer( + rust::Box observer) { + return std::make_unique(std::move(observer)); +} +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/data_channel.rs b/crates/livekit-webrtc/libwebrtc-sys/src/data_channel.rs index fc1854b..98b187a 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/data_channel.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/src/data_channel.rs @@ -1,9 +1,7 @@ -use cxx::UniquePtr; use std::slice; #[cxx::bridge(namespace = "livekit")] pub mod ffi { - #[derive(Debug)] #[repr(u32)] pub enum Priority { @@ -83,6 +81,7 @@ pub mod ffi { } unsafe impl Send for ffi::DataChannel {} + unsafe impl Send for ffi::NativeDataChannelObserver {} // DataChannelObserver diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/jsep.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/jsep.cpp index f52a767..e214b42 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/jsep.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/jsep.cpp @@ -2,93 +2,106 @@ // Created by Théo Monnom on 01/09/2022. // +#include "livekit/jsep.h" + #include -#include "livekit/rtc_error.h" -#include "livekit/jsep.h" #include "libwebrtc-sys/src/jsep.rs.h" +#include "livekit/rtc_error.h" #include "rtc_base/ref_counted_object.h" namespace livekit { - IceCandidate::IceCandidate(std::unique_ptr ice_candidate) : ice_candidate_(std::move(ice_candidate)){ +IceCandidate::IceCandidate( + std::unique_ptr ice_candidate) + : ice_candidate_(std::move(ice_candidate)) {} - } +std::unique_ptr IceCandidate::release() { + return std::move(ice_candidate_); +} - std::unique_ptr IceCandidate::release() { - return std::move(ice_candidate_); - } +SessionDescription::SessionDescription( + std::unique_ptr session_description) + : session_description_(std::move(session_description)) {} - SessionDescription::SessionDescription(std::unique_ptr session_description) : session_description_(std::move(session_description)){ +rust::String SessionDescription::stringify() const { + std::string str; + session_description_->ToString(&str); + return rust::String{str}; +} - } +std::unique_ptr SessionDescription::clone() const { + return std::make_unique(session_description_->Clone()); +} - rust::String SessionDescription::stringify() const { - std::string str; - session_description_->ToString(&str); - return rust::String{str}; - } +std::unique_ptr +SessionDescription::release() { + return std::move(session_description_); +} - std::unique_ptr SessionDescription::clone() const { - return std::make_unique(session_description_->Clone()); - } +// CreateSdpObserver - std::unique_ptr SessionDescription::release() { - return std::move(session_description_); - } +NativeCreateSdpObserver::NativeCreateSdpObserver( + rust::Box observer) + : observer_(std::move(observer)) {} - // CreateSdpObserver +void NativeCreateSdpObserver::OnSuccess( + webrtc::SessionDescriptionInterface* desc) { + // We have ownership of desc + observer_->on_success(std::make_unique( + std::unique_ptr(desc))); +} - NativeCreateSdpObserver::NativeCreateSdpObserver( - rust::Box observer) : observer_(std::move(observer)) { +void NativeCreateSdpObserver::OnFailure(webrtc::RTCError error) { + observer_->on_failure(to_error(error)); +} - } +std::unique_ptr +create_native_create_sdp_observer( + rust::Box observer) { + return std::make_unique( + NativeCreateSdpObserverHandle{ + rtc::make_ref_counted(std::move(observer))}); +} - void NativeCreateSdpObserver::OnSuccess(webrtc::SessionDescriptionInterface *desc) { - // We have ownership of desc - observer_->on_success(std::make_unique(std::unique_ptr(desc))); - } +// SetLocalSdpObserver - void NativeCreateSdpObserver::OnFailure(webrtc::RTCError error) { - observer_->on_failure(to_error(error)); - } +NativeSetLocalSdpObserver::NativeSetLocalSdpObserver( + rust::Box observer) + : observer_(std::move(observer)) {} - std::unique_ptr create_native_create_sdp_observer(rust::Box observer){ - return std::make_unique(NativeCreateSdpObserverHandle { - rtc::make_ref_counted(std::move(observer)) - }); - } +void NativeSetLocalSdpObserver::OnSetLocalDescriptionComplete( + webrtc::RTCError error) { + observer_->on_set_local_description_complete(to_error(error)); +} - // SetLocalSdpObserver +std::unique_ptr +create_native_set_local_sdp_observer( + rust::Box observer) { + return std::make_unique( + NativeSetLocalSdpObserverHandle{ + rtc::make_ref_counted( + std::move(observer))}); +} - NativeSetLocalSdpObserver::NativeSetLocalSdpObserver(rust::Box observer) : observer_(std::move(observer)) { +// SetRemoteSdpObserver - } +NativeSetRemoteSdpObserver::NativeSetRemoteSdpObserver( + rust::Box observer) + : observer_(std::move(observer)) {} - void NativeSetLocalSdpObserver::OnSetLocalDescriptionComplete(webrtc::RTCError error) { - observer_->on_set_local_description_complete(to_error(error)); - } +void NativeSetRemoteSdpObserver::OnSetRemoteDescriptionComplete( + webrtc::RTCError error) { + observer_->on_set_remote_description_complete(to_error(error)); +} - std::unique_ptr create_native_set_local_sdp_observer(rust::Box observer){ - return std::make_unique(NativeSetLocalSdpObserverHandle { - rtc::make_ref_counted(std::move(observer)) - }); - } +std::unique_ptr +create_native_set_remote_sdp_observer( + rust::Box observer) { + return std::make_unique( + NativeSetRemoteSdpObserverHandle{ + rtc::make_ref_counted( + std::move(observer))}); +} - // SetRemoteSdpObserver - - NativeSetRemoteSdpObserver::NativeSetRemoteSdpObserver(rust::Box observer) : observer_(std::move(observer)) { - - } - - void NativeSetRemoteSdpObserver::OnSetRemoteDescriptionComplete(webrtc::RTCError error) { - observer_->on_set_remote_description_complete(to_error(error)); - } - - std::unique_ptr create_native_set_remote_sdp_observer(rust::Box observer){ - return std::make_unique(NativeSetRemoteSdpObserverHandle { - rtc::make_ref_counted(std::move(observer)) - }); - } - -} // livekit \ No newline at end of file +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs b/crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs index 1388e8c..f752f99 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs @@ -1,11 +1,11 @@ -use cxx::UniquePtr; use std::fmt::{Debug, Formatter}; +use cxx::UniquePtr; + use crate::rtc_error::ffi::RTCError; #[cxx::bridge(namespace = "livekit")] pub mod ffi { - extern "Rust" { type CreateSdpObserverWrapper; fn on_success( @@ -46,7 +46,7 @@ pub mod ffi { ) -> UniquePtr; fn _unique_ice_candidate() -> UniquePtr; // Ignore - fn _unique_session_description() -> UniquePtr; // Ignore + fn _unique_session_description() -> UniquePtr; // Ignore } } diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.cpp index c8c9a5a..8f5936c 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.cpp @@ -6,7 +6,7 @@ namespace livekit { - MediaStreamInterface::MediaStreamInterface(rtc::scoped_refptr stream) : media_stream_(std::move(stream)) { - - } -} // livekit \ No newline at end of file +MediaStreamInterface::MediaStreamInterface( + rtc::scoped_refptr stream) + : media_stream_(std::move(stream)) {} +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs b/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs index 5ae33c8..1999583 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs @@ -1,5 +1,3 @@ -use cxx::UniquePtr; - #[cxx::bridge(namespace = "livekit")] pub mod ffi { unsafe extern "C++" { diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.cpp index 732f52b..3b18976 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.cpp @@ -3,193 +3,234 @@ // #include "livekit/peer_connection.h" + #include "libwebrtc-sys/src/peer_connection.rs.h" #include "livekit/rtc_error.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; - } +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 peer_connection) : peer_connection_(std::move(peer_connection)) { +PeerConnection::PeerConnection( + rtc::scoped_refptr peer_connection) + : peer_connection_(std::move(peer_connection)) {} - } +void PeerConnection::create_offer( + NativeCreateSdpObserverHandle& observer_handle, + RTCOfferAnswerOptions options) { + peer_connection_->CreateOffer(observer_handle.observer.get(), + toNativeOfferAnswerOptions(options)); +} - void PeerConnection::create_offer(NativeCreateSdpObserverHandle &observer_handle, RTCOfferAnswerOptions options) { - peer_connection_->CreateOffer(observer_handle.observer.get(), toNativeOfferAnswerOptions(options)); - } +void PeerConnection::create_answer( + NativeCreateSdpObserverHandle& observer_handle, + RTCOfferAnswerOptions options) { + peer_connection_->CreateAnswer(observer_handle.observer.get(), + toNativeOfferAnswerOptions(options)); +} - void PeerConnection::create_answer(NativeCreateSdpObserverHandle &observer_handle, RTCOfferAnswerOptions options) { - peer_connection_->CreateAnswer(observer_handle.observer.get(), toNativeOfferAnswerOptions(options)); - } +void PeerConnection::set_local_description( + std::unique_ptr desc, + NativeSetLocalSdpObserverHandle& observer) { + peer_connection_->SetLocalDescription(desc->clone()->release(), + observer.observer); +} - void PeerConnection::set_local_description(std::unique_ptr desc, NativeSetLocalSdpObserverHandle &observer) { - peer_connection_->SetLocalDescription(desc->clone()->release(), observer.observer); - } +void PeerConnection::set_remote_description( + std::unique_ptr desc, + NativeSetRemoteSdpObserverHandle& observer) { + peer_connection_->SetRemoteDescription(desc->clone()->release(), + observer.observer); +} - void PeerConnection::set_remote_description(std::unique_ptr desc, NativeSetRemoteSdpObserverHandle &observer) { - peer_connection_->SetRemoteDescription(desc->clone()->release(), observer.observer); - } +std::unique_ptr PeerConnection::create_data_channel( + rust::String label, + std::unique_ptr init) { + auto result = + peer_connection_->CreateDataChannelOrError(label.c_str(), init.get()); - std::unique_ptr PeerConnection::create_data_channel(rust::String label, std::unique_ptr init) { - auto result = peer_connection_->CreateDataChannelOrError(label.c_str(), init.get()); + if (!result.ok()) { + throw std::runtime_error(serialize_error(to_error(result.error()))); + } - if(!result.ok()) { - throw std::runtime_error(serialize_error(to_error(result.error()))); - } + return std::make_unique(result.value()); +} - return std::make_unique(result.value()); - } +void PeerConnection::add_ice_candidate( + std::unique_ptr candidate, + NativeAddIceCandidateObserver& observer) { + peer_connection_->AddIceCandidate( + candidate->release(), + [&](const webrtc::RTCError& err) { observer.OnComplete(to_error(err)); }); +} - void PeerConnection::add_ice_candidate(std::unique_ptr candidate, NativeAddIceCandidateObserver &observer){ - peer_connection_->AddIceCandidate(candidate->release(), [&](const webrtc::RTCError& err){ - observer.OnComplete(to_error(err)); - }); - } +void PeerConnection::close() { + peer_connection_->Close(); +} - void PeerConnection::close() { - peer_connection_->Close(); - } +// AddIceCandidateObserver - // AddIceCandidateObserver +NativeAddIceCandidateObserver::NativeAddIceCandidateObserver( + rust::Box observer) + : observer_(std::move(observer)) {} - NativeAddIceCandidateObserver::NativeAddIceCandidateObserver(rust::Box observer) : observer_(std::move(observer)) { +void NativeAddIceCandidateObserver::OnComplete(const RTCError& error) { + observer_->on_complete(error); +} - } +std::unique_ptr +create_native_add_ice_candidate_observer( + rust::Box observer) { + return std::make_unique(std::move(observer)); +} - void NativeAddIceCandidateObserver::OnComplete(const RTCError &error) { - observer_->on_complete(error); - } +// PeerConnectionObserver - std::unique_ptr create_native_add_ice_candidate_observer(rust::Box observer) { - return std::make_unique(std::move(observer)); - } +NativePeerConnectionObserver::NativePeerConnectionObserver( + rust::Box observer) + : observer_(std::move(observer)) {} - // PeerConnectionObserver +void NativePeerConnectionObserver::OnSignalingChange( + webrtc::PeerConnectionInterface::SignalingState new_state) { + observer_->on_signaling_change(static_cast(new_state)); +} - NativePeerConnectionObserver::NativePeerConnectionObserver(rust::Box observer) : observer_(std::move(observer)) { +void NativePeerConnectionObserver::OnAddStream( + rtc::scoped_refptr stream) { + observer_->on_add_stream(std::make_unique(stream)); +} - } +void NativePeerConnectionObserver::OnRemoveStream( + rtc::scoped_refptr stream) { + observer_->on_remove_stream(std::make_unique(stream)); +} - void NativePeerConnectionObserver::OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) { - observer_->on_signaling_change(static_cast(new_state)); - } +void NativePeerConnectionObserver::OnDataChannel( + rtc::scoped_refptr data_channel) { + observer_->on_data_channel(std::make_unique(data_channel)); +} - void NativePeerConnectionObserver::OnAddStream(rtc::scoped_refptr stream) { - observer_->on_add_stream(std::make_unique(stream)); - } +void NativePeerConnectionObserver::OnRenegotiationNeeded() { + observer_->on_renegotiation_needed(); +} - void NativePeerConnectionObserver::OnRemoveStream(rtc::scoped_refptr stream) { - observer_->on_remove_stream(std::make_unique(stream)); - } +void NativePeerConnectionObserver::OnNegotiationNeededEvent(uint32_t event_id) { + observer_->on_negotiation_needed_event(event_id); +} - void NativePeerConnectionObserver::OnDataChannel(rtc::scoped_refptr data_channel) { - observer_->on_data_channel(std::make_unique(data_channel)); - } +void NativePeerConnectionObserver::OnIceConnectionChange( + webrtc::PeerConnectionInterface::IceConnectionState new_state) { + observer_->on_ice_connection_change( + static_cast(new_state)); +} - void NativePeerConnectionObserver::OnRenegotiationNeeded() { - observer_->on_renegotiation_needed(); - } +void NativePeerConnectionObserver::OnStandardizedIceConnectionChange( + webrtc::PeerConnectionInterface::IceConnectionState new_state) { + observer_->on_standardized_ice_connection_change( + static_cast(new_state)); +} - void NativePeerConnectionObserver::OnNegotiationNeededEvent(uint32_t event_id) { - observer_->on_negotiation_needed_event(event_id); - } +void NativePeerConnectionObserver::OnConnectionChange( + webrtc::PeerConnectionInterface::PeerConnectionState new_state) { + observer_->on_connection_change(static_cast(new_state)); +} - void - NativePeerConnectionObserver::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) { - observer_->on_ice_connection_change(static_cast(new_state)); - } +void NativePeerConnectionObserver::OnIceGatheringChange( + webrtc::PeerConnectionInterface::IceGatheringState new_state) { + observer_->on_ice_gathering_change(static_cast(new_state)); +} - void NativePeerConnectionObserver::OnStandardizedIceConnectionChange( - webrtc::PeerConnectionInterface::IceConnectionState new_state) { - observer_->on_standardized_ice_connection_change(static_cast(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(std::move(new_candidate))); +} - void - NativePeerConnectionObserver::OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state) { - observer_->on_connection_change(static_cast(new_state)); - } +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::OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) { - observer_->on_ice_gathering_change(static_cast(new_state)); - } +void NativePeerConnectionObserver::OnIceCandidatesRemoved( + const std::vector& candidates) { + rust::Vec vec; - 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(std::move(new_candidate))); - } + for (const auto& item : candidates) { + vec.push_back(CandidatePtr{std::make_unique(item)}); + } - 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); - } + observer_->on_ice_candidates_removed(std::move(vec)); +} - void NativePeerConnectionObserver::OnIceCandidatesRemoved(const std::vector &candidates) { - rust::Vec vec; +void NativePeerConnectionObserver::OnIceConnectionReceivingChange( + bool receiving) { + observer_->on_ice_connection_receiving_change(receiving); +} - for (const auto &item: candidates) { - vec.push_back(CandidatePtr{ - std::make_unique(item) - }); - } +void NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged( + const cricket::CandidatePairChangeEvent& event) { + CandidatePairChangeEvent e; + e.selected_candidate_pair.local = + std::make_unique(event.selected_candidate_pair.local); + e.selected_candidate_pair.remote = + std::make_unique(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_candidates_removed(std::move(vec)); - } + observer_->on_ice_selected_candidate_pair_changed(std::move(e)); +} - void NativePeerConnectionObserver::OnIceConnectionReceivingChange(bool receiving) { - observer_->on_ice_connection_receiving_change(receiving); - } +void NativePeerConnectionObserver::OnAddTrack( + rtc::scoped_refptr receiver, + const std::vector>& + streams) { + rust::Vec vec; - void - NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged(const cricket::CandidatePairChangeEvent &event) { - CandidatePairChangeEvent e; - e.selected_candidate_pair.local = std::make_unique(event.selected_candidate_pair.local); - e.selected_candidate_pair.remote = std::make_unique(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; + for (const auto& item : streams) { + vec.push_back(MediaStreamPtr{std::make_unique(item)}); + } - observer_->on_ice_selected_candidate_pair_changed(std::move(e)); - } + observer_->on_add_track(std::make_unique(receiver), + std::move(vec)); +} - void NativePeerConnectionObserver::OnAddTrack(rtc::scoped_refptr receiver, - const std::vector> &streams) { - rust::Vec vec; +void NativePeerConnectionObserver::OnTrack( + rtc::scoped_refptr transceiver) { + observer_->on_track(std::make_unique(transceiver)); +} - for (const auto &item: streams) { - vec.push_back(MediaStreamPtr{ - std::make_unique(item) - }); - } +void NativePeerConnectionObserver::OnRemoveTrack( + rtc::scoped_refptr receiver) { + observer_->on_remove_track(std::make_unique(receiver)); +} - observer_->on_add_track(std::make_unique(receiver), std::move(vec)); - } +void NativePeerConnectionObserver::OnInterestingUsage(int usage_pattern) { + observer_->on_interesting_usage(usage_pattern); +} - void NativePeerConnectionObserver::OnTrack(rtc::scoped_refptr transceiver) { - observer_->on_track(std::make_unique(transceiver)); - } - - void NativePeerConnectionObserver::OnRemoveTrack(rtc::scoped_refptr receiver) { - observer_->on_remove_track(std::make_unique(receiver)); - } - - void NativePeerConnectionObserver::OnInterestingUsage(int usage_pattern) { - observer_->on_interesting_usage(usage_pattern); - } - - std::unique_ptr create_native_peer_connection_observer(rust::Box observer) { - return std::make_unique(std::move(observer)); - } -} // livekit \ No newline at end of file +std::unique_ptr +create_native_peer_connection_observer( + rust::Box observer) { + return std::make_unique(std::move(observer)); +} +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs index 72f6424..2bd8442 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs @@ -1,3 +1,5 @@ +use cxx::UniquePtr; + use crate::candidate::ffi::Candidate; use crate::data_channel::ffi::DataChannel; use crate::jsep::ffi::IceCandidate; @@ -5,11 +7,9 @@ use crate::media_stream_interface::ffi::MediaStreamInterface; use crate::rtc_error::ffi::RTCError; use crate::rtp_receiver::ffi::RtpReceiver; use crate::rtp_transceiver::ffi::RtpTransceiver; -use cxx::UniquePtr; #[cxx::bridge(namespace = "livekit")] pub mod ffi { - struct CandidatePair { local: UniquePtr, remote: UniquePtr, @@ -246,6 +246,7 @@ pub mod ffi { // https://webrtc.github.io/webrtc-org/native-code/native-apis/ unsafe impl Sync for ffi::PeerConnection {} + unsafe impl Send for ffi::PeerConnection {} unsafe impl Send for ffi::NativePeerConnectionObserver {} diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.cpp index 0b3f9d6..1de4ff4 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.cpp @@ -3,85 +3,93 @@ // #include "livekit/peer_connection_factory.h" -#include "api/video_codecs/builtin_video_decoder_factory.h" + #include "api/audio_codecs/builtin_audio_decoder_factory.h" #include "api/audio_codecs/builtin_audio_encoder_factory.h" -#include "api/video_codecs/builtin_video_encoder_factory.h" -#include "media/engine/webrtc_media_engine.h" -#include "api/task_queue/default_task_queue_factory.h" #include "api/rtc_event_log/rtc_event_log_factory.h" +#include "api/task_queue/default_task_queue_factory.h" +#include "api/video_codecs/builtin_video_decoder_factory.h" +#include "api/video_codecs/builtin_video_encoder_factory.h" #include "libwebrtc-sys/src/peer_connection_factory.rs.h" #include "livekit/rtc_error.h" +#include "media/engine/webrtc_media_engine.h" -namespace livekit{ +namespace livekit { - PeerConnectionFactory::PeerConnectionFactory(){ - rtc::LogMessage::LogToDebug(rtc::LS_INFO); - RTC_LOG(LS_INFO) << "PeerConnectionFactory::PeerConnectionFactory()"; +PeerConnectionFactory::PeerConnectionFactory() { + rtc::LogMessage::LogToDebug(rtc::LS_INFO); + RTC_LOG(LS_INFO) << "PeerConnectionFactory::PeerConnectionFactory()"; - network_thread_ = rtc::Thread::CreateWithSocketServer(); - network_thread_->SetName("network_thread", &network_thread_); - network_thread_->Start(); - worker_thread_ = rtc::Thread::Create(); - worker_thread_->SetName("worker_thread", &worker_thread_); - worker_thread_->Start(); - signaling_thread_ = rtc::Thread::Create(); - signaling_thread_->SetName("signaling_thread", &signaling_thread_); - signaling_thread_->Start(); + network_thread_ = rtc::Thread::CreateWithSocketServer(); + network_thread_->SetName("network_thread", &network_thread_); + network_thread_->Start(); + worker_thread_ = rtc::Thread::Create(); + worker_thread_->SetName("worker_thread", &worker_thread_); + worker_thread_->Start(); + signaling_thread_ = rtc::Thread::Create(); + signaling_thread_->SetName("signaling_thread", &signaling_thread_); + signaling_thread_->Start(); - webrtc::PeerConnectionFactoryDependencies dependencies; - dependencies.network_thread = network_thread_.get(); - dependencies.worker_thread = worker_thread_.get(); - dependencies.signaling_thread = signaling_thread_.get(); - dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory(); - dependencies.event_log_factory = std::make_unique(dependencies.task_queue_factory.get()); + webrtc::PeerConnectionFactoryDependencies dependencies; + dependencies.network_thread = network_thread_.get(); + dependencies.worker_thread = worker_thread_.get(); + dependencies.signaling_thread = signaling_thread_.get(); + dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory(); + dependencies.event_log_factory = std::make_unique( + dependencies.task_queue_factory.get()); - cricket::MediaEngineDependencies media_deps; - media_deps.task_queue_factory = dependencies.task_queue_factory.get(); - media_deps.video_encoder_factory = webrtc::CreateBuiltinVideoEncoderFactory(); - media_deps.video_decoder_factory = webrtc::CreateBuiltinVideoDecoderFactory(); - media_deps.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory(); - media_deps.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory(); + cricket::MediaEngineDependencies media_deps; + media_deps.task_queue_factory = dependencies.task_queue_factory.get(); + media_deps.video_encoder_factory = webrtc::CreateBuiltinVideoEncoderFactory(); + media_deps.video_decoder_factory = webrtc::CreateBuiltinVideoDecoderFactory(); + media_deps.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory(); + media_deps.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory(); - dependencies.media_engine = cricket::CreateMediaEngine(std::move(media_deps)); + dependencies.media_engine = cricket::CreateMediaEngine(std::move(media_deps)); - peer_factory_ = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies)); + peer_factory_ = + webrtc::CreateModularPeerConnectionFactory(std::move(dependencies)); - if (peer_factory_.get() == nullptr) { - RTC_LOG_ERR(LS_ERROR) << "Failed to create PeerConnectionFactory"; - return; - } + if (peer_factory_.get() == nullptr) { + RTC_LOG_ERR(LS_ERROR) << "Failed to create PeerConnectionFactory"; + return; + } +} + +std::unique_ptr PeerConnectionFactory::create_peer_connection( + std::unique_ptr config, + NativePeerConnectionObserver& observer) const { + webrtc::PeerConnectionDependencies deps{&observer}; + auto result = + peer_factory_->CreatePeerConnectionOrError(*config, std::move(deps)); + + if (!result.ok()) { + throw std::runtime_error(serialize_error(to_error(result.error()))); + } + + return std::make_unique(result.value()); +} + +std::unique_ptr create_peer_connection_factory() { + return std::make_unique(); +} + +std::unique_ptr create_rtc_configuration( + RTCConfiguration conf) { + auto rtc = + std::make_unique(); + for (auto& item : conf.ice_servers) { + webrtc::PeerConnectionInterface::IceServer ice_server; + ice_server.username = item.username.c_str(); + ice_server.password = item.password.c_str(); + + for (auto& url : item.urls) { + ice_server.urls.emplace_back(url.c_str()); } - std::unique_ptr PeerConnectionFactory::create_peer_connection(std::unique_ptr config, NativePeerConnectionObserver &observer) const { - webrtc::PeerConnectionDependencies deps{&observer}; - auto result = peer_factory_->CreatePeerConnectionOrError(*config, std::move(deps)); + rtc->servers.push_back(ice_server); + } - if(!result.ok()) { - throw std::runtime_error(serialize_error(to_error(result.error()))); - } - - return std::make_unique(result.value()); - } - - std::unique_ptr create_peer_connection_factory() { - return std::make_unique(); - } - - std::unique_ptr create_rtc_configuration(RTCConfiguration conf){ - auto rtc = std::make_unique(); - for (auto &item: conf.ice_servers){ - webrtc::PeerConnectionInterface::IceServer ice_server; - ice_server.username = item.username.c_str(); - ice_server.password = item.password.c_str(); - - for (auto &url: item.urls){ - ice_server.urls.emplace_back(url.c_str()); - } - - rtc->servers.push_back(ice_server); - } - - return rtc; - } -} // namespace lk \ No newline at end of file + return rtc; +} +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs index 5252078..4116eca 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs @@ -1,25 +1,10 @@ -use crate::candidate::ffi::Candidate; -use crate::data_channel::ffi::DataChannel; -use crate::jsep::ffi::IceCandidate; -use crate::jsep::CreateSdpObserver; -use crate::media_stream_interface::ffi::MediaStreamInterface; -use crate::peer_connection::ffi::{ - CandidatePairChangeEvent, IceConnectionState, IceGatheringState, PeerConnectionState, - SignalingState, -}; -use crate::peer_connection::PeerConnectionObserver; -use crate::rtp_receiver::ffi::RtpReceiver; -use crate::rtp_transceiver::ffi::RtpTransceiver; -use crate::{jsep, peer_connection}; -use cxx::UniquePtr; -use log::info; use std::any::Any; -use std::thread::sleep; -use std::time::Duration; + +use crate::jsep::CreateSdpObserver; +use crate::peer_connection::PeerConnectionObserver; #[cxx::bridge(namespace = "livekit")] pub mod ffi { - #[derive(Debug, Clone)] pub struct ICEServer { pub urls: Vec, @@ -37,7 +22,7 @@ pub mod ffi { type PeerConnection = crate::peer_connection::ffi::PeerConnection; type NativePeerConnectionObserver = - crate::peer_connection::ffi::NativePeerConnectionObserver; + crate::peer_connection::ffi::NativePeerConnectionObserver; type PeerConnectionFactory; type NativeRTCConfiguration; diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.cpp index 5ea6217..7488112 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.cpp @@ -3,53 +3,54 @@ // #include "livekit/rtc_error.h" + #include #include #include namespace livekit { - RTCError to_error(const webrtc::RTCError &error) { - RTCError lk_error; - lk_error.error_detail = static_cast(error.error_detail()); - lk_error.error_type = static_cast(error.type()); - lk_error.has_sctp_cause_code = error.sctp_cause_code().has_value(); - lk_error.sctp_cause_code = error.sctp_cause_code().value_or(0); - lk_error.message = error.message(); - return lk_error; - } +RTCError to_error(const webrtc::RTCError& error) { + RTCError lk_error; + lk_error.error_detail = static_cast(error.error_detail()); + lk_error.error_type = static_cast(error.type()); + lk_error.has_sctp_cause_code = error.sctp_cause_code().has_value(); + lk_error.sctp_cause_code = error.sctp_cause_code().value_or(0); + lk_error.message = error.message(); + return lk_error; +} - std::string serialize_error(const RTCError &error) { - std::stringstream ss; - ss << std::hex << std::setfill('0'); - ss << std::setw(8) << (uint32_t) error.error_type; - ss << std::setw(8) << (uint32_t) error.error_detail; - ss << std::setw(2) << (uint16_t) error.has_sctp_cause_code; - ss << std::setw(4) << (uint16_t) error.sctp_cause_code; - ss << std::dec << std::setw(1) << std::string(error.message); - return ss.str(); - } +std::string serialize_error(const RTCError& error) { + std::stringstream ss; + ss << std::hex << std::setfill('0'); + ss << std::setw(8) << (uint32_t)error.error_type; + ss << std::setw(8) << (uint32_t)error.error_detail; + ss << std::setw(2) << (uint16_t)error.has_sctp_cause_code; + ss << std::setw(4) << (uint16_t)error.sctp_cause_code; + ss << std::dec << std::setw(1) << std::string(error.message); + return ss.str(); +} #ifdef LIVEKIT_TEST - rust::String serialize_deserialize(){ - RTCError lk_error; - lk_error.error_type = RTCErrorType::InternalError; - lk_error.error_detail = RTCErrorDetailType::DataChannelFailure; - lk_error.has_sctp_cause_code = true; - lk_error.sctp_cause_code = 24; - lk_error.message = "this is not a test, I repeat, this is not a test"; - return serialize_error(lk_error); - } +rust::String serialize_deserialize() { + RTCError lk_error; + lk_error.error_type = RTCErrorType::InternalError; + lk_error.error_detail = RTCErrorDetailType::DataChannelFailure; + lk_error.has_sctp_cause_code = true; + lk_error.sctp_cause_code = 24; + lk_error.message = "this is not a test, I repeat, this is not a test"; + return serialize_error(lk_error); +} - void throw_error() { - RTCError lk_error; - lk_error.error_type = RTCErrorType::InvalidModification; - lk_error.error_detail = RTCErrorDetailType::None; - lk_error.has_sctp_cause_code = false; - lk_error.sctp_cause_code = 0; - lk_error.message = "exception is thrown!"; - throw std::runtime_error(serialize_error(lk_error)); - } +void throw_error() { + RTCError lk_error; + lk_error.error_type = RTCErrorType::InvalidModification; + lk_error.error_detail = RTCErrorDetailType::None; + lk_error.has_sctp_cause_code = false; + lk_error.sctp_cause_code = 0; + lk_error.message = "exception is thrown!"; + throw std::runtime_error(serialize_error(lk_error)); +} #endif -} // livekit \ No newline at end of file +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.rs b/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.rs index 8ac3bc0..0c2e1bd 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.rs @@ -6,7 +6,6 @@ use std::fmt::{Display, Formatter}; #[cxx::bridge(namespace = "livekit")] pub mod ffi { - #[derive(Debug)] #[repr(u32)] pub enum RTCErrorType { @@ -42,7 +41,8 @@ pub mod ffi { pub error_type: RTCErrorType, pub message: String, pub error_detail: RTCErrorDetailType, - pub has_sctp_cause_code: bool, // cxx doesn't support the Option trait + pub has_sctp_cause_code: bool, + // cxx doesn't support the Option trait pub sctp_cause_code: u16, } } diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/rtp_receiver.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/rtp_receiver.cpp index 0ca8a69..b413a32 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/rtp_receiver.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/rtp_receiver.cpp @@ -5,7 +5,7 @@ #include "livekit/rtp_receiver.h" namespace livekit { - RtpReceiver::RtpReceiver(rtc::scoped_refptr receiver) : receiver_(std::move(receiver)) { - - } -} // livekit \ No newline at end of file +RtpReceiver::RtpReceiver( + rtc::scoped_refptr receiver) + : receiver_(std::move(receiver)) {} +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/rtp_transceiver.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/rtp_transceiver.cpp index f05e6c5..84d37d9 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/rtp_transceiver.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/rtp_transceiver.cpp @@ -5,7 +5,7 @@ #include "livekit/rtp_transceiver.h" namespace livekit { - RtpTransceiver::RtpTransceiver(rtc::scoped_refptr transceiver) : transceiver_(std::move(transceiver)) { - - } -} // livekit \ No newline at end of file +RtpTransceiver::RtpTransceiver( + rtc::scoped_refptr transceiver) + : transceiver_(std::move(transceiver)) {} +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/webrtc.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/webrtc.cpp index b435694..37665f1 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/webrtc.cpp +++ b/crates/livekit-webrtc/libwebrtc-sys/src/webrtc.cpp @@ -3,20 +3,21 @@ // #include "livekit/webrtc.h" + #include "rtc_base/logging.h" namespace livekit { - RTCRuntime::RTCRuntime() { - RTC_LOG(LS_INFO) << "RTCRuntime()"; - RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()"; - } +RTCRuntime::RTCRuntime() { + RTC_LOG(LS_INFO) << "RTCRuntime()"; + RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()"; +} - RTCRuntime::~RTCRuntime() { - RTC_LOG(LS_INFO) << "~RTCRuntime()"; - RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()"; - } +RTCRuntime::~RTCRuntime() { + RTC_LOG(LS_INFO) << "~RTCRuntime()"; + RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()"; +} - std::unique_ptr create_rtc_runtime(){ - return std::make_unique(); - } -} // livekit \ No newline at end of file +std::unique_ptr create_rtc_runtime() { + return std::make_unique(); +} +} // namespace livekit \ No newline at end of file diff --git a/crates/livekit-webrtc/src/data_channel.rs b/crates/livekit-webrtc/src/data_channel.rs index 7819c17..ad5145d 100644 --- a/crates/livekit-webrtc/src/data_channel.rs +++ b/crates/livekit-webrtc/src/data_channel.rs @@ -1,9 +1,10 @@ -use cxx::UniquePtr; -use libwebrtc_sys::data_channel as sys_dc; -use log::trace; use std::fmt::{Debug, Formatter}; use std::sync::{Arc, Mutex}; +use cxx::UniquePtr; +use log::trace; + +use libwebrtc_sys::data_channel as sys_dc; pub use sys_dc::ffi::Priority; pub struct DataChannel { @@ -78,7 +79,8 @@ impl DataChannel { } pub type OnStateChangeHandler = Box; -pub type OnMessageHandler = Box; // data, is_binary +pub type OnMessageHandler = Box; +// data, is_binary pub type OnBufferedAmountChangeHandler = Box; struct InternalDataChannelObserver { diff --git a/crates/livekit-webrtc/src/jsep.rs b/crates/livekit-webrtc/src/jsep.rs index 3d66eb6..d979b9a 100644 --- a/crates/livekit-webrtc/src/jsep.rs +++ b/crates/livekit-webrtc/src/jsep.rs @@ -1,4 +1,5 @@ -use cxx::{SharedPtr, UniquePtr}; +use cxx::UniquePtr; + use libwebrtc_sys::jsep as sys_jsep; #[derive(Debug)] diff --git a/crates/livekit-webrtc/src/peer_connection.rs b/crates/livekit-webrtc/src/peer_connection.rs index f03f123..d310435 100644 --- a/crates/livekit-webrtc/src/peer_connection.rs +++ b/crates/livekit-webrtc/src/peer_connection.rs @@ -1,12 +1,19 @@ +use std::fmt::Debug; +use std::sync::{Arc, Mutex}; + use cxx::UniquePtr; +use log::trace; +use thiserror::Error; +use tokio::sync::mpsc; + use libwebrtc_sys::data_channel as sys_dc; use libwebrtc_sys::jsep as sys_jsep; use libwebrtc_sys::peer_connection as sys_pc; -use log::trace; -use std::fmt::{Debug, Formatter}; -use std::sync::{Arc, Mutex}; -use thiserror::Error; -use tokio::sync::{mpsc, oneshot}; +pub use libwebrtc_sys::peer_connection::ffi::IceConnectionState; +pub use libwebrtc_sys::peer_connection::ffi::IceGatheringState; +pub use libwebrtc_sys::peer_connection::ffi::PeerConnectionState; +pub use libwebrtc_sys::peer_connection::ffi::RTCOfferAnswerOptions; +pub use libwebrtc_sys::peer_connection::ffi::SignalingState; use crate::data_channel::{DataChannel, DataChannelInit}; use crate::jsep::{IceCandidate, SessionDescription}; @@ -15,12 +22,6 @@ use crate::rtc_error::RTCError; use crate::rtp_receiver::RtpReceiver; use crate::rtp_transceiver::RtpTransceiver; -pub use libwebrtc_sys::peer_connection::ffi::IceConnectionState; -pub use libwebrtc_sys::peer_connection::ffi::IceGatheringState; -pub use libwebrtc_sys::peer_connection::ffi::PeerConnectionState; -pub use libwebrtc_sys::peer_connection::ffi::RTCOfferAnswerOptions; -pub use libwebrtc_sys::peer_connection::ffi::SignalingState; - #[derive(Error, Debug)] pub enum SdpError { #[error("recv failure: {0}")] @@ -343,16 +344,16 @@ pub type OnRenegotiationNeededHandler = Box; pub type OnNegotiationNeededEventHandler = Box; pub type OnIceConnectionChangeHandler = Box; pub type OnStandardizedIceConnectionChangeHandler = - Box; +Box; pub type OnConnectionChangeHandler = Box; pub type OnIceGatheringChangeHandler = Box; pub type OnIceCandidateHandler = Box; pub type OnIceCandidateErrorHandler = - Box; +Box; pub type OnIceCandidatesRemovedHandler = Box) + Send + Sync>; pub type OnIceConnectionReceivingChangeHandler = Box; pub type OnIceSelectedCandidatePairChangedHandler = - Box; +Box; pub type OnAddTrackHandler = Box) + Send + Sync>; pub type OnTrackHandler = Box; pub type OnRemoveTrackHandler = Box; @@ -367,16 +368,16 @@ pub(crate) struct InternalObserver { on_negotiation_needed_event_handler: Arc>>, on_ice_connection_change_handler: Arc>>, on_standardized_ice_connection_change_handler: - Arc>>, + Arc>>, on_connection_change_handler: Arc>>, on_ice_gathering_change_handler: Arc>>, on_ice_candidate_handler: Arc>>, on_ice_candidate_error_handler: Arc>>, on_ice_candidates_removed_handler: Arc>>, on_ice_connection_receiving_change_handler: - Arc>>, + Arc>>, on_ice_selected_candidate_pair_changed_handler: - Arc>>, + Arc>>, on_add_track_handler: Arc>>, on_track_handler: Arc>>, on_remove_track_handler: Arc>>, @@ -604,12 +605,13 @@ impl sys_pc::PeerConnectionObserver for InternalObserver { #[cfg(test)] mod tests { + use log::trace; + use tokio::sync::mpsc; + use crate::data_channel::{DataChannel, DataChannelInit}; use crate::jsep::IceCandidate; use crate::peer_connection_factory::{ICEServer, PeerConnectionFactory, RTCConfiguration}; use crate::webrtc::RTCRuntime; - use log::trace; - use tokio::sync::mpsc; fn init_log() { let _ = env_logger::builder().is_test(true).try_init(); diff --git a/crates/livekit-webrtc/src/peer_connection_factory.rs b/crates/livekit-webrtc/src/peer_connection_factory.rs index 2724bf5..6ff7e75 100644 --- a/crates/livekit-webrtc/src/peer_connection_factory.rs +++ b/crates/livekit-webrtc/src/peer_connection_factory.rs @@ -1,12 +1,12 @@ use cxx::UniquePtr; + use libwebrtc_sys::peer_connection as sys_pc; use libwebrtc_sys::peer_connection_factory as sys_factory; +pub use sys_factory::ffi::{ICEServer, RTCConfiguration}; use crate::peer_connection::{InternalObserver, PeerConnection}; use crate::rtc_error::RTCError; -pub use sys_factory::ffi::{ICEServer, RTCConfiguration}; - pub struct PeerConnectionFactory { cxx_handle: UniquePtr, } diff --git a/crates/livekit-webrtc/src/rtc_error.rs b/crates/livekit-webrtc/src/rtc_error.rs index e7aa9c0..e054cf4 100644 --- a/crates/livekit-webrtc/src/rtc_error.rs +++ b/crates/livekit-webrtc/src/rtc_error.rs @@ -1,4 +1,3 @@ -use std::fmt; - // TODO(theomonnom) Wrap the RTCError ffi so we can use Option(u16) pub use libwebrtc_sys::rtc_error::ffi::RTCError; + diff --git a/crates/livekit-webrtc/src/webrtc.rs b/crates/livekit-webrtc/src/webrtc.rs index 80484ae..5065a79 100644 --- a/crates/livekit-webrtc/src/webrtc.rs +++ b/crates/livekit-webrtc/src/webrtc.rs @@ -1,4 +1,5 @@ use cxx::UniquePtr; + use libwebrtc_sys::webrtc as sys_rtc; pub struct RTCRuntime {