mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-26 18:20:44 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gstreamer-sharp/sources/generated/Gst.Base/BaseTransform.cs

1844 lines
65 KiB
C#
Raw Blame History

// 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 BaseTransform : Gst.Element {
protected BaseTransform (IntPtr raw) : base(raw) {}
protected BaseTransform() : base(IntPtr.Zero)
{
CreateNativeObject (new string [0], new GLib.Value [0]);
}
[GLib.Property ("qos")]
public bool Qos {
get {
GLib.Value val = GetProperty ("qos");
bool ret = (bool) val;
val.Dispose ();
return ret;
}
set {
GLib.Value val = new GLib.Value(value);
SetProperty("qos", val);
val.Dispose ();
}
}
public Gst.Pad Sinkpad {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("sinkpad"));
return GLib.Object.GetObject((*raw_ptr)) as Gst.Pad;
}
}
}
public Gst.Pad Srcpad {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("srcpad"));
return GLib.Object.GetObject((*raw_ptr)) as Gst.Pad;
}
}
}
public bool HaveSegment {
get {
unsafe {
bool* raw_ptr = (bool*)(((byte*)Handle) + abi_info.GetFieldOffset("have_segment"));
return (*raw_ptr);
}
}
}
public Gst.Segment Segment {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("segment"));
return Gst.Segment.New ((*raw_ptr));
}
}
}
public Gst.Buffer QueuedBuf {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("queued_buf"));
return (*raw_ptr) == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque ((*raw_ptr), typeof (Gst.Buffer), false);
}
}
}
static TransformCapsNativeDelegate TransformCaps_cb_delegate;
static TransformCapsNativeDelegate TransformCapsVMCallback {
get {
if (TransformCaps_cb_delegate == null)
TransformCaps_cb_delegate = new TransformCapsNativeDelegate (TransformCaps_cb);
return TransformCaps_cb_delegate;
}
}
static void OverrideTransformCaps (GLib.GType gtype)
{
OverrideTransformCaps (gtype, TransformCapsVMCallback);
}
static void OverrideTransformCaps (GLib.GType gtype, TransformCapsNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("transform_caps"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr TransformCapsNativeDelegate (IntPtr inst, int direction, IntPtr caps, IntPtr filter);
static IntPtr TransformCaps_cb (IntPtr inst, int direction, IntPtr caps, IntPtr filter)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
Gst.Caps __result;
__result = __obj.OnTransformCaps ((Gst.PadDirection) direction, caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false), filter == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (filter, typeof (Gst.Caps), false));
return __result == null ? IntPtr.Zero : __result.OwnedCopy;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseTransform), ConnectionMethod="OverrideTransformCaps")]
protected virtual Gst.Caps OnTransformCaps (Gst.PadDirection direction, Gst.Caps caps, Gst.Caps filter)
{
return InternalTransformCaps (direction, caps, filter);
}
private Gst.Caps InternalTransformCaps (Gst.PadDirection direction, Gst.Caps caps, Gst.Caps filter)
{
TransformCapsNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("transform_caps"));
unmanaged = (TransformCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TransformCapsNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr __result = unmanaged (this.Handle, (int) direction, caps == null ? IntPtr.Zero : caps.Handle, filter == null ? IntPtr.Zero : filter.Handle);
return __result == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (__result, typeof (Gst.Caps), true);
}
static FixateCapsNativeDelegate FixateCaps_cb_delegate;
static FixateCapsNativeDelegate FixateCapsVMCallback {
get {
if (FixateCaps_cb_delegate == null)
FixateCaps_cb_delegate = new FixateCapsNativeDelegate (FixateCaps_cb);
return FixateCaps_cb_delegate;
}
}
static void OverrideFixateCaps (GLib.GType gtype)
{
OverrideFixateCaps (gtype, FixateCapsVMCallback);
}
static void OverrideFixateCaps (GLib.GType gtype, FixateCapsNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("fixate_caps"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr FixateCapsNativeDelegate (IntPtr inst, int direction, IntPtr caps, IntPtr othercaps);
static IntPtr FixateCaps_cb (IntPtr inst, int direction, IntPtr caps, IntPtr othercaps)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
Gst.Caps __result;
__result = __obj.OnFixateCaps ((Gst.PadDirection) direction, caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false), othercaps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (othercaps, 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.BaseTransform), ConnectionMethod="OverrideFixateCaps")]
protected virtual Gst.Caps OnFixateCaps (Gst.PadDirection direction, Gst.Caps caps, Gst.Caps othercaps)
{
return InternalFixateCaps (direction, caps, othercaps);
}
private Gst.Caps InternalFixateCaps (Gst.PadDirection direction, Gst.Caps caps, Gst.Caps othercaps)
{
FixateCapsNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("fixate_caps"));
unmanaged = (FixateCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FixateCapsNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr __result = unmanaged (this.Handle, (int) direction, caps == null ? IntPtr.Zero : caps.Handle, othercaps == null ? IntPtr.Zero : othercaps.Handle);
return __result == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (__result, typeof (Gst.Caps), true);
}
static AcceptCapsNativeDelegate AcceptCaps_cb_delegate;
static AcceptCapsNativeDelegate AcceptCapsVMCallback {
get {
if (AcceptCaps_cb_delegate == null)
AcceptCaps_cb_delegate = new AcceptCapsNativeDelegate (AcceptCaps_cb);
return AcceptCaps_cb_delegate;
}
}
static void OverrideAcceptCaps (GLib.GType gtype)
{
OverrideAcceptCaps (gtype, AcceptCapsVMCallback);
}
static void OverrideAcceptCaps (GLib.GType gtype, AcceptCapsNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("accept_caps"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool AcceptCapsNativeDelegate (IntPtr inst, int direction, IntPtr caps);
static bool AcceptCaps_cb (IntPtr inst, int direction, IntPtr caps)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
__result = __obj.OnAcceptCaps ((Gst.PadDirection) direction, 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.BaseTransform), ConnectionMethod="OverrideAcceptCaps")]
protected virtual bool OnAcceptCaps (Gst.PadDirection direction, Gst.Caps caps)
{
return InternalAcceptCaps (direction, caps);
}
private bool InternalAcceptCaps (Gst.PadDirection direction, Gst.Caps caps)
{
AcceptCapsNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("accept_caps"));
unmanaged = (AcceptCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AcceptCapsNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, (int) direction, caps == null ? IntPtr.Zero : caps.Handle);
return __result;
}
static SetCapsNativeDelegate SetCaps_cb_delegate;
static SetCapsNativeDelegate SetCapsVMCallback {
get {
if (SetCaps_cb_delegate == null)
SetCaps_cb_delegate = new SetCapsNativeDelegate (SetCaps_cb);
return SetCaps_cb_delegate;
}
}
static void OverrideSetCaps (GLib.GType gtype)
{
OverrideSetCaps (gtype, SetCapsVMCallback);
}
static void OverrideSetCaps (GLib.GType gtype, SetCapsNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_caps"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SetCapsNativeDelegate (IntPtr inst, IntPtr incaps, IntPtr outcaps);
static bool SetCaps_cb (IntPtr inst, IntPtr incaps, IntPtr outcaps)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
__result = __obj.OnSetCaps (incaps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (incaps, typeof (Gst.Caps), false), outcaps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (outcaps, 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.BaseTransform), ConnectionMethod="OverrideSetCaps")]
protected virtual bool OnSetCaps (Gst.Caps incaps, Gst.Caps outcaps)
{
return InternalSetCaps (incaps, outcaps);
}
private bool InternalSetCaps (Gst.Caps incaps, Gst.Caps outcaps)
{
SetCapsNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_caps"));
unmanaged = (SetCapsNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetCapsNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, incaps == null ? IntPtr.Zero : incaps.Handle, outcaps == null ? IntPtr.Zero : outcaps.Handle);
return __result;
}
static QueryNativeDelegate Query_cb_delegate;
static QueryNativeDelegate QueryVMCallback {
get {
if (Query_cb_delegate == null)
Query_cb_delegate = new QueryNativeDelegate (Query_cb);
return Query_cb_delegate;
}
}
static void OverrideQuery (GLib.GType gtype)
{
OverrideQuery (gtype, QueryVMCallback);
}
static void OverrideQuery (GLib.GType gtype, QueryNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool QueryNativeDelegate (IntPtr inst, int direction, IntPtr query);
static bool Query_cb (IntPtr inst, int direction, IntPtr query)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
__result = __obj.OnQuery ((Gst.PadDirection) direction, 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.BaseTransform), ConnectionMethod="OverrideQuery")]
protected virtual bool OnQuery (Gst.PadDirection direction, Gst.Query query)
{
return InternalQuery (direction, query);
}
private bool InternalQuery (Gst.PadDirection direction, Gst.Query query)
{
QueryNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query"));
unmanaged = (QueryNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, (int) direction, query == null ? IntPtr.Zero : query.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 {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
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.BaseTransform), 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 FilterMetaNativeDelegate FilterMeta_cb_delegate;
static FilterMetaNativeDelegate FilterMetaVMCallback {
get {
if (FilterMeta_cb_delegate == null)
FilterMeta_cb_delegate = new FilterMetaNativeDelegate (FilterMeta_cb);
return FilterMeta_cb_delegate;
}
}
static void OverrideFilterMeta (GLib.GType gtype)
{
OverrideFilterMeta (gtype, FilterMetaVMCallback);
}
static void OverrideFilterMeta (GLib.GType gtype, FilterMetaNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("filter_meta"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool FilterMetaNativeDelegate (IntPtr inst, IntPtr query, IntPtr api, IntPtr parms);
static bool FilterMeta_cb (IntPtr inst, IntPtr query, IntPtr api, IntPtr parms)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
__result = __obj.OnFilterMeta (query == IntPtr.Zero ? null : (Gst.Query) GLib.Opaque.GetOpaque (query, typeof (Gst.Query), false), new GLib.GType(api), parms == IntPtr.Zero ? null : (Gst.Structure) GLib.Opaque.GetOpaque (parms, typeof (Gst.Structure), 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.BaseTransform), ConnectionMethod="OverrideFilterMeta")]
protected virtual bool OnFilterMeta (Gst.Query query, GLib.GType api, Gst.Structure parms)
{
return InternalFilterMeta (query, api, parms);
}
private bool InternalFilterMeta (Gst.Query query, GLib.GType api, Gst.Structure parms)
{
FilterMetaNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("filter_meta"));
unmanaged = (FilterMetaNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FilterMetaNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, query == null ? IntPtr.Zero : query.Handle, api.Val, parms == null ? IntPtr.Zero : parms.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 decide_query, IntPtr query);
static bool ProposeAllocation_cb (IntPtr inst, IntPtr decide_query, IntPtr query)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
__result = __obj.OnProposeAllocation (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.BaseTransform), ConnectionMethod="OverrideProposeAllocation")]
protected virtual bool OnProposeAllocation (Gst.Query decide_query, Gst.Query query)
{
return InternalProposeAllocation (decide_query, query);
}
private bool InternalProposeAllocation (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, decide_query == null ? IntPtr.Zero : decide_query.Handle, query == null ? IntPtr.Zero : query.Handle);
return __result;
}
static TransformSizeNativeDelegate TransformSize_cb_delegate;
static TransformSizeNativeDelegate TransformSizeVMCallback {
get {
if (TransformSize_cb_delegate == null)
TransformSize_cb_delegate = new TransformSizeNativeDelegate (TransformSize_cb);
return TransformSize_cb_delegate;
}
}
static void OverrideTransformSize (GLib.GType gtype)
{
OverrideTransformSize (gtype, TransformSizeVMCallback);
}
static void OverrideTransformSize (GLib.GType gtype, TransformSizeNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("transform_size"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool TransformSizeNativeDelegate (IntPtr inst, int direction, IntPtr caps, UIntPtr size, IntPtr othercaps, out UIntPtr othersize);
static bool TransformSize_cb (IntPtr inst, int direction, IntPtr caps, UIntPtr size, IntPtr othercaps, out UIntPtr othersize)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
ulong myothersize;
__result = __obj.OnTransformSize ((Gst.PadDirection) direction, caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false), (ulong) size, othercaps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (othercaps, typeof (Gst.Caps), false), out myothersize);
othersize = new UIntPtr (myothersize);
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseTransform), ConnectionMethod="OverrideTransformSize")]
protected virtual bool OnTransformSize (Gst.PadDirection direction, Gst.Caps caps, ulong size, Gst.Caps othercaps, out ulong othersize)
{
return InternalTransformSize (direction, caps, size, othercaps, out othersize);
}
private bool InternalTransformSize (Gst.PadDirection direction, Gst.Caps caps, ulong size, Gst.Caps othercaps, out ulong othersize)
{
TransformSizeNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("transform_size"));
unmanaged = (TransformSizeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TransformSizeNativeDelegate));
}
if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
UIntPtr native_othersize;
bool __result = unmanaged (this.Handle, (int) direction, caps == null ? IntPtr.Zero : caps.Handle, new UIntPtr (size), othercaps == null ? IntPtr.Zero : othercaps.Handle, out native_othersize);
othersize = (ulong) native_othersize;
return __result;
}
static GetUnitSizeNativeDelegate GetUnitSize_cb_delegate;
static GetUnitSizeNativeDelegate GetUnitSizeVMCallback {
get {
if (GetUnitSize_cb_delegate == null)
GetUnitSize_cb_delegate = new GetUnitSizeNativeDelegate (GetUnitSize_cb);
return GetUnitSize_cb_delegate;
}
}
static void OverrideGetUnitSize (GLib.GType gtype)
{
OverrideGetUnitSize (gtype, GetUnitSizeVMCallback);
}
static void OverrideGetUnitSize (GLib.GType gtype, GetUnitSizeNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_unit_size"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool GetUnitSizeNativeDelegate (IntPtr inst, IntPtr caps, out UIntPtr size);
static bool GetUnitSize_cb (IntPtr inst, IntPtr caps, out UIntPtr size)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
ulong mysize;
__result = __obj.OnGetUnitSize (caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false), out mysize);
size = new UIntPtr (mysize);
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseTransform), ConnectionMethod="OverrideGetUnitSize")]
protected virtual bool OnGetUnitSize (Gst.Caps caps, out ulong size)
{
return InternalGetUnitSize (caps, out size);
}
private bool InternalGetUnitSize (Gst.Caps caps, out ulong size)
{
GetUnitSizeNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_unit_size"));
unmanaged = (GetUnitSizeNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetUnitSizeNativeDelegate));
}
if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
UIntPtr native_size;
bool __result = unmanaged (this.Handle, caps == null ? IntPtr.Zero : caps.Handle, out native_size);
size = (ulong) native_size;
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 {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
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.BaseTransform), ConnectionMethod="OverrideStart")]
protected virtual bool OnStart ()
{
return InternalStart ();
}
private bool InternalStart ()
{
StartNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("start"));
unmanaged = (StartNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(StartNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle);
return __result;
}
static StopNativeDelegate Stop_cb_delegate;
static StopNativeDelegate StopVMCallback {
get {
if (Stop_cb_delegate == null)
Stop_cb_delegate = new StopNativeDelegate (Stop_cb);
return Stop_cb_delegate;
}
}
static void OverrideStop (GLib.GType gtype)
{
OverrideStop (gtype, StopVMCallback);
}
static void OverrideStop (GLib.GType gtype, StopNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("stop"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool StopNativeDelegate (IntPtr inst);
static bool Stop_cb (IntPtr inst)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
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.BaseTransform), 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 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 evnt);
static bool SinkEvent_cb (IntPtr inst, IntPtr evnt)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
__result = __obj.OnSinkEvent (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.BaseTransform), ConnectionMethod="OverrideSinkEvent")]
protected virtual bool OnSinkEvent (Gst.Event evnt)
{
return InternalSinkEvent (evnt);
}
private bool InternalSinkEvent (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, evnt == null ? IntPtr.Zero : evnt.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 {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
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.BaseTransform), 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 PrepareOutputBufferNativeDelegate PrepareOutputBuffer_cb_delegate;
static PrepareOutputBufferNativeDelegate PrepareOutputBufferVMCallback {
get {
if (PrepareOutputBuffer_cb_delegate == null)
PrepareOutputBuffer_cb_delegate = new PrepareOutputBufferNativeDelegate (PrepareOutputBuffer_cb);
return PrepareOutputBuffer_cb_delegate;
}
}
static void OverridePrepareOutputBuffer (GLib.GType gtype)
{
OverridePrepareOutputBuffer (gtype, PrepareOutputBufferVMCallback);
}
static void OverridePrepareOutputBuffer (GLib.GType gtype, PrepareOutputBufferNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare_output_buffer"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int PrepareOutputBufferNativeDelegate (IntPtr inst, IntPtr input, out IntPtr outbuf);
static int PrepareOutputBuffer_cb (IntPtr inst, IntPtr input, out IntPtr outbuf)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
Gst.FlowReturn __result;
Gst.Buffer myoutbuf;
__result = __obj.OnPrepareOutputBuffer (input == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (input, typeof (Gst.Buffer), false), out myoutbuf);
outbuf = myoutbuf == null ? IntPtr.Zero : myoutbuf.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.BaseTransform), ConnectionMethod="OverridePrepareOutputBuffer")]
protected virtual Gst.FlowReturn OnPrepareOutputBuffer (Gst.Buffer input, out Gst.Buffer outbuf)
{
return InternalPrepareOutputBuffer (input, out outbuf);
}
private Gst.FlowReturn InternalPrepareOutputBuffer (Gst.Buffer input, out Gst.Buffer outbuf)
{
PrepareOutputBufferNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare_output_buffer"));
unmanaged = (PrepareOutputBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrepareOutputBufferNativeDelegate));
}
if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
IntPtr native_outbuf;
int __result = unmanaged (this.Handle, input == null ? IntPtr.Zero : input.Handle, out native_outbuf);
outbuf = native_outbuf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (native_outbuf, typeof (Gst.Buffer), true);
return (Gst.FlowReturn) __result;
}
static CopyMetadataNativeDelegate CopyMetadata_cb_delegate;
static CopyMetadataNativeDelegate CopyMetadataVMCallback {
get {
if (CopyMetadata_cb_delegate == null)
CopyMetadata_cb_delegate = new CopyMetadataNativeDelegate (CopyMetadata_cb);
return CopyMetadata_cb_delegate;
}
}
static void OverrideCopyMetadata (GLib.GType gtype)
{
OverrideCopyMetadata (gtype, CopyMetadataVMCallback);
}
static void OverrideCopyMetadata (GLib.GType gtype, CopyMetadataNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("copy_metadata"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool CopyMetadataNativeDelegate (IntPtr inst, IntPtr input, IntPtr outbuf);
static bool CopyMetadata_cb (IntPtr inst, IntPtr input, IntPtr outbuf)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
__result = __obj.OnCopyMetadata (input == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (input, typeof (Gst.Buffer), false), outbuf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (outbuf, typeof (Gst.Buffer), 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.BaseTransform), ConnectionMethod="OverrideCopyMetadata")]
protected virtual bool OnCopyMetadata (Gst.Buffer input, Gst.Buffer outbuf)
{
return InternalCopyMetadata (input, outbuf);
}
private bool InternalCopyMetadata (Gst.Buffer input, Gst.Buffer outbuf)
{
CopyMetadataNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("copy_metadata"));
unmanaged = (CopyMetadataNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CopyMetadataNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, input == null ? IntPtr.Zero : input.Handle, outbuf == null ? IntPtr.Zero : outbuf.Handle);
return __result;
}
static TransformMetaNativeDelegate TransformMeta_cb_delegate;
static TransformMetaNativeDelegate TransformMetaVMCallback {
get {
if (TransformMeta_cb_delegate == null)
TransformMeta_cb_delegate = new TransformMetaNativeDelegate (TransformMeta_cb);
return TransformMeta_cb_delegate;
}
}
static void OverrideTransformMeta (GLib.GType gtype)
{
OverrideTransformMeta (gtype, TransformMetaVMCallback);
}
static void OverrideTransformMeta (GLib.GType gtype, TransformMetaNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("transform_meta"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool TransformMetaNativeDelegate (IntPtr inst, IntPtr outbuf, IntPtr meta, IntPtr inbuf);
static bool TransformMeta_cb (IntPtr inst, IntPtr outbuf, IntPtr meta, IntPtr inbuf)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
bool __result;
__result = __obj.OnTransformMeta (outbuf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (outbuf, typeof (Gst.Buffer), false), Gst.Meta.New (meta), inbuf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (inbuf, typeof (Gst.Buffer), 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.BaseTransform), ConnectionMethod="OverrideTransformMeta")]
protected virtual bool OnTransformMeta (Gst.Buffer outbuf, Gst.Meta meta, Gst.Buffer inbuf)
{
return InternalTransformMeta (outbuf, meta, inbuf);
}
private bool InternalTransformMeta (Gst.Buffer outbuf, Gst.Meta meta, Gst.Buffer inbuf)
{
TransformMetaNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("transform_meta"));
unmanaged = (TransformMetaNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TransformMetaNativeDelegate));
}
if (unmanaged == null) return false;
IntPtr native_meta = GLib.Marshaller.StructureToPtrAlloc (meta);
bool __result = unmanaged (this.Handle, outbuf == null ? IntPtr.Zero : outbuf.Handle, native_meta, inbuf == null ? IntPtr.Zero : inbuf.Handle);
Marshal.FreeHGlobal (native_meta);
return __result;
}
static BeforeTransformNativeDelegate BeforeTransform_cb_delegate;
static BeforeTransformNativeDelegate BeforeTransformVMCallback {
get {
if (BeforeTransform_cb_delegate == null)
BeforeTransform_cb_delegate = new BeforeTransformNativeDelegate (BeforeTransform_cb);
return BeforeTransform_cb_delegate;
}
}
static void OverrideBeforeTransform (GLib.GType gtype)
{
OverrideBeforeTransform (gtype, BeforeTransformVMCallback);
}
static void OverrideBeforeTransform (GLib.GType gtype, BeforeTransformNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("before_transform"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void BeforeTransformNativeDelegate (IntPtr inst, IntPtr buffer);
static void BeforeTransform_cb (IntPtr inst, IntPtr buffer)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
__obj.OnBeforeTransform (buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), false));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseTransform), ConnectionMethod="OverrideBeforeTransform")]
protected virtual void OnBeforeTransform (Gst.Buffer buffer)
{
InternalBeforeTransform (buffer);
}
private void InternalBeforeTransform (Gst.Buffer buffer)
{
BeforeTransformNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("before_transform"));
unmanaged = (BeforeTransformNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(BeforeTransformNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
}
static TransformNativeDelegate Transform_cb_delegate;
static TransformNativeDelegate TransformVMCallback {
get {
if (Transform_cb_delegate == null)
Transform_cb_delegate = new TransformNativeDelegate (Transform_cb);
return Transform_cb_delegate;
}
}
static void OverrideTransform (GLib.GType gtype)
{
OverrideTransform (gtype, TransformVMCallback);
}
static void OverrideTransform (GLib.GType gtype, TransformNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("transform"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int TransformNativeDelegate (IntPtr inst, IntPtr inbuf, IntPtr outbuf);
static int Transform_cb (IntPtr inst, IntPtr inbuf, IntPtr outbuf)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
Gst.FlowReturn __result;
__result = __obj.OnTransform (inbuf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (inbuf, typeof (Gst.Buffer), false), outbuf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (outbuf, typeof (Gst.Buffer), false));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseTransform), ConnectionMethod="OverrideTransform")]
protected virtual Gst.FlowReturn OnTransform (Gst.Buffer inbuf, Gst.Buffer outbuf)
{
return InternalTransform (inbuf, outbuf);
}
private Gst.FlowReturn InternalTransform (Gst.Buffer inbuf, Gst.Buffer outbuf)
{
TransformNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("transform"));
unmanaged = (TransformNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TransformNativeDelegate));
}
if (unmanaged == null) return (Gst.FlowReturn) 0;
int __result = unmanaged (this.Handle, inbuf == null ? IntPtr.Zero : inbuf.Handle, outbuf == null ? IntPtr.Zero : outbuf.Handle);
return (Gst.FlowReturn) __result;
}
static TransformIpNativeDelegate TransformIp_cb_delegate;
static TransformIpNativeDelegate TransformIpVMCallback {
get {
if (TransformIp_cb_delegate == null)
TransformIp_cb_delegate = new TransformIpNativeDelegate (TransformIp_cb);
return TransformIp_cb_delegate;
}
}
static void OverrideTransformIp (GLib.GType gtype)
{
OverrideTransformIp (gtype, TransformIpVMCallback);
}
static void OverrideTransformIp (GLib.GType gtype, TransformIpNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("transform_ip"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int TransformIpNativeDelegate (IntPtr inst, IntPtr buf);
static int TransformIp_cb (IntPtr inst, IntPtr buf)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
Gst.FlowReturn __result;
__result = __obj.OnTransformIp (buf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buf, typeof (Gst.Buffer), false));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseTransform), ConnectionMethod="OverrideTransformIp")]
protected virtual Gst.FlowReturn OnTransformIp (Gst.Buffer buf)
{
return InternalTransformIp (buf);
}
private Gst.FlowReturn InternalTransformIp (Gst.Buffer buf)
{
TransformIpNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("transform_ip"));
unmanaged = (TransformIpNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TransformIpNativeDelegate));
}
if (unmanaged == null) return (Gst.FlowReturn) 0;
int __result = unmanaged (this.Handle, buf == null ? IntPtr.Zero : buf.Handle);
return (Gst.FlowReturn) __result;
}
static SubmitInputBufferNativeDelegate SubmitInputBuffer_cb_delegate;
static SubmitInputBufferNativeDelegate SubmitInputBufferVMCallback {
get {
if (SubmitInputBuffer_cb_delegate == null)
SubmitInputBuffer_cb_delegate = new SubmitInputBufferNativeDelegate (SubmitInputBuffer_cb);
return SubmitInputBuffer_cb_delegate;
}
}
static void OverrideSubmitInputBuffer (GLib.GType gtype)
{
OverrideSubmitInputBuffer (gtype, SubmitInputBufferVMCallback);
}
static void OverrideSubmitInputBuffer (GLib.GType gtype, SubmitInputBufferNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("submit_input_buffer"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int SubmitInputBufferNativeDelegate (IntPtr inst, bool is_discont, IntPtr input);
static int SubmitInputBuffer_cb (IntPtr inst, bool is_discont, IntPtr input)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
Gst.FlowReturn __result;
__result = __obj.OnSubmitInputBuffer (is_discont, input == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (input, typeof (Gst.Buffer), false));
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.BaseTransform), ConnectionMethod="OverrideSubmitInputBuffer")]
protected virtual Gst.FlowReturn OnSubmitInputBuffer (bool is_discont, Gst.Buffer input)
{
return InternalSubmitInputBuffer (is_discont, input);
}
private Gst.FlowReturn InternalSubmitInputBuffer (bool is_discont, Gst.Buffer input)
{
SubmitInputBufferNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("submit_input_buffer"));
unmanaged = (SubmitInputBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SubmitInputBufferNativeDelegate));
}
if (unmanaged == null) return (Gst.FlowReturn) 0;
int __result = unmanaged (this.Handle, is_discont, input == null ? IntPtr.Zero : input.Handle);
return (Gst.FlowReturn) __result;
}
static GenerateOutputNativeDelegate GenerateOutput_cb_delegate;
static GenerateOutputNativeDelegate GenerateOutputVMCallback {
get {
if (GenerateOutput_cb_delegate == null)
GenerateOutput_cb_delegate = new GenerateOutputNativeDelegate (GenerateOutput_cb);
return GenerateOutput_cb_delegate;
}
}
static void OverrideGenerateOutput (GLib.GType gtype)
{
OverrideGenerateOutput (gtype, GenerateOutputVMCallback);
}
static void OverrideGenerateOutput (GLib.GType gtype, GenerateOutputNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("generate_output"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int GenerateOutputNativeDelegate (IntPtr inst, out IntPtr outbuf);
static int GenerateOutput_cb (IntPtr inst, out IntPtr outbuf)
{
try {
BaseTransform __obj = GLib.Object.GetObject (inst, false) as BaseTransform;
Gst.FlowReturn __result;
Gst.Buffer myoutbuf;
__result = __obj.OnGenerateOutput (out myoutbuf);
outbuf = myoutbuf == null ? IntPtr.Zero : myoutbuf.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.BaseTransform), ConnectionMethod="OverrideGenerateOutput")]
protected virtual Gst.FlowReturn OnGenerateOutput (out Gst.Buffer outbuf)
{
return InternalGenerateOutput (out outbuf);
}
private Gst.FlowReturn InternalGenerateOutput (out Gst.Buffer outbuf)
{
GenerateOutputNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("generate_output"));
unmanaged = (GenerateOutputNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GenerateOutputNativeDelegate));
}
if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
IntPtr native_outbuf;
int __result = unmanaged (this.Handle, out native_outbuf);
outbuf = native_outbuf == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (native_outbuf, typeof (Gst.Buffer), true);
return (Gst.FlowReturn) __result;
}
// Internal representation of the wrapped structure ABI.
static GLib.AbiStruct _class_abi = null;
static public new GLib.AbiStruct class_abi {
get {
if (_class_abi == null)
_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{
new GLib.AbiField("passthrough_on_same_caps"
, Gst.Element.class_abi.Fields
, (uint) Marshal.SizeOf(typeof(bool)) // passthrough_on_same_caps
, null
, "transform_ip_on_passthrough"
, (long) Marshal.OffsetOf(typeof(GstBaseTransform_passthrough_on_same_capsAlign), "passthrough_on_same_caps")
, 0
),
new GLib.AbiField("transform_ip_on_passthrough"
, -1
, (uint) Marshal.SizeOf(typeof(bool)) // transform_ip_on_passthrough
, "passthrough_on_same_caps"
, "transform_caps"
, (long) Marshal.OffsetOf(typeof(GstBaseTransform_transform_ip_on_passthroughAlign), "transform_ip_on_passthrough")
, 0
),
new GLib.AbiField("transform_caps"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // transform_caps
, "transform_ip_on_passthrough"
, "fixate_caps"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("fixate_caps"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // fixate_caps
, "transform_caps"
, "accept_caps"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("accept_caps"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // accept_caps
, "fixate_caps"
, "set_caps"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("set_caps"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_caps
, "accept_caps"
, "query"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("query"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // query
, "set_caps"
, "decide_allocation"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("decide_allocation"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // decide_allocation
, "query"
, "filter_meta"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("filter_meta"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // filter_meta
, "decide_allocation"
, "propose_allocation"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("propose_allocation"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // propose_allocation
, "filter_meta"
, "transform_size"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("transform_size"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // transform_size
, "propose_allocation"
, "get_unit_size"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("get_unit_size"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_unit_size
, "transform_size"
, "start"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("start"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // start
, "get_unit_size"
, "stop"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("stop"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // stop
, "start"
, "sink_event"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("sink_event"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // sink_event
, "stop"
, "src_event"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("src_event"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // src_event
, "sink_event"
, "prepare_output_buffer"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("prepare_output_buffer"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // prepare_output_buffer
, "src_event"
, "copy_metadata"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("copy_metadata"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // copy_metadata
, "prepare_output_buffer"
, "transform_meta"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("transform_meta"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // transform_meta
, "copy_metadata"
, "before_transform"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("before_transform"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // before_transform
, "transform_meta"
, "transform"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("transform"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // transform
, "before_transform"
, "transform_ip"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("transform_ip"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // transform_ip
, "transform"
, "submit_input_buffer"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("submit_input_buffer"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // submit_input_buffer
, "transform_ip"
, "generate_output"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("generate_output"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // generate_output
, "submit_input_buffer"
, "_gst_reserved"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("_gst_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 18 // _gst_reserved
, "generate_output"
, null
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
});
return _class_abi;
}
}
[StructLayout(LayoutKind.Sequential)]
public struct GstBaseTransform_passthrough_on_same_capsAlign
{
sbyte f1;
private bool passthrough_on_same_caps;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstBaseTransform_transform_ip_on_passthroughAlign
{
sbyte f1;
private bool transform_ip_on_passthrough;
}
// End of the ABI representation.
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_base_transform_get_type();
public static new GLib.GType GType {
get {
IntPtr raw_ret = gst_base_transform_get_type();
GLib.GType ret = new GLib.GType(raw_ret);
return ret;
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_get_allocator(IntPtr raw, out IntPtr allocator, IntPtr parms);
public void GetAllocator(out Gst.Allocator allocator, out Gst.AllocationParams parms) {
IntPtr native_allocator;
IntPtr native_parms = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (Gst.AllocationParams)));
gst_base_transform_get_allocator(Handle, out native_allocator, native_parms);
allocator = GLib.Object.GetObject(native_allocator, true) as Gst.Allocator;
parms = Gst.AllocationParams.New (native_parms);
Marshal.FreeHGlobal (native_parms);
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_base_transform_get_buffer_pool(IntPtr raw);
public Gst.BufferPool BufferPool {
get {
IntPtr raw_ret = gst_base_transform_get_buffer_pool(Handle);
Gst.BufferPool ret = GLib.Object.GetObject(raw_ret, true) as Gst.BufferPool;
return ret;
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_base_transform_is_in_place(IntPtr raw);
public bool IsInPlace {
get {
bool raw_ret = gst_base_transform_is_in_place(Handle);
bool ret = raw_ret;
return ret;
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_base_transform_is_passthrough(IntPtr raw);
public bool IsPassthrough {
get {
bool raw_ret = gst_base_transform_is_passthrough(Handle);
bool ret = raw_ret;
return ret;
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_base_transform_is_qos_enabled(IntPtr raw);
public bool IsQosEnabled {
get {
bool raw_ret = gst_base_transform_is_qos_enabled(Handle);
bool ret = raw_ret;
return ret;
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_base_transform_reconfigure(IntPtr raw);
public bool Reconfigure() {
bool raw_ret = gst_base_transform_reconfigure(Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_reconfigure_sink(IntPtr raw);
public void ReconfigureSink() {
gst_base_transform_reconfigure_sink(Handle);
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_reconfigure_src(IntPtr raw);
public void ReconfigureSrc() {
gst_base_transform_reconfigure_src(Handle);
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_set_gap_aware(IntPtr raw, bool gap_aware);
public bool GapAware {
set {
gst_base_transform_set_gap_aware(Handle, value);
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_set_in_place(IntPtr raw, bool in_place);
public bool InPlace {
set {
gst_base_transform_set_in_place(Handle, value);
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_set_passthrough(IntPtr raw, bool passthrough);
public bool Passthrough {
set {
gst_base_transform_set_passthrough(Handle, value);
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_set_prefer_passthrough(IntPtr raw, bool prefer_passthrough);
public bool PreferPassthrough {
set {
gst_base_transform_set_prefer_passthrough(Handle, value);
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_set_qos_enabled(IntPtr raw, bool enabled);
public bool QosEnabled {
set {
gst_base_transform_set_qos_enabled(Handle, value);
}
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_base_transform_update_qos(IntPtr raw, double proportion, long diff, ulong timestamp);
public void UpdateQos(double proportion, long diff, ulong timestamp) {
gst_base_transform_update_qos(Handle, proportion, diff, timestamp);
}
[DllImport("gstbase-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_base_transform_update_src_caps(IntPtr raw, IntPtr updated_caps);
public bool UpdateSrcCaps(Gst.Caps updated_caps) {
bool raw_ret = gst_base_transform_update_src_caps(Handle, updated_caps == null ? IntPtr.Zero : updated_caps.Handle);
bool ret = raw_ret;
return ret;
}
static BaseTransform ()
{
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("sinkpad"
, Gst.Element.abi_info.Fields
, (uint) Marshal.SizeOf(typeof(IntPtr)) // sinkpad
, null
, "srcpad"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("srcpad"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // srcpad
, "sinkpad"
, "have_segment"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("have_segment"
, -1
, (uint) Marshal.SizeOf(typeof(bool)) // have_segment
, "srcpad"
, "segment"
, (long) Marshal.OffsetOf(typeof(GstBaseTransform_have_segmentAlign), "have_segment")
, 0
),
new GLib.AbiField("segment"
, -1
, (uint) Marshal.SizeOf(typeof(Gst.Segment)) // segment
, "have_segment"
, "queued_buf"
, (long) Marshal.OffsetOf(typeof(GstBaseTransform_segmentAlign), "segment")
, 0
),
new GLib.AbiField("queued_buf"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // queued_buf
, "segment"
, "priv"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("priv"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
, "queued_buf"
, "_gst_reserved"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("_gst_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 19 // _gst_reserved
, "priv"
, null
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
});
return _abi_info;
}
}
[StructLayout(LayoutKind.Sequential)]
public struct GstBaseTransform_have_segmentAlign
{
sbyte f1;
private bool have_segment;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstBaseTransform_segmentAlign
{
sbyte f1;
private Gst.Segment segment;
}
// End of the ABI representation.
#endregion
}
}
Reference in a new issue View git blame Copy permalink