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

namespace Gst.Rtp {

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

#region Autogenerated code
	public partial class RTPHeaderExtension : Gst.Element {

		protected RTPHeaderExtension (IntPtr raw) : base(raw) {}

		protected RTPHeaderExtension() : base(IntPtr.Zero)
		{
			CreateNativeObject (new string [0], new GLib.Value [0]);
		}

		static GetSupportedFlagsNativeDelegate GetSupportedFlags_cb_delegate;
		static GetSupportedFlagsNativeDelegate GetSupportedFlagsVMCallback {
			get {
				if (GetSupportedFlags_cb_delegate == null)
					GetSupportedFlags_cb_delegate = new GetSupportedFlagsNativeDelegate (GetSupportedFlags_cb);
				return GetSupportedFlags_cb_delegate;
			}
		}

		static void OverrideGetSupportedFlags (GLib.GType gtype)
		{
			OverrideGetSupportedFlags (gtype, GetSupportedFlagsVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetSupportedFlagsNativeDelegate (IntPtr inst);

		static int GetSupportedFlags_cb (IntPtr inst)
		{
			try {
				RTPHeaderExtension __obj = GLib.Object.GetObject (inst, false) as RTPHeaderExtension;
				Gst.Rtp.RTPHeaderExtensionFlags __result;
				__result = __obj.OnGetSupportedFlags ();
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Rtp.RTPHeaderExtension), ConnectionMethod="OverrideGetSupportedFlags")]
		protected virtual Gst.Rtp.RTPHeaderExtensionFlags OnGetSupportedFlags ()
		{
			return InternalGetSupportedFlags ();
		}

		private Gst.Rtp.RTPHeaderExtensionFlags InternalGetSupportedFlags ()
		{
			GetSupportedFlagsNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_supported_flags"));
				unmanaged = (GetSupportedFlagsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetSupportedFlagsNativeDelegate));
			}
			if (unmanaged == null) return (Gst.Rtp.RTPHeaderExtensionFlags) 0;

			int __result = unmanaged (this.Handle);
			return (Gst.Rtp.RTPHeaderExtensionFlags) __result;
		}

		static GetMaxSizeNativeDelegate GetMaxSize_cb_delegate;
		static GetMaxSizeNativeDelegate GetMaxSizeVMCallback {
			get {
				if (GetMaxSize_cb_delegate == null)
					GetMaxSize_cb_delegate = new GetMaxSizeNativeDelegate (GetMaxSize_cb);
				return GetMaxSize_cb_delegate;
			}
		}

		static void OverrideGetMaxSize (GLib.GType gtype)
		{
			OverrideGetMaxSize (gtype, GetMaxSizeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate UIntPtr GetMaxSizeNativeDelegate (IntPtr inst, IntPtr input_meta);

		static UIntPtr GetMaxSize_cb (IntPtr inst, IntPtr input_meta)
		{
			try {
				RTPHeaderExtension __obj = GLib.Object.GetObject (inst, false) as RTPHeaderExtension;
				ulong __result;
				__result = __obj.OnGetMaxSize (input_meta == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (input_meta, typeof (Gst.Buffer), false));
				return new UIntPtr (__result);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Rtp.RTPHeaderExtension), ConnectionMethod="OverrideGetMaxSize")]
		protected virtual ulong OnGetMaxSize (Gst.Buffer input_meta)
		{
			return InternalGetMaxSize (input_meta);
		}

		private ulong InternalGetMaxSize (Gst.Buffer input_meta)
		{
			GetMaxSizeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_max_size"));
				unmanaged = (GetMaxSizeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetMaxSizeNativeDelegate));
			}
			if (unmanaged == null) return 0;

			UIntPtr __result = unmanaged (this.Handle, input_meta == null ? IntPtr.Zero : input_meta.Handle);
			return (ulong) __result;
		}

		static WriteNativeDelegate Write_cb_delegate;
		static WriteNativeDelegate WriteVMCallback {
			get {
				if (Write_cb_delegate == null)
					Write_cb_delegate = new WriteNativeDelegate (Write_cb);
				return Write_cb_delegate;
			}
		}

		static void OverrideWrite (GLib.GType gtype)
		{
			OverrideWrite (gtype, WriteVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr WriteNativeDelegate (IntPtr inst, IntPtr input_meta, int write_flags, IntPtr output, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=5)]byte[] data, UIntPtr size);

		static IntPtr Write_cb (IntPtr inst, IntPtr input_meta, int write_flags, IntPtr output, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=5)]byte[] data, UIntPtr size)
		{
			try {
				RTPHeaderExtension __obj = GLib.Object.GetObject (inst, false) as RTPHeaderExtension;
				long __result;
				__result = __obj.OnWrite (input_meta == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (input_meta, typeof (Gst.Buffer), false), (Gst.Rtp.RTPHeaderExtensionFlags) write_flags, output == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (output, typeof (Gst.Buffer), false), data);
				return new IntPtr (__result);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Rtp.RTPHeaderExtension), ConnectionMethod="OverrideWrite")]
		protected virtual long OnWrite (Gst.Buffer input_meta, Gst.Rtp.RTPHeaderExtensionFlags write_flags, Gst.Buffer output, byte[] data)
		{
			return InternalWrite (input_meta, write_flags, output, data);
		}

		private long InternalWrite (Gst.Buffer input_meta, Gst.Rtp.RTPHeaderExtensionFlags write_flags, Gst.Buffer output, byte[] data)
		{
			WriteNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("write"));
				unmanaged = (WriteNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(WriteNativeDelegate));
			}
			if (unmanaged == null) return 0L;

			ulong size = (ulong)(data == null ? 0 : data.Length);
			IntPtr __result = unmanaged (this.Handle, input_meta == null ? IntPtr.Zero : input_meta.Handle, (int) write_flags, output == null ? IntPtr.Zero : output.Handle, data, new UIntPtr ((uint)size));
			return (long) __result;
		}

		static ReadNativeDelegate Read_cb_delegate;
		static ReadNativeDelegate ReadVMCallback {
			get {
				if (Read_cb_delegate == null)
					Read_cb_delegate = new ReadNativeDelegate (Read_cb);
				return Read_cb_delegate;
			}
		}

		static void OverrideRead (GLib.GType gtype)
		{
			OverrideRead (gtype, ReadVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ReadNativeDelegate (IntPtr inst, int read_flags, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)]byte[] data, UIntPtr size, IntPtr buffer);

		static bool Read_cb (IntPtr inst, int read_flags, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)]byte[] data, UIntPtr size, IntPtr buffer)
		{
			try {
				RTPHeaderExtension __obj = GLib.Object.GetObject (inst, false) as RTPHeaderExtension;
				bool __result;
				__result = __obj.OnRead ((Gst.Rtp.RTPHeaderExtensionFlags) read_flags, data, buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), false));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Rtp.RTPHeaderExtension), ConnectionMethod="OverrideRead")]
		protected virtual bool OnRead (Gst.Rtp.RTPHeaderExtensionFlags read_flags, byte[] data, Gst.Buffer buffer)
		{
			return InternalRead (read_flags, data, buffer);
		}

		private bool InternalRead (Gst.Rtp.RTPHeaderExtensionFlags read_flags, byte[] data, Gst.Buffer buffer)
		{
			ReadNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("read"));
				unmanaged = (ReadNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ReadNativeDelegate));
			}
			if (unmanaged == null) return false;

			ulong size = (ulong)(data == null ? 0 : data.Length);
			bool __result = unmanaged (this.Handle, (int) read_flags, data, new UIntPtr ((uint)size), buffer == null ? IntPtr.Zero : buffer.Handle);
			return __result;
		}

		static SetNonRtpSinkCapsNativeDelegate SetNonRtpSinkCaps_cb_delegate;
		static SetNonRtpSinkCapsNativeDelegate SetNonRtpSinkCapsVMCallback {
			get {
				if (SetNonRtpSinkCaps_cb_delegate == null)
					SetNonRtpSinkCaps_cb_delegate = new SetNonRtpSinkCapsNativeDelegate (SetNonRtpSinkCaps_cb);
				return SetNonRtpSinkCaps_cb_delegate;
			}
		}

		static void OverrideSetNonRtpSinkCaps (GLib.GType gtype)
		{
			OverrideSetNonRtpSinkCaps (gtype, SetNonRtpSinkCapsVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetNonRtpSinkCapsNativeDelegate (IntPtr inst, IntPtr caps);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Rtp.RTPHeaderExtension), ConnectionMethod="OverrideSetNonRtpSinkCaps")]
		protected virtual bool OnSetNonRtpSinkCaps (Gst.Caps caps)
		{
			return InternalSetNonRtpSinkCaps (caps);
		}

		private bool InternalSetNonRtpSinkCaps (Gst.Caps caps)
		{
			SetNonRtpSinkCapsNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_non_rtp_sink_caps"));
				unmanaged = (SetNonRtpSinkCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetNonRtpSinkCapsNativeDelegate));
			}
			if (unmanaged == null) return false;

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

		static UpdateNonRtpSrcCapsNativeDelegate UpdateNonRtpSrcCaps_cb_delegate;
		static UpdateNonRtpSrcCapsNativeDelegate UpdateNonRtpSrcCapsVMCallback {
			get {
				if (UpdateNonRtpSrcCaps_cb_delegate == null)
					UpdateNonRtpSrcCaps_cb_delegate = new UpdateNonRtpSrcCapsNativeDelegate (UpdateNonRtpSrcCaps_cb);
				return UpdateNonRtpSrcCaps_cb_delegate;
			}
		}

		static void OverrideUpdateNonRtpSrcCaps (GLib.GType gtype)
		{
			OverrideUpdateNonRtpSrcCaps (gtype, UpdateNonRtpSrcCapsVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool UpdateNonRtpSrcCapsNativeDelegate (IntPtr inst, IntPtr caps);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Rtp.RTPHeaderExtension), ConnectionMethod="OverrideUpdateNonRtpSrcCaps")]
		protected virtual bool OnUpdateNonRtpSrcCaps (Gst.Caps caps)
		{
			return InternalUpdateNonRtpSrcCaps (caps);
		}

		private bool InternalUpdateNonRtpSrcCaps (Gst.Caps caps)
		{
			UpdateNonRtpSrcCapsNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("update_non_rtp_src_caps"));
				unmanaged = (UpdateNonRtpSrcCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UpdateNonRtpSrcCapsNativeDelegate));
			}
			if (unmanaged == null) return false;

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

		static SetAttributesNativeDelegate SetAttributes_cb_delegate;
		static SetAttributesNativeDelegate SetAttributesVMCallback {
			get {
				if (SetAttributes_cb_delegate == null)
					SetAttributes_cb_delegate = new SetAttributesNativeDelegate (SetAttributes_cb);
				return SetAttributes_cb_delegate;
			}
		}

		static void OverrideSetAttributes (GLib.GType gtype)
		{
			OverrideSetAttributes (gtype, SetAttributesVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetAttributesNativeDelegate (IntPtr inst, int direction, IntPtr attributes);

		static bool SetAttributes_cb (IntPtr inst, int direction, IntPtr attributes)
		{
			try {
				RTPHeaderExtension __obj = GLib.Object.GetObject (inst, false) as RTPHeaderExtension;
				bool __result;
				__result = __obj.OnSetAttributes ((Gst.Rtp.RTPHeaderExtensionDirection) direction, GLib.Marshaller.Utf8PtrToString (attributes));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Rtp.RTPHeaderExtension), ConnectionMethod="OverrideSetAttributes")]
		protected virtual bool OnSetAttributes (Gst.Rtp.RTPHeaderExtensionDirection direction, string attributes)
		{
			return InternalSetAttributes (direction, attributes);
		}

		private bool InternalSetAttributes (Gst.Rtp.RTPHeaderExtensionDirection direction, string attributes)
		{
			SetAttributesNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_attributes"));
				unmanaged = (SetAttributesNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetAttributesNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_attributes = GLib.Marshaller.StringToPtrGStrdup (attributes);
			bool __result = unmanaged (this.Handle, (int) direction, native_attributes);
			GLib.Marshaller.Free (native_attributes);
			return __result;
		}

		static SetCapsFromAttributesNativeDelegate SetCapsFromAttributes_cb_delegate;
		static SetCapsFromAttributesNativeDelegate SetCapsFromAttributesVMCallback {
			get {
				if (SetCapsFromAttributes_cb_delegate == null)
					SetCapsFromAttributes_cb_delegate = new SetCapsFromAttributesNativeDelegate (SetCapsFromAttributes_cb);
				return SetCapsFromAttributes_cb_delegate;
			}
		}

		static void OverrideSetCapsFromAttributes (GLib.GType gtype)
		{
			OverrideSetCapsFromAttributes (gtype, SetCapsFromAttributesVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetCapsFromAttributesNativeDelegate (IntPtr inst, IntPtr caps);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Rtp.RTPHeaderExtension), ConnectionMethod="OverrideSetCapsFromAttributes")]
		protected virtual bool OnSetCapsFromAttributes (Gst.Caps caps)
		{
			return InternalSetCapsFromAttributes (caps);
		}

		private bool InternalSetCapsFromAttributes (Gst.Caps caps)
		{
			SetCapsFromAttributesNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_caps_from_attributes"));
				unmanaged = (SetCapsFromAttributesNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetCapsFromAttributesNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, caps == null ? IntPtr.Zero : caps.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("get_supported_flags"
							, Gst.Element.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_supported_flags
							, null
							, "get_max_size"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_max_size"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_max_size
							, "get_supported_flags"
							, "write"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("write"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // write
							, "get_max_size"
							, "read"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("read"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // read
							, "write"
							, "set_non_rtp_sink_caps"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_non_rtp_sink_caps"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_non_rtp_sink_caps
							, "read"
							, "update_non_rtp_src_caps"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("update_non_rtp_src_caps"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // update_non_rtp_src_caps
							, "set_non_rtp_sink_caps"
							, "set_attributes"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_attributes"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_attributes
							, "update_non_rtp_src_caps"
							, "set_caps_from_attributes"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_caps_from_attributes"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_caps_from_attributes
							, "set_attributes"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _gst_reserved
							, "set_caps_from_attributes"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

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

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtp_header_extension_create_from_uri(IntPtr uri);

		public static Gst.Rtp.RTPHeaderExtension CreateFromUri(string uri) {
			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
			IntPtr raw_ret = gst_rtp_header_extension_create_from_uri(native_uri);
			Gst.Rtp.RTPHeaderExtension ret = GLib.Object.GetObject(raw_ret, true) as Gst.Rtp.RTPHeaderExtension;
			GLib.Marshaller.Free (native_uri);
			return ret;
		}

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

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtp_header_extension_set_direction(IntPtr raw, int direction);

		public Gst.Rtp.RTPHeaderExtensionDirection Direction { 
			get {
				int raw_ret = gst_rtp_header_extension_get_direction(Handle);
				Gst.Rtp.RTPHeaderExtensionDirection ret = (Gst.Rtp.RTPHeaderExtensionDirection) raw_ret;
				return ret;
			}
			set {
				gst_rtp_header_extension_set_direction(Handle, (int) value);
			}
		}

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

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtp_header_extension_set_id(IntPtr raw, uint ext_id);

		public uint Id { 
			get {
				uint raw_ret = gst_rtp_header_extension_get_id(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set {
				gst_rtp_header_extension_set_id(Handle, value);
			}
		}

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern UIntPtr gst_rtp_header_extension_get_max_size(IntPtr raw, IntPtr input_meta);

		public ulong GetMaxSize(Gst.Buffer input_meta) {
			UIntPtr raw_ret = gst_rtp_header_extension_get_max_size(Handle, input_meta == null ? IntPtr.Zero : input_meta.Handle);
			ulong ret = (ulong) raw_ret;
			return ret;
		}

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

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

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

		public Gst.Rtp.RTPHeaderExtensionFlags SupportedFlags { 
			get {
				int raw_ret = gst_rtp_header_extension_get_supported_flags(Handle);
				Gst.Rtp.RTPHeaderExtensionFlags ret = (Gst.Rtp.RTPHeaderExtensionFlags) raw_ret;
				return ret;
			}
		}

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

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtp_header_extension_class_set_uri(IntPtr uri);

		public string Uri { 
			get {
				IntPtr raw_ret = gst_rtp_header_extension_get_uri(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gst_rtp_header_extension_class_set_uri(native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtp_header_extension_read(IntPtr raw, int read_flags, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)]byte[] data, UIntPtr size, IntPtr buffer);

		public bool Read(Gst.Rtp.RTPHeaderExtensionFlags read_flags, byte[] data, Gst.Buffer buffer) {
			ulong size = (ulong)(data == null ? 0 : data.Length);
			bool raw_ret = gst_rtp_header_extension_read(Handle, (int) read_flags, data, new UIntPtr ((uint)size), buffer == null ? IntPtr.Zero : buffer.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool SetAttributesFromCaps(Gst.Caps caps) {
			bool raw_ret = gst_rtp_header_extension_set_attributes_from_caps(Handle, caps == null ? IntPtr.Zero : caps.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool SetCapsFromAttributes(Gst.Caps caps) {
			bool raw_ret = gst_rtp_header_extension_set_caps_from_attributes(Handle, caps == null ? IntPtr.Zero : caps.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_rtp_header_extension_set_caps_from_attributes_helper(IntPtr raw, IntPtr caps, IntPtr attributes);

		public bool SetCapsFromAttributesHelper(Gst.Caps caps, string attributes) {
			IntPtr native_attributes = GLib.Marshaller.StringToPtrGStrdup (attributes);
			bool raw_ret = gst_rtp_header_extension_set_caps_from_attributes_helper(Handle, caps == null ? IntPtr.Zero : caps.Handle, native_attributes);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_attributes);
			return ret;
		}

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

		public bool SetNonRtpSinkCaps(Gst.Caps caps) {
			bool raw_ret = gst_rtp_header_extension_set_non_rtp_sink_caps(Handle, caps == null ? IntPtr.Zero : caps.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_rtp_header_extension_set_wants_update_non_rtp_src_caps(IntPtr raw, bool state);

		public bool WantsUpdateNonRtpSrcCaps { 
			set {
				gst_rtp_header_extension_set_wants_update_non_rtp_src_caps(Handle, value);
			}
		}

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

		public bool UpdateNonRtpSrcCaps(Gst.Caps caps) {
			bool raw_ret = gst_rtp_header_extension_update_non_rtp_src_caps(Handle, caps == null ? IntPtr.Zero : caps.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool SetWantsUpdateNonRtpSrcCaps() {
			bool raw_ret = gst_rtp_header_extension_wants_update_non_rtp_src_caps(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstrtp-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_rtp_header_extension_write(IntPtr raw, IntPtr input_meta, int write_flags, IntPtr output, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=5)]byte[] data, UIntPtr size);

		public long Write(Gst.Buffer input_meta, Gst.Rtp.RTPHeaderExtensionFlags write_flags, Gst.Buffer output, byte[] data) {
			ulong size = (ulong)(data == null ? 0 : data.Length);
			IntPtr raw_ret = gst_rtp_header_extension_write(Handle, input_meta == null ? IntPtr.Zero : input_meta.Handle, (int) write_flags, output == null ? IntPtr.Zero : output.Handle, data, new UIntPtr ((uint)size));
			long ret = (long) raw_ret;
			return ret;
		}


		static RTPHeaderExtension ()
		{
			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("_gst_reserved"
							, Gst.Element.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
							, null
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}