mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-24 04:50:16 +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.
2295 lines
78 KiB
C#
2295 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("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern IntPtr gst_element_get_bus(IntPtr raw);
|
|
|
|
[DllImport("libgstreamer-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("libgstreamer-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("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern ulong gst_element_get_base_time(IntPtr raw);
|
|
|
|
[DllImport("libgstreamer-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("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
|
|
static extern ulong gst_element_get_start_time(IntPtr raw);
|
|
|
|
[DllImport("libgstreamer-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("libgstreamer-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-added")]
|
|
public event Gst.PadAddedHandler PadAdded {
|
|
add {
|
|
this.AddSignalHandler ("pad-added", value, typeof (Gst.PadAddedArgs));
|
|
}
|
|
remove {
|
|
this.RemoveSignalHandler ("pad-added", 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);
|
|
}
|
|
}
|
|
|
|
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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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("libgstreamer-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
|
|
}
|
|
}
|