gstreamer/subprojects/gstreamer-sharp/sources/generated/Gst.Base/Aggregator.cs
Andoni Morales Alastruey 4be602a137 csharp: update c# bindings
Update to C# bindings to use a more recent version of GtkSharp
and regenerate the bindings with that version

Fix #1718
2023-12-07 17:34:34 +01:00

1864 lines
64 KiB
C#

// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.
namespace Gst.Base {
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
#region Autogenerated code
public partial class Aggregator : Gst.Element {
protected Aggregator (IntPtr raw) : base(raw) {}
protected Aggregator() : base(IntPtr.Zero)
{
CreateNativeObject (new string [0], new GLib.Value [0]);
}
[GLib.Property ("emit-signals")]
public bool EmitSignals {
get {
GLib.Value val = GetProperty ("emit-signals");
bool ret = (bool) val;
val.Dispose ();
return ret;
}
set {
GLib.Value val = new GLib.Value(value);
SetProperty("emit-signals", val);
val.Dispose ();
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern ulong gst_aggregator_get_latency(IntPtr raw);
[GLib.Property ("latency")]
public ulong Latency {
get {
ulong raw_ret = gst_aggregator_get_latency(Handle);
ulong ret = raw_ret;
return ret;
}
set {
GLib.Value val = new GLib.Value(value);
SetProperty("latency", val);
val.Dispose ();
}
}
[GLib.Property ("min-upstream-latency")]
public ulong MinUpstreamLatency {
get {
GLib.Value val = GetProperty ("min-upstream-latency");
ulong ret = (ulong) val;
val.Dispose ();
return ret;
}
set {
GLib.Value val = new GLib.Value(value);
SetProperty("min-upstream-latency", val);
val.Dispose ();
}
}
[GLib.Property ("start-time")]
public ulong StartTime {
get {
GLib.Value val = GetProperty ("start-time");
ulong ret = (ulong) val;
val.Dispose ();
return ret;
}
set {
GLib.Value val = new GLib.Value(value);
SetProperty("start-time", val);
val.Dispose ();
}
}
[GLib.Property ("start-time-selection")]
public Gst.Base.AggregatorStartTimeSelection StartTimeSelection {
get {
GLib.Value val = GetProperty ("start-time-selection");
Gst.Base.AggregatorStartTimeSelection ret = (Gst.Base.AggregatorStartTimeSelection) (Enum) val;
val.Dispose ();
return ret;
}
set {
GLib.Value val = new GLib.Value((Enum) value);
SetProperty("start-time-selection", val);
val.Dispose ();
}
}
public Gst.Pad Srcpad {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("srcpad"));
return GLib.Object.GetObject((*raw_ptr)) as Gst.Pad;
}
}
}
[GLib.Signal("samples-selected")]
public event Gst.Base.SamplesSelectedHandler SamplesSelected {
add {
this.AddSignalHandler ("samples-selected", value, typeof (Gst.Base.SamplesSelectedArgs));
}
remove {
this.RemoveSignalHandler ("samples-selected", value);
}
}
static SamplesSelectedNativeDelegate SamplesSelected_cb_delegate;
static SamplesSelectedNativeDelegate SamplesSelectedVMCallback {
get {
if (SamplesSelected_cb_delegate == null)
SamplesSelected_cb_delegate = new SamplesSelectedNativeDelegate (SamplesSelected_cb);
return SamplesSelected_cb_delegate;
}
}
static void OverrideSamplesSelected (GLib.GType gtype)
{
OverrideSamplesSelected (gtype, SamplesSelectedVMCallback);
}
static void OverrideSamplesSelected (GLib.GType gtype, SamplesSelectedNativeDelegate callback)
{
OverrideVirtualMethod (gtype, "samples-selected", callback);
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void SamplesSelectedNativeDelegate (IntPtr inst, IntPtr segment, ulong pts, ulong dts, ulong duration, IntPtr info);
static void SamplesSelected_cb (IntPtr inst, IntPtr segment, ulong pts, ulong dts, ulong duration, IntPtr info)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
__obj.OnSamplesSelected (Gst.Segment.New (segment), pts, dts, duration, info == IntPtr.Zero ? null : (Gst.Structure) GLib.Opaque.GetOpaque (info, typeof (Gst.Structure), false));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideSamplesSelected")]
protected virtual void OnSamplesSelected (Gst.Segment segment, ulong pts, ulong dts, ulong duration, Gst.Structure info)
{
InternalSamplesSelected (segment, pts, dts, duration, info);
}
private void InternalSamplesSelected (Gst.Segment segment, ulong pts, ulong dts, ulong duration, Gst.Structure info)
{
GLib.Value ret = GLib.Value.Empty;
GLib.ValueArray inst_and_params = new GLib.ValueArray (6);
GLib.Value[] vals = new GLib.Value [6];
vals [0] = new GLib.Value (this);
inst_and_params.Append (vals [0]);
vals [1] = new GLib.Value (segment);
inst_and_params.Append (vals [1]);
vals [2] = new GLib.Value (pts);
inst_and_params.Append (vals [2]);
vals [3] = new GLib.Value (dts);
inst_and_params.Append (vals [3]);
vals [4] = new GLib.Value (duration);
inst_and_params.Append (vals [4]);
vals [5] = new GLib.Value (info);
inst_and_params.Append (vals [5]);
g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
foreach (GLib.Value v in vals)
v.Dispose ();
}
static FlushNativeDelegate Flush_cb_delegate;
static FlushNativeDelegate FlushVMCallback {
get {
if (Flush_cb_delegate == null)
Flush_cb_delegate = new FlushNativeDelegate (Flush_cb);
return Flush_cb_delegate;
}
}
static void OverrideFlush (GLib.GType gtype)
{
OverrideFlush (gtype, FlushVMCallback);
}
static void OverrideFlush (GLib.GType gtype, FlushNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("flush"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int FlushNativeDelegate (IntPtr inst);
static int Flush_cb (IntPtr inst)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.FlowReturn __result;
__result = __obj.OnFlush ();
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideFlush")]
protected virtual Gst.FlowReturn OnFlush ()
{
return InternalFlush ();
}
private Gst.FlowReturn InternalFlush ()
{
FlushNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("flush"));
unmanaged = (FlushNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FlushNativeDelegate));
}
if (unmanaged == null) return (Gst.FlowReturn) 0;
int __result = unmanaged (this.Handle);
return (Gst.FlowReturn) __result;
}
static ClipNativeDelegate Clip_cb_delegate;
static ClipNativeDelegate ClipVMCallback {
get {
if (Clip_cb_delegate == null)
Clip_cb_delegate = new ClipNativeDelegate (Clip_cb);
return Clip_cb_delegate;
}
}
static void OverrideClip (GLib.GType gtype)
{
OverrideClip (gtype, ClipVMCallback);
}
static void OverrideClip (GLib.GType gtype, ClipNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("clip"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr ClipNativeDelegate (IntPtr inst, IntPtr aggregator_pad, IntPtr buf);
static IntPtr Clip_cb (IntPtr inst, IntPtr aggregator_pad, IntPtr buf)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.Buffer __result;
__result = __obj.OnClip (GLib.Object.GetObject(aggregator_pad) as Gst.Base.AggregatorPad, buf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buf, typeof (Gst.Buffer), false));
return __result == null ? IntPtr.Zero : __result.OwnedCopy;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideClip")]
protected virtual Gst.Buffer OnClip (Gst.Base.AggregatorPad aggregator_pad, Gst.Buffer buf)
{
return InternalClip (aggregator_pad, buf);
}
private Gst.Buffer InternalClip (Gst.Base.AggregatorPad aggregator_pad, Gst.Buffer buf)
{
ClipNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("clip"));
unmanaged = (ClipNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ClipNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr __result = unmanaged (this.Handle, aggregator_pad == null ? IntPtr.Zero : aggregator_pad.Handle, buf == null ? IntPtr.Zero : buf.Handle);
return __result == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (__result, typeof (Gst.Buffer), true);
}
static FinishBufferNativeDelegate FinishBuffer_cb_delegate;
static FinishBufferNativeDelegate FinishBufferVMCallback {
get {
if (FinishBuffer_cb_delegate == null)
FinishBuffer_cb_delegate = new FinishBufferNativeDelegate (FinishBuffer_cb);
return FinishBuffer_cb_delegate;
}
}
static void OverrideFinishBuffer (GLib.GType gtype)
{
OverrideFinishBuffer (gtype, FinishBufferVMCallback);
}
static void OverrideFinishBuffer (GLib.GType gtype, FinishBufferNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("finish_buffer"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int FinishBufferNativeDelegate (IntPtr inst, IntPtr buffer);
static int FinishBuffer_cb (IntPtr inst, IntPtr buffer)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.FlowReturn __result;
__result = __obj.OnFinishBuffer (buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), true));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideFinishBuffer")]
protected virtual Gst.FlowReturn OnFinishBuffer (Gst.Buffer buffer)
{
return InternalFinishBuffer (buffer);
}
private Gst.FlowReturn InternalFinishBuffer (Gst.Buffer buffer)
{
FinishBufferNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("finish_buffer"));
unmanaged = (FinishBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FinishBufferNativeDelegate));
}
if (unmanaged == null) return (Gst.FlowReturn) 0;
buffer.Owned = false;
int __result = unmanaged (this.Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
return (Gst.FlowReturn) __result;
}
static SinkEventNativeDelegate SinkEvent_cb_delegate;
static SinkEventNativeDelegate SinkEventVMCallback {
get {
if (SinkEvent_cb_delegate == null)
SinkEvent_cb_delegate = new SinkEventNativeDelegate (SinkEvent_cb);
return SinkEvent_cb_delegate;
}
}
static void OverrideSinkEvent (GLib.GType gtype)
{
OverrideSinkEvent (gtype, SinkEventVMCallback);
}
static void OverrideSinkEvent (GLib.GType gtype, SinkEventNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("sink_event"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SinkEventNativeDelegate (IntPtr inst, IntPtr aggregator_pad, IntPtr evnt);
static bool SinkEvent_cb (IntPtr inst, IntPtr aggregator_pad, IntPtr evnt)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnSinkEvent (GLib.Object.GetObject(aggregator_pad) as Gst.Base.AggregatorPad, evnt == IntPtr.Zero ? null : (Gst.Event) GLib.Opaque.GetOpaque (evnt, typeof (Gst.Event), false));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideSinkEvent")]
protected virtual bool OnSinkEvent (Gst.Base.AggregatorPad aggregator_pad, Gst.Event evnt)
{
return InternalSinkEvent (aggregator_pad, evnt);
}
private bool InternalSinkEvent (Gst.Base.AggregatorPad aggregator_pad, Gst.Event evnt)
{
SinkEventNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("sink_event"));
unmanaged = (SinkEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SinkEventNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, aggregator_pad == null ? IntPtr.Zero : aggregator_pad.Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
return __result;
}
static SinkQueryNativeDelegate SinkQuery_cb_delegate;
static SinkQueryNativeDelegate SinkQueryVMCallback {
get {
if (SinkQuery_cb_delegate == null)
SinkQuery_cb_delegate = new SinkQueryNativeDelegate (SinkQuery_cb);
return SinkQuery_cb_delegate;
}
}
static void OverrideSinkQuery (GLib.GType gtype)
{
OverrideSinkQuery (gtype, SinkQueryVMCallback);
}
static void OverrideSinkQuery (GLib.GType gtype, SinkQueryNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("sink_query"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SinkQueryNativeDelegate (IntPtr inst, IntPtr aggregator_pad, IntPtr query);
static bool SinkQuery_cb (IntPtr inst, IntPtr aggregator_pad, IntPtr query)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnSinkQuery (GLib.Object.GetObject(aggregator_pad) as Gst.Base.AggregatorPad, query == IntPtr.Zero ? null : (Gst.Query) GLib.Opaque.GetOpaque (query, typeof (Gst.Query), false));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideSinkQuery")]
protected virtual bool OnSinkQuery (Gst.Base.AggregatorPad aggregator_pad, Gst.Query query)
{
return InternalSinkQuery (aggregator_pad, query);
}
private bool InternalSinkQuery (Gst.Base.AggregatorPad aggregator_pad, Gst.Query query)
{
SinkQueryNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("sink_query"));
unmanaged = (SinkQueryNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SinkQueryNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, aggregator_pad == null ? IntPtr.Zero : aggregator_pad.Handle, query == null ? IntPtr.Zero : query.Handle);
return __result;
}
static SrcEventNativeDelegate SrcEvent_cb_delegate;
static SrcEventNativeDelegate SrcEventVMCallback {
get {
if (SrcEvent_cb_delegate == null)
SrcEvent_cb_delegate = new SrcEventNativeDelegate (SrcEvent_cb);
return SrcEvent_cb_delegate;
}
}
static void OverrideSrcEvent (GLib.GType gtype)
{
OverrideSrcEvent (gtype, SrcEventVMCallback);
}
static void OverrideSrcEvent (GLib.GType gtype, SrcEventNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("src_event"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SrcEventNativeDelegate (IntPtr inst, IntPtr evnt);
static bool SrcEvent_cb (IntPtr inst, IntPtr evnt)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnSrcEvent (evnt == IntPtr.Zero ? null : (Gst.Event) GLib.Opaque.GetOpaque (evnt, typeof (Gst.Event), false));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideSrcEvent")]
protected virtual bool OnSrcEvent (Gst.Event evnt)
{
return InternalSrcEvent (evnt);
}
private bool InternalSrcEvent (Gst.Event evnt)
{
SrcEventNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("src_event"));
unmanaged = (SrcEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SrcEventNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
return __result;
}
static SrcQueryNativeDelegate SrcQuery_cb_delegate;
static SrcQueryNativeDelegate SrcQueryVMCallback {
get {
if (SrcQuery_cb_delegate == null)
SrcQuery_cb_delegate = new SrcQueryNativeDelegate (SrcQuery_cb);
return SrcQuery_cb_delegate;
}
}
static void OverrideSrcQuery (GLib.GType gtype)
{
OverrideSrcQuery (gtype, SrcQueryVMCallback);
}
static void OverrideSrcQuery (GLib.GType gtype, SrcQueryNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("src_query"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SrcQueryNativeDelegate (IntPtr inst, IntPtr query);
static bool SrcQuery_cb (IntPtr inst, IntPtr query)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnSrcQuery (query == IntPtr.Zero ? null : (Gst.Query) GLib.Opaque.GetOpaque (query, typeof (Gst.Query), false));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideSrcQuery")]
protected virtual bool OnSrcQuery (Gst.Query query)
{
return InternalSrcQuery (query);
}
private bool InternalSrcQuery (Gst.Query query)
{
SrcQueryNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("src_query"));
unmanaged = (SrcQueryNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SrcQueryNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, query == null ? IntPtr.Zero : query.Handle);
return __result;
}
static SrcActivateNativeDelegate SrcActivate_cb_delegate;
static SrcActivateNativeDelegate SrcActivateVMCallback {
get {
if (SrcActivate_cb_delegate == null)
SrcActivate_cb_delegate = new SrcActivateNativeDelegate (SrcActivate_cb);
return SrcActivate_cb_delegate;
}
}
static void OverrideSrcActivate (GLib.GType gtype)
{
OverrideSrcActivate (gtype, SrcActivateVMCallback);
}
static void OverrideSrcActivate (GLib.GType gtype, SrcActivateNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("src_activate"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SrcActivateNativeDelegate (IntPtr inst, int mode, bool active);
static bool SrcActivate_cb (IntPtr inst, int mode, bool active)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnSrcActivate ((Gst.PadMode) mode, active);
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideSrcActivate")]
protected virtual bool OnSrcActivate (Gst.PadMode mode, bool active)
{
return InternalSrcActivate (mode, active);
}
private bool InternalSrcActivate (Gst.PadMode mode, bool active)
{
SrcActivateNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("src_activate"));
unmanaged = (SrcActivateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SrcActivateNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, (int) mode, active);
return __result;
}
static AggregateNativeDelegate Aggregate_cb_delegate;
static AggregateNativeDelegate AggregateVMCallback {
get {
if (Aggregate_cb_delegate == null)
Aggregate_cb_delegate = new AggregateNativeDelegate (Aggregate_cb);
return Aggregate_cb_delegate;
}
}
static void OverrideAggregate (GLib.GType gtype)
{
OverrideAggregate (gtype, AggregateVMCallback);
}
static void OverrideAggregate (GLib.GType gtype, AggregateNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("aggregate"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int AggregateNativeDelegate (IntPtr inst, bool timeout);
static int Aggregate_cb (IntPtr inst, bool timeout)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.FlowReturn __result;
__result = __obj.OnAggregate (timeout);
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideAggregate")]
protected virtual Gst.FlowReturn OnAggregate (bool timeout)
{
return InternalAggregate (timeout);
}
private Gst.FlowReturn InternalAggregate (bool timeout)
{
AggregateNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("aggregate"));
unmanaged = (AggregateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AggregateNativeDelegate));
}
if (unmanaged == null) return (Gst.FlowReturn) 0;
int __result = unmanaged (this.Handle, timeout);
return (Gst.FlowReturn) __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 {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnStop ();
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), 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 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 {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnStart ();
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), 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 GetNextTimeNativeDelegate GetNextTime_cb_delegate;
static GetNextTimeNativeDelegate GetNextTimeVMCallback {
get {
if (GetNextTime_cb_delegate == null)
GetNextTime_cb_delegate = new GetNextTimeNativeDelegate (GetNextTime_cb);
return GetNextTime_cb_delegate;
}
}
static void OverrideGetNextTime (GLib.GType gtype)
{
OverrideGetNextTime (gtype, GetNextTimeVMCallback);
}
static void OverrideGetNextTime (GLib.GType gtype, GetNextTimeNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_next_time"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate ulong GetNextTimeNativeDelegate (IntPtr inst);
static ulong GetNextTime_cb (IntPtr inst)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
ulong __result;
__result = __obj.OnGetNextTime ();
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideGetNextTime")]
protected virtual ulong OnGetNextTime ()
{
return InternalGetNextTime ();
}
private ulong InternalGetNextTime ()
{
GetNextTimeNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_next_time"));
unmanaged = (GetNextTimeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetNextTimeNativeDelegate));
}
if (unmanaged == null) return 0;
ulong __result = unmanaged (this.Handle);
return __result;
}
static UpdateSrcCapsNativeDelegate UpdateSrcCaps_cb_delegate;
static UpdateSrcCapsNativeDelegate UpdateSrcCapsVMCallback {
get {
if (UpdateSrcCaps_cb_delegate == null)
UpdateSrcCaps_cb_delegate = new UpdateSrcCapsNativeDelegate (UpdateSrcCaps_cb);
return UpdateSrcCaps_cb_delegate;
}
}
static void OverrideUpdateSrcCaps (GLib.GType gtype)
{
OverrideUpdateSrcCaps (gtype, UpdateSrcCapsVMCallback);
}
static void OverrideUpdateSrcCaps (GLib.GType gtype, UpdateSrcCapsNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("update_src_caps"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int UpdateSrcCapsNativeDelegate (IntPtr inst, IntPtr caps, out IntPtr _ret);
static int UpdateSrcCaps_cb (IntPtr inst, IntPtr caps, out IntPtr _ret)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.FlowReturn __result;
Gst.Caps my_ret;
__result = __obj.OnUpdateSrcCaps (caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false), out my_ret);
_ret = my_ret == null ? IntPtr.Zero : my_ret.Handle;
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideUpdateSrcCaps")]
protected virtual Gst.FlowReturn OnUpdateSrcCaps (Gst.Caps caps, out Gst.Caps _ret)
{
return InternalUpdateSrcCaps (caps, out _ret);
}
private Gst.FlowReturn InternalUpdateSrcCaps (Gst.Caps caps, out Gst.Caps _ret)
{
UpdateSrcCapsNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("update_src_caps"));
unmanaged = (UpdateSrcCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UpdateSrcCapsNativeDelegate));
}
if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
IntPtr native__ret;
int __result = unmanaged (this.Handle, caps == null ? IntPtr.Zero : caps.Handle, out native__ret);
_ret = native__ret == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (native__ret, typeof (Gst.Caps), true);
return (Gst.FlowReturn) __result;
}
static FixateSrcCapsNativeDelegate FixateSrcCaps_cb_delegate;
static FixateSrcCapsNativeDelegate FixateSrcCapsVMCallback {
get {
if (FixateSrcCaps_cb_delegate == null)
FixateSrcCaps_cb_delegate = new FixateSrcCapsNativeDelegate (FixateSrcCaps_cb);
return FixateSrcCaps_cb_delegate;
}
}
static void OverrideFixateSrcCaps (GLib.GType gtype)
{
OverrideFixateSrcCaps (gtype, FixateSrcCapsVMCallback);
}
static void OverrideFixateSrcCaps (GLib.GType gtype, FixateSrcCapsNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("fixate_src_caps"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr FixateSrcCapsNativeDelegate (IntPtr inst, IntPtr caps);
static IntPtr FixateSrcCaps_cb (IntPtr inst, IntPtr caps)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.Caps __result;
__result = __obj.OnFixateSrcCaps (caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false));
return __result == null ? IntPtr.Zero : __result.OwnedCopy;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideFixateSrcCaps")]
protected virtual Gst.Caps OnFixateSrcCaps (Gst.Caps caps)
{
return InternalFixateSrcCaps (caps);
}
private Gst.Caps InternalFixateSrcCaps (Gst.Caps caps)
{
FixateSrcCapsNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("fixate_src_caps"));
unmanaged = (FixateSrcCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FixateSrcCapsNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr __result = unmanaged (this.Handle, caps == null ? IntPtr.Zero : caps.Handle);
return __result == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (__result, typeof (Gst.Caps), true);
}
static NegotiatedSrcCapsNativeDelegate NegotiatedSrcCaps_cb_delegate;
static NegotiatedSrcCapsNativeDelegate NegotiatedSrcCapsVMCallback {
get {
if (NegotiatedSrcCaps_cb_delegate == null)
NegotiatedSrcCaps_cb_delegate = new NegotiatedSrcCapsNativeDelegate (NegotiatedSrcCaps_cb);
return NegotiatedSrcCaps_cb_delegate;
}
}
static void OverrideNegotiatedSrcCaps (GLib.GType gtype)
{
OverrideNegotiatedSrcCaps (gtype, NegotiatedSrcCapsVMCallback);
}
static void OverrideNegotiatedSrcCaps (GLib.GType gtype, NegotiatedSrcCapsNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("negotiated_src_caps"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool NegotiatedSrcCapsNativeDelegate (IntPtr inst, IntPtr caps);
static bool NegotiatedSrcCaps_cb (IntPtr inst, IntPtr caps)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnNegotiatedSrcCaps (caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideNegotiatedSrcCaps")]
protected virtual bool OnNegotiatedSrcCaps (Gst.Caps caps)
{
return InternalNegotiatedSrcCaps (caps);
}
private bool InternalNegotiatedSrcCaps (Gst.Caps caps)
{
NegotiatedSrcCapsNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("negotiated_src_caps"));
unmanaged = (NegotiatedSrcCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NegotiatedSrcCapsNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, caps == null ? IntPtr.Zero : caps.Handle);
return __result;
}
static DecideAllocationNativeDelegate DecideAllocation_cb_delegate;
static DecideAllocationNativeDelegate DecideAllocationVMCallback {
get {
if (DecideAllocation_cb_delegate == null)
DecideAllocation_cb_delegate = new DecideAllocationNativeDelegate (DecideAllocation_cb);
return DecideAllocation_cb_delegate;
}
}
static void OverrideDecideAllocation (GLib.GType gtype)
{
OverrideDecideAllocation (gtype, DecideAllocationVMCallback);
}
static void OverrideDecideAllocation (GLib.GType gtype, DecideAllocationNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("decide_allocation"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool DecideAllocationNativeDelegate (IntPtr inst, IntPtr query);
static bool DecideAllocation_cb (IntPtr inst, IntPtr query)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnDecideAllocation (query == IntPtr.Zero ? null : (Gst.Query) GLib.Opaque.GetOpaque (query, typeof (Gst.Query), false));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideDecideAllocation")]
protected virtual bool OnDecideAllocation (Gst.Query query)
{
return InternalDecideAllocation (query);
}
private bool InternalDecideAllocation (Gst.Query query)
{
DecideAllocationNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("decide_allocation"));
unmanaged = (DecideAllocationNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DecideAllocationNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, query == null ? IntPtr.Zero : query.Handle);
return __result;
}
static ProposeAllocationNativeDelegate ProposeAllocation_cb_delegate;
static ProposeAllocationNativeDelegate ProposeAllocationVMCallback {
get {
if (ProposeAllocation_cb_delegate == null)
ProposeAllocation_cb_delegate = new ProposeAllocationNativeDelegate (ProposeAllocation_cb);
return ProposeAllocation_cb_delegate;
}
}
static void OverrideProposeAllocation (GLib.GType gtype)
{
OverrideProposeAllocation (gtype, ProposeAllocationVMCallback);
}
static void OverrideProposeAllocation (GLib.GType gtype, ProposeAllocationNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("propose_allocation"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool ProposeAllocationNativeDelegate (IntPtr inst, IntPtr pad, IntPtr decide_query, IntPtr query);
static bool ProposeAllocation_cb (IntPtr inst, IntPtr pad, IntPtr decide_query, IntPtr query)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnProposeAllocation (GLib.Object.GetObject(pad) as Gst.Base.AggregatorPad, decide_query == IntPtr.Zero ? null : (Gst.Query) GLib.Opaque.GetOpaque (decide_query, typeof (Gst.Query), false), query == IntPtr.Zero ? null : (Gst.Query) GLib.Opaque.GetOpaque (query, typeof (Gst.Query), false));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideProposeAllocation")]
protected virtual bool OnProposeAllocation (Gst.Base.AggregatorPad pad, Gst.Query decide_query, Gst.Query query)
{
return InternalProposeAllocation (pad, decide_query, query);
}
private bool InternalProposeAllocation (Gst.Base.AggregatorPad pad, Gst.Query decide_query, Gst.Query query)
{
ProposeAllocationNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("propose_allocation"));
unmanaged = (ProposeAllocationNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ProposeAllocationNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, pad == null ? IntPtr.Zero : pad.Handle, decide_query == null ? IntPtr.Zero : decide_query.Handle, query == null ? IntPtr.Zero : query.Handle);
return __result;
}
static NegotiateNativeDelegate Negotiate_cb_delegate;
static NegotiateNativeDelegate NegotiateVMCallback {
get {
if (Negotiate_cb_delegate == null)
Negotiate_cb_delegate = new NegotiateNativeDelegate (Negotiate_cb);
return Negotiate_cb_delegate;
}
}
static void OverrideNegotiate (GLib.GType gtype)
{
OverrideNegotiate (gtype, NegotiateVMCallback);
}
static void OverrideNegotiate (GLib.GType gtype, NegotiateNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("negotiate"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool NegotiateNativeDelegate (IntPtr inst);
static bool Negotiate_cb (IntPtr inst)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnNegotiate ();
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideNegotiate")]
protected virtual bool OnNegotiate ()
{
return InternalNegotiate ();
}
private bool InternalNegotiate ()
{
NegotiateNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("negotiate"));
unmanaged = (NegotiateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NegotiateNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle);
return __result;
}
static SinkEventPreQueueNativeDelegate SinkEventPreQueue_cb_delegate;
static SinkEventPreQueueNativeDelegate SinkEventPreQueueVMCallback {
get {
if (SinkEventPreQueue_cb_delegate == null)
SinkEventPreQueue_cb_delegate = new SinkEventPreQueueNativeDelegate (SinkEventPreQueue_cb);
return SinkEventPreQueue_cb_delegate;
}
}
static void OverrideSinkEventPreQueue (GLib.GType gtype)
{
OverrideSinkEventPreQueue (gtype, SinkEventPreQueueVMCallback);
}
static void OverrideSinkEventPreQueue (GLib.GType gtype, SinkEventPreQueueNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("sink_event_pre_queue"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int SinkEventPreQueueNativeDelegate (IntPtr inst, IntPtr aggregator_pad, IntPtr evnt);
static int SinkEventPreQueue_cb (IntPtr inst, IntPtr aggregator_pad, IntPtr evnt)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.FlowReturn __result;
__result = __obj.OnSinkEventPreQueue (GLib.Object.GetObject(aggregator_pad) as Gst.Base.AggregatorPad, evnt == IntPtr.Zero ? null : (Gst.Event) GLib.Opaque.GetOpaque (evnt, typeof (Gst.Event), false));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideSinkEventPreQueue")]
protected virtual Gst.FlowReturn OnSinkEventPreQueue (Gst.Base.AggregatorPad aggregator_pad, Gst.Event evnt)
{
return InternalSinkEventPreQueue (aggregator_pad, evnt);
}
private Gst.FlowReturn InternalSinkEventPreQueue (Gst.Base.AggregatorPad aggregator_pad, Gst.Event evnt)
{
SinkEventPreQueueNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("sink_event_pre_queue"));
unmanaged = (SinkEventPreQueueNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SinkEventPreQueueNativeDelegate));
}
if (unmanaged == null) return (Gst.FlowReturn) 0;
int __result = unmanaged (this.Handle, aggregator_pad == null ? IntPtr.Zero : aggregator_pad.Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
return (Gst.FlowReturn) __result;
}
static SinkQueryPreQueueNativeDelegate SinkQueryPreQueue_cb_delegate;
static SinkQueryPreQueueNativeDelegate SinkQueryPreQueueVMCallback {
get {
if (SinkQueryPreQueue_cb_delegate == null)
SinkQueryPreQueue_cb_delegate = new SinkQueryPreQueueNativeDelegate (SinkQueryPreQueue_cb);
return SinkQueryPreQueue_cb_delegate;
}
}
static void OverrideSinkQueryPreQueue (GLib.GType gtype)
{
OverrideSinkQueryPreQueue (gtype, SinkQueryPreQueueVMCallback);
}
static void OverrideSinkQueryPreQueue (GLib.GType gtype, SinkQueryPreQueueNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("sink_query_pre_queue"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SinkQueryPreQueueNativeDelegate (IntPtr inst, IntPtr aggregator_pad, IntPtr query);
static bool SinkQueryPreQueue_cb (IntPtr inst, IntPtr aggregator_pad, IntPtr query)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
bool __result;
__result = __obj.OnSinkQueryPreQueue (GLib.Object.GetObject(aggregator_pad) as Gst.Base.AggregatorPad, query == IntPtr.Zero ? null : (Gst.Query) GLib.Opaque.GetOpaque (query, typeof (Gst.Query), false));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideSinkQueryPreQueue")]
protected virtual bool OnSinkQueryPreQueue (Gst.Base.AggregatorPad aggregator_pad, Gst.Query query)
{
return InternalSinkQueryPreQueue (aggregator_pad, query);
}
private bool InternalSinkQueryPreQueue (Gst.Base.AggregatorPad aggregator_pad, Gst.Query query)
{
SinkQueryPreQueueNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("sink_query_pre_queue"));
unmanaged = (SinkQueryPreQueueNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SinkQueryPreQueueNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, aggregator_pad == null ? IntPtr.Zero : aggregator_pad.Handle, query == null ? IntPtr.Zero : query.Handle);
return __result;
}
static FinishBufferListNativeDelegate FinishBufferList_cb_delegate;
static FinishBufferListNativeDelegate FinishBufferListVMCallback {
get {
if (FinishBufferList_cb_delegate == null)
FinishBufferList_cb_delegate = new FinishBufferListNativeDelegate (FinishBufferList_cb);
return FinishBufferList_cb_delegate;
}
}
static void OverrideFinishBufferList (GLib.GType gtype)
{
OverrideFinishBufferList (gtype, FinishBufferListVMCallback);
}
static void OverrideFinishBufferList (GLib.GType gtype, FinishBufferListNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("finish_buffer_list"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int FinishBufferListNativeDelegate (IntPtr inst, IntPtr bufferlist);
static int FinishBufferList_cb (IntPtr inst, IntPtr bufferlist)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.FlowReturn __result;
__result = __obj.OnFinishBufferList (bufferlist == IntPtr.Zero ? null : (Gst.BufferList) GLib.Opaque.GetOpaque (bufferlist, typeof (Gst.BufferList), true));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverrideFinishBufferList")]
protected virtual Gst.FlowReturn OnFinishBufferList (Gst.BufferList bufferlist)
{
return InternalFinishBufferList (bufferlist);
}
private Gst.FlowReturn InternalFinishBufferList (Gst.BufferList bufferlist)
{
FinishBufferListNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("finish_buffer_list"));
unmanaged = (FinishBufferListNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FinishBufferListNativeDelegate));
}
if (unmanaged == null) return (Gst.FlowReturn) 0;
bufferlist.Owned = false;
int __result = unmanaged (this.Handle, bufferlist == null ? IntPtr.Zero : bufferlist.Handle);
return (Gst.FlowReturn) __result;
}
static PeekNextSampleNativeDelegate PeekNextSample_cb_delegate;
static PeekNextSampleNativeDelegate PeekNextSampleVMCallback {
get {
if (PeekNextSample_cb_delegate == null)
PeekNextSample_cb_delegate = new PeekNextSampleNativeDelegate (PeekNextSample_cb);
return PeekNextSample_cb_delegate;
}
}
static void OverridePeekNextSample (GLib.GType gtype)
{
OverridePeekNextSample (gtype, PeekNextSampleVMCallback);
}
static void OverridePeekNextSample (GLib.GType gtype, PeekNextSampleNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("peek_next_sample"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr PeekNextSampleNativeDelegate (IntPtr inst, IntPtr aggregator_pad);
static IntPtr PeekNextSample_cb (IntPtr inst, IntPtr aggregator_pad)
{
try {
Aggregator __obj = GLib.Object.GetObject (inst, false) as Aggregator;
Gst.Sample __result;
__result = __obj.OnPeekNextSample (GLib.Object.GetObject(aggregator_pad) as Gst.Base.AggregatorPad);
return __result == null ? IntPtr.Zero : __result.OwnedCopy;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.Aggregator), ConnectionMethod="OverridePeekNextSample")]
protected virtual Gst.Sample OnPeekNextSample (Gst.Base.AggregatorPad aggregator_pad)
{
return InternalPeekNextSample (aggregator_pad);
}
private Gst.Sample InternalPeekNextSample (Gst.Base.AggregatorPad aggregator_pad)
{
PeekNextSampleNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("peek_next_sample"));
unmanaged = (PeekNextSampleNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PeekNextSampleNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr __result = unmanaged (this.Handle, aggregator_pad == null ? IntPtr.Zero : aggregator_pad.Handle);
return __result == IntPtr.Zero ? null : (Gst.Sample) GLib.Opaque.GetOpaque (__result, typeof (Gst.Sample), true);
}
// 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("flush"
, Gst.Element.class_abi.Fields
, (uint) Marshal.SizeOf(typeof(IntPtr)) // flush
, null
, "clip"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("clip"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // clip
, "flush"
, "finish_buffer"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("finish_buffer"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // finish_buffer
, "clip"
, "sink_event"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("sink_event"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // sink_event
, "finish_buffer"
, "sink_query"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("sink_query"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // sink_query
, "sink_event"
, "src_event"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("src_event"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // src_event
, "sink_query"
, "src_query"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("src_query"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // src_query
, "src_event"
, "src_activate"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("src_activate"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // src_activate
, "src_query"
, "aggregate"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("aggregate"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // aggregate
, "src_activate"
, "stop"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("stop"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // stop
, "aggregate"
, "start"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("start"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // start
, "stop"
, "get_next_time"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("get_next_time"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_next_time
, "start"
, "create_new_pad"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("create_new_pad"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // create_new_pad
, "get_next_time"
, "update_src_caps"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("update_src_caps"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // update_src_caps
, "create_new_pad"
, "fixate_src_caps"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("fixate_src_caps"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // fixate_src_caps
, "update_src_caps"
, "negotiated_src_caps"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("negotiated_src_caps"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // negotiated_src_caps
, "fixate_src_caps"
, "decide_allocation"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("decide_allocation"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // decide_allocation
, "negotiated_src_caps"
, "propose_allocation"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("propose_allocation"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // propose_allocation
, "decide_allocation"
, "negotiate"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("negotiate"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // negotiate
, "propose_allocation"
, "sink_event_pre_queue"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("sink_event_pre_queue"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // sink_event_pre_queue
, "negotiate"
, "sink_query_pre_queue"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("sink_query_pre_queue"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // sink_query_pre_queue
, "sink_event_pre_queue"
, "finish_buffer_list"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("finish_buffer_list"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // finish_buffer_list
, "sink_query_pre_queue"
, "peek_next_sample"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("peek_next_sample"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // peek_next_sample
, "finish_buffer_list"
, "_gst_reserved"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("_gst_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 15 // _gst_reserved
, "peek_next_sample"
, null
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
});
return _class_abi;
}
}
// End of the ABI representation.
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_aggregator_get_type();
public static new GLib.GType GType {
get {
IntPtr raw_ret = gst_aggregator_get_type();
GLib.GType ret = new GLib.GType(raw_ret);
return ret;
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int gst_aggregator_finish_buffer(IntPtr raw, IntPtr buffer);
public Gst.FlowReturn FinishBuffer(Gst.Buffer buffer) {
buffer.Owned = false;
int raw_ret = gst_aggregator_finish_buffer(Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
return ret;
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int gst_aggregator_finish_buffer_list(IntPtr raw, IntPtr bufferlist);
public Gst.FlowReturn FinishBufferList(Gst.BufferList bufferlist) {
bufferlist.Owned = false;
int raw_ret = gst_aggregator_finish_buffer_list(Handle, bufferlist == null ? IntPtr.Zero : bufferlist.Handle);
Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
return ret;
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_aggregator_get_allocator(IntPtr raw, out IntPtr allocator, IntPtr parms);
public void GetAllocator(out Gst.Allocator allocator, out Gst.AllocationParams parms) {
IntPtr native_allocator;
IntPtr native_parms = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (Gst.AllocationParams)));
gst_aggregator_get_allocator(Handle, out native_allocator, native_parms);
allocator = GLib.Object.GetObject(native_allocator, true) as Gst.Allocator;
parms = Gst.AllocationParams.New (native_parms);
Marshal.FreeHGlobal (native_parms);
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_aggregator_get_buffer_pool(IntPtr raw);
public Gst.BufferPool BufferPool {
get {
IntPtr raw_ret = gst_aggregator_get_buffer_pool(Handle);
Gst.BufferPool ret = GLib.Object.GetObject(raw_ret, true) as Gst.BufferPool;
return ret;
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_aggregator_get_force_live(IntPtr raw);
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_aggregator_set_force_live(IntPtr raw, bool force_live);
public bool ForceLive {
get {
bool raw_ret = gst_aggregator_get_force_live(Handle);
bool ret = raw_ret;
return ret;
}
set {
gst_aggregator_set_force_live(Handle, value);
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_aggregator_get_ignore_inactive_pads(IntPtr raw);
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_aggregator_set_ignore_inactive_pads(IntPtr raw, bool ignore);
public bool IgnoreInactivePads {
get {
bool raw_ret = gst_aggregator_get_ignore_inactive_pads(Handle);
bool ret = raw_ret;
return ret;
}
set {
gst_aggregator_set_ignore_inactive_pads(Handle, value);
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_aggregator_negotiate(IntPtr raw);
public bool Negotiate() {
bool raw_ret = gst_aggregator_negotiate(Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_aggregator_peek_next_sample(IntPtr raw, IntPtr pad);
public Gst.Sample PeekNextSample(Gst.Base.AggregatorPad pad) {
IntPtr raw_ret = gst_aggregator_peek_next_sample(Handle, pad == null ? IntPtr.Zero : pad.Handle);
Gst.Sample ret = raw_ret == IntPtr.Zero ? null : (Gst.Sample) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Sample), true);
return ret;
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_aggregator_selected_samples(IntPtr raw, ulong pts, ulong dts, ulong duration, IntPtr info);
public void SelectedSamples(ulong pts, ulong dts, ulong duration, Gst.Structure info) {
gst_aggregator_selected_samples(Handle, pts, dts, duration, info == null ? IntPtr.Zero : info.Handle);
}
public void SelectedSamples(ulong pts, ulong dts, ulong duration) {
SelectedSamples (pts, dts, duration, null);
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_aggregator_set_latency(IntPtr raw, ulong min_latency, ulong max_latency);
public void SetLatency(ulong min_latency, ulong max_latency) {
gst_aggregator_set_latency(Handle, min_latency, max_latency);
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_aggregator_set_src_caps(IntPtr raw, IntPtr caps);
public Gst.Caps SrcCaps {
set {
gst_aggregator_set_src_caps(Handle, value == null ? IntPtr.Zero : value.Handle);
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern ulong gst_aggregator_simple_get_next_time(IntPtr raw);
public ulong SimpleGetNextTime() {
ulong raw_ret = gst_aggregator_simple_get_next_time(Handle);
ulong ret = raw_ret;
return ret;
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_aggregator_update_segment(IntPtr raw, IntPtr segment);
public void UpdateSegment(Gst.Segment segment) {
IntPtr native_segment = GLib.Marshaller.StructureToPtrAlloc (segment);
gst_aggregator_update_segment(Handle, native_segment);
Marshal.FreeHGlobal (native_segment);
}
static Aggregator ()
{
GtkSharp.GstreamerSharp.ObjectManager.Initialize ();
}
// Internal representation of the wrapped structure ABI.
static GLib.AbiStruct _abi_info = null;
static public new GLib.AbiStruct abi_info {
get {
if (_abi_info == null)
_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{
new GLib.AbiField("srcpad"
, Gst.Element.abi_info.Fields
, (uint) Marshal.SizeOf(typeof(IntPtr)) // srcpad
, null
, "priv"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("priv"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
, "srcpad"
, "_gst_reserved"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("_gst_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _gst_reserved
, "priv"
, null
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
});
return _abi_info;
}
}
// End of the ABI representation.
#endregion
}
}