gstreamer/sources/generated/Gst/Clock.cs

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

namespace Gst {

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

#region Autogenerated code
	public partial class Clock : Gst.Object {

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

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

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

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_clock_set_timeout(IntPtr raw, ulong timeout);

		[GLib.Property ("timeout")]
		public ulong Timeout {
			get  {
				ulong raw_ret = gst_clock_get_timeout(Handle);
				ulong ret = raw_ret;
				return ret;
			}
			set  {
				gst_clock_set_timeout(Handle, value);
			}
		}

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

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

		[GLib.Signal("synced")]
		public event Gst.SyncedHandler Synced {
			add {
				this.AddSignalHandler ("synced", value, typeof (Gst.SyncedArgs));
			}
			remove {
				this.RemoveSignalHandler ("synced", value);
			}
		}

		static SyncedNativeDelegate Synced_cb_delegate;
		static SyncedNativeDelegate SyncedVMCallback {
			get {
				if (Synced_cb_delegate == null)
					Synced_cb_delegate = new SyncedNativeDelegate (Synced_cb);
				return Synced_cb_delegate;
			}
		}

		static void OverrideSynced (GLib.GType gtype)
		{
			OverrideSynced (gtype, SyncedVMCallback);
		}

		static void OverrideSynced (GLib.GType gtype, SyncedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "synced", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SyncedNativeDelegate (IntPtr inst, bool synced);

		static void Synced_cb (IntPtr inst, bool synced)
		{
			try {
				Clock __obj = GLib.Object.GetObject (inst, false) as Clock;
				__obj.OnSynced (synced);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Clock), ConnectionMethod="OverrideSynced")]
		protected virtual void OnSynced (bool synced)
		{
			InternalSynced (synced);
		}

		private void InternalSynced (bool synced)
		{
			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 (synced);
			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 ChangeResolutionNativeDelegate ChangeResolution_cb_delegate;
		static ChangeResolutionNativeDelegate ChangeResolutionVMCallback {
			get {
				if (ChangeResolution_cb_delegate == null)
					ChangeResolution_cb_delegate = new ChangeResolutionNativeDelegate (ChangeResolution_cb);
				return ChangeResolution_cb_delegate;
			}
		}

		static void OverrideChangeResolution (GLib.GType gtype)
		{
			OverrideChangeResolution (gtype, ChangeResolutionVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate ulong ChangeResolutionNativeDelegate (IntPtr inst, ulong old_resolution, ulong new_resolution);

		static ulong ChangeResolution_cb (IntPtr inst, ulong old_resolution, ulong new_resolution)
		{
			try {
				Clock __obj = GLib.Object.GetObject (inst, false) as Clock;
				ulong __result;
				__result = __obj.OnChangeResolution (old_resolution, new_resolution);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Clock), ConnectionMethod="OverrideChangeResolution")]
		protected virtual ulong OnChangeResolution (ulong old_resolution, ulong new_resolution)
		{
			return InternalChangeResolution (old_resolution, new_resolution);
		}

		private ulong InternalChangeResolution (ulong old_resolution, ulong new_resolution)
		{
			ChangeResolutionNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("change_resolution"));
				unmanaged = (ChangeResolutionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChangeResolutionNativeDelegate));
			}
			if (unmanaged == null) return 0;

			ulong __result = unmanaged (this.Handle, old_resolution, new_resolution);
			return __result;
		}

		static GetResolutionNativeDelegate GetResolution_cb_delegate;
		static GetResolutionNativeDelegate GetResolutionVMCallback {
			get {
				if (GetResolution_cb_delegate == null)
					GetResolution_cb_delegate = new GetResolutionNativeDelegate (GetResolution_cb);
				return GetResolution_cb_delegate;
			}
		}

		static void OverrideGetResolution (GLib.GType gtype)
		{
			OverrideGetResolution (gtype, GetResolutionVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate ulong GetResolutionNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Clock), ConnectionMethod="OverrideGetResolution")]
		protected virtual ulong OnGetResolution ()
		{
			return InternalGetResolution ();
		}

		private ulong InternalGetResolution ()
		{
			GetResolutionNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_resolution"));
				unmanaged = (GetResolutionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetResolutionNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static GetInternalTimeNativeDelegate GetInternalTime_cb_delegate;
		static GetInternalTimeNativeDelegate GetInternalTimeVMCallback {
			get {
				if (GetInternalTime_cb_delegate == null)
					GetInternalTime_cb_delegate = new GetInternalTimeNativeDelegate (GetInternalTime_cb);
				return GetInternalTime_cb_delegate;
			}
		}

		static void OverrideGetInternalTime (GLib.GType gtype)
		{
			OverrideGetInternalTime (gtype, GetInternalTimeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate ulong GetInternalTimeNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Clock), ConnectionMethod="OverrideGetInternalTime")]
		protected virtual ulong OnGetInternalTime ()
		{
			return InternalGetInternalTime ();
		}

		private ulong InternalGetInternalTime ()
		{
			GetInternalTimeNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_internal_time"));
				unmanaged = (GetInternalTimeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetInternalTimeNativeDelegate));
			}
			if (unmanaged == null) return 0;

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

		static WaitNativeDelegate Wait_cb_delegate;
		static WaitNativeDelegate WaitVMCallback {
			get {
				if (Wait_cb_delegate == null)
					Wait_cb_delegate = new WaitNativeDelegate (Wait_cb);
				return Wait_cb_delegate;
			}
		}

		static void OverrideWait (GLib.GType gtype)
		{
			OverrideWait (gtype, WaitVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int WaitNativeDelegate (IntPtr inst, IntPtr entry, long jitter);

		static int Wait_cb (IntPtr inst, IntPtr entry, long jitter)
		{
			try {
				Clock __obj = GLib.Object.GetObject (inst, false) as Clock;
				Gst.ClockReturn __result;
				__result = __obj.OnWait (entry == IntPtr.Zero ? null : (Gst.ClockEntry) GLib.Opaque.GetOpaque (entry, typeof (Gst.ClockEntry), false), jitter);
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Clock), ConnectionMethod="OverrideWait")]
		protected virtual Gst.ClockReturn OnWait (Gst.ClockEntry entry, long jitter)
		{
			return InternalWait (entry, jitter);
		}

		private Gst.ClockReturn InternalWait (Gst.ClockEntry entry, long jitter)
		{
			WaitNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("wait"));
				unmanaged = (WaitNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(WaitNativeDelegate));
			}
			if (unmanaged == null) return (Gst.ClockReturn) 0;

			int __result = unmanaged (this.Handle, entry == null ? IntPtr.Zero : entry.Handle, jitter);
			return (Gst.ClockReturn) __result;
		}

		static WaitAsyncNativeDelegate WaitAsync_cb_delegate;
		static WaitAsyncNativeDelegate WaitAsyncVMCallback {
			get {
				if (WaitAsync_cb_delegate == null)
					WaitAsync_cb_delegate = new WaitAsyncNativeDelegate (WaitAsync_cb);
				return WaitAsync_cb_delegate;
			}
		}

		static void OverrideWaitAsync (GLib.GType gtype)
		{
			OverrideWaitAsync (gtype, WaitAsyncVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int WaitAsyncNativeDelegate (IntPtr inst, IntPtr entry);

		static int WaitAsync_cb (IntPtr inst, IntPtr entry)
		{
			try {
				Clock __obj = GLib.Object.GetObject (inst, false) as Clock;
				Gst.ClockReturn __result;
				__result = __obj.OnWaitAsync (entry == IntPtr.Zero ? null : (Gst.ClockEntry) GLib.Opaque.GetOpaque (entry, typeof (Gst.ClockEntry), 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.Clock), ConnectionMethod="OverrideWaitAsync")]
		protected virtual Gst.ClockReturn OnWaitAsync (Gst.ClockEntry entry)
		{
			return InternalWaitAsync (entry);
		}

		private Gst.ClockReturn InternalWaitAsync (Gst.ClockEntry entry)
		{
			WaitAsyncNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("wait_async"));
				unmanaged = (WaitAsyncNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(WaitAsyncNativeDelegate));
			}
			if (unmanaged == null) return (Gst.ClockReturn) 0;

			int __result = unmanaged (this.Handle, entry == null ? IntPtr.Zero : entry.Handle);
			return (Gst.ClockReturn) __result;
		}

		static UnscheduleNativeDelegate Unschedule_cb_delegate;
		static UnscheduleNativeDelegate UnscheduleVMCallback {
			get {
				if (Unschedule_cb_delegate == null)
					Unschedule_cb_delegate = new UnscheduleNativeDelegate (Unschedule_cb);
				return Unschedule_cb_delegate;
			}
		}

		static void OverrideUnschedule (GLib.GType gtype)
		{
			OverrideUnschedule (gtype, UnscheduleVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void UnscheduleNativeDelegate (IntPtr inst, IntPtr entry);

		static void Unschedule_cb (IntPtr inst, IntPtr entry)
		{
			try {
				Clock __obj = GLib.Object.GetObject (inst, false) as Clock;
				__obj.OnUnschedule (entry == IntPtr.Zero ? null : (Gst.ClockEntry) GLib.Opaque.GetOpaque (entry, typeof (Gst.ClockEntry), false));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Clock), ConnectionMethod="OverrideUnschedule")]
		protected virtual void OnUnschedule (Gst.ClockEntry entry)
		{
			InternalUnschedule (entry);
		}

		private void InternalUnschedule (Gst.ClockEntry entry)
		{
			UnscheduleNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unschedule"));
				unmanaged = (UnscheduleNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnscheduleNativeDelegate));
			}
			if (unmanaged == null) return;

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


		// 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("change_resolution"
							, Gst.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // change_resolution
							, null
							, "get_resolution"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_resolution"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_resolution
							, "change_resolution"
							, "get_internal_time"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_internal_time"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_internal_time
							, "get_resolution"
							, "wait"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("wait"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // wait
							, "get_internal_time"
							, "wait_async"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("wait_async"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // wait_async
							, "wait"
							, "unschedule"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unschedule"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unschedule
							, "wait_async"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
							, "unschedule"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

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

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_clock_id_compare_func(IntPtr id1, IntPtr id2);

		public static int IdCompareFunc(IntPtr id1, IntPtr id2) {
			int raw_ret = gst_clock_id_compare_func(id1, id2);
			int ret = raw_ret;
			return ret;
		}

		public static int IdCompareFunc() {
			return IdCompareFunc (IntPtr.Zero, IntPtr.Zero);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_clock_id_get_clock(IntPtr id);

		public static Gst.Clock IdGetClock(IntPtr id) {
			IntPtr raw_ret = gst_clock_id_get_clock(id);
			Gst.Clock ret = GLib.Object.GetObject(raw_ret, true) as Gst.Clock;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern ulong gst_clock_id_get_time(IntPtr id);

		public static ulong IdGetTime(IntPtr id) {
			ulong raw_ret = gst_clock_id_get_time(id);
			ulong ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_clock_id_ref(IntPtr id);

		public static IntPtr IdRef(IntPtr id) {
			IntPtr raw_ret = gst_clock_id_ref(id);
			IntPtr ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_clock_id_unref(IntPtr id);

		public static void IdUnref(IntPtr id) {
			gst_clock_id_unref(id);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_clock_id_unschedule(IntPtr id);

		public static void IdUnschedule(IntPtr id) {
			gst_clock_id_unschedule(id);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_clock_id_uses_clock(IntPtr id, IntPtr clock);

		public static bool IdUsesClock(IntPtr id, Gst.Clock clock) {
			bool raw_ret = gst_clock_id_uses_clock(id, clock == null ? IntPtr.Zero : clock.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_clock_id_wait(IntPtr id, out long jitter);

		public static Gst.ClockReturn IdWait(IntPtr id, out long jitter) {
			int raw_ret = gst_clock_id_wait(id, out jitter);
			Gst.ClockReturn ret = (Gst.ClockReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_clock_id_wait_async(IntPtr id, GstSharp.ClockCallbackNative func, IntPtr user_data, GLib.DestroyNotify destroy_data);

		public static Gst.ClockReturn IdWaitAsync(IntPtr id, Gst.ClockCallback func) {
			GstSharp.ClockCallbackWrapper func_wrapper = new GstSharp.ClockCallbackWrapper (func);
			IntPtr user_data;
			GLib.DestroyNotify destroy_data;
			if (func == null) {
				user_data = IntPtr.Zero;
				destroy_data = null;
			} else {
				user_data = (IntPtr) GCHandle.Alloc (func_wrapper);
				destroy_data = GLib.DestroyHelper.NotifyHandler;
			}
			int raw_ret = gst_clock_id_wait_async(id, func_wrapper.NativeDelegate, user_data, destroy_data);
			Gst.ClockReturn ret = (Gst.ClockReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_clock_add_observation(IntPtr raw, ulong slave, ulong master, out double r_squared);

		public bool AddObservation(ulong slave, ulong master, out double r_squared) {
			bool raw_ret = gst_clock_add_observation(Handle, slave, master, out r_squared);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_clock_add_observation_unapplied(IntPtr raw, ulong slave, ulong master, out double r_squared, out ulong _internal, out ulong external, out ulong rate_num, out ulong rate_denom);

		public bool AddObservationUnapplied(ulong slave, ulong master, out double r_squared, out ulong _internal, out ulong external, out ulong rate_num, out ulong rate_denom) {
			bool raw_ret = gst_clock_add_observation_unapplied(Handle, slave, master, out r_squared, out _internal, out external, out rate_num, out rate_denom);
			bool ret = raw_ret;
			return ret;
		}

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

		public ulong AdjustUnlocked(ulong _internal) {
			ulong raw_ret = gst_clock_adjust_unlocked(Handle, _internal);
			ulong ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern ulong gst_clock_adjust_with_calibration(IntPtr raw, ulong internal_target, ulong cinternal, ulong cexternal, ulong cnum, ulong cdenom);

		public ulong AdjustWithCalibration(ulong internal_target, ulong cinternal, ulong cexternal, ulong cnum, ulong cdenom) {
			ulong raw_ret = gst_clock_adjust_with_calibration(Handle, internal_target, cinternal, cexternal, cnum, cdenom);
			ulong ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_clock_get_calibration(IntPtr raw, out ulong _internal, out ulong external, out ulong rate_num, out ulong rate_denom);

		public void GetCalibration(out ulong _internal, out ulong external, out ulong rate_num, out ulong rate_denom) {
			gst_clock_get_calibration(Handle, out _internal, out external, out rate_num, out rate_denom);
		}

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

		public ulong InternalTime { 
			get {
				ulong raw_ret = gst_clock_get_internal_time(Handle);
				ulong ret = raw_ret;
				return ret;
			}
		}

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

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

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

		public ulong Resolution { 
			get {
				ulong raw_ret = gst_clock_get_resolution(Handle);
				ulong ret = raw_ret;
				return ret;
			}
		}

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

		public ulong Time { 
			get {
				ulong raw_ret = gst_clock_get_time(Handle);
				ulong ret = raw_ret;
				return ret;
			}
		}

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

		public bool IsSynced { 
			get {
				bool raw_ret = gst_clock_is_synced(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_clock_new_periodic_id(IntPtr raw, ulong start_time, ulong interval);

		public IntPtr NewPeriodicId(ulong start_time, ulong interval) {
			IntPtr raw_ret = gst_clock_new_periodic_id(Handle, start_time, interval);
			IntPtr ret = raw_ret;
			return ret;
		}

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

		public IntPtr NewSingleShotId(ulong time) {
			IntPtr raw_ret = gst_clock_new_single_shot_id(Handle, time);
			IntPtr ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_clock_periodic_id_reinit(IntPtr raw, IntPtr id, ulong start_time, ulong interval);

		public bool PeriodicIdReinit(IntPtr id, ulong start_time, ulong interval) {
			bool raw_ret = gst_clock_periodic_id_reinit(Handle, id, start_time, interval);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_clock_set_calibration(IntPtr raw, ulong _internal, ulong external, ulong rate_num, ulong rate_denom);

		public void SetCalibration(ulong _internal, ulong external, ulong rate_num, ulong rate_denom) {
			gst_clock_set_calibration(Handle, _internal, external, rate_num, rate_denom);
		}

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

		public bool SetMaster(Gst.Clock master) {
			bool raw_ret = gst_clock_set_master(Handle, master == null ? IntPtr.Zero : master.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

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

		public ulong SetResolution(ulong resolution) {
			ulong raw_ret = gst_clock_set_resolution(Handle, resolution);
			ulong ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_clock_set_synced(IntPtr raw, bool synced);

		public void is_synced(bool synced) {
			gst_clock_set_synced(Handle, synced);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_clock_single_shot_id_reinit(IntPtr raw, IntPtr id, ulong time);

		public bool SingleShotIdReinit(IntPtr id, ulong time) {
			bool raw_ret = gst_clock_single_shot_id_reinit(Handle, id, time);
			bool ret = raw_ret;
			return ret;
		}

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

		public ulong UnadjustUnlocked(ulong external) {
			ulong raw_ret = gst_clock_unadjust_unlocked(Handle, external);
			ulong ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern ulong gst_clock_unadjust_with_calibration(IntPtr raw, ulong external_target, ulong cinternal, ulong cexternal, ulong cnum, ulong cdenom);

		public ulong UnadjustWithCalibration(ulong external_target, ulong cinternal, ulong cexternal, ulong cnum, ulong cdenom) {
			ulong raw_ret = gst_clock_unadjust_with_calibration(Handle, external_target, cinternal, cexternal, cnum, cdenom);
			ulong ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_clock_wait_for_sync(IntPtr raw, ulong timeout);

		public bool WaitForSync(ulong timeout) {
			bool raw_ret = gst_clock_wait_for_sync(Handle, timeout);
			bool ret = raw_ret;
			return ret;
		}


		// 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"
							, Gst.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
	}
}