From 6bada6f67d29a73c416293f2640a2e8d917dab09 Mon Sep 17 00:00:00 2001 From: Thibault Saunier Date: Mon, 19 Mar 2018 15:49:25 -0300 Subject: [PATCH] Generate bindings for the new GstWebRTC library --- girs/GstWebRTC-1.0.gir | 1003 +++++++++++++++++ meson.build | 8 +- sources/custom/Application.cs | 3 +- sources/generated/Gst.WebRTC/Constants.cs | 16 + sources/generated/Gst.WebRTC/Global.cs | 25 + .../Gst.WebRTC/OnNewCandidateHandler.cs | 18 + .../generated/Gst.WebRTC/WebRTCDTLSSetup.cs | 30 + .../Gst.WebRTC/WebRTCDTLSTransport.cs | 333 ++++++ .../Gst.WebRTC/WebRTCDTLSTransportState.cs | 31 + .../Gst.WebRTC/WebRTCICEComponent.cs | 28 + .../Gst.WebRTC/WebRTCICEConnectionState.cs | 33 + .../Gst.WebRTC/WebRTCICEGatheringState.cs | 29 + sources/generated/Gst.WebRTC/WebRTCICERole.cs | 28 + .../Gst.WebRTC/WebRTCICETransport.cs | 463 ++++++++ .../Gst.WebRTC/WebRTCPeerConnectionState.cs | 32 + .../generated/Gst.WebRTC/WebRTCRTPReceiver.cs | 140 +++ .../generated/Gst.WebRTC/WebRTCRTPSender.cs | 148 +++ .../Gst.WebRTC/WebRTCRTPTransceiver.cs | 281 +++++ .../WebRTCRTPTransceiverDirection.cs | 31 + sources/generated/Gst.WebRTC/WebRTCSDPType.cs | 30 + .../Gst.WebRTC/WebRTCSessionDescription.cs | 83 ++ .../Gst.WebRTC/WebRTCSignalingState.cs | 32 + .../generated/Gst.WebRTC/WebRTCStatsType.cs | 40 + sources/generated/GtkSharp/ObjectManager.cs | 5 + sources/generated/gstreamer-sharp-abi.c | 48 + sources/generated/gstreamer-sharp-abi.cs | 47 + sources/generated/gstreamer-sharp-api.xml | 301 +++++ sources/generated/meson.build | 20 + sources/gstreamer-sharp-api.raw | 301 +++++ sources/gstreamer-sharp.dll.config | 2 + sources/gstreamer-sharp.metadata | 2 + sources/meson.build | 4 +- 32 files changed, 3589 insertions(+), 6 deletions(-) create mode 100644 girs/GstWebRTC-1.0.gir create mode 100644 sources/generated/Gst.WebRTC/Constants.cs create mode 100644 sources/generated/Gst.WebRTC/Global.cs create mode 100644 sources/generated/Gst.WebRTC/OnNewCandidateHandler.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCDTLSSetup.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCDTLSTransport.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCDTLSTransportState.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCICEComponent.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCICEConnectionState.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCICEGatheringState.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCICERole.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCICETransport.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCPeerConnectionState.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCRTPReceiver.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCRTPSender.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCRTPTransceiver.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCRTPTransceiverDirection.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCSDPType.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCSessionDescription.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCSignalingState.cs create mode 100644 sources/generated/Gst.WebRTC/WebRTCStatsType.cs diff --git a/girs/GstWebRTC-1.0.gir b/girs/GstWebRTC-1.0.gir new file mode 100644 index 0000000000..951089f479 --- /dev/null +++ b/girs/GstWebRTC-1.0.gir @@ -0,0 +1,1003 @@ + + + + + + + + + + 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_FEC_TYPE_NONE: none +GST_WEBRTC_FEC_TYPE_ULP_RED: ulpfec + red + + + + + + + GST_WEBRTC_ICE_COMPONENT_RTP, +GST_WEBRTC_ICE_COMPONENT_RTCP, + + + + + + + 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> + + + + + + + + + + + the string representation of @type or "unknown" when @type is not + recognized. + + + + + a #GstWebRTCSDPType + + + + + + + See <ulink url="https://www.w3.org/TR/webrtc/#rtcsessiondescription-class">https://www.w3.org/TR/webrtc/#rtcsessiondescription-class</ulink> + + the #GstWebRTCSDPType of the description + + + + the #GstSDPMessage of the description + + + + + 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/meson.build b/meson.build index 0b92311654..978aff217d 100644 --- a/meson.build +++ b/meson.build @@ -79,7 +79,9 @@ gst_deps_defs = [ ['gstreamer-rtsp', ['gst-plugins-base', 'rtsp_dep'], 'gst_rtsp'], ['gstreamer-sdp', ['gst-plugins-base', 'sdp_dep'], 'gstsdp'], ['gstreamer-tag', ['gst-plugins-base', 'tag_dep'], 'gsttag'], - ['gstreamer-video', ['gst-plugins-base', 'video_dep'], 'gstvideo'],] + ['gstreamer-video', ['gst-plugins-base', 'video_dep'], 'gstvideo'], + ['gstreamer-webrtc', ['gst-plugins-bad', 'gstwebrtc_dep'], 'gstwebrtc'], +] foreach dep: gst_deps_defs gst_deps += [dependency(dep.get(0) + '-' + apiversion, version: gst_required_version, @@ -165,7 +167,7 @@ if bindinator.get_variable('found') run_target('bindinate_gstreamer', command: [bindinate, '--name=gstreamer', '--regenerate=true', - '--merge-with=GstApp-1.0,GstAudio-1.0,GstBase-1.0,GstController-1.0,GstNet-1.0,GstPbutils-1.0,GstRtp-1.0,GstRtsp-1.0,GstSdp-1.0,GstTag-1.0,GstVideo-1.0', + '--merge-with=GstApp-1.0,GstAudio-1.0,GstBase-1.0,GstController-1.0,GstNet-1.0,GstPbutils-1.0,GstRtp-1.0,GstRtsp-1.0,GstSdp-1.0,GstTag-1.0,GstVideo-1.0,GstWebRTC-1.0', '--gir=Gst-1.0', '--copy-girs=@0@'.format(join_paths(meson.current_source_dir(), 'girs'))], depends: [] @@ -183,4 +185,4 @@ if bindinator.get_variable('found') run_target('update-all', command: [find_program('update_sources.py'), 'bindinate']) else warning('Bindinator not usable as some required dependencies are not avalaible.') -endif \ No newline at end of file +endif diff --git a/sources/custom/Application.cs b/sources/custom/Application.cs index 4ac9abb47c..6a5f022622 100644 --- a/sources/custom/Application.cs +++ b/sources/custom/Application.cs @@ -32,7 +32,8 @@ namespace Gst { GLib.GType.Register (FractionRange.GType, typeof(FractionRange)); GLib.GType.Register (DateTime.GType, typeof(DateTime)); GLib.GType.Register (Gst.Array.GType, typeof(Gst.Array)); - + GLib.GType.Register(Promise.GType, typeof(Promise)); + GLib.GType.Register(Gst.WebRTC.WebRTCSessionDescription.GType, typeof(Gst.WebRTC.WebRTCSessionDescription)); } [DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] diff --git a/sources/generated/Gst.WebRTC/Constants.cs b/sources/generated/Gst.WebRTC/Constants.cs new file mode 100644 index 0000000000..640f6820c2 --- /dev/null +++ b/sources/generated/Gst.WebRTC/Constants.cs @@ -0,0 +1,16 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Runtime.InteropServices; + +#region Autogenerated code + public partial class Constants { + +#endregion + } +} diff --git a/sources/generated/Gst.WebRTC/Global.cs b/sources/generated/Gst.WebRTC/Global.cs new file mode 100644 index 0000000000..460a1cc078 --- /dev/null +++ b/sources/generated/Gst.WebRTC/Global.cs @@ -0,0 +1,25 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Runtime.InteropServices; + +#region Autogenerated code + public partial class Global { + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_sdp_type_to_string(int type); + + public static string WebrtcSdpTypeToString(Gst.WebRTC.WebRTCSDPType type) { + IntPtr raw_ret = gst_webrtc_sdp_type_to_string((int) type); + string ret = GLib.Marshaller.Utf8PtrToString (raw_ret); + return ret; + } + +#endregion + } +} diff --git a/sources/generated/Gst.WebRTC/OnNewCandidateHandler.cs b/sources/generated/Gst.WebRTC/OnNewCandidateHandler.cs new file mode 100644 index 0000000000..42d9524004 --- /dev/null +++ b/sources/generated/Gst.WebRTC/OnNewCandidateHandler.cs @@ -0,0 +1,18 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + + public delegate void OnNewCandidateHandler(object o, OnNewCandidateArgs args); + + public class OnNewCandidateArgs : GLib.SignalArgs { + public string Object{ + get { + return (string) Args [0]; + } + } + + } +} diff --git a/sources/generated/Gst.WebRTC/WebRTCDTLSSetup.cs b/sources/generated/Gst.WebRTC/WebRTCDTLSSetup.cs new file mode 100644 index 0000000000..208f6bd472 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCDTLSSetup.cs @@ -0,0 +1,30 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCDTLSSetupGType))] + public enum WebRTCDTLSSetup { + + None = 0, + Actpass = 1, + Active = 2, + Passive = 3, + } + + internal class WebRTCDTLSSetupGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_dtls_setup_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_dtls_setup_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCDTLSTransport.cs b/sources/generated/Gst.WebRTC/WebRTCDTLSTransport.cs new file mode 100644 index 0000000000..bcbdde6af4 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCDTLSTransport.cs @@ -0,0 +1,333 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Runtime.InteropServices; + +#region Autogenerated code + public partial class WebRTCDTLSTransport : Gst.Object { + + public WebRTCDTLSTransport (IntPtr raw) : base(raw) {} + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_dtls_transport_new(uint session_id, bool rtcp); + + public WebRTCDTLSTransport (uint session_id, bool rtcp) : base (IntPtr.Zero) + { + if (GetType () != typeof (WebRTCDTLSTransport)) { + var vals = new List (); + var names = new List (); + names.Add ("session_id"); + vals.Add (new GLib.Value (session_id)); + names.Add ("rtcp"); + vals.Add (new GLib.Value (rtcp)); + CreateNativeObject (names.ToArray (), vals.ToArray ()); + return; + } + Raw = gst_webrtc_dtls_transport_new(session_id, rtcp); + } + + [GLib.Property ("certificate")] + public string Certificate { + get { + GLib.Value val = GetProperty ("certificate"); + string ret = (string) val; + val.Dispose (); + return ret; + } + set { + GLib.Value val = new GLib.Value(value); + SetProperty("certificate", val); + val.Dispose (); + } + } + + [GLib.Property ("client")] + public bool Client { + get { + GLib.Value val = GetProperty ("client"); + bool ret = (bool) val; + val.Dispose (); + return ret; + } + set { + GLib.Value val = new GLib.Value(value); + SetProperty("client", val); + val.Dispose (); + } + } + + [GLib.Property ("remote-certificate")] + public string RemoteCertificate { + get { + GLib.Value val = GetProperty ("remote-certificate"); + string ret = (string) val; + val.Dispose (); + return ret; + } + } + + [GLib.Property ("rtcp")] + public bool Rtcp { + get { + GLib.Value val = GetProperty ("rtcp"); + bool ret = (bool) val; + val.Dispose (); + return ret; + } + } + + [GLib.Property ("session-id")] + public uint SessionId { + get { + GLib.Value val = GetProperty ("session-id"); + uint ret = (uint) val; + val.Dispose (); + return ret; + } + } + + [GLib.Property ("state")] + public Gst.WebRTC.WebRTCDTLSTransportState State { + get { + GLib.Value val = GetProperty ("state"); + Gst.WebRTC.WebRTCDTLSTransportState ret = (Gst.WebRTC.WebRTCDTLSTransportState) (Enum) val; + val.Dispose (); + return ret; + } + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_dtls_transport_set_transport(IntPtr raw, IntPtr ice); + + [GLib.Property ("transport")] + public Gst.WebRTC.WebRTCICETransport Transport { + get { + GLib.Value val = GetProperty ("transport"); + Gst.WebRTC.WebRTCICETransport ret = (Gst.WebRTC.WebRTCICETransport) val; + val.Dispose (); + return ret; + } + set { + gst_webrtc_dtls_transport_set_transport(Handle, value == null ? IntPtr.Zero : value.Handle); + } + } + + public Gst.WebRTC.WebRTCICETransport TransportField { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("transport")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.WebRTC.WebRTCICETransport; + } + } + } + + public Gst.WebRTC.WebRTCDTLSTransportState StateField { + get { + unsafe { + int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("state")); + return (Gst.WebRTC.WebRTCDTLSTransportState) (*raw_ptr); + } + } + } + + public bool IsRtcp { + get { + unsafe { + bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("is_rtcp")); + return (*raw_ptr); + } + } + } + + public bool ClientField { + get { + unsafe { + bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("client")); + return (*raw_ptr); + } + } + } + + public uint SessionIdField { + get { + unsafe { + uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("session_id")); + return (*raw_ptr); + } + } + } + + public Gst.Element Dtlssrtpenc { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("dtlssrtpenc")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.Element; + } + } + } + + public Gst.Element Dtlssrtpdec { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("dtlssrtpdec")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.Element; + } + } + } + + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _class_abi = null; + static public new GLib.AbiStruct class_abi { + get { + if (_class_abi == null) + _class_abi = new GLib.AbiStruct (new List{ + new GLib.AbiField("_padding" + , Gst.Object.class_abi.Fields + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , null + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _class_abi; + } + } + + + // End of the ABI representation. + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_dtls_transport_get_type(); + + public static new GLib.GType GType { + get { + IntPtr raw_ret = gst_webrtc_dtls_transport_get_type(); + GLib.GType ret = new GLib.GType(raw_ret); + return ret; + } + } + + + static WebRTCDTLSTransport () + { + GtkSharp.GstreamerSharp.ObjectManager.Initialize (); + } + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _abi_info = null; + static public new GLib.AbiStruct abi_info { + get { + if (_abi_info == null) + _abi_info = new GLib.AbiStruct (new List{ + new GLib.AbiField("transport" + , Gst.Object.abi_info.Fields + , (uint) Marshal.SizeOf(typeof(IntPtr)) // transport + , null + , "state" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("state" + , -1 + , (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.WebRTC.WebRTCDTLSTransportState))) // state + , "transport" + , "is_rtcp" + , (long) Marshal.OffsetOf(typeof(GstWebRTCDTLSTransport_stateAlign), "state") + , 0 + ), + new GLib.AbiField("is_rtcp" + , -1 + , (uint) Marshal.SizeOf(typeof(bool)) // is_rtcp + , "state" + , "client" + , (long) Marshal.OffsetOf(typeof(GstWebRTCDTLSTransport_is_rtcpAlign), "is_rtcp") + , 0 + ), + new GLib.AbiField("client" + , -1 + , (uint) Marshal.SizeOf(typeof(bool)) // client + , "is_rtcp" + , "session_id" + , (long) Marshal.OffsetOf(typeof(GstWebRTCDTLSTransport_clientAlign), "client") + , 0 + ), + new GLib.AbiField("session_id" + , -1 + , (uint) Marshal.SizeOf(typeof(uint)) // session_id + , "client" + , "dtlssrtpenc" + , (long) Marshal.OffsetOf(typeof(GstWebRTCDTLSTransport_session_idAlign), "session_id") + , 0 + ), + new GLib.AbiField("dtlssrtpenc" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // dtlssrtpenc + , "session_id" + , "dtlssrtpdec" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("dtlssrtpdec" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // dtlssrtpdec + , "dtlssrtpenc" + , "_padding" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("_padding" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , "dtlssrtpdec" + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _abi_info; + } + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCDTLSTransport_stateAlign + { + sbyte f1; + private Gst.WebRTC.WebRTCDTLSTransportState state; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCDTLSTransport_is_rtcpAlign + { + sbyte f1; + private bool is_rtcp; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCDTLSTransport_clientAlign + { + sbyte f1; + private bool client; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCDTLSTransport_session_idAlign + { + sbyte f1; + private uint session_id; + } + + + // End of the ABI representation. + +#endregion + } +} diff --git a/sources/generated/Gst.WebRTC/WebRTCDTLSTransportState.cs b/sources/generated/Gst.WebRTC/WebRTCDTLSTransportState.cs new file mode 100644 index 0000000000..dae707ccc6 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCDTLSTransportState.cs @@ -0,0 +1,31 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCDTLSTransportStateGType))] + public enum WebRTCDTLSTransportState { + + New = 0, + Closed = 1, + Failed = 2, + Connecting = 3, + Connected = 4, + } + + internal class WebRTCDTLSTransportStateGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_dtls_transport_state_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_dtls_transport_state_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCICEComponent.cs b/sources/generated/Gst.WebRTC/WebRTCICEComponent.cs new file mode 100644 index 0000000000..925bda9626 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCICEComponent.cs @@ -0,0 +1,28 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCICEComponentGType))] + public enum WebRTCICEComponent { + + Rtp = 0, + Rtcp = 1, + } + + internal class WebRTCICEComponentGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_ice_component_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_ice_component_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCICEConnectionState.cs b/sources/generated/Gst.WebRTC/WebRTCICEConnectionState.cs new file mode 100644 index 0000000000..f894208eb5 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCICEConnectionState.cs @@ -0,0 +1,33 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCICEConnectionStateGType))] + public enum WebRTCICEConnectionState { + + New = 0, + Checking = 1, + Connected = 2, + Completed = 3, + Failed = 4, + Disconnected = 5, + Closed = 6, + } + + internal class WebRTCICEConnectionStateGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_ice_connection_state_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_ice_connection_state_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCICEGatheringState.cs b/sources/generated/Gst.WebRTC/WebRTCICEGatheringState.cs new file mode 100644 index 0000000000..73f3975fcb --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCICEGatheringState.cs @@ -0,0 +1,29 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCICEGatheringStateGType))] + public enum WebRTCICEGatheringState { + + New = 0, + Gathering = 1, + Complete = 2, + } + + internal class WebRTCICEGatheringStateGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_ice_gathering_state_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_ice_gathering_state_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCICERole.cs b/sources/generated/Gst.WebRTC/WebRTCICERole.cs new file mode 100644 index 0000000000..921d6377ce --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCICERole.cs @@ -0,0 +1,28 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCICERoleGType))] + public enum WebRTCICERole { + + Controlled = 0, + Controlling = 1, + } + + internal class WebRTCICERoleGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_ice_role_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_ice_role_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCICETransport.cs b/sources/generated/Gst.WebRTC/WebRTCICETransport.cs new file mode 100644 index 0000000000..886fd40f00 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCICETransport.cs @@ -0,0 +1,463 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Runtime.InteropServices; + +#region Autogenerated code + public partial class WebRTCICETransport : Gst.Object { + + protected WebRTCICETransport (IntPtr raw) : base(raw) {} + + protected WebRTCICETransport() : base(IntPtr.Zero) + { + CreateNativeObject (new string [0], new GLib.Value [0]); + } + + [GLib.Property ("component")] + public Gst.WebRTC.WebRTCICEComponent Component { + get { + GLib.Value val = GetProperty ("component"); + Gst.WebRTC.WebRTCICEComponent ret = (Gst.WebRTC.WebRTCICEComponent) (Enum) val; + val.Dispose (); + return ret; + } + } + + [GLib.Property ("gathering-state")] + public Gst.WebRTC.WebRTCICEGatheringState GatheringState { + get { + GLib.Value val = GetProperty ("gathering-state"); + Gst.WebRTC.WebRTCICEGatheringState ret = (Gst.WebRTC.WebRTCICEGatheringState) (Enum) val; + val.Dispose (); + return ret; + } + } + + [GLib.Property ("state")] + public Gst.WebRTC.WebRTCICEConnectionState State { + get { + GLib.Value val = GetProperty ("state"); + Gst.WebRTC.WebRTCICEConnectionState ret = (Gst.WebRTC.WebRTCICEConnectionState) (Enum) val; + val.Dispose (); + return ret; + } + } + + public Gst.WebRTC.WebRTCICERole Role { + get { + unsafe { + int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("role")); + return (Gst.WebRTC.WebRTCICERole) (*raw_ptr); + } + } + } + + public Gst.WebRTC.WebRTCICEComponent ComponentField { + get { + unsafe { + int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("component")); + return (Gst.WebRTC.WebRTCICEComponent) (*raw_ptr); + } + } + } + + public Gst.WebRTC.WebRTCICEConnectionState StateField { + get { + unsafe { + int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("state")); + return (Gst.WebRTC.WebRTCICEConnectionState) (*raw_ptr); + } + } + } + + public Gst.WebRTC.WebRTCICEGatheringState GatheringStateField { + get { + unsafe { + int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("gathering_state")); + return (Gst.WebRTC.WebRTCICEGatheringState) (*raw_ptr); + } + } + } + + public Gst.Element Src { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("src")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.Element; + } + } + } + + public Gst.Element Sink { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("sink")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.Element; + } + } + } + + [GLib.Signal("on-selected-candidate-pair-change")] + public event System.EventHandler OnSelectedCandidatePairChange { + add { + this.AddSignalHandler ("on-selected-candidate-pair-change", value); + } + remove { + this.RemoveSignalHandler ("on-selected-candidate-pair-change", value); + } + } + + [GLib.Signal("on-new-candidate")] + public event Gst.WebRTC.OnNewCandidateHandler OnNewCandidate { + add { + this.AddSignalHandler ("on-new-candidate", value, typeof (Gst.WebRTC.OnNewCandidateArgs)); + } + remove { + this.RemoveSignalHandler ("on-new-candidate", value); + } + } + + static OnNewCandidateNativeDelegate OnNewCandidate_cb_delegate; + static OnNewCandidateNativeDelegate OnNewCandidateVMCallback { + get { + if (OnNewCandidate_cb_delegate == null) + OnNewCandidate_cb_delegate = new OnNewCandidateNativeDelegate (OnNewCandidate_cb); + return OnNewCandidate_cb_delegate; + } + } + + static void OverrideOnNewCandidate (GLib.GType gtype) + { + OverrideOnNewCandidate (gtype, OnNewCandidateVMCallback); + } + + static void OverrideOnNewCandidate (GLib.GType gtype, OnNewCandidateNativeDelegate callback) + { + OverrideVirtualMethod (gtype, "on-new-candidate", callback); + } + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void OnNewCandidateNativeDelegate (IntPtr inst, IntPtr _object); + + static void OnNewCandidate_cb (IntPtr inst, IntPtr _object) + { + try { + WebRTCICETransport __obj = GLib.Object.GetObject (inst, false) as WebRTCICETransport; + __obj.OnOnNewCandidate (GLib.Marshaller.Utf8PtrToString (_object)); + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, false); + } + } + + [GLib.DefaultSignalHandler(Type=typeof(Gst.WebRTC.WebRTCICETransport), ConnectionMethod="OverrideOnNewCandidate")] + protected virtual void OnOnNewCandidate (string _object) + { + InternalOnNewCandidate (_object); + } + + private void InternalOnNewCandidate (string _object) + { + GLib.Value ret = GLib.Value.Empty; + GLib.ValueArray inst_and_params = new GLib.ValueArray (2); + GLib.Value[] vals = new GLib.Value [2]; + vals [0] = new GLib.Value (this); + inst_and_params.Append (vals [0]); + vals [1] = new GLib.Value (_object); + inst_and_params.Append (vals [1]); + g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret); + foreach (GLib.Value v in vals) + v.Dispose (); + } + + static OnSelectedCandidatePairChangeNativeDelegate OnSelectedCandidatePairChange_cb_delegate; + static OnSelectedCandidatePairChangeNativeDelegate OnSelectedCandidatePairChangeVMCallback { + get { + if (OnSelectedCandidatePairChange_cb_delegate == null) + OnSelectedCandidatePairChange_cb_delegate = new OnSelectedCandidatePairChangeNativeDelegate (OnSelectedCandidatePairChange_cb); + return OnSelectedCandidatePairChange_cb_delegate; + } + } + + static void OverrideOnSelectedCandidatePairChange (GLib.GType gtype) + { + OverrideOnSelectedCandidatePairChange (gtype, OnSelectedCandidatePairChangeVMCallback); + } + + static void OverrideOnSelectedCandidatePairChange (GLib.GType gtype, OnSelectedCandidatePairChangeNativeDelegate callback) + { + OverrideVirtualMethod (gtype, "on-selected-candidate-pair-change", callback); + } + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void OnSelectedCandidatePairChangeNativeDelegate (IntPtr inst); + + static void OnSelectedCandidatePairChange_cb (IntPtr inst) + { + try { + WebRTCICETransport __obj = GLib.Object.GetObject (inst, false) as WebRTCICETransport; + __obj.OnOnSelectedCandidatePairChange (); + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, false); + } + } + + [GLib.DefaultSignalHandler(Type=typeof(Gst.WebRTC.WebRTCICETransport), ConnectionMethod="OverrideOnSelectedCandidatePairChange")] + protected virtual void OnOnSelectedCandidatePairChange () + { + InternalOnSelectedCandidatePairChange (); + } + + private void InternalOnSelectedCandidatePairChange () + { + GLib.Value ret = GLib.Value.Empty; + GLib.ValueArray inst_and_params = new GLib.ValueArray (1); + GLib.Value[] vals = new GLib.Value [1]; + vals [0] = new GLib.Value (this); + inst_and_params.Append (vals [0]); + g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret); + foreach (GLib.Value v in vals) + v.Dispose (); + } + + static GatherCandidatesNativeDelegate GatherCandidates_cb_delegate; + static GatherCandidatesNativeDelegate GatherCandidatesVMCallback { + get { + if (GatherCandidates_cb_delegate == null) + GatherCandidates_cb_delegate = new GatherCandidatesNativeDelegate (GatherCandidates_cb); + return GatherCandidates_cb_delegate; + } + } + + static void OverrideGatherCandidates (GLib.GType gtype) + { + OverrideGatherCandidates (gtype, GatherCandidatesVMCallback); + } + + static void OverrideGatherCandidates (GLib.GType gtype, GatherCandidatesNativeDelegate callback) + { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("gather_candidates")); + *raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback); + } + } + + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate bool GatherCandidatesNativeDelegate (IntPtr inst); + + static bool GatherCandidates_cb (IntPtr inst) + { + try { + WebRTCICETransport __obj = GLib.Object.GetObject (inst, false) as WebRTCICETransport; + bool __result; + __result = __obj.OnGatherCandidates (); + return __result; + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, true); + // NOTREACHED: above call does not return. + throw e; + } + } + + [GLib.DefaultSignalHandler(Type=typeof(Gst.WebRTC.WebRTCICETransport), ConnectionMethod="OverrideGatherCandidates")] + protected virtual bool OnGatherCandidates () + { + return InternalGatherCandidates (); + } + + private bool InternalGatherCandidates () + { + GatherCandidatesNativeDelegate unmanaged = null; + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("gather_candidates")); + unmanaged = (GatherCandidatesNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GatherCandidatesNativeDelegate)); + } + if (unmanaged == null) return false; + + bool __result = unmanaged (this.Handle); + return __result; + } + + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _class_abi = null; + static public new GLib.AbiStruct class_abi { + get { + if (_class_abi == null) + _class_abi = new GLib.AbiStruct (new List{ + new GLib.AbiField("gather_candidates" + , Gst.Object.class_abi.Fields + , (uint) Marshal.SizeOf(typeof(IntPtr)) // gather_candidates + , null + , "_padding" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("_padding" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , "gather_candidates" + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _class_abi; + } + } + + + // End of the ABI representation. + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_ice_transport_get_type(); + + public static new GLib.GType GType { + get { + IntPtr raw_ret = gst_webrtc_ice_transport_get_type(); + GLib.GType ret = new GLib.GType(raw_ret); + return ret; + } + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_ice_transport_connection_state_change(IntPtr raw, int new_state); + + public void ConnectionStateChange(Gst.WebRTC.WebRTCICEConnectionState new_state) { + gst_webrtc_ice_transport_connection_state_change(Handle, (int) new_state); + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_ice_transport_gathering_state_change(IntPtr raw, int new_state); + + public void GatheringStateChange(Gst.WebRTC.WebRTCICEGatheringState new_state) { + gst_webrtc_ice_transport_gathering_state_change(Handle, (int) new_state); + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_ice_transport_new_candidate(IntPtr raw, uint stream_id, int component, IntPtr attr); + + public void NewCandidate(uint stream_id, Gst.WebRTC.WebRTCICEComponent component, string attr) { + IntPtr native_attr = GLib.Marshaller.StringToPtrGStrdup (attr); + gst_webrtc_ice_transport_new_candidate(Handle, stream_id, (int) component, native_attr); + GLib.Marshaller.Free (native_attr); + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_ice_transport_selected_pair_change(IntPtr raw); + + public void SelectedPairChange() { + gst_webrtc_ice_transport_selected_pair_change(Handle); + } + + + static WebRTCICETransport () + { + GtkSharp.GstreamerSharp.ObjectManager.Initialize (); + } + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _abi_info = null; + static public new GLib.AbiStruct abi_info { + get { + if (_abi_info == null) + _abi_info = new GLib.AbiStruct (new List{ + new GLib.AbiField("role" + , Gst.Object.abi_info.Fields + , (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.WebRTC.WebRTCICERole))) // role + , null + , "component" + , (long) Marshal.OffsetOf(typeof(GstWebRTCICETransport_roleAlign), "role") + , 0 + ), + new GLib.AbiField("component" + , -1 + , (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.WebRTC.WebRTCICEComponent))) // component + , "role" + , "state" + , (long) Marshal.OffsetOf(typeof(GstWebRTCICETransport_componentAlign), "component") + , 0 + ), + new GLib.AbiField("state" + , -1 + , (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.WebRTC.WebRTCICEConnectionState))) // state + , "component" + , "gathering_state" + , (long) Marshal.OffsetOf(typeof(GstWebRTCICETransport_stateAlign), "state") + , 0 + ), + new GLib.AbiField("gathering_state" + , -1 + , (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.WebRTC.WebRTCICEGatheringState))) // gathering_state + , "state" + , "src" + , (long) Marshal.OffsetOf(typeof(GstWebRTCICETransport_gathering_stateAlign), "gathering_state") + , 0 + ), + new GLib.AbiField("src" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // src + , "gathering_state" + , "sink" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("sink" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // sink + , "src" + , "_padding" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("_padding" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , "sink" + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _abi_info; + } + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCICETransport_roleAlign + { + sbyte f1; + private Gst.WebRTC.WebRTCICERole role; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCICETransport_componentAlign + { + sbyte f1; + private Gst.WebRTC.WebRTCICEComponent component; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCICETransport_stateAlign + { + sbyte f1; + private Gst.WebRTC.WebRTCICEConnectionState state; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCICETransport_gathering_stateAlign + { + sbyte f1; + private Gst.WebRTC.WebRTCICEGatheringState gathering_state; + } + + + // End of the ABI representation. + +#endregion + } +} diff --git a/sources/generated/Gst.WebRTC/WebRTCPeerConnectionState.cs b/sources/generated/Gst.WebRTC/WebRTCPeerConnectionState.cs new file mode 100644 index 0000000000..3b3524f994 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCPeerConnectionState.cs @@ -0,0 +1,32 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCPeerConnectionStateGType))] + public enum WebRTCPeerConnectionState { + + New = 0, + Connecting = 1, + Connected = 2, + Disconnected = 3, + Failed = 4, + Closed = 5, + } + + internal class WebRTCPeerConnectionStateGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_peer_connection_state_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_peer_connection_state_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCRTPReceiver.cs b/sources/generated/Gst.WebRTC/WebRTCRTPReceiver.cs new file mode 100644 index 0000000000..4ed2981c8c --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCRTPReceiver.cs @@ -0,0 +1,140 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Runtime.InteropServices; + +#region Autogenerated code + public partial class WebRTCRTPReceiver : Gst.Object { + + public WebRTCRTPReceiver (IntPtr raw) : base(raw) {} + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_rtp_receiver_new(); + + public WebRTCRTPReceiver () : base (IntPtr.Zero) + { + if (GetType () != typeof (WebRTCRTPReceiver)) { + CreateNativeObject (new string [0], new GLib.Value[0]); + return; + } + Raw = gst_webrtc_rtp_receiver_new(); + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_rtp_receiver_set_transport(IntPtr raw, IntPtr transport); + + public Gst.WebRTC.WebRTCDTLSTransport Transport { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("transport")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.WebRTC.WebRTCDTLSTransport; + } + } + set { + gst_webrtc_rtp_receiver_set_transport(Handle, value == null ? IntPtr.Zero : value.Handle); + } + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_rtp_receiver_set_rtcp_transport(IntPtr raw, IntPtr transport); + + public Gst.WebRTC.WebRTCDTLSTransport RtcpTransport { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("rtcp_transport")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.WebRTC.WebRTCDTLSTransport; + } + } + set { + gst_webrtc_rtp_receiver_set_rtcp_transport(Handle, value == null ? IntPtr.Zero : value.Handle); + } + } + + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _class_abi = null; + static public new GLib.AbiStruct class_abi { + get { + if (_class_abi == null) + _class_abi = new GLib.AbiStruct (new List{ + new GLib.AbiField("_padding" + , Gst.Object.class_abi.Fields + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , null + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _class_abi; + } + } + + + // End of the ABI representation. + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_rtp_receiver_get_type(); + + public static new GLib.GType GType { + get { + IntPtr raw_ret = gst_webrtc_rtp_receiver_get_type(); + GLib.GType ret = new GLib.GType(raw_ret); + return ret; + } + } + + + static WebRTCRTPReceiver () + { + GtkSharp.GstreamerSharp.ObjectManager.Initialize (); + } + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _abi_info = null; + static public new GLib.AbiStruct abi_info { + get { + if (_abi_info == null) + _abi_info = new GLib.AbiStruct (new List{ + new GLib.AbiField("transport" + , Gst.Object.abi_info.Fields + , (uint) Marshal.SizeOf(typeof(IntPtr)) // transport + , null + , "rtcp_transport" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("rtcp_transport" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // rtcp_transport + , "transport" + , "_padding" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("_padding" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , "rtcp_transport" + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _abi_info; + } + } + + + // End of the ABI representation. + +#endregion + } +} diff --git a/sources/generated/Gst.WebRTC/WebRTCRTPSender.cs b/sources/generated/Gst.WebRTC/WebRTCRTPSender.cs new file mode 100644 index 0000000000..d6b4924c72 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCRTPSender.cs @@ -0,0 +1,148 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Runtime.InteropServices; + +#region Autogenerated code + public partial class WebRTCRTPSender : Gst.Object { + + public WebRTCRTPSender (IntPtr raw) : base(raw) {} + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_rtp_sender_new(); + + public WebRTCRTPSender () : base (IntPtr.Zero) + { + if (GetType () != typeof (WebRTCRTPSender)) { + CreateNativeObject (new string [0], new GLib.Value[0]); + return; + } + Raw = gst_webrtc_rtp_sender_new(); + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_rtp_sender_set_transport(IntPtr raw, IntPtr transport); + + public Gst.WebRTC.WebRTCDTLSTransport Transport { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("transport")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.WebRTC.WebRTCDTLSTransport; + } + } + set { + gst_webrtc_rtp_sender_set_transport(Handle, value == null ? IntPtr.Zero : value.Handle); + } + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern void gst_webrtc_rtp_sender_set_rtcp_transport(IntPtr raw, IntPtr transport); + + public Gst.WebRTC.WebRTCDTLSTransport RtcpTransport { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("rtcp_transport")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.WebRTC.WebRTCDTLSTransport; + } + } + set { + gst_webrtc_rtp_sender_set_rtcp_transport(Handle, value == null ? IntPtr.Zero : value.Handle); + } + } + + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _class_abi = null; + static public new GLib.AbiStruct class_abi { + get { + if (_class_abi == null) + _class_abi = new GLib.AbiStruct (new List{ + new GLib.AbiField("_padding" + , Gst.Object.class_abi.Fields + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , null + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _class_abi; + } + } + + + // End of the ABI representation. + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_rtp_sender_get_type(); + + public static new GLib.GType GType { + get { + IntPtr raw_ret = gst_webrtc_rtp_sender_get_type(); + GLib.GType ret = new GLib.GType(raw_ret); + return ret; + } + } + + + static WebRTCRTPSender () + { + GtkSharp.GstreamerSharp.ObjectManager.Initialize (); + } + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _abi_info = null; + static public new GLib.AbiStruct abi_info { + get { + if (_abi_info == null) + _abi_info = new GLib.AbiStruct (new List{ + new GLib.AbiField("transport" + , Gst.Object.abi_info.Fields + , (uint) Marshal.SizeOf(typeof(IntPtr)) // transport + , null + , "rtcp_transport" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("rtcp_transport" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // rtcp_transport + , "transport" + , "send_encodings" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("send_encodings" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // send_encodings + , "rtcp_transport" + , "_padding" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("_padding" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , "send_encodings" + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _abi_info; + } + } + + + // End of the ABI representation. + +#endregion + } +} diff --git a/sources/generated/Gst.WebRTC/WebRTCRTPTransceiver.cs b/sources/generated/Gst.WebRTC/WebRTCRTPTransceiver.cs new file mode 100644 index 0000000000..af4436cfda --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCRTPTransceiver.cs @@ -0,0 +1,281 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Runtime.InteropServices; + +#region Autogenerated code + public partial class WebRTCRTPTransceiver : Gst.Object { + + protected WebRTCRTPTransceiver (IntPtr raw) : base(raw) {} + + protected WebRTCRTPTransceiver() : base(IntPtr.Zero) + { + CreateNativeObject (new string [0], new GLib.Value [0]); + } + + [GLib.Property ("mlineindex")] + public uint Mlineindex { + get { + GLib.Value val = GetProperty ("mlineindex"); + uint ret = (uint) val; + val.Dispose (); + return ret; + } + } + + [GLib.Property ("receiver")] + public Gst.WebRTC.WebRTCRTPReceiver Receiver { + get { + GLib.Value val = GetProperty ("receiver"); + Gst.WebRTC.WebRTCRTPReceiver ret = (Gst.WebRTC.WebRTCRTPReceiver) val; + val.Dispose (); + return ret; + } + } + + [GLib.Property ("sender")] + public Gst.WebRTC.WebRTCRTPSender Sender { + get { + GLib.Value val = GetProperty ("sender"); + Gst.WebRTC.WebRTCRTPSender ret = (Gst.WebRTC.WebRTCRTPSender) val; + val.Dispose (); + return ret; + } + } + + public uint Mline { + get { + unsafe { + uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("mline")); + return (*raw_ptr); + } + } + } + + public string Mid { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("mid")); + return GLib.Marshaller.Utf8PtrToString ((*raw_ptr)); + } + } + } + + public bool Stopped { + get { + unsafe { + bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("stopped")); + return (*raw_ptr); + } + } + } + + public Gst.WebRTC.WebRTCRTPSender SenderField { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("sender")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.WebRTC.WebRTCRTPSender; + } + } + } + + public Gst.WebRTC.WebRTCRTPReceiver ReceiverField { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("receiver")); + return GLib.Object.GetObject((*raw_ptr)) as Gst.WebRTC.WebRTCRTPReceiver; + } + } + } + + public Gst.WebRTC.WebRTCRTPTransceiverDirection Direction { + get { + unsafe { + int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("direction")); + return (Gst.WebRTC.WebRTCRTPTransceiverDirection) (*raw_ptr); + } + } + } + + public Gst.WebRTC.WebRTCRTPTransceiverDirection CurrentDirection { + get { + unsafe { + int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("current_direction")); + return (Gst.WebRTC.WebRTCRTPTransceiverDirection) (*raw_ptr); + } + } + } + + public Gst.Caps CodecPreferences { + get { + unsafe { + IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("codec_preferences")); + return (*raw_ptr) == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque ((*raw_ptr), typeof (Gst.Caps), false); + } + } + } + + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _class_abi = null; + static public new GLib.AbiStruct class_abi { + get { + if (_class_abi == null) + _class_abi = new GLib.AbiStruct (new List{ + new GLib.AbiField("_padding" + , Gst.Object.class_abi.Fields + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , null + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _class_abi; + } + } + + + // End of the ABI representation. + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_rtp_transceiver_get_type(); + + public static new GLib.GType GType { + get { + IntPtr raw_ret = gst_webrtc_rtp_transceiver_get_type(); + GLib.GType ret = new GLib.GType(raw_ret); + return ret; + } + } + + + static WebRTCRTPTransceiver () + { + GtkSharp.GstreamerSharp.ObjectManager.Initialize (); + } + + // Internal representation of the wrapped structure ABI. + static GLib.AbiStruct _abi_info = null; + static public new GLib.AbiStruct abi_info { + get { + if (_abi_info == null) + _abi_info = new GLib.AbiStruct (new List{ + new GLib.AbiField("mline" + , Gst.Object.abi_info.Fields + , (uint) Marshal.SizeOf(typeof(uint)) // mline + , null + , "mid" + , (long) Marshal.OffsetOf(typeof(GstWebRTCRTPTransceiver_mlineAlign), "mline") + , 0 + ), + new GLib.AbiField("mid" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // mid + , "mline" + , "stopped" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("stopped" + , -1 + , (uint) Marshal.SizeOf(typeof(bool)) // stopped + , "mid" + , "sender" + , (long) Marshal.OffsetOf(typeof(GstWebRTCRTPTransceiver_stoppedAlign), "stopped") + , 0 + ), + new GLib.AbiField("sender" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // sender + , "stopped" + , "receiver" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("receiver" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // receiver + , "sender" + , "direction" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("direction" + , -1 + , (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.WebRTC.WebRTCRTPTransceiverDirection))) // direction + , "receiver" + , "current_direction" + , (long) Marshal.OffsetOf(typeof(GstWebRTCRTPTransceiver_directionAlign), "direction") + , 0 + ), + new GLib.AbiField("current_direction" + , -1 + , (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.WebRTC.WebRTCRTPTransceiverDirection))) // current_direction + , "direction" + , "codec_preferences" + , (long) Marshal.OffsetOf(typeof(GstWebRTCRTPTransceiver_current_directionAlign), "current_direction") + , 0 + ), + new GLib.AbiField("codec_preferences" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) // codec_preferences + , "current_direction" + , "_padding" + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + new GLib.AbiField("_padding" + , -1 + , (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _padding + , "codec_preferences" + , null + , (uint) Marshal.SizeOf(typeof(IntPtr)) + , 0 + ), + }); + + return _abi_info; + } + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCRTPTransceiver_mlineAlign + { + sbyte f1; + private uint mline; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCRTPTransceiver_stoppedAlign + { + sbyte f1; + private bool stopped; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCRTPTransceiver_directionAlign + { + sbyte f1; + private Gst.WebRTC.WebRTCRTPTransceiverDirection direction; + } + + [StructLayout(LayoutKind.Sequential)] + public struct GstWebRTCRTPTransceiver_current_directionAlign + { + sbyte f1; + private Gst.WebRTC.WebRTCRTPTransceiverDirection current_direction; + } + + + // End of the ABI representation. + +#endregion + } +} diff --git a/sources/generated/Gst.WebRTC/WebRTCRTPTransceiverDirection.cs b/sources/generated/Gst.WebRTC/WebRTCRTPTransceiverDirection.cs new file mode 100644 index 0000000000..9c1e68fd2d --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCRTPTransceiverDirection.cs @@ -0,0 +1,31 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCRTPTransceiverDirectionGType))] + public enum WebRTCRTPTransceiverDirection { + + None = 0, + Inactive = 1, + Sendonly = 2, + Recvonly = 3, + Sendrecv = 4, + } + + internal class WebRTCRTPTransceiverDirectionGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_rtp_transceiver_direction_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_rtp_transceiver_direction_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCSDPType.cs b/sources/generated/Gst.WebRTC/WebRTCSDPType.cs new file mode 100644 index 0000000000..b39f5673bd --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCSDPType.cs @@ -0,0 +1,30 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCSDPTypeGType))] + public enum WebRTCSDPType { + + Offer = 1, + Pranswer = 2, + Answer = 3, + Rollback = 4, + } + + internal class WebRTCSDPTypeGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_sdp_type_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_sdp_type_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCSessionDescription.cs b/sources/generated/Gst.WebRTC/WebRTCSessionDescription.cs new file mode 100644 index 0000000000..c34ed23358 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCSessionDescription.cs @@ -0,0 +1,83 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Runtime.InteropServices; + +#region Autogenerated code + [StructLayout(LayoutKind.Sequential)] + public partial struct WebRTCSessionDescription : IEquatable { + + public Gst.WebRTC.WebRTCSDPType Type; + private IntPtr _sdp; + public Gst.Sdp.SDPMessage Sdp { + get { + return _sdp == IntPtr.Zero ? null : (Gst.Sdp.SDPMessage) GLib.Opaque.GetOpaque (_sdp, typeof (Gst.Sdp.SDPMessage), false); + } + set { + _sdp = value == null ? IntPtr.Zero : value.Handle; + } + } + + public static Gst.WebRTC.WebRTCSessionDescription Zero = new Gst.WebRTC.WebRTCSessionDescription (); + + public static Gst.WebRTC.WebRTCSessionDescription New(IntPtr raw) { + if (raw == IntPtr.Zero) + return Gst.WebRTC.WebRTCSessionDescription.Zero; + return (Gst.WebRTC.WebRTCSessionDescription) Marshal.PtrToStructure (raw, typeof (Gst.WebRTC.WebRTCSessionDescription)); + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_session_description_new(int type, IntPtr sdp); + + public static WebRTCSessionDescription New(Gst.WebRTC.WebRTCSDPType type, Gst.Sdp.SDPMessage sdp) + { + WebRTCSessionDescription result = WebRTCSessionDescription.New (gst_webrtc_session_description_new((int) type, sdp == null ? IntPtr.Zero : sdp.Handle)); + return result; + } + + [DllImport("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_session_description_get_type(); + + public static GLib.GType GType { + get { + IntPtr raw_ret = gst_webrtc_session_description_get_type(); + GLib.GType ret = new GLib.GType(raw_ret); + return ret; + } + } + + public bool Equals (WebRTCSessionDescription other) + { + return true && Type.Equals (other.Type) && Sdp.Equals (other.Sdp); + } + + public override bool Equals (object other) + { + return other is WebRTCSessionDescription && Equals ((WebRTCSessionDescription) other); + } + + public override int GetHashCode () + { + return this.GetType ().FullName.GetHashCode () ^ Type.GetHashCode () ^ Sdp.GetHashCode (); + } + + public static explicit operator GLib.Value (Gst.WebRTC.WebRTCSessionDescription boxed) + { + GLib.Value val = GLib.Value.Empty; + val.Init (Gst.WebRTC.WebRTCSessionDescription.GType); + val.Val = boxed; + return val; + } + + public static explicit operator Gst.WebRTC.WebRTCSessionDescription (GLib.Value val) + { + return (Gst.WebRTC.WebRTCSessionDescription) val.Val; + } +#endregion + } +} diff --git a/sources/generated/Gst.WebRTC/WebRTCSignalingState.cs b/sources/generated/Gst.WebRTC/WebRTCSignalingState.cs new file mode 100644 index 0000000000..ccad44b223 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCSignalingState.cs @@ -0,0 +1,32 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCSignalingStateGType))] + public enum WebRTCSignalingState { + + Stable = 0, + Closed = 1, + HaveLocalOffer = 2, + HaveRemoteOffer = 3, + HaveLocalPranswer = 4, + HaveRemotePranswer = 5, + } + + internal class WebRTCSignalingStateGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_signaling_state_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_signaling_state_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/Gst.WebRTC/WebRTCStatsType.cs b/sources/generated/Gst.WebRTC/WebRTCStatsType.cs new file mode 100644 index 0000000000..b8916f4415 --- /dev/null +++ b/sources/generated/Gst.WebRTC/WebRTCStatsType.cs @@ -0,0 +1,40 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.WebRTC { + + using System; + using System.Runtime.InteropServices; + +#region Autogenerated code + [GLib.GType (typeof (Gst.WebRTC.WebRTCStatsTypeGType))] + public enum WebRTCStatsType { + + Codec = 1, + InboundRtp = 2, + OutboundRtp = 3, + RemoteInboundRtp = 4, + RemoteOutboundRtp = 5, + Csrc = 6, + PeerConnection = 7, + DataChannel = 8, + Stream = 9, + Transport = 10, + CandidatePair = 11, + LocalCandidate = 12, + RemoteCandidate = 13, + Certificate = 14, + } + + internal class WebRTCStatsTypeGType { + [DllImport ("libgstwebrtc-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)] + static extern IntPtr gst_webrtc_stats_type_get_type (); + + public static GLib.GType GType { + get { + return new GLib.GType (gst_webrtc_stats_type_get_type ()); + } + } + } +#endregion +} diff --git a/sources/generated/GtkSharp/ObjectManager.cs b/sources/generated/GtkSharp/ObjectManager.cs index ba47db25c3..6b410a6f96 100644 --- a/sources/generated/GtkSharp/ObjectManager.cs +++ b/sources/generated/GtkSharp/ObjectManager.cs @@ -69,6 +69,11 @@ namespace GtkSharp.GstreamerSharp { GLib.GType.Register (Gst.Video.VideoEncoder.GType, typeof (Gst.Video.VideoEncoder)); GLib.GType.Register (Gst.Video.VideoFilter.GType, typeof (Gst.Video.VideoFilter)); GLib.GType.Register (Gst.Video.VideoSink.GType, typeof (Gst.Video.VideoSink)); + GLib.GType.Register (Gst.WebRTC.WebRTCDTLSTransport.GType, typeof (Gst.WebRTC.WebRTCDTLSTransport)); + GLib.GType.Register (Gst.WebRTC.WebRTCICETransport.GType, typeof (Gst.WebRTC.WebRTCICETransport)); + GLib.GType.Register (Gst.WebRTC.WebRTCRTPReceiver.GType, typeof (Gst.WebRTC.WebRTCRTPReceiver)); + GLib.GType.Register (Gst.WebRTC.WebRTCRTPSender.GType, typeof (Gst.WebRTC.WebRTCRTPSender)); + GLib.GType.Register (Gst.WebRTC.WebRTCRTPTransceiver.GType, typeof (Gst.WebRTC.WebRTCRTPTransceiver)); } } } diff --git a/sources/generated/gstreamer-sharp-abi.c b/sources/generated/gstreamer-sharp-abi.c index 1e42011056..5b7f57283e 100644 --- a/sources/generated/gstreamer-sharp-abi.c +++ b/sources/generated/gstreamer-sharp-abi.c @@ -21,6 +21,7 @@ #include #include #include +#include int main (int argc, char *argv[]) { g_print("\"sizeof(GstAllocatorClass)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstAllocatorClass)); @@ -944,5 +945,52 @@ int main (int argc, char *argv[]) { g_print("\"GstVideoInfo.fps_d\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstVideoInfo, fps_d)); g_print("\"GstVideoInfo.offset\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstVideoInfo, offset)); g_print("\"GstVideoInfo.stride\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstVideoInfo, stride)); + g_print("\"sizeof(GstWebRTCDTLSTransportClass)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCDTLSTransportClass)); + g_print("\"GstWebRTCDTLSTransportClass._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransportClass, _padding)); + g_print("\"sizeof(GstWebRTCDTLSTransport)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCDTLSTransport)); + g_print("\"GstWebRTCDTLSTransport.transport\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransport, transport)); + g_print("\"GstWebRTCDTLSTransport.state\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransport, state)); + g_print("\"GstWebRTCDTLSTransport.is_rtcp\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransport, is_rtcp)); + g_print("\"GstWebRTCDTLSTransport.client\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransport, client)); + g_print("\"GstWebRTCDTLSTransport.session_id\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransport, session_id)); + g_print("\"GstWebRTCDTLSTransport.dtlssrtpenc\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransport, dtlssrtpenc)); + g_print("\"GstWebRTCDTLSTransport.dtlssrtpdec\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransport, dtlssrtpdec)); + g_print("\"GstWebRTCDTLSTransport._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCDTLSTransport, _padding)); + g_print("\"sizeof(GstWebRTCICETransportClass)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCICETransportClass)); + g_print("\"GstWebRTCICETransportClass.gather_candidates\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransportClass, gather_candidates)); + g_print("\"GstWebRTCICETransportClass._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransportClass, _padding)); + g_print("\"sizeof(GstWebRTCICETransport)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCICETransport)); + g_print("\"GstWebRTCICETransport.role\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransport, role)); + g_print("\"GstWebRTCICETransport.component\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransport, component)); + g_print("\"GstWebRTCICETransport.state\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransport, state)); + g_print("\"GstWebRTCICETransport.gathering_state\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransport, gathering_state)); + g_print("\"GstWebRTCICETransport.src\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransport, src)); + g_print("\"GstWebRTCICETransport.sink\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransport, sink)); + g_print("\"GstWebRTCICETransport._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCICETransport, _padding)); + g_print("\"sizeof(GstWebRTCRTPReceiverClass)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCRTPReceiverClass)); + g_print("\"GstWebRTCRTPReceiverClass._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPReceiverClass, _padding)); + g_print("\"sizeof(GstWebRTCRTPReceiver)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCRTPReceiver)); + g_print("\"GstWebRTCRTPReceiver.transport\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPReceiver, transport)); + g_print("\"GstWebRTCRTPReceiver.rtcp_transport\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPReceiver, rtcp_transport)); + g_print("\"GstWebRTCRTPReceiver._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPReceiver, _padding)); + g_print("\"sizeof(GstWebRTCRTPSenderClass)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCRTPSenderClass)); + g_print("\"GstWebRTCRTPSenderClass._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPSenderClass, _padding)); + g_print("\"sizeof(GstWebRTCRTPSender)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCRTPSender)); + g_print("\"GstWebRTCRTPSender.transport\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPSender, transport)); + g_print("\"GstWebRTCRTPSender.rtcp_transport\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPSender, rtcp_transport)); + g_print("\"GstWebRTCRTPSender.send_encodings\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPSender, send_encodings)); + g_print("\"GstWebRTCRTPSender._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPSender, _padding)); + g_print("\"sizeof(GstWebRTCRTPTransceiverClass)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCRTPTransceiverClass)); + g_print("\"GstWebRTCRTPTransceiverClass._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiverClass, _padding)); + g_print("\"sizeof(GstWebRTCRTPTransceiver)\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) sizeof(GstWebRTCRTPTransceiver)); + g_print("\"GstWebRTCRTPTransceiver.mline\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, mline)); + g_print("\"GstWebRTCRTPTransceiver.mid\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, mid)); + g_print("\"GstWebRTCRTPTransceiver.stopped\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, stopped)); + g_print("\"GstWebRTCRTPTransceiver.sender\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, sender)); + g_print("\"GstWebRTCRTPTransceiver.receiver\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, receiver)); + g_print("\"GstWebRTCRTPTransceiver.direction\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, direction)); + g_print("\"GstWebRTCRTPTransceiver.current_direction\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, current_direction)); + g_print("\"GstWebRTCRTPTransceiver.codec_preferences\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, codec_preferences)); + g_print("\"GstWebRTCRTPTransceiver._padding\": \"%" G_GUINT64_FORMAT "\"\n", (guint64) G_STRUCT_OFFSET(GstWebRTCRTPTransceiver, _padding)); return 0; } diff --git a/sources/generated/gstreamer-sharp-abi.cs b/sources/generated/gstreamer-sharp-abi.cs index 27332da914..df93275720 100644 --- a/sources/generated/gstreamer-sharp-abi.cs +++ b/sources/generated/gstreamer-sharp-abi.cs @@ -939,6 +939,53 @@ namespace AbiTester { Console.WriteLine("\"GstVideoInfo.fps_d\": \"" + Gst.Video.VideoInfo.abi_info.GetFieldOffset("fps_d") + "\""); Console.WriteLine("\"GstVideoInfo.offset\": \"" + Gst.Video.VideoInfo.abi_info.GetFieldOffset("offset") + "\""); Console.WriteLine("\"GstVideoInfo.stride\": \"" + Gst.Video.VideoInfo.abi_info.GetFieldOffset("stride") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCDTLSTransportClass)\": \"" + Gst.WebRTC.WebRTCDTLSTransport.class_abi.Size + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransportClass._padding\": \"" + Gst.WebRTC.WebRTCDTLSTransport.class_abi.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCDTLSTransport)\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.Size + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransport.transport\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.GetFieldOffset("transport") + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransport.state\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.GetFieldOffset("state") + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransport.is_rtcp\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.GetFieldOffset("is_rtcp") + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransport.client\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.GetFieldOffset("client") + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransport.session_id\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.GetFieldOffset("session_id") + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransport.dtlssrtpenc\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.GetFieldOffset("dtlssrtpenc") + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransport.dtlssrtpdec\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.GetFieldOffset("dtlssrtpdec") + "\""); + Console.WriteLine("\"GstWebRTCDTLSTransport._padding\": \"" + Gst.WebRTC.WebRTCDTLSTransport.abi_info.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCICETransportClass)\": \"" + Gst.WebRTC.WebRTCICETransport.class_abi.Size + "\""); + Console.WriteLine("\"GstWebRTCICETransportClass.gather_candidates\": \"" + Gst.WebRTC.WebRTCICETransport.class_abi.GetFieldOffset("gather_candidates") + "\""); + Console.WriteLine("\"GstWebRTCICETransportClass._padding\": \"" + Gst.WebRTC.WebRTCICETransport.class_abi.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCICETransport)\": \"" + Gst.WebRTC.WebRTCICETransport.abi_info.Size + "\""); + Console.WriteLine("\"GstWebRTCICETransport.role\": \"" + Gst.WebRTC.WebRTCICETransport.abi_info.GetFieldOffset("role") + "\""); + Console.WriteLine("\"GstWebRTCICETransport.component\": \"" + Gst.WebRTC.WebRTCICETransport.abi_info.GetFieldOffset("component") + "\""); + Console.WriteLine("\"GstWebRTCICETransport.state\": \"" + Gst.WebRTC.WebRTCICETransport.abi_info.GetFieldOffset("state") + "\""); + Console.WriteLine("\"GstWebRTCICETransport.gathering_state\": \"" + Gst.WebRTC.WebRTCICETransport.abi_info.GetFieldOffset("gathering_state") + "\""); + Console.WriteLine("\"GstWebRTCICETransport.src\": \"" + Gst.WebRTC.WebRTCICETransport.abi_info.GetFieldOffset("src") + "\""); + Console.WriteLine("\"GstWebRTCICETransport.sink\": \"" + Gst.WebRTC.WebRTCICETransport.abi_info.GetFieldOffset("sink") + "\""); + Console.WriteLine("\"GstWebRTCICETransport._padding\": \"" + Gst.WebRTC.WebRTCICETransport.abi_info.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCRTPReceiverClass)\": \"" + Gst.WebRTC.WebRTCRTPReceiver.class_abi.Size + "\""); + Console.WriteLine("\"GstWebRTCRTPReceiverClass._padding\": \"" + Gst.WebRTC.WebRTCRTPReceiver.class_abi.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCRTPReceiver)\": \"" + Gst.WebRTC.WebRTCRTPReceiver.abi_info.Size + "\""); + Console.WriteLine("\"GstWebRTCRTPReceiver.transport\": \"" + Gst.WebRTC.WebRTCRTPReceiver.abi_info.GetFieldOffset("transport") + "\""); + Console.WriteLine("\"GstWebRTCRTPReceiver.rtcp_transport\": \"" + Gst.WebRTC.WebRTCRTPReceiver.abi_info.GetFieldOffset("rtcp_transport") + "\""); + Console.WriteLine("\"GstWebRTCRTPReceiver._padding\": \"" + Gst.WebRTC.WebRTCRTPReceiver.abi_info.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCRTPSenderClass)\": \"" + Gst.WebRTC.WebRTCRTPSender.class_abi.Size + "\""); + Console.WriteLine("\"GstWebRTCRTPSenderClass._padding\": \"" + Gst.WebRTC.WebRTCRTPSender.class_abi.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCRTPSender)\": \"" + Gst.WebRTC.WebRTCRTPSender.abi_info.Size + "\""); + Console.WriteLine("\"GstWebRTCRTPSender.transport\": \"" + Gst.WebRTC.WebRTCRTPSender.abi_info.GetFieldOffset("transport") + "\""); + Console.WriteLine("\"GstWebRTCRTPSender.rtcp_transport\": \"" + Gst.WebRTC.WebRTCRTPSender.abi_info.GetFieldOffset("rtcp_transport") + "\""); + Console.WriteLine("\"GstWebRTCRTPSender.send_encodings\": \"" + Gst.WebRTC.WebRTCRTPSender.abi_info.GetFieldOffset("send_encodings") + "\""); + Console.WriteLine("\"GstWebRTCRTPSender._padding\": \"" + Gst.WebRTC.WebRTCRTPSender.abi_info.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCRTPTransceiverClass)\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.class_abi.Size + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiverClass._padding\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.class_abi.GetFieldOffset("_padding") + "\""); + Console.WriteLine("\"sizeof(GstWebRTCRTPTransceiver)\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.Size + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver.mline\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("mline") + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver.mid\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("mid") + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver.stopped\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("stopped") + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver.sender\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("sender") + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver.receiver\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("receiver") + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver.direction\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("direction") + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver.current_direction\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("current_direction") + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver.codec_preferences\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("codec_preferences") + "\""); + Console.WriteLine("\"GstWebRTCRTPTransceiver._padding\": \"" + Gst.WebRTC.WebRTCRTPTransceiver.abi_info.GetFieldOffset("_padding") + "\""); } } } diff --git a/sources/generated/gstreamer-sharp-api.xml b/sources/generated/gstreamer-sharp-api.xml index d7bf61f8aa..53e047e00b 100644 --- a/sources/generated/gstreamer-sharp-api.xml +++ b/sources/generated/gstreamer-sharp-api.xml @@ -28814,4 +28814,305 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/sources/generated/meson.build b/sources/generated/meson.build index 5a82c3c068..942ef08eb5 100644 --- a/sources/generated/meson.build +++ b/sources/generated/meson.build @@ -722,6 +722,26 @@ generated_sources = [ 'Gst.Rtsp/Gst.RtspSharp.RTSPConnectionAcceptCertificateFuncNative.cs', 'Gst.Audio/AudioStreamAlign.cs', 'Gst.Video/VideoOverlayProperties.cs', + 'Gst.WebRTC/WebRTCPeerConnectionState.cs', + 'Gst.WebRTC/WebRTCSessionDescription.cs', + 'Gst.WebRTC/WebRTCICEGatheringState.cs', + 'Gst.WebRTC/WebRTCRTPTransceiverDirection.cs', + 'Gst.WebRTC/WebRTCRTPTransceiver.cs', + 'Gst.WebRTC/OnNewCandidateHandler.cs', + 'Gst.WebRTC/WebRTCICERole.cs', + 'Gst.WebRTC/Global.cs', + 'Gst.WebRTC/WebRTCICEComponent.cs', + 'Gst.WebRTC/WebRTCICEConnectionState.cs', + 'Gst.WebRTC/WebRTCDTLSTransport.cs', + 'Gst.WebRTC/WebRTCICETransport.cs', + 'Gst.WebRTC/WebRTCSDPType.cs', + 'Gst.WebRTC/WebRTCRTPSender.cs', + 'Gst.WebRTC/WebRTCSignalingState.cs', + 'Gst.WebRTC/WebRTCDTLSTransportState.cs', + 'Gst.WebRTC/WebRTCDTLSSetup.cs', + 'Gst.WebRTC/WebRTCRTPReceiver.cs', + 'Gst.WebRTC/WebRTCStatsType.cs', + 'Gst.WebRTC/Constants.cs', ] run_target('update_gstreamer_code', diff --git a/sources/gstreamer-sharp-api.raw b/sources/gstreamer-sharp-api.raw index 23c852e1fb..d132b09d6e 100644 --- a/sources/gstreamer-sharp-api.raw +++ b/sources/gstreamer-sharp-api.raw @@ -29184,4 +29184,305 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/sources/gstreamer-sharp.dll.config b/sources/gstreamer-sharp.dll.config index cb98e23dc8..63059b373f 100644 --- a/sources/gstreamer-sharp.dll.config +++ b/sources/gstreamer-sharp.dll.config @@ -12,6 +12,7 @@ + @@ -29,6 +30,7 @@ + diff --git a/sources/gstreamer-sharp.metadata b/sources/gstreamer-sharp.metadata index d710b4aebb..fb726b2880 100644 --- a/sources/gstreamer-sharp.metadata +++ b/sources/gstreamer-sharp.metadata @@ -243,6 +243,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA Gst.Rtp Gst.Rtsp Gst.Sdp + Gst.WebRTC libgstreamer-1.0-0.dll libgstbase-1.0-0.dll @@ -258,6 +259,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA libgstrtp-1.0-0.dll libgstrtsp-1.0-0.dll libgstsdp-1.0-0.dll + libgstwebrtc-1.0-0.dll true diff --git a/sources/meson.build b/sources/meson.build index 2eea17268a..6b44a7d7ea 100644 --- a/sources/meson.build +++ b/sources/meson.build @@ -1,7 +1,7 @@ raw_api_fname = join_paths(meson.current_source_dir(), meson.project_name() + '-api.raw') metadata = files(meson.project_name() + '.metadata') -abi_includes = 'glib.h,gst/gst.h,gst/video/video.h,gst/audio/audio.h,gst/rtsp/rtsp.h,gst/app/app.h,gst/audio/audio.h,gst/base/base.h,gst/controller/controller.h,gst/fft/fft.h,gst/net/net.h,gst/pbutils/gstaudiovisualizer.h,gst/pbutils/pbutils.h,gst/rtp/rtp.h,gst/rtsp/rtsp.h,gst/sdp/sdp.h,gst/tag/tag.h,gst/video/video.h,gst/video/gstvideoaffinetransformationmeta.h,gst/net/gstnetcontrolmessagemeta.h' +abi_includes = 'glib.h,gst/gst.h,gst/video/video.h,gst/audio/audio.h,gst/rtsp/rtsp.h,gst/app/app.h,gst/audio/audio.h,gst/base/base.h,gst/controller/controller.h,gst/fft/fft.h,gst/net/net.h,gst/pbutils/gstaudiovisualizer.h,gst/pbutils/pbutils.h,gst/rtp/rtp.h,gst/rtsp/rtsp.h,gst/sdp/sdp.h,gst/tag/tag.h,gst/video/video.h,gst/video/gstvideoaffinetransformationmeta.h,gst/net/gstnetcontrolmessagemeta.h,gst/webrtc/webrtc.h' sources = [ 'custom/Adapter.cs', @@ -43,7 +43,7 @@ gst_sharp_dep = declare_dependency(dependencies: [glib_sharp_dep, gio_sharp_dep] if add_languages('c', required: false) and csc.get_id() == 'mono' c_abi_exe = executable('gst_sharp_c_abi', c_abi, - cs_args: ['-nowarn:169', '-nowarn:108', '-nowarn:114', '-unsafe'], + c_args: ['-DGST_USE_UNSTABLE_API'], dependencies: [gst_deps]) cs_abi_exe = executable('gst_sharp_cs_abi', cs_abi, -- 2.34.1