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

namespace Gst.Base {

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

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

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

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

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

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_set_blocksize(IntPtr raw, uint blocksize);

		[GLib.Property ("blocksize")]
		public uint Blocksize {
			get  {
				uint raw_ret = gst_base_src_get_blocksize(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gst_base_src_set_blocksize(Handle, value);
			}
		}

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

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_set_do_timestamp(IntPtr raw, bool timestamp);

		[GLib.Property ("do-timestamp")]
		public bool DoTimestamp {
			get  {
				bool raw_ret = gst_base_src_get_do_timestamp(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gst_base_src_set_do_timestamp(Handle, value);
			}
		}

		[GLib.Property ("num-buffers")]
		public int NumBuffers {
			get {
				GLib.Value val = GetProperty ("num-buffers");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("num-buffers", val);
				val.Dispose ();
			}
		}

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

		public Gst.Pad Srcpad {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("srcpad"));
					return GLib.Object.GetObject((*raw_ptr)) as Gst.Pad;
				}
			}
		}

		public GLib.Mutex LiveLock {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("live_lock"));
					return new GLib.Mutex((*raw_ptr));
				}
			}
		}

		public GLib.Cond LiveCond {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("live_cond"));
					return new GLib.Cond((*raw_ptr));
				}
			}
		}

		public bool IsLiveField {
			get {
				unsafe {
					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("is_live"));
					return (*raw_ptr);
				}
			}
		}

		public bool LiveRunning {
			get {
				unsafe {
					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("live_running"));
					return (*raw_ptr);
				}
			}
		}

		public uint BlocksizeField {
			get {
				unsafe {
					uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("blocksize"));
					return (*raw_ptr);
				}
			}
		}

		public bool CanActivatePush {
			get {
				unsafe {
					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("can_activate_push"));
					return (*raw_ptr);
				}
			}
		}

		public bool RandomAccess {
			get {
				unsafe {
					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("random_access"));
					return (*raw_ptr);
				}
			}
		}

		public IntPtr ClockId {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("clock_id"));
					return (*raw_ptr);
				}
			}
		}

		public Gst.Segment Segment {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("segment"));
					return Gst.Segment.New ((*raw_ptr));
				}
			}
		}

		public bool NeedNewsegment {
			get {
				unsafe {
					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("need_newsegment"));
					return (*raw_ptr);
				}
			}
		}

		public int NumBuffersField {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("num_buffers"));
					return (*raw_ptr);
				}
			}
		}

		public int NumBuffersLeft {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("num_buffers_left"));
					return (*raw_ptr);
				}
			}
		}

		public bool TypefindField {
			get {
				unsafe {
					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("typefind"));
					return (*raw_ptr);
				}
			}
		}

		public bool Running {
			get {
				unsafe {
					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("running"));
					return (*raw_ptr);
				}
			}
		}

		public Gst.Event PendingSeek {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("pending_seek"));
					return (*raw_ptr) == IntPtr.Zero ? null : (Gst.Event) GLib.Opaque.GetOpaque ((*raw_ptr), typeof (Gst.Event), false);
				}
			}
		}

		static GetCapsNativeDelegate GetCaps_cb_delegate;
		static GetCapsNativeDelegate GetCapsVMCallback {
			get {
				if (GetCaps_cb_delegate == null)
					GetCaps_cb_delegate = new GetCapsNativeDelegate (GetCaps_cb);
				return GetCaps_cb_delegate;
			}
		}

		static void OverrideGetCaps (GLib.GType gtype)
		{
			OverrideGetCaps (gtype, GetCapsVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr GetCapsNativeDelegate (IntPtr inst, IntPtr filter);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideGetCaps")]
		protected virtual Gst.Caps OnGetCaps (Gst.Caps filter)
		{
			return InternalGetCaps (filter);
		}

		private Gst.Caps InternalGetCaps (Gst.Caps filter)
		{
			GetCapsNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_caps"));
				unmanaged = (GetCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetCapsNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, filter == null ? IntPtr.Zero : filter.Handle);
			return __result == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (__result, typeof (Gst.Caps), true);
		}

		static NegotiateNativeDelegate Negotiate_cb_delegate;
		static NegotiateNativeDelegate NegotiateVMCallback {
			get {
				if (Negotiate_cb_delegate == null)
					Negotiate_cb_delegate = new NegotiateNativeDelegate (Negotiate_cb);
				return Negotiate_cb_delegate;
			}
		}

		static void OverrideNegotiate (GLib.GType gtype)
		{
			OverrideNegotiate (gtype, NegotiateVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideNegotiate")]
		protected virtual bool OnNegotiate ()
		{
			return InternalNegotiate ();
		}

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

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

		static FixateNativeDelegate Fixate_cb_delegate;
		static FixateNativeDelegate FixateVMCallback {
			get {
				if (Fixate_cb_delegate == null)
					Fixate_cb_delegate = new FixateNativeDelegate (Fixate_cb);
				return Fixate_cb_delegate;
			}
		}

		static void OverrideFixate (GLib.GType gtype)
		{
			OverrideFixate (gtype, FixateVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideFixate")]
		protected virtual Gst.Caps OnFixate (Gst.Caps caps)
		{
			return InternalFixate (caps);
		}

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

			IntPtr __result = unmanaged (this.Handle, caps == null ? IntPtr.Zero : caps.Handle);
			return __result == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (__result, typeof (Gst.Caps), true);
		}

		static SetCapsNativeDelegate SetCaps_cb_delegate;
		static SetCapsNativeDelegate SetCapsVMCallback {
			get {
				if (SetCaps_cb_delegate == null)
					SetCaps_cb_delegate = new SetCapsNativeDelegate (SetCaps_cb);
				return SetCaps_cb_delegate;
			}
		}

		static void OverrideSetCaps (GLib.GType gtype)
		{
			OverrideSetCaps (gtype, SetCapsVMCallback);
		}

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

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

		static bool SetCaps_cb (IntPtr inst, IntPtr caps)
		{
			try {
				BaseSrc __obj = GLib.Object.GetObject (inst, false) as BaseSrc;
				bool __result;
				__result = __obj.OnSetCaps (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.Base.BaseSrc), ConnectionMethod="OverrideSetCaps")]
		protected virtual bool OnSetCaps (Gst.Caps caps)
		{
			return InternalSetCaps (caps);
		}

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

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

		static DecideAllocationNativeDelegate DecideAllocation_cb_delegate;
		static DecideAllocationNativeDelegate DecideAllocationVMCallback {
			get {
				if (DecideAllocation_cb_delegate == null)
					DecideAllocation_cb_delegate = new DecideAllocationNativeDelegate (DecideAllocation_cb);
				return DecideAllocation_cb_delegate;
			}
		}

		static void OverrideDecideAllocation (GLib.GType gtype)
		{
			OverrideDecideAllocation (gtype, DecideAllocationVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DecideAllocationNativeDelegate (IntPtr inst, IntPtr query);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideDecideAllocation")]
		protected virtual bool OnDecideAllocation (Gst.Query query)
		{
			return InternalDecideAllocation (query);
		}

		private bool InternalDecideAllocation (Gst.Query query)
		{
			DecideAllocationNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("decide_allocation"));
				unmanaged = (DecideAllocationNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DecideAllocationNativeDelegate));
			}
			if (unmanaged == null) return false;

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

		static StartNativeDelegate Start_cb_delegate;
		static StartNativeDelegate StartVMCallback {
			get {
				if (Start_cb_delegate == null)
					Start_cb_delegate = new StartNativeDelegate (Start_cb);
				return Start_cb_delegate;
			}
		}

		static void OverrideStart (GLib.GType gtype)
		{
			OverrideStart (gtype, StartVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideStart")]
		protected virtual bool OnStart ()
		{
			return InternalStart ();
		}

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

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

		static StopNativeDelegate Stop_cb_delegate;
		static StopNativeDelegate StopVMCallback {
			get {
				if (Stop_cb_delegate == null)
					Stop_cb_delegate = new StopNativeDelegate (Stop_cb);
				return Stop_cb_delegate;
			}
		}

		static void OverrideStop (GLib.GType gtype)
		{
			OverrideStop (gtype, StopVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideStop")]
		protected virtual bool OnStop ()
		{
			return InternalStop ();
		}

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

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

		static GetTimesNativeDelegate GetTimes_cb_delegate;
		static GetTimesNativeDelegate GetTimesVMCallback {
			get {
				if (GetTimes_cb_delegate == null)
					GetTimes_cb_delegate = new GetTimesNativeDelegate (GetTimes_cb);
				return GetTimes_cb_delegate;
			}
		}

		static void OverrideGetTimes (GLib.GType gtype)
		{
			OverrideGetTimes (gtype, GetTimesVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetTimesNativeDelegate (IntPtr inst, IntPtr buffer, out ulong start, out ulong end);

		static void GetTimes_cb (IntPtr inst, IntPtr buffer, out ulong start, out ulong end)
		{
			try {
				BaseSrc __obj = GLib.Object.GetObject (inst, false) as BaseSrc;
				__obj.OnGetTimes (buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), false), out start, out end);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideGetTimes")]
		protected virtual void OnGetTimes (Gst.Buffer buffer, out ulong start, out ulong end)
		{
			InternalGetTimes (buffer, out start, out end);
		}

		private void InternalGetTimes (Gst.Buffer buffer, out ulong start, out ulong end)
		{
			GetTimesNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_times"));
				unmanaged = (GetTimesNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetTimesNativeDelegate));
			}
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, buffer == null ? IntPtr.Zero : buffer.Handle, out start, out end);
		}

		static GetSizeNativeDelegate GetSize_cb_delegate;
		static GetSizeNativeDelegate GetSizeVMCallback {
			get {
				if (GetSize_cb_delegate == null)
					GetSize_cb_delegate = new GetSizeNativeDelegate (GetSize_cb);
				return GetSize_cb_delegate;
			}
		}

		static void OverrideGetSize (GLib.GType gtype)
		{
			OverrideGetSize (gtype, GetSizeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool GetSizeNativeDelegate (IntPtr inst, ulong size);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideGetSize")]
		protected virtual bool OnGetSize (ulong size)
		{
			return InternalGetSize (size);
		}

		private bool InternalGetSize (ulong size)
		{
			GetSizeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_size"));
				unmanaged = (GetSizeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetSizeNativeDelegate));
			}
			if (unmanaged == null) return false;

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

		static IsSeekableNativeDelegate IsSeekable_cb_delegate;
		static IsSeekableNativeDelegate IsSeekableVMCallback {
			get {
				if (IsSeekable_cb_delegate == null)
					IsSeekable_cb_delegate = new IsSeekableNativeDelegate (IsSeekable_cb);
				return IsSeekable_cb_delegate;
			}
		}

		static void OverrideIsSeekable (GLib.GType gtype)
		{
			OverrideIsSeekable (gtype, IsSeekableVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideIsSeekable")]
		protected virtual bool OnIsSeekable ()
		{
			return InternalIsSeekable ();
		}

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

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

		static PrepareSeekSegmentNativeDelegate PrepareSeekSegment_cb_delegate;
		static PrepareSeekSegmentNativeDelegate PrepareSeekSegmentVMCallback {
			get {
				if (PrepareSeekSegment_cb_delegate == null)
					PrepareSeekSegment_cb_delegate = new PrepareSeekSegmentNativeDelegate (PrepareSeekSegment_cb);
				return PrepareSeekSegment_cb_delegate;
			}
		}

		static void OverridePrepareSeekSegment (GLib.GType gtype)
		{
			OverridePrepareSeekSegment (gtype, PrepareSeekSegmentVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool PrepareSeekSegmentNativeDelegate (IntPtr inst, IntPtr seek, IntPtr segment);

		static bool PrepareSeekSegment_cb (IntPtr inst, IntPtr seek, IntPtr segment)
		{
			try {
				BaseSrc __obj = GLib.Object.GetObject (inst, false) as BaseSrc;
				bool __result;
				__result = __obj.OnPrepareSeekSegment (seek == IntPtr.Zero ? null : (Gst.Event) GLib.Opaque.GetOpaque (seek, typeof (Gst.Event), false), Gst.Segment.New (segment));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverridePrepareSeekSegment")]
		protected virtual bool OnPrepareSeekSegment (Gst.Event seek, Gst.Segment segment)
		{
			return InternalPrepareSeekSegment (seek, segment);
		}

		private bool InternalPrepareSeekSegment (Gst.Event seek, Gst.Segment segment)
		{
			PrepareSeekSegmentNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare_seek_segment"));
				unmanaged = (PrepareSeekSegmentNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrepareSeekSegmentNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_segment = GLib.Marshaller.StructureToPtrAlloc (segment);
			bool __result = unmanaged (this.Handle, seek == null ? IntPtr.Zero : seek.Handle, native_segment);
			Marshal.FreeHGlobal (native_segment);
			return __result;
		}

		static DoSeekNativeDelegate DoSeek_cb_delegate;
		static DoSeekNativeDelegate DoSeekVMCallback {
			get {
				if (DoSeek_cb_delegate == null)
					DoSeek_cb_delegate = new DoSeekNativeDelegate (DoSeek_cb);
				return DoSeek_cb_delegate;
			}
		}

		static void OverrideDoSeek (GLib.GType gtype)
		{
			OverrideDoSeek (gtype, DoSeekVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool DoSeekNativeDelegate (IntPtr inst, IntPtr segment);

		static bool DoSeek_cb (IntPtr inst, IntPtr segment)
		{
			try {
				BaseSrc __obj = GLib.Object.GetObject (inst, false) as BaseSrc;
				bool __result;
				__result = __obj.OnDoSeek (Gst.Segment.New (segment));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideDoSeek")]
		protected virtual bool OnDoSeek (Gst.Segment segment)
		{
			return InternalDoSeek (segment);
		}

		private bool InternalDoSeek (Gst.Segment segment)
		{
			DoSeekNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("do_seek"));
				unmanaged = (DoSeekNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DoSeekNativeDelegate));
			}
			if (unmanaged == null) return false;

			IntPtr native_segment = GLib.Marshaller.StructureToPtrAlloc (segment);
			bool __result = unmanaged (this.Handle, native_segment);
			Marshal.FreeHGlobal (native_segment);
			return __result;
		}

		static UnlockNativeDelegate Unlock_cb_delegate;
		static UnlockNativeDelegate UnlockVMCallback {
			get {
				if (Unlock_cb_delegate == null)
					Unlock_cb_delegate = new UnlockNativeDelegate (Unlock_cb);
				return Unlock_cb_delegate;
			}
		}

		static void OverrideUnlock (GLib.GType gtype)
		{
			OverrideUnlock (gtype, UnlockVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideUnlock")]
		protected virtual bool OnUnlock ()
		{
			return InternalUnlock ();
		}

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

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

		static UnlockStopNativeDelegate UnlockStop_cb_delegate;
		static UnlockStopNativeDelegate UnlockStopVMCallback {
			get {
				if (UnlockStop_cb_delegate == null)
					UnlockStop_cb_delegate = new UnlockStopNativeDelegate (UnlockStop_cb);
				return UnlockStop_cb_delegate;
			}
		}

		static void OverrideUnlockStop (GLib.GType gtype)
		{
			OverrideUnlockStop (gtype, UnlockStopVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideUnlockStop")]
		protected virtual bool OnUnlockStop ()
		{
			return InternalUnlockStop ();
		}

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

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

		static QueryNativeDelegate Query_cb_delegate;
		static QueryNativeDelegate QueryVMCallback {
			get {
				if (Query_cb_delegate == null)
					Query_cb_delegate = new QueryNativeDelegate (Query_cb);
				return Query_cb_delegate;
			}
		}

		static void OverrideQuery (GLib.GType gtype)
		{
			OverrideQuery (gtype, QueryVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool QueryNativeDelegate (IntPtr inst, IntPtr query);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideQuery")]
		protected virtual bool OnQuery (Gst.Query query)
		{
			return InternalQuery (query);
		}

		private bool InternalQuery (Gst.Query query)
		{
			QueryNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query"));
				unmanaged = (QueryNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryNativeDelegate));
			}
			if (unmanaged == null) return false;

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

		static EventNativeDelegate Event_cb_delegate;
		static EventNativeDelegate EventVMCallback {
			get {
				if (Event_cb_delegate == null)
					Event_cb_delegate = new EventNativeDelegate (Event_cb);
				return Event_cb_delegate;
			}
		}

		static void OverrideEvent (GLib.GType gtype)
		{
			OverrideEvent (gtype, EventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool EventNativeDelegate (IntPtr inst, IntPtr evnt);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideEvent")]
		protected virtual bool OnEvent (Gst.Event evnt)
		{
			return InternalEvent (evnt);
		}

		private bool InternalEvent (Gst.Event evnt)
		{
			EventNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("evnt"));
				unmanaged = (EventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(EventNativeDelegate));
			}
			if (unmanaged == null) return false;

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

		static CreateNativeDelegate Create_cb_delegate;
		static CreateNativeDelegate CreateVMCallback {
			get {
				if (Create_cb_delegate == null)
					Create_cb_delegate = new CreateNativeDelegate (Create_cb);
				return Create_cb_delegate;
			}
		}

		static void OverrideCreate (GLib.GType gtype)
		{
			OverrideCreate (gtype, CreateVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int CreateNativeDelegate (IntPtr inst, ulong offset, uint size, out IntPtr buf);

		static int Create_cb (IntPtr inst, ulong offset, uint size, out IntPtr buf)
		{
			try {
				BaseSrc __obj = GLib.Object.GetObject (inst, false) as BaseSrc;
				Gst.FlowReturn __result;
				Gst.Buffer mybuf;
				__result = __obj.OnCreate (offset, size, out mybuf);
				buf = mybuf == null ? IntPtr.Zero : mybuf.Handle;
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideCreate")]
		protected virtual Gst.FlowReturn OnCreate (ulong offset, uint size, out Gst.Buffer buf)
		{
			return InternalCreate (offset, size, out buf);
		}

		private Gst.FlowReturn InternalCreate (ulong offset, uint size, out Gst.Buffer buf)
		{
			CreateNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("create"));
				unmanaged = (CreateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CreateNativeDelegate));
			}
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			IntPtr native_buf;
			int __result = unmanaged (this.Handle, offset, size, out native_buf);
			buf = native_buf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (native_buf, typeof (Gst.Buffer), true);
			return (Gst.FlowReturn) __result;
		}

		static AllocNativeDelegate Alloc_cb_delegate;
		static AllocNativeDelegate AllocVMCallback {
			get {
				if (Alloc_cb_delegate == null)
					Alloc_cb_delegate = new AllocNativeDelegate (Alloc_cb);
				return Alloc_cb_delegate;
			}
		}

		static void OverrideAlloc (GLib.GType gtype)
		{
			OverrideAlloc (gtype, AllocVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int AllocNativeDelegate (IntPtr inst, ulong offset, uint size, IntPtr buf);

		static int Alloc_cb (IntPtr inst, ulong offset, uint size, IntPtr buf)
		{
			try {
				BaseSrc __obj = GLib.Object.GetObject (inst, false) as BaseSrc;
				Gst.FlowReturn __result;
				__result = __obj.OnAlloc (offset, size, buf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buf, typeof (Gst.Buffer), false));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideAlloc")]
		protected virtual Gst.FlowReturn OnAlloc (ulong offset, uint size, Gst.Buffer buf)
		{
			return InternalAlloc (offset, size, buf);
		}

		private Gst.FlowReturn InternalAlloc (ulong offset, uint size, Gst.Buffer buf)
		{
			AllocNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("alloc"));
				unmanaged = (AllocNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AllocNativeDelegate));
			}
			if (unmanaged == null) return (Gst.FlowReturn) 0;

			int __result = unmanaged (this.Handle, offset, size, buf == null ? IntPtr.Zero : buf.Handle);
			return (Gst.FlowReturn) __result;
		}

		static FillNativeDelegate Fill_cb_delegate;
		static FillNativeDelegate FillVMCallback {
			get {
				if (Fill_cb_delegate == null)
					Fill_cb_delegate = new FillNativeDelegate (Fill_cb);
				return Fill_cb_delegate;
			}
		}

		static void OverrideFill (GLib.GType gtype)
		{
			OverrideFill (gtype, FillVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int FillNativeDelegate (IntPtr inst, ulong offset, uint size, IntPtr buf);

		static int Fill_cb (IntPtr inst, ulong offset, uint size, IntPtr buf)
		{
			try {
				BaseSrc __obj = GLib.Object.GetObject (inst, false) as BaseSrc;
				Gst.FlowReturn __result;
				__result = __obj.OnFill (offset, size, buf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buf, typeof (Gst.Buffer), false));
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseSrc), ConnectionMethod="OverrideFill")]
		protected virtual Gst.FlowReturn OnFill (ulong offset, uint size, Gst.Buffer buf)
		{
			return InternalFill (offset, size, buf);
		}

		private Gst.FlowReturn InternalFill (ulong offset, uint size, Gst.Buffer buf)
		{
			FillNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("fill"));
				unmanaged = (FillNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FillNativeDelegate));
			}
			if (unmanaged == null) return (Gst.FlowReturn) 0;

			int __result = unmanaged (this.Handle, offset, size, buf == null ? IntPtr.Zero : buf.Handle);
			return (Gst.FlowReturn) __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_caps"
							, Gst.Element.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_caps
							, null
							, "negotiate"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("negotiate"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // negotiate
							, "get_caps"
							, "fixate"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("fixate"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // fixate
							, "negotiate"
							, "set_caps"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_caps"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_caps
							, "fixate"
							, "decide_allocation"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("decide_allocation"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // decide_allocation
							, "set_caps"
							, "start"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("start"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // start
							, "decide_allocation"
							, "stop"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("stop"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // stop
							, "start"
							, "get_times"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_times"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_times
							, "stop"
							, "get_size"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_size"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_size
							, "get_times"
							, "is_seekable"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("is_seekable"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // is_seekable
							, "get_size"
							, "prepare_seek_segment"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("prepare_seek_segment"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // prepare_seek_segment
							, "is_seekable"
							, "do_seek"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("do_seek"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // do_seek
							, "prepare_seek_segment"
							, "unlock"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unlock"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unlock
							, "do_seek"
							, "unlock_stop"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unlock_stop"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unlock_stop
							, "unlock"
							, "query"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("query"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // query
							, "unlock_stop"
							, "event"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("event"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // event
							, "query"
							, "create"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("create"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // create
							, "event"
							, "alloc"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("alloc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // alloc
							, "create"
							, "fill"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("fill"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // fill
							, "alloc"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _gst_reserved
							, "fill"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

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

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_get_allocator(IntPtr raw, out IntPtr allocator, IntPtr parms);

		public void GetAllocator(out Gst.Allocator allocator, out Gst.AllocationParams parms) {
			IntPtr native_allocator;
			IntPtr native_parms = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (Gst.AllocationParams)));
			gst_base_src_get_allocator(Handle, out native_allocator, native_parms);
			allocator = GLib.Object.GetObject(native_allocator, true) as Gst.Allocator;
			parms = Gst.AllocationParams.New (native_parms);
			Marshal.FreeHGlobal (native_parms);
		}

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

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

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

		public bool IsAsync { 
			get {
				bool raw_ret = gst_base_src_is_async(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsLive { 
			get {
				bool raw_ret = gst_base_src_is_live(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public bool Negotiate() {
			bool raw_ret = gst_base_src_negotiate(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_base_src_new_seamless_segment(IntPtr raw, long start, long stop, long time);

		[Obsolete]
		public bool NewSeamlessSegment(long start, long stop, long time) {
			bool raw_ret = gst_base_src_new_seamless_segment(Handle, start, stop, time);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool NewSegment(Gst.Segment segment) {
			IntPtr native_segment = GLib.Marshaller.StructureToPtrAlloc (segment);
			bool raw_ret = gst_base_src_new_segment(Handle, native_segment);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_segment);
			return ret;
		}

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_base_src_query_latency(IntPtr raw, out bool live, out ulong min_latency, out ulong max_latency);

		public bool QueryLatency(out bool live, out ulong min_latency, out ulong max_latency) {
			bool raw_ret = gst_base_src_query_latency(Handle, out live, out min_latency, out max_latency);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_set_async(IntPtr raw, bool async);

		public bool Async { 
			set {
				gst_base_src_set_async(Handle, value);
			}
		}

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_set_automatic_eos(IntPtr raw, bool automatic_eos);

		public bool AutomaticEos { 
			set {
				gst_base_src_set_automatic_eos(Handle, value);
			}
		}

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

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

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_set_dynamic_size(IntPtr raw, bool dynamic);

		public bool DynamicSize { 
			set {
				gst_base_src_set_dynamic_size(Handle, value);
			}
		}

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_set_format(IntPtr raw, int format);

		public Gst.Format Format { 
			set {
				gst_base_src_set_format(Handle, (int) value);
			}
		}

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_set_live(IntPtr raw, bool live);

		public bool Live { 
			set {
				gst_base_src_set_live(Handle, value);
			}
		}

		[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_base_src_start_complete(IntPtr raw, int _ret);

		public void StartComplete(Gst.FlowReturn _ret) {
			gst_base_src_start_complete(Handle, (int) _ret);
		}

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

		public Gst.FlowReturn StartWait() {
			int raw_ret = gst_base_src_start_wait(Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}

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

		public void SubmitBufferList(Gst.BufferList buffer_list) {
			buffer_list.Owned = false;
			gst_base_src_submit_buffer_list(Handle, buffer_list == null ? IntPtr.Zero : buffer_list.Handle);
		}

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

		public Gst.FlowReturn WaitPlaying() {
			int raw_ret = gst_base_src_wait_playing(Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}


		static BaseSrc ()
		{
			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("srcpad"
							, Gst.Element.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // srcpad
							, null
							, "live_lock"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("live_lock"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // live_lock
							, "srcpad"
							, "live_cond"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("live_cond"
							, -1
							, (uint) Marshal.SizeOf(typeof(GLib.Cond.ABI)) // live_cond
							, "live_lock"
							, "is_live"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_live_condAlign), "live_cond")
							, 0
							),
						new GLib.AbiField("is_live"
							, -1
							, (uint) Marshal.SizeOf(typeof(bool)) // is_live
							, "live_cond"
							, "live_running"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_is_liveAlign), "is_live")
							, 0
							),
						new GLib.AbiField("live_running"
							, -1
							, (uint) Marshal.SizeOf(typeof(bool)) // live_running
							, "is_live"
							, "blocksize"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_live_runningAlign), "live_running")
							, 0
							),
						new GLib.AbiField("blocksize"
							, -1
							, (uint) Marshal.SizeOf(typeof(uint)) // blocksize
							, "live_running"
							, "can_activate_push"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_blocksizeAlign), "blocksize")
							, 0
							),
						new GLib.AbiField("can_activate_push"
							, -1
							, (uint) Marshal.SizeOf(typeof(bool)) // can_activate_push
							, "blocksize"
							, "random_access"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_can_activate_pushAlign), "can_activate_push")
							, 0
							),
						new GLib.AbiField("random_access"
							, -1
							, (uint) Marshal.SizeOf(typeof(bool)) // random_access
							, "can_activate_push"
							, "clock_id"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_random_accessAlign), "random_access")
							, 0
							),
						new GLib.AbiField("clock_id"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // clock_id
							, "random_access"
							, "segment"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("segment"
							, -1
							, (uint) Marshal.SizeOf(typeof(Gst.Segment)) // segment
							, "clock_id"
							, "need_newsegment"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_segmentAlign), "segment")
							, 0
							),
						new GLib.AbiField("need_newsegment"
							, -1
							, (uint) Marshal.SizeOf(typeof(bool)) // need_newsegment
							, "segment"
							, "num_buffers"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_need_newsegmentAlign), "need_newsegment")
							, 0
							),
						new GLib.AbiField("num_buffers"
							, -1
							, (uint) Marshal.SizeOf(typeof(int)) // num_buffers
							, "need_newsegment"
							, "num_buffers_left"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_num_buffersAlign), "num_buffers")
							, 0
							),
						new GLib.AbiField("num_buffers_left"
							, -1
							, (uint) Marshal.SizeOf(typeof(int)) // num_buffers_left
							, "num_buffers"
							, "typefind"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_num_buffers_leftAlign), "num_buffers_left")
							, 0
							),
						new GLib.AbiField("typefind"
							, -1
							, (uint) Marshal.SizeOf(typeof(bool)) // typefind
							, "num_buffers_left"
							, "running"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_typefindAlign), "typefind")
							, 0
							),
						new GLib.AbiField("running"
							, -1
							, (uint) Marshal.SizeOf(typeof(bool)) // running
							, "typefind"
							, "pending_seek"
							, (long) Marshal.OffsetOf(typeof(GstBaseSrc_runningAlign), "running")
							, 0
							),
						new GLib.AbiField("pending_seek"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pending_seek
							, "running"
							, "priv"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("priv"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
							, "pending_seek"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _gst_reserved
							, "priv"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _abi_info;
			}
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_live_condAlign
		{
			sbyte f1;
			private GLib.Cond.ABI live_cond;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_is_liveAlign
		{
			sbyte f1;
			private bool is_live;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_live_runningAlign
		{
			sbyte f1;
			private bool live_running;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_blocksizeAlign
		{
			sbyte f1;
			private uint blocksize;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_can_activate_pushAlign
		{
			sbyte f1;
			private bool can_activate_push;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_random_accessAlign
		{
			sbyte f1;
			private bool random_access;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_segmentAlign
		{
			sbyte f1;
			private Gst.Segment segment;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_need_newsegmentAlign
		{
			sbyte f1;
			private bool need_newsegment;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_num_buffersAlign
		{
			sbyte f1;
			private int num_buffers;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_num_buffers_leftAlign
		{
			sbyte f1;
			private int num_buffers_left;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_typefindAlign
		{
			sbyte f1;
			private bool typefind;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstBaseSrc_runningAlign
		{
			sbyte f1;
			private bool running;
		}


		// End of the ABI representation.

#endregion
	}
}