mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-21 07:46:38 +00:00
4e31f2def5
With a few unnecessary gst_rtsp_stream_transport_* methods manually disabled to avoid compilation errors. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/5961>
2082 lines
67 KiB
C#
2082 lines
67 KiB
C#
// This file was generated by the Gtk# code generator.
|
|
// Any changes made will be lost if regenerated.
|
|
|
|
namespace Gst.RtspServer {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
#region Autogenerated code
|
|
public partial class RTSPMedia : GLib.Object {
|
|
|
|
public RTSPMedia (IntPtr raw) : base(raw) {}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_new(IntPtr element);
|
|
|
|
public RTSPMedia (Gst.Element element) : base (IntPtr.Zero)
|
|
{
|
|
if (GetType () != typeof (RTSPMedia)) {
|
|
var vals = new List<GLib.Value> ();
|
|
var names = new List<string> ();
|
|
if (element != null) {
|
|
names.Add ("element");
|
|
vals.Add (new GLib.Value (element));
|
|
}
|
|
CreateNativeObject (names.ToArray (), vals.ToArray ());
|
|
return;
|
|
}
|
|
Raw = gst_rtsp_media_new(element == null ? IntPtr.Zero : element.OwnedHandle);
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_bind_mcast_address(IntPtr raw, bool bind_mcast_addr);
|
|
|
|
[GLib.Property ("bind-mcast-address")]
|
|
public bool BindMcastAddress {
|
|
get {
|
|
GLib.Value val = GetProperty ("bind-mcast-address");
|
|
bool ret = (bool) val;
|
|
val.Dispose ();
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_bind_mcast_address(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern uint gst_rtsp_media_get_buffer_size(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_buffer_size(IntPtr raw, uint size);
|
|
|
|
[GLib.Property ("buffer-size")]
|
|
public uint BufferSize {
|
|
get {
|
|
uint raw_ret = gst_rtsp_media_get_buffer_size(Handle);
|
|
uint ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_buffer_size(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_clock(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_clock(IntPtr raw, IntPtr clock);
|
|
|
|
[GLib.Property ("clock")]
|
|
public Gst.Clock Clock {
|
|
get {
|
|
IntPtr raw_ret = gst_rtsp_media_get_clock(Handle);
|
|
Gst.Clock ret = GLib.Object.GetObject(raw_ret, true) as Gst.Clock;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_clock(Handle, value == null ? IntPtr.Zero : value.Handle);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern int gst_rtsp_media_get_dscp_qos(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_dscp_qos(IntPtr raw, int dscp_qos);
|
|
|
|
[GLib.Property ("dscp-qos")]
|
|
public int DscpQos {
|
|
get {
|
|
int raw_ret = gst_rtsp_media_get_dscp_qos(Handle);
|
|
int ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_dscp_qos(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_element(IntPtr raw);
|
|
|
|
[GLib.Property ("element")]
|
|
public Gst.Element Element {
|
|
get {
|
|
IntPtr raw_ret = gst_rtsp_media_get_element(Handle);
|
|
Gst.Element ret = GLib.Object.GetObject(raw_ret, true) as Gst.Element;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_get_ensure_keyunit_on_start(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_ensure_keyunit_on_start(IntPtr raw, bool ensure_keyunit_on_start);
|
|
|
|
[GLib.Property ("ensure-keyunit-on-start")]
|
|
public bool EnsureKeyunitOnStart {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_get_ensure_keyunit_on_start(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_ensure_keyunit_on_start(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern uint gst_rtsp_media_get_ensure_keyunit_on_start_timeout(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_ensure_keyunit_on_start_timeout(IntPtr raw, uint timeout);
|
|
|
|
[GLib.Property ("ensure-keyunit-on-start-timeout")]
|
|
public uint EnsureKeyunitOnStartTimeout {
|
|
get {
|
|
uint raw_ret = gst_rtsp_media_get_ensure_keyunit_on_start_timeout(Handle);
|
|
uint ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_ensure_keyunit_on_start_timeout(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_eos_shutdown(IntPtr raw, bool eos_shutdown);
|
|
|
|
[GLib.Property ("eos-shutdown")]
|
|
public bool EosShutdown {
|
|
get {
|
|
GLib.Value val = GetProperty ("eos-shutdown");
|
|
bool ret = (bool) val;
|
|
val.Dispose ();
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_eos_shutdown(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern uint gst_rtsp_media_get_latency(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_latency(IntPtr raw, uint latency);
|
|
|
|
[GLib.Property ("latency")]
|
|
public uint Latency {
|
|
get {
|
|
uint raw_ret = gst_rtsp_media_get_latency(Handle);
|
|
uint ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_latency(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern uint gst_rtsp_media_get_max_mcast_ttl(IntPtr raw);
|
|
|
|
[GLib.Property ("max-mcast-ttl")]
|
|
public uint MaxMcastTtl {
|
|
get {
|
|
uint raw_ret = gst_rtsp_media_get_max_mcast_ttl(Handle);
|
|
uint ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
GLib.Value val = new GLib.Value(value);
|
|
SetProperty("max-mcast-ttl", val);
|
|
val.Dispose ();
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern int gst_rtsp_media_get_profiles(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_profiles(IntPtr raw, int profiles);
|
|
|
|
[GLib.Property ("profiles")]
|
|
public Gst.Rtsp.RTSPProfile Profiles {
|
|
get {
|
|
int raw_ret = gst_rtsp_media_get_profiles(Handle);
|
|
Gst.Rtsp.RTSPProfile ret = (Gst.Rtsp.RTSPProfile) raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_profiles(Handle, (int) value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern int gst_rtsp_media_get_protocols(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_protocols(IntPtr raw, int protocols);
|
|
|
|
[GLib.Property ("protocols")]
|
|
public Gst.Rtsp.RTSPLowerTrans Protocols {
|
|
get {
|
|
int raw_ret = gst_rtsp_media_get_protocols(Handle);
|
|
Gst.Rtsp.RTSPLowerTrans ret = (Gst.Rtsp.RTSPLowerTrans) raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_protocols(Handle, (int) value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_reusable(IntPtr raw, bool reusable);
|
|
|
|
[GLib.Property ("reusable")]
|
|
public bool Reusable {
|
|
get {
|
|
GLib.Value val = GetProperty ("reusable");
|
|
bool ret = (bool) val;
|
|
val.Dispose ();
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_reusable(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_shared(IntPtr raw, bool shared);
|
|
|
|
[GLib.Property ("shared")]
|
|
public bool Shared {
|
|
get {
|
|
GLib.Value val = GetProperty ("shared");
|
|
bool ret = (bool) val;
|
|
val.Dispose ();
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_shared(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_stop_on_disconnect(IntPtr raw, bool stop_on_disconnect);
|
|
|
|
[GLib.Property ("stop-on-disconnect")]
|
|
public bool StopOnDisconnect {
|
|
get {
|
|
GLib.Value val = GetProperty ("stop-on-disconnect");
|
|
bool ret = (bool) val;
|
|
val.Dispose ();
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_stop_on_disconnect(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern int gst_rtsp_media_get_suspend_mode(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_suspend_mode(IntPtr raw, int mode);
|
|
|
|
[GLib.Property ("suspend-mode")]
|
|
public Gst.RtspServer.RTSPSuspendMode SuspendMode {
|
|
get {
|
|
int raw_ret = gst_rtsp_media_get_suspend_mode(Handle);
|
|
Gst.RtspServer.RTSPSuspendMode ret = (Gst.RtspServer.RTSPSuspendMode) raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_suspend_mode(Handle, (int) value);
|
|
}
|
|
}
|
|
|
|
[GLib.Property ("time-provider")]
|
|
public bool TimeProvider {
|
|
get {
|
|
GLib.Value val = GetProperty ("time-provider");
|
|
bool ret = (bool) val;
|
|
val.Dispose ();
|
|
return ret;
|
|
}
|
|
set {
|
|
GLib.Value val = new GLib.Value(value);
|
|
SetProperty("time-provider", val);
|
|
val.Dispose ();
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern int gst_rtsp_media_get_transport_mode(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_transport_mode(IntPtr raw, int mode);
|
|
|
|
[GLib.Property ("transport-mode")]
|
|
public Gst.RtspServer.RTSPTransportMode TransportMode {
|
|
get {
|
|
int raw_ret = gst_rtsp_media_get_transport_mode(Handle);
|
|
Gst.RtspServer.RTSPTransportMode ret = (Gst.RtspServer.RTSPTransportMode) raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_transport_mode(Handle, (int) value);
|
|
}
|
|
}
|
|
|
|
[GLib.Signal("new-state")]
|
|
public event Gst.RtspServer.NewStateHandler NewState {
|
|
add {
|
|
this.AddSignalHandler ("new-state", value, typeof (Gst.RtspServer.NewStateArgs));
|
|
}
|
|
remove {
|
|
this.RemoveSignalHandler ("new-state", value);
|
|
}
|
|
}
|
|
|
|
[GLib.Signal("unprepared")]
|
|
public event System.EventHandler Unprepared {
|
|
add {
|
|
this.AddSignalHandler ("unprepared", value);
|
|
}
|
|
remove {
|
|
this.RemoveSignalHandler ("unprepared", value);
|
|
}
|
|
}
|
|
|
|
[GLib.Signal("removed-stream")]
|
|
public event Gst.RtspServer.RemovedStreamHandler RemovedStream {
|
|
add {
|
|
this.AddSignalHandler ("removed-stream", value, typeof (Gst.RtspServer.RemovedStreamArgs));
|
|
}
|
|
remove {
|
|
this.RemoveSignalHandler ("removed-stream", value);
|
|
}
|
|
}
|
|
|
|
[GLib.Signal("new-stream")]
|
|
public event Gst.RtspServer.NewStreamHandler NewStream {
|
|
add {
|
|
this.AddSignalHandler ("new-stream", value, typeof (Gst.RtspServer.NewStreamArgs));
|
|
}
|
|
remove {
|
|
this.RemoveSignalHandler ("new-stream", value);
|
|
}
|
|
}
|
|
|
|
[GLib.Signal("prepared")]
|
|
public event System.EventHandler Prepared {
|
|
add {
|
|
this.AddSignalHandler ("prepared", value);
|
|
}
|
|
remove {
|
|
this.RemoveSignalHandler ("prepared", value);
|
|
}
|
|
}
|
|
|
|
[GLib.Signal("handle-message")]
|
|
public event Gst.RtspServer.HandleMessageHandler HandleMessage {
|
|
add {
|
|
this.AddSignalHandler ("handle-message", value, typeof (Gst.RtspServer.HandleMessageArgs));
|
|
}
|
|
remove {
|
|
this.RemoveSignalHandler ("handle-message", value);
|
|
}
|
|
}
|
|
|
|
[GLib.Signal("target-state")]
|
|
public event Gst.RtspServer.TargetStateHandler TargetState {
|
|
add {
|
|
this.AddSignalHandler ("target-state", value, typeof (Gst.RtspServer.TargetStateArgs));
|
|
}
|
|
remove {
|
|
this.RemoveSignalHandler ("target-state", value);
|
|
}
|
|
}
|
|
|
|
static HandleMessageNativeDelegate HandleMessage_cb_delegate;
|
|
static HandleMessageNativeDelegate HandleMessageVMCallback {
|
|
get {
|
|
if (HandleMessage_cb_delegate == null)
|
|
HandleMessage_cb_delegate = new HandleMessageNativeDelegate (HandleMessage_cb);
|
|
return HandleMessage_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideHandleMessage (GLib.GType gtype)
|
|
{
|
|
OverrideHandleMessage (gtype, HandleMessageVMCallback);
|
|
}
|
|
|
|
static void OverrideHandleMessage (GLib.GType gtype, HandleMessageNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_message"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool HandleMessageNativeDelegate (IntPtr inst, IntPtr message);
|
|
|
|
static bool HandleMessage_cb (IntPtr inst, IntPtr message)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnHandleMessage (message == IntPtr.Zero ? null : (Gst.Message) GLib.Opaque.GetOpaque (message, typeof (Gst.Message), false));
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideHandleMessage")]
|
|
protected virtual bool OnHandleMessage (Gst.Message message)
|
|
{
|
|
return InternalHandleMessage (message);
|
|
}
|
|
|
|
private bool InternalHandleMessage (Gst.Message message)
|
|
{
|
|
HandleMessageNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_message"));
|
|
unmanaged = (HandleMessageNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(HandleMessageNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
bool __result = unmanaged (this.Handle, message == null ? IntPtr.Zero : message.Handle);
|
|
return __result;
|
|
}
|
|
|
|
static PrepareNativeDelegate Prepare_cb_delegate;
|
|
static PrepareNativeDelegate PrepareVMCallback {
|
|
get {
|
|
if (Prepare_cb_delegate == null)
|
|
Prepare_cb_delegate = new PrepareNativeDelegate (Prepare_cb);
|
|
return Prepare_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverridePrepare (GLib.GType gtype)
|
|
{
|
|
OverridePrepare (gtype, PrepareVMCallback);
|
|
}
|
|
|
|
static void OverridePrepare (GLib.GType gtype, PrepareNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool PrepareNativeDelegate (IntPtr inst, IntPtr thread);
|
|
|
|
static bool Prepare_cb (IntPtr inst, IntPtr thread)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnPrepare (thread == IntPtr.Zero ? null : (Gst.RtspServer.RTSPThread) GLib.Opaque.GetOpaque (thread, typeof (Gst.RtspServer.RTSPThread), true));
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverridePrepare")]
|
|
protected virtual bool OnPrepare (Gst.RtspServer.RTSPThread thread)
|
|
{
|
|
return InternalPrepare (thread);
|
|
}
|
|
|
|
private bool InternalPrepare (Gst.RtspServer.RTSPThread thread)
|
|
{
|
|
PrepareNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare"));
|
|
unmanaged = (PrepareNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrepareNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
thread.Owned = false;
|
|
bool __result = unmanaged (this.Handle, thread == null ? IntPtr.Zero : thread.Handle);
|
|
return __result;
|
|
}
|
|
|
|
static UnprepareNativeDelegate Unprepare_cb_delegate;
|
|
static UnprepareNativeDelegate UnprepareVMCallback {
|
|
get {
|
|
if (Unprepare_cb_delegate == null)
|
|
Unprepare_cb_delegate = new UnprepareNativeDelegate (Unprepare_cb);
|
|
return Unprepare_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideUnprepare (GLib.GType gtype)
|
|
{
|
|
OverrideUnprepare (gtype, UnprepareVMCallback);
|
|
}
|
|
|
|
static void OverrideUnprepare (GLib.GType gtype, UnprepareNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepare"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool UnprepareNativeDelegate (IntPtr inst);
|
|
|
|
static bool Unprepare_cb (IntPtr inst)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnUnprepare ();
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideUnprepare")]
|
|
protected virtual bool OnUnprepare ()
|
|
{
|
|
return InternalUnprepare ();
|
|
}
|
|
|
|
private bool InternalUnprepare ()
|
|
{
|
|
UnprepareNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepare"));
|
|
unmanaged = (UnprepareNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnprepareNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
bool __result = unmanaged (this.Handle);
|
|
return __result;
|
|
}
|
|
|
|
static SuspendNativeDelegate Suspend_cb_delegate;
|
|
static SuspendNativeDelegate SuspendVMCallback {
|
|
get {
|
|
if (Suspend_cb_delegate == null)
|
|
Suspend_cb_delegate = new SuspendNativeDelegate (Suspend_cb);
|
|
return Suspend_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideSuspend (GLib.GType gtype)
|
|
{
|
|
OverrideSuspend (gtype, SuspendVMCallback);
|
|
}
|
|
|
|
static void OverrideSuspend (GLib.GType gtype, SuspendNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("suspend"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool SuspendNativeDelegate (IntPtr inst);
|
|
|
|
static bool Suspend_cb (IntPtr inst)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnSuspend ();
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideSuspend")]
|
|
protected virtual bool OnSuspend ()
|
|
{
|
|
return InternalSuspend ();
|
|
}
|
|
|
|
private bool InternalSuspend ()
|
|
{
|
|
SuspendNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("suspend"));
|
|
unmanaged = (SuspendNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SuspendNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
bool __result = unmanaged (this.Handle);
|
|
return __result;
|
|
}
|
|
|
|
static UnsuspendNativeDelegate Unsuspend_cb_delegate;
|
|
static UnsuspendNativeDelegate UnsuspendVMCallback {
|
|
get {
|
|
if (Unsuspend_cb_delegate == null)
|
|
Unsuspend_cb_delegate = new UnsuspendNativeDelegate (Unsuspend_cb);
|
|
return Unsuspend_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideUnsuspend (GLib.GType gtype)
|
|
{
|
|
OverrideUnsuspend (gtype, UnsuspendVMCallback);
|
|
}
|
|
|
|
static void OverrideUnsuspend (GLib.GType gtype, UnsuspendNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("unsuspend"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool UnsuspendNativeDelegate (IntPtr inst);
|
|
|
|
static bool Unsuspend_cb (IntPtr inst)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnUnsuspend ();
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideUnsuspend")]
|
|
protected virtual bool OnUnsuspend ()
|
|
{
|
|
return InternalUnsuspend ();
|
|
}
|
|
|
|
private bool InternalUnsuspend ()
|
|
{
|
|
UnsuspendNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unsuspend"));
|
|
unmanaged = (UnsuspendNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnsuspendNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
bool __result = unmanaged (this.Handle);
|
|
return __result;
|
|
}
|
|
|
|
static ConvertRangeNativeDelegate ConvertRange_cb_delegate;
|
|
static ConvertRangeNativeDelegate ConvertRangeVMCallback {
|
|
get {
|
|
if (ConvertRange_cb_delegate == null)
|
|
ConvertRange_cb_delegate = new ConvertRangeNativeDelegate (ConvertRange_cb);
|
|
return ConvertRange_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideConvertRange (GLib.GType gtype)
|
|
{
|
|
OverrideConvertRange (gtype, ConvertRangeVMCallback);
|
|
}
|
|
|
|
static void OverrideConvertRange (GLib.GType gtype, ConvertRangeNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("convert_range"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool ConvertRangeNativeDelegate (IntPtr inst, IntPtr range, int unit);
|
|
|
|
static bool ConvertRange_cb (IntPtr inst, IntPtr range, int unit)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnConvertRange (Gst.Rtsp.RTSPTimeRange.New (range), (Gst.Rtsp.RTSPRangeUnit) unit);
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideConvertRange")]
|
|
protected virtual bool OnConvertRange (Gst.Rtsp.RTSPTimeRange range, Gst.Rtsp.RTSPRangeUnit unit)
|
|
{
|
|
return InternalConvertRange (range, unit);
|
|
}
|
|
|
|
private bool InternalConvertRange (Gst.Rtsp.RTSPTimeRange range, Gst.Rtsp.RTSPRangeUnit unit)
|
|
{
|
|
ConvertRangeNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("convert_range"));
|
|
unmanaged = (ConvertRangeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ConvertRangeNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
|
|
bool __result = unmanaged (this.Handle, native_range, (int) unit);
|
|
Marshal.FreeHGlobal (native_range);
|
|
return __result;
|
|
}
|
|
|
|
static QueryPositionNativeDelegate QueryPosition_cb_delegate;
|
|
static QueryPositionNativeDelegate QueryPositionVMCallback {
|
|
get {
|
|
if (QueryPosition_cb_delegate == null)
|
|
QueryPosition_cb_delegate = new QueryPositionNativeDelegate (QueryPosition_cb);
|
|
return QueryPosition_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideQueryPosition (GLib.GType gtype)
|
|
{
|
|
OverrideQueryPosition (gtype, QueryPositionVMCallback);
|
|
}
|
|
|
|
static void OverrideQueryPosition (GLib.GType gtype, QueryPositionNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_position"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool QueryPositionNativeDelegate (IntPtr inst, long position);
|
|
|
|
static bool QueryPosition_cb (IntPtr inst, long position)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnQueryPosition (position);
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideQueryPosition")]
|
|
protected virtual bool OnQueryPosition (long position)
|
|
{
|
|
return InternalQueryPosition (position);
|
|
}
|
|
|
|
private bool InternalQueryPosition (long position)
|
|
{
|
|
QueryPositionNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query_position"));
|
|
unmanaged = (QueryPositionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryPositionNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
bool __result = unmanaged (this.Handle, position);
|
|
return __result;
|
|
}
|
|
|
|
static QueryStopNativeDelegate QueryStop_cb_delegate;
|
|
static QueryStopNativeDelegate QueryStopVMCallback {
|
|
get {
|
|
if (QueryStop_cb_delegate == null)
|
|
QueryStop_cb_delegate = new QueryStopNativeDelegate (QueryStop_cb);
|
|
return QueryStop_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideQueryStop (GLib.GType gtype)
|
|
{
|
|
OverrideQueryStop (gtype, QueryStopVMCallback);
|
|
}
|
|
|
|
static void OverrideQueryStop (GLib.GType gtype, QueryStopNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_stop"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool QueryStopNativeDelegate (IntPtr inst, long stop);
|
|
|
|
static bool QueryStop_cb (IntPtr inst, long stop)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnQueryStop (stop);
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideQueryStop")]
|
|
protected virtual bool OnQueryStop (long stop)
|
|
{
|
|
return InternalQueryStop (stop);
|
|
}
|
|
|
|
private bool InternalQueryStop (long stop)
|
|
{
|
|
QueryStopNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query_stop"));
|
|
unmanaged = (QueryStopNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryStopNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
bool __result = unmanaged (this.Handle, stop);
|
|
return __result;
|
|
}
|
|
|
|
static SetupRtpbinNativeDelegate SetupRtpbin_cb_delegate;
|
|
static SetupRtpbinNativeDelegate SetupRtpbinVMCallback {
|
|
get {
|
|
if (SetupRtpbin_cb_delegate == null)
|
|
SetupRtpbin_cb_delegate = new SetupRtpbinNativeDelegate (SetupRtpbin_cb);
|
|
return SetupRtpbin_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideSetupRtpbin (GLib.GType gtype)
|
|
{
|
|
OverrideSetupRtpbin (gtype, SetupRtpbinVMCallback);
|
|
}
|
|
|
|
static void OverrideSetupRtpbin (GLib.GType gtype, SetupRtpbinNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_rtpbin"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool SetupRtpbinNativeDelegate (IntPtr inst, IntPtr rtpbin);
|
|
|
|
static bool SetupRtpbin_cb (IntPtr inst, IntPtr rtpbin)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnSetupRtpbin (GLib.Object.GetObject(rtpbin) as Gst.Element);
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideSetupRtpbin")]
|
|
protected virtual bool OnSetupRtpbin (Gst.Element rtpbin)
|
|
{
|
|
return InternalSetupRtpbin (rtpbin);
|
|
}
|
|
|
|
private bool InternalSetupRtpbin (Gst.Element rtpbin)
|
|
{
|
|
SetupRtpbinNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_rtpbin"));
|
|
unmanaged = (SetupRtpbinNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetupRtpbinNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
bool __result = unmanaged (this.Handle, rtpbin == null ? IntPtr.Zero : rtpbin.Handle);
|
|
return __result;
|
|
}
|
|
|
|
static SetupSdpNativeDelegate SetupSdp_cb_delegate;
|
|
static SetupSdpNativeDelegate SetupSdpVMCallback {
|
|
get {
|
|
if (SetupSdp_cb_delegate == null)
|
|
SetupSdp_cb_delegate = new SetupSdpNativeDelegate (SetupSdp_cb);
|
|
return SetupSdp_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideSetupSdp (GLib.GType gtype)
|
|
{
|
|
OverrideSetupSdp (gtype, SetupSdpVMCallback);
|
|
}
|
|
|
|
static void OverrideSetupSdp (GLib.GType gtype, SetupSdpNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_sdp"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool SetupSdpNativeDelegate (IntPtr inst, IntPtr sdp, IntPtr info);
|
|
|
|
static bool SetupSdp_cb (IntPtr inst, IntPtr sdp, IntPtr info)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnSetupSdp (sdp == IntPtr.Zero ? null : (Gst.Sdp.SDPMessage) GLib.Opaque.GetOpaque (sdp, typeof (Gst.Sdp.SDPMessage), false), Gst.RtspServer.SDPInfo.New (info));
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideSetupSdp")]
|
|
protected virtual bool OnSetupSdp (Gst.Sdp.SDPMessage sdp, Gst.RtspServer.SDPInfo info)
|
|
{
|
|
return InternalSetupSdp (sdp, info);
|
|
}
|
|
|
|
private bool InternalSetupSdp (Gst.Sdp.SDPMessage sdp, Gst.RtspServer.SDPInfo info)
|
|
{
|
|
SetupSdpNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_sdp"));
|
|
unmanaged = (SetupSdpNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetupSdpNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
IntPtr native_info = GLib.Marshaller.StructureToPtrAlloc (info);
|
|
bool __result = unmanaged (this.Handle, sdp == null ? IntPtr.Zero : sdp.Handle, native_info);
|
|
Marshal.FreeHGlobal (native_info);
|
|
return __result;
|
|
}
|
|
|
|
static NewStreamNativeDelegate NewStream_cb_delegate;
|
|
static NewStreamNativeDelegate NewStreamVMCallback {
|
|
get {
|
|
if (NewStream_cb_delegate == null)
|
|
NewStream_cb_delegate = new NewStreamNativeDelegate (NewStream_cb);
|
|
return NewStream_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideNewStream (GLib.GType gtype)
|
|
{
|
|
OverrideNewStream (gtype, NewStreamVMCallback);
|
|
}
|
|
|
|
static void OverrideNewStream (GLib.GType gtype, NewStreamNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("new_stream"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate void NewStreamNativeDelegate (IntPtr inst, IntPtr _object);
|
|
|
|
static void NewStream_cb (IntPtr inst, IntPtr _object)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
__obj.OnNewStream (GLib.Object.GetObject(_object) as Gst.RtspServer.RTSPStream);
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, false);
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideNewStream")]
|
|
protected virtual void OnNewStream (Gst.RtspServer.RTSPStream _object)
|
|
{
|
|
InternalNewStream (_object);
|
|
}
|
|
|
|
private void InternalNewStream (Gst.RtspServer.RTSPStream _object)
|
|
{
|
|
NewStreamNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("new_stream"));
|
|
unmanaged = (NewStreamNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NewStreamNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return;
|
|
|
|
unmanaged (this.Handle, _object == null ? IntPtr.Zero : _object.Handle);
|
|
}
|
|
|
|
static RemovedStreamNativeDelegate RemovedStream_cb_delegate;
|
|
static RemovedStreamNativeDelegate RemovedStreamVMCallback {
|
|
get {
|
|
if (RemovedStream_cb_delegate == null)
|
|
RemovedStream_cb_delegate = new RemovedStreamNativeDelegate (RemovedStream_cb);
|
|
return RemovedStream_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideRemovedStream (GLib.GType gtype)
|
|
{
|
|
OverrideRemovedStream (gtype, RemovedStreamVMCallback);
|
|
}
|
|
|
|
static void OverrideRemovedStream (GLib.GType gtype, RemovedStreamNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("removed_stream"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate void RemovedStreamNativeDelegate (IntPtr inst, IntPtr _object);
|
|
|
|
static void RemovedStream_cb (IntPtr inst, IntPtr _object)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
__obj.OnRemovedStream (GLib.Object.GetObject(_object) as Gst.RtspServer.RTSPStream);
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, false);
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideRemovedStream")]
|
|
protected virtual void OnRemovedStream (Gst.RtspServer.RTSPStream _object)
|
|
{
|
|
InternalRemovedStream (_object);
|
|
}
|
|
|
|
private void InternalRemovedStream (Gst.RtspServer.RTSPStream _object)
|
|
{
|
|
RemovedStreamNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("removed_stream"));
|
|
unmanaged = (RemovedStreamNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RemovedStreamNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return;
|
|
|
|
unmanaged (this.Handle, _object == null ? IntPtr.Zero : _object.Handle);
|
|
}
|
|
|
|
static PreparedNativeDelegate Prepared_cb_delegate;
|
|
static PreparedNativeDelegate PreparedVMCallback {
|
|
get {
|
|
if (Prepared_cb_delegate == null)
|
|
Prepared_cb_delegate = new PreparedNativeDelegate (Prepared_cb);
|
|
return Prepared_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverridePrepared (GLib.GType gtype)
|
|
{
|
|
OverridePrepared (gtype, PreparedVMCallback);
|
|
}
|
|
|
|
static void OverridePrepared (GLib.GType gtype, PreparedNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("prepared"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate void PreparedNativeDelegate (IntPtr inst);
|
|
|
|
static void Prepared_cb (IntPtr inst)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
__obj.OnPrepared ();
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, false);
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverridePrepared")]
|
|
protected virtual void OnPrepared ()
|
|
{
|
|
InternalPrepared ();
|
|
}
|
|
|
|
private void InternalPrepared ()
|
|
{
|
|
PreparedNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("prepared"));
|
|
unmanaged = (PreparedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreparedNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return;
|
|
|
|
unmanaged (this.Handle);
|
|
}
|
|
|
|
static UnpreparedNativeDelegate Unprepared_cb_delegate;
|
|
static UnpreparedNativeDelegate UnpreparedVMCallback {
|
|
get {
|
|
if (Unprepared_cb_delegate == null)
|
|
Unprepared_cb_delegate = new UnpreparedNativeDelegate (Unprepared_cb);
|
|
return Unprepared_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideUnprepared (GLib.GType gtype)
|
|
{
|
|
OverrideUnprepared (gtype, UnpreparedVMCallback);
|
|
}
|
|
|
|
static void OverrideUnprepared (GLib.GType gtype, UnpreparedNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepared"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate void UnpreparedNativeDelegate (IntPtr inst);
|
|
|
|
static void Unprepared_cb (IntPtr inst)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
__obj.OnUnprepared ();
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, false);
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideUnprepared")]
|
|
protected virtual void OnUnprepared ()
|
|
{
|
|
InternalUnprepared ();
|
|
}
|
|
|
|
private void InternalUnprepared ()
|
|
{
|
|
UnpreparedNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepared"));
|
|
unmanaged = (UnpreparedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnpreparedNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return;
|
|
|
|
unmanaged (this.Handle);
|
|
}
|
|
|
|
static TargetStateNativeDelegate TargetState_cb_delegate;
|
|
static TargetStateNativeDelegate TargetStateVMCallback {
|
|
get {
|
|
if (TargetState_cb_delegate == null)
|
|
TargetState_cb_delegate = new TargetStateNativeDelegate (TargetState_cb);
|
|
return TargetState_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideTargetState (GLib.GType gtype)
|
|
{
|
|
OverrideTargetState (gtype, TargetStateVMCallback);
|
|
}
|
|
|
|
static void OverrideTargetState (GLib.GType gtype, TargetStateNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("target_state"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate void TargetStateNativeDelegate (IntPtr inst, int _object);
|
|
|
|
static void TargetState_cb (IntPtr inst, int _object)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
__obj.OnTargetState (_object);
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, false);
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideTargetState")]
|
|
protected virtual void OnTargetState (int _object)
|
|
{
|
|
InternalTargetState (_object);
|
|
}
|
|
|
|
private void InternalTargetState (int _object)
|
|
{
|
|
TargetStateNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("target_state"));
|
|
unmanaged = (TargetStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TargetStateNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return;
|
|
|
|
unmanaged (this.Handle, _object);
|
|
}
|
|
|
|
static NewStateNativeDelegate NewState_cb_delegate;
|
|
static NewStateNativeDelegate NewStateVMCallback {
|
|
get {
|
|
if (NewState_cb_delegate == null)
|
|
NewState_cb_delegate = new NewStateNativeDelegate (NewState_cb);
|
|
return NewState_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideNewState (GLib.GType gtype)
|
|
{
|
|
OverrideNewState (gtype, NewStateVMCallback);
|
|
}
|
|
|
|
static void OverrideNewState (GLib.GType gtype, NewStateNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("new_state"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate void NewStateNativeDelegate (IntPtr inst, int _object);
|
|
|
|
static void NewState_cb (IntPtr inst, int _object)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
__obj.OnNewState (_object);
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, false);
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideNewState")]
|
|
protected virtual void OnNewState (int _object)
|
|
{
|
|
InternalNewState (_object);
|
|
}
|
|
|
|
private void InternalNewState (int _object)
|
|
{
|
|
NewStateNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("new_state"));
|
|
unmanaged = (NewStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NewStateNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return;
|
|
|
|
unmanaged (this.Handle, _object);
|
|
}
|
|
|
|
static HandleSdpNativeDelegate HandleSdp_cb_delegate;
|
|
static HandleSdpNativeDelegate HandleSdpVMCallback {
|
|
get {
|
|
if (HandleSdp_cb_delegate == null)
|
|
HandleSdp_cb_delegate = new HandleSdpNativeDelegate (HandleSdp_cb);
|
|
return HandleSdp_cb_delegate;
|
|
}
|
|
}
|
|
|
|
static void OverrideHandleSdp (GLib.GType gtype)
|
|
{
|
|
OverrideHandleSdp (gtype, HandleSdpVMCallback);
|
|
}
|
|
|
|
static void OverrideHandleSdp (GLib.GType gtype, HandleSdpNativeDelegate callback)
|
|
{
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_sdp"));
|
|
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
|
|
}
|
|
}
|
|
|
|
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
|
|
delegate bool HandleSdpNativeDelegate (IntPtr inst, IntPtr sdp);
|
|
|
|
static bool HandleSdp_cb (IntPtr inst, IntPtr sdp)
|
|
{
|
|
try {
|
|
RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
|
|
bool __result;
|
|
__result = __obj.OnHandleSdp (sdp == IntPtr.Zero ? null : (Gst.Sdp.SDPMessage) GLib.Opaque.GetOpaque (sdp, typeof (Gst.Sdp.SDPMessage), false));
|
|
return __result;
|
|
} catch (Exception e) {
|
|
GLib.ExceptionManager.RaiseUnhandledException (e, true);
|
|
// NOTREACHED: above call does not return.
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideHandleSdp")]
|
|
protected virtual bool OnHandleSdp (Gst.Sdp.SDPMessage sdp)
|
|
{
|
|
return InternalHandleSdp (sdp);
|
|
}
|
|
|
|
private bool InternalHandleSdp (Gst.Sdp.SDPMessage sdp)
|
|
{
|
|
HandleSdpNativeDelegate unmanaged = null;
|
|
unsafe {
|
|
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_sdp"));
|
|
unmanaged = (HandleSdpNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(HandleSdpNativeDelegate));
|
|
}
|
|
if (unmanaged == null) return false;
|
|
|
|
bool __result = unmanaged (this.Handle, sdp == null ? IntPtr.Zero : sdp.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<GLib.AbiField>{
|
|
new GLib.AbiField("handle_message"
|
|
, GLib.Object.class_abi.Fields
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_message
|
|
, null
|
|
, "prepare"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("prepare"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // prepare
|
|
, "handle_message"
|
|
, "unprepare"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("unprepare"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // unprepare
|
|
, "prepare"
|
|
, "suspend"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("suspend"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // suspend
|
|
, "unprepare"
|
|
, "unsuspend"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("unsuspend"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // unsuspend
|
|
, "suspend"
|
|
, "convert_range"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("convert_range"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // convert_range
|
|
, "unsuspend"
|
|
, "query_position"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("query_position"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // query_position
|
|
, "convert_range"
|
|
, "query_stop"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("query_stop"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // query_stop
|
|
, "query_position"
|
|
, "create_rtpbin"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("create_rtpbin"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // create_rtpbin
|
|
, "query_stop"
|
|
, "setup_rtpbin"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("setup_rtpbin"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // setup_rtpbin
|
|
, "create_rtpbin"
|
|
, "setup_sdp"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("setup_sdp"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // setup_sdp
|
|
, "setup_rtpbin"
|
|
, "new_stream"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("new_stream"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // new_stream
|
|
, "setup_sdp"
|
|
, "removed_stream"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("removed_stream"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // removed_stream
|
|
, "new_stream"
|
|
, "prepared"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("prepared"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // prepared
|
|
, "removed_stream"
|
|
, "unprepared"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("unprepared"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // unprepared
|
|
, "prepared"
|
|
, "target_state"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("target_state"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // target_state
|
|
, "unprepared"
|
|
, "new_state"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("new_state"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // new_state
|
|
, "target_state"
|
|
, "handle_sdp"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("handle_sdp"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_sdp
|
|
, "new_state"
|
|
, "_gst_reserved"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("_gst_reserved"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 19 // _gst_reserved
|
|
, "handle_sdp"
|
|
, null
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
});
|
|
|
|
return _class_abi;
|
|
}
|
|
}
|
|
|
|
|
|
// End of the ABI representation.
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_type();
|
|
|
|
public static new GLib.GType GType {
|
|
get {
|
|
IntPtr raw_ret = gst_rtsp_media_get_type();
|
|
GLib.GType ret = new GLib.GType(raw_ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_can_be_shared(IntPtr raw);
|
|
|
|
public bool CanBeShared() {
|
|
bool raw_ret = gst_rtsp_media_can_be_shared(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_collect_streams(IntPtr raw);
|
|
|
|
public void CollectStreams() {
|
|
gst_rtsp_media_collect_streams(Handle);
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_complete_pipeline(IntPtr raw, IntPtr[] transports);
|
|
|
|
public bool CompletePipeline(GLib.PtrArray[] transports) {
|
|
int cnt_transports = transports == null ? 0 : transports.Length;
|
|
IntPtr[] native_transports = new IntPtr [cnt_transports + 1];
|
|
for (int i = 0; i < cnt_transports; i++)
|
|
native_transports [i] = transports[i] == null ? IntPtr.Zero : transports[i].Handle;
|
|
native_transports [cnt_transports] = IntPtr.Zero;
|
|
bool raw_ret = gst_rtsp_media_complete_pipeline(Handle, native_transports);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_create_stream(IntPtr raw, IntPtr payloader, IntPtr pad);
|
|
|
|
public Gst.RtspServer.RTSPStream CreateStream(Gst.Element payloader, Gst.Pad pad) {
|
|
IntPtr raw_ret = gst_rtsp_media_create_stream(Handle, payloader == null ? IntPtr.Zero : payloader.Handle, pad == null ? IntPtr.Zero : pad.Handle);
|
|
Gst.RtspServer.RTSPStream ret = GLib.Object.GetObject(raw_ret) as Gst.RtspServer.RTSPStream;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_find_stream(IntPtr raw, IntPtr control);
|
|
|
|
public Gst.RtspServer.RTSPStream FindStream(string control) {
|
|
IntPtr native_control = GLib.Marshaller.StringToPtrGStrdup (control);
|
|
IntPtr raw_ret = gst_rtsp_media_find_stream(Handle, native_control);
|
|
Gst.RtspServer.RTSPStream ret = GLib.Object.GetObject(raw_ret) as Gst.RtspServer.RTSPStream;
|
|
GLib.Marshaller.Free (native_control);
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_address_pool(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_address_pool(IntPtr raw, IntPtr pool);
|
|
|
|
public Gst.RtspServer.RTSPAddressPool AddressPool {
|
|
get {
|
|
IntPtr raw_ret = gst_rtsp_media_get_address_pool(Handle);
|
|
Gst.RtspServer.RTSPAddressPool ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPAddressPool;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_address_pool(Handle, value == null ? IntPtr.Zero : value.Handle);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern ulong gst_rtsp_media_get_base_time(IntPtr raw);
|
|
|
|
public ulong BaseTime {
|
|
get {
|
|
ulong raw_ret = gst_rtsp_media_get_base_time(Handle);
|
|
ulong ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_get_do_retransmission(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_do_retransmission(IntPtr raw, bool do_retransmission);
|
|
|
|
public bool DoRetransmission {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_get_do_retransmission(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_do_retransmission(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_multicast_iface(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_multicast_iface(IntPtr raw, IntPtr multicast_iface);
|
|
|
|
public string MulticastIface {
|
|
get {
|
|
IntPtr raw_ret = gst_rtsp_media_get_multicast_iface(Handle);
|
|
string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
|
|
return ret;
|
|
}
|
|
set {
|
|
IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
|
|
gst_rtsp_media_set_multicast_iface(Handle, native_value);
|
|
GLib.Marshaller.Free (native_value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_permissions(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_permissions(IntPtr raw, IntPtr permissions);
|
|
|
|
public Gst.RtspServer.RTSPPermissions Permissions {
|
|
get {
|
|
IntPtr raw_ret = gst_rtsp_media_get_permissions(Handle);
|
|
Gst.RtspServer.RTSPPermissions ret = raw_ret == IntPtr.Zero ? null : (Gst.RtspServer.RTSPPermissions) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.RtspServer.RTSPPermissions), true);
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_permissions(Handle, value == null ? IntPtr.Zero : value.Handle);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern int gst_rtsp_media_get_publish_clock_mode(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_publish_clock_mode(IntPtr raw, int mode);
|
|
|
|
public Gst.RtspServer.RTSPPublishClockMode PublishClockMode {
|
|
get {
|
|
int raw_ret = gst_rtsp_media_get_publish_clock_mode(Handle);
|
|
Gst.RtspServer.RTSPPublishClockMode ret = (Gst.RtspServer.RTSPPublishClockMode) raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_publish_clock_mode(Handle, (int) value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_range_string(IntPtr raw, bool play, int unit);
|
|
|
|
public string GetRangeString(bool play, Gst.Rtsp.RTSPRangeUnit unit) {
|
|
IntPtr raw_ret = gst_rtsp_media_get_range_string(Handle, play, (int) unit);
|
|
string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_get_rate_control(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_rate_control(IntPtr raw, bool enabled);
|
|
|
|
public bool RateControl {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_get_rate_control(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_rate_control(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_get_rates(IntPtr raw, out double rate, out double applied_rate);
|
|
|
|
public bool GetRates(out double rate, out double applied_rate) {
|
|
bool raw_ret = gst_rtsp_media_get_rates(Handle, out rate, out applied_rate);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern ulong gst_rtsp_media_get_retransmission_time(IntPtr raw);
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_retransmission_time(IntPtr raw, ulong time);
|
|
|
|
public ulong RetransmissionTime {
|
|
get {
|
|
ulong raw_ret = gst_rtsp_media_get_retransmission_time(Handle);
|
|
ulong ret = raw_ret;
|
|
return ret;
|
|
}
|
|
set {
|
|
gst_rtsp_media_set_retransmission_time(Handle, value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern int gst_rtsp_media_get_status(IntPtr raw);
|
|
|
|
public Gst.RtspServer.RTSPMediaStatus Status {
|
|
get {
|
|
int raw_ret = gst_rtsp_media_get_status(Handle);
|
|
Gst.RtspServer.RTSPMediaStatus ret = (Gst.RtspServer.RTSPMediaStatus) raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_stream(IntPtr raw, uint idx);
|
|
|
|
public Gst.RtspServer.RTSPStream GetStream(uint idx) {
|
|
IntPtr raw_ret = gst_rtsp_media_get_stream(Handle, idx);
|
|
Gst.RtspServer.RTSPStream ret = GLib.Object.GetObject(raw_ret) as Gst.RtspServer.RTSPStream;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_rtsp_media_get_time_provider(IntPtr raw, IntPtr address, ushort port);
|
|
|
|
public Gst.Net.NetTimeProvider GetTimeProvider(string address, ushort port) {
|
|
IntPtr native_address = GLib.Marshaller.StringToPtrGStrdup (address);
|
|
IntPtr raw_ret = gst_rtsp_media_get_time_provider(Handle, native_address, port);
|
|
Gst.Net.NetTimeProvider ret = GLib.Object.GetObject(raw_ret, true) as Gst.Net.NetTimeProvider;
|
|
GLib.Marshaller.Free (native_address);
|
|
return ret;
|
|
}
|
|
|
|
public Gst.Net.NetTimeProvider GetTimeProvider(ushort port) {
|
|
return GetTimeProvider (null, port);
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_handle_sdp(IntPtr raw, IntPtr sdp);
|
|
|
|
public bool HandleSdp(Gst.Sdp.SDPMessage sdp) {
|
|
bool raw_ret = gst_rtsp_media_handle_sdp(Handle, sdp == null ? IntPtr.Zero : sdp.Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_has_completed_sender(IntPtr raw);
|
|
|
|
public bool HasCompletedSender {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_has_completed_sender(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_is_bind_mcast_address(IntPtr raw);
|
|
|
|
public bool IsBindMcastAddress {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_is_bind_mcast_address(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_is_eos_shutdown(IntPtr raw);
|
|
|
|
public bool IsEosShutdown {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_is_eos_shutdown(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_is_receive_only(IntPtr raw);
|
|
|
|
public bool IsReceiveOnly {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_is_receive_only(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_is_reusable(IntPtr raw);
|
|
|
|
public bool IsReusable {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_is_reusable(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_is_shared(IntPtr raw);
|
|
|
|
public bool IsShared {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_is_shared(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_is_stop_on_disconnect(IntPtr raw);
|
|
|
|
public bool IsStopOnDisconnect {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_is_stop_on_disconnect(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_is_time_provider(IntPtr raw);
|
|
|
|
public bool IsTimeProvider {
|
|
get {
|
|
bool raw_ret = gst_rtsp_media_is_time_provider(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_lock(IntPtr raw);
|
|
|
|
public void Lock() {
|
|
gst_rtsp_media_lock(Handle);
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern uint gst_rtsp_media_n_streams(IntPtr raw);
|
|
|
|
public uint NStreams() {
|
|
uint raw_ret = gst_rtsp_media_n_streams(Handle);
|
|
uint ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_prepare(IntPtr raw, IntPtr thread);
|
|
|
|
public bool Prepare(Gst.RtspServer.RTSPThread thread) {
|
|
thread.Owned = false;
|
|
bool raw_ret = gst_rtsp_media_prepare(Handle, thread == null ? IntPtr.Zero : thread.Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
public bool Prepare() {
|
|
return Prepare (null);
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_seek(IntPtr raw, IntPtr range);
|
|
|
|
public bool Seek(Gst.Rtsp.RTSPTimeRange range) {
|
|
IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
|
|
bool raw_ret = gst_rtsp_media_seek(Handle, native_range);
|
|
bool ret = raw_ret;
|
|
Marshal.FreeHGlobal (native_range);
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_seek_full(IntPtr raw, IntPtr range, int flags);
|
|
|
|
public bool SeekFull(Gst.Rtsp.RTSPTimeRange range, Gst.SeekFlags flags) {
|
|
IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
|
|
bool raw_ret = gst_rtsp_media_seek_full(Handle, native_range, (int) flags);
|
|
bool ret = raw_ret;
|
|
Marshal.FreeHGlobal (native_range);
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_seek_trickmode(IntPtr raw, IntPtr range, int flags, double rate, ulong trickmode_interval);
|
|
|
|
public bool SeekTrickmode(Gst.Rtsp.RTSPTimeRange range, Gst.SeekFlags flags, double rate, ulong trickmode_interval) {
|
|
IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
|
|
bool raw_ret = gst_rtsp_media_seek_trickmode(Handle, native_range, (int) flags, rate, trickmode_interval);
|
|
bool ret = raw_ret;
|
|
Marshal.FreeHGlobal (native_range);
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern long gst_rtsp_media_seekable(IntPtr raw);
|
|
|
|
public long Seekable() {
|
|
long raw_ret = gst_rtsp_media_seekable(Handle);
|
|
long ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_set_max_mcast_ttl(IntPtr raw, uint ttl);
|
|
|
|
public bool SetMaxMcastTtl(uint ttl) {
|
|
bool raw_ret = gst_rtsp_media_set_max_mcast_ttl(Handle, ttl);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_set_pipeline_state(IntPtr raw, int state);
|
|
|
|
public Gst.State PipelineState {
|
|
set {
|
|
gst_rtsp_media_set_pipeline_state(Handle, (int) value);
|
|
}
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_set_state(IntPtr raw, int state, IntPtr[] transports);
|
|
|
|
public bool SetState(Gst.State state, GLib.PtrArray[] transports) {
|
|
int cnt_transports = transports == null ? 0 : transports.Length;
|
|
IntPtr[] native_transports = new IntPtr [cnt_transports + 1];
|
|
for (int i = 0; i < cnt_transports; i++)
|
|
native_transports [i] = transports[i] == null ? IntPtr.Zero : transports[i].Handle;
|
|
native_transports [cnt_transports] = IntPtr.Zero;
|
|
bool raw_ret = gst_rtsp_media_set_state(Handle, (int) state, native_transports);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_setup_sdp(IntPtr raw, IntPtr sdp, IntPtr info);
|
|
|
|
public bool SetupSdp(Gst.Sdp.SDPMessage sdp, Gst.RtspServer.SDPInfo info) {
|
|
IntPtr native_info = GLib.Marshaller.StructureToPtrAlloc (info);
|
|
bool raw_ret = gst_rtsp_media_setup_sdp(Handle, sdp == null ? IntPtr.Zero : sdp.Handle, native_info);
|
|
bool ret = raw_ret;
|
|
Marshal.FreeHGlobal (native_info);
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_suspend(IntPtr raw);
|
|
|
|
public bool Suspend() {
|
|
bool raw_ret = gst_rtsp_media_suspend(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_take_pipeline(IntPtr raw, IntPtr pipeline);
|
|
|
|
public void TakePipeline(Gst.Pipeline pipeline) {
|
|
gst_rtsp_media_take_pipeline(Handle, pipeline == null ? IntPtr.Zero : pipeline.Handle);
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_unlock(IntPtr raw);
|
|
|
|
public void Unlock() {
|
|
gst_rtsp_media_unlock(Handle);
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_unprepare(IntPtr raw);
|
|
|
|
public bool Unprepare() {
|
|
bool raw_ret = gst_rtsp_media_unprepare(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern bool gst_rtsp_media_unsuspend(IntPtr raw);
|
|
|
|
public bool Unsuspend() {
|
|
bool raw_ret = gst_rtsp_media_unsuspend(Handle);
|
|
bool ret = raw_ret;
|
|
return ret;
|
|
}
|
|
|
|
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern void gst_rtsp_media_use_time_provider(IntPtr raw, bool time_provider);
|
|
|
|
public void UseTimeProvider(bool time_provider) {
|
|
gst_rtsp_media_use_time_provider(Handle, time_provider);
|
|
}
|
|
|
|
|
|
static RTSPMedia ()
|
|
{
|
|
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<GLib.AbiField>{
|
|
new GLib.AbiField("priv"
|
|
, GLib.Object.abi_info.Fields
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
|
|
, null
|
|
, "_gst_reserved"
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
new GLib.AbiField("_gst_reserved"
|
|
, -1
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
|
|
, "priv"
|
|
, null
|
|
, (uint) Marshal.SizeOf(typeof(IntPtr))
|
|
, 0
|
|
),
|
|
});
|
|
|
|
return _abi_info;
|
|
}
|
|
}
|
|
|
|
|
|
// End of the ABI representation.
|
|
|
|
#endregion
|
|
}
|
|
}
|