From 9c390351c4c43f1a316e2ce51bcb4331704429e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Thu, 15 Mar 2018 12:18:06 +0200 Subject: [PATCH] Add gstreamer-webrtc-sys --- Cargo.toml | 3 +- Gir_GstWebRTC.toml | 17 + gir-files/GstWebRTC-1.0.gir | 950 ++++++++++++++++++++++++++++++++ gstreamer-webrtc-sys/Cargo.toml | 35 ++ gstreamer-webrtc-sys/build.rs | 60 ++ gstreamer-webrtc-sys/src/lib.rs | 391 +++++++++++++ 6 files changed, 1455 insertions(+), 1 deletion(-) create mode 100644 Gir_GstWebRTC.toml create mode 100644 gir-files/GstWebRTC-1.0.gir create mode 100644 gstreamer-webrtc-sys/Cargo.toml create mode 100644 gstreamer-webrtc-sys/build.rs create mode 100644 gstreamer-webrtc-sys/src/lib.rs diff --git a/Cargo.toml b/Cargo.toml index 2146777b2..8fcfae742 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,5 +13,6 @@ members = [ "gstreamer-net-sys", "gstreamer-sdp-sys", "gstreamer-rtsp-sys", - "gstreamer-rtsp-server-sys" + "gstreamer-rtsp-server-sys", + "gstreamer-webrtc-sys" ] diff --git a/Gir_GstWebRTC.toml b/Gir_GstWebRTC.toml new file mode 100644 index 000000000..df7d32ca5 --- /dev/null +++ b/Gir_GstWebRTC.toml @@ -0,0 +1,17 @@ +[options] +girs_dir = "gir-files" +library = "GstWebRTC" +version = "1.0" +min_cfg_version = "1.0" +target_path = "gstreamer-webrtc-sys" +work_mode = "sys" + +external_libraries = [ + "GLib", + "GObject", + "Gst" +] + +[external_libraries] +gstreamer="Gst" +gstreamer_sdp="GstSdp" diff --git a/gir-files/GstWebRTC-1.0.gir b/gir-files/GstWebRTC-1.0.gir new file mode 100644 index 000000000..6381ff081 --- /dev/null +++ b/gir-files/GstWebRTC-1.0.gir @@ -0,0 +1,950 @@ + + + + + + + + + + GST_WEBRTC_DTLS_SETUP_NONE: none +GST_WEBRTC_DTLS_SETUP_ACTPASS: actpass +GST_WEBRTC_DTLS_SETUP_ACTIVE: sendonly +GST_WEBRTC_DTLS_SETUP_PASSIVE: recvonly + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + GST_WEBRTC_DTLS_TRANSPORT_STATE_NEW: new +GST_WEBRTC_DTLS_TRANSPORT_STATE_CLOSED: closed +GST_WEBRTC_DTLS_TRANSPORT_STATE_FAILED: failed +GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTING: connecting +GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTED: connected + + + + + + + + + + + + + + + + + + + GST_WEBRTC_ICE_CONNECTION_STATE_NEW: new +GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING: checking +GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED: connected +GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED: completed +GST_WEBRTC_ICE_CONNECTION_STATE_FAILED: failed +GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED: disconnected +GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED: closed +See <ulink url="http://w3c.github.io/webrtc-pc/#dom-rtciceconnectionstate">http://w3c.github.io/webrtc-pc/#dom-rtciceconnectionstate</ulink> + + + + + + + + + + + + + + + + + GST_WEBRTC_ICE_GATHERING_STATE_NEW: new +GST_WEBRTC_ICE_GATHERING_STATE_GATHERING: gathering +GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE: complete +See <ulink url="http://w3c.github.io/webrtc-pc/#dom-rtcicegatheringstate">http://w3c.github.io/webrtc-pc/#dom-rtcicegatheringstate</ulink> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + GST_WEBRTC_ICE_ROLE_CONTROLLED: controlled +GST_WEBRTC_ICE_ROLE_CONTROLLING: controlling + + + + + + + GST_WEBRTC_PEER_CONNECTION_STATE_NEW: new +GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING: connecting +GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED: connected +GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED: disconnected +GST_WEBRTC_PEER_CONNECTION_STATE_FAILED: failed +GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED: closed +See <ulink url="http://w3c.github.io/webrtc-pc/#dom-rtcpeerconnectionstate">http://w3c.github.io/webrtc-pc/#dom-rtcpeerconnectionstate</ulink> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + GST_WEBRTC_SDP_TYPE_OFFER: offer +GST_WEBRTC_SDP_TYPE_PRANSWER: pranswer +GST_WEBRTC_SDP_TYPE_ANSWER: answer +GST_WEBRTC_SDP_TYPE_ROLLBACK: rollback +See <ulink url="http://w3c.github.io/webrtc-pc/#rtcsdptype">http://w3c.github.io/webrtc-pc/#rtcsdptype</ulink> + + + + + + + + + + + sdp: the #GstSDPMessage of the description +See <ulink url="https://www.w3.org/TR/webrtc/#rtcsessiondescription-class">https://www.w3.org/TR/webrtc/#rtcsessiondescription-class</ulink> + + + + + + + + + a new #GstWebRTCSessionDescription from @type + and @sdp + + + + + a #GstWebRTCSDPType + + + + a #GstSDPMessage + + + + + + + a new copy of @src + + + + + a #GstWebRTCSessionDescription + + + + + + Free @desc and all associated resources + + + + + + a #GstWebRTCSessionDescription + + + + + + + GST_WEBRTC_SIGNALING_STATE_STABLE: stable +GST_WEBRTC_SIGNALING_STATE_CLOSED: closed +GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER: have-local-offer +GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER: have-remote-offer +GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER: have-local-pranswer +GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER: have-remote-pranswer +See <ulink url="http://w3c.github.io/webrtc-pc/#dom-rtcsignalingstate">http://w3c.github.io/webrtc-pc/#dom-rtcsignalingstate</ulink> + + + + + + + + + + + + + + + GST_WEBRTC_STATS_CODEC: codec +GST_WEBRTC_STATS_INBOUND_RTP: inbound-rtp +GST_WEBRTC_STATS_OUTBOUND_RTP: outbound-rtp +GST_WEBRTC_STATS_REMOTE_INBOUND_RTP: remote-inbound-rtp +GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP: remote-outbound-rtp +GST_WEBRTC_STATS_CSRC: csrc +GST_WEBRTC_STATS_PEER_CONNECTION: peer-connectiion +GST_WEBRTC_STATS_DATA_CHANNEL: data-channel +GST_WEBRTC_STATS_STREAM: stream +GST_WEBRTC_STATS_TRANSPORT: transport +GST_WEBRTC_STATS_CANDIDATE_PAIR: candidate-pair +GST_WEBRTC_STATS_LOCAL_CANDIDATE: local-candidate +GST_WEBRTC_STATS_REMOTE_CANDIDATE: remote-candidate +GST_WEBRTC_STATS_CERTIFICATE: certificate + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + the string representation of @type or "unknown" when @type is not + recognized. + + + + + a #GstWebRTCSDPType + + + + + + diff --git a/gstreamer-webrtc-sys/Cargo.toml b/gstreamer-webrtc-sys/Cargo.toml new file mode 100644 index 000000000..d1eb8669b --- /dev/null +++ b/gstreamer-webrtc-sys/Cargo.toml @@ -0,0 +1,35 @@ +[build-dependencies] +pkg-config = "0.3.7" + +[dependencies] +libc = "0.2" +glib-sys = { git = "https://github.com/gtk-rs/sys" } +gobject-sys = { git = "https://github.com/gtk-rs/sys" } + +[dependencies.gstreamer-sys] +path = "../gstreamer-sys" + +[dependencies.gstreamer-sdp-sys] +path = "../gstreamer-sdp-sys" + +[features] +dox = [] + +[lib] +name = "gstreamer_webrtc_sys" + +[package] +build = "build.rs" +links = "gstwebrtc-1.0" +name = "gstreamer-webrtc-sys" +version = "0.5.0" +authors = ["Sebastian Dröge "] +description = "FFI bindings to libgstwebrtc-1.0" +homepage = "https://gstreamer.freedesktop.org" +keywords = ["ffi", "gstreamer", "gnome", "multimedia"] +repository = "https://github.com/sdroege/gstreamer-sys" +license = "MIT" +readme = "README.md" + +[badges] +travis-ci = { repository = "sdroege/gstreamer-sys", branch = "master" } diff --git a/gstreamer-webrtc-sys/build.rs b/gstreamer-webrtc-sys/build.rs new file mode 100644 index 000000000..dbc73b1d9 --- /dev/null +++ b/gstreamer-webrtc-sys/build.rs @@ -0,0 +1,60 @@ +extern crate pkg_config; + +use pkg_config::{Config, Error}; +use std::env; +use std::io::prelude::*; +use std::io; +use std::process; + +fn main() { + if let Err(s) = find() { + let _ = writeln!(io::stderr(), "{}", s); + process::exit(1); + } +} + +fn find() -> Result<(), Error> { + let package_name = "gstreamer-player-1.0"; + let shared_libs = ["gstplayer-1.0"]; + let version = "1.13.91"; + + if let Ok(lib_dir) = env::var("GTK_LIB_DIR") { + for lib_ in shared_libs.iter() { + println!("cargo:rustc-link-lib=dylib={}", lib_); + } + println!("cargo:rustc-link-search=native={}", lib_dir); + return Ok(()) + } + + let target = env::var("TARGET").expect("TARGET environment variable doesn't exist"); + let hardcode_shared_libs = target.contains("windows"); + + let mut config = Config::new(); + config.atleast_version(version); + config.print_system_libs(false); + if hardcode_shared_libs { + config.cargo_metadata(false); + } + match config.probe(package_name) { + Ok(library) => { + if hardcode_shared_libs { + for lib_ in shared_libs.iter() { + println!("cargo:rustc-link-lib=dylib={}", lib_); + } + for path in library.link_paths.iter() { + println!("cargo:rustc-link-search=native={}", + path.to_str().expect("library path doesn't exist")); + } + } + Ok(()) + } + Err(Error::EnvNoPkgConfig(_)) | Err(Error::Command { .. }) => { + for lib_ in shared_libs.iter() { + println!("cargo:rustc-link-lib=dylib={}", lib_); + } + Ok(()) + } + Err(err) => Err(err), + } +} + diff --git a/gstreamer-webrtc-sys/src/lib.rs b/gstreamer-webrtc-sys/src/lib.rs new file mode 100644 index 000000000..18913fd37 --- /dev/null +++ b/gstreamer-webrtc-sys/src/lib.rs @@ -0,0 +1,391 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir @ d1e0127) +// from gir-files (https://github.com/gtk-rs/gir-files @ ???) +// DO NOT EDIT + +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] + +extern crate libc; +extern crate glib_sys as glib; +extern crate gobject_sys as gobject; +extern crate gstreamer_sys as gst; +extern crate gstreamer_sdp_sys as gst_sdp; + +#[allow(unused_imports)] +use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double, + c_short, c_ushort, c_long, c_ulong, + c_void, size_t, ssize_t, intptr_t, uintptr_t, time_t, FILE}; + +#[allow(unused_imports)] +use glib::{gboolean, gconstpointer, gpointer, GType, Volatile}; + +// Enums +pub type GstWebRTCDTLSSetup = c_int; +pub const GST_WEBRTC_DTLS_SETUP_NONE: GstWebRTCDTLSSetup = 0; +pub const GST_WEBRTC_DTLS_SETUP_ACTPASS: GstWebRTCDTLSSetup = 1; +pub const GST_WEBRTC_DTLS_SETUP_ACTIVE: GstWebRTCDTLSSetup = 2; +pub const GST_WEBRTC_DTLS_SETUP_PASSIVE: GstWebRTCDTLSSetup = 3; + +pub type GstWebRTCDTLSTransportState = c_int; +pub const GST_WEBRTC_DTLS_TRANSPORT_STATE_NEW: GstWebRTCDTLSTransportState = 0; +pub const GST_WEBRTC_DTLS_TRANSPORT_STATE_CLOSED: GstWebRTCDTLSTransportState = 1; +pub const GST_WEBRTC_DTLS_TRANSPORT_STATE_FAILED: GstWebRTCDTLSTransportState = 2; +pub const GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTING: GstWebRTCDTLSTransportState = 3; +pub const GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTED: GstWebRTCDTLSTransportState = 4; + +pub type GstWebRTCICEComponent = c_int; +pub const GST_WEBRTC_ICE_COMPONENT_RTP: GstWebRTCICEComponent = 0; +pub const GST_WEBRTC_ICE_COMPONENT_RTCP: GstWebRTCICEComponent = 1; + +pub type GstWebRTCICEConnectionState = c_int; +pub const GST_WEBRTC_ICE_CONNECTION_STATE_NEW: GstWebRTCICEConnectionState = 0; +pub const GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING: GstWebRTCICEConnectionState = 1; +pub const GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED: GstWebRTCICEConnectionState = 2; +pub const GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED: GstWebRTCICEConnectionState = 3; +pub const GST_WEBRTC_ICE_CONNECTION_STATE_FAILED: GstWebRTCICEConnectionState = 4; +pub const GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED: GstWebRTCICEConnectionState = 5; +pub const GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED: GstWebRTCICEConnectionState = 6; + +pub type GstWebRTCICEGatheringState = c_int; +pub const GST_WEBRTC_ICE_GATHERING_STATE_NEW: GstWebRTCICEGatheringState = 0; +pub const GST_WEBRTC_ICE_GATHERING_STATE_GATHERING: GstWebRTCICEGatheringState = 1; +pub const GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE: GstWebRTCICEGatheringState = 2; + +pub type GstWebRTCIceRole = c_int; +pub const GST_WEBRTC_ICE_ROLE_CONTROLLED: GstWebRTCIceRole = 0; +pub const GST_WEBRTC_ICE_ROLE_CONTROLLING: GstWebRTCIceRole = 1; + +pub type GstWebRTCPeerConnectionState = c_int; +pub const GST_WEBRTC_PEER_CONNECTION_STATE_NEW: GstWebRTCPeerConnectionState = 0; +pub const GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTING: GstWebRTCPeerConnectionState = 1; +pub const GST_WEBRTC_PEER_CONNECTION_STATE_CONNECTED: GstWebRTCPeerConnectionState = 2; +pub const GST_WEBRTC_PEER_CONNECTION_STATE_DISCONNECTED: GstWebRTCPeerConnectionState = 3; +pub const GST_WEBRTC_PEER_CONNECTION_STATE_FAILED: GstWebRTCPeerConnectionState = 4; +pub const GST_WEBRTC_PEER_CONNECTION_STATE_CLOSED: GstWebRTCPeerConnectionState = 5; + +pub type GstWebRTCRTPTransceiverDirection = c_int; +pub const GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_NONE: GstWebRTCRTPTransceiverDirection = 0; +pub const GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_INACTIVE: GstWebRTCRTPTransceiverDirection = 1; +pub const GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY: GstWebRTCRTPTransceiverDirection = 2; +pub const GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_RECVONLY: GstWebRTCRTPTransceiverDirection = 3; +pub const GST_WEBRTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV: GstWebRTCRTPTransceiverDirection = 4; + +pub type GstWebRTCSDPType = c_int; +pub const GST_WEBRTC_SDP_TYPE_OFFER: GstWebRTCSDPType = 1; +pub const GST_WEBRTC_SDP_TYPE_PRANSWER: GstWebRTCSDPType = 2; +pub const GST_WEBRTC_SDP_TYPE_ANSWER: GstWebRTCSDPType = 3; +pub const GST_WEBRTC_SDP_TYPE_ROLLBACK: GstWebRTCSDPType = 4; + +pub type GstWebRTCSignalingState = c_int; +pub const GST_WEBRTC_SIGNALING_STATE_STABLE: GstWebRTCSignalingState = 0; +pub const GST_WEBRTC_SIGNALING_STATE_CLOSED: GstWebRTCSignalingState = 1; +pub const GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_OFFER: GstWebRTCSignalingState = 2; +pub const GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_OFFER: GstWebRTCSignalingState = 3; +pub const GST_WEBRTC_SIGNALING_STATE_HAVE_LOCAL_PRANSWER: GstWebRTCSignalingState = 4; +pub const GST_WEBRTC_SIGNALING_STATE_HAVE_REMOTE_PRANSWER: GstWebRTCSignalingState = 5; + +pub type GstWebRTCStatsType = c_int; +pub const GST_WEBRTC_STATS_CODEC: GstWebRTCStatsType = 1; +pub const GST_WEBRTC_STATS_INBOUND_RTP: GstWebRTCStatsType = 2; +pub const GST_WEBRTC_STATS_OUTBOUND_RTP: GstWebRTCStatsType = 3; +pub const GST_WEBRTC_STATS_REMOTE_INBOUND_RTP: GstWebRTCStatsType = 4; +pub const GST_WEBRTC_STATS_REMOTE_OUTBOUND_RTP: GstWebRTCStatsType = 5; +pub const GST_WEBRTC_STATS_CSRC: GstWebRTCStatsType = 6; +pub const GST_WEBRTC_STATS_PEER_CONNECTION: GstWebRTCStatsType = 7; +pub const GST_WEBRTC_STATS_DATA_CHANNEL: GstWebRTCStatsType = 8; +pub const GST_WEBRTC_STATS_STREAM: GstWebRTCStatsType = 9; +pub const GST_WEBRTC_STATS_TRANSPORT: GstWebRTCStatsType = 10; +pub const GST_WEBRTC_STATS_CANDIDATE_PAIR: GstWebRTCStatsType = 11; +pub const GST_WEBRTC_STATS_LOCAL_CANDIDATE: GstWebRTCStatsType = 12; +pub const GST_WEBRTC_STATS_REMOTE_CANDIDATE: GstWebRTCStatsType = 13; +pub const GST_WEBRTC_STATS_CERTIFICATE: GstWebRTCStatsType = 14; + +// Records +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCDTLSTransportClass { + pub parent_class: gst::GstBinClass, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCDTLSTransportClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCDTLSTransportClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCICETransportClass { + pub parent_class: gst::GstBinClass, + pub gather_candidates: Option gboolean>, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCICETransportClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCICETransportClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("gather_candidates", &self.gather_candidates) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCRTPReceiverClass { + pub parent_class: gst::GstObjectClass, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCRTPReceiverClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCRTPReceiverClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCRTPSenderClass { + pub parent_class: gst::GstObjectClass, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCRTPSenderClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCRTPSenderClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCRTPTransceiverClass { + pub parent_class: gst::GstObjectClass, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCRTPTransceiverClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCRTPTransceiverClass @ {:?}", self as *const _)) + .field("parent_class", &self.parent_class) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCSessionDescription { + pub type_: GstWebRTCSDPType, + pub sdp: *mut gst_sdp::GstSDPMessage, +} + +impl ::std::fmt::Debug for GstWebRTCSessionDescription { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCSessionDescription @ {:?}", self as *const _)) + .field("type_", &self.type_) + .field("sdp", &self.sdp) + .finish() + } +} + +// Classes +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCDTLSTransport { + pub parent: gst::GstObject, + pub transport: *mut GstWebRTCICETransport, + pub state: GstWebRTCDTLSTransportState, + pub is_rtcp: gboolean, + pub client: gboolean, + pub session_id: c_uint, + pub dtlssrtpenc: *mut gst::GstElement, + pub dtlssrtpdec: *mut gst::GstElement, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCDTLSTransport { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCDTLSTransport @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("transport", &self.transport) + .field("state", &self.state) + .field("is_rtcp", &self.is_rtcp) + .field("client", &self.client) + .field("session_id", &self.session_id) + .field("dtlssrtpenc", &self.dtlssrtpenc) + .field("dtlssrtpdec", &self.dtlssrtpdec) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCICETransport { + pub parent: gst::GstObject, + pub role: GstWebRTCIceRole, + pub component: GstWebRTCICEComponent, + pub state: GstWebRTCICEConnectionState, + pub gathering_state: GstWebRTCICEGatheringState, + pub src: *mut gst::GstElement, + pub sink: *mut gst::GstElement, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCICETransport { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCICETransport @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("role", &self.role) + .field("component", &self.component) + .field("state", &self.state) + .field("gathering_state", &self.gathering_state) + .field("src", &self.src) + .field("sink", &self.sink) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCRTPReceiver { + pub parent: gst::GstObject, + pub transport: *mut GstWebRTCDTLSTransport, + pub rtcp_transport: *mut GstWebRTCDTLSTransport, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCRTPReceiver { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCRTPReceiver @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("transport", &self.transport) + .field("rtcp_transport", &self.rtcp_transport) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCRTPSender { + pub parent: gst::GstObject, + pub transport: *mut GstWebRTCDTLSTransport, + pub rtcp_transport: *mut GstWebRTCDTLSTransport, + pub send_encodings: *mut glib::GArray, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCRTPSender { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCRTPSender @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("transport", &self.transport) + .field("rtcp_transport", &self.rtcp_transport) + .field("send_encodings", &self.send_encodings) + .field("_padding", &self._padding) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GstWebRTCRTPTransceiver { + pub parent: gst::GstObject, + pub mline: c_uint, + pub mid: *mut c_char, + pub stopped: gboolean, + pub sender: *mut GstWebRTCRTPSender, + pub receiver: *mut GstWebRTCRTPReceiver, + pub direction: GstWebRTCRTPTransceiverDirection, + pub current_direction: GstWebRTCRTPTransceiverDirection, + pub codec_preferences: *mut gst::GstCaps, + pub _padding: [gpointer; 4], +} + +impl ::std::fmt::Debug for GstWebRTCRTPTransceiver { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("GstWebRTCRTPTransceiver @ {:?}", self as *const _)) + .field("parent", &self.parent) + .field("mline", &self.mline) + .field("mid", &self.mid) + .field("stopped", &self.stopped) + .field("sender", &self.sender) + .field("receiver", &self.receiver) + .field("direction", &self.direction) + .field("current_direction", &self.current_direction) + .field("codec_preferences", &self.codec_preferences) + .field("_padding", &self._padding) + .finish() + } +} + +extern "C" { + + //========================================================================= + // GstWebRTCSessionDescription + //========================================================================= + pub fn gst_webrtc_session_description_get_type() -> GType; + pub fn gst_webrtc_session_description_new(type_: GstWebRTCSDPType, sdp: *mut gst_sdp::GstSDPMessage) -> *mut GstWebRTCSessionDescription; + pub fn gst_webrtc_session_description_copy(src: *const GstWebRTCSessionDescription) -> *mut GstWebRTCSessionDescription; + pub fn gst_webrtc_session_description_free(desc: *mut GstWebRTCSessionDescription); + + //========================================================================= + // GstWebRTCDTLSTransport + //========================================================================= + pub fn gst_webrtc_dtls_transport_get_type() -> GType; + pub fn gst_webrtc_dtls_transport_new(session_id: c_uint, rtcp: gboolean) -> *mut GstWebRTCDTLSTransport; + pub fn gst_webrtc_dtls_transport_set_transport(transport: *mut GstWebRTCDTLSTransport, ice: *mut GstWebRTCICETransport); + + //========================================================================= + // GstWebRTCICETransport + //========================================================================= + pub fn gst_webrtc_ice_transport_get_type() -> GType; + pub fn gst_webrtc_ice_transport_connection_state_change(ice: *mut GstWebRTCICETransport, new_state: GstWebRTCICEConnectionState); + pub fn gst_webrtc_ice_transport_gathering_state_change(ice: *mut GstWebRTCICETransport, new_state: GstWebRTCICEGatheringState); + pub fn gst_webrtc_ice_transport_new_candidate(ice: *mut GstWebRTCICETransport, stream_id: c_uint, component: GstWebRTCICEComponent, attr: *mut c_char); + pub fn gst_webrtc_ice_transport_selected_pair_change(ice: *mut GstWebRTCICETransport); + + //========================================================================= + // GstWebRTCRTPReceiver + //========================================================================= + pub fn gst_webrtc_rtp_receiver_get_type() -> GType; + pub fn gst_webrtc_rtp_receiver_new() -> *mut GstWebRTCRTPReceiver; + pub fn gst_webrtc_rtp_receiver_get_parameters(receiver: *mut GstWebRTCRTPReceiver, kind: *mut c_char) -> *mut gst::GstStructure; + pub fn gst_webrtc_rtp_receiver_set_parameters(receiver: *mut GstWebRTCRTPReceiver, parameters: *mut gst::GstStructure) -> gboolean; + pub fn gst_webrtc_rtp_receiver_set_rtcp_transport(receiver: *mut GstWebRTCRTPReceiver, transport: *mut GstWebRTCDTLSTransport); + pub fn gst_webrtc_rtp_receiver_set_transport(receiver: *mut GstWebRTCRTPReceiver, transport: *mut GstWebRTCDTLSTransport); + + //========================================================================= + // GstWebRTCRTPSender + //========================================================================= + pub fn gst_webrtc_rtp_sender_get_type() -> GType; + pub fn gst_webrtc_rtp_sender_new(send_encodings: *mut glib::GArray) -> *mut GstWebRTCRTPSender; + pub fn gst_webrtc_rtp_sender_get_parameters(sender: *mut GstWebRTCRTPSender, kind: *mut c_char) -> *mut gst::GstStructure; + pub fn gst_webrtc_rtp_sender_set_parameters(sender: *mut GstWebRTCRTPSender, parameters: *mut gst::GstStructure) -> gboolean; + pub fn gst_webrtc_rtp_sender_set_rtcp_transport(sender: *mut GstWebRTCRTPSender, transport: *mut GstWebRTCDTLSTransport); + pub fn gst_webrtc_rtp_sender_set_transport(sender: *mut GstWebRTCRTPSender, transport: *mut GstWebRTCDTLSTransport); + + //========================================================================= + // GstWebRTCRTPTransceiver + //========================================================================= + pub fn gst_webrtc_rtp_transceiver_get_type() -> GType; + pub fn gst_webrtc_rtp_transceiver_stop(transceiver: *mut GstWebRTCRTPTransceiver); + + //========================================================================= + // Other functions + //========================================================================= + pub fn gst_webrtc_sdp_type_to_string(type_: GstWebRTCSDPType) -> *const c_char; + +}