gstreamer/subprojects/gstreamer-sharp/sources/generated/Gst.Audio/AudioRingBuffer.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1538 lines
45 KiB
C#
Raw Normal View History

2018-01-29 18:56:49 +00:00
// 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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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);
2018-01-29 18:56:49 +00:00
static uint Commit_cb (IntPtr inst, ulong sample, byte[] data, int in_samples, int out_samples, ref int accum)
2018-01-29 18:56:49 +00:00
{
try {
AudioRingBuffer __obj = GLib.Object.GetObject (inst, false) as AudioRingBuffer;
uint __result;
__result = __obj.OnCommit (sample, data, in_samples, out_samples, ref accum);
2018-01-29 18:56:49 +00:00
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)
2018-01-29 18:56:49 +00:00
{
return InternalCommit (sample, data, in_samples, out_samples, ref accum);
2018-01-29 18:56:49 +00:00
}
private uint InternalCommit (ulong sample, byte[] data, int in_samples, int out_samples, ref int accum)
2018-01-29 18:56:49 +00:00
{
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);
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
static extern void gst_audio_ring_buffer_clear_all(IntPtr raw);
public void ClearAll() {
gst_audio_ring_buffer_clear_all(Handle);
}
[DllImport("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-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);
2018-01-29 18:56:49 +00:00
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);
2018-01-29 18:56:49 +00:00
uint ret = raw_ret;
return ret;
}
[DllImport("gstaudio-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);
2018-01-29 18:56:49 +00:00
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);
2018-01-29 18:56:49 +00:00
bool ret = raw_ret;
return ret;
}
[DllImport("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-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);
2018-01-29 18:56:49 +00:00
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);
2018-01-29 18:56:49 +00:00
uint ret = raw_ret;
return ret;
}
[DllImport("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_audio_ring_buffer_set_channel_positions(IntPtr raw, int[] position);
2018-01-29 18:56:49 +00:00
public Gst.Audio.AudioChannelPosition[] ChannelPositions {
2018-01-29 18:56:49 +00:00
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);
2018-01-29 18:56:49 +00:00
}
}
[DllImport("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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("gstaudio-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
2018-01-29 18:56:49 +00:00
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"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("state"
, -1
, (uint) Marshal.SizeOf(typeof(int)) // state
, "empty_seg"
, "segdone"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_stateAlign), "state")
, 0
),
new GLib.AbiField("segdone"
, -1
, (uint) Marshal.SizeOf(typeof(int)) // segdone
, "state"
, "segbase"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_segdoneAlign), "segdone")
, 0
),
new GLib.AbiField("segbase"
, -1
, (uint) Marshal.SizeOf(typeof(int)) // segbase
, "segdone"
, "waiting"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_segbaseAlign), "segbase")
, 0
),
new GLib.AbiField("waiting"
, -1
, (uint) Marshal.SizeOf(typeof(int)) // waiting
, "segbase"
, "callback"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_waitingAlign), "waiting")
, 0
),
new GLib.AbiField("callback"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // callback
, "waiting"
, "cb_data"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("cb_data"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // cb_data
, "callback"
, "need_reorder"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("need_reorder"
, -1
, (uint) Marshal.SizeOf(typeof(bool)) // need_reorder
, "cb_data"
, "channel_reorder_map"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_need_reorderAlign), "need_reorder")
, 0
),
new GLib.AbiField("channel_reorder_map"
, -1
, (uint) Marshal.SizeOf(typeof(int)) * 64 // channel_reorder_map
, "need_reorder"
, "flushing"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_channel_reorder_mapAlign), "channel_reorder_map")
, 0
),
new GLib.AbiField("flushing"
, -1
, (uint) Marshal.SizeOf(typeof(bool)) // flushing
, "channel_reorder_map"
, "may_start"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_flushingAlign), "flushing")
, 0
),
new GLib.AbiField("may_start"
, -1
, (uint) Marshal.SizeOf(typeof(int)) // may_start
, "flushing"
, "active"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_may_startAlign), "may_start")
, 0
),
new GLib.AbiField("active"
, -1
, (uint) Marshal.SizeOf(typeof(bool)) // active
, "may_start"
, "cb_data_notify"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_activeAlign), "active")
, 0
),
new GLib.AbiField("cb_data_notify"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // cb_data_notify
, "active"
, "_gst_reserved"
, (long) Marshal.OffsetOf(typeof(GstAudioRingBuffer_cb_data_notifyAlign), "cb_data_notify")
, 0
),
new GLib.AbiField("_gst_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 3 // _gst_reserved
, "cb_data_notify"
, null
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
});
return _abi_info;
}
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_condAlign
{
sbyte f1;
private GLib.Cond.ABI cond;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_openAlign
{
sbyte f1;
private bool open;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_acquiredAlign
{
sbyte f1;
private bool acquired;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_memoryAlign
{
sbyte f1;
private byte memory;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_sizeAlign
{
sbyte f1;
private UIntPtr size;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_timestampsAlign
{
sbyte f1;
private ulong timestamps;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_samples_per_segAlign
{
sbyte f1;
private int samples_per_seg;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_stateAlign
{
sbyte f1;
private int state;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_segdoneAlign
{
sbyte f1;
private int segdone;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_segbaseAlign
{
sbyte f1;
private int segbase;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_waitingAlign
{
sbyte f1;
private int waiting;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_need_reorderAlign
{
sbyte f1;
private bool need_reorder;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_channel_reorder_mapAlign
{
sbyte f1;
[MarshalAs (UnmanagedType.ByValArray, SizeConst=64)]
private int[] channel_reorder_map;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_flushingAlign
{
sbyte f1;
private bool flushing;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_may_startAlign
{
sbyte f1;
private int may_start;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_activeAlign
{
sbyte f1;
private bool active;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstAudioRingBuffer_cb_data_notifyAlign
{
sbyte f1;
private GLib.DestroyNotify cb_data_notify;
}
// End of the ABI representation.
#endregion
}
}