mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-23 20:40:24 +00:00
2d00f898fb
Making it cleaner and simpler to navigate and removing previous ugly and now useless hack where we were renaming files ourself to make meson happy.
1835 lines
65 KiB
C#
1835 lines
65 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 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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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("libgstbase-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
|
|
}
|
|
}
|