gstreamer/sources/generated/Gst/Element.cs
2020-06-17 21:16:40 -04:00

2317 lines
78 KiB
C#

// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.
namespace Gst {
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
#region Autogenerated code
public partial class Element : Gst.Object {
protected Element (IntPtr raw) : base(raw) {}
protected Element() : base(IntPtr.Zero)
{
CreateNativeObject (new string [0], new GLib.Value [0]);
}
public GLib.RecMutex StateLock {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("state_lock"));
return new GLib.RecMutex((*raw_ptr));
}
}
}
public GLib.Cond StateCond {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("state_cond"));
return new GLib.Cond((*raw_ptr));
}
}
}
public uint StateCookie {
get {
unsafe {
uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("state_cookie"));
return (*raw_ptr);
}
}
}
public Gst.State TargetState {
get {
unsafe {
int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("target_state"));
return (Gst.State) (*raw_ptr);
}
}
}
public Gst.State CurrentState {
get {
unsafe {
int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("current_state"));
return (Gst.State) (*raw_ptr);
}
}
}
public Gst.State NextState {
get {
unsafe {
int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("next_state"));
return (Gst.State) (*raw_ptr);
}
}
}
public Gst.State PendingState {
get {
unsafe {
int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("pending_state"));
return (Gst.State) (*raw_ptr);
}
}
}
public Gst.StateChangeReturn LastReturn {
get {
unsafe {
int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("last_return"));
return (Gst.StateChangeReturn) (*raw_ptr);
}
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_bus(IntPtr raw);
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_set_bus(IntPtr raw, IntPtr bus);
public Gst.Bus Bus {
get {
IntPtr raw_ret = gst_element_get_bus(Handle);
Gst.Bus ret = GLib.Object.GetObject(raw_ret, true) as Gst.Bus;
return ret;
}
set {
gst_element_set_bus(Handle, value == null ? IntPtr.Zero : value.Handle);
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_clock(IntPtr raw);
public Gst.Clock Clock {
get {
IntPtr raw_ret = gst_element_get_clock(Handle);
Gst.Clock ret = GLib.Object.GetObject(raw_ret, true) as Gst.Clock;
return ret;
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern ulong gst_element_get_base_time(IntPtr raw);
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_set_base_time(IntPtr raw, ulong time);
public ulong BaseTime {
get {
ulong raw_ret = gst_element_get_base_time(Handle);
ulong ret = raw_ret;
return ret;
}
set {
gst_element_set_base_time(Handle, value);
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern ulong gst_element_get_start_time(IntPtr raw);
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_set_start_time(IntPtr raw, ulong time);
public ulong StartTime {
get {
ulong raw_ret = gst_element_get_start_time(Handle);
ulong ret = raw_ret;
return ret;
}
set {
gst_element_set_start_time(Handle, value);
}
}
public ushort Numpads {
get {
unsafe {
ushort* raw_ptr = (ushort*)(((byte*)Handle) + abi_info.GetFieldOffset("numpads"));
return (*raw_ptr);
}
}
}
public GLib.List Pads {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("pads"));
return new GLib.List((*raw_ptr));
}
}
}
public ushort Numsrcpads {
get {
unsafe {
ushort* raw_ptr = (ushort*)(((byte*)Handle) + abi_info.GetFieldOffset("numsrcpads"));
return (*raw_ptr);
}
}
}
public GLib.List Srcpads {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("srcpads"));
return new GLib.List((*raw_ptr));
}
}
}
public ushort Numsinkpads {
get {
unsafe {
ushort* raw_ptr = (ushort*)(((byte*)Handle) + abi_info.GetFieldOffset("numsinkpads"));
return (*raw_ptr);
}
}
}
public GLib.List Sinkpads {
get {
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("sinkpads"));
return new GLib.List((*raw_ptr));
}
}
}
public uint PadsCookie {
get {
unsafe {
uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("pads_cookie"));
return (*raw_ptr);
}
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_contexts(IntPtr raw);
public GLib.List[] Contexts {
get {
IntPtr raw_ret = gst_element_get_contexts(Handle);
GLib.List[] ret = (GLib.List[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GLib.List));
return ret;
}
}
[GLib.Signal("no-more-pads")]
public event System.EventHandler NoMorePadsEvent {
add {
this.AddSignalHandler ("no-more-pads", value);
}
remove {
this.RemoveSignalHandler ("no-more-pads", value);
}
}
[GLib.Signal("pad-removed")]
public event Gst.PadRemovedHandler PadRemoved {
add {
this.AddSignalHandler ("pad-removed", value, typeof (Gst.PadRemovedArgs));
}
remove {
this.RemoveSignalHandler ("pad-removed", value);
}
}
[GLib.Signal("pad-added")]
public event Gst.PadAddedHandler PadAdded {
add {
this.AddSignalHandler ("pad-added", value, typeof (Gst.PadAddedArgs));
}
remove {
this.RemoveSignalHandler ("pad-added", value);
}
}
static PadAddedNativeDelegate PadAdded_cb_delegate;
static PadAddedNativeDelegate PadAddedVMCallback {
get {
if (PadAdded_cb_delegate == null)
PadAdded_cb_delegate = new PadAddedNativeDelegate (PadAdded_cb);
return PadAdded_cb_delegate;
}
}
static void OverridePadAdded (GLib.GType gtype)
{
OverridePadAdded (gtype, PadAddedVMCallback);
}
static void OverridePadAdded (GLib.GType gtype, PadAddedNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pad_added"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void PadAddedNativeDelegate (IntPtr inst, IntPtr new_pad);
static void PadAdded_cb (IntPtr inst, IntPtr new_pad)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
__obj.OnPadAdded (GLib.Object.GetObject(new_pad) as Gst.Pad);
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverridePadAdded")]
protected virtual void OnPadAdded (Gst.Pad new_pad)
{
InternalPadAdded (new_pad);
}
private void InternalPadAdded (Gst.Pad new_pad)
{
PadAddedNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pad_added"));
unmanaged = (PadAddedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PadAddedNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle, new_pad == null ? IntPtr.Zero : new_pad.Handle);
}
static PadRemovedNativeDelegate PadRemoved_cb_delegate;
static PadRemovedNativeDelegate PadRemovedVMCallback {
get {
if (PadRemoved_cb_delegate == null)
PadRemoved_cb_delegate = new PadRemovedNativeDelegate (PadRemoved_cb);
return PadRemoved_cb_delegate;
}
}
static void OverridePadRemoved (GLib.GType gtype)
{
OverridePadRemoved (gtype, PadRemovedVMCallback);
}
static void OverridePadRemoved (GLib.GType gtype, PadRemovedNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("pad_removed"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void PadRemovedNativeDelegate (IntPtr inst, IntPtr old_pad);
static void PadRemoved_cb (IntPtr inst, IntPtr old_pad)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
__obj.OnPadRemoved (GLib.Object.GetObject(old_pad) as Gst.Pad);
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverridePadRemoved")]
protected virtual void OnPadRemoved (Gst.Pad old_pad)
{
InternalPadRemoved (old_pad);
}
private void InternalPadRemoved (Gst.Pad old_pad)
{
PadRemovedNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("pad_removed"));
unmanaged = (PadRemovedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PadRemovedNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle, old_pad == null ? IntPtr.Zero : old_pad.Handle);
}
static NoMorePadsEventNativeDelegate NoMorePadsEvent_cb_delegate;
static NoMorePadsEventNativeDelegate NoMorePadsEventVMCallback {
get {
if (NoMorePadsEvent_cb_delegate == null)
NoMorePadsEvent_cb_delegate = new NoMorePadsEventNativeDelegate (NoMorePadsEvent_cb);
return NoMorePadsEvent_cb_delegate;
}
}
static void OverrideNoMorePadsEvent (GLib.GType gtype)
{
OverrideNoMorePadsEvent (gtype, NoMorePadsEventVMCallback);
}
static void OverrideNoMorePadsEvent (GLib.GType gtype, NoMorePadsEventNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("no_more_pads"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void NoMorePadsEventNativeDelegate (IntPtr inst);
static void NoMorePadsEvent_cb (IntPtr inst)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
__obj.OnNoMorePadsEvent ();
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideNoMorePadsEvent")]
protected virtual void OnNoMorePadsEvent ()
{
InternalNoMorePadsEvent ();
}
private void InternalNoMorePadsEvent ()
{
NoMorePadsEventNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("no_more_pads"));
unmanaged = (NoMorePadsEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NoMorePadsEventNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle);
}
static RequestNewPadNativeDelegate RequestNewPad_cb_delegate;
static RequestNewPadNativeDelegate RequestNewPadVMCallback {
get {
if (RequestNewPad_cb_delegate == null)
RequestNewPad_cb_delegate = new RequestNewPadNativeDelegate (RequestNewPad_cb);
return RequestNewPad_cb_delegate;
}
}
static void OverrideRequestNewPad (GLib.GType gtype)
{
OverrideRequestNewPad (gtype, RequestNewPadVMCallback);
}
static void OverrideRequestNewPad (GLib.GType gtype, RequestNewPadNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("request_new_pad"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr RequestNewPadNativeDelegate (IntPtr inst, IntPtr templ, IntPtr name, IntPtr caps);
static IntPtr RequestNewPad_cb (IntPtr inst, IntPtr templ, IntPtr name, IntPtr caps)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
Gst.Pad __result;
__result = __obj.OnRequestNewPad (GLib.Object.GetObject(templ) as Gst.PadTemplate, GLib.Marshaller.Utf8PtrToString (name), caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false));
return __result == null ? IntPtr.Zero : __result.OwnedHandle;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideRequestNewPad")]
protected virtual Gst.Pad OnRequestNewPad (Gst.PadTemplate templ, string name, Gst.Caps caps)
{
return InternalRequestNewPad (templ, name, caps);
}
private Gst.Pad InternalRequestNewPad (Gst.PadTemplate templ, string name, Gst.Caps caps)
{
RequestNewPadNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("request_new_pad"));
unmanaged = (RequestNewPadNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RequestNewPadNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
IntPtr __result = unmanaged (this.Handle, templ == null ? IntPtr.Zero : templ.Handle, native_name, caps == null ? IntPtr.Zero : caps.Handle);
GLib.Marshaller.Free (native_name);
return GLib.Object.GetObject(__result, true) as Gst.Pad;
}
static ReleasePadNativeDelegate ReleasePad_cb_delegate;
static ReleasePadNativeDelegate ReleasePadVMCallback {
get {
if (ReleasePad_cb_delegate == null)
ReleasePad_cb_delegate = new ReleasePadNativeDelegate (ReleasePad_cb);
return ReleasePad_cb_delegate;
}
}
static void OverrideReleasePad (GLib.GType gtype)
{
OverrideReleasePad (gtype, ReleasePadVMCallback);
}
static void OverrideReleasePad (GLib.GType gtype, ReleasePadNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("release_pad"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void ReleasePadNativeDelegate (IntPtr inst, IntPtr pad);
static void ReleasePad_cb (IntPtr inst, IntPtr pad)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
__obj.OnReleasePad (GLib.Object.GetObject(pad) as Gst.Pad);
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideReleasePad")]
protected virtual void OnReleasePad (Gst.Pad pad)
{
InternalReleasePad (pad);
}
private void InternalReleasePad (Gst.Pad pad)
{
ReleasePadNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("release_pad"));
unmanaged = (ReleasePadNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ReleasePadNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle, pad == null ? IntPtr.Zero : pad.Handle);
}
static GetStateNativeDelegate GetState_cb_delegate;
static GetStateNativeDelegate GetStateVMCallback {
get {
if (GetState_cb_delegate == null)
GetState_cb_delegate = new GetStateNativeDelegate (GetState_cb);
return GetState_cb_delegate;
}
}
static void OverrideGetState (GLib.GType gtype)
{
OverrideGetState (gtype, GetStateVMCallback);
}
static void OverrideGetState (GLib.GType gtype, GetStateNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_state"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int GetStateNativeDelegate (IntPtr inst, out int state, out int pending, ulong timeout);
static int GetState_cb (IntPtr inst, out int state, out int pending, ulong timeout)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
Gst.StateChangeReturn __result;
Gst.State mystate;
Gst.State mypending;
__result = __obj.OnGetState (out mystate, out mypending, timeout);
state = (int) mystate;
pending = (int) mypending;
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideGetState")]
protected virtual Gst.StateChangeReturn OnGetState (out Gst.State state, out Gst.State pending, ulong timeout)
{
return InternalGetState (out state, out pending, timeout);
}
private Gst.StateChangeReturn InternalGetState (out Gst.State state, out Gst.State pending, ulong timeout)
{
GetStateNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_state"));
unmanaged = (GetStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetStateNativeDelegate));
}
if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
int native_state;
int native_pending;
int __result = unmanaged (this.Handle, out native_state, out native_pending, timeout);
state = (Gst.State) native_state;
pending = (Gst.State) native_pending;
return (Gst.StateChangeReturn) __result;
}
static SetStateNativeDelegate SetState_cb_delegate;
static SetStateNativeDelegate SetStateVMCallback {
get {
if (SetState_cb_delegate == null)
SetState_cb_delegate = new SetStateNativeDelegate (SetState_cb);
return SetState_cb_delegate;
}
}
static void OverrideSetState (GLib.GType gtype)
{
OverrideSetState (gtype, SetStateVMCallback);
}
static void OverrideSetState (GLib.GType gtype, SetStateNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_state"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int SetStateNativeDelegate (IntPtr inst, int state);
static int SetState_cb (IntPtr inst, int state)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
Gst.StateChangeReturn __result;
__result = __obj.OnSetState ((Gst.State) state);
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSetState")]
protected virtual Gst.StateChangeReturn OnSetState (Gst.State state)
{
return InternalSetState (state);
}
private Gst.StateChangeReturn InternalSetState (Gst.State state)
{
SetStateNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_state"));
unmanaged = (SetStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetStateNativeDelegate));
}
if (unmanaged == null) return (Gst.StateChangeReturn) 0;
int __result = unmanaged (this.Handle, (int) state);
return (Gst.StateChangeReturn) __result;
}
static ChangeStateNativeDelegate ChangeState_cb_delegate;
static ChangeStateNativeDelegate ChangeStateVMCallback {
get {
if (ChangeState_cb_delegate == null)
ChangeState_cb_delegate = new ChangeStateNativeDelegate (ChangeState_cb);
return ChangeState_cb_delegate;
}
}
static void OverrideChangeState (GLib.GType gtype)
{
OverrideChangeState (gtype, ChangeStateVMCallback);
}
static void OverrideChangeState (GLib.GType gtype, ChangeStateNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("change_state"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate int ChangeStateNativeDelegate (IntPtr inst, int transition);
static int ChangeState_cb (IntPtr inst, int transition)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
Gst.StateChangeReturn __result;
__result = __obj.OnChangeState ((Gst.StateChange) transition);
return (int) __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideChangeState")]
protected virtual Gst.StateChangeReturn OnChangeState (Gst.StateChange transition)
{
return InternalChangeState (transition);
}
private Gst.StateChangeReturn InternalChangeState (Gst.StateChange transition)
{
ChangeStateNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("change_state"));
unmanaged = (ChangeStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChangeStateNativeDelegate));
}
if (unmanaged == null) return (Gst.StateChangeReturn) 0;
int __result = unmanaged (this.Handle, (int) transition);
return (Gst.StateChangeReturn) __result;
}
static StateChangedNativeDelegate StateChanged_cb_delegate;
static StateChangedNativeDelegate StateChangedVMCallback {
get {
if (StateChanged_cb_delegate == null)
StateChanged_cb_delegate = new StateChangedNativeDelegate (StateChanged_cb);
return StateChanged_cb_delegate;
}
}
static void OverrideStateChanged (GLib.GType gtype)
{
OverrideStateChanged (gtype, StateChangedVMCallback);
}
static void OverrideStateChanged (GLib.GType gtype, StateChangedNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("state_changed"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void StateChangedNativeDelegate (IntPtr inst, int oldstate, int newstate, int pending);
static void StateChanged_cb (IntPtr inst, int oldstate, int newstate, int pending)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
__obj.OnStateChanged ((Gst.State) oldstate, (Gst.State) newstate, (Gst.State) pending);
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideStateChanged")]
protected virtual void OnStateChanged (Gst.State oldstate, Gst.State newstate, Gst.State pending)
{
InternalStateChanged (oldstate, newstate, pending);
}
private void InternalStateChanged (Gst.State oldstate, Gst.State newstate, Gst.State pending)
{
StateChangedNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("state_changed"));
unmanaged = (StateChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(StateChangedNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle, (int) oldstate, (int) newstate, (int) pending);
}
static SetBusNativeDelegate SetBus_cb_delegate;
static SetBusNativeDelegate SetBusVMCallback {
get {
if (SetBus_cb_delegate == null)
SetBus_cb_delegate = new SetBusNativeDelegate (SetBus_cb);
return SetBus_cb_delegate;
}
}
static void OverrideSetBus (GLib.GType gtype)
{
OverrideSetBus (gtype, SetBusVMCallback);
}
static void OverrideSetBus (GLib.GType gtype, SetBusNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_bus"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void SetBusNativeDelegate (IntPtr inst, IntPtr bus);
static void SetBus_cb (IntPtr inst, IntPtr bus)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
__obj.OnSetBus (GLib.Object.GetObject(bus) as Gst.Bus);
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSetBus")]
protected virtual void OnSetBus (Gst.Bus bus)
{
InternalSetBus (bus);
}
private void InternalSetBus (Gst.Bus bus)
{
SetBusNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_bus"));
unmanaged = (SetBusNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetBusNativeDelegate));
}
if (unmanaged == null) return;
unmanaged (this.Handle, bus == null ? IntPtr.Zero : bus.Handle);
}
static ProvideClockNativeDelegate ProvideClock_cb_delegate;
static ProvideClockNativeDelegate ProvideClockVMCallback {
get {
if (ProvideClock_cb_delegate == null)
ProvideClock_cb_delegate = new ProvideClockNativeDelegate (ProvideClock_cb);
return ProvideClock_cb_delegate;
}
}
static void OverrideProvideClock (GLib.GType gtype)
{
OverrideProvideClock (gtype, ProvideClockVMCallback);
}
static void OverrideProvideClock (GLib.GType gtype, ProvideClockNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("provide_clock"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate IntPtr ProvideClockNativeDelegate (IntPtr inst);
static IntPtr ProvideClock_cb (IntPtr inst)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
Gst.Clock __result;
__result = __obj.OnProvideClock ();
return __result == null ? IntPtr.Zero : __result.OwnedHandle;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideProvideClock")]
protected virtual Gst.Clock OnProvideClock ()
{
return InternalProvideClock ();
}
private Gst.Clock InternalProvideClock ()
{
ProvideClockNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("provide_clock"));
unmanaged = (ProvideClockNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ProvideClockNativeDelegate));
}
if (unmanaged == null) return null;
IntPtr __result = unmanaged (this.Handle);
return GLib.Object.GetObject(__result, true) as Gst.Clock;
}
static SetClockNativeDelegate SetClock_cb_delegate;
static SetClockNativeDelegate SetClockVMCallback {
get {
if (SetClock_cb_delegate == null)
SetClock_cb_delegate = new SetClockNativeDelegate (SetClock_cb);
return SetClock_cb_delegate;
}
}
static void OverrideSetClock (GLib.GType gtype)
{
OverrideSetClock (gtype, SetClockVMCallback);
}
static void OverrideSetClock (GLib.GType gtype, SetClockNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_clock"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SetClockNativeDelegate (IntPtr inst, IntPtr clock);
static bool SetClock_cb (IntPtr inst, IntPtr clock)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
bool __result;
__result = __obj.OnSetClock (GLib.Object.GetObject(clock) as Gst.Clock);
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSetClock")]
protected virtual bool OnSetClock (Gst.Clock clock)
{
return InternalSetClock (clock);
}
private bool InternalSetClock (Gst.Clock clock)
{
SetClockNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_clock"));
unmanaged = (SetClockNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetClockNativeDelegate));
}
if (unmanaged == null) return false;
bool __result = unmanaged (this.Handle, clock == null ? IntPtr.Zero : clock.Handle);
return __result;
}
static SendEventNativeDelegate SendEvent_cb_delegate;
static SendEventNativeDelegate SendEventVMCallback {
get {
if (SendEvent_cb_delegate == null)
SendEvent_cb_delegate = new SendEventNativeDelegate (SendEvent_cb);
return SendEvent_cb_delegate;
}
}
static void OverrideSendEvent (GLib.GType gtype)
{
OverrideSendEvent (gtype, SendEventVMCallback);
}
static void OverrideSendEvent (GLib.GType gtype, SendEventNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("send_event"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool SendEventNativeDelegate (IntPtr inst, IntPtr evnt);
static bool SendEvent_cb (IntPtr inst, IntPtr evnt)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
bool __result;
__result = __obj.OnSendEvent (evnt == IntPtr.Zero ? null : (Gst.Event) GLib.Opaque.GetOpaque (evnt, typeof (Gst.Event), true));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSendEvent")]
protected virtual bool OnSendEvent (Gst.Event evnt)
{
return InternalSendEvent (evnt);
}
private bool InternalSendEvent (Gst.Event evnt)
{
SendEventNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("send_event"));
unmanaged = (SendEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SendEventNativeDelegate));
}
if (unmanaged == null) return false;
evnt.Owned = false;
bool __result = unmanaged (this.Handle, evnt == null ? IntPtr.Zero : evnt.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, IntPtr query);
static bool Query_cb (IntPtr inst, IntPtr query)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
bool __result;
__result = __obj.OnQuery (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.Element), ConnectionMethod="OverrideQuery")]
protected virtual bool OnQuery (Gst.Query query)
{
return InternalQuery (query);
}
private bool InternalQuery (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, query == null ? IntPtr.Zero : query.Handle);
return __result;
}
static PostMessageNativeDelegate PostMessage_cb_delegate;
static PostMessageNativeDelegate PostMessageVMCallback {
get {
if (PostMessage_cb_delegate == null)
PostMessage_cb_delegate = new PostMessageNativeDelegate (PostMessage_cb);
return PostMessage_cb_delegate;
}
}
static void OverridePostMessage (GLib.GType gtype)
{
OverridePostMessage (gtype, PostMessageVMCallback);
}
static void OverridePostMessage (GLib.GType gtype, PostMessageNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("post_message"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate bool PostMessageNativeDelegate (IntPtr inst, IntPtr message);
static bool PostMessage_cb (IntPtr inst, IntPtr message)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
bool __result;
__result = __obj.OnPostMessage (message == IntPtr.Zero ? null : (Gst.Message) GLib.Opaque.GetOpaque (message, typeof (Gst.Message), true));
return __result;
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, true);
// NOTREACHED: above call does not return.
throw e;
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverridePostMessage")]
protected virtual bool OnPostMessage (Gst.Message message)
{
return InternalPostMessage (message);
}
private bool InternalPostMessage (Gst.Message message)
{
PostMessageNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("post_message"));
unmanaged = (PostMessageNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PostMessageNativeDelegate));
}
if (unmanaged == null) return false;
message.Owned = false;
bool __result = unmanaged (this.Handle, message == null ? IntPtr.Zero : message.Handle);
return __result;
}
static SetContextNativeDelegate SetContext_cb_delegate;
static SetContextNativeDelegate SetContextVMCallback {
get {
if (SetContext_cb_delegate == null)
SetContext_cb_delegate = new SetContextNativeDelegate (SetContext_cb);
return SetContext_cb_delegate;
}
}
static void OverrideSetContext (GLib.GType gtype)
{
OverrideSetContext (gtype, SetContextVMCallback);
}
static void OverrideSetContext (GLib.GType gtype, SetContextNativeDelegate callback)
{
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_context"));
*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
}
}
[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
delegate void SetContextNativeDelegate (IntPtr inst, IntPtr context);
static void SetContext_cb (IntPtr inst, IntPtr context)
{
try {
Element __obj = GLib.Object.GetObject (inst, false) as Element;
__obj.OnSetContext (Gst.Context.New (context));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSetContext")]
protected virtual void OnSetContext (Gst.Context context)
{
InternalSetContext (context);
}
private void InternalSetContext (Gst.Context context)
{
SetContextNativeDelegate unmanaged = null;
unsafe {
IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_context"));
unmanaged = (SetContextNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetContextNativeDelegate));
}
if (unmanaged == null) return;
IntPtr native_context = GLib.Marshaller.StructureToPtrAlloc (context);
unmanaged (this.Handle, native_context);
Marshal.FreeHGlobal (native_context);
}
// 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("metadata"
, Gst.Object.class_abi.Fields
, (uint) Marshal.SizeOf(typeof(IntPtr)) // metadata
, null
, "elementfactory"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("elementfactory"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // elementfactory
, "metadata"
, "padtemplates"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("padtemplates"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // padtemplates
, "elementfactory"
, "numpadtemplates"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("numpadtemplates"
, -1
, (uint) Marshal.SizeOf(typeof(int)) // numpadtemplates
, "padtemplates"
, "pad_templ_cookie"
, (long) Marshal.OffsetOf(typeof(GstElement_numpadtemplatesAlign), "numpadtemplates")
, 0
),
new GLib.AbiField("pad_templ_cookie"
, -1
, (uint) Marshal.SizeOf(typeof(uint)) // pad_templ_cookie
, "numpadtemplates"
, "pad_added"
, (long) Marshal.OffsetOf(typeof(GstElement_pad_templ_cookieAlign), "pad_templ_cookie")
, 0
),
new GLib.AbiField("pad_added"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pad_added
, "pad_templ_cookie"
, "pad_removed"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pad_removed"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pad_removed
, "pad_added"
, "no_more_pads"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("no_more_pads"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // no_more_pads
, "pad_removed"
, "request_new_pad"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("request_new_pad"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // request_new_pad
, "no_more_pads"
, "release_pad"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("release_pad"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // release_pad
, "request_new_pad"
, "get_state"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("get_state"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_state
, "release_pad"
, "set_state"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("set_state"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_state
, "get_state"
, "change_state"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("change_state"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // change_state
, "set_state"
, "state_changed"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("state_changed"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // state_changed
, "change_state"
, "set_bus"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("set_bus"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_bus
, "state_changed"
, "provide_clock"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("provide_clock"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // provide_clock
, "set_bus"
, "set_clock"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("set_clock"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_clock
, "provide_clock"
, "send_event"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("send_event"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // send_event
, "set_clock"
, "query"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("query"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // query
, "send_event"
, "post_message"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("post_message"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // post_message
, "query"
, "set_context"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("set_context"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_context
, "post_message"
, "_gst_reserved"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("_gst_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 18 // _gst_reserved
, "set_context"
, null
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
});
return _class_abi;
}
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_numpadtemplatesAlign
{
sbyte f1;
private int numpadtemplates;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_pad_templ_cookieAlign
{
sbyte f1;
private uint pad_templ_cookie;
}
// End of the ABI representation.
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_type();
public static new GLib.GType GType {
get {
IntPtr raw_ret = gst_element_get_type();
GLib.GType ret = new GLib.GType(raw_ret);
return ret;
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern unsafe IntPtr gst_element_make_from_uri(int type, IntPtr uri, IntPtr elementname, out IntPtr error);
public static unsafe Gst.Element MakeFromUri(Gst.URIType type, string uri, string elementname) {
IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
IntPtr native_elementname = GLib.Marshaller.StringToPtrGStrdup (elementname);
IntPtr error = IntPtr.Zero;
IntPtr raw_ret = gst_element_make_from_uri((int) type, native_uri, native_elementname, out error);
Gst.Element ret = GLib.Object.GetObject(raw_ret) as Gst.Element;
GLib.Marshaller.Free (native_uri);
GLib.Marshaller.Free (native_elementname);
if (error != IntPtr.Zero) throw new GLib.GException (error);
return ret;
}
public static Gst.Element MakeFromUri(Gst.URIType type, string uri) {
return MakeFromUri (type, uri, null);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_register(IntPtr plugin, IntPtr name, uint rank, IntPtr type);
public static bool Register(Gst.Plugin plugin, string name, uint rank, GLib.GType type) {
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
bool raw_ret = gst_element_register(plugin == null ? IntPtr.Zero : plugin.Handle, native_name, rank, type.Val);
bool ret = raw_ret;
GLib.Marshaller.Free (native_name);
return ret;
}
public static bool Register(string name, uint rank, GLib.GType type) {
return Register (null, name, rank, type);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_state_change_return_get_name(int state_ret);
public static string StateChangeReturnGetName(Gst.StateChangeReturn state_ret) {
IntPtr raw_ret = gst_element_state_change_return_get_name((int) state_ret);
string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_state_get_name(int state);
public static string StateGetName(Gst.State state) {
IntPtr raw_ret = gst_element_state_get_name((int) state);
string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_abort_state(IntPtr raw);
public void AbortState() {
gst_element_abort_state(Handle);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_add_pad(IntPtr raw, IntPtr pad);
public bool AddPad(Gst.Pad pad) {
bool raw_ret = gst_element_add_pad(Handle, pad == null ? IntPtr.Zero : pad.Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern UIntPtr gst_element_add_property_deep_notify_watch(IntPtr raw, IntPtr property_name, bool include_value);
public ulong AddPropertyDeepNotifyWatch(string property_name, bool include_value) {
IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
UIntPtr raw_ret = gst_element_add_property_deep_notify_watch(Handle, native_property_name, include_value);
ulong ret = (ulong) raw_ret;
GLib.Marshaller.Free (native_property_name);
return ret;
}
public ulong AddPropertyDeepNotifyWatch(bool include_value) {
return AddPropertyDeepNotifyWatch (null, include_value);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern UIntPtr gst_element_add_property_notify_watch(IntPtr raw, IntPtr property_name, bool include_value);
public ulong AddPropertyNotifyWatch(string property_name, bool include_value) {
IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
UIntPtr raw_ret = gst_element_add_property_notify_watch(Handle, native_property_name, include_value);
ulong ret = (ulong) raw_ret;
GLib.Marshaller.Free (native_property_name);
return ret;
}
public ulong AddPropertyNotifyWatch(bool include_value) {
return AddPropertyNotifyWatch (null, include_value);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_call_async(IntPtr raw, GstSharp.ElementCallAsyncFuncNative func, IntPtr user_data, GLib.DestroyNotify destroy_notify);
public void CallAsync(Gst.ElementCallAsyncFunc func) {
GstSharp.ElementCallAsyncFuncWrapper func_wrapper = new GstSharp.ElementCallAsyncFuncWrapper (func);
IntPtr user_data;
GLib.DestroyNotify destroy_notify;
if (func == null) {
user_data = IntPtr.Zero;
destroy_notify = null;
} else {
user_data = (IntPtr) GCHandle.Alloc (func_wrapper);
destroy_notify = GLib.DestroyHelper.NotifyHandler;
}
gst_element_call_async(Handle, func_wrapper.NativeDelegate, user_data, destroy_notify);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int gst_element_change_state(IntPtr raw, int transition);
public Gst.StateChangeReturn ChangeState(Gst.StateChange transition) {
int raw_ret = gst_element_change_state(Handle, (int) transition);
Gst.StateChangeReturn ret = (Gst.StateChangeReturn) raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int gst_element_continue_state(IntPtr raw, int _ret);
public Gst.StateChangeReturn ContinueState(Gst.StateChangeReturn _ret) {
int raw_ret = gst_element_continue_state(Handle, (int) _ret);
Gst.StateChangeReturn ret = (Gst.StateChangeReturn) raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_create_all_pads(IntPtr raw);
public void CreateAllPads() {
gst_element_create_all_pads(Handle);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_foreach_pad(IntPtr raw, GstSharp.ElementForeachPadFuncNative func, IntPtr user_data);
public bool ForeachPad(Gst.ElementForeachPadFunc func) {
GstSharp.ElementForeachPadFuncWrapper func_wrapper = new GstSharp.ElementForeachPadFuncWrapper (func);
bool raw_ret = gst_element_foreach_pad(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_foreach_sink_pad(IntPtr raw, GstSharp.ElementForeachPadFuncNative func, IntPtr user_data);
public bool ForeachSinkPad(Gst.ElementForeachPadFunc func) {
GstSharp.ElementForeachPadFuncWrapper func_wrapper = new GstSharp.ElementForeachPadFuncWrapper (func);
bool raw_ret = gst_element_foreach_sink_pad(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_foreach_src_pad(IntPtr raw, GstSharp.ElementForeachPadFuncNative func, IntPtr user_data);
public bool ForeachSrcPad(Gst.ElementForeachPadFunc func) {
GstSharp.ElementForeachPadFuncWrapper func_wrapper = new GstSharp.ElementForeachPadFuncWrapper (func);
bool raw_ret = gst_element_foreach_src_pad(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_compatible_pad(IntPtr raw, IntPtr pad, IntPtr caps);
public Gst.Pad GetCompatiblePad(Gst.Pad pad, Gst.Caps caps) {
IntPtr raw_ret = gst_element_get_compatible_pad(Handle, pad == null ? IntPtr.Zero : pad.Handle, caps == null ? IntPtr.Zero : caps.Handle);
Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
return ret;
}
public Gst.Pad GetCompatiblePad(Gst.Pad pad) {
return GetCompatiblePad (pad, null);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_compatible_pad_template(IntPtr raw, IntPtr compattempl);
public Gst.PadTemplate GetCompatiblePadTemplate(Gst.PadTemplate compattempl) {
IntPtr raw_ret = gst_element_get_compatible_pad_template(Handle, compattempl == null ? IntPtr.Zero : compattempl.Handle);
Gst.PadTemplate ret = GLib.Object.GetObject(raw_ret) as Gst.PadTemplate;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_context(IntPtr raw, IntPtr context_type);
public Gst.Context GetContext(string context_type) {
IntPtr native_context_type = GLib.Marshaller.StringToPtrGStrdup (context_type);
IntPtr raw_ret = gst_element_get_context(Handle, native_context_type);
Gst.Context ret = Gst.Context.New (raw_ret);
GLib.Marshaller.Free (native_context_type);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_context_unlocked(IntPtr raw, IntPtr context_type);
public Gst.Context GetContextUnlocked(string context_type) {
IntPtr native_context_type = GLib.Marshaller.StringToPtrGStrdup (context_type);
IntPtr raw_ret = gst_element_get_context_unlocked(Handle, native_context_type);
Gst.Context ret = Gst.Context.New (raw_ret);
GLib.Marshaller.Free (native_context_type);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern ulong gst_element_get_current_clock_time(IntPtr raw);
public ulong CurrentClockTime {
get {
ulong raw_ret = gst_element_get_current_clock_time(Handle);
ulong ret = raw_ret;
return ret;
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern ulong gst_element_get_current_running_time(IntPtr raw);
public ulong CurrentRunningTime {
get {
ulong raw_ret = gst_element_get_current_running_time(Handle);
ulong ret = raw_ret;
return ret;
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_factory(IntPtr raw);
public Gst.ElementFactory Factory {
get {
IntPtr raw_ret = gst_element_get_factory(Handle);
Gst.ElementFactory ret = GLib.Object.GetObject(raw_ret) as Gst.ElementFactory;
return ret;
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_metadata(IntPtr raw, IntPtr key);
public string GetMetadata(string key) {
IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
IntPtr raw_ret = gst_element_get_metadata(Handle, native_key);
string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
GLib.Marshaller.Free (native_key);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_pad_template(IntPtr raw, IntPtr name);
public Gst.PadTemplate GetPadTemplate(string name) {
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
IntPtr raw_ret = gst_element_get_pad_template(Handle, native_name);
Gst.PadTemplate ret = GLib.Object.GetObject(raw_ret) as Gst.PadTemplate;
GLib.Marshaller.Free (native_name);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_pad_template_list(IntPtr raw);
public Gst.PadTemplate[] PadTemplateList {
get {
IntPtr raw_ret = gst_element_get_pad_template_list(Handle);
Gst.PadTemplate[] ret = (Gst.PadTemplate[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), false, false, typeof(Gst.PadTemplate));
return ret;
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_request_pad(IntPtr raw, IntPtr name);
public Gst.Pad GetRequestPad(string name) {
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
IntPtr raw_ret = gst_element_get_request_pad(Handle, native_name);
Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
GLib.Marshaller.Free (native_name);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int gst_element_get_state(IntPtr raw, out int state, out int pending, ulong timeout);
public Gst.StateChangeReturn GetState(out Gst.State state, out Gst.State pending, ulong timeout) {
int native_state;
int native_pending;
int raw_ret = gst_element_get_state(Handle, out native_state, out native_pending, timeout);
Gst.StateChangeReturn ret = (Gst.StateChangeReturn) raw_ret;
state = (Gst.State) native_state;
pending = (Gst.State) native_pending;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_get_static_pad(IntPtr raw, IntPtr name);
public Gst.Pad GetStaticPad(string name) {
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
IntPtr raw_ret = gst_element_get_static_pad(Handle, native_name);
Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
GLib.Marshaller.Free (native_name);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_is_locked_state(IntPtr raw);
public bool IsLockedState {
get {
bool raw_ret = gst_element_is_locked_state(Handle);
bool ret = raw_ret;
return ret;
}
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_iterate_pads(IntPtr raw);
public Gst.Iterator IteratePads() {
IntPtr raw_ret = gst_element_iterate_pads(Handle);
Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_iterate_sink_pads(IntPtr raw);
public Gst.Iterator IterateSinkPads() {
IntPtr raw_ret = gst_element_iterate_sink_pads(Handle);
Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_iterate_src_pads(IntPtr raw);
public Gst.Iterator IterateSrcPads() {
IntPtr raw_ret = gst_element_iterate_src_pads(Handle);
Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_link(IntPtr raw, IntPtr dest);
public bool Link(Gst.Element dest) {
bool raw_ret = gst_element_link(Handle, dest == null ? IntPtr.Zero : dest.Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_link_filtered(IntPtr raw, IntPtr dest, IntPtr filter);
public bool LinkFiltered(Gst.Element dest, Gst.Caps filter) {
bool raw_ret = gst_element_link_filtered(Handle, dest == null ? IntPtr.Zero : dest.Handle, filter == null ? IntPtr.Zero : filter.Handle);
bool ret = raw_ret;
return ret;
}
public bool LinkFiltered(Gst.Element dest) {
return LinkFiltered (dest, null);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_link_pads(IntPtr raw, IntPtr srcpadname, IntPtr dest, IntPtr destpadname);
public bool LinkPads(string srcpadname, Gst.Element dest, string destpadname) {
IntPtr native_srcpadname = GLib.Marshaller.StringToPtrGStrdup (srcpadname);
IntPtr native_destpadname = GLib.Marshaller.StringToPtrGStrdup (destpadname);
bool raw_ret = gst_element_link_pads(Handle, native_srcpadname, dest == null ? IntPtr.Zero : dest.Handle, native_destpadname);
bool ret = raw_ret;
GLib.Marshaller.Free (native_srcpadname);
GLib.Marshaller.Free (native_destpadname);
return ret;
}
public bool LinkPads(Gst.Element dest) {
return LinkPads (null, dest, null);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_link_pads_filtered(IntPtr raw, IntPtr srcpadname, IntPtr dest, IntPtr destpadname, IntPtr filter);
public bool LinkPadsFiltered(string srcpadname, Gst.Element dest, string destpadname, Gst.Caps filter) {
IntPtr native_srcpadname = GLib.Marshaller.StringToPtrGStrdup (srcpadname);
IntPtr native_destpadname = GLib.Marshaller.StringToPtrGStrdup (destpadname);
bool raw_ret = gst_element_link_pads_filtered(Handle, native_srcpadname, dest == null ? IntPtr.Zero : dest.Handle, native_destpadname, filter == null ? IntPtr.Zero : filter.Handle);
bool ret = raw_ret;
GLib.Marshaller.Free (native_srcpadname);
GLib.Marshaller.Free (native_destpadname);
return ret;
}
public bool LinkPadsFiltered(Gst.Element dest) {
return LinkPadsFiltered (null, dest, null, null);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_link_pads_full(IntPtr raw, IntPtr srcpadname, IntPtr dest, IntPtr destpadname, int flags);
public bool LinkPadsFull(string srcpadname, Gst.Element dest, string destpadname, Gst.PadLinkCheck flags) {
IntPtr native_srcpadname = GLib.Marshaller.StringToPtrGStrdup (srcpadname);
IntPtr native_destpadname = GLib.Marshaller.StringToPtrGStrdup (destpadname);
bool raw_ret = gst_element_link_pads_full(Handle, native_srcpadname, dest == null ? IntPtr.Zero : dest.Handle, native_destpadname, (int) flags);
bool ret = raw_ret;
GLib.Marshaller.Free (native_srcpadname);
GLib.Marshaller.Free (native_destpadname);
return ret;
}
public bool LinkPadsFull(Gst.Element dest, Gst.PadLinkCheck flags) {
return LinkPadsFull (null, dest, null, flags);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_lost_state(IntPtr raw);
public void LostState() {
gst_element_lost_state(Handle);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_message_full(IntPtr raw, int type, uint domain, int code, IntPtr text, IntPtr debug, IntPtr file, IntPtr function, int line);
public void MessageFull(Gst.MessageType type, uint domain, int code, string text, string debug, string file, string function, int line) {
IntPtr native_file = GLib.Marshaller.StringToPtrGStrdup (file);
IntPtr native_function = GLib.Marshaller.StringToPtrGStrdup (function);
gst_element_message_full(Handle, (int) type, domain, code, GLib.Marshaller.StringToPtrGStrdup(text), GLib.Marshaller.StringToPtrGStrdup(debug), native_file, native_function, line);
GLib.Marshaller.Free (native_file);
GLib.Marshaller.Free (native_function);
}
public void MessageFull(Gst.MessageType type, uint domain, int code, string file, string function, int line) {
MessageFull (type, domain, code, null, null, file, function, line);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_message_full_with_details(IntPtr raw, int type, uint domain, int code, IntPtr text, IntPtr debug, IntPtr file, IntPtr function, int line, IntPtr structure);
public void MessageFullWithDetails(Gst.MessageType type, uint domain, int code, string text, string debug, string file, string function, int line, Gst.Structure structure) {
IntPtr native_file = GLib.Marshaller.StringToPtrGStrdup (file);
IntPtr native_function = GLib.Marshaller.StringToPtrGStrdup (function);
structure.Owned = false;
gst_element_message_full_with_details(Handle, (int) type, domain, code, GLib.Marshaller.StringToPtrGStrdup(text), GLib.Marshaller.StringToPtrGStrdup(debug), native_file, native_function, line, structure == null ? IntPtr.Zero : structure.Handle);
GLib.Marshaller.Free (native_file);
GLib.Marshaller.Free (native_function);
}
public void MessageFullWithDetails(Gst.MessageType type, uint domain, int code, string file, string function, int line, Gst.Structure structure) {
MessageFullWithDetails (type, domain, code, null, null, file, function, line, structure);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_no_more_pads(IntPtr raw);
public void NoMorePads() {
gst_element_no_more_pads(Handle);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_post_message(IntPtr raw, IntPtr message);
public bool PostMessage(Gst.Message message) {
message.Owned = false;
bool raw_ret = gst_element_post_message(Handle, message == null ? IntPtr.Zero : message.Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_provide_clock(IntPtr raw);
public Gst.Clock ProvideClock() {
IntPtr raw_ret = gst_element_provide_clock(Handle);
Gst.Clock ret = GLib.Object.GetObject(raw_ret, true) as Gst.Clock;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_query(IntPtr raw, IntPtr query);
public bool Query(Gst.Query query) {
bool raw_ret = gst_element_query(Handle, query == null ? IntPtr.Zero : query.Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_query_convert(IntPtr raw, int src_format, long src_val, int dest_format, out long dest_val);
public bool QueryConvert(Gst.Format src_format, long src_val, Gst.Format dest_format, out long dest_val) {
bool raw_ret = gst_element_query_convert(Handle, (int) src_format, src_val, (int) dest_format, out dest_val);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_query_duration(IntPtr raw, int format, out long duration);
public bool QueryDuration(Gst.Format format, out long duration) {
bool raw_ret = gst_element_query_duration(Handle, (int) format, out duration);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_query_position(IntPtr raw, int format, out long cur);
public bool QueryPosition(Gst.Format format, out long cur) {
bool raw_ret = gst_element_query_position(Handle, (int) format, out cur);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_release_request_pad(IntPtr raw, IntPtr pad);
public void ReleaseRequestPad(Gst.Pad pad) {
gst_element_release_request_pad(Handle, pad == null ? IntPtr.Zero : pad.Handle);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_remove_pad(IntPtr raw, IntPtr pad);
public bool RemovePad(Gst.Pad pad) {
bool raw_ret = gst_element_remove_pad(Handle, pad == null ? IntPtr.Zero : pad.Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_remove_property_notify_watch(IntPtr raw, UIntPtr watch_id);
public void RemovePropertyNotifyWatch(ulong watch_id) {
gst_element_remove_property_notify_watch(Handle, new UIntPtr (watch_id));
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr gst_element_request_pad(IntPtr raw, IntPtr templ, IntPtr name, IntPtr caps);
public Gst.Pad RequestPad(Gst.PadTemplate templ, string name, Gst.Caps caps) {
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
IntPtr raw_ret = gst_element_request_pad(Handle, templ == null ? IntPtr.Zero : templ.Handle, native_name, caps == null ? IntPtr.Zero : caps.Handle);
Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
GLib.Marshaller.Free (native_name);
return ret;
}
public Gst.Pad RequestPad(Gst.PadTemplate templ) {
return RequestPad (templ, null, null);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_seek(IntPtr raw, double rate, int format, int flags, int start_type, long start, int stop_type, long stop);
public bool Seek(double rate, Gst.Format format, Gst.SeekFlags flags, Gst.SeekType start_type, long start, Gst.SeekType stop_type, long stop) {
bool raw_ret = gst_element_seek(Handle, rate, (int) format, (int) flags, (int) start_type, start, (int) stop_type, stop);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_seek_simple(IntPtr raw, int format, int seek_flags, long seek_pos);
public bool SeekSimple(Gst.Format format, Gst.SeekFlags seek_flags, long seek_pos) {
bool raw_ret = gst_element_seek_simple(Handle, (int) format, (int) seek_flags, seek_pos);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_send_event(IntPtr raw, IntPtr evnt);
public bool SendEvent(Gst.Event evnt) {
evnt.Owned = false;
bool raw_ret = gst_element_send_event(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_set_clock(IntPtr raw, IntPtr clock);
public bool SetClock(Gst.Clock clock) {
bool raw_ret = gst_element_set_clock(Handle, clock == null ? IntPtr.Zero : clock.Handle);
bool ret = raw_ret;
return ret;
}
public bool SetClock() {
return SetClock (null);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_set_locked_state(IntPtr raw, bool locked_state);
public bool SetLockedState(bool locked_state) {
bool raw_ret = gst_element_set_locked_state(Handle, locked_state);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int gst_element_set_state(IntPtr raw, int state);
public Gst.StateChangeReturn SetState(Gst.State state) {
int raw_ret = gst_element_set_state(Handle, (int) state);
Gst.StateChangeReturn ret = (Gst.StateChangeReturn) raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern bool gst_element_sync_state_with_parent(IntPtr raw);
public bool SyncStateWithParent() {
bool raw_ret = gst_element_sync_state_with_parent(Handle);
bool ret = raw_ret;
return ret;
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_unlink(IntPtr raw, IntPtr dest);
public void Unlink(Gst.Element dest) {
gst_element_unlink(Handle, dest == null ? IntPtr.Zero : dest.Handle);
}
[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
static extern void gst_element_unlink_pads(IntPtr raw, IntPtr srcpadname, IntPtr dest, IntPtr destpadname);
public void UnlinkPads(string srcpadname, Gst.Element dest, string destpadname) {
IntPtr native_srcpadname = GLib.Marshaller.StringToPtrGStrdup (srcpadname);
IntPtr native_destpadname = GLib.Marshaller.StringToPtrGStrdup (destpadname);
gst_element_unlink_pads(Handle, native_srcpadname, dest == null ? IntPtr.Zero : dest.Handle, native_destpadname);
GLib.Marshaller.Free (native_srcpadname);
GLib.Marshaller.Free (native_destpadname);
}
// 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("state_lock"
, Gst.Object.abi_info.Fields
, (uint) Marshal.SizeOf(typeof(GLib.RecMutex.ABI)) // state_lock
, null
, "state_cond"
, (long) Marshal.OffsetOf(typeof(GstElement_state_lockAlign), "state_lock")
, 0
),
new GLib.AbiField("state_cond"
, -1
, (uint) Marshal.SizeOf(typeof(GLib.Cond.ABI)) // state_cond
, "state_lock"
, "state_cookie"
, (long) Marshal.OffsetOf(typeof(GstElement_state_condAlign), "state_cond")
, 0
),
new GLib.AbiField("state_cookie"
, -1
, (uint) Marshal.SizeOf(typeof(uint)) // state_cookie
, "state_cond"
, "target_state"
, (long) Marshal.OffsetOf(typeof(GstElement_state_cookieAlign), "state_cookie")
, 0
),
new GLib.AbiField("target_state"
, -1
, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.State))) // target_state
, "state_cookie"
, "current_state"
, (long) Marshal.OffsetOf(typeof(GstElement_target_stateAlign), "target_state")
, 0
),
new GLib.AbiField("current_state"
, -1
, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.State))) // current_state
, "target_state"
, "next_state"
, (long) Marshal.OffsetOf(typeof(GstElement_current_stateAlign), "current_state")
, 0
),
new GLib.AbiField("next_state"
, -1
, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.State))) // next_state
, "current_state"
, "pending_state"
, (long) Marshal.OffsetOf(typeof(GstElement_next_stateAlign), "next_state")
, 0
),
new GLib.AbiField("pending_state"
, -1
, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.State))) // pending_state
, "next_state"
, "last_return"
, (long) Marshal.OffsetOf(typeof(GstElement_pending_stateAlign), "pending_state")
, 0
),
new GLib.AbiField("last_return"
, -1
, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.StateChangeReturn))) // last_return
, "pending_state"
, "bus"
, (long) Marshal.OffsetOf(typeof(GstElement_last_returnAlign), "last_return")
, 0
),
new GLib.AbiField("bus"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // bus
, "last_return"
, "clock"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("clock"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // clock
, "bus"
, "base_time"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("base_time"
, -1
, (uint) Marshal.SizeOf(typeof(long)) // base_time
, "clock"
, "start_time"
, (long) Marshal.OffsetOf(typeof(GstElement_base_timeAlign), "base_time")
, 0
),
new GLib.AbiField("start_time"
, -1
, (uint) Marshal.SizeOf(typeof(ulong)) // start_time
, "base_time"
, "numpads"
, (long) Marshal.OffsetOf(typeof(GstElement_start_timeAlign), "start_time")
, 0
),
new GLib.AbiField("numpads"
, -1
, (uint) Marshal.SizeOf(typeof(ushort)) // numpads
, "start_time"
, "pads"
, (long) Marshal.OffsetOf(typeof(GstElement_numpadsAlign), "numpads")
, 0
),
new GLib.AbiField("pads"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // pads
, "numpads"
, "numsrcpads"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("numsrcpads"
, -1
, (uint) Marshal.SizeOf(typeof(ushort)) // numsrcpads
, "pads"
, "srcpads"
, (long) Marshal.OffsetOf(typeof(GstElement_numsrcpadsAlign), "numsrcpads")
, 0
),
new GLib.AbiField("srcpads"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // srcpads
, "numsrcpads"
, "numsinkpads"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("numsinkpads"
, -1
, (uint) Marshal.SizeOf(typeof(ushort)) // numsinkpads
, "srcpads"
, "sinkpads"
, (long) Marshal.OffsetOf(typeof(GstElement_numsinkpadsAlign), "numsinkpads")
, 0
),
new GLib.AbiField("sinkpads"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // sinkpads
, "numsinkpads"
, "pads_cookie"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("pads_cookie"
, -1
, (uint) Marshal.SizeOf(typeof(uint)) // pads_cookie
, "sinkpads"
, "contexts"
, (long) Marshal.OffsetOf(typeof(GstElement_pads_cookieAlign), "pads_cookie")
, 0
),
new GLib.AbiField("contexts"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) // contexts
, "pads_cookie"
, "_gst_reserved"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("_gst_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 3 // _gst_reserved
, "contexts"
, null
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
});
return _abi_info;
}
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_state_lockAlign
{
sbyte f1;
private GLib.RecMutex.ABI state_lock;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_state_condAlign
{
sbyte f1;
private GLib.Cond.ABI state_cond;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_state_cookieAlign
{
sbyte f1;
private uint state_cookie;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_target_stateAlign
{
sbyte f1;
private Gst.State target_state;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_current_stateAlign
{
sbyte f1;
private Gst.State current_state;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_next_stateAlign
{
sbyte f1;
private Gst.State next_state;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_pending_stateAlign
{
sbyte f1;
private Gst.State pending_state;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_last_returnAlign
{
sbyte f1;
private Gst.StateChangeReturn last_return;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_base_timeAlign
{
sbyte f1;
private ulong base_time;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_start_timeAlign
{
sbyte f1;
private ulong start_time;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_numpadsAlign
{
sbyte f1;
private ushort numpads;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_numsrcpadsAlign
{
sbyte f1;
private ushort numsrcpads;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_numsinkpadsAlign
{
sbyte f1;
private ushort numsinkpads;
}
[StructLayout(LayoutKind.Sequential)]
public struct GstElement_pads_cookieAlign
{
sbyte f1;
private uint pads_cookie;
}
// End of the ABI representation.
#endregion
}
}