gstreamer/subprojects/gstreamer-sharp/sources/generated/Gst.RtspServer/RTSPClient.cs

2899 lines
105 KiB
C#
Raw Normal View History

// 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 RTSPClient : GLib.Object {
public RTSPClient (IntPtr raw) : base(raw) {}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_rtsp_client_new();
public RTSPClient () : base (IntPtr.Zero)
{
if (GetType () != typeof (RTSPClient)) {
CreateNativeObject (new string [0], new GLib.Value[0]);
return;
}
Raw = gst_rtsp_client_new();
}
[GLib.Property ("drop-backlog")]
public bool DropBacklog {
get {
GLib.Value val = GetProperty ("drop-backlog");
bool ret = (bool) val;
val.Dispose ();
return ret;
}
set {
GLib.Value val = new GLib.Value(value);
SetProperty("drop-backlog", val);
val.Dispose ();
}
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_rtsp_client_get_mount_points(IntPtr raw);
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_rtsp_client_set_mount_points(IntPtr raw, IntPtr mounts);
[GLib.Property ("mount-points")]
public Gst.RtspServer.RTSPMountPoints MountPoints {
get {
IntPtr raw_ret = gst_rtsp_client_get_mount_points(Handle);
Gst.RtspServer.RTSPMountPoints ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPMountPoints;
return ret;
}
set {
gst_rtsp_client_set_mount_points(Handle, value == null ? IntPtr.Zero : value.Handle);
}
}
[GLib.Property ("post-session-timeout")]
public int PostSessionTimeout {
get {
GLib.Value val = GetProperty ("post-session-timeout");
int ret = (int) val;
val.Dispose ();
return ret;
}
set {
GLib.Value val = new GLib.Value(value);
SetProperty("post-session-timeout", val);
val.Dispose ();
}
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_rtsp_client_get_session_pool(IntPtr raw);
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_rtsp_client_set_session_pool(IntPtr raw, IntPtr pool);
[GLib.Property ("session-pool")]
public Gst.RtspServer.RTSPSessionPool SessionPool {
get {
IntPtr raw_ret = gst_rtsp_client_get_session_pool(Handle);
Gst.RtspServer.RTSPSessionPool ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPSessionPool;
return ret;
}
set {
gst_rtsp_client_set_session_pool(Handle, value == null ? IntPtr.Zero : value.Handle);
}
}
[GLib.Signal("play-request")]
public event Gst.RtspServer.PlayRequestHandler PlayRequest {
add {
this.AddSignalHandler ("play-request", value, typeof (Gst.RtspServer.PlayRequestArgs));
}
remove {
this.RemoveSignalHandler ("play-request", value);
}
}
[GLib.Signal("pre-setup-request")]
public event Gst.RtspServer.PreSetupRequestHandler PreSetupRequest {
add {
this.AddSignalHandler ("pre-setup-request", value, typeof (Gst.RtspServer.PreSetupRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-setup-request", value);
}
}
[GLib.Signal("pause-request")]
public event Gst.RtspServer.PauseRequestHandler PauseRequest {
add {
this.AddSignalHandler ("pause-request", value, typeof (Gst.RtspServer.PauseRequestArgs));
}
remove {
this.RemoveSignalHandler ("pause-request", value);
}
}
[GLib.Signal("describe-request")]
public event Gst.RtspServer.DescribeRequestHandler DescribeRequest {
add {
this.AddSignalHandler ("describe-request", value, typeof (Gst.RtspServer.DescribeRequestArgs));
}
remove {
this.RemoveSignalHandler ("describe-request", value);
}
}
[GLib.Signal("teardown-request")]
public event Gst.RtspServer.TeardownRequestHandler TeardownRequest {
add {
this.AddSignalHandler ("teardown-request", value, typeof (Gst.RtspServer.TeardownRequestArgs));
}
remove {
this.RemoveSignalHandler ("teardown-request", value);
}
}
[GLib.Signal("setup-request")]
public event Gst.RtspServer.SetupRequestHandler SetupRequest {
add {
this.AddSignalHandler ("setup-request", value, typeof (Gst.RtspServer.SetupRequestArgs));
}
remove {
this.RemoveSignalHandler ("setup-request", value);
}
}
[GLib.Signal("pre-get-parameter-request")]
public event Gst.RtspServer.PreGetParameterRequestHandler PreGetParameterRequest {
add {
this.AddSignalHandler ("pre-get-parameter-request", value, typeof (Gst.RtspServer.PreGetParameterRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-get-parameter-request", value);
}
}
[GLib.Signal("pre-record-request")]
public event Gst.RtspServer.PreRecordRequestHandler PreRecordRequest {
add {
this.AddSignalHandler ("pre-record-request", value, typeof (Gst.RtspServer.PreRecordRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-record-request", value);
}
}
[GLib.Signal("new-session")]
public event Gst.RtspServer.NewSessionHandler NewSession {
add {
this.AddSignalHandler ("new-session", value, typeof (Gst.RtspServer.NewSessionArgs));
}
remove {
this.RemoveSignalHandler ("new-session", value);
}
}
[GLib.Signal("handle-response")]
public event Gst.RtspServer.HandleResponseHandler HandleResponse {
add {
this.AddSignalHandler ("handle-response", value, typeof (Gst.RtspServer.HandleResponseArgs));
}
remove {
this.RemoveSignalHandler ("handle-response", value);
}
}
[GLib.Signal("announce-request")]
public event Gst.RtspServer.AnnounceRequestHandler AnnounceRequest {
add {
this.AddSignalHandler ("announce-request", value, typeof (Gst.RtspServer.AnnounceRequestArgs));
}
remove {
this.RemoveSignalHandler ("announce-request", value);
}
}
[GLib.Signal("pre-teardown-request")]
public event Gst.RtspServer.PreTeardownRequestHandler PreTeardownRequest {
add {
this.AddSignalHandler ("pre-teardown-request", value, typeof (Gst.RtspServer.PreTeardownRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-teardown-request", value);
}
}
[GLib.Signal("set-parameter-request")]
public event Gst.RtspServer.SetParameterRequestHandler SetParameterRequest {
add {
this.AddSignalHandler ("set-parameter-request", value, typeof (Gst.RtspServer.SetParameterRequestArgs));
}
remove {
this.RemoveSignalHandler ("set-parameter-request", value);
}
}
[GLib.Signal("send-message")]
public event Gst.RtspServer.SendMessageEventHandler SendMessageEvent {
add {
this.AddSignalHandler ("send-message", value, typeof (Gst.RtspServer.SendMessageEventArgs));
}
remove {
this.RemoveSignalHandler ("send-message", value);
}
}
[GLib.Signal("pre-pause-request")]
public event Gst.RtspServer.PrePauseRequestHandler PrePauseRequest {
add {
this.AddSignalHandler ("pre-pause-request", value, typeof (Gst.RtspServer.PrePauseRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-pause-request", value);
}
}
[GLib.Signal("pre-set-parameter-request")]
public event Gst.RtspServer.PreSetParameterRequestHandler PreSetParameterRequest {
add {
this.AddSignalHandler ("pre-set-parameter-request", value, typeof (Gst.RtspServer.PreSetParameterRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-set-parameter-request", value);
}
}
[GLib.Signal("pre-describe-request")]
public event Gst.RtspServer.PreDescribeRequestHandler PreDescribeRequest {
add {
this.AddSignalHandler ("pre-describe-request", value, typeof (Gst.RtspServer.PreDescribeRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-describe-request", value);
}
}
[GLib.Signal("pre-play-request")]
public event Gst.RtspServer.PrePlayRequestHandler PrePlayRequest {
add {
this.AddSignalHandler ("pre-play-request", value, typeof (Gst.RtspServer.PrePlayRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-play-request", value);
}
}
[GLib.Signal("pre-announce-request")]
public event Gst.RtspServer.PreAnnounceRequestHandler PreAnnounceRequest {
add {
this.AddSignalHandler ("pre-announce-request", value, typeof (Gst.RtspServer.PreAnnounceRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-announce-request", value);
}
}
[GLib.Signal("get-parameter-request")]
public event Gst.RtspServer.GetParameterRequestHandler GetParameterRequest {
add {
this.AddSignalHandler ("get-parameter-request", value, typeof (Gst.RtspServer.GetParameterRequestArgs));
}
remove {
this.RemoveSignalHandler ("get-parameter-request", value);
}
}
[GLib.Signal("record-request")]
public event Gst.RtspServer.RecordRequestHandler RecordRequest {
add {
this.AddSignalHandler ("record-request", value, typeof (Gst.RtspServer.RecordRequestArgs));
}
remove {
this.RemoveSignalHandler ("record-request", value);
}
}
[GLib.Signal("closed")]
public event System.EventHandler Closed {
add {
this.AddSignalHandler ("closed", value);
}
remove {
this.RemoveSignalHandler ("closed", value);
}
}
[GLib.Signal("pre-options-request")]
public event Gst.RtspServer.PreOptionsRequestHandler PreOptionsRequest {
add {
this.AddSignalHandler ("pre-options-request", value, typeof (Gst.RtspServer.PreOptionsRequestArgs));
}
remove {
this.RemoveSignalHandler ("pre-options-request", value);
}
}
[GLib.Signal("options-request")]
public event Gst.RtspServer.OptionsRequestHandler OptionsRequest {
add {
this.AddSignalHandler ("options-request", value, typeof (Gst.RtspServer.OptionsRequestArgs));
}
remove {
this.RemoveSignalHandler ("options-request", value);
}
}
static CreateSdpNativeDelegate CreateSdp_cb_delegate;
static CreateSdpNativeDelegate CreateSdpVMCallback {
get {
if (CreateSdp_cb_delegate == null)
CreateSdp_cb_delegate = new CreateSdpNativeDelegate (CreateSdp_cb);
return CreateSdp_cb_delegate;
}
}
static void OverrideCreateSdp (GLib.GType gtype)
{
OverrideCreateSdp (gtype, CreateSdpVMCallback);
}
static void OverrideCreateSdp (GLib.GType gtype, CreateSdpNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("create_sdp"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr CreateSdpNativeDelegate (IntPtr inst, IntPtr media);
static IntPtr CreateSdp_cb (IntPtr inst, IntPtr media)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Sdp.SDPMessage __result;
__result = __obj.OnCreateSdp (GLib.Object.GetObject(media) as Gst.RtspServer.RTSPMedia);
return __result == null ? IntPtr.Zero : __result.OwnedCopy;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideCreateSdp")]
protected virtual Gst.Sdp.SDPMessage OnCreateSdp (Gst.RtspServer.RTSPMedia media)
{
return InternalCreateSdp (media);
}
private Gst.Sdp.SDPMessage InternalCreateSdp (Gst.RtspServer.RTSPMedia media)
{
CreateSdpNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("create_sdp"));
unmanaged = (CreateSdpNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CreateSdpNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr __result = unmanaged (this.Handle, media == null ? IntPtr.Zero : media.Handle);
return __result == IntPtr.Zero ? null : (Gst.Sdp.SDPMessage) GLib.Opaque.GetOpaque (__result, typeof (Gst.Sdp.SDPMessage), true);
}
static ConfigureClientMediaNativeDelegate ConfigureClientMedia_cb_delegate;
static ConfigureClientMediaNativeDelegate ConfigureClientMediaVMCallback {
get {
if (ConfigureClientMedia_cb_delegate == null)
ConfigureClientMedia_cb_delegate = new ConfigureClientMediaNativeDelegate (ConfigureClientMedia_cb);
return ConfigureClientMedia_cb_delegate;
}
}
static void OverrideConfigureClientMedia (GLib.GType gtype)
{
OverrideConfigureClientMedia (gtype, ConfigureClientMediaVMCallback);
}
static void OverrideConfigureClientMedia (GLib.GType gtype, ConfigureClientMediaNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("configure_client_media"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool ConfigureClientMediaNativeDelegate (IntPtr inst, IntPtr media, IntPtr stream, IntPtr ctx);
static bool ConfigureClientMedia_cb (IntPtr inst, IntPtr media, IntPtr stream, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
bool __result;
__result = __obj.OnConfigureClientMedia (GLib.Object.GetObject(media) as Gst.RtspServer.RTSPMedia, GLib.Object.GetObject(stream) as Gst.RtspServer.RTSPStream, Gst.RtspServer.RTSPContext.New (ctx));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideConfigureClientMedia")]
protected virtual bool OnConfigureClientMedia (Gst.RtspServer.RTSPMedia media, Gst.RtspServer.RTSPStream stream, Gst.RtspServer.RTSPContext ctx)
{
return InternalConfigureClientMedia (media, stream, ctx);
}
private bool InternalConfigureClientMedia (Gst.RtspServer.RTSPMedia media, Gst.RtspServer.RTSPStream stream, Gst.RtspServer.RTSPContext ctx)
{
ConfigureClientMediaNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("configure_client_media"));
unmanaged = (ConfigureClientMediaNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ConfigureClientMediaNativeDelegate));
}
if (unmanaged == null) return false;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
bool __result = unmanaged (this.Handle, media == null ? IntPtr.Zero : media.Handle, stream == null ? IntPtr.Zero : stream.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return __result;
}
static ConfigureClientTransportNativeDelegate ConfigureClientTransport_cb_delegate;
static ConfigureClientTransportNativeDelegate ConfigureClientTransportVMCallback {
get {
if (ConfigureClientTransport_cb_delegate == null)
ConfigureClientTransport_cb_delegate = new ConfigureClientTransportNativeDelegate (ConfigureClientTransport_cb);
return ConfigureClientTransport_cb_delegate;
}
}
static void OverrideConfigureClientTransport (GLib.GType gtype)
{
OverrideConfigureClientTransport (gtype, ConfigureClientTransportVMCallback);
}
static void OverrideConfigureClientTransport (GLib.GType gtype, ConfigureClientTransportNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("configure_client_transport"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool ConfigureClientTransportNativeDelegate (IntPtr inst, IntPtr ctx, IntPtr ct);
static bool ConfigureClientTransport_cb (IntPtr inst, IntPtr ctx, IntPtr ct)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
bool __result;
__result = __obj.OnConfigureClientTransport (Gst.RtspServer.RTSPContext.New (ctx), Gst.Rtsp.RTSPTransport.New (ct));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideConfigureClientTransport")]
protected virtual bool OnConfigureClientTransport (Gst.RtspServer.RTSPContext ctx, Gst.Rtsp.RTSPTransport ct)
{
return InternalConfigureClientTransport (ctx, ct);
}
private bool InternalConfigureClientTransport (Gst.RtspServer.RTSPContext ctx, Gst.Rtsp.RTSPTransport ct)
{
ConfigureClientTransportNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("configure_client_transport"));
unmanaged = (ConfigureClientTransportNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ConfigureClientTransportNativeDelegate));
}
if (unmanaged == null) return false;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
IntPtr native_ct = GLib.Marshaller.StructureToPtrAlloc (ct);
bool __result = unmanaged (this.Handle, native_ctx, native_ct);
Marshal.FreeHGlobal (native_ctx);
Marshal.FreeHGlobal (native_ct);
return __result;
}
static ParamsSetNativeDelegate ParamsSet_cb_delegate;
static ParamsSetNativeDelegate ParamsSetVMCallback {
get {
if (ParamsSet_cb_delegate == null)
ParamsSet_cb_delegate = new ParamsSetNativeDelegate (ParamsSet_cb);
return ParamsSet_cb_delegate;
}
}
static void OverrideParamsSet (GLib.GType gtype)
{
OverrideParamsSet (gtype, ParamsSetVMCallback);
}
static void OverrideParamsSet (GLib.GType gtype, ParamsSetNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("params_set"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int ParamsSetNativeDelegate (IntPtr inst, IntPtr ctx);
static int ParamsSet_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPResult __result;
__result = __obj.OnParamsSet (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideParamsSet")]
protected virtual Gst.Rtsp.RTSPResult OnParamsSet (Gst.RtspServer.RTSPContext ctx)
{
return InternalParamsSet (ctx);
}
private Gst.Rtsp.RTSPResult InternalParamsSet (Gst.RtspServer.RTSPContext ctx)
{
ParamsSetNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("params_set"));
unmanaged = (ParamsSetNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ParamsSetNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPResult) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPResult) __result;
}
static ParamsGetNativeDelegate ParamsGet_cb_delegate;
static ParamsGetNativeDelegate ParamsGetVMCallback {
get {
if (ParamsGet_cb_delegate == null)
ParamsGet_cb_delegate = new ParamsGetNativeDelegate (ParamsGet_cb);
return ParamsGet_cb_delegate;
}
}
static void OverrideParamsGet (GLib.GType gtype)
{
OverrideParamsGet (gtype, ParamsGetVMCallback);
}
static void OverrideParamsGet (GLib.GType gtype, ParamsGetNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("params_get"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int ParamsGetNativeDelegate (IntPtr inst, IntPtr ctx);
static int ParamsGet_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPResult __result;
__result = __obj.OnParamsGet (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideParamsGet")]
protected virtual Gst.Rtsp.RTSPResult OnParamsGet (Gst.RtspServer.RTSPContext ctx)
{
return InternalParamsGet (ctx);
}
private Gst.Rtsp.RTSPResult InternalParamsGet (Gst.RtspServer.RTSPContext ctx)
{
ParamsGetNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("params_get"));
unmanaged = (ParamsGetNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ParamsGetNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPResult) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPResult) __result;
}
static MakePathFromUriNativeDelegate MakePathFromUri_cb_delegate;
static MakePathFromUriNativeDelegate MakePathFromUriVMCallback {
get {
if (MakePathFromUri_cb_delegate == null)
MakePathFromUri_cb_delegate = new MakePathFromUriNativeDelegate (MakePathFromUri_cb);
return MakePathFromUri_cb_delegate;
}
}
static void OverrideMakePathFromUri (GLib.GType gtype)
{
OverrideMakePathFromUri (gtype, MakePathFromUriVMCallback);
}
static void OverrideMakePathFromUri (GLib.GType gtype, MakePathFromUriNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("make_path_from_uri"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr MakePathFromUriNativeDelegate (IntPtr inst, IntPtr uri);
static IntPtr MakePathFromUri_cb (IntPtr inst, IntPtr uri)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
string __result;
__result = __obj.OnMakePathFromUri (Gst.Rtsp.RTSPUrl.New (uri));
return GLib.Marshaller.StringToPtrGStrdup(__result);
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideMakePathFromUri")]
protected virtual string OnMakePathFromUri (Gst.Rtsp.RTSPUrl uri)
{
return InternalMakePathFromUri (uri);
}
private string InternalMakePathFromUri (Gst.Rtsp.RTSPUrl uri)
{
MakePathFromUriNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("make_path_from_uri"));
unmanaged = (MakePathFromUriNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(MakePathFromUriNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr native_uri = GLib.Marshaller.StructureToPtrAlloc (uri);
IntPtr __result = unmanaged (this.Handle, native_uri);
Marshal.FreeHGlobal (native_uri);
return GLib.Marshaller.PtrToStringGFree(__result);
}
static AdjustPlayModeNativeDelegate AdjustPlayMode_cb_delegate;
static AdjustPlayModeNativeDelegate AdjustPlayModeVMCallback {
get {
if (AdjustPlayMode_cb_delegate == null)
AdjustPlayMode_cb_delegate = new AdjustPlayModeNativeDelegate (AdjustPlayMode_cb);
return AdjustPlayMode_cb_delegate;
}
}
static void OverrideAdjustPlayMode (GLib.GType gtype)
{
OverrideAdjustPlayMode (gtype, AdjustPlayModeVMCallback);
}
static void OverrideAdjustPlayMode (GLib.GType gtype, AdjustPlayModeNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_play_mode"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int AdjustPlayModeNativeDelegate (IntPtr inst, IntPtr context, IntPtr range, int flags, double rate, ulong trickmode_interval, bool enable_rate_control);
static int AdjustPlayMode_cb (IntPtr inst, IntPtr context, IntPtr range, int flags, double rate, ulong trickmode_interval, bool enable_rate_control)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnAdjustPlayMode (Gst.RtspServer.RTSPContext.New (context), Gst.Rtsp.RTSPTimeRange.New (range), (Gst.SeekFlags) flags, rate, trickmode_interval, enable_rate_control);
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideAdjustPlayMode")]
protected virtual Gst.Rtsp.RTSPStatusCode OnAdjustPlayMode (Gst.RtspServer.RTSPContext context, Gst.Rtsp.RTSPTimeRange range, Gst.SeekFlags flags, double rate, ulong trickmode_interval, bool enable_rate_control)
{
return InternalAdjustPlayMode (context, range, flags, rate, trickmode_interval, enable_rate_control);
}
private Gst.Rtsp.RTSPStatusCode InternalAdjustPlayMode (Gst.RtspServer.RTSPContext context, Gst.Rtsp.RTSPTimeRange range, Gst.SeekFlags flags, double rate, ulong trickmode_interval, bool enable_rate_control)
{
AdjustPlayModeNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_play_mode"));
unmanaged = (AdjustPlayModeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AdjustPlayModeNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_context = GLib.Marshaller.StructureToPtrAlloc (context);
IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
int __result = unmanaged (this.Handle, native_context, native_range, (int) flags, rate, trickmode_interval, enable_rate_control);
Marshal.FreeHGlobal (native_context);
Marshal.FreeHGlobal (native_range);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static AdjustPlayResponseNativeDelegate AdjustPlayResponse_cb_delegate;
static AdjustPlayResponseNativeDelegate AdjustPlayResponseVMCallback {
get {
if (AdjustPlayResponse_cb_delegate == null)
AdjustPlayResponse_cb_delegate = new AdjustPlayResponseNativeDelegate (AdjustPlayResponse_cb);
return AdjustPlayResponse_cb_delegate;
}
}
static void OverrideAdjustPlayResponse (GLib.GType gtype)
{
OverrideAdjustPlayResponse (gtype, AdjustPlayResponseVMCallback);
}
static void OverrideAdjustPlayResponse (GLib.GType gtype, AdjustPlayResponseNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_play_response"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int AdjustPlayResponseNativeDelegate (IntPtr inst, IntPtr context);
static int AdjustPlayResponse_cb (IntPtr inst, IntPtr context)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnAdjustPlayResponse (Gst.RtspServer.RTSPContext.New (context));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideAdjustPlayResponse")]
protected virtual Gst.Rtsp.RTSPStatusCode OnAdjustPlayResponse (Gst.RtspServer.RTSPContext context)
{
return InternalAdjustPlayResponse (context);
}
private Gst.Rtsp.RTSPStatusCode InternalAdjustPlayResponse (Gst.RtspServer.RTSPContext context)
{
AdjustPlayResponseNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_play_response"));
unmanaged = (AdjustPlayResponseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AdjustPlayResponseNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_context = GLib.Marshaller.StructureToPtrAlloc (context);
int __result = unmanaged (this.Handle, native_context);
Marshal.FreeHGlobal (native_context);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static ClosedNativeDelegate Closed_cb_delegate;
static ClosedNativeDelegate ClosedVMCallback {
get {
if (Closed_cb_delegate == null)
Closed_cb_delegate = new ClosedNativeDelegate (Closed_cb);
return Closed_cb_delegate;
}
}
static void OverrideClosed (GLib.GType gtype)
{
OverrideClosed (gtype, ClosedVMCallback);
}
static void OverrideClosed (GLib.GType gtype, ClosedNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("closed"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void ClosedNativeDelegate (IntPtr inst);
static void Closed_cb (IntPtr inst)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnClosed ();
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideClosed")]
protected virtual void OnClosed ()
{
InternalClosed ();
}
private void InternalClosed ()
{
ClosedNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("closed"));
unmanaged = (ClosedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ClosedNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle);
}
static NewSessionNativeDelegate NewSession_cb_delegate;
static NewSessionNativeDelegate NewSessionVMCallback {
get {
if (NewSession_cb_delegate == null)
NewSession_cb_delegate = new NewSessionNativeDelegate (NewSession_cb);
return NewSession_cb_delegate;
}
}
static void OverrideNewSession (GLib.GType gtype)
{
OverrideNewSession (gtype, NewSessionVMCallback);
}
static void OverrideNewSession (GLib.GType gtype, NewSessionNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("new_session"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void NewSessionNativeDelegate (IntPtr inst, IntPtr _object);
static void NewSession_cb (IntPtr inst, IntPtr _object)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnNewSession (GLib.Object.GetObject(_object) as Gst.RtspServer.RTSPSession);
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideNewSession")]
protected virtual void OnNewSession (Gst.RtspServer.RTSPSession _object)
{
InternalNewSession (_object);
}
private void InternalNewSession (Gst.RtspServer.RTSPSession _object)
{
NewSessionNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("new_session"));
unmanaged = (NewSessionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NewSessionNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle, _object == null ? IntPtr.Zero : _object.Handle);
}
static OptionsRequestNativeDelegate OptionsRequest_cb_delegate;
static OptionsRequestNativeDelegate OptionsRequestVMCallback {
get {
if (OptionsRequest_cb_delegate == null)
OptionsRequest_cb_delegate = new OptionsRequestNativeDelegate (OptionsRequest_cb);
return OptionsRequest_cb_delegate;
}
}
static void OverrideOptionsRequest (GLib.GType gtype)
{
OverrideOptionsRequest (gtype, OptionsRequestVMCallback);
}
static void OverrideOptionsRequest (GLib.GType gtype, OptionsRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("options_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void OptionsRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void OptionsRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnOptionsRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideOptionsRequest")]
protected virtual void OnOptionsRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalOptionsRequest (ctx);
}
private void InternalOptionsRequest (Gst.RtspServer.RTSPContext ctx)
{
OptionsRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("options_request"));
unmanaged = (OptionsRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(OptionsRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static DescribeRequestNativeDelegate DescribeRequest_cb_delegate;
static DescribeRequestNativeDelegate DescribeRequestVMCallback {
get {
if (DescribeRequest_cb_delegate == null)
DescribeRequest_cb_delegate = new DescribeRequestNativeDelegate (DescribeRequest_cb);
return DescribeRequest_cb_delegate;
}
}
static void OverrideDescribeRequest (GLib.GType gtype)
{
OverrideDescribeRequest (gtype, DescribeRequestVMCallback);
}
static void OverrideDescribeRequest (GLib.GType gtype, DescribeRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("describe_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void DescribeRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void DescribeRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnDescribeRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideDescribeRequest")]
protected virtual void OnDescribeRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalDescribeRequest (ctx);
}
private void InternalDescribeRequest (Gst.RtspServer.RTSPContext ctx)
{
DescribeRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("describe_request"));
unmanaged = (DescribeRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DescribeRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static SetupRequestNativeDelegate SetupRequest_cb_delegate;
static SetupRequestNativeDelegate SetupRequestVMCallback {
get {
if (SetupRequest_cb_delegate == null)
SetupRequest_cb_delegate = new SetupRequestNativeDelegate (SetupRequest_cb);
return SetupRequest_cb_delegate;
}
}
static void OverrideSetupRequest (GLib.GType gtype)
{
OverrideSetupRequest (gtype, SetupRequestVMCallback);
}
static void OverrideSetupRequest (GLib.GType gtype, SetupRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void SetupRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void SetupRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnSetupRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideSetupRequest")]
protected virtual void OnSetupRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalSetupRequest (ctx);
}
private void InternalSetupRequest (Gst.RtspServer.RTSPContext ctx)
{
SetupRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_request"));
unmanaged = (SetupRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetupRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static PlayRequestNativeDelegate PlayRequest_cb_delegate;
static PlayRequestNativeDelegate PlayRequestVMCallback {
get {
if (PlayRequest_cb_delegate == null)
PlayRequest_cb_delegate = new PlayRequestNativeDelegate (PlayRequest_cb);
return PlayRequest_cb_delegate;
}
}
static void OverridePlayRequest (GLib.GType gtype)
{
OverridePlayRequest (gtype, PlayRequestVMCallback);
}
static void OverridePlayRequest (GLib.GType gtype, PlayRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("play_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void PlayRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void PlayRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnPlayRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePlayRequest")]
protected virtual void OnPlayRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalPlayRequest (ctx);
}
private void InternalPlayRequest (Gst.RtspServer.RTSPContext ctx)
{
PlayRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("play_request"));
unmanaged = (PlayRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PlayRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static PauseRequestNativeDelegate PauseRequest_cb_delegate;
static PauseRequestNativeDelegate PauseRequestVMCallback {
get {
if (PauseRequest_cb_delegate == null)
PauseRequest_cb_delegate = new PauseRequestNativeDelegate (PauseRequest_cb);
return PauseRequest_cb_delegate;
}
}
static void OverridePauseRequest (GLib.GType gtype)
{
OverridePauseRequest (gtype, PauseRequestVMCallback);
}
static void OverridePauseRequest (GLib.GType gtype, PauseRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pause_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void PauseRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void PauseRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnPauseRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePauseRequest")]
protected virtual void OnPauseRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalPauseRequest (ctx);
}
private void InternalPauseRequest (Gst.RtspServer.RTSPContext ctx)
{
PauseRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pause_request"));
unmanaged = (PauseRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PauseRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static TeardownRequestNativeDelegate TeardownRequest_cb_delegate;
static TeardownRequestNativeDelegate TeardownRequestVMCallback {
get {
if (TeardownRequest_cb_delegate == null)
TeardownRequest_cb_delegate = new TeardownRequestNativeDelegate (TeardownRequest_cb);
return TeardownRequest_cb_delegate;
}
}
static void OverrideTeardownRequest (GLib.GType gtype)
{
OverrideTeardownRequest (gtype, TeardownRequestVMCallback);
}
static void OverrideTeardownRequest (GLib.GType gtype, TeardownRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("teardown_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void TeardownRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void TeardownRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnTeardownRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideTeardownRequest")]
protected virtual void OnTeardownRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalTeardownRequest (ctx);
}
private void InternalTeardownRequest (Gst.RtspServer.RTSPContext ctx)
{
TeardownRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("teardown_request"));
unmanaged = (TeardownRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TeardownRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static SetParameterRequestNativeDelegate SetParameterRequest_cb_delegate;
static SetParameterRequestNativeDelegate SetParameterRequestVMCallback {
get {
if (SetParameterRequest_cb_delegate == null)
SetParameterRequest_cb_delegate = new SetParameterRequestNativeDelegate (SetParameterRequest_cb);
return SetParameterRequest_cb_delegate;
}
}
static void OverrideSetParameterRequest (GLib.GType gtype)
{
OverrideSetParameterRequest (gtype, SetParameterRequestVMCallback);
}
static void OverrideSetParameterRequest (GLib.GType gtype, SetParameterRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_parameter_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void SetParameterRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void SetParameterRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnSetParameterRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideSetParameterRequest")]
protected virtual void OnSetParameterRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalSetParameterRequest (ctx);
}
private void InternalSetParameterRequest (Gst.RtspServer.RTSPContext ctx)
{
SetParameterRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_parameter_request"));
unmanaged = (SetParameterRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetParameterRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static GetParameterRequestNativeDelegate GetParameterRequest_cb_delegate;
static GetParameterRequestNativeDelegate GetParameterRequestVMCallback {
get {
if (GetParameterRequest_cb_delegate == null)
GetParameterRequest_cb_delegate = new GetParameterRequestNativeDelegate (GetParameterRequest_cb);
return GetParameterRequest_cb_delegate;
}
}
static void OverrideGetParameterRequest (GLib.GType gtype)
{
OverrideGetParameterRequest (gtype, GetParameterRequestVMCallback);
}
static void OverrideGetParameterRequest (GLib.GType gtype, GetParameterRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_parameter_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void GetParameterRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void GetParameterRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnGetParameterRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideGetParameterRequest")]
protected virtual void OnGetParameterRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalGetParameterRequest (ctx);
}
private void InternalGetParameterRequest (Gst.RtspServer.RTSPContext ctx)
{
GetParameterRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_parameter_request"));
unmanaged = (GetParameterRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetParameterRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static HandleResponseNativeDelegate HandleResponse_cb_delegate;
static HandleResponseNativeDelegate HandleResponseVMCallback {
get {
if (HandleResponse_cb_delegate == null)
HandleResponse_cb_delegate = new HandleResponseNativeDelegate (HandleResponse_cb);
return HandleResponse_cb_delegate;
}
}
static void OverrideHandleResponse (GLib.GType gtype)
{
OverrideHandleResponse (gtype, HandleResponseVMCallback);
}
static void OverrideHandleResponse (GLib.GType gtype, HandleResponseNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_response"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void HandleResponseNativeDelegate (IntPtr inst, IntPtr ctx);
static void HandleResponse_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnHandleResponse (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideHandleResponse")]
protected virtual void OnHandleResponse (Gst.RtspServer.RTSPContext ctx)
{
InternalHandleResponse (ctx);
}
private void InternalHandleResponse (Gst.RtspServer.RTSPContext ctx)
{
HandleResponseNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_response"));
unmanaged = (HandleResponseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(HandleResponseNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static TunnelHttpResponseNativeDelegate TunnelHttpResponse_cb_delegate;
static TunnelHttpResponseNativeDelegate TunnelHttpResponseVMCallback {
get {
if (TunnelHttpResponse_cb_delegate == null)
TunnelHttpResponse_cb_delegate = new TunnelHttpResponseNativeDelegate (TunnelHttpResponse_cb);
return TunnelHttpResponse_cb_delegate;
}
}
static void OverrideTunnelHttpResponse (GLib.GType gtype)
{
OverrideTunnelHttpResponse (gtype, TunnelHttpResponseVMCallback);
}
static void OverrideTunnelHttpResponse (GLib.GType gtype, TunnelHttpResponseNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("tunnel_http_response"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void TunnelHttpResponseNativeDelegate (IntPtr inst, IntPtr request, IntPtr response);
static void TunnelHttpResponse_cb (IntPtr inst, IntPtr request, IntPtr response)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnTunnelHttpResponse (Gst.Rtsp.RTSPMessage.New (request), Gst.Rtsp.RTSPMessage.New (response));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideTunnelHttpResponse")]
protected virtual void OnTunnelHttpResponse (Gst.Rtsp.RTSPMessage request, Gst.Rtsp.RTSPMessage response)
{
InternalTunnelHttpResponse (request, response);
}
private void InternalTunnelHttpResponse (Gst.Rtsp.RTSPMessage request, Gst.Rtsp.RTSPMessage response)
{
TunnelHttpResponseNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("tunnel_http_response"));
unmanaged = (TunnelHttpResponseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TunnelHttpResponseNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_request = GLib.Marshaller.StructureToPtrAlloc (request);
IntPtr native_response = GLib.Marshaller.StructureToPtrAlloc (response);
unmanaged (this.Handle, native_request, native_response);
Marshal.FreeHGlobal (native_request);
Marshal.FreeHGlobal (native_response);
}
static SendMessageEventNativeDelegate SendMessageEvent_cb_delegate;
static SendMessageEventNativeDelegate SendMessageEventVMCallback {
get {
if (SendMessageEvent_cb_delegate == null)
SendMessageEvent_cb_delegate = new SendMessageEventNativeDelegate (SendMessageEvent_cb);
return SendMessageEvent_cb_delegate;
}
}
static void OverrideSendMessageEvent (GLib.GType gtype)
{
OverrideSendMessageEvent (gtype, SendMessageEventVMCallback);
}
static void OverrideSendMessageEvent (GLib.GType gtype, SendMessageEventNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("send_message"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void SendMessageEventNativeDelegate (IntPtr inst, IntPtr session, IntPtr message);
static void SendMessageEvent_cb (IntPtr inst, IntPtr session, IntPtr message)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnSendMessageEvent (GLib.Object.GetObject(session) as Gst.RtspServer.RTSPSession, message);
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideSendMessageEvent")]
protected virtual void OnSendMessageEvent (Gst.RtspServer.RTSPSession session, IntPtr message)
{
InternalSendMessageEvent (session, message);
}
private void InternalSendMessageEvent (Gst.RtspServer.RTSPSession session, IntPtr message)
{
SendMessageEventNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("send_message"));
unmanaged = (SendMessageEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SendMessageEventNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle, session == null ? IntPtr.Zero : session.Handle, message);
}
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 ctx, IntPtr media, IntPtr sdp);
static bool HandleSdp_cb (IntPtr inst, IntPtr ctx, IntPtr media, IntPtr sdp)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
bool __result;
__result = __obj.OnHandleSdp (Gst.RtspServer.RTSPContext.New (ctx), GLib.Object.GetObject(media) as Gst.RtspServer.RTSPMedia, 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.RTSPClient), ConnectionMethod="OverrideHandleSdp")]
protected virtual bool OnHandleSdp (Gst.RtspServer.RTSPContext ctx, Gst.RtspServer.RTSPMedia media, Gst.Sdp.SDPMessage sdp)
{
return InternalHandleSdp (ctx, media, sdp);
}
private bool InternalHandleSdp (Gst.RtspServer.RTSPContext ctx, Gst.RtspServer.RTSPMedia media, 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;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
bool __result = unmanaged (this.Handle, native_ctx, media == null ? IntPtr.Zero : media.Handle, sdp == null ? IntPtr.Zero : sdp.Handle);
Marshal.FreeHGlobal (native_ctx);
return __result;
}
static AnnounceRequestNativeDelegate AnnounceRequest_cb_delegate;
static AnnounceRequestNativeDelegate AnnounceRequestVMCallback {
get {
if (AnnounceRequest_cb_delegate == null)
AnnounceRequest_cb_delegate = new AnnounceRequestNativeDelegate (AnnounceRequest_cb);
return AnnounceRequest_cb_delegate;
}
}
static void OverrideAnnounceRequest (GLib.GType gtype)
{
OverrideAnnounceRequest (gtype, AnnounceRequestVMCallback);
}
static void OverrideAnnounceRequest (GLib.GType gtype, AnnounceRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("announce_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void AnnounceRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void AnnounceRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnAnnounceRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideAnnounceRequest")]
protected virtual void OnAnnounceRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalAnnounceRequest (ctx);
}
private void InternalAnnounceRequest (Gst.RtspServer.RTSPContext ctx)
{
AnnounceRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("announce_request"));
unmanaged = (AnnounceRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AnnounceRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static RecordRequestNativeDelegate RecordRequest_cb_delegate;
static RecordRequestNativeDelegate RecordRequestVMCallback {
get {
if (RecordRequest_cb_delegate == null)
RecordRequest_cb_delegate = new RecordRequestNativeDelegate (RecordRequest_cb);
return RecordRequest_cb_delegate;
}
}
static void OverrideRecordRequest (GLib.GType gtype)
{
OverrideRecordRequest (gtype, RecordRequestVMCallback);
}
static void OverrideRecordRequest (GLib.GType gtype, RecordRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("record_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void RecordRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static void RecordRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
__obj.OnRecordRequest (Gst.RtspServer.RTSPContext.New (ctx));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideRecordRequest")]
protected virtual void OnRecordRequest (Gst.RtspServer.RTSPContext ctx)
{
InternalRecordRequest (ctx);
}
private void InternalRecordRequest (Gst.RtspServer.RTSPContext ctx)
{
RecordRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("record_request"));
unmanaged = (RecordRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RecordRequestNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
}
static PreOptionsRequestNativeDelegate PreOptionsRequest_cb_delegate;
static PreOptionsRequestNativeDelegate PreOptionsRequestVMCallback {
get {
if (PreOptionsRequest_cb_delegate == null)
PreOptionsRequest_cb_delegate = new PreOptionsRequestNativeDelegate (PreOptionsRequest_cb);
return PreOptionsRequest_cb_delegate;
}
}
static void OverridePreOptionsRequest (GLib.GType gtype)
{
OverridePreOptionsRequest (gtype, PreOptionsRequestVMCallback);
}
static void OverridePreOptionsRequest (GLib.GType gtype, PreOptionsRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_options_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PreOptionsRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PreOptionsRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPreOptionsRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreOptionsRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPreOptionsRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPreOptionsRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPreOptionsRequest (Gst.RtspServer.RTSPContext ctx)
{
PreOptionsRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_options_request"));
unmanaged = (PreOptionsRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreOptionsRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PreDescribeRequestNativeDelegate PreDescribeRequest_cb_delegate;
static PreDescribeRequestNativeDelegate PreDescribeRequestVMCallback {
get {
if (PreDescribeRequest_cb_delegate == null)
PreDescribeRequest_cb_delegate = new PreDescribeRequestNativeDelegate (PreDescribeRequest_cb);
return PreDescribeRequest_cb_delegate;
}
}
static void OverridePreDescribeRequest (GLib.GType gtype)
{
OverridePreDescribeRequest (gtype, PreDescribeRequestVMCallback);
}
static void OverridePreDescribeRequest (GLib.GType gtype, PreDescribeRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_describe_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PreDescribeRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PreDescribeRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPreDescribeRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreDescribeRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPreDescribeRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPreDescribeRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPreDescribeRequest (Gst.RtspServer.RTSPContext ctx)
{
PreDescribeRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_describe_request"));
unmanaged = (PreDescribeRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreDescribeRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PreSetupRequestNativeDelegate PreSetupRequest_cb_delegate;
static PreSetupRequestNativeDelegate PreSetupRequestVMCallback {
get {
if (PreSetupRequest_cb_delegate == null)
PreSetupRequest_cb_delegate = new PreSetupRequestNativeDelegate (PreSetupRequest_cb);
return PreSetupRequest_cb_delegate;
}
}
static void OverridePreSetupRequest (GLib.GType gtype)
{
OverridePreSetupRequest (gtype, PreSetupRequestVMCallback);
}
static void OverridePreSetupRequest (GLib.GType gtype, PreSetupRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_setup_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PreSetupRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PreSetupRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPreSetupRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreSetupRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPreSetupRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPreSetupRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPreSetupRequest (Gst.RtspServer.RTSPContext ctx)
{
PreSetupRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_setup_request"));
unmanaged = (PreSetupRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreSetupRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PrePlayRequestNativeDelegate PrePlayRequest_cb_delegate;
static PrePlayRequestNativeDelegate PrePlayRequestVMCallback {
get {
if (PrePlayRequest_cb_delegate == null)
PrePlayRequest_cb_delegate = new PrePlayRequestNativeDelegate (PrePlayRequest_cb);
return PrePlayRequest_cb_delegate;
}
}
static void OverridePrePlayRequest (GLib.GType gtype)
{
OverridePrePlayRequest (gtype, PrePlayRequestVMCallback);
}
static void OverridePrePlayRequest (GLib.GType gtype, PrePlayRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_play_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PrePlayRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PrePlayRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPrePlayRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePrePlayRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPrePlayRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPrePlayRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPrePlayRequest (Gst.RtspServer.RTSPContext ctx)
{
PrePlayRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_play_request"));
unmanaged = (PrePlayRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrePlayRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PrePauseRequestNativeDelegate PrePauseRequest_cb_delegate;
static PrePauseRequestNativeDelegate PrePauseRequestVMCallback {
get {
if (PrePauseRequest_cb_delegate == null)
PrePauseRequest_cb_delegate = new PrePauseRequestNativeDelegate (PrePauseRequest_cb);
return PrePauseRequest_cb_delegate;
}
}
static void OverridePrePauseRequest (GLib.GType gtype)
{
OverridePrePauseRequest (gtype, PrePauseRequestVMCallback);
}
static void OverridePrePauseRequest (GLib.GType gtype, PrePauseRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_pause_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PrePauseRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PrePauseRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPrePauseRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePrePauseRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPrePauseRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPrePauseRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPrePauseRequest (Gst.RtspServer.RTSPContext ctx)
{
PrePauseRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_pause_request"));
unmanaged = (PrePauseRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrePauseRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PreTeardownRequestNativeDelegate PreTeardownRequest_cb_delegate;
static PreTeardownRequestNativeDelegate PreTeardownRequestVMCallback {
get {
if (PreTeardownRequest_cb_delegate == null)
PreTeardownRequest_cb_delegate = new PreTeardownRequestNativeDelegate (PreTeardownRequest_cb);
return PreTeardownRequest_cb_delegate;
}
}
static void OverridePreTeardownRequest (GLib.GType gtype)
{
OverridePreTeardownRequest (gtype, PreTeardownRequestVMCallback);
}
static void OverridePreTeardownRequest (GLib.GType gtype, PreTeardownRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_teardown_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PreTeardownRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PreTeardownRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPreTeardownRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreTeardownRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPreTeardownRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPreTeardownRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPreTeardownRequest (Gst.RtspServer.RTSPContext ctx)
{
PreTeardownRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_teardown_request"));
unmanaged = (PreTeardownRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreTeardownRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PreSetParameterRequestNativeDelegate PreSetParameterRequest_cb_delegate;
static PreSetParameterRequestNativeDelegate PreSetParameterRequestVMCallback {
get {
if (PreSetParameterRequest_cb_delegate == null)
PreSetParameterRequest_cb_delegate = new PreSetParameterRequestNativeDelegate (PreSetParameterRequest_cb);
return PreSetParameterRequest_cb_delegate;
}
}
static void OverridePreSetParameterRequest (GLib.GType gtype)
{
OverridePreSetParameterRequest (gtype, PreSetParameterRequestVMCallback);
}
static void OverridePreSetParameterRequest (GLib.GType gtype, PreSetParameterRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_set_parameter_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PreSetParameterRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PreSetParameterRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPreSetParameterRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreSetParameterRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPreSetParameterRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPreSetParameterRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPreSetParameterRequest (Gst.RtspServer.RTSPContext ctx)
{
PreSetParameterRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_set_parameter_request"));
unmanaged = (PreSetParameterRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreSetParameterRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PreGetParameterRequestNativeDelegate PreGetParameterRequest_cb_delegate;
static PreGetParameterRequestNativeDelegate PreGetParameterRequestVMCallback {
get {
if (PreGetParameterRequest_cb_delegate == null)
PreGetParameterRequest_cb_delegate = new PreGetParameterRequestNativeDelegate (PreGetParameterRequest_cb);
return PreGetParameterRequest_cb_delegate;
}
}
static void OverridePreGetParameterRequest (GLib.GType gtype)
{
OverridePreGetParameterRequest (gtype, PreGetParameterRequestVMCallback);
}
static void OverridePreGetParameterRequest (GLib.GType gtype, PreGetParameterRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_get_parameter_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PreGetParameterRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PreGetParameterRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPreGetParameterRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreGetParameterRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPreGetParameterRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPreGetParameterRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPreGetParameterRequest (Gst.RtspServer.RTSPContext ctx)
{
PreGetParameterRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_get_parameter_request"));
unmanaged = (PreGetParameterRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreGetParameterRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PreAnnounceRequestNativeDelegate PreAnnounceRequest_cb_delegate;
static PreAnnounceRequestNativeDelegate PreAnnounceRequestVMCallback {
get {
if (PreAnnounceRequest_cb_delegate == null)
PreAnnounceRequest_cb_delegate = new PreAnnounceRequestNativeDelegate (PreAnnounceRequest_cb);
return PreAnnounceRequest_cb_delegate;
}
}
static void OverridePreAnnounceRequest (GLib.GType gtype)
{
OverridePreAnnounceRequest (gtype, PreAnnounceRequestVMCallback);
}
static void OverridePreAnnounceRequest (GLib.GType gtype, PreAnnounceRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_announce_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PreAnnounceRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PreAnnounceRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPreAnnounceRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreAnnounceRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPreAnnounceRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPreAnnounceRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPreAnnounceRequest (Gst.RtspServer.RTSPContext ctx)
{
PreAnnounceRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_announce_request"));
unmanaged = (PreAnnounceRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreAnnounceRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static PreRecordRequestNativeDelegate PreRecordRequest_cb_delegate;
static PreRecordRequestNativeDelegate PreRecordRequestVMCallback {
get {
if (PreRecordRequest_cb_delegate == null)
PreRecordRequest_cb_delegate = new PreRecordRequestNativeDelegate (PreRecordRequest_cb);
return PreRecordRequest_cb_delegate;
}
}
static void OverridePreRecordRequest (GLib.GType gtype)
{
OverridePreRecordRequest (gtype, PreRecordRequestVMCallback);
}
static void OverridePreRecordRequest (GLib.GType gtype, PreRecordRequestNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_record_request"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PreRecordRequestNativeDelegate (IntPtr inst, IntPtr ctx);
static int PreRecordRequest_cb (IntPtr inst, IntPtr ctx)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnPreRecordRequest (Gst.RtspServer.RTSPContext.New (ctx));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverridePreRecordRequest")]
protected virtual Gst.Rtsp.RTSPStatusCode OnPreRecordRequest (Gst.RtspServer.RTSPContext ctx)
{
return InternalPreRecordRequest (ctx);
}
private Gst.Rtsp.RTSPStatusCode InternalPreRecordRequest (Gst.RtspServer.RTSPContext ctx)
{
PreRecordRequestNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pre_record_request"));
unmanaged = (PreRecordRequestNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreRecordRequestNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __result;
}
static AdjustErrorCodeNativeDelegate AdjustErrorCode_cb_delegate;
static AdjustErrorCodeNativeDelegate AdjustErrorCodeVMCallback {
get {
if (AdjustErrorCode_cb_delegate == null)
AdjustErrorCode_cb_delegate = new AdjustErrorCodeNativeDelegate (AdjustErrorCode_cb);
return AdjustErrorCode_cb_delegate;
}
}
static void OverrideAdjustErrorCode (GLib.GType gtype)
{
OverrideAdjustErrorCode (gtype, AdjustErrorCodeVMCallback);
}
static void OverrideAdjustErrorCode (GLib.GType gtype, AdjustErrorCodeNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_error_code"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int AdjustErrorCodeNativeDelegate (IntPtr inst, IntPtr ctx, int code);
static int AdjustErrorCode_cb (IntPtr inst, IntPtr ctx, int code)
{
try {
RTSPClient __obj = GLib.Object.GetObject (inst, false) as RTSPClient;
Gst.Rtsp.RTSPStatusCode __result;
__result = __obj.OnAdjustErrorCode (Gst.RtspServer.RTSPContext.New (ctx), (Gst.Rtsp.RTSPStatusCode) code);
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPClient), ConnectionMethod="OverrideAdjustErrorCode")]
protected virtual Gst.Rtsp.RTSPStatusCode OnAdjustErrorCode (Gst.RtspServer.RTSPContext ctx, Gst.Rtsp.RTSPStatusCode code)
{
return InternalAdjustErrorCode (ctx, code);
}
private Gst.Rtsp.RTSPStatusCode InternalAdjustErrorCode (Gst.RtspServer.RTSPContext ctx, Gst.Rtsp.RTSPStatusCode code)
{
AdjustErrorCodeNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("adjust_error_code"));
unmanaged = (AdjustErrorCodeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AdjustErrorCodeNativeDelegate));
}
if (unmanaged == null) return (Gst.Rtsp.RTSPStatusCode) 0;
IntPtr native_ctx = GLib.Marshaller.StructureToPtrAlloc (ctx);
int __result = unmanaged (this.Handle, native_ctx, (int) code);
Marshal.FreeHGlobal (native_ctx);
return (Gst.Rtsp.RTSPStatusCode) __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("create_sdp"
, GLib.Object.class_abi.Fields
, (uint) Marshal.SizeOf(typeof(IntPtr)) // create_sdp
, null
, "configure_client_media"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("configure_client_media"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // configure_client_media
, "create_sdp"
, "configure_client_transport"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("configure_client_transport"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // configure_client_transport
, "configure_client_media"
, "params_set"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("params_set"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // params_set
, "configure_client_transport"
, "params_get"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("params_get"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // params_get
, "params_set"
, "make_path_from_uri"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("make_path_from_uri"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // make_path_from_uri
, "params_get"
, "adjust_play_mode"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("adjust_play_mode"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // adjust_play_mode
, "make_path_from_uri"
, "adjust_play_response"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("adjust_play_response"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // adjust_play_response
, "adjust_play_mode"
, "closed"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("closed"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // closed
, "adjust_play_response"
, "new_session"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("new_session"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // new_session
, "closed"
, "options_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("options_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // options_request
, "new_session"
, "describe_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("describe_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // describe_request
, "options_request"
, "setup_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("setup_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // setup_request
, "describe_request"
, "play_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("play_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // play_request
, "setup_request"
, "pause_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pause_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pause_request
, "play_request"
, "teardown_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("teardown_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // teardown_request
, "pause_request"
, "set_parameter_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("set_parameter_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_parameter_request
, "teardown_request"
, "get_parameter_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("get_parameter_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_parameter_request
, "set_parameter_request"
, "handle_response"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("handle_response"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_response
, "get_parameter_request"
, "tunnel_http_response"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("tunnel_http_response"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // tunnel_http_response
, "handle_response"
, "send_message"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("send_message"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // send_message
, "tunnel_http_response"
, "handle_sdp"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("handle_sdp"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_sdp
, "send_message"
, "announce_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("announce_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // announce_request
, "handle_sdp"
, "record_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("record_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // record_request
, "announce_request"
, "check_requirements"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("check_requirements"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // check_requirements
, "record_request"
, "pre_options_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_options_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_options_request
, "check_requirements"
, "pre_describe_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_describe_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_describe_request
, "pre_options_request"
, "pre_setup_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_setup_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_setup_request
, "pre_describe_request"
, "pre_play_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_play_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_play_request
, "pre_setup_request"
, "pre_pause_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_pause_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_pause_request
, "pre_play_request"
, "pre_teardown_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_teardown_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_teardown_request
, "pre_pause_request"
, "pre_set_parameter_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_set_parameter_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_set_parameter_request
, "pre_teardown_request"
, "pre_get_parameter_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_get_parameter_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_get_parameter_request
, "pre_set_parameter_request"
, "pre_announce_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_announce_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_announce_request
, "pre_get_parameter_request"
, "pre_record_request"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pre_record_request"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pre_record_request
, "pre_announce_request"
, "adjust_error_code"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("adjust_error_code"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // adjust_error_code
, "pre_record_request"
, "_gst_reserved"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("_gst_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 1 // _gst_reserved
, "adjust_error_code"
, 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_client_get_type();
public static new GLib.GType GType {
get {
IntPtr raw_ret = gst_rtsp_client_get_type();
GLib.GType ret = new GLib.GType(raw_ret);
return ret;
}
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern uint gst_rtsp_client_attach(IntPtr raw, IntPtr context);
public uint Attach(GLib.MainContext context) {
uint raw_ret = gst_rtsp_client_attach(Handle, context == null ? IntPtr.Zero : context.Handle);
uint ret = raw_ret;
return ret;
}
public uint Attach() {
return Attach (null);
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_rtsp_client_close(IntPtr raw);
public void Close() {
gst_rtsp_client_close(Handle);
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_rtsp_client_get_auth(IntPtr raw);
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_rtsp_client_set_auth(IntPtr raw, IntPtr auth);
public Gst.RtspServer.RTSPAuth Auth {
get {
IntPtr raw_ret = gst_rtsp_client_get_auth(Handle);
Gst.RtspServer.RTSPAuth ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPAuth;
return ret;
}
set {
gst_rtsp_client_set_auth(Handle, value == null ? IntPtr.Zero : value.Handle);
}
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_rtsp_client_get_connection(IntPtr raw);
public Gst.Rtsp.RTSPConnection Connection {
get {
IntPtr raw_ret = gst_rtsp_client_get_connection(Handle);
Gst.Rtsp.RTSPConnection ret = raw_ret == IntPtr.Zero ? null : (Gst.Rtsp.RTSPConnection) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Rtsp.RTSPConnection), false);
return ret;
}
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern uint gst_rtsp_client_get_content_length_limit(IntPtr raw);
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_rtsp_client_set_content_length_limit(IntPtr raw, uint limit);
public uint ContentLengthLimit {
get {
uint raw_ret = gst_rtsp_client_get_content_length_limit(Handle);
uint ret = raw_ret;
return ret;
}
set {
gst_rtsp_client_set_content_length_limit(Handle, value);
}
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_rtsp_client_get_stream_transport(IntPtr raw, byte channel);
public Gst.RtspServer.RTSPStreamTransport GetStreamTransport(byte channel) {
IntPtr raw_ret = gst_rtsp_client_get_stream_transport(Handle, channel);
Gst.RtspServer.RTSPStreamTransport ret = GLib.Object.GetObject(raw_ret) as Gst.RtspServer.RTSPStreamTransport;
return ret;
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_rtsp_client_get_thread_pool(IntPtr raw);
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_rtsp_client_set_thread_pool(IntPtr raw, IntPtr pool);
public Gst.RtspServer.RTSPThreadPool ThreadPool {
get {
IntPtr raw_ret = gst_rtsp_client_get_thread_pool(Handle);
Gst.RtspServer.RTSPThreadPool ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPThreadPool;
return ret;
}
set {
gst_rtsp_client_set_thread_pool(Handle, value == null ? IntPtr.Zero : value.Handle);
}
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int gst_rtsp_client_handle_message(IntPtr raw, IntPtr message);
public Gst.Rtsp.RTSPResult HandleMessage(Gst.Rtsp.RTSPMessage message) {
IntPtr native_message = GLib.Marshaller.StructureToPtrAlloc (message);
int raw_ret = gst_rtsp_client_handle_message(Handle, native_message);
Gst.Rtsp.RTSPResult ret = (Gst.Rtsp.RTSPResult) raw_ret;
Marshal.FreeHGlobal (native_message);
return ret;
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int gst_rtsp_client_send_message(IntPtr raw, IntPtr session, IntPtr message);
public Gst.Rtsp.RTSPResult SendMessage(Gst.RtspServer.RTSPSession session, Gst.Rtsp.RTSPMessage message) {
IntPtr native_message = GLib.Marshaller.StructureToPtrAlloc (message);
int raw_ret = gst_rtsp_client_send_message(Handle, session == null ? IntPtr.Zero : session.Handle, native_message);
Gst.Rtsp.RTSPResult ret = (Gst.Rtsp.RTSPResult) raw_ret;
Marshal.FreeHGlobal (native_message);
return ret;
}
public Gst.Rtsp.RTSPResult SendMessage(Gst.Rtsp.RTSPMessage message) {
return SendMessage (null, message);
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_rtsp_client_session_filter(IntPtr raw, Gst.RtspServerSharp.RTSPClientSessionFilterFuncNative func, IntPtr user_data);
public Gst.RtspServer.RTSPSession[] SessionFilter(Gst.RtspServer.RTSPClientSessionFilterFunc func) {
Gst.RtspServerSharp.RTSPClientSessionFilterFuncWrapper func_wrapper = new Gst.RtspServerSharp.RTSPClientSessionFilterFuncWrapper (func);
IntPtr raw_ret = gst_rtsp_client_session_filter(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
Gst.RtspServer.RTSPSession[] ret = (Gst.RtspServer.RTSPSession[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(Gst.RtspServer.RTSPSession));
return ret;
}
public Gst.RtspServer.RTSPSession[] SessionFilter() {
return SessionFilter (null);
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_rtsp_client_set_connection(IntPtr raw, IntPtr conn);
public bool SetConnection(Gst.Rtsp.RTSPConnection conn) {
conn.Owned = false;
bool raw_ret = gst_rtsp_client_set_connection(Handle, conn == null ? IntPtr.Zero : conn.Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_rtsp_client_set_send_func(IntPtr raw, Gst.RtspServerSharp.RTSPClientSendFuncNative func, IntPtr user_data, GLib.DestroyNotify notify);
public Gst.RtspServer.RTSPClientSendFunc SendFunc {
set {
Gst.RtspServerSharp.RTSPClientSendFuncWrapper value_wrapper = new Gst.RtspServerSharp.RTSPClientSendFuncWrapper (value);
IntPtr user_data;
GLib.DestroyNotify notify;
if (value == null) {
user_data = IntPtr.Zero;
notify = null;
} else {
user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
notify = GLib.DestroyHelper.NotifyHandler;
}
gst_rtsp_client_set_send_func(Handle, value_wrapper.NativeDelegate, user_data, notify);
}
}
[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_rtsp_client_set_send_messages_func(IntPtr raw, Gst.RtspServerSharp.RTSPClientSendMessagesFuncNative func, IntPtr user_data, GLib.DestroyNotify notify);
public Gst.RtspServer.RTSPClientSendMessagesFunc SendMessagesFunc {
set {
Gst.RtspServerSharp.RTSPClientSendMessagesFuncWrapper value_wrapper = new Gst.RtspServerSharp.RTSPClientSendMessagesFuncWrapper (value);
IntPtr user_data;
GLib.DestroyNotify notify;
if (value == null) {
user_data = IntPtr.Zero;
notify = null;
} else {
user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
notify = GLib.DestroyHelper.NotifyHandler;
}
gst_rtsp_client_set_send_messages_func(Handle, value_wrapper.NativeDelegate, user_data, notify);
}
}
static RTSPClient ()
{
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
}
}