// 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 RTSPStream : GLib.Object {

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

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

		public RTSPStream (uint idx, Gst.Element payloader, Gst.Pad pad) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (RTSPStream)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = gst_rtsp_stream_new(idx, payloader == null ? IntPtr.Zero : payloader.Handle, pad == null ? IntPtr.Zero : pad.Handle);
		}

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

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

		[GLib.Property ("control")]
		public string Control {
			get  {
				IntPtr raw_ret = gst_rtsp_stream_get_control(Handle);
				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gst_rtsp_stream_set_control(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

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

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

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

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

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

		[GLib.Signal("new-rtp-encoder")]
		public event Gst.RtspServer.NewRtpEncoderHandler NewRtpEncoder {
			add {
				this.AddSignalHandler ("new-rtp-encoder", value, typeof (Gst.RtspServer.NewRtpEncoderArgs));
			}
			remove {
				this.RemoveSignalHandler ("new-rtp-encoder", value);
			}
		}

		[GLib.Signal("new-rtcp-encoder")]
		public event Gst.RtspServer.NewRtcpEncoderHandler NewRtcpEncoder {
			add {
				this.AddSignalHandler ("new-rtcp-encoder", value, typeof (Gst.RtspServer.NewRtcpEncoderArgs));
			}
			remove {
				this.RemoveSignalHandler ("new-rtcp-encoder", value);
			}
		}

		[GLib.Signal("new-rtp-rtcp-decoder")]
		public event Gst.RtspServer.NewRtpRtcpDecoderHandler NewRtpRtcpDecoder {
			add {
				this.AddSignalHandler ("new-rtp-rtcp-decoder", value, typeof (Gst.RtspServer.NewRtpRtcpDecoderArgs));
			}
			remove {
				this.RemoveSignalHandler ("new-rtp-rtcp-decoder", value);
			}
		}

		static NewRtcpEncoderNativeDelegate NewRtcpEncoder_cb_delegate;
		static NewRtcpEncoderNativeDelegate NewRtcpEncoderVMCallback {
			get {
				if (NewRtcpEncoder_cb_delegate == null)
					NewRtcpEncoder_cb_delegate = new NewRtcpEncoderNativeDelegate (NewRtcpEncoder_cb);
				return NewRtcpEncoder_cb_delegate;
			}
		}

		static void OverrideNewRtcpEncoder (GLib.GType gtype)
		{
			OverrideNewRtcpEncoder (gtype, NewRtcpEncoderVMCallback);
		}

		static void OverrideNewRtcpEncoder (GLib.GType gtype, NewRtcpEncoderNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "new-rtcp-encoder", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void NewRtcpEncoderNativeDelegate (IntPtr inst, IntPtr _object);

		static void NewRtcpEncoder_cb (IntPtr inst, IntPtr _object)
		{
			try {
				RTSPStream __obj = GLib.Object.GetObject (inst, false) as RTSPStream;
				__obj.OnNewRtcpEncoder (GLib.Object.GetObject(_object) as Gst.Element);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPStream), ConnectionMethod="OverrideNewRtcpEncoder")]
		protected virtual void OnNewRtcpEncoder (Gst.Element _object)
		{
			InternalNewRtcpEncoder (_object);
		}

		private void InternalNewRtcpEncoder (Gst.Element _object)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
			GLib.Value[] vals = new GLib.Value [2];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (_object);
			inst_and_params.Append (vals [1]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static NewRtpEncoderNativeDelegate NewRtpEncoder_cb_delegate;
		static NewRtpEncoderNativeDelegate NewRtpEncoderVMCallback {
			get {
				if (NewRtpEncoder_cb_delegate == null)
					NewRtpEncoder_cb_delegate = new NewRtpEncoderNativeDelegate (NewRtpEncoder_cb);
				return NewRtpEncoder_cb_delegate;
			}
		}

		static void OverrideNewRtpEncoder (GLib.GType gtype)
		{
			OverrideNewRtpEncoder (gtype, NewRtpEncoderVMCallback);
		}

		static void OverrideNewRtpEncoder (GLib.GType gtype, NewRtpEncoderNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "new-rtp-encoder", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void NewRtpEncoderNativeDelegate (IntPtr inst, IntPtr _object);

		static void NewRtpEncoder_cb (IntPtr inst, IntPtr _object)
		{
			try {
				RTSPStream __obj = GLib.Object.GetObject (inst, false) as RTSPStream;
				__obj.OnNewRtpEncoder (GLib.Object.GetObject(_object) as Gst.Element);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPStream), ConnectionMethod="OverrideNewRtpEncoder")]
		protected virtual void OnNewRtpEncoder (Gst.Element _object)
		{
			InternalNewRtpEncoder (_object);
		}

		private void InternalNewRtpEncoder (Gst.Element _object)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
			GLib.Value[] vals = new GLib.Value [2];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (_object);
			inst_and_params.Append (vals [1]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static NewRtpRtcpDecoderNativeDelegate NewRtpRtcpDecoder_cb_delegate;
		static NewRtpRtcpDecoderNativeDelegate NewRtpRtcpDecoderVMCallback {
			get {
				if (NewRtpRtcpDecoder_cb_delegate == null)
					NewRtpRtcpDecoder_cb_delegate = new NewRtpRtcpDecoderNativeDelegate (NewRtpRtcpDecoder_cb);
				return NewRtpRtcpDecoder_cb_delegate;
			}
		}

		static void OverrideNewRtpRtcpDecoder (GLib.GType gtype)
		{
			OverrideNewRtpRtcpDecoder (gtype, NewRtpRtcpDecoderVMCallback);
		}

		static void OverrideNewRtpRtcpDecoder (GLib.GType gtype, NewRtpRtcpDecoderNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "new-rtp-rtcp-decoder", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void NewRtpRtcpDecoderNativeDelegate (IntPtr inst, IntPtr _object);

		static void NewRtpRtcpDecoder_cb (IntPtr inst, IntPtr _object)
		{
			try {
				RTSPStream __obj = GLib.Object.GetObject (inst, false) as RTSPStream;
				__obj.OnNewRtpRtcpDecoder (GLib.Object.GetObject(_object) as Gst.Element);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.RtspServer.RTSPStream), ConnectionMethod="OverrideNewRtpRtcpDecoder")]
		protected virtual void OnNewRtpRtcpDecoder (Gst.Element _object)
		{
			InternalNewRtpRtcpDecoder (_object);
		}

		private void InternalNewRtpRtcpDecoder (Gst.Element _object)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
			GLib.Value[] vals = new GLib.Value [2];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (_object);
			inst_and_params.Append (vals [1]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			foreach (GLib.Value v in vals)
				v.Dispose ();
		}


		// 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("_gst_reserved"
							, GLib.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
							, null
							, 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_stream_get_type();

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = gst_rtsp_stream_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_stream_add_multicast_client_address(IntPtr raw, IntPtr destination, uint rtp_port, uint rtcp_port, int family);

		public bool AddMulticastClientAddress(string destination, uint rtp_port, uint rtcp_port, GLib.SocketFamily family) {
			IntPtr native_destination = GLib.Marshaller.StringToPtrGStrdup (destination);
			bool raw_ret = gst_rtsp_stream_add_multicast_client_address(Handle, native_destination, rtp_port, rtcp_port, (int) family);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_destination);
			return ret;
		}

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

		public bool AddTransport(Gst.RtspServer.RTSPStreamTransport trans) {
			bool raw_ret = gst_rtsp_stream_add_transport(Handle, trans == null ? IntPtr.Zero : trans.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_stream_allocate_udp_sockets(IntPtr raw, int family, IntPtr transport, bool use_client_settings);

		public bool AllocateUdpSockets(GLib.SocketFamily family, Gst.Rtsp.RTSPTransport transport, bool use_client_settings) {
			IntPtr native_transport = GLib.Marshaller.StructureToPtrAlloc (transport);
			bool raw_ret = gst_rtsp_stream_allocate_udp_sockets(Handle, (int) family, native_transport, use_client_settings);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_transport);
			return ret;
		}

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

		public bool CompleteStream(Gst.Rtsp.RTSPTransport transport) {
			IntPtr native_transport = GLib.Marshaller.StructureToPtrAlloc (transport);
			bool raw_ret = gst_rtsp_stream_complete_stream(Handle, native_transport);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_transport);
			return ret;
		}

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

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

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

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

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

		public uint BufferSize { 
			get {
				uint raw_ret = gst_rtsp_stream_get_buffer_size(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_stream_set_buffer_size(Handle, value);
			}
		}

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

		public Gst.Caps Caps { 
			get {
				IntPtr raw_ret = gst_rtsp_stream_get_caps(Handle);
				Gst.Caps ret = raw_ret == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Caps), true);
				return ret;
			}
		}

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

		public ushort CurrentSeqnum { 
			get {
				ushort raw_ret = gst_rtsp_stream_get_current_seqnum(Handle);
				ushort ret = raw_ret;
				return ret;
			}
		}

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

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

		public int DscpQos { 
			get {
				int raw_ret = gst_rtsp_stream_get_dscp_qos(Handle);
				int ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_stream_set_dscp_qos(Handle, value);
			}
		}

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

		public uint Index { 
			get {
				uint raw_ret = gst_rtsp_stream_get_index(Handle);
				uint ret = raw_ret;
				return ret;
			}
		}

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

		public Gst.Bin JoinedBin { 
			get {
				IntPtr raw_ret = gst_rtsp_stream_get_joined_bin(Handle);
				Gst.Bin ret = GLib.Object.GetObject(raw_ret, true) as Gst.Bin;
				return ret;
			}
		}

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

		public uint MaxMcastTtl { 
			get {
				uint raw_ret = gst_rtsp_stream_get_max_mcast_ttl(Handle);
				uint ret = raw_ret;
				return ret;
			}
		}

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

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

		public uint Mtu { 
			get {
				uint raw_ret = gst_rtsp_stream_get_mtu(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_stream_set_mtu(Handle, value);
			}
		}

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

		public Gst.RtspServer.RTSPAddress GetMulticastAddress(GLib.SocketFamily family) {
			IntPtr raw_ret = gst_rtsp_stream_get_multicast_address(Handle, (int) family);
			Gst.RtspServer.RTSPAddress ret = Gst.RtspServer.RTSPAddress.New (raw_ret);
			return ret;
		}

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

		public string MulticastClientAddresses { 
			get {
				IntPtr raw_ret = gst_rtsp_stream_get_multicast_client_addresses(Handle);
				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
				return ret;
			}
		}

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

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

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

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

		public uint Pt { 
			get {
				uint raw_ret = gst_rtsp_stream_get_pt(Handle);
				uint ret = raw_ret;
				return ret;
			}
		}

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

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

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

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

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

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

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_stream_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_stream_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 uint gst_rtsp_stream_get_retransmission_pt(IntPtr raw);

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

		public uint RetransmissionPt { 
			get {
				uint raw_ret = gst_rtsp_stream_get_retransmission_pt(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_stream_set_retransmission_pt(Handle, value);
			}
		}

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

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

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

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

		public GLib.Socket GetRtcpMulticastSocket(GLib.SocketFamily family) {
			IntPtr raw_ret = gst_rtsp_stream_get_rtcp_multicast_socket(Handle, (int) family);
			GLib.Socket ret = raw_ret == IntPtr.Zero ? null : (GLib.Socket) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.Socket), true);
			return ret;
		}

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

		public GLib.Socket GetRtcpSocket(GLib.SocketFamily family) {
			IntPtr raw_ret = gst_rtsp_stream_get_rtcp_socket(Handle, (int) family);
			GLib.Socket ret = raw_ret == IntPtr.Zero ? null : (GLib.Socket) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.Socket), true);
			return ret;
		}

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

		public GLib.Socket GetRtpMulticastSocket(GLib.SocketFamily family) {
			IntPtr raw_ret = gst_rtsp_stream_get_rtp_multicast_socket(Handle, (int) family);
			GLib.Socket ret = raw_ret == IntPtr.Zero ? null : (GLib.Socket) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.Socket), true);
			return ret;
		}

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

		public GLib.Socket GetRtpSocket(GLib.SocketFamily family) {
			IntPtr raw_ret = gst_rtsp_stream_get_rtp_socket(Handle, (int) family);
			GLib.Socket ret = raw_ret == IntPtr.Zero ? null : (GLib.Socket) GLib.Opaque.GetOpaque (raw_ret, typeof (GLib.Socket), true);
			return ret;
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtsp_stream_get_rtpinfo(IntPtr raw, out uint rtptime, out uint seq, out uint clock_rate, out ulong running_time);

		public bool GetRtpinfo(out uint rtptime, out uint seq, out uint clock_rate, out ulong running_time) {
			bool raw_ret = gst_rtsp_stream_get_rtpinfo(Handle, out rtptime, out seq, out clock_rate, out running_time);
			bool ret = raw_ret;
			return ret;
		}

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

		public GLib.Object Rtpsession { 
			get {
				IntPtr raw_ret = gst_rtsp_stream_get_rtpsession(Handle);
				GLib.Object ret = GLib.Object.GetObject (raw_ret);
				return ret;
			}
		}

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

		public Gst.Rtsp.RTSPRange GetServerPort(GLib.SocketFamily family) {
			Gst.Rtsp.RTSPRange server_port;
			IntPtr native_server_port = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (Gst.Rtsp.RTSPRange)));
			gst_rtsp_stream_get_server_port(Handle, native_server_port, (int) family);
			server_port = Gst.Rtsp.RTSPRange.New (native_server_port);
			Marshal.FreeHGlobal (native_server_port);
			return server_port;
		}

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

		public Gst.Pad Sinkpad { 
			get {
				IntPtr raw_ret = gst_rtsp_stream_get_sinkpad(Handle);
				Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
				return ret;
			}
		}

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

		public Gst.Pad Srcpad { 
			get {
				IntPtr raw_ret = gst_rtsp_stream_get_srcpad(Handle);
				Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
				return ret;
			}
		}

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

		public Gst.Element SrtpEncoder { 
			get {
				IntPtr raw_ret = gst_rtsp_stream_get_srtp_encoder(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 void gst_rtsp_stream_get_ssrc(IntPtr raw, out uint ssrc);

		public uint Ssrc { 
			get {
				uint ssrc;
				gst_rtsp_stream_get_ssrc(Handle, out ssrc);
				return ssrc;
			}
		}

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

		public bool UlpfecEnabled { 
			get {
				bool raw_ret = gst_rtsp_stream_get_ulpfec_enabled(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

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

		public uint UlpfecPercentage { 
			get {
				uint raw_ret = gst_rtsp_stream_get_ulpfec_percentage(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_stream_set_ulpfec_percentage(Handle, value);
			}
		}

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

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

		public uint UlpfecPt { 
			get {
				uint raw_ret = gst_rtsp_stream_get_ulpfec_pt(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set {
				gst_rtsp_stream_set_ulpfec_pt(Handle, value);
			}
		}

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

		public bool HandleKeymgmt(string keymgmt) {
			IntPtr native_keymgmt = GLib.Marshaller.StringToPtrGStrdup (keymgmt);
			bool raw_ret = gst_rtsp_stream_handle_keymgmt(Handle, native_keymgmt);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_keymgmt);
			return ret;
		}

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

		public bool HasControl(string control) {
			IntPtr native_control = GLib.Marshaller.StringToPtrGStrdup (control);
			bool raw_ret = gst_rtsp_stream_has_control(Handle, native_control);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_control);
			return ret;
		}

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

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

		public bool IsBindMcastAddress { 
			get {
				bool raw_ret = gst_rtsp_stream_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_stream_is_blocking(IntPtr raw);

		public bool IsBlocking { 
			get {
				bool raw_ret = gst_rtsp_stream_is_blocking(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsClientSide { 
			get {
				bool raw_ret = gst_rtsp_stream_is_client_side(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsComplete { 
			get {
				bool raw_ret = gst_rtsp_stream_is_complete(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsReceiver { 
			get {
				bool raw_ret = gst_rtsp_stream_is_receiver(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsSender { 
			get {
				bool raw_ret = gst_rtsp_stream_is_sender(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsTransportSupported(Gst.Rtsp.RTSPTransport transport) {
			IntPtr native_transport = GLib.Marshaller.StructureToPtrAlloc (transport);
			bool raw_ret = gst_rtsp_stream_is_transport_supported(Handle, native_transport);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_transport);
			return ret;
		}

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

		public bool JoinBin(Gst.Bin bin, Gst.Element rtpbin, Gst.State state) {
			bool raw_ret = gst_rtsp_stream_join_bin(Handle, bin == null ? IntPtr.Zero : bin.Handle, rtpbin == null ? IntPtr.Zero : rtpbin.Handle, (int) state);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool LeaveBin(Gst.Bin bin, Gst.Element rtpbin) {
			bool raw_ret = gst_rtsp_stream_leave_bin(Handle, bin == null ? IntPtr.Zero : bin.Handle, rtpbin == null ? IntPtr.Zero : rtpbin.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool QueryPosition(out long position) {
			bool raw_ret = gst_rtsp_stream_query_position(Handle, out position);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool QueryStop(out long stop) {
			bool raw_ret = gst_rtsp_stream_query_stop(Handle, out stop);
			bool ret = raw_ret;
			return ret;
		}

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

		public Gst.FlowReturn RecvRtcp(Gst.Buffer buffer) {
			buffer.Owned = false;
			int raw_ret = gst_rtsp_stream_recv_rtcp(Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}

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

		public Gst.FlowReturn RecvRtp(Gst.Buffer buffer) {
			buffer.Owned = false;
			int raw_ret = gst_rtsp_stream_recv_rtp(Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}

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

		public bool RemoveTransport(Gst.RtspServer.RTSPStreamTransport trans) {
			bool raw_ret = gst_rtsp_stream_remove_transport(Handle, trans == null ? IntPtr.Zero : trans.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public Gst.Element RequestAuxReceiver(uint sessid) {
			IntPtr raw_ret = gst_rtsp_stream_request_aux_receiver(Handle, sessid);
			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 IntPtr gst_rtsp_stream_request_aux_sender(IntPtr raw, uint sessid);

		public Gst.Element RequestAuxSender(uint sessid) {
			IntPtr raw_ret = gst_rtsp_stream_request_aux_sender(Handle, sessid);
			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 IntPtr gst_rtsp_stream_request_ulpfec_decoder(IntPtr raw, IntPtr rtpbin, uint sessid);

		public Gst.Element RequestUlpfecDecoder(Gst.Element rtpbin, uint sessid) {
			IntPtr raw_ret = gst_rtsp_stream_request_ulpfec_decoder(Handle, rtpbin == null ? IntPtr.Zero : rtpbin.Handle, sessid);
			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 IntPtr gst_rtsp_stream_request_ulpfec_encoder(IntPtr raw, uint sessid);

		public Gst.Element RequestUlpfecEncoder(uint sessid) {
			IntPtr raw_ret = gst_rtsp_stream_request_ulpfec_encoder(Handle, sessid);
			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 IntPtr gst_rtsp_stream_reserve_address(IntPtr raw, IntPtr address, uint port, uint n_ports, uint ttl);

		public Gst.RtspServer.RTSPAddress ReserveAddress(string address, uint port, uint n_ports, uint ttl) {
			IntPtr native_address = GLib.Marshaller.StringToPtrGStrdup (address);
			IntPtr raw_ret = gst_rtsp_stream_reserve_address(Handle, native_address, port, n_ports, ttl);
			Gst.RtspServer.RTSPAddress ret = Gst.RtspServer.RTSPAddress.New (raw_ret);
			GLib.Marshaller.Free (native_address);
			return ret;
		}

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

		public bool Seekable() {
			bool raw_ret = gst_rtsp_stream_seekable(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool BindMcastAddress { 
			set {
				gst_rtsp_stream_set_bind_mcast_address(Handle, value);
			}
		}

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

		public bool SetBlocked(bool blocked) {
			bool raw_ret = gst_rtsp_stream_set_blocked(Handle, blocked);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool ClientSide { 
			set {
				gst_rtsp_stream_set_client_side(Handle, value);
			}
		}

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

		public bool SetMaxMcastTtl(uint ttl) {
			bool raw_ret = gst_rtsp_stream_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_stream_set_pt_map(IntPtr raw, uint pt, IntPtr caps);

		public void SetPtMap(uint pt, Gst.Caps caps) {
			gst_rtsp_stream_set_pt_map(Handle, pt, caps == null ? IntPtr.Zero : caps.Handle);
		}

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

		public ushort SeqnumOffset { 
			set {
				gst_rtsp_stream_set_seqnum_offset(Handle, value);
			}
		}

		[DllImport("gstrtspserver-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtsp_stream_transport_filter(IntPtr raw, Gst.RtspServerSharp.RTSPStreamTransportFilterFuncNative func, IntPtr user_data);

		public Gst.RtspServer.RTSPStreamTransport[] TransportFilter(Gst.RtspServer.RTSPStreamTransportFilterFunc func) {
			Gst.RtspServerSharp.RTSPStreamTransportFilterFuncWrapper func_wrapper = new Gst.RtspServerSharp.RTSPStreamTransportFilterFuncWrapper (func);
			IntPtr raw_ret = gst_rtsp_stream_transport_filter(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
			Gst.RtspServer.RTSPStreamTransport[] ret = (Gst.RtspServer.RTSPStreamTransport[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(Gst.RtspServer.RTSPStreamTransport));
			return ret;
		}

		public Gst.RtspServer.RTSPStreamTransport[] TransportFilter() {
			return TransportFilter (null);
		}

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

		public bool UnblockLinked() {
			bool raw_ret = gst_rtsp_stream_unblock_linked(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public void UnblockRtcp() {
			gst_rtsp_stream_unblock_rtcp(Handle);
		}

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

		public bool UpdateCrypto(uint ssrc, Gst.Caps crypto) {
			bool raw_ret = gst_rtsp_stream_update_crypto(Handle, ssrc, crypto == null ? IntPtr.Zero : crypto.Handle);
			bool ret = raw_ret;
			return ret;
		}

		public bool UpdateCrypto(uint ssrc) {
			return UpdateCrypto (ssrc, null);
		}

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

		public bool VerifyMcastTtl(uint ttl) {
			bool raw_ret = gst_rtsp_stream_verify_mcast_ttl(Handle, ttl);
			bool ret = raw_ret;
			return ret;
		}


		static RTSPStream ()
		{
			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
	}
}
