diff options
Diffstat (limited to 'subprojects/gstreamer-sharp/sources/generated/Gst/Element.cs')
| -rw-r--r-- | subprojects/gstreamer-sharp/sources/generated/Gst/Element.cs | 2317 |
1 files changed, 2317 insertions, 0 deletions
diff --git a/subprojects/gstreamer-sharp/sources/generated/Gst/Element.cs b/subprojects/gstreamer-sharp/sources/generated/Gst/Element.cs new file mode 100644 index 0000000000..507f032380 --- /dev/null +++ b/subprojects/gstreamer-sharp/sources/generated/Gst/Element.cs @@ -0,0 +1,2317 @@ +// 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 + } +} |