context: // This file was generated by the Gtk# code generator.
  // Any changes made will be lost if regenerated.
  
  namespace Gst.Audio {
  
  	using System;
  	using System.Collections;
  	using System.Collections.Generic;
  	using System.Runtime.InteropServices;
  
  #region Autogenerated code
  	public partial class AudioRingBuffer : Gst.Object {
  
  		protected AudioRingBuffer (IntPtr raw) : base(raw) {}
  
  		protected AudioRingBuffer() : base(IntPtr.Zero)
  		{
  			CreateNativeObject (new string [0], new GLib.Value [0]);
  		}
  
  		public GLib.Cond Cond {
  			get {
  				unsafe {
  					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("cond"));
  					return new GLib.Cond((*raw_ptr));
  				}
  			}
  		}
  
  		public bool Open {
  			get {
  				unsafe {
  					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("open"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public bool Acquired {
  			get {
  				unsafe {
  					bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("acquired"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public byte Memory {
  			get {
  				unsafe {
  					byte* raw_ptr = (byte*)(((byte*)Handle) + abi_info.GetFieldOffset("memory"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public ulong Size {
  			get {
  				unsafe {
  					UIntPtr* raw_ptr = (UIntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("size"));
  					return (ulong) (*raw_ptr);
  				}
  			}
  		}
  
  		public Gst.Audio.AudioRingBufferSpec Spec {
  			get {
  				unsafe {
  					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("spec"));
  					return (*raw_ptr) == IntPtr.Zero ? null : (Gst.Audio.AudioRingBufferSpec) GLib.Opaque.GetOpaque ((*raw_ptr), typeof (Gst.Audio.AudioRingBufferSpec), false);
  				}
  			}
  		}
  
  		public int SamplesPerSeg {
  			get {
  				unsafe {
  					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("samples_per_seg"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public byte EmptySeg {
  			get {
  				unsafe {
  					byte* raw_ptr = (byte*)(((byte*)Handle) + abi_info.GetFieldOffset("empty_seg"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public int State {
  			get {
  				unsafe {
  					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("state"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public int Segdone {
  			get {
  				unsafe {
  					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("segdone"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public int Segbase {
  			get {
  				unsafe {
  					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("segbase"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public int Waiting {
  			get {
  				unsafe {
  					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("waiting"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_set_flushing(IntPtr raw, bool flushing);
  
  		public bool Flushing {
  			set  {
  				gst_audio_ring_buffer_set_flushing(Handle, value);
  			}
  		}
  
  		static OpenDeviceNativeDelegate OpenDevice_cb_delegate;
  		static OpenDeviceNativeDelegate OpenDeviceVMCallback {
  			get {
  				if (OpenDevice_cb_delegate == null)
  					OpenDevice_cb_delegate = new OpenDeviceNativeDelegate (OpenDevice_cb);
  				return OpenDevice_cb_delegate;
  			}
  		}
  
  		static void OverrideOpenDevice (GLib.GType gtype)
  		{
  			OverrideOpenDevice (gtype, OpenDeviceVMCallback);
  		}
  
  		static void OverrideOpenDevice (GLib.GType gtype, OpenDeviceNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("open_device"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool OpenDeviceNativeDelegate (IntPtr inst);
  
  		static bool OpenDevice_cb (IntPtr inst)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				bool __result;
  				__result = __obj.OnOpenDevice ();
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideOpenDevice")]
  		protected virtual bool OnOpenDevice ()
  		{
  			return InternalOpenDevice ();
  		}
  
  		private bool InternalOpenDevice ()
  		{
  			OpenDeviceNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("open_device"));
  				unmanaged = (OpenDeviceNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(OpenDeviceNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle);
  			return __result;
  		}
  
  		static AcquireNativeDelegate Acquire_cb_delegate;
  		static AcquireNativeDelegate AcquireVMCallback {
  			get {
  				if (Acquire_cb_delegate == null)
  					Acquire_cb_delegate = new AcquireNativeDelegate (Acquire_cb);
  				return Acquire_cb_delegate;
  			}
  		}
  
  		static void OverrideAcquire (GLib.GType gtype)
  		{
  			OverrideAcquire (gtype, AcquireVMCallback);
  		}
  
  		static void OverrideAcquire (GLib.GType gtype, AcquireNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("acquire"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool AcquireNativeDelegate (IntPtr inst, IntPtr spec);
  
  		static bool Acquire_cb (IntPtr inst, IntPtr spec)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				bool __result;
  				__result = __obj.OnAcquire (spec == IntPtr.Zero ? null : (Gst.Audio.AudioRingBufferSpec) GLib.Opaque.GetOpaque (spec, typeof (Gst.Audio.AudioRingBufferSpec), false));
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideAcquire")]
  		protected virtual bool OnAcquire (Gst.Audio.AudioRingBufferSpec spec)
  		{
  			return InternalAcquire (spec);
  		}
  
  		private bool InternalAcquire (Gst.Audio.AudioRingBufferSpec spec)
  		{
  			AcquireNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("acquire"));
  				unmanaged = (AcquireNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AcquireNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle, spec == null ? IntPtr.Zero : spec.Handle);
  			return __result;
  		}
  
  		static ReleaseNativeDelegate Release_cb_delegate;
  		static ReleaseNativeDelegate ReleaseVMCallback {
  			get {
  				if (Release_cb_delegate == null)
  					Release_cb_delegate = new ReleaseNativeDelegate (Release_cb);
  				return Release_cb_delegate;
  			}
  		}
  
  		static void OverrideRelease (GLib.GType gtype)
  		{
  			OverrideRelease (gtype, ReleaseVMCallback);
  		}
  
  		static void OverrideRelease (GLib.GType gtype, ReleaseNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("release"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool ReleaseNativeDelegate (IntPtr inst);
  
  		static bool Release_cb (IntPtr inst)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				bool __result;
  				__result = __obj.OnRelease ();
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideRelease")]
  		protected virtual bool OnRelease ()
  		{
  			return InternalRelease ();
  		}
  
  		private bool InternalRelease ()
  		{
  			ReleaseNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("release"));
  				unmanaged = (ReleaseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ReleaseNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle);
  			return __result;
  		}
  
  		static CloseDeviceNativeDelegate CloseDevice_cb_delegate;
  		static CloseDeviceNativeDelegate CloseDeviceVMCallback {
  			get {
  				if (CloseDevice_cb_delegate == null)
  					CloseDevice_cb_delegate = new CloseDeviceNativeDelegate (CloseDevice_cb);
  				return CloseDevice_cb_delegate;
  			}
  		}
  
  		static void OverrideCloseDevice (GLib.GType gtype)
  		{
  			OverrideCloseDevice (gtype, CloseDeviceVMCallback);
  		}
  
  		static void OverrideCloseDevice (GLib.GType gtype, CloseDeviceNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("close_device"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool CloseDeviceNativeDelegate (IntPtr inst);
  
  		static bool CloseDevice_cb (IntPtr inst)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				bool __result;
  				__result = __obj.OnCloseDevice ();
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideCloseDevice")]
  		protected virtual bool OnCloseDevice ()
  		{
  			return InternalCloseDevice ();
  		}
  
  		private bool InternalCloseDevice ()
  		{
  			CloseDeviceNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("close_device"));
  				unmanaged = (CloseDeviceNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CloseDeviceNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.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 {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				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.Audio.AudioRingBuffer), 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 PauseNativeDelegate Pause_cb_delegate;
  		static PauseNativeDelegate PauseVMCallback {
  			get {
  				if (Pause_cb_delegate == null)
  					Pause_cb_delegate = new PauseNativeDelegate (Pause_cb);
  				return Pause_cb_delegate;
  			}
  		}
  
  		static void OverridePause (GLib.GType gtype)
  		{
  			OverridePause (gtype, PauseVMCallback);
  		}
  
  		static void OverridePause (GLib.GType gtype, PauseNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pause"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool PauseNativeDelegate (IntPtr inst);
  
  		static bool Pause_cb (IntPtr inst)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				bool __result;
  				__result = __obj.OnPause ();
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverridePause")]
  		protected virtual bool OnPause ()
  		{
  			return InternalPause ();
  		}
  
  		private bool InternalPause ()
  		{
  			PauseNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pause"));
  				unmanaged = (PauseNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PauseNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle);
  			return __result;
  		}
  
  		static ResumeNativeDelegate Resume_cb_delegate;
  		static ResumeNativeDelegate ResumeVMCallback {
  			get {
  				if (Resume_cb_delegate == null)
  					Resume_cb_delegate = new ResumeNativeDelegate (Resume_cb);
  				return Resume_cb_delegate;
  			}
  		}
  
  		static void OverrideResume (GLib.GType gtype)
  		{
  			OverrideResume (gtype, ResumeVMCallback);
  		}
  
  		static void OverrideResume (GLib.GType gtype, ResumeNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("resume"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool ResumeNativeDelegate (IntPtr inst);
  
  		static bool Resume_cb (IntPtr inst)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				bool __result;
  				__result = __obj.OnResume ();
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideResume")]
  		protected virtual bool OnResume ()
  		{
  			return InternalResume ();
  		}
  
  		private bool InternalResume ()
  		{
  			ResumeNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("resume"));
  				unmanaged = (ResumeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ResumeNativeDelegate));
  			}
  			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 {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				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.Audio.AudioRingBuffer), 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 DelayNativeDelegate Delay_cb_delegate;
  		static DelayNativeDelegate DelayVMCallback {
  			get {
  				if (Delay_cb_delegate == null)
  					Delay_cb_delegate = new DelayNativeDelegate (Delay_cb);
  				return Delay_cb_delegate;
  			}
  		}
  
  		static void OverrideDelay (GLib.GType gtype)
  		{
  			OverrideDelay (gtype, DelayVMCallback);
  		}
  
  		static void OverrideDelay (GLib.GType gtype, DelayNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("delay"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate uint DelayNativeDelegate (IntPtr inst);
  
  		static uint Delay_cb (IntPtr inst)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				uint __result;
  				__result = __obj.OnDelay ();
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideDelay")]
  		protected virtual uint OnDelay ()
  		{
  			return InternalDelay ();
  		}
  
  		private uint InternalDelay ()
  		{
  			DelayNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("delay"));
  				unmanaged = (DelayNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DelayNativeDelegate));
  			}
  			if (unmanaged == null) return 0;
  
  			uint __result = unmanaged (this.Handle);
  			return __result;
  		}
  
  		static ActivateNativeDelegate Activate_cb_delegate;
  		static ActivateNativeDelegate ActivateVMCallback {
  			get {
  				if (Activate_cb_delegate == null)
  					Activate_cb_delegate = new ActivateNativeDelegate (Activate_cb);
  				return Activate_cb_delegate;
  			}
  		}
  
  		static void OverrideActivate (GLib.GType gtype)
  		{
  			OverrideActivate (gtype, ActivateVMCallback);
  		}
  
  		static void OverrideActivate (GLib.GType gtype, ActivateNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("activate"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool ActivateNativeDelegate (IntPtr inst, bool active);
  
  		static bool Activate_cb (IntPtr inst, bool active)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				bool __result;
  				__result = __obj.OnActivate (active);
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideActivate")]
  		protected virtual bool OnActivate (bool active)
  		{
  			return InternalActivate (active);
  		}
  
  		private bool InternalActivate (bool active)
  		{
  			ActivateNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("activate"));
  				unmanaged = (ActivateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ActivateNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle, active);
  			return __result;
  		}
  
  		static CommitNativeDelegate Commit_cb_delegate;
  		static CommitNativeDelegate CommitVMCallback {
  			get {
  				if (Commit_cb_delegate == null)
  					Commit_cb_delegate = new CommitNativeDelegate (Commit_cb);
  				return Commit_cb_delegate;
  			}
  		}
  
  		static void OverrideCommit (GLib.GType gtype)
  		{
  			OverrideCommit (gtype, CommitVMCallback);
  		}
  
  		static void OverrideCommit (GLib.GType gtype, CommitNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("commit"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate uint CommitNativeDelegate (IntPtr inst, ulong sample, byte[] data, int in_samples, int out_samples, ref int accum);
  
  		static uint Commit_cb (IntPtr inst, ulong sample, byte[] data, int in_samples, int out_samples, ref int accum)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				uint __result;
  				__result = __obj.OnCommit (sample, data, in_samples, out_samples, ref accum);
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideCommit")]
  		protected virtual uint OnCommit (ulong sample, byte[] data, int in_samples, int out_samples, ref int accum)
  		{
  			return InternalCommit (sample, data, in_samples, out_samples, ref accum);
  		}
  
  		private uint InternalCommit (ulong sample, byte[] data, int in_samples, int out_samples, ref int accum)
  		{
  			CommitNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("commit"));
  				unmanaged = (CommitNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CommitNativeDelegate));
  			}
  			if (unmanaged == null) return 0;
  
  			uint __result = unmanaged (this.Handle, sample, data, in_samples, out_samples, ref accum);
  			return __result;
  		}
  
  		static ClearAllNativeDelegate ClearAll_cb_delegate;
  		static ClearAllNativeDelegate ClearAllVMCallback {
  			get {
  				if (ClearAll_cb_delegate == null)
  					ClearAll_cb_delegate = new ClearAllNativeDelegate (ClearAll_cb);
  				return ClearAll_cb_delegate;
  			}
  		}
  
  		static void OverrideClearAll (GLib.GType gtype)
  		{
  			OverrideClearAll (gtype, ClearAllVMCallback);
  		}
  
  		static void OverrideClearAll (GLib.GType gtype, ClearAllNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("clear_all"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void ClearAllNativeDelegate (IntPtr inst);
  
  		static void ClearAll_cb (IntPtr inst)
  		{
  			try {
  				AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
  				__obj.OnClearAll ();
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Audio.AudioRingBuffer), ConnectionMethod="OverrideClearAll")]
  		protected virtual void OnClearAll ()
  		{
  			InternalClearAll ();
  		}
  
  		private void InternalClearAll ()
  		{
  			ClearAllNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("clear_all"));
  				unmanaged = (ClearAllNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ClearAllNativeDelegate));
  			}
  			if (unmanaged == null) return;
  
  			unmanaged (this.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("open_device"
  							, Gst.Object.class_abi.Fields
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // open_device
  							, null
  							, "acquire"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("acquire"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // acquire
  							, "open_device"
  							, "release"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("release"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // release
  							, "acquire"
  							, "close_device"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("close_device"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // close_device
  							, "release"
  							, "start"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("start"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // start
  							, "close_device"
  							, "pause"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("pause"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pause
  							, "start"
  							, "resume"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("resume"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // resume
  							, "pause"
  							, "stop"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("stop"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // stop
  							, "resume"
  							, "delay"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("delay"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // delay
  							, "stop"
  							, "activate"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("activate"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // activate
  							, "delay"
  							, "commit"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("commit"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // commit
  							, "activate"
  							, "clear_all"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("clear_all"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // clear_all
  							, "commit"
  							, "_gst_reserved"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("_gst_reserved"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
  							, "clear_all"
  							, null
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  					});
  
  				return _class_abi;
  			}
  		}
  
  
  		// End of the ABI representation.
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gst_audio_ring_buffer_get_type();
  
  		public static new GLib.GType GType { 
  			get {
  				IntPtr raw_ret = gst_audio_ring_buffer_get_type();
  				GLib.GType ret = new GLib.GType(raw_ret);
  				return ret;
  			}
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_debug_spec_buff(IntPtr spec);
  
  		public static void DebugSpecBuff(Gst.Audio.AudioRingBufferSpec spec) {
  			gst_audio_ring_buffer_debug_spec_buff(spec == null ? IntPtr.Zero : spec.Handle);
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_debug_spec_caps(IntPtr spec);
  
  		public static void DebugSpecCaps(Gst.Audio.AudioRingBufferSpec spec) {
  			gst_audio_ring_buffer_debug_spec_caps(spec == null ? IntPtr.Zero : spec.Handle);
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_parse_caps(IntPtr spec, IntPtr caps);
  
  		public static bool ParseCaps(Gst.Audio.AudioRingBufferSpec spec, Gst.Caps caps) {
  			bool raw_ret = gst_audio_ring_buffer_parse_caps(spec == null ? IntPtr.Zero : spec.Handle, caps == null ? IntPtr.Zero : caps.Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_acquire(IntPtr raw, IntPtr spec);
  
  		public bool Acquire(Gst.Audio.AudioRingBufferSpec spec) {
  			bool raw_ret = gst_audio_ring_buffer_acquire(Handle, spec == null ? IntPtr.Zero : spec.Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_activate(IntPtr raw, bool active);
  
  		public bool Activate(bool active) {
  			bool raw_ret = gst_audio_ring_buffer_activate(Handle, active);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_advance(IntPtr raw, uint advance);
  
  		public void Advance(uint advance) {
  			gst_audio_ring_buffer_advance(Handle, advance);
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_clear(IntPtr raw, int segment);
  
  		public void Clear(int segment) {
  			gst_audio_ring_buffer_clear(Handle, segment);
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_clear_all(IntPtr raw);
  
  		public void ClearAll() {
  			gst_audio_ring_buffer_clear_all(Handle);
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_close_device(IntPtr raw);
  
  		public bool CloseDevice() {
  			bool raw_ret = gst_audio_ring_buffer_close_device(Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern uint gst_audio_ring_buffer_commit(IntPtr raw, ulong sample, byte[] data, int in_samples, int out_samples, ref int accum);
  
  		public uint Commit(ulong sample, byte[] data, int in_samples, int out_samples, ref int accum) {
  			uint raw_ret = gst_audio_ring_buffer_commit(Handle, sample, data, in_samples, out_samples, ref accum);
  			uint ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_convert(IntPtr raw, int src_fmt, long src_val, int dest_fmt, out long dest_val);
  
  		public bool Convert(Gst.Format src_fmt, long src_val, Gst.Format dest_fmt, out long dest_val) {
  			bool raw_ret = gst_audio_ring_buffer_convert(Handle, (int) src_fmt, src_val, (int) dest_fmt, out dest_val);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern uint gst_audio_ring_buffer_delay(IntPtr raw);
  
  		public uint Delay() {
  			uint raw_ret = gst_audio_ring_buffer_delay(Handle);
  			uint ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_device_is_open(IntPtr raw);
  
  		public bool DeviceIsOpen() {
  			bool raw_ret = gst_audio_ring_buffer_device_is_open(Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_is_acquired(IntPtr raw);
  
  		public bool IsAcquired { 
  			get {
  				bool raw_ret = gst_audio_ring_buffer_is_acquired(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_is_active(IntPtr raw);
  
  		public bool IsActive { 
  			get {
  				bool raw_ret = gst_audio_ring_buffer_is_active(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_is_flushing(IntPtr raw);
  
  		public bool IsFlushing { 
  			get {
  				bool raw_ret = gst_audio_ring_buffer_is_flushing(Handle);
  				bool ret = raw_ret;
  				return ret;
  			}
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_may_start(IntPtr raw, bool allowed);
  
  		public void MayStart(bool allowed) {
  			gst_audio_ring_buffer_may_start(Handle, allowed);
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_open_device(IntPtr raw);
  
  		public bool OpenDevice() {
  			bool raw_ret = gst_audio_ring_buffer_open_device(Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_pause(IntPtr raw);
  
  		public bool Pause() {
  			bool raw_ret = gst_audio_ring_buffer_pause(Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern uint gst_audio_ring_buffer_read(IntPtr raw, ulong sample, byte[] data, uint len, out ulong timestamp);
  
  		public uint Read(ulong sample, byte[] data, uint len, out ulong timestamp) {
  			uint raw_ret = gst_audio_ring_buffer_read(Handle, sample, data, len, out timestamp);
  			uint ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_release(IntPtr raw);
  
  		public bool Release() {
  			bool raw_ret = gst_audio_ring_buffer_release(Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern ulong gst_audio_ring_buffer_samples_done(IntPtr raw);
  
  		public ulong SamplesDone() {
  			ulong raw_ret = gst_audio_ring_buffer_samples_done(Handle);
  			ulong ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_set_callback_full(IntPtr raw, Gst.AudioSharp.AudioRingBufferCallbackNative cb, IntPtr user_data, GLib.DestroyNotify notify);
  
  		public Gst.Audio.AudioRingBufferCallback CallbackFull { 
  			set {
  				Gst.AudioSharp.AudioRingBufferCallbackWrapper value_wrapper = new Gst.AudioSharp.AudioRingBufferCallbackWrapper (value);
  				IntPtr user_data;
  				GLib.DestroyNotify notify;
  				if (value == null) {
  					user_data = IntPtr.Zero;
  					notify = null;
  				} else {
  					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
  					notify = GLib.DestroyHelper.NotifyHandler;
  				}
  				gst_audio_ring_buffer_set_callback_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
  			}
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_set_channel_positions(IntPtr raw, int[] position);
  
  		public Gst.Audio.AudioChannelPosition[] ChannelPositions { 
  			set {
  				int cnt_value = value == null ? 0 : value.Length;
  				int[] native_value = new int [cnt_value];
  				for (int i = 0; i < cnt_value; i++)
  					native_value [i] = (int) value[i];
  				gst_audio_ring_buffer_set_channel_positions(Handle, native_value);
  			}
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_set_sample(IntPtr raw, ulong sample);
  
  		public ulong Sample { 
  			set {
  				gst_audio_ring_buffer_set_sample(Handle, value);
  			}
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern void gst_audio_ring_buffer_set_timestamp(IntPtr raw, int readseg, ulong timestamp);
  
  		public void SetTimestamp(int readseg, ulong timestamp) {
  			gst_audio_ring_buffer_set_timestamp(Handle, readseg, timestamp);
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_start(IntPtr raw);
  
  		public bool Start() {
  			bool raw_ret = gst_audio_ring_buffer_start(Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  		[DllImport("libgstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern bool gst_audio_ring_buffer_stop(IntPtr raw);
  
  		public bool Stop() {
  			bool raw_ret = gst_audio_ring_buffer_stop(Handle);
  			bool ret = raw_ret;
  			return ret;
  		}
  
  
  		static AudioRingBuffer ()
  		{
  			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("cond"
  							, Gst.Object.abi_info.Fields
  							, (uint) Marshal.SizeOf(typeof(GLib.Cond.ABI)) // cond
  							, null
  							, "open"
  							, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_condAlign), "cond")
  							, 0
  							),
  						new GLib.AbiField("open"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(bool)) // open
  							, "cond"
  							, "acquired"
  							, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_openAlign), "open")
  							, 0
  							),
  						new GLib.AbiField("acquired"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(bool)) // acquired
  							, "open"
  							, "memory"
  							, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_acquiredAlign), "acquired")
  							, 0
  							),
  						new GLib.AbiField("memory"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(byte)) // memory
  							, "acquired"
  							, "size"
  							, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_memoryAlign), "memory")
  							, 0
  							),
  						new GLib.AbiField("size"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(ulong)) // size
  							, "memory"
  							, "timestamps"
  							, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_sizeAlign), "size")
  							, 0
  							),
  						new GLib.AbiField("timestamps"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(ulong)) // timestamps
  							, "size"
  							, "spec"
  							, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_timestampsAlign), "timestamps")
  							, 0
  							),
  						new GLib.AbiField("spec"
  							, -1
  							, Gst.Audio.AudioRingBufferSpec.abi_info.Size // spec
  							, "timestamps"
  							, "samples_per_seg"
  							, Gst.Audio.AudioRingBufferSpec.abi_info.Align
  							, 0
  							),
  						new GLib.AbiField("samples_per_seg"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(int)) // samples_per_seg
  							, "spec"
  							, "empty_seg"
  							, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_samples_per_segAlign), "samples_per_seg")
  							, 0
  							),
  						new GLib.AbiField("empty_seg"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // empty_seg
  							, "samples_per_seg"
  							, "state"
  
gt: 							, (uint) Marshal.SizeOf(typeof(IntPtr))