// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.

namespace Gst.RtspServer {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;

#region Autogenerated code
	public partial class RTSPMedia : GLib.Object {

		public RTSPMedia (IntPtr raw) : base(raw) {}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_new(IntPtr element);

		public RTSPMedia (Gst.Element element) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (RTSPMedia)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				if (element != null) {
					names.Add ("element");
					vals.Add (new GLib.Value (element));
				}
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = gst_rtsp_media_new(element == null ? IntPtr.Zero : element.OwnedHandle);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_bind_mcast_address(IntPtr raw, bool bind_mcast_addr);

		[GLib.Property ("bind-mcast-address")]
		public bool BindMcastAddress {
			get {
				GLib.Value val = GetProperty ("bind-mcast-address");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set  {
				gst_rtsp_media_set_bind_mcast_address(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_rtsp_media_get_buffer_size(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_buffer_size(IntPtr raw, uint size);

		[GLib.Property ("buffer-size")]
		public uint BufferSize {
			get  {
				uint raw_ret = gst_rtsp_media_get_buffer_size(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_buffer_size(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_clock(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_clock(IntPtr raw, IntPtr clock);

		[GLib.Property ("clock")]
		public Gst.Clock Clock {
			get  {
				IntPtr raw_ret = gst_rtsp_media_get_clock(Handle);
				Gst.Clock ret = GLib.Object.GetObject(raw_ret, true) as Gst.Clock;
				return ret;
			}
			set  {
				gst_rtsp_media_set_clock(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_media_get_dscp_qos(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_dscp_qos(IntPtr raw, int dscp_qos);

		[GLib.Property ("dscp-qos")]
		public int DscpQos {
			get  {
				int raw_ret = gst_rtsp_media_get_dscp_qos(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_dscp_qos(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_element(IntPtr raw);

		[GLib.Property ("element")]
		public Gst.Element Element {
			get  {
				IntPtr raw_ret = gst_rtsp_media_get_element(Handle);
				Gst.Element ret = GLib.Object.GetObject(raw_ret, true) as Gst.Element;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_get_ensure_keyunit_on_start(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_ensure_keyunit_on_start(IntPtr raw, bool ensure_keyunit_on_start);

		[GLib.Property ("ensure-keyunit-on-start")]
		public bool EnsureKeyunitOnStart {
			get  {
				bool raw_ret = gst_rtsp_media_get_ensure_keyunit_on_start(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_ensure_keyunit_on_start(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_rtsp_media_get_ensure_keyunit_on_start_timeout(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_ensure_keyunit_on_start_timeout(IntPtr raw, uint timeout);

		[GLib.Property ("ensure-keyunit-on-start-timeout")]
		public uint EnsureKeyunitOnStartTimeout {
			get  {
				uint raw_ret = gst_rtsp_media_get_ensure_keyunit_on_start_timeout(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_ensure_keyunit_on_start_timeout(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_eos_shutdown(IntPtr raw, bool eos_shutdown);

		[GLib.Property ("eos-shutdown")]
		public bool EosShutdown {
			get {
				GLib.Value val = GetProperty ("eos-shutdown");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set  {
				gst_rtsp_media_set_eos_shutdown(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_rtsp_media_get_latency(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_latency(IntPtr raw, uint latency);

		[GLib.Property ("latency")]
		public uint Latency {
			get  {
				uint raw_ret = gst_rtsp_media_get_latency(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_latency(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_rtsp_media_get_max_mcast_ttl(IntPtr raw);

		[GLib.Property ("max-mcast-ttl")]
		public uint MaxMcastTtl {
			get  {
				uint raw_ret = gst_rtsp_media_get_max_mcast_ttl(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("max-mcast-ttl", val);
				val.Dispose ();
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_media_get_profiles(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_profiles(IntPtr raw, int profiles);

		[GLib.Property ("profiles")]
		public Gst.Rtsp.RTSPProfile Profiles {
			get  {
				int raw_ret = gst_rtsp_media_get_profiles(Handle);
				Gst.Rtsp.RTSPProfile ret = (Gst.Rtsp.RTSPProfile) raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_profiles(Handle, (int) value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_media_get_protocols(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_protocols(IntPtr raw, int protocols);

		[GLib.Property ("protocols")]
		public Gst.Rtsp.RTSPLowerTrans Protocols {
			get  {
				int raw_ret = gst_rtsp_media_get_protocols(Handle);
				Gst.Rtsp.RTSPLowerTrans ret = (Gst.Rtsp.RTSPLowerTrans) raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_protocols(Handle, (int) value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_reusable(IntPtr raw, bool reusable);

		[GLib.Property ("reusable")]
		public bool Reusable {
			get {
				GLib.Value val = GetProperty ("reusable");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set  {
				gst_rtsp_media_set_reusable(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_shared(IntPtr raw, bool shared);

		[GLib.Property ("shared")]
		public bool Shared {
			get {
				GLib.Value val = GetProperty ("shared");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set  {
				gst_rtsp_media_set_shared(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_stop_on_disconnect(IntPtr raw, bool stop_on_disconnect);

		[GLib.Property ("stop-on-disconnect")]
		public bool StopOnDisconnect {
			get {
				GLib.Value val = GetProperty ("stop-on-disconnect");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set  {
				gst_rtsp_media_set_stop_on_disconnect(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_media_get_suspend_mode(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_suspend_mode(IntPtr raw, int mode);

		[GLib.Property ("suspend-mode")]
		public Gst.RtspServer.RTSPSuspendMode SuspendMode {
			get  {
				int raw_ret = gst_rtsp_media_get_suspend_mode(Handle);
				Gst.RtspServer.RTSPSuspendMode ret = (Gst.RtspServer.RTSPSuspendMode) raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_suspend_mode(Handle, (int) value);
			}
		}

		[GLib.Property ("time-provider")]
		public bool TimeProvider {
			get {
				GLib.Value val = GetProperty ("time-provider");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("time-provider", val);
				val.Dispose ();
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_media_get_transport_mode(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_transport_mode(IntPtr raw, int mode);

		[GLib.Property ("transport-mode")]
		public Gst.RtspServer.RTSPTransportMode TransportMode {
			get  {
				int raw_ret = gst_rtsp_media_get_transport_mode(Handle);
				Gst.RtspServer.RTSPTransportMode ret = (Gst.RtspServer.RTSPTransportMode) raw_ret;
				return ret;
			}
			set  {
				gst_rtsp_media_set_transport_mode(Handle, (int) value);
			}
		}

		[GLib.Signal("new-state")]
		public event Gst.RtspServer.NewStateHandler NewState {
			add {
				this.AddSignalHandler ("new-state", value, typeof (Gst.RtspServer.NewStateArgs));
			}
			remove {
				this.RemoveSignalHandler ("new-state", value);
			}
		}

		[GLib.Signal("unprepared")]
		public event System.EventHandler Unprepared {
			add {
				this.AddSignalHandler ("unprepared", value);
			}
			remove {
				this.RemoveSignalHandler ("unprepared", value);
			}
		}

		[GLib.Signal("removed-stream")]
		public event Gst.RtspServer.RemovedStreamHandler RemovedStream {
			add {
				this.AddSignalHandler ("removed-stream", value, typeof (Gst.RtspServer.RemovedStreamArgs));
			}
			remove {
				this.RemoveSignalHandler ("removed-stream", value);
			}
		}

		[GLib.Signal("new-stream")]
		public event Gst.RtspServer.NewStreamHandler NewStream {
			add {
				this.AddSignalHandler ("new-stream", value, typeof (Gst.RtspServer.NewStreamArgs));
			}
			remove {
				this.RemoveSignalHandler ("new-stream", value);
			}
		}

		[GLib.Signal("prepared")]
		public event System.EventHandler Prepared {
			add {
				this.AddSignalHandler ("prepared", value);
			}
			remove {
				this.RemoveSignalHandler ("prepared", value);
			}
		}

		[GLib.Signal("handle-message")]
		public event Gst.RtspServer.HandleMessageHandler HandleMessage {
			add {
				this.AddSignalHandler ("handle-message", value, typeof (Gst.RtspServer.HandleMessageArgs));
			}
			remove {
				this.RemoveSignalHandler ("handle-message", value);
			}
		}

		[GLib.Signal("target-state")]
		public event Gst.RtspServer.TargetStateHandler TargetState {
			add {
				this.AddSignalHandler ("target-state", value, typeof (Gst.RtspServer.TargetStateArgs));
			}
			remove {
				this.RemoveSignalHandler ("target-state", value);
			}
		}

		static HandleMessageNativeDelegate HandleMessage_cb_delegate;
		static HandleMessageNativeDelegate HandleMessageVMCallback {
			get {
				if (HandleMessage_cb_delegate == null)
					HandleMessage_cb_delegate = new HandleMessageNativeDelegate (HandleMessage_cb);
				return HandleMessage_cb_delegate;
			}
		}

		static void OverrideHandleMessage (GLib.GType gtype)
		{
			OverrideHandleMessage (gtype, HandleMessageVMCallback);
		}

		static void OverrideHandleMessage (GLib.GType gtype, HandleMessageNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_message"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool HandleMessageNativeDelegate (IntPtr inst, IntPtr message);

		static bool HandleMessage_cb (IntPtr inst, IntPtr message)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnHandleMessage (message == IntPtr.Zero ? null : (Gst.Message) GLib.Opaque.GetOpaque (message, typeof (Gst.Message), false));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideHandleMessage")]
		protected virtual bool OnHandleMessage (Gst.Message message)
		{
			return InternalHandleMessage (message);
		}

		private bool InternalHandleMessage (Gst.Message message)
		{
			HandleMessageNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_message"));
				unmanaged = (HandleMessageNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(HandleMessageNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, message == null ? IntPtr.Zero : message.Handle);
			return __result;
		}

		static PrepareNativeDelegate Prepare_cb_delegate;
		static PrepareNativeDelegate PrepareVMCallback {
			get {
				if (Prepare_cb_delegate == null)
					Prepare_cb_delegate = new PrepareNativeDelegate (Prepare_cb);
				return Prepare_cb_delegate;
			}
		}

		static void OverridePrepare (GLib.GType gtype)
		{
			OverridePrepare (gtype, PrepareVMCallback);
		}

		static void OverridePrepare (GLib.GType gtype, PrepareNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool PrepareNativeDelegate (IntPtr inst, IntPtr thread);

		static bool Prepare_cb (IntPtr inst, IntPtr thread)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnPrepare (thread == IntPtr.Zero ? null : (Gst.RtspServer.RTSPThread) GLib.Opaque.GetOpaque (thread, typeof (Gst.RtspServer.RTSPThread), true));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverridePrepare")]
		protected virtual bool OnPrepare (Gst.RtspServer.RTSPThread thread)
		{
			return InternalPrepare (thread);
		}

		private bool InternalPrepare (Gst.RtspServer.RTSPThread thread)
		{
			PrepareNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare"));
				unmanaged = (PrepareNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrepareNativeDelegate));
			}
			if (unmanaged == null) return false;

			thread.Owned = false;
			bool __result = unmanaged (this.Handle, thread == null ? IntPtr.Zero : thread.Handle);
			return __result;
		}

		static UnprepareNativeDelegate Unprepare_cb_delegate;
		static UnprepareNativeDelegate UnprepareVMCallback {
			get {
				if (Unprepare_cb_delegate == null)
					Unprepare_cb_delegate = new UnprepareNativeDelegate (Unprepare_cb);
				return Unprepare_cb_delegate;
			}
		}

		static void OverrideUnprepare (GLib.GType gtype)
		{
			OverrideUnprepare (gtype, UnprepareVMCallback);
		}

		static void OverrideUnprepare (GLib.GType gtype, UnprepareNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepare"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool UnprepareNativeDelegate (IntPtr inst);

		static bool Unprepare_cb (IntPtr inst)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnUnprepare ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideUnprepare")]
		protected virtual bool OnUnprepare ()
		{
			return InternalUnprepare ();
		}

		private bool InternalUnprepare ()
		{
			UnprepareNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepare"));
				unmanaged = (UnprepareNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnprepareNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}

		static SuspendNativeDelegate Suspend_cb_delegate;
		static SuspendNativeDelegate SuspendVMCallback {
			get {
				if (Suspend_cb_delegate == null)
					Suspend_cb_delegate = new SuspendNativeDelegate (Suspend_cb);
				return Suspend_cb_delegate;
			}
		}

		static void OverrideSuspend (GLib.GType gtype)
		{
			OverrideSuspend (gtype, SuspendVMCallback);
		}

		static void OverrideSuspend (GLib.GType gtype, SuspendNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("suspend"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SuspendNativeDelegate (IntPtr inst);

		static bool Suspend_cb (IntPtr inst)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnSuspend ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideSuspend")]
		protected virtual bool OnSuspend ()
		{
			return InternalSuspend ();
		}

		private bool InternalSuspend ()
		{
			SuspendNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("suspend"));
				unmanaged = (SuspendNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SuspendNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}

		static UnsuspendNativeDelegate Unsuspend_cb_delegate;
		static UnsuspendNativeDelegate UnsuspendVMCallback {
			get {
				if (Unsuspend_cb_delegate == null)
					Unsuspend_cb_delegate = new UnsuspendNativeDelegate (Unsuspend_cb);
				return Unsuspend_cb_delegate;
			}
		}

		static void OverrideUnsuspend (GLib.GType gtype)
		{
			OverrideUnsuspend (gtype, UnsuspendVMCallback);
		}

		static void OverrideUnsuspend (GLib.GType gtype, UnsuspendNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("unsuspend"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool UnsuspendNativeDelegate (IntPtr inst);

		static bool Unsuspend_cb (IntPtr inst)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnUnsuspend ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideUnsuspend")]
		protected virtual bool OnUnsuspend ()
		{
			return InternalUnsuspend ();
		}

		private bool InternalUnsuspend ()
		{
			UnsuspendNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unsuspend"));
				unmanaged = (UnsuspendNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnsuspendNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}

		static ConvertRangeNativeDelegate ConvertRange_cb_delegate;
		static ConvertRangeNativeDelegate ConvertRangeVMCallback {
			get {
				if (ConvertRange_cb_delegate == null)
					ConvertRange_cb_delegate = new ConvertRangeNativeDelegate (ConvertRange_cb);
				return ConvertRange_cb_delegate;
			}
		}

		static void OverrideConvertRange (GLib.GType gtype)
		{
			OverrideConvertRange (gtype, ConvertRangeVMCallback);
		}

		static void OverrideConvertRange (GLib.GType gtype, ConvertRangeNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("convert_range"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ConvertRangeNativeDelegate (IntPtr inst, IntPtr range, int unit);

		static bool ConvertRange_cb (IntPtr inst, IntPtr range, int unit)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnConvertRange (Gst.Rtsp.RTSPTimeRange.New (range), (Gst.Rtsp.RTSPRangeUnit) unit);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideConvertRange")]
		protected virtual bool OnConvertRange (Gst.Rtsp.RTSPTimeRange range, Gst.Rtsp.RTSPRangeUnit unit)
		{
			return InternalConvertRange (range, unit);
		}

		private bool InternalConvertRange (Gst.Rtsp.RTSPTimeRange range, Gst.Rtsp.RTSPRangeUnit unit)
		{
			ConvertRangeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("convert_range"));
				unmanaged = (ConvertRangeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ConvertRangeNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
			bool __result = unmanaged (this.Handle, native_range, (int) unit);
			Marshal.FreeHGlobal (native_range);
			return __result;
		}

		static QueryPositionNativeDelegate QueryPosition_cb_delegate;
		static QueryPositionNativeDelegate QueryPositionVMCallback {
			get {
				if (QueryPosition_cb_delegate == null)
					QueryPosition_cb_delegate = new QueryPositionNativeDelegate (QueryPosition_cb);
				return QueryPosition_cb_delegate;
			}
		}

		static void OverrideQueryPosition (GLib.GType gtype)
		{
			OverrideQueryPosition (gtype, QueryPositionVMCallback);
		}

		static void OverrideQueryPosition (GLib.GType gtype, QueryPositionNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_position"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool QueryPositionNativeDelegate (IntPtr inst, long position);

		static bool QueryPosition_cb (IntPtr inst, long position)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnQueryPosition (position);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideQueryPosition")]
		protected virtual bool OnQueryPosition (long position)
		{
			return InternalQueryPosition (position);
		}

		private bool InternalQueryPosition (long position)
		{
			QueryPositionNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query_position"));
				unmanaged = (QueryPositionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryPositionNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, position);
			return __result;
		}

		static QueryStopNativeDelegate QueryStop_cb_delegate;
		static QueryStopNativeDelegate QueryStopVMCallback {
			get {
				if (QueryStop_cb_delegate == null)
					QueryStop_cb_delegate = new QueryStopNativeDelegate (QueryStop_cb);
				return QueryStop_cb_delegate;
			}
		}

		static void OverrideQueryStop (GLib.GType gtype)
		{
			OverrideQueryStop (gtype, QueryStopVMCallback);
		}

		static void OverrideQueryStop (GLib.GType gtype, QueryStopNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_stop"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool QueryStopNativeDelegate (IntPtr inst, long stop);

		static bool QueryStop_cb (IntPtr inst, long stop)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnQueryStop (stop);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideQueryStop")]
		protected virtual bool OnQueryStop (long stop)
		{
			return InternalQueryStop (stop);
		}

		private bool InternalQueryStop (long stop)
		{
			QueryStopNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query_stop"));
				unmanaged = (QueryStopNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryStopNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, stop);
			return __result;
		}

		static SetupRtpbinNativeDelegate SetupRtpbin_cb_delegate;
		static SetupRtpbinNativeDelegate SetupRtpbinVMCallback {
			get {
				if (SetupRtpbin_cb_delegate == null)
					SetupRtpbin_cb_delegate = new SetupRtpbinNativeDelegate (SetupRtpbin_cb);
				return SetupRtpbin_cb_delegate;
			}
		}

		static void OverrideSetupRtpbin (GLib.GType gtype)
		{
			OverrideSetupRtpbin (gtype, SetupRtpbinVMCallback);
		}

		static void OverrideSetupRtpbin (GLib.GType gtype, SetupRtpbinNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_rtpbin"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetupRtpbinNativeDelegate (IntPtr inst, IntPtr rtpbin);

		static bool SetupRtpbin_cb (IntPtr inst, IntPtr rtpbin)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnSetupRtpbin (GLib.Object.GetObject(rtpbin) as Gst.Element);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideSetupRtpbin")]
		protected virtual bool OnSetupRtpbin (Gst.Element rtpbin)
		{
			return InternalSetupRtpbin (rtpbin);
		}

		private bool InternalSetupRtpbin (Gst.Element rtpbin)
		{
			SetupRtpbinNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_rtpbin"));
				unmanaged = (SetupRtpbinNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetupRtpbinNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, rtpbin == null ? IntPtr.Zero : rtpbin.Handle);
			return __result;
		}

		static SetupSdpNativeDelegate SetupSdp_cb_delegate;
		static SetupSdpNativeDelegate SetupSdpVMCallback {
			get {
				if (SetupSdp_cb_delegate == null)
					SetupSdp_cb_delegate = new SetupSdpNativeDelegate (SetupSdp_cb);
				return SetupSdp_cb_delegate;
			}
		}

		static void OverrideSetupSdp (GLib.GType gtype)
		{
			OverrideSetupSdp (gtype, SetupSdpVMCallback);
		}

		static void OverrideSetupSdp (GLib.GType gtype, SetupSdpNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_sdp"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetupSdpNativeDelegate (IntPtr inst, IntPtr sdp, IntPtr info);

		static bool SetupSdp_cb (IntPtr inst, IntPtr sdp, IntPtr info)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnSetupSdp (sdp == IntPtr.Zero ? null : (Gst.Sdp.SDPMessage) GLib.Opaque.GetOpaque (sdp, typeof (Gst.Sdp.SDPMessage), false), Gst.RtspServer.SDPInfo.New (info));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideSetupSdp")]
		protected virtual bool OnSetupSdp (Gst.Sdp.SDPMessage sdp, Gst.RtspServer.SDPInfo info)
		{
			return InternalSetupSdp (sdp, info);
		}

		private bool InternalSetupSdp (Gst.Sdp.SDPMessage sdp, Gst.RtspServer.SDPInfo info)
		{
			SetupSdpNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("setup_sdp"));
				unmanaged = (SetupSdpNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetupSdpNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_info = GLib.Marshaller.StructureToPtrAlloc (info);
			bool __result = unmanaged (this.Handle, sdp == null ? IntPtr.Zero : sdp.Handle, native_info);
			Marshal.FreeHGlobal (native_info);
			return __result;
		}

		static NewStreamNativeDelegate NewStream_cb_delegate;
		static NewStreamNativeDelegate NewStreamVMCallback {
			get {
				if (NewStream_cb_delegate == null)
					NewStream_cb_delegate = new NewStreamNativeDelegate (NewStream_cb);
				return NewStream_cb_delegate;
			}
		}

		static void OverrideNewStream (GLib.GType gtype)
		{
			OverrideNewStream (gtype, NewStreamVMCallback);
		}

		static void OverrideNewStream (GLib.GType gtype, NewStreamNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("new_stream"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void NewStreamNativeDelegate (IntPtr inst, IntPtr _object);

		static void NewStream_cb (IntPtr inst, IntPtr _object)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				__obj.OnNewStream (GLib.Object.GetObject(_object) as Gst.RtspServer.RTSPStream);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideNewStream")]
		protected virtual void OnNewStream (Gst.RtspServer.RTSPStream _object)
		{
			InternalNewStream (_object);
		}

		private void InternalNewStream (Gst.RtspServer.RTSPStream _object)
		{
			NewStreamNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("new_stream"));
				unmanaged = (NewStreamNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NewStreamNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, _object == null ? IntPtr.Zero : _object.Handle);
		}

		static RemovedStreamNativeDelegate RemovedStream_cb_delegate;
		static RemovedStreamNativeDelegate RemovedStreamVMCallback {
			get {
				if (RemovedStream_cb_delegate == null)
					RemovedStream_cb_delegate = new RemovedStreamNativeDelegate (RemovedStream_cb);
				return RemovedStream_cb_delegate;
			}
		}

		static void OverrideRemovedStream (GLib.GType gtype)
		{
			OverrideRemovedStream (gtype, RemovedStreamVMCallback);
		}

		static void OverrideRemovedStream (GLib.GType gtype, RemovedStreamNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("removed_stream"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RemovedStreamNativeDelegate (IntPtr inst, IntPtr _object);

		static void RemovedStream_cb (IntPtr inst, IntPtr _object)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				__obj.OnRemovedStream (GLib.Object.GetObject(_object) as Gst.RtspServer.RTSPStream);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideRemovedStream")]
		protected virtual void OnRemovedStream (Gst.RtspServer.RTSPStream _object)
		{
			InternalRemovedStream (_object);
		}

		private void InternalRemovedStream (Gst.RtspServer.RTSPStream _object)
		{
			RemovedStreamNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("removed_stream"));
				unmanaged = (RemovedStreamNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RemovedStreamNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, _object == null ? IntPtr.Zero : _object.Handle);
		}

		static PreparedNativeDelegate Prepared_cb_delegate;
		static PreparedNativeDelegate PreparedVMCallback {
			get {
				if (Prepared_cb_delegate == null)
					Prepared_cb_delegate = new PreparedNativeDelegate (Prepared_cb);
				return Prepared_cb_delegate;
			}
		}

		static void OverridePrepared (GLib.GType gtype)
		{
			OverridePrepared (gtype, PreparedVMCallback);
		}

		static void OverridePrepared (GLib.GType gtype, PreparedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("prepared"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PreparedNativeDelegate (IntPtr inst);

		static void Prepared_cb (IntPtr inst)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				__obj.OnPrepared ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverridePrepared")]
		protected virtual void OnPrepared ()
		{
			InternalPrepared ();
		}

		private void InternalPrepared ()
		{
			PreparedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("prepared"));
				unmanaged = (PreparedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PreparedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static UnpreparedNativeDelegate Unprepared_cb_delegate;
		static UnpreparedNativeDelegate UnpreparedVMCallback {
			get {
				if (Unprepared_cb_delegate == null)
					Unprepared_cb_delegate = new UnpreparedNativeDelegate (Unprepared_cb);
				return Unprepared_cb_delegate;
			}
		}

		static void OverrideUnprepared (GLib.GType gtype)
		{
			OverrideUnprepared (gtype, UnpreparedVMCallback);
		}

		static void OverrideUnprepared (GLib.GType gtype, UnpreparedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepared"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void UnpreparedNativeDelegate (IntPtr inst);

		static void Unprepared_cb (IntPtr inst)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				__obj.OnUnprepared ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideUnprepared")]
		protected virtual void OnUnprepared ()
		{
			InternalUnprepared ();
		}

		private void InternalUnprepared ()
		{
			UnpreparedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unprepared"));
				unmanaged = (UnpreparedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnpreparedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static TargetStateNativeDelegate TargetState_cb_delegate;
		static TargetStateNativeDelegate TargetStateVMCallback {
			get {
				if (TargetState_cb_delegate == null)
					TargetState_cb_delegate = new TargetStateNativeDelegate (TargetState_cb);
				return TargetState_cb_delegate;
			}
		}

		static void OverrideTargetState (GLib.GType gtype)
		{
			OverrideTargetState (gtype, TargetStateVMCallback);
		}

		static void OverrideTargetState (GLib.GType gtype, TargetStateNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("target_state"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TargetStateNativeDelegate (IntPtr inst, int _object);

		static void TargetState_cb (IntPtr inst, int _object)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				__obj.OnTargetState (_object);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideTargetState")]
		protected virtual void OnTargetState (int _object)
		{
			InternalTargetState (_object);
		}

		private void InternalTargetState (int _object)
		{
			TargetStateNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("target_state"));
				unmanaged = (TargetStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TargetStateNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, _object);
		}

		static NewStateNativeDelegate NewState_cb_delegate;
		static NewStateNativeDelegate NewStateVMCallback {
			get {
				if (NewState_cb_delegate == null)
					NewState_cb_delegate = new NewStateNativeDelegate (NewState_cb);
				return NewState_cb_delegate;
			}
		}

		static void OverrideNewState (GLib.GType gtype)
		{
			OverrideNewState (gtype, NewStateVMCallback);
		}

		static void OverrideNewState (GLib.GType gtype, NewStateNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("new_state"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void NewStateNativeDelegate (IntPtr inst, int _object);

		static void NewState_cb (IntPtr inst, int _object)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				__obj.OnNewState (_object);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideNewState")]
		protected virtual void OnNewState (int _object)
		{
			InternalNewState (_object);
		}

		private void InternalNewState (int _object)
		{
			NewStateNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("new_state"));
				unmanaged = (NewStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NewStateNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, _object);
		}

		static HandleSdpNativeDelegate HandleSdp_cb_delegate;
		static HandleSdpNativeDelegate HandleSdpVMCallback {
			get {
				if (HandleSdp_cb_delegate == null)
					HandleSdp_cb_delegate = new HandleSdpNativeDelegate (HandleSdp_cb);
				return HandleSdp_cb_delegate;
			}
		}

		static void OverrideHandleSdp (GLib.GType gtype)
		{
			OverrideHandleSdp (gtype, HandleSdpVMCallback);
		}

		static void OverrideHandleSdp (GLib.GType gtype, HandleSdpNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_sdp"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool HandleSdpNativeDelegate (IntPtr inst, IntPtr sdp);

		static bool HandleSdp_cb (IntPtr inst, IntPtr sdp)
		{
			try {
				RTSPMedia __obj = GLib.Object.GetObject (inst, false) as RTSPMedia;
				bool __result;
				__result = __obj.OnHandleSdp (sdp == IntPtr.Zero ? null : (Gst.Sdp.SDPMessage) GLib.Opaque.GetOpaque (sdp, typeof (Gst.Sdp.SDPMessage), false));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPMedia), ConnectionMethod="OverrideHandleSdp")]
		protected virtual bool OnHandleSdp (Gst.Sdp.SDPMessage sdp)
		{
			return InternalHandleSdp (sdp);
		}

		private bool InternalHandleSdp (Gst.Sdp.SDPMessage sdp)
		{
			HandleSdpNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("handle_sdp"));
				unmanaged = (HandleSdpNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(HandleSdpNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, sdp == null ? IntPtr.Zero : sdp.Handle);
			return __result;
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("handle_message"
							, GLib.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_message
							, null
							, "prepare"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("prepare"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // prepare
							, "handle_message"
							, "unprepare"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unprepare"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unprepare
							, "prepare"
							, "suspend"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("suspend"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // suspend
							, "unprepare"
							, "unsuspend"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unsuspend"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unsuspend
							, "suspend"
							, "convert_range"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("convert_range"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // convert_range
							, "unsuspend"
							, "query_position"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("query_position"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // query_position
							, "convert_range"
							, "query_stop"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("query_stop"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // query_stop
							, "query_position"
							, "create_rtpbin"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("create_rtpbin"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // create_rtpbin
							, "query_stop"
							, "setup_rtpbin"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("setup_rtpbin"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // setup_rtpbin
							, "create_rtpbin"
							, "setup_sdp"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("setup_sdp"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // setup_sdp
							, "setup_rtpbin"
							, "new_stream"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("new_stream"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // new_stream
							, "setup_sdp"
							, "removed_stream"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("removed_stream"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // removed_stream
							, "new_stream"
							, "prepared"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("prepared"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // prepared
							, "removed_stream"
							, "unprepared"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unprepared"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unprepared
							, "prepared"
							, "target_state"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("target_state"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // target_state
							, "unprepared"
							, "new_state"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("new_state"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // new_state
							, "target_state"
							, "handle_sdp"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("handle_sdp"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // handle_sdp
							, "new_state"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 19 // _gst_reserved
							, "handle_sdp"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_type();

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = gst_rtsp_media_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_can_be_shared(IntPtr raw);

		public bool CanBeShared() {
			bool raw_ret = gst_rtsp_media_can_be_shared(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_collect_streams(IntPtr raw);

		public void CollectStreams() {
			gst_rtsp_media_collect_streams(Handle);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_complete_pipeline(IntPtr raw, IntPtr[] transports);

		public bool CompletePipeline(GLib.PtrArray[] transports) {
			int cnt_transports = transports == null ? 0 : transports.Length;
			IntPtr[] native_transports = new IntPtr [cnt_transports + 1];
			for (int i = 0; i < cnt_transports; i++)
				native_transports [i] = transports[i] == null ? IntPtr.Zero : transports[i].Handle;
			native_transports [cnt_transports] = IntPtr.Zero;
			bool raw_ret = gst_rtsp_media_complete_pipeline(Handle, native_transports);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_create_stream(IntPtr raw, IntPtr payloader, IntPtr pad);

		public Gst.RtspServer.RTSPStream CreateStream(Gst.Element payloader, Gst.Pad pad) {
			IntPtr raw_ret = gst_rtsp_media_create_stream(Handle, payloader == null ? IntPtr.Zero : payloader.Handle, pad == null ? IntPtr.Zero : pad.Handle);
			Gst.RtspServer.RTSPStream ret = GLib.Object.GetObject(raw_ret) as Gst.RtspServer.RTSPStream;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_find_stream(IntPtr raw, IntPtr control);

		public Gst.RtspServer.RTSPStream FindStream(string control) {
			IntPtr native_control = GLib.Marshaller.StringToPtrGStrdup (control);
			IntPtr raw_ret = gst_rtsp_media_find_stream(Handle, native_control);
			Gst.RtspServer.RTSPStream ret = GLib.Object.GetObject(raw_ret) as Gst.RtspServer.RTSPStream;
			GLib.Marshaller.Free (native_control);
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_address_pool(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_address_pool(IntPtr raw, IntPtr pool);

		public Gst.RtspServer.RTSPAddressPool AddressPool { 
			get {
				IntPtr raw_ret = gst_rtsp_media_get_address_pool(Handle);
				Gst.RtspServer.RTSPAddressPool ret = GLib.Object.GetObject(raw_ret, true) as Gst.RtspServer.RTSPAddressPool;
				return ret;
			}
			set {
				gst_rtsp_media_set_address_pool(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern ulong gst_rtsp_media_get_base_time(IntPtr raw);

		public ulong BaseTime { 
			get {
				ulong raw_ret = gst_rtsp_media_get_base_time(Handle);
				ulong ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_get_do_retransmission(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_do_retransmission(IntPtr raw, bool do_retransmission);

		public bool DoRetransmission { 
			get {
				bool raw_ret = gst_rtsp_media_get_do_retransmission(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_media_set_do_retransmission(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_multicast_iface(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_multicast_iface(IntPtr raw, IntPtr multicast_iface);

		public string MulticastIface { 
			get {
				IntPtr raw_ret = gst_rtsp_media_get_multicast_iface(Handle);
				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
				return ret;
			}
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gst_rtsp_media_set_multicast_iface(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_permissions(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_permissions(IntPtr raw, IntPtr permissions);

		public Gst.RtspServer.RTSPPermissions Permissions { 
			get {
				IntPtr raw_ret = gst_rtsp_media_get_permissions(Handle);
				Gst.RtspServer.RTSPPermissions ret = raw_ret == IntPtr.Zero ? null : (Gst.RtspServer.RTSPPermissions) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.RtspServer.RTSPPermissions), true);
				return ret;
			}
			set {
				gst_rtsp_media_set_permissions(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_media_get_publish_clock_mode(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_publish_clock_mode(IntPtr raw, int mode);

		public Gst.RtspServer.RTSPPublishClockMode PublishClockMode { 
			get {
				int raw_ret = gst_rtsp_media_get_publish_clock_mode(Handle);
				Gst.RtspServer.RTSPPublishClockMode ret = (Gst.RtspServer.RTSPPublishClockMode) raw_ret;
				return ret;
			}
			set {
				gst_rtsp_media_set_publish_clock_mode(Handle, (int) value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_range_string(IntPtr raw, bool play, int unit);

		public string GetRangeString(bool play, Gst.Rtsp.RTSPRangeUnit unit) {
			IntPtr raw_ret = gst_rtsp_media_get_range_string(Handle, play, (int) unit);
			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_get_rate_control(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_rate_control(IntPtr raw, bool enabled);

		public bool RateControl { 
			get {
				bool raw_ret = gst_rtsp_media_get_rate_control(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_media_set_rate_control(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_get_rates(IntPtr raw, out double rate, out double applied_rate);

		public bool GetRates(out double rate, out double applied_rate) {
			bool raw_ret = gst_rtsp_media_get_rates(Handle, out rate, out applied_rate);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern ulong gst_rtsp_media_get_retransmission_time(IntPtr raw);

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_retransmission_time(IntPtr raw, ulong time);

		public ulong RetransmissionTime { 
			get {
				ulong raw_ret = gst_rtsp_media_get_retransmission_time(Handle);
				ulong ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_media_set_retransmission_time(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_rtsp_media_get_status(IntPtr raw);

		public Gst.RtspServer.RTSPMediaStatus Status { 
			get {
				int raw_ret = gst_rtsp_media_get_status(Handle);
				Gst.RtspServer.RTSPMediaStatus ret = (Gst.RtspServer.RTSPMediaStatus) raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_stream(IntPtr raw, uint idx);

		public Gst.RtspServer.RTSPStream GetStream(uint idx) {
			IntPtr raw_ret = gst_rtsp_media_get_stream(Handle, idx);
			Gst.RtspServer.RTSPStream ret = GLib.Object.GetObject(raw_ret) as Gst.RtspServer.RTSPStream;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_media_get_time_provider(IntPtr raw, IntPtr address, ushort port);

		public Gst.Net.NetTimeProvider GetTimeProvider(string address, ushort port) {
			IntPtr native_address = GLib.Marshaller.StringToPtrGStrdup (address);
			IntPtr raw_ret = gst_rtsp_media_get_time_provider(Handle, native_address, port);
			Gst.Net.NetTimeProvider ret = GLib.Object.GetObject(raw_ret, true) as Gst.Net.NetTimeProvider;
			GLib.Marshaller.Free (native_address);
			return ret;
		}

		public Gst.Net.NetTimeProvider GetTimeProvider(ushort port) {
			return GetTimeProvider (null, port);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_handle_sdp(IntPtr raw, IntPtr sdp);

		public bool HandleSdp(Gst.Sdp.SDPMessage sdp) {
			bool raw_ret = gst_rtsp_media_handle_sdp(Handle, sdp == null ? IntPtr.Zero : sdp.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_has_completed_sender(IntPtr raw);

		public bool HasCompletedSender { 
			get {
				bool raw_ret = gst_rtsp_media_has_completed_sender(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_is_bind_mcast_address(IntPtr raw);

		public bool IsBindMcastAddress { 
			get {
				bool raw_ret = gst_rtsp_media_is_bind_mcast_address(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_is_eos_shutdown(IntPtr raw);

		public bool IsEosShutdown { 
			get {
				bool raw_ret = gst_rtsp_media_is_eos_shutdown(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_is_receive_only(IntPtr raw);

		public bool IsReceiveOnly { 
			get {
				bool raw_ret = gst_rtsp_media_is_receive_only(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_is_reusable(IntPtr raw);

		public bool IsReusable { 
			get {
				bool raw_ret = gst_rtsp_media_is_reusable(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_is_shared(IntPtr raw);

		public bool IsShared { 
			get {
				bool raw_ret = gst_rtsp_media_is_shared(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_is_stop_on_disconnect(IntPtr raw);

		public bool IsStopOnDisconnect { 
			get {
				bool raw_ret = gst_rtsp_media_is_stop_on_disconnect(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_is_time_provider(IntPtr raw);

		public bool IsTimeProvider { 
			get {
				bool raw_ret = gst_rtsp_media_is_time_provider(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_lock(IntPtr raw);

		public void Lock() {
			gst_rtsp_media_lock(Handle);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern uint gst_rtsp_media_n_streams(IntPtr raw);

		public uint NStreams() {
			uint raw_ret = gst_rtsp_media_n_streams(Handle);
			uint ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_prepare(IntPtr raw, IntPtr thread);

		public bool Prepare(Gst.RtspServer.RTSPThread thread) {
			thread.Owned = false;
			bool raw_ret = gst_rtsp_media_prepare(Handle, thread == null ? IntPtr.Zero : thread.Handle);
			bool ret = raw_ret;
			return ret;
		}

		public bool Prepare() {
			return Prepare (null);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_seek(IntPtr raw, IntPtr range);

		public bool Seek(Gst.Rtsp.RTSPTimeRange range) {
			IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
			bool raw_ret = gst_rtsp_media_seek(Handle, native_range);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_range);
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_seek_full(IntPtr raw, IntPtr range, int flags);

		public bool SeekFull(Gst.Rtsp.RTSPTimeRange range, Gst.SeekFlags flags) {
			IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
			bool raw_ret = gst_rtsp_media_seek_full(Handle, native_range, (int) flags);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_range);
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_seek_trickmode(IntPtr raw, IntPtr range, int flags, double rate, ulong trickmode_interval);

		public bool SeekTrickmode(Gst.Rtsp.RTSPTimeRange range, Gst.SeekFlags flags, double rate, ulong trickmode_interval) {
			IntPtr native_range = GLib.Marshaller.StructureToPtrAlloc (range);
			bool raw_ret = gst_rtsp_media_seek_trickmode(Handle, native_range, (int) flags, rate, trickmode_interval);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_range);
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern long gst_rtsp_media_seekable(IntPtr raw);

		public long Seekable() {
			long raw_ret = gst_rtsp_media_seekable(Handle);
			long ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_set_max_mcast_ttl(IntPtr raw, uint ttl);

		public bool SetMaxMcastTtl(uint ttl) {
			bool raw_ret = gst_rtsp_media_set_max_mcast_ttl(Handle, ttl);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_set_pipeline_state(IntPtr raw, int state);

		public Gst.State PipelineState { 
			set {
				gst_rtsp_media_set_pipeline_state(Handle, (int) value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_set_state(IntPtr raw, int state, IntPtr[] transports);

		public bool SetState(Gst.State state, GLib.PtrArray[] transports) {
			int cnt_transports = transports == null ? 0 : transports.Length;
			IntPtr[] native_transports = new IntPtr [cnt_transports + 1];
			for (int i = 0; i < cnt_transports; i++)
				native_transports [i] = transports[i] == null ? IntPtr.Zero : transports[i].Handle;
			native_transports [cnt_transports] = IntPtr.Zero;
			bool raw_ret = gst_rtsp_media_set_state(Handle, (int) state, native_transports);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_setup_sdp(IntPtr raw, IntPtr sdp, IntPtr info);

		public bool SetupSdp(Gst.Sdp.SDPMessage sdp, Gst.RtspServer.SDPInfo info) {
			IntPtr native_info = GLib.Marshaller.StructureToPtrAlloc (info);
			bool raw_ret = gst_rtsp_media_setup_sdp(Handle, sdp == null ? IntPtr.Zero : sdp.Handle, native_info);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_info);
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_suspend(IntPtr raw);

		public bool Suspend() {
			bool raw_ret = gst_rtsp_media_suspend(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_take_pipeline(IntPtr raw, IntPtr pipeline);

		public void TakePipeline(Gst.Pipeline pipeline) {
			gst_rtsp_media_take_pipeline(Handle, pipeline == null ? IntPtr.Zero : pipeline.Handle);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_unlock(IntPtr raw);

		public void Unlock() {
			gst_rtsp_media_unlock(Handle);
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_unprepare(IntPtr raw);

		public bool Unprepare() {
			bool raw_ret = gst_rtsp_media_unprepare(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_media_unsuspend(IntPtr raw);

		public bool Unsuspend() {
			bool raw_ret = gst_rtsp_media_unsuspend(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtsp_media_use_time_provider(IntPtr raw, bool time_provider);

		public void UseTimeProvider(bool time_provider) {
			gst_rtsp_media_use_time_provider(Handle, time_provider);
		}


		static RTSPMedia ()
		{
			GtkSharp.GstreamerSharp.ObjectManager.Initialize ();
		}

		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("priv"
							, GLib.Object.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
							, null
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
							, "priv"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}