libvlcpp.cs

// ----------------------------------------------------------------------------
// <auto-generated>
// This is autogenerated code by CppSharp.
// Do not edit this file or all your changes will be lost after re-generation.
// </auto-generated>
// ----------------------------------------------------------------------------
using System;
using System.Runtime.InteropServices;
using System.Security;

namespace libvlcpp
{
    public unsafe partial class Pollfd
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.Pollfd> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.Pollfd>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.Pollfd __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.Pollfd(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.Pollfd __CreateInstance(global::libvlcpp.Pollfd.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.Pollfd(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.Pollfd.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.Pollfd.__Internal));
            *(global::libvlcpp.Pollfd.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private Pollfd(global::libvlcpp.Pollfd.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected Pollfd(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class vlc
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="?poll@@YAHPEAUpollfd@@IH@Z")]
            internal static extern int Poll(global::System.IntPtr _0, uint _1, int _2);
        }

        public static int Poll(global::libvlcpp.Pollfd _0, uint _1, int _2)
        {
            var __arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance;
            var __ret = __Internal.Poll(__arg0, _1, _2);
            return __ret;
        }
    }

    namespace VLC
    {
        public unsafe partial class CallbackHandlerBase : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 8)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::System.IntPtr vfptr_CallbackHandlerBase;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0CallbackHandlerBase@VLC@@QEAA@XZ")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0CallbackHandlerBase@VLC@@QEAA@AEBU01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.CallbackHandlerBase> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.CallbackHandlerBase>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.CallbackHandlerBase __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.CallbackHandlerBase(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.CallbackHandlerBase __CreateInstance(global::libvlcpp.VLC.CallbackHandlerBase.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.CallbackHandlerBase(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.CallbackHandlerBase.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.CallbackHandlerBase.__Internal));
                global::libvlcpp.VLC.CallbackHandlerBase.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private CallbackHandlerBase(global::libvlcpp.VLC.CallbackHandlerBase.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected CallbackHandlerBase(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
                if (skipVTables)
                    __OriginalVTables = new void*[] { *(void**) (__Instance + 0) };
                else
                    SetupVTables(true);
            }

            public CallbackHandlerBase()
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.CallbackHandlerBase.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                __Internal.ctor((__Instance + __PointerAdjustment));
                SetupVTables(GetType().FullName == "libvlcpp.VLC.CallbackHandlerBase");
            }

            public CallbackHandlerBase(global::libvlcpp.VLC.CallbackHandlerBase _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.CallbackHandlerBase.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
                SetupVTables(GetType().FullName == "libvlcpp.VLC.CallbackHandlerBase");
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.CallbackHandlerBase __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                ((global::libvlcpp.VLC.CallbackHandlerBase.__Internal*) __Instance)->vfptr_CallbackHandlerBase = new global::System.IntPtr(__OriginalVTables[0]);
                if (disposing)
                {
                    var __slot = *(void**) ((IntPtr) __OriginalVTables[0] + 1 * 8);
                    var ___dtorDelegate = (global::libvlcpp.Delegates.Action_IntPtr_int) Marshal.GetDelegateForFunctionPointer(new IntPtr(__slot), typeof(global::libvlcpp.Delegates.Action_IntPtr_int));
                    ___dtorDelegate((__Instance + __PointerAdjustment), 0);
                }
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            #region Virtual table interop

            // virtual ~CallbackHandlerBase() = default
            private static global::libvlcpp.Delegates.Action_IntPtr_int _dtorDelegateInstance;

            private static void _dtorDelegateHook(global::System.IntPtr instance, int delete)
            {
                if (!NativeToManagedMap.ContainsKey(instance))
                    throw new global::System.Exception("No managed instance was found");

                var __target = (global::libvlcpp.VLC.CallbackHandlerBase) NativeToManagedMap[instance];
                if (__target.__ownsNativeInstance)
                    __target.SetupVTables();
                __target.Dispose(true);
            }

            private static void*[] __ManagedVTables;
            private static void*[] __ManagedVTablesDtorOnly;
            private static void*[] _Thunks;

            private void SetupVTables(bool destructorOnly = false)
            {
                if (__OriginalVTables != null)
                    return;
                __OriginalVTables = new void*[] { *(void**) (__Instance + 0) };

                if (_Thunks == null)
                {
                    _Thunks = new void*[1];
                    _dtorDelegateInstance += _dtorDelegateHook;
                    _Thunks[0] = Marshal.GetFunctionPointerForDelegate(_dtorDelegateInstance).ToPointer();
                }

                if (destructorOnly)
                {
                    if (__ManagedVTablesDtorOnly == null)
                    {
                        __ManagedVTablesDtorOnly = new void*[1];
                        var vfptr0 = Marshal.AllocHGlobal(2 * 8);
                        __ManagedVTablesDtorOnly[0] = vfptr0.ToPointer();
                        *(void**) (vfptr0 + 0) = *(void**) (new IntPtr(*(void**) __Instance) + 0 + 0);
                        *(void**) (vfptr0 + 8) = _Thunks[0];
                    }

                    *(void**) (__Instance + 0) = __ManagedVTablesDtorOnly[0];
                }
                else
                {
                    if (__ManagedVTables == null)
                    {
                        __ManagedVTables = new void*[1];
                        var vfptr0 = Marshal.AllocHGlobal(2 * 8);
                        __ManagedVTables[0] = vfptr0.ToPointer();
                        *(void**) (vfptr0 + 0) = *(void**) (new IntPtr(*(void**) __Instance) + 0 + 0);
                        *(void**) (vfptr0 + 8) = _Thunks[0];
                    }

                    *(void**) (__Instance + 0) = __ManagedVTables[0];
                }
            }

            #endregion
        }

        public unsafe partial class VaCopy : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 8)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal va_list va;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0VaCopy@VLC@@QEAA@AEBU01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1VaCopy@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.VaCopy> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.VaCopy>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.VaCopy __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.VaCopy(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.VaCopy __CreateInstance(global::libvlcpp.VLC.VaCopy.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.VaCopy(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.VaCopy.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.VaCopy.__Internal));
                *(global::libvlcpp.VLC.VaCopy.__Internal*) ret = native;
                return ret.ToPointer();
            }

            private VaCopy(global::libvlcpp.VLC.VaCopy.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected VaCopy(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public VaCopy(global::libvlcpp.VLC.VaCopy _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.VaCopy.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                *((global::libvlcpp.VLC.VaCopy.__Internal*) __Instance) = *((global::libvlcpp.VLC.VaCopy.__Internal*) _0.__Instance);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.VaCopy __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }
        }

        namespace Detail
        {
            public unsafe partial class common
            {
                public partial struct __Internal
                {
                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="??$converterForNullToString@PEBD@detail@VLC@@YA$$QEAPEBD$$QEAPEBD@Z")]
                    internal static extern sbyte** ConverterForNullToString(sbyte** str);
                }

                public static sbyte** ConverterForNullToString(sbyte** str)
                {
                    var __ret = __Internal.ConverterForNullToString(str);
                    return __ret;
                }
            }
        }

        namespace Imem
        {
            public enum BoxingStrategy
            {
                /// <summary>No boxing required.</summary>
                NoBoxing = 0,
                /// <summary>Used to create the Opaque wrapper and setup pointers</summary>
                Setup = 1,
                /// <summary>Unbox CallbackArray/user callback pointers</summary>
                Unbox = 2,
                /// <summary>Releases the Opaque, created during Setup</summary>
                Cleanup = 3
            }
        }
    }

    /// <summary>Logging messages level.</summary>
    /// <remarks>Future LibVLC versions may define new levels.</remarks>
    public enum LibvlcLogLevel
    {
        /// <summary>Debug message</summary>
        LIBVLC_DEBUG = 0,
        /// <summary>Important informational message</summary>
        LIBVLC_NOTICE = 2,
        /// <summary>Warning (potential error) message</summary>
        LIBVLC_WARNING = 3,
        /// <summary>Error message</summary>
        LIBVLC_ERROR = 4
    }

    /// <summary>This structure is opaque. It represents a libvlc instance</summary>
    /// <summary>
    /// <para>Event manager that belongs to a libvlc object, and from whom events can</para>
    /// <para>be received.</para>
    /// </summary>
    /// <summary>Type of a LibVLC event.</summary>
    /// <summary>Callback function notification</summary>
    /// <param name="p_event">the event triggering the callback</param>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcCallbackT(global::System.IntPtr p_event, global::System.IntPtr p_data);

    public unsafe partial class LibvlcInstanceT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcInstanceT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcInstanceT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcInstanceT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcInstanceT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcInstanceT __CreateInstance(global::libvlcpp.LibvlcInstanceT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcInstanceT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcInstanceT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcInstanceT.__Internal));
            *(global::libvlcpp.LibvlcInstanceT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcInstanceT(global::libvlcpp.LibvlcInstanceT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcInstanceT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class LibvlcEventManagerT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcEventManagerT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcEventManagerT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcEventManagerT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcEventManagerT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcEventManagerT __CreateInstance(global::libvlcpp.LibvlcEventManagerT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcEventManagerT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcEventManagerT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcEventManagerT.__Internal));
            *(global::libvlcpp.LibvlcEventManagerT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcEventManagerT(global::libvlcpp.LibvlcEventManagerT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcEventManagerT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class VlcLogT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VlcLogT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VlcLogT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.VlcLogT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.VlcLogT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.VlcLogT __CreateInstance(global::libvlcpp.VlcLogT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.VlcLogT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.VlcLogT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VlcLogT.__Internal));
            *(global::libvlcpp.VlcLogT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private VlcLogT(global::libvlcpp.VlcLogT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected VlcLogT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    /// <summary>Description of a module.</summary>
    public unsafe partial class LibvlcModuleDescriptionT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 40)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr psz_name;

            [FieldOffset(8)]
            internal global::System.IntPtr psz_shortname;

            [FieldOffset(16)]
            internal global::System.IntPtr psz_longname;

            [FieldOffset(24)]
            internal global::System.IntPtr psz_help;

            [FieldOffset(32)]
            internal global::System.IntPtr p_next;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_module_description_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcModuleDescriptionT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcModuleDescriptionT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcModuleDescriptionT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcModuleDescriptionT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcModuleDescriptionT __CreateInstance(global::libvlcpp.LibvlcModuleDescriptionT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcModuleDescriptionT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcModuleDescriptionT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcModuleDescriptionT.__Internal));
            *(global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcModuleDescriptionT(global::libvlcpp.LibvlcModuleDescriptionT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcModuleDescriptionT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcModuleDescriptionT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcModuleDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcModuleDescriptionT(global::libvlcpp.LibvlcModuleDescriptionT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcModuleDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcModuleDescriptionT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public sbyte* PszName
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->psz_name;
            }

            set
            {
                ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->psz_name = (global::System.IntPtr) value;
            }
        }

        public sbyte* PszShortname
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->psz_shortname;
            }

            set
            {
                ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->psz_shortname = (global::System.IntPtr) value;
            }
        }

        public sbyte* PszLongname
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->psz_longname;
            }

            set
            {
                ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->psz_longname = (global::System.IntPtr) value;
            }
        }

        public sbyte* PszHelp
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->psz_help;
            }

            set
            {
                ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->psz_help = (global::System.IntPtr) value;
            }
        }

        public global::libvlcpp.LibvlcModuleDescriptionT PNext
        {
            get
            {
                global::libvlcpp.LibvlcModuleDescriptionT __result0;
                if (((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->p_next == IntPtr.Zero) __result0 = null;
                else if (global::libvlcpp.LibvlcModuleDescriptionT.NativeToManagedMap.ContainsKey(((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->p_next))
                    __result0 = (global::libvlcpp.LibvlcModuleDescriptionT) global::libvlcpp.LibvlcModuleDescriptionT.NativeToManagedMap[((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->p_next];
                else __result0 = global::libvlcpp.LibvlcModuleDescriptionT.__CreateInstance(((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->p_next);
                return __result0;
            }

            set
            {
                ((global::libvlcpp.LibvlcModuleDescriptionT.__Internal*) __Instance)->p_next = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }
    }

    public unsafe partial class libvlc
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_errmsg")]
            internal static extern global::System.IntPtr LibvlcErrmsg();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_clearerr")]
            internal static extern void LibvlcClearerr();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_printerr")]
            internal static extern global::System.IntPtr LibvlcPrinterr([MarshalAs(UnmanagedType.LPStr)] string fmt);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_new")]
            internal static extern global::System.IntPtr LibvlcNew(int argc, sbyte** argv);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_release")]
            internal static extern void LibvlcRelease(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_retain")]
            internal static extern void LibvlcRetain(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_add_intf")]
            internal static extern int LibvlcAddIntf(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_set_exit_handler")]
            internal static extern void LibvlcSetExitHandler(global::System.IntPtr p_instance, global::System.IntPtr cb, global::System.IntPtr opaque);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_set_user_agent")]
            internal static extern void LibvlcSetUserAgent(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string name, [MarshalAs(UnmanagedType.LPStr)] string http);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_set_app_id")]
            internal static extern void LibvlcSetAppId(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string id, [MarshalAs(UnmanagedType.LPStr)] string version, [MarshalAs(UnmanagedType.LPStr)] string icon);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_get_version")]
            internal static extern global::System.IntPtr LibvlcGetVersion();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_get_compiler")]
            internal static extern global::System.IntPtr LibvlcGetCompiler();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_get_changeset")]
            internal static extern global::System.IntPtr LibvlcGetChangeset();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_free")]
            internal static extern void LibvlcFree(global::System.IntPtr ptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_event_attach")]
            internal static extern int LibvlcEventAttach(global::System.IntPtr p_event_manager, int i_event_type, global::System.IntPtr f_callback, global::System.IntPtr user_data);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_event_detach")]
            internal static extern void LibvlcEventDetach(global::System.IntPtr p_event_manager, int i_event_type, global::System.IntPtr f_callback, global::System.IntPtr p_user_data);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_event_type_name")]
            internal static extern global::System.IntPtr LibvlcEventTypeName(int event_type);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_get_context")]
            internal static extern void LibvlcLogGetContext(global::System.IntPtr ctx, sbyte** module, sbyte** file, uint* line);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_get_object")]
            internal static extern void LibvlcLogGetObject(global::System.IntPtr ctx, sbyte** name, sbyte** header, ulong* id);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_unset")]
            internal static extern void LibvlcLogUnset(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_set_file")]
            internal static extern void LibvlcLogSetFile(global::System.IntPtr p_instance, global::System.IntPtr stream);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_module_description_list_release")]
            internal static extern void LibvlcModuleDescriptionListRelease(global::System.IntPtr p_list);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_filter_list_get")]
            internal static extern global::System.IntPtr LibvlcAudioFilterListGet(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_filter_list_get")]
            internal static extern global::System.IntPtr LibvlcVideoFilterListGet(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_clock")]
            internal static extern long LibvlcClock();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="?libvlc_delay@@YA_J_J@Z")]
            internal static extern long LibvlcDelay(long pts);
        }

        /// <summary>
        /// <para>A human-readable error message for the last LibVLC error in the calling</para>
        /// <para>thread. The resulting string is valid until another error occurs (at least</para>
        /// <para>until the next LibVLC call).</para>
        /// </summary>
        /// <remarks>This will be NULL if there was no error.</remarks>
        public static string LibvlcErrmsg()
        {
            var __ret = __Internal.LibvlcErrmsg();
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>
        /// <para>Clears the LibVLC error status for the current thread. This is optional.</para>
        /// <para>By default, the error status is automatically overridden when a new error</para>
        /// <para>occurs, and destroyed when the thread exits.</para>
        /// </summary>
        public static void LibvlcClearerr()
        {
            __Internal.LibvlcClearerr();
        }

        /// <summary>
        /// <para>Sets the LibVLC error status and message for the current thread.</para>
        /// <para>Any previous error is overridden.</para>
        /// </summary>
        /// <param name="fmt">the format string</param>
        /// <param name="args">the arguments</param>
        /// <returns>a nul terminated string in any case</returns>
        public static string LibvlcPrinterr(string fmt)
        {
            var __ret = __Internal.LibvlcPrinterr(fmt);
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>
        /// <para>Create and initialize a libvlc instance.</para>
        /// <para>This functions accept a list of &quot;command line&quot; arguments similar to the</para>
        /// <para>main(). These arguments affect the LibVLC instance default configuration.</para>
        /// </summary>
        /// <param name="argc">the number of arguments (should be 0)</param>
        /// <param name="argv">list of arguments (should be NULL)</param>
        /// <returns>the libvlc instance or NULL in case of error</returns>
        /// <remarks>
        /// <para>LibVLC may create threads. Therefore, any thread-unsafe process</para>
        /// <para>initialization must be performed before calling libvlc_new(). In particular</para>
        /// <para>and where applicable:</para>
        /// <para>- setlocale() and textdomain(),</para>
        /// <para>- setenv(), unsetenv() and putenv(),</para>
        /// <para>- with the X11 display system, XInitThreads()</para>
        /// <para>(see also libvlc_media_player_set_xwindow()) and</para>
        /// <para>- on Microsoft Windows, SetErrorMode().</para>
        /// <para>- sigprocmask() shall never be invoked; pthread_sigmask() can be used.</para>
        /// <para>On POSIX systems, the SIGCHLD signalmust notbe ignored, i.e. the</para>
        /// <para>signal handler must set to SIG_DFL or a function pointer, not SIG_IGN.</para>
        /// <para>Also while LibVLC is active, the wait() function shall not be called, and</para>
        /// <para>any call to waitpid() shall use a strictly positive value for the first</para>
        /// <para>parameter (i.e. the PID). Failure to follow those rules may lead to a</para>
        /// <para>deadlock or a busy loop.</para>
        /// <para>Also on POSIX systems, it is recommended that the SIGPIPE signal be blocked,</para>
        /// <para>even if it is not, in principles, necessary, e.g.:</para>
        /// <para>On Microsoft Windows Vista/2008, the process error mode</para>
        /// <para>SEM_FAILCRITICALERRORS flagmustbe set before using LibVLC.</para>
        /// <para>On later versions, that is optional and unnecessary.</para>
        /// <para>Also on Microsoft Windows (Vista and any later version), setting the default</para>
        /// <para>DLL directories to SYSTEM32 exclusively is strongly recommended for</para>
        /// <para>security reasons:</para>
        /// <para>Arguments are meant to be passed from the command line to LibVLC, just like</para>
        /// <para>VLC media player does. The list of valid arguments depends on the LibVLC</para>
        /// <para>version, the operating system and platform, and set of available LibVLC</para>
        /// <para>plugins. Invalid or unsupported arguments will cause the function to fail</para>
        /// <para>(i.e. return NULL). Also, some arguments may alter the behaviour or</para>
        /// <para>otherwise interfere with other LibVLC functions.</para>
        /// <para>There is absolutely no warranty or promise of forward, backward and</para>
        /// <para>cross-platform compatibility with regards to libvlc_new() arguments.</para>
        /// <para>We recommend that you do not use them, other than when debugging.</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcInstanceT LibvlcNew(int argc, sbyte** argv)
        {
            var __ret = __Internal.LibvlcNew(argc, argv);
            global::libvlcpp.LibvlcInstanceT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcInstanceT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcInstanceT) global::libvlcpp.LibvlcInstanceT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcInstanceT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Decrement the reference count of a libvlc instance, and destroy it</para>
        /// <para>if it reaches zero.</para>
        /// </summary>
        /// <param name="p_instance">the instance to destroy</param>
        public static void LibvlcRelease(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcRelease(__arg0);
        }

        /// <summary>
        /// <para>Increments the reference count of a libvlc instance.</para>
        /// <para>The initial reference count is 1 after libvlc_new() returns.</para>
        /// </summary>
        /// <param name="p_instance">the instance to reference</param>
        public static void LibvlcRetain(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcRetain(__arg0);
        }

        /// <summary>Try to start a user interface for the libvlc instance.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="name">interface name, or NULL for default</param>
        /// <returns>0 on success, -1 on error.</returns>
        public static int LibvlcAddIntf(global::libvlcpp.LibvlcInstanceT p_instance, string name)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcAddIntf(__arg0, name);
            return __ret;
        }

        /// <summary>
        /// <para>Registers a callback for the LibVLC exit event. This is mostly useful if</para>
        /// <para>the VLC playlist and/or at least one interface are started with</para>
        /// <para>libvlc_playlist_play() or libvlc_add_intf() respectively.</para>
        /// <para>Typically, this function will wake up your application main loop (from</para>
        /// <para>another thread).</para>
        /// </summary>
        /// <param name="p_instance">LibVLC instance</param>
        /// <param name="cb">
        /// <para>callback to invoke when LibVLC wants to exit,</para>
        /// <para>or NULL to disable the exit handler (as by default)</para>
        /// </param>
        /// <param name="opaque">data pointer for the callback</param>
        /// <remarks>
        /// <para>This function should be called before the playlist or interface are</para>
        /// <para>started. Otherwise, there is a small race condition: the exit event could</para>
        /// <para>be raised before the handler is registered.</para>
        /// <para>This function and libvlc_wait() cannot be used at the same time.</para>
        /// </remarks>
        public static void LibvlcSetExitHandler(global::libvlcpp.LibvlcInstanceT p_instance, global::libvlcpp.Delegates.Action_IntPtr cb, global::System.IntPtr opaque)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __arg1 = cb == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(cb);
            __Internal.LibvlcSetExitHandler(__arg0, __arg1, opaque);
        }

        /// <summary>
        /// <para>Sets the application name. LibVLC passes this as the user agent string</para>
        /// <para>when a protocol requires it.</para>
        /// </summary>
        /// <param name="p_instance">LibVLC instance</param>
        /// <param name="name">human-readable application name, e.g. &quot;FooBar player 1.2.3&quot;</param>
        /// <param name="http">HTTP User Agent, e.g. &quot;FooBar/1.2.3 Python/2.6.0&quot;</param>
        /// <remarks>LibVLC 1.1.1 or later</remarks>
        public static void LibvlcSetUserAgent(global::libvlcpp.LibvlcInstanceT p_instance, string name, string http)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcSetUserAgent(__arg0, name, http);
        }

        /// <summary>
        /// <para>Sets some meta-information about the application.</para>
        /// <para>See also libvlc_set_user_agent().</para>
        /// </summary>
        /// <param name="p_instance">LibVLC instance</param>
        /// <param name="id">Java-style application identifier, e.g. &quot;com.acme.foobar&quot;</param>
        /// <param name="version">application version numbers, e.g. &quot;1.2.3&quot;</param>
        /// <param name="icon">application icon name, e.g. &quot;foobar&quot;</param>
        /// <remarks>LibVLC 2.1.0 or later.</remarks>
        public static void LibvlcSetAppId(global::libvlcpp.LibvlcInstanceT p_instance, string id, string version, string icon)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcSetAppId(__arg0, id, version, icon);
        }

        /// <summary>Retrieve libvlc version.</summary>
        /// <returns>a string containing the libvlc version</returns>
        /// <remarks>Example: &quot;1.1.0-git The Luggage&quot;</remarks>
        public static string LibvlcGetVersion()
        {
            var __ret = __Internal.LibvlcGetVersion();
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>Retrieve libvlc compiler version.</summary>
        /// <returns>a string containing the libvlc compiler version</returns>
        /// <remarks>Example: &quot;gcc version 4.2.3 (Ubuntu 4.2.3-2ubuntu6)&quot;</remarks>
        public static string LibvlcGetCompiler()
        {
            var __ret = __Internal.LibvlcGetCompiler();
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>Retrieve libvlc changeset.</summary>
        /// <returns>a string containing the libvlc changeset</returns>
        /// <remarks>Example: &quot;aa9bce0bc4&quot;</remarks>
        public static string LibvlcGetChangeset()
        {
            var __ret = __Internal.LibvlcGetChangeset();
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>
        /// <para>Frees an heap allocation returned by a LibVLC function.</para>
        /// <para>If you know you're using the same underlying C run-time as the LibVLC</para>
        /// <para>implementation, then you can call ANSI C free() directly instead.</para>
        /// </summary>
        /// <param name="ptr">the pointer</param>
        public static void LibvlcFree(global::System.IntPtr ptr)
        {
            __Internal.LibvlcFree(ptr);
        }

        /// <summary>Register for an event notification.</summary>
        /// <param name="p_event_manager">
        /// <para>the event manager to which you want to attach to.</para>
        /// <para>Generally it is obtained by vlc_my_object_event_manager() where</para>
        /// <para>my_object is the object you want to listen to.</para>
        /// </param>
        /// <param name="i_event_type">the desired event to which we want to listen</param>
        /// <param name="f_callback">the function to call when i_event_type occurs</param>
        /// <param name="user_data">user provided data to carry with the event</param>
        /// <returns>0 on success, ENOMEM on error</returns>
        public static int LibvlcEventAttach(global::libvlcpp.LibvlcEventManagerT p_event_manager, int i_event_type, global::libvlcpp.LibvlcCallbackT f_callback, global::System.IntPtr user_data)
        {
            var __arg0 = ReferenceEquals(p_event_manager, null) ? global::System.IntPtr.Zero : p_event_manager.__Instance;
            var __arg2 = f_callback == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(f_callback);
            var __ret = __Internal.LibvlcEventAttach(__arg0, i_event_type, __arg2, user_data);
            return __ret;
        }

        /// <summary>Unregister an event notification.</summary>
        /// <param name="p_event_manager">the event manager</param>
        /// <param name="i_event_type">the desired event to which we want to unregister</param>
        /// <param name="f_callback">the function to call when i_event_type occurs</param>
        /// <param name="p_user_data">user provided data to carry with the event</param>
        public static void LibvlcEventDetach(global::libvlcpp.LibvlcEventManagerT p_event_manager, int i_event_type, global::libvlcpp.LibvlcCallbackT f_callback, global::System.IntPtr p_user_data)
        {
            var __arg0 = ReferenceEquals(p_event_manager, null) ? global::System.IntPtr.Zero : p_event_manager.__Instance;
            var __arg2 = f_callback == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(f_callback);
            __Internal.LibvlcEventDetach(__arg0, i_event_type, __arg2, p_user_data);
        }

        /// <summary>Get an event's type name.</summary>
        /// <param name="event_type">the desired event</param>
        public static string LibvlcEventTypeName(int event_type)
        {
            var __ret = __Internal.LibvlcEventTypeName(event_type);
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>Gets log message debug infos.</summary>
        /// <param name="ctx">message context (as passed to the</param>
        /// <param name="module">module name storage (or NULL) [OUT]</param>
        /// <param name="file">source code file name storage (or NULL) [OUT]</param>
        /// <param name="line">source code file line number storage (or NULL) [OUT]</param>
        /// <remarks>
        /// <para>This function retrieves self-debug information about a log message:</para>
        /// <para>- the name of the VLC module emitting the message,</para>
        /// <para>- the name of the source code module (i.e. file) and</para>
        /// <para>- the line number within the source code module.</para>
        /// <para>The returned module name and file name will be NULL if unknown.</para>
        /// <para>The returned line number will similarly be zero if unknown.</para>
        /// <para>The returned module name and source code file name, if non-NULL,</para>
        /// <para>are only valid until the logging callback returns.</para>
        /// <para>LibVLC 2.1.0 or later</para>
        /// </remarks>
        public static void LibvlcLogGetContext(global::libvlcpp.VlcLogT ctx, sbyte** module, sbyte** file, ref uint line)
        {
            var __arg0 = ReferenceEquals(ctx, null) ? global::System.IntPtr.Zero : ctx.__Instance;
            fixed (uint* __refParamPtr3 = &line)
            {
                var __arg3 = __refParamPtr3;
                __Internal.LibvlcLogGetContext(__arg0, module, file, __arg3);
            }
        }

        /// <summary>Gets log message info.</summary>
        /// <param name="ctx">message context (as passed to the</param>
        /// <param name="name">object name storage (or NULL) [OUT]</param>
        /// <param name="header">object header (or NULL) [OUT]</param>
        /// <param name="line">source code file line number storage (or NULL) [OUT]</param>
        /// <remarks>
        /// <para>This function retrieves meta-information about a log message:</para>
        /// <para>- the type name of the VLC object emitting the message,</para>
        /// <para>- the object header if any, and</para>
        /// <para>- a temporaly-unique object identifier.</para>
        /// <para>This information is mainly meant formanualtroubleshooting.</para>
        /// <para>The returned type name may be &quot;generic&quot; if unknown, but it cannot be NULL.</para>
        /// <para>The returned header will be NULL if unset; in current versions, the header</para>
        /// <para>is used to distinguish for VLM inputs.</para>
        /// <para>The returned object ID will be zero if the message is not associated with</para>
        /// <para>any VLC object.</para>
        /// <para>The returned module name and source code file name, if non-NULL,</para>
        /// <para>are only valid until the logging callback returns.</para>
        /// <para>LibVLC 2.1.0 or later</para>
        /// </remarks>
        public static void LibvlcLogGetObject(global::libvlcpp.VlcLogT ctx, sbyte** name, sbyte** header, ref ulong id)
        {
            var __arg0 = ReferenceEquals(ctx, null) ? global::System.IntPtr.Zero : ctx.__Instance;
            fixed (ulong* __refParamPtr3 = &id)
            {
                var __arg3 = __refParamPtr3;
                __Internal.LibvlcLogGetObject(__arg0, name, header, __arg3);
            }
        }

        /// <summary>Unsets the logging callback.</summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <remarks>
        /// <para>This function deregisters the logging callback for a LibVLC instance.</para>
        /// <para>This is rarely needed as the callback is implicitly unset when the instance</para>
        /// <para>is destroyed.</para>
        /// <para>This function will wait for any pending callbacks invocation to</para>
        /// <para>complete (causing a deadlock if called from within the callback).</para>
        /// <para>LibVLC 2.1.0 or later</para>
        /// </remarks>
        public static void LibvlcLogUnset(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcLogUnset(__arg0);
        }

        /// <summary>Sets up logging to a file.</summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <param name="stream">
        /// <para>FILE pointer opened for writing</para>
        /// <para>(the FILE pointer must remain valid until libvlc_log_unset())</para>
        /// </param>
        /// <remarks>LibVLC 2.1.0 or later</remarks>
        public static void LibvlcLogSetFile(global::libvlcpp.LibvlcInstanceT p_instance, global::System.IntPtr stream)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcLogSetFile(__arg0, stream);
        }

        /// <summary>Release a list of module descriptions.</summary>
        /// <param name="p_list">the list to be released</param>
        public static void LibvlcModuleDescriptionListRelease(global::libvlcpp.LibvlcModuleDescriptionT p_list)
        {
            var __arg0 = ReferenceEquals(p_list, null) ? global::System.IntPtr.Zero : p_list.__Instance;
            __Internal.LibvlcModuleDescriptionListRelease(__arg0);
        }

        /// <summary>Returns a list of audio filters that are available.</summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <returns>
        /// <para>a list of module descriptions. It should be freed with libvlc_module_description_list_release().</para>
        /// <para>In case of an error, NULL is returned.</para>
        /// </returns>
        /// <remarks>
        /// <para>libvlc_module_description_t</para>
        /// <para>libvlc_module_description_list_release</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcModuleDescriptionT LibvlcAudioFilterListGet(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcAudioFilterListGet(__arg0);
            global::libvlcpp.LibvlcModuleDescriptionT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcModuleDescriptionT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcModuleDescriptionT) global::libvlcpp.LibvlcModuleDescriptionT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcModuleDescriptionT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Returns a list of video filters that are available.</summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <returns>
        /// <para>a list of module descriptions. It should be freed with libvlc_module_description_list_release().</para>
        /// <para>In case of an error, NULL is returned.</para>
        /// </returns>
        /// <remarks>
        /// <para>libvlc_module_description_t</para>
        /// <para>libvlc_module_description_list_release</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcModuleDescriptionT LibvlcVideoFilterListGet(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVideoFilterListGet(__arg0);
            global::libvlcpp.LibvlcModuleDescriptionT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcModuleDescriptionT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcModuleDescriptionT) global::libvlcpp.LibvlcModuleDescriptionT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcModuleDescriptionT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Return the current time as defined by LibVLC. The unit is the microsecond.</para>
        /// <para>Time increases monotonically (regardless of time zone changes and RTC</para>
        /// <para>adjustements).</para>
        /// <para>The origin is arbitrary but consistent across the whole system</para>
        /// <para>(e.g. the system uptim, the time since the system was booted).</para>
        /// </summary>
        /// <remarks>On systems that support it, the POSIX monotonic clock is used.</remarks>
        public static long LibvlcClock()
        {
            var __ret = __Internal.LibvlcClock();
            return __ret;
        }

        /// <summary>Return the delay (in microseconds) until a certain timestamp.</summary>
        /// <param name="pts">timestamp</param>
        /// <returns>
        /// <para>negative if timestamp is in the past,</para>
        /// <para>positive if it is in the future</para>
        /// </returns>
        public static long LibvlcDelay(long pts)
        {
            var __ret = __Internal.LibvlcDelay(pts);
            return __ret;
        }
    }

    /// <summary>
    /// <para>LibVLC renderer discoverer finds available renderers available on the local</para>
    /// <para>network</para>
    /// <para>@{</para>
    /// <para></para>
    /// <para>LibVLC renderer discoverer external API</para>
    /// </summary>
    /// <summary>Renderer item</summary>
    /// <remarks>
    /// <para>This struct is passed by a</para>
    /// <para>or deleted.</para>
    /// <para>An item is valid until the</para>
    /// <para>is called with the same pointer.</para>
    /// <para>libvlc_renderer_discoverer_event_manager()</para>
    /// </remarks>
    public unsafe partial class LibvlcRendererItemT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcRendererItemT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcRendererItemT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcRendererItemT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcRendererItemT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcRendererItemT __CreateInstance(global::libvlcpp.LibvlcRendererItemT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcRendererItemT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcRendererItemT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcRendererItemT.__Internal));
            *(global::libvlcpp.LibvlcRendererItemT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcRendererItemT(global::libvlcpp.LibvlcRendererItemT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcRendererItemT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class LibvlcRendererDiscovererT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcRendererDiscovererT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcRendererDiscovererT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcRendererDiscovererT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcRendererDiscovererT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcRendererDiscovererT __CreateInstance(global::libvlcpp.LibvlcRendererDiscovererT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcRendererDiscovererT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcRendererDiscovererT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcRendererDiscovererT.__Internal));
            *(global::libvlcpp.LibvlcRendererDiscovererT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcRendererDiscovererT(global::libvlcpp.LibvlcRendererDiscovererT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcRendererDiscovererT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    /// <summary>Renderer discoverer description</summary>
    /// <remarks>libvlc_renderer_discoverer_list_get()</remarks>
    public unsafe partial class LibvlcRdDescriptionT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 16)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr psz_name;

            [FieldOffset(8)]
            internal global::System.IntPtr psz_longname;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_rd_description_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcRdDescriptionT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcRdDescriptionT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcRdDescriptionT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcRdDescriptionT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcRdDescriptionT __CreateInstance(global::libvlcpp.LibvlcRdDescriptionT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcRdDescriptionT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcRdDescriptionT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcRdDescriptionT.__Internal));
            *(global::libvlcpp.LibvlcRdDescriptionT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcRdDescriptionT(global::libvlcpp.LibvlcRdDescriptionT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcRdDescriptionT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcRdDescriptionT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcRdDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcRdDescriptionT(global::libvlcpp.LibvlcRdDescriptionT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcRdDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcRdDescriptionT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcRdDescriptionT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcRdDescriptionT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public sbyte* PszName
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcRdDescriptionT.__Internal*) __Instance)->psz_name;
            }

            set
            {
                ((global::libvlcpp.LibvlcRdDescriptionT.__Internal*) __Instance)->psz_name = (global::System.IntPtr) value;
            }
        }

        public sbyte* PszLongname
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcRdDescriptionT.__Internal*) __Instance)->psz_longname;
            }

            set
            {
                ((global::libvlcpp.LibvlcRdDescriptionT.__Internal*) __Instance)->psz_longname = (global::System.IntPtr) value;
            }
        }
    }

    public unsafe partial class libvlc_renderer_discoverer
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_item_hold")]
            internal static extern global::System.IntPtr LibvlcRendererItemHold(global::System.IntPtr p_item);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_item_release")]
            internal static extern void LibvlcRendererItemRelease(global::System.IntPtr p_item);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_item_name")]
            internal static extern global::System.IntPtr LibvlcRendererItemName(global::System.IntPtr p_item);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_item_type")]
            internal static extern global::System.IntPtr LibvlcRendererItemType(global::System.IntPtr p_item);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_item_icon_uri")]
            internal static extern global::System.IntPtr LibvlcRendererItemIconUri(global::System.IntPtr p_item);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_item_flags")]
            internal static extern int LibvlcRendererItemFlags(global::System.IntPtr p_item);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_discoverer_new")]
            internal static extern global::System.IntPtr LibvlcRendererDiscovererNew(global::System.IntPtr p_inst, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_discoverer_release")]
            internal static extern void LibvlcRendererDiscovererRelease(global::System.IntPtr p_rd);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_discoverer_start")]
            internal static extern int LibvlcRendererDiscovererStart(global::System.IntPtr p_rd);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_discoverer_stop")]
            internal static extern void LibvlcRendererDiscovererStop(global::System.IntPtr p_rd);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_discoverer_event_manager")]
            internal static extern global::System.IntPtr LibvlcRendererDiscovererEventManager(global::System.IntPtr p_rd);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_discoverer_list_get")]
            internal static extern ulong LibvlcRendererDiscovererListGet(global::System.IntPtr p_inst, global::System.IntPtr ppp_services);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_renderer_discoverer_list_release")]
            internal static extern void LibvlcRendererDiscovererListRelease(global::System.IntPtr pp_services, ulong i_count);
        }

        /// <summary>Hold a renderer item, i.e. creates a new reference</summary>
        /// <returns>the current item</returns>
        /// <remarks>
        /// <para>This functions need to called from the libvlc_RendererDiscovererItemAdded</para>
        /// <para>callback if the libvlc user wants to use this item after. (for display or</para>
        /// <para>for passing it to the mediaplayer for example).</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcRendererItemT LibvlcRendererItemHold(global::libvlcpp.LibvlcRendererItemT p_item)
        {
            var __arg0 = ReferenceEquals(p_item, null) ? global::System.IntPtr.Zero : p_item.__Instance;
            var __ret = __Internal.LibvlcRendererItemHold(__arg0);
            global::libvlcpp.LibvlcRendererItemT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcRendererItemT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcRendererItemT) global::libvlcpp.LibvlcRendererItemT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcRendererItemT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Releases a renderer item, i.e. decrements its reference counter</summary>
        /// <remarks>LibVLC 3.0.0 or later</remarks>
        public static void LibvlcRendererItemRelease(global::libvlcpp.LibvlcRendererItemT p_item)
        {
            var __arg0 = ReferenceEquals(p_item, null) ? global::System.IntPtr.Zero : p_item.__Instance;
            __Internal.LibvlcRendererItemRelease(__arg0);
        }

        /// <summary>Get the human readable name of a renderer item</summary>
        /// <returns>the name of the item (can't be NULL, must *not* be freed)</returns>
        /// <remarks>LibVLC 3.0.0 or later</remarks>
        public static string LibvlcRendererItemName(global::libvlcpp.LibvlcRendererItemT p_item)
        {
            var __arg0 = ReferenceEquals(p_item, null) ? global::System.IntPtr.Zero : p_item.__Instance;
            var __ret = __Internal.LibvlcRendererItemName(__arg0);
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>
        /// <para>Get the type (not translated) of a renderer item. For now, the type can only</para>
        /// <para>be &quot;chromecast&quot; (&quot;upnp&quot;, &quot;airplay&quot; may come later).</para>
        /// </summary>
        /// <returns>the type of the item (can't be NULL, must *not* be freed)</returns>
        /// <remarks>LibVLC 3.0.0 or later</remarks>
        public static string LibvlcRendererItemType(global::libvlcpp.LibvlcRendererItemT p_item)
        {
            var __arg0 = ReferenceEquals(p_item, null) ? global::System.IntPtr.Zero : p_item.__Instance;
            var __ret = __Internal.LibvlcRendererItemType(__arg0);
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>Get the icon uri of a renderer item</summary>
        /// <returns>the uri of the item's icon (can be NULL, must *not* be freed)</returns>
        /// <remarks>LibVLC 3.0.0 or later</remarks>
        public static string LibvlcRendererItemIconUri(global::libvlcpp.LibvlcRendererItemT p_item)
        {
            var __arg0 = ReferenceEquals(p_item, null) ? global::System.IntPtr.Zero : p_item.__Instance;
            var __ret = __Internal.LibvlcRendererItemIconUri(__arg0);
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>Get the flags of a renderer item</summary>
        /// <returns>bitwise flag: capabilities of the renderer, see</returns>
        /// <remarks>
        /// <para>LIBVLC_RENDERER_CAN_AUDIO</para>
        /// <para>LIBVLC_RENDERER_CAN_VIDEO</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static int LibvlcRendererItemFlags(global::libvlcpp.LibvlcRendererItemT p_item)
        {
            var __arg0 = ReferenceEquals(p_item, null) ? global::System.IntPtr.Zero : p_item.__Instance;
            var __ret = __Internal.LibvlcRendererItemFlags(__arg0);
            return __ret;
        }

        /// <summary>Create a renderer discoverer object by name</summary>
        /// <param name="p_inst">libvlc instance</param>
        /// <param name="psz_name">
        /// <para>service name; use libvlc_renderer_discoverer_list_get() to</para>
        /// <para>get a list of the discoverer names available in this libVLC instance</para>
        /// </param>
        /// <returns>media discover object or NULL in case of error</returns>
        /// <remarks>
        /// <para>After this object is created, you should attach to events in order to be</para>
        /// <para>notified of the discoverer events.</para>
        /// <para>You need to call libvlc_renderer_discoverer_start() in order to start the</para>
        /// <para>discovery.</para>
        /// <para>libvlc_renderer_discoverer_event_manager()</para>
        /// <para>libvlc_renderer_discoverer_start()</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcRendererDiscovererT LibvlcRendererDiscovererNew(global::libvlcpp.LibvlcInstanceT p_inst, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_inst, null) ? global::System.IntPtr.Zero : p_inst.__Instance;
            var __ret = __Internal.LibvlcRendererDiscovererNew(__arg0, psz_name);
            global::libvlcpp.LibvlcRendererDiscovererT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcRendererDiscovererT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcRendererDiscovererT) global::libvlcpp.LibvlcRendererDiscovererT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcRendererDiscovererT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Release a renderer discoverer object</summary>
        /// <param name="p_rd">renderer discoverer object</param>
        /// <remarks>LibVLC 3.0.0 or later</remarks>
        public static void LibvlcRendererDiscovererRelease(global::libvlcpp.LibvlcRendererDiscovererT p_rd)
        {
            var __arg0 = ReferenceEquals(p_rd, null) ? global::System.IntPtr.Zero : p_rd.__Instance;
            __Internal.LibvlcRendererDiscovererRelease(__arg0);
        }

        /// <summary>Start renderer discovery</summary>
        /// <param name="p_rd">renderer discoverer object</param>
        /// <returns>-1 in case of error, 0 otherwise</returns>
        /// <remarks>
        /// <para>To stop it, call libvlc_renderer_discoverer_stop() or</para>
        /// <para>libvlc_renderer_discoverer_release() directly.</para>
        /// <para>libvlc_renderer_discoverer_stop()</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static int LibvlcRendererDiscovererStart(global::libvlcpp.LibvlcRendererDiscovererT p_rd)
        {
            var __arg0 = ReferenceEquals(p_rd, null) ? global::System.IntPtr.Zero : p_rd.__Instance;
            var __ret = __Internal.LibvlcRendererDiscovererStart(__arg0);
            return __ret;
        }

        /// <summary>Stop renderer discovery.</summary>
        /// <param name="p_rd">renderer discoverer object</param>
        /// <remarks>
        /// <para>libvlc_renderer_discoverer_start()</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static void LibvlcRendererDiscovererStop(global::libvlcpp.LibvlcRendererDiscovererT p_rd)
        {
            var __arg0 = ReferenceEquals(p_rd, null) ? global::System.IntPtr.Zero : p_rd.__Instance;
            __Internal.LibvlcRendererDiscovererStop(__arg0);
        }

        /// <summary>Get the event manager of the renderer discoverer</summary>
        /// <returns>a valid event manager (can't fail)</returns>
        /// <remarks>
        /// <para>The possible events to attach are</para>
        /// <para>and</para>
        /// <para>The</para>
        /// <para>VLC, users should take care of holding/releasing this struct for their</para>
        /// <para>internal usage.</para>
        /// <para>libvlc_event_t.u.renderer_discoverer_item_added.item</para>
        /// <para>libvlc_event_t.u.renderer_discoverer_item_removed.item</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcEventManagerT LibvlcRendererDiscovererEventManager(global::libvlcpp.LibvlcRendererDiscovererT p_rd)
        {
            var __arg0 = ReferenceEquals(p_rd, null) ? global::System.IntPtr.Zero : p_rd.__Instance;
            var __ret = __Internal.LibvlcRendererDiscovererEventManager(__arg0);
            global::libvlcpp.LibvlcEventManagerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEventManagerT) global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEventManagerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Get media discoverer services</summary>
        /// <param name="p_inst">libvlc instance</param>
        /// <param name="ppp_services">
        /// <para>address to store an allocated array of renderer</para>
        /// <para>discoverer services (must be freed with libvlc_renderer_list_release() by</para>
        /// <para>the caller) [OUT]</para>
        /// </param>
        /// <returns>the number of media discoverer services (0 on error)</returns>
        /// <remarks>
        /// <para>libvlc_renderer_list_release()</para>
        /// <para>LibVLC 3.0.0 and later</para>
        /// </remarks>
        public static ulong LibvlcRendererDiscovererListGet(global::libvlcpp.LibvlcInstanceT p_inst, global::libvlcpp.LibvlcRdDescriptionT ppp_services)
        {
            var __arg0 = ReferenceEquals(p_inst, null) ? global::System.IntPtr.Zero : p_inst.__Instance;
            var __arg1 = ReferenceEquals(ppp_services, null) ? global::System.IntPtr.Zero : ppp_services.__Instance;
            var __ret = __Internal.LibvlcRendererDiscovererListGet(__arg0, __arg1);
            return __ret;
        }

        /// <summary>Release an array of media discoverer services</summary>
        /// <param name="pp_services">array to release</param>
        /// <param name="i_count">number of elements in the array</param>
        /// <remarks>
        /// <para>libvlc_renderer_discoverer_list_get()</para>
        /// <para>LibVLC 3.0.0 and later</para>
        /// </remarks>
        public static void LibvlcRendererDiscovererListRelease(global::libvlcpp.LibvlcRdDescriptionT pp_services, ulong i_count)
        {
            var __arg0 = ReferenceEquals(pp_services, null) ? global::System.IntPtr.Zero : pp_services.__Instance;
            __Internal.LibvlcRendererDiscovererListRelease(__arg0, i_count);
        }
    }

    /// <summary>Meta data types</summary>
    public enum LibvlcMetaT
    {
        LibvlcMetaTitle = 0,
        LibvlcMetaArtist = 1,
        LibvlcMetaGenre = 2,
        LibvlcMetaCopyright = 3,
        LibvlcMetaAlbum = 4,
        LibvlcMetaTrackNumber = 5,
        LibvlcMetaDescription = 6,
        LibvlcMetaRating = 7,
        LibvlcMetaDate = 8,
        LibvlcMetaSetting = 9,
        LibvlcMetaURL = 10,
        LibvlcMetaLanguage = 11,
        LibvlcMetaNowPlaying = 12,
        LibvlcMetaPublisher = 13,
        LibvlcMetaEncodedBy = 14,
        LibvlcMetaArtworkURL = 15,
        LibvlcMetaTrackID = 16,
        LibvlcMetaTrackTotal = 17,
        LibvlcMetaDirector = 18,
        LibvlcMetaSeason = 19,
        LibvlcMetaEpisode = 20,
        LibvlcMetaShowName = 21,
        LibvlcMetaActors = 22,
        LibvlcMetaAlbumArtist = 23,
        LibvlcMetaDiscNumber = 24,
        LibvlcMetaDiscTotal = 25
    }

    public enum LibvlcTrackTypeT
    {
        LibvlcTrackUnknown = -1,
        LibvlcTrackAudio = 0,
        LibvlcTrackVideo = 1,
        LibvlcTrackText = 2
    }

    /// <summary>Note the order of libvlc_state_t enum must match exactly the order of</summary>
    /// <remarks>
    /// <para>mediacontrol_PlayerStatus,</para>
    /// <para>input_state_e enums,</para>
    /// <para>and VideoLAN.LibVLC.State (at bindings/cil/src/media.cs).</para>
    /// <para>Expected states by web plugins are:</para>
    /// <para>IDLE/CLOSE=0, OPENING=1, PLAYING=3, PAUSED=4,</para>
    /// <para>STOPPING=5, ENDED=6, ERROR=7</para>
    /// </remarks>
    public enum LibvlcStateT
    {
        LibvlcNothingSpecial = 0,
        LibvlcOpening = 1,
        LibvlcBuffering = 2,
        LibvlcPlaying = 3,
        LibvlcPaused = 4,
        LibvlcStopped = 5,
        LibvlcEnded = 6,
        LibvlcError = 7
    }

    [Flags]
    public enum LibvlcMediaOption
    {
        LibvlcMediaOptionTrusted = 2,
        LibvlcMediaOptionUnique = 256
    }

    public enum LibvlcVideoOrientT
    {
        /// <summary>Normal. Top line represents top, left column left.</summary>
        LibvlcVideoOrientTopLeft = 0,
        /// <summary>Flipped horizontally</summary>
        LibvlcVideoOrientTopRight = 1,
        /// <summary>Flipped vertically</summary>
        LibvlcVideoOrientBottomLeft = 2,
        /// <summary>Rotated 180 degrees</summary>
        LibvlcVideoOrientBottomRight = 3,
        /// <summary>Transposed</summary>
        LibvlcVideoOrientLeftTop = 4,
        /// <summary>Rotated 90 degrees clockwise (or 270 anti-clockwise)</summary>
        LibvlcVideoOrientLeftBottom = 5,
        /// <summary>Rotated 90 degrees anti-clockwise</summary>
        LibvlcVideoOrientRightTop = 6,
        /// <summary>Anti-transposed</summary>
        LibvlcVideoOrientRightBottom = 7
    }

    [Flags]
    public enum LibvlcVideoProjectionT
    {
        LibvlcVideoProjectionRectangular = 0,
        /// <summary>360 spherical</summary>
        LibvlcVideoProjectionEquirectangular = 1,
        LibvlcVideoProjectionCubemapLayoutStandard = 256
    }

    /// <summary>Media type</summary>
    /// <remarks>libvlc_media_get_type</remarks>
    public enum LibvlcMediaTypeT
    {
        LibvlcMediaTypeUnknown = 0,
        LibvlcMediaTypeFile = 1,
        LibvlcMediaTypeDirectory = 2,
        LibvlcMediaTypeDisc = 3,
        LibvlcMediaTypeStream = 4,
        LibvlcMediaTypePlaylist = 5
    }

    /// <summary>Parse flags used by libvlc_media_parse_with_options()</summary>
    /// <remarks>libvlc_media_parse_with_options</remarks>
    [Flags]
    public enum LibvlcMediaParseFlagT
    {
        /// <summary>Parse media if it's a local file</summary>
        LibvlcMediaParseLocal = 0,
        /// <summary>Parse media even if it's a network file</summary>
        LibvlcMediaParseNetwork = 1,
        /// <summary>Fetch meta and covert art using local resources</summary>
        LibvlcMediaFetchLocal = 2,
        /// <summary>Fetch meta and covert art using network resources</summary>
        LibvlcMediaFetchNetwork = 4,
        /// <summary>
        /// <para>Interact with the user (via libvlc_dialog_cbs) when preparsing this item</para>
        /// <para>(and not its sub items). Set this flag in order to receive a callback</para>
        /// <para>when the input is asking for credentials.</para>
        /// </summary>
        LibvlcMediaDoInteract = 8
    }

    /// <summary>
    /// <para>Parse status used sent by libvlc_media_parse_with_options() or returned by</para>
    /// <para>libvlc_media_get_parsed_status()</para>
    /// </summary>
    /// <remarks>
    /// <para>libvlc_media_parse_with_options</para>
    /// <para>libvlc_media_get_parsed_status</para>
    /// </remarks>
    public enum LibvlcMediaParsedStatusT
    {
        LibvlcMediaParsedStatusSkipped = 1,
        LibvlcMediaParsedStatusFailed = 2,
        LibvlcMediaParsedStatusTimeout = 3,
        LibvlcMediaParsedStatusDone = 4
    }

    /// <summary>Type of a media slave: subtitle or audio.</summary>
    public enum LibvlcMediaSlaveTypeT
    {
        LibvlcMediaSlaveTypeSubtitle = 0,
        LibvlcMediaSlaveTypeAudio = 1
    }

    /// <summary>
    /// <para>It consists of a media location and various optional meta data.</para>
    /// <para>@{</para>
    /// <para></para>
    /// <para>LibVLC media item/descriptor external API</para>
    /// </summary>
    /// <summary>Callback prototype to open a custom bitstream input media.</summary>
    /// <param name="opaque">private pointer as passed to libvlc_media_new_callbacks()</param>
    /// <param name="datap">storage space for a private data pointer [OUT]</param>
    /// <param name="sizep">byte length of the bitstream or UINT64_MAX if unknown [OUT]</param>
    /// <returns>
    /// <para>0 on success, non-zero on error. In case of failure, the other</para>
    /// <para>callbacks will not be invoked and any value stored in *datap and *sizep is</para>
    /// <para>discarded.</para>
    /// </returns>
    /// <remarks>
    /// <para>The same media item can be opened multiple times. Each time, this callback</para>
    /// <para>is invoked. It should allocate and initialize any instance-specific</para>
    /// <para>resources, then store them in *datap. The instance resources can be freed</para>
    /// <para>in the</para>
    /// <para>For convenience, *datap is initially NULL and *sizep is initially 0.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate int LibvlcMediaOpenCb(global::System.IntPtr opaque, void** datap, ulong* sizep);

    /// <summary>Callback prototype to read data from a custom bitstream input media.</summary>
    /// <param name="opaque">private pointer as set by the</param>
    /// <param name="buf">start address of the buffer to read data into</param>
    /// <param name="len">bytes length of the buffer</param>
    /// <returns>
    /// <para>strictly positive number of bytes read, 0 on end-of-stream,</para>
    /// <para>or -1 on non-recoverable error</para>
    /// </returns>
    /// <remarks>
    /// <para>callback</para>
    /// <para>If no data is immediately available, then the callback should sleep.</para>
    /// <para>The application is responsible for avoiding deadlock situations.</para>
    /// <para>In particular, the callback should return an error if playback is stopped;</para>
    /// <para>if it does not return, then libvlc_media_player_stop() will never return.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate int LibvlcMediaReadCb(global::System.IntPtr opaque, byte* buf, ulong len);

    /// <summary>Callback prototype to seek a custom bitstream input media.</summary>
    /// <param name="opaque">private pointer as set by the</param>
    /// <param name="offset">absolute byte offset to seek to</param>
    /// <returns>0 on success, -1 on error.</returns>
    /// <remarks>callback</remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate int LibvlcMediaSeekCb(global::System.IntPtr opaque, ulong offset);

    /// <summary>Callback prototype to close a custom bitstream input media.</summary>
    /// <param name="opaque">private pointer as set by the</param>
    /// <remarks>callback</remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcMediaCloseCb(global::System.IntPtr opaque);

    public unsafe partial class LibvlcMediaT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaT __CreateInstance(global::libvlcpp.LibvlcMediaT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaT.__Internal));
            *(global::libvlcpp.LibvlcMediaT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaT(global::libvlcpp.LibvlcMediaT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class LibvlcMediaListT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaListT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaListT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaListT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaListT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaListT __CreateInstance(global::libvlcpp.LibvlcMediaListT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaListT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaListT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaListT.__Internal));
            *(global::libvlcpp.LibvlcMediaListT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaListT(global::libvlcpp.LibvlcMediaListT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaListT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class LibvlcMediaStatsT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 60)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int i_read_bytes;

            [FieldOffset(4)]
            internal float f_input_bitrate;

            [FieldOffset(8)]
            internal int i_demux_read_bytes;

            [FieldOffset(12)]
            internal float f_demux_bitrate;

            [FieldOffset(16)]
            internal int i_demux_corrupted;

            [FieldOffset(20)]
            internal int i_demux_discontinuity;

            [FieldOffset(24)]
            internal int i_decoded_video;

            [FieldOffset(28)]
            internal int i_decoded_audio;

            [FieldOffset(32)]
            internal int i_displayed_pictures;

            [FieldOffset(36)]
            internal int i_lost_pictures;

            [FieldOffset(40)]
            internal int i_played_abuffers;

            [FieldOffset(44)]
            internal int i_lost_abuffers;

            [FieldOffset(48)]
            internal int i_sent_packets;

            [FieldOffset(52)]
            internal int i_sent_bytes;

            [FieldOffset(56)]
            internal float f_send_bitrate;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_media_stats_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaStatsT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaStatsT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaStatsT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaStatsT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaStatsT __CreateInstance(global::libvlcpp.LibvlcMediaStatsT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaStatsT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaStatsT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaStatsT.__Internal));
            *(global::libvlcpp.LibvlcMediaStatsT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaStatsT(global::libvlcpp.LibvlcMediaStatsT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaStatsT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcMediaStatsT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaStatsT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcMediaStatsT(global::libvlcpp.LibvlcMediaStatsT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaStatsT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcMediaStatsT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcMediaStatsT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int IReadBytes
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_read_bytes;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_read_bytes = value;
            }
        }

        public float FInputBitrate
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->f_input_bitrate;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->f_input_bitrate = value;
            }
        }

        public int IDemuxReadBytes
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_demux_read_bytes;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_demux_read_bytes = value;
            }
        }

        public float FDemuxBitrate
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->f_demux_bitrate;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->f_demux_bitrate = value;
            }
        }

        public int IDemuxCorrupted
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_demux_corrupted;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_demux_corrupted = value;
            }
        }

        public int IDemuxDiscontinuity
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_demux_discontinuity;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_demux_discontinuity = value;
            }
        }

        public int IDecodedVideo
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_decoded_video;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_decoded_video = value;
            }
        }

        public int IDecodedAudio
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_decoded_audio;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_decoded_audio = value;
            }
        }

        public int IDisplayedPictures
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_displayed_pictures;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_displayed_pictures = value;
            }
        }

        public int ILostPictures
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_lost_pictures;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_lost_pictures = value;
            }
        }

        public int IPlayedAbuffers
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_played_abuffers;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_played_abuffers = value;
            }
        }

        public int ILostAbuffers
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_lost_abuffers;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_lost_abuffers = value;
            }
        }

        public int ISentPackets
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_sent_packets;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_sent_packets = value;
            }
        }

        public int ISentBytes
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_sent_bytes;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->i_sent_bytes = value;
            }
        }

        public float FSendBitrate
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->f_send_bitrate;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaStatsT.__Internal*) __Instance)->f_send_bitrate = value;
            }
        }
    }

    public unsafe partial class LibvlcMediaTrackInfoT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 28)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal uint i_codec;

            [FieldOffset(4)]
            internal int i_id;

            [FieldOffset(8)]
            internal global::libvlcpp.LibvlcTrackTypeT i_type;

            [FieldOffset(12)]
            internal int i_profile;

            [FieldOffset(16)]
            internal int i_level;

            [FieldOffset(20)]
            internal global::libvlcpp.LibvlcMediaTrackInfoT._.__Internal u;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_media_track_info_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public unsafe partial struct _
        {
            [StructLayout(LayoutKind.Explicit, Size = 8)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcMediaTrackInfoT._.__.__Internal audio;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcMediaTrackInfoT._.___.__Internal video;
            }

            public unsafe partial class __
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal uint i_channels;

                    [FieldOffset(4)]
                    internal uint i_rate;
                }
            }

            public unsafe partial class ___
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal uint i_height;

                    [FieldOffset(4)]
                    internal uint i_width;
                }
            }
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaTrackInfoT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaTrackInfoT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaTrackInfoT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaTrackInfoT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaTrackInfoT __CreateInstance(global::libvlcpp.LibvlcMediaTrackInfoT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaTrackInfoT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaTrackInfoT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaTrackInfoT.__Internal));
            *(global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaTrackInfoT(global::libvlcpp.LibvlcMediaTrackInfoT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaTrackInfoT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcMediaTrackInfoT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaTrackInfoT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcMediaTrackInfoT(global::libvlcpp.LibvlcMediaTrackInfoT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaTrackInfoT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcMediaTrackInfoT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public uint ICodec
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_codec;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_codec = value;
            }
        }

        public int IId
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_id;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_id = value;
            }
        }

        public global::libvlcpp.LibvlcTrackTypeT IType
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_type;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_type = value;
            }
        }

        public int IProfile
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_profile;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_profile = value;
            }
        }

        public int ILevel
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_level;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackInfoT.__Internal*) __Instance)->i_level = value;
            }
        }
    }

    public unsafe partial class LibvlcAudioTrackT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 8)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal uint i_channels;

            [FieldOffset(4)]
            internal uint i_rate;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_audio_track_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcAudioTrackT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcAudioTrackT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcAudioTrackT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcAudioTrackT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcAudioTrackT __CreateInstance(global::libvlcpp.LibvlcAudioTrackT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcAudioTrackT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcAudioTrackT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioTrackT.__Internal));
            *(global::libvlcpp.LibvlcAudioTrackT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcAudioTrackT(global::libvlcpp.LibvlcAudioTrackT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcAudioTrackT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcAudioTrackT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioTrackT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcAudioTrackT(global::libvlcpp.LibvlcAudioTrackT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioTrackT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcAudioTrackT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcAudioTrackT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcAudioTrackT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public uint IChannels
        {
            get
            {
                return ((global::libvlcpp.LibvlcAudioTrackT.__Internal*) __Instance)->i_channels;
            }

            set
            {
                ((global::libvlcpp.LibvlcAudioTrackT.__Internal*) __Instance)->i_channels = value;
            }
        }

        public uint IRate
        {
            get
            {
                return ((global::libvlcpp.LibvlcAudioTrackT.__Internal*) __Instance)->i_rate;
            }

            set
            {
                ((global::libvlcpp.LibvlcAudioTrackT.__Internal*) __Instance)->i_rate = value;
            }
        }
    }

    /// <summary>Viewpoint</summary>
    /// <remarks>allocate using libvlc_video_new_viewpoint()</remarks>
    public unsafe partial class LibvlcVideoViewpointT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 16)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal float f_yaw;

            [FieldOffset(4)]
            internal float f_pitch;

            [FieldOffset(8)]
            internal float f_roll;

            [FieldOffset(12)]
            internal float f_field_of_view;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_video_viewpoint_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcVideoViewpointT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcVideoViewpointT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcVideoViewpointT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcVideoViewpointT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcVideoViewpointT __CreateInstance(global::libvlcpp.LibvlcVideoViewpointT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcVideoViewpointT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcVideoViewpointT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcVideoViewpointT.__Internal));
            *(global::libvlcpp.LibvlcVideoViewpointT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcVideoViewpointT(global::libvlcpp.LibvlcVideoViewpointT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcVideoViewpointT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcVideoViewpointT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcVideoViewpointT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcVideoViewpointT(global::libvlcpp.LibvlcVideoViewpointT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcVideoViewpointT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcVideoViewpointT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public float FYaw
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance)->f_yaw;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance)->f_yaw = value;
            }
        }

        public float FPitch
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance)->f_pitch;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance)->f_pitch = value;
            }
        }

        public float FRoll
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance)->f_roll;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance)->f_roll = value;
            }
        }

        public float FFieldOfView
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance)->f_field_of_view;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoViewpointT.__Internal*) __Instance)->f_field_of_view = value;
            }
        }
    }

    public unsafe partial class LibvlcVideoTrackT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 48)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal uint i_height;

            [FieldOffset(4)]
            internal uint i_width;

            [FieldOffset(8)]
            internal uint i_sar_num;

            [FieldOffset(12)]
            internal uint i_sar_den;

            [FieldOffset(16)]
            internal uint i_frame_rate_num;

            [FieldOffset(20)]
            internal uint i_frame_rate_den;

            [FieldOffset(24)]
            internal global::libvlcpp.LibvlcVideoOrientT i_orientation;

            [FieldOffset(28)]
            internal global::libvlcpp.LibvlcVideoProjectionT i_projection;

            [FieldOffset(32)]
            internal global::libvlcpp.LibvlcVideoViewpointT.__Internal pose;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_video_track_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcVideoTrackT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcVideoTrackT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcVideoTrackT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcVideoTrackT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcVideoTrackT __CreateInstance(global::libvlcpp.LibvlcVideoTrackT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcVideoTrackT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcVideoTrackT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcVideoTrackT.__Internal));
            *(global::libvlcpp.LibvlcVideoTrackT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcVideoTrackT(global::libvlcpp.LibvlcVideoTrackT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcVideoTrackT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcVideoTrackT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcVideoTrackT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcVideoTrackT(global::libvlcpp.LibvlcVideoTrackT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcVideoTrackT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcVideoTrackT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcVideoTrackT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public uint IHeight
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_height;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_height = value;
            }
        }

        public uint IWidth
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_width;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_width = value;
            }
        }

        public uint ISarNum
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_sar_num;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_sar_num = value;
            }
        }

        public uint ISarDen
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_sar_den;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_sar_den = value;
            }
        }

        public uint IFrameRateNum
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_frame_rate_num;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_frame_rate_num = value;
            }
        }

        public uint IFrameRateDen
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_frame_rate_den;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_frame_rate_den = value;
            }
        }

        public global::libvlcpp.LibvlcVideoOrientT IOrientation
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_orientation;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_orientation = value;
            }
        }

        public global::libvlcpp.LibvlcVideoProjectionT IProjection
        {
            get
            {
                return ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_projection;
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->i_projection = value;
            }
        }

        public global::libvlcpp.LibvlcVideoViewpointT Pose
        {
            get
            {
                return global::libvlcpp.LibvlcVideoViewpointT.__CreateInstance(((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->pose);
            }

            set
            {
                ((global::libvlcpp.LibvlcVideoTrackT.__Internal*) __Instance)->pose = ReferenceEquals(value, null) ? new global::libvlcpp.LibvlcVideoViewpointT.__Internal() : *(global::libvlcpp.LibvlcVideoViewpointT.__Internal*) value.__Instance;
            }
        }
    }

    public unsafe partial class LibvlcSubtitleTrackT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 8)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr psz_encoding;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_subtitle_track_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcSubtitleTrackT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcSubtitleTrackT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcSubtitleTrackT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcSubtitleTrackT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcSubtitleTrackT __CreateInstance(global::libvlcpp.LibvlcSubtitleTrackT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcSubtitleTrackT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcSubtitleTrackT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcSubtitleTrackT.__Internal));
            *(global::libvlcpp.LibvlcSubtitleTrackT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcSubtitleTrackT(global::libvlcpp.LibvlcSubtitleTrackT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcSubtitleTrackT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcSubtitleTrackT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcSubtitleTrackT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcSubtitleTrackT(global::libvlcpp.LibvlcSubtitleTrackT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcSubtitleTrackT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcSubtitleTrackT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcSubtitleTrackT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcSubtitleTrackT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public sbyte* PszEncoding
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcSubtitleTrackT.__Internal*) __Instance)->psz_encoding;
            }

            set
            {
                ((global::libvlcpp.LibvlcSubtitleTrackT.__Internal*) __Instance)->psz_encoding = (global::System.IntPtr) value;
            }
        }
    }

    public unsafe partial class LibvlcMediaTrackT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 56)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal uint i_codec;

            [FieldOffset(4)]
            internal uint i_original_fourcc;

            [FieldOffset(8)]
            internal int i_id;

            [FieldOffset(12)]
            internal global::libvlcpp.LibvlcTrackTypeT i_type;

            [FieldOffset(16)]
            internal int i_profile;

            [FieldOffset(20)]
            internal int i_level;

            [FieldOffset(24)]
            internal global::libvlcpp.LibvlcMediaTrackT._.__Internal _;

            [FieldOffset(32)]
            internal uint i_bitrate;

            [FieldOffset(40)]
            internal global::System.IntPtr psz_language;

            [FieldOffset(48)]
            internal global::System.IntPtr psz_description;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_media_track_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public unsafe partial struct _
        {
            [StructLayout(LayoutKind.Explicit, Size = 8)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::System.IntPtr audio;

                [FieldOffset(0)]
                internal global::System.IntPtr video;

                [FieldOffset(0)]
                internal global::System.IntPtr subtitle;
            }
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaTrackT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaTrackT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaTrackT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaTrackT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaTrackT __CreateInstance(global::libvlcpp.LibvlcMediaTrackT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaTrackT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaTrackT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaTrackT.__Internal));
            *(global::libvlcpp.LibvlcMediaTrackT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaTrackT(global::libvlcpp.LibvlcMediaTrackT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaTrackT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcMediaTrackT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaTrackT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcMediaTrackT(global::libvlcpp.LibvlcMediaTrackT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaTrackT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcMediaTrackT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcMediaTrackT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public uint ICodec
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_codec;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_codec = value;
            }
        }

        public uint IOriginalFourcc
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_original_fourcc;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_original_fourcc = value;
            }
        }

        public int IId
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_id;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_id = value;
            }
        }

        public global::libvlcpp.LibvlcTrackTypeT IType
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_type;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_type = value;
            }
        }

        public int IProfile
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_profile;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_profile = value;
            }
        }

        public int ILevel
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_level;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_level = value;
            }
        }

        public uint IBitrate
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_bitrate;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->i_bitrate = value;
            }
        }

        public sbyte* PszLanguage
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->psz_language;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->psz_language = (global::System.IntPtr) value;
            }
        }

        public sbyte* PszDescription
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->psz_description;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaTrackT.__Internal*) __Instance)->psz_description = (global::System.IntPtr) value;
            }
        }
    }

    /// <summary>A slave of a libvlc_media_t</summary>
    /// <remarks>libvlc_media_slaves_get</remarks>
    public unsafe partial class LibvlcMediaSlaveT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 16)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr psz_uri;

            [FieldOffset(8)]
            internal global::libvlcpp.LibvlcMediaSlaveTypeT i_type;

            [FieldOffset(12)]
            internal uint i_priority;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_media_slave_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaSlaveT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaSlaveT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaSlaveT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaSlaveT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaSlaveT __CreateInstance(global::libvlcpp.LibvlcMediaSlaveT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaSlaveT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaSlaveT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaSlaveT.__Internal));
            *(global::libvlcpp.LibvlcMediaSlaveT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaSlaveT(global::libvlcpp.LibvlcMediaSlaveT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaSlaveT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcMediaSlaveT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaSlaveT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcMediaSlaveT(global::libvlcpp.LibvlcMediaSlaveT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaSlaveT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcMediaSlaveT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcMediaSlaveT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcMediaSlaveT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public sbyte* PszUri
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcMediaSlaveT.__Internal*) __Instance)->psz_uri;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaSlaveT.__Internal*) __Instance)->psz_uri = (global::System.IntPtr) value;
            }
        }

        public global::libvlcpp.LibvlcMediaSlaveTypeT IType
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaSlaveT.__Internal*) __Instance)->i_type;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaSlaveT.__Internal*) __Instance)->i_type = value;
            }
        }

        public uint IPriority
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaSlaveT.__Internal*) __Instance)->i_priority;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaSlaveT.__Internal*) __Instance)->i_priority = value;
            }
        }
    }

    public unsafe partial class libvlc_media
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_new_location")]
            internal static extern global::System.IntPtr LibvlcMediaNewLocation(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_mrl);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_new_path")]
            internal static extern global::System.IntPtr LibvlcMediaNewPath(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string path);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_new_fd")]
            internal static extern global::System.IntPtr LibvlcMediaNewFd(global::System.IntPtr p_instance, int fd);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_new_callbacks")]
            internal static extern global::System.IntPtr LibvlcMediaNewCallbacks(global::System.IntPtr instance, global::System.IntPtr open_cb, global::System.IntPtr read_cb, global::System.IntPtr seek_cb, global::System.IntPtr close_cb, global::System.IntPtr opaque);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_new_as_node")]
            internal static extern global::System.IntPtr LibvlcMediaNewAsNode(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_add_option")]
            internal static extern void LibvlcMediaAddOption(global::System.IntPtr p_md, [MarshalAs(UnmanagedType.LPStr)] string psz_options);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_add_option_flag")]
            internal static extern void LibvlcMediaAddOptionFlag(global::System.IntPtr p_md, [MarshalAs(UnmanagedType.LPStr)] string psz_options, uint i_flags);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_retain")]
            internal static extern void LibvlcMediaRetain(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_release")]
            internal static extern void LibvlcMediaRelease(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_mrl")]
            internal static extern sbyte* LibvlcMediaGetMrl(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_duplicate")]
            internal static extern global::System.IntPtr LibvlcMediaDuplicate(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_meta")]
            internal static extern sbyte* LibvlcMediaGetMeta(global::System.IntPtr p_md, global::libvlcpp.LibvlcMetaT e_meta);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_set_meta")]
            internal static extern void LibvlcMediaSetMeta(global::System.IntPtr p_md, global::libvlcpp.LibvlcMetaT e_meta, [MarshalAs(UnmanagedType.LPStr)] string psz_value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_save_meta")]
            internal static extern int LibvlcMediaSaveMeta(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_state")]
            internal static extern global::libvlcpp.LibvlcStateT LibvlcMediaGetState(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_stats")]
            internal static extern int LibvlcMediaGetStats(global::System.IntPtr p_md, global::System.IntPtr p_stats);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_subitems")]
            internal static extern global::System.IntPtr LibvlcMediaSubitems(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_event_manager")]
            internal static extern global::System.IntPtr LibvlcMediaEventManager(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_duration")]
            internal static extern long LibvlcMediaGetDuration(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_parse_with_options")]
            internal static extern int LibvlcMediaParseWithOptions(global::System.IntPtr p_md, global::libvlcpp.LibvlcMediaParseFlagT parse_flag, int timeout);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_parse_stop")]
            internal static extern void LibvlcMediaParseStop(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_parsed_status")]
            internal static extern global::libvlcpp.LibvlcMediaParsedStatusT LibvlcMediaGetParsedStatus(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_set_user_data")]
            internal static extern void LibvlcMediaSetUserData(global::System.IntPtr p_md, global::System.IntPtr p_new_user_data);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_user_data")]
            internal static extern global::System.IntPtr LibvlcMediaGetUserData(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_tracks_get")]
            internal static extern uint LibvlcMediaTracksGet(global::System.IntPtr p_md, global::System.IntPtr tracks);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_codec_description")]
            internal static extern global::System.IntPtr LibvlcMediaGetCodecDescription(global::libvlcpp.LibvlcTrackTypeT i_type, uint i_codec);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_tracks_release")]
            internal static extern void LibvlcMediaTracksRelease(global::System.IntPtr p_tracks, uint i_count);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_type")]
            internal static extern global::libvlcpp.LibvlcMediaTypeT LibvlcMediaGetType(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_slaves_add")]
            internal static extern int LibvlcMediaSlavesAdd(global::System.IntPtr p_md, global::libvlcpp.LibvlcMediaSlaveTypeT i_type, uint i_priority, [MarshalAs(UnmanagedType.LPStr)] string psz_uri);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_slaves_clear")]
            internal static extern void LibvlcMediaSlavesClear(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_slaves_get")]
            internal static extern uint LibvlcMediaSlavesGet(global::System.IntPtr p_md, global::System.IntPtr ppp_slaves);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_slaves_release")]
            internal static extern void LibvlcMediaSlavesRelease(global::System.IntPtr pp_slaves, uint i_count);
        }

        /// <summary>
        /// <para>Create a media with a certain given media resource location,</para>
        /// <para>for instance a valid URL.</para>
        /// </summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_mrl">the media location</param>
        /// <returns>the newly created media or NULL on error</returns>
        /// <remarks>
        /// <para>To refer to a local file with this function,</para>
        /// <para>the file://... URI syntaxmustbe used (see IETF RFC3986).</para>
        /// <para>We recommend using libvlc_media_new_path() instead when dealing with</para>
        /// <para>local files.</para>
        /// <para>libvlc_media_release</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaNewLocation(global::libvlcpp.LibvlcInstanceT p_instance, string psz_mrl)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcMediaNewLocation(__arg0, psz_mrl);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Create a media for a certain file path.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="path">local filesystem path</param>
        /// <returns>the newly created media or NULL on error</returns>
        /// <remarks>libvlc_media_release</remarks>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaNewPath(global::libvlcpp.LibvlcInstanceT p_instance, string path)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcMediaNewPath(__arg0, path);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Create a media for an already open file descriptor.</para>
        /// <para>The file descriptor shall be open for reading (or reading and writing).</para>
        /// </summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="fd">open file descriptor</param>
        /// <returns>the newly created media or NULL on error</returns>
        /// <remarks>
        /// <para>Regular file descriptors, pipe read descriptors and character device</para>
        /// <para>descriptors (including TTYs) are supported on all platforms.</para>
        /// <para>Block device descriptors are supported where available.</para>
        /// <para>Directory descriptors are supported on systems that provide fdopendir().</para>
        /// <para>Sockets are supported on all platforms where they are file descriptors,</para>
        /// <para>i.e. all except Windows.</para>
        /// <para>This library willnotautomatically close the file descriptor</para>
        /// <para>under any circumstance. Nevertheless, a file descriptor can usually only be</para>
        /// <para>rendered once in a media player. To render it a second time, the file</para>
        /// <para>descriptor should probably be rewound to the beginning with lseek().</para>
        /// <para>libvlc_media_release</para>
        /// <para>LibVLC 1.1.5 and later.</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaNewFd(global::libvlcpp.LibvlcInstanceT p_instance, int fd)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcMediaNewFd(__arg0, fd);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Create a media with custom callbacks to read the data from.</summary>
        /// <param name="instance">LibVLC instance</param>
        /// <param name="open_cb">callback to open the custom bitstream input media</param>
        /// <param name="read_cb">callback to read data (must not be NULL)</param>
        /// <param name="seek_cb">callback to seek, or NULL if seeking is not supported</param>
        /// <param name="close_cb">callback to close the media, or NULL if unnecessary</param>
        /// <param name="opaque">data pointer for the open callback</param>
        /// <returns>the newly created media or NULL on error</returns>
        /// <remarks>
        /// <para>If open_cb is NULL, the opaque pointer will be passed to read_cb,</para>
        /// <para>seek_cb and close_cb, and the stream size will be treated as unknown.</para>
        /// <para>The callbacks may be called asynchronously (from another thread).</para>
        /// <para>A single stream instance need not be reentrant. However the open_cb needs to</para>
        /// <para>be reentrant if the media is used by multiple player instances.</para>
        /// <para>The callbacks may be used until all or any player instances</para>
        /// <para>that were supplied the media item are stopped.</para>
        /// <para>libvlc_media_release</para>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaNewCallbacks(global::libvlcpp.LibvlcInstanceT instance, global::libvlcpp.LibvlcMediaOpenCb open_cb, global::libvlcpp.LibvlcMediaReadCb read_cb, global::libvlcpp.LibvlcMediaSeekCb seek_cb, global::libvlcpp.LibvlcMediaCloseCb close_cb, global::System.IntPtr opaque)
        {
            var __arg0 = ReferenceEquals(instance, null) ? global::System.IntPtr.Zero : instance.__Instance;
            var __arg1 = open_cb == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(open_cb);
            var __arg2 = read_cb == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(read_cb);
            var __arg3 = seek_cb == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(seek_cb);
            var __arg4 = close_cb == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(close_cb);
            var __ret = __Internal.LibvlcMediaNewCallbacks(__arg0, __arg1, __arg2, __arg3, __arg4, opaque);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Create a media as an empty node with a given name.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the name of the node</param>
        /// <returns>the new empty media or NULL on error</returns>
        /// <remarks>libvlc_media_release</remarks>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaNewAsNode(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcMediaNewAsNode(__arg0, psz_name);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Add an option to the media.</summary>
        /// <param name="p_md">the media descriptor</param>
        /// <param name="psz_options">the options (as a string)</param>
        /// <remarks>
        /// <para>This option will be used to determine how the media_player will</para>
        /// <para>read the media. This allows to use VLC's advanced</para>
        /// <para>reading/streaming options on a per-media basis.</para>
        /// <para>The options are listed in 'vlc --long-help' from the command line,</para>
        /// <para>e.g. &quot;-sout-all&quot;. Keep in mind that available options and their semantics</para>
        /// <para>vary across LibVLC versions and builds.</para>
        /// <para>Not all options affects libvlc_media_t objects:</para>
        /// <para>Specifically, due to architectural issues most audio and video options,</para>
        /// <para>such as text renderer options, have no effects on an individual media.</para>
        /// <para>These options must be set through libvlc_new() instead.</para>
        /// </remarks>
        public static void LibvlcMediaAddOption(global::libvlcpp.LibvlcMediaT p_md, string psz_options)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaAddOption(__arg0, psz_options);
        }

        /// <summary>Add an option to the media with configurable flags.</summary>
        /// <param name="p_md">the media descriptor</param>
        /// <param name="psz_options">the options (as a string)</param>
        /// <param name="i_flags">the flags for this option</param>
        /// <remarks>
        /// <para>This option will be used to determine how the media_player will</para>
        /// <para>read the media. This allows to use VLC's advanced</para>
        /// <para>reading/streaming options on a per-media basis.</para>
        /// <para>The options are detailed in vlc --long-help, for instance</para>
        /// <para>&quot;--sout-all&quot;. Note that all options are not usable on medias:</para>
        /// <para>specifically, due to architectural issues, video-related options</para>
        /// <para>such as text renderer options cannot be set on a single media. They</para>
        /// <para>must be set on the whole libvlc instance instead.</para>
        /// </remarks>
        public static void LibvlcMediaAddOptionFlag(global::libvlcpp.LibvlcMediaT p_md, string psz_options, uint i_flags)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaAddOptionFlag(__arg0, psz_options, i_flags);
        }

        /// <summary>
        /// <para>Retain a reference to a media descriptor object (libvlc_media_t). Use</para>
        /// <para>libvlc_media_release() to decrement the reference count of a</para>
        /// <para>media descriptor object.</para>
        /// </summary>
        /// <param name="p_md">the media descriptor</param>
        public static void LibvlcMediaRetain(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaRetain(__arg0);
        }

        /// <summary>
        /// <para>Decrement the reference count of a media descriptor object. If the</para>
        /// <para>reference count is 0, then libvlc_media_release() will release the</para>
        /// <para>media descriptor object. It will send out an libvlc_MediaFreed event</para>
        /// <para>to all listeners. If the media descriptor object has been released it</para>
        /// <para>should not be used again.</para>
        /// </summary>
        /// <param name="p_md">the media descriptor</param>
        public static void LibvlcMediaRelease(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaRelease(__arg0);
        }

        /// <summary>Get the media resource locator (mrl) from a media descriptor object</summary>
        /// <param name="p_md">a media descriptor object</param>
        /// <returns>string with mrl of media descriptor object</returns>
        public static sbyte* LibvlcMediaGetMrl(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaGetMrl(__arg0);
            return __ret;
        }

        /// <summary>Duplicate a media descriptor object.</summary>
        /// <param name="p_md">a media descriptor object.</param>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaDuplicate(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaDuplicate(__arg0);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Read the meta of the media.</summary>
        /// <param name="p_md">the media descriptor</param>
        /// <param name="e_meta">the meta to read</param>
        /// <returns>the media's meta</returns>
        /// <remarks>
        /// <para>If the media has not yet been parsed this will return NULL.</para>
        /// <para>libvlc_media_parse</para>
        /// <para>libvlc_media_parse_with_options</para>
        /// <para>libvlc_MediaMetaChanged</para>
        /// </remarks>
        public static sbyte* LibvlcMediaGetMeta(global::libvlcpp.LibvlcMediaT p_md, global::libvlcpp.LibvlcMetaT e_meta)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaGetMeta(__arg0, e_meta);
            return __ret;
        }

        /// <summary>
        /// <para>Set the meta of the media (this function will not save the meta, call</para>
        /// <para>libvlc_media_save_meta in order to save the meta)</para>
        /// </summary>
        /// <param name="p_md">the media descriptor</param>
        /// <param name="e_meta">the meta to write</param>
        /// <param name="psz_value">the media's meta</param>
        public static void LibvlcMediaSetMeta(global::libvlcpp.LibvlcMediaT p_md, global::libvlcpp.LibvlcMetaT e_meta, string psz_value)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaSetMeta(__arg0, e_meta, psz_value);
        }

        /// <summary>Save the meta previously set</summary>
        /// <param name="p_md">the media desriptor</param>
        /// <returns>true if the write operation was successful</returns>
        public static int LibvlcMediaSaveMeta(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaSaveMeta(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Get current state of media descriptor object. Possible media states are</para>
        /// <para>libvlc_NothingSpecial=0, libvlc_Opening, libvlc_Playing, libvlc_Paused,</para>
        /// <para>libvlc_Stopped, libvlc_Ended, libvlc_Error.</para>
        /// </summary>
        /// <param name="p_md">a media descriptor object</param>
        /// <returns>state of media descriptor object</returns>
        /// <remarks>libvlc_state_t</remarks>
        public static global::libvlcpp.LibvlcStateT LibvlcMediaGetState(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaGetState(__arg0);
            return __ret;
        }

        /// <summary>Get the current statistics about the media</summary>
        /// <param name="p_md:">media descriptor object</param>
        /// <param name="p_stats:">
        /// <para>structure that contain the statistics about the media</para>
        /// <para>(this structure must be allocated by the caller)</para>
        /// </param>
        /// <returns>true if the statistics are available, false otherwise</returns>
        public static int LibvlcMediaGetStats(global::libvlcpp.LibvlcMediaT p_md, global::libvlcpp.LibvlcMediaStatsT p_stats)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __arg1 = ReferenceEquals(p_stats, null) ? global::System.IntPtr.Zero : p_stats.__Instance;
            var __ret = __Internal.LibvlcMediaGetStats(__arg0, __arg1);
            return __ret;
        }

        /// <summary>
        /// <para>Get subitems of media descriptor object. This will increment</para>
        /// <para>the reference count of supplied media descriptor object. Use</para>
        /// <para>libvlc_media_list_release() to decrement the reference counting.</para>
        /// </summary>
        /// <param name="p_md">media descriptor object</param>
        /// <returns>list of media descriptor subitems or NULL</returns>
        public static global::libvlcpp.LibvlcMediaListT LibvlcMediaSubitems(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaSubitems(__arg0);
            global::libvlcpp.LibvlcMediaListT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaListT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaListT) global::libvlcpp.LibvlcMediaListT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaListT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Get event manager from media descriptor object.</para>
        /// <para>NOTE: this function doesn't increment reference counting.</para>
        /// </summary>
        /// <param name="p_md">a media descriptor object</param>
        /// <returns>event manager object</returns>
        public static global::libvlcpp.LibvlcEventManagerT LibvlcMediaEventManager(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaEventManager(__arg0);
            global::libvlcpp.LibvlcEventManagerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEventManagerT) global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEventManagerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Get duration (in ms) of media descriptor object item.</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <returns>duration of media item or -1 on error</returns>
        public static long LibvlcMediaGetDuration(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaGetDuration(__arg0);
            return __ret;
        }

        /// <summary>Parse the media asynchronously with options.</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <param name="parse_flag">parse options:</param>
        /// <param name="timeout">
        /// <para>maximum time allowed to preparse the media. If -1, the</para>
        /// <para>default &quot;preparse-timeout&quot; option will be used as a timeout. If 0, it will</para>
        /// <para>wait indefinitely. If &gt; 0, the timeout will be used (in milliseconds).</para>
        /// </param>
        /// <returns>-1 in case of error, 0 otherwise</returns>
        /// <remarks>
        /// <para>This fetches (local or network) art, meta data and/or tracks information.</para>
        /// <para>This method is the extended version of libvlc_media_parse_with_options().</para>
        /// <para>To track when this is over you can listen to libvlc_MediaParsedChanged</para>
        /// <para>event. However if this functions returns an error, you will not receive any</para>
        /// <para>events.</para>
        /// <para>It uses a flag to specify parse options (see libvlc_media_parse_flag_t). All</para>
        /// <para>these flags can be combined. By default, media is parsed if it's a local</para>
        /// <para>file.</para>
        /// <para>Parsing can be aborted with libvlc_media_parse_stop().</para>
        /// <para>libvlc_MediaParsedChanged</para>
        /// <para>libvlc_media_get_meta</para>
        /// <para>libvlc_media_tracks_get</para>
        /// <para>libvlc_media_get_parsed_status</para>
        /// <para>libvlc_media_parse_flag_t</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static int LibvlcMediaParseWithOptions(global::libvlcpp.LibvlcMediaT p_md, global::libvlcpp.LibvlcMediaParseFlagT parse_flag, int timeout)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaParseWithOptions(__arg0, parse_flag, timeout);
            return __ret;
        }

        /// <summary>Stop the parsing of the media</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <remarks>
        /// <para>When the media parsing is stopped, the libvlc_MediaParsedChanged event will</para>
        /// <para>be sent with the libvlc_media_parsed_status_timeout status.</para>
        /// <para>libvlc_media_parse_with_options</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static void LibvlcMediaParseStop(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaParseStop(__arg0);
        }

        /// <summary>Get Parsed status for media descriptor object.</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <returns>a value of the libvlc_media_parsed_status_t enum</returns>
        /// <remarks>
        /// <para>libvlc_MediaParsedChanged</para>
        /// <para>libvlc_media_parsed_status_t</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcMediaParsedStatusT LibvlcMediaGetParsedStatus(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaGetParsedStatus(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Sets media descriptor's user_data. user_data is specialized data</para>
        /// <para>accessed by the host application, VLC.framework uses it as a pointer to</para>
        /// <para>an native object that references a libvlc_media_t pointer</para>
        /// </summary>
        /// <param name="p_md">media descriptor object</param>
        /// <param name="p_new_user_data">pointer to user data</param>
        public static void LibvlcMediaSetUserData(global::libvlcpp.LibvlcMediaT p_md, global::System.IntPtr p_new_user_data)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaSetUserData(__arg0, p_new_user_data);
        }

        /// <summary>
        /// <para>Get media descriptor's user_data. user_data is specialized data</para>
        /// <para>accessed by the host application, VLC.framework uses it as a pointer to</para>
        /// <para>an native object that references a libvlc_media_t pointer</para>
        /// </summary>
        /// <param name="p_md">media descriptor object</param>
        public static global::System.IntPtr LibvlcMediaGetUserData(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaGetUserData(__arg0);
            return __ret;
        }

        /// <summary>Get media descriptor's elementary streams description</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <param name="tracks">
        /// <para>address to store an allocated array of Elementary Streams</para>
        /// <para>descriptions (must be freed with libvlc_media_tracks_release</para>
        /// <para>by the caller) [OUT]</para>
        /// </param>
        /// <returns>the number of Elementary Streams (zero on error)</returns>
        /// <remarks>
        /// <para>Note, you need to call libvlc_media_parse() or play the media at least once</para>
        /// <para>before calling this function.</para>
        /// <para>Not doing this will result in an empty array.</para>
        /// <para>LibVLC 2.1.0 and later.</para>
        /// </remarks>
        public static uint LibvlcMediaTracksGet(global::libvlcpp.LibvlcMediaT p_md, global::libvlcpp.LibvlcMediaTrackT tracks)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __arg1 = ReferenceEquals(tracks, null) ? global::System.IntPtr.Zero : tracks.__Instance;
            var __ret = __Internal.LibvlcMediaTracksGet(__arg0, __arg1);
            return __ret;
        }

        /// <summary>Get codec description from media elementary stream</summary>
        /// <param name="i_type">i_type from libvlc_media_track_t</param>
        /// <param name="i_codec">i_codec or i_original_fourcc from libvlc_media_track_t</param>
        /// <returns>codec description</returns>
        /// <remarks>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// <para>libvlc_media_track_t</para>
        /// </remarks>
        public static string LibvlcMediaGetCodecDescription(global::libvlcpp.LibvlcTrackTypeT i_type, uint i_codec)
        {
            var __ret = __Internal.LibvlcMediaGetCodecDescription(i_type, i_codec);
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>Release media descriptor's elementary streams description array</summary>
        /// <param name="p_tracks">tracks info array to release</param>
        /// <param name="i_count">number of elements in the array</param>
        /// <remarks>LibVLC 2.1.0 and later.</remarks>
        public static void LibvlcMediaTracksRelease(global::libvlcpp.LibvlcMediaTrackT p_tracks, uint i_count)
        {
            var __arg0 = ReferenceEquals(p_tracks, null) ? global::System.IntPtr.Zero : p_tracks.__Instance;
            __Internal.LibvlcMediaTracksRelease(__arg0, i_count);
        }

        /// <summary>Get the media type of the media descriptor object</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <returns>media type</returns>
        /// <remarks>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// <para>libvlc_media_type_t</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcMediaTypeT LibvlcMediaGetType(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaGetType(__arg0);
            return __ret;
        }

        /// <summary>Add a slave to the current media.</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <param name="i_type">subtitle or audio</param>
        /// <param name="i_priority">from 0 (low priority) to 4 (high priority)</param>
        /// <param name="psz_uri">Uri of the slave (should contain a valid scheme).</param>
        /// <returns>0 on success, -1 on error.</returns>
        /// <remarks>
        /// <para>A slave is an external input source that may contains an additional subtitle</para>
        /// <para>track (like a .srt) or an additional audio track (like a .ac3).</para>
        /// <para>This function must be called before the media is parsed (via</para>
        /// <para>libvlc_media_parse_with_options()) or before the media is played (via</para>
        /// <para>libvlc_media_player_play())</para>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// </remarks>
        public static int LibvlcMediaSlavesAdd(global::libvlcpp.LibvlcMediaT p_md, global::libvlcpp.LibvlcMediaSlaveTypeT i_type, uint i_priority, string psz_uri)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaSlavesAdd(__arg0, i_type, i_priority, psz_uri);
            return __ret;
        }

        /// <summary>
        /// <para>Clear all slaves previously added by libvlc_media_slaves_add() or</para>
        /// <para>internally.</para>
        /// </summary>
        /// <param name="p_md">media descriptor object</param>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static void LibvlcMediaSlavesClear(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaSlavesClear(__arg0);
        }

        /// <summary>Get a media descriptor's slave list</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <param name="ppp_slaves">
        /// <para>address to store an allocated array of slaves (must be</para>
        /// <para>freed with libvlc_media_slaves_release()) [OUT]</para>
        /// </param>
        /// <returns>the number of slaves (zero on error)</returns>
        /// <remarks>
        /// <para>The list will contain slaves parsed by VLC or previously added by</para>
        /// <para>libvlc_media_slaves_add(). The typical use case of this function is to save</para>
        /// <para>a list of slave in a database for a later use.</para>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// <para>libvlc_media_slaves_add</para>
        /// </remarks>
        public static uint LibvlcMediaSlavesGet(global::libvlcpp.LibvlcMediaT p_md, global::libvlcpp.LibvlcMediaSlaveT ppp_slaves)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __arg1 = ReferenceEquals(ppp_slaves, null) ? global::System.IntPtr.Zero : ppp_slaves.__Instance;
            var __ret = __Internal.LibvlcMediaSlavesGet(__arg0, __arg1);
            return __ret;
        }

        /// <summary>Release a media descriptor's slave list</summary>
        /// <param name="pp_slaves">slave array to release</param>
        /// <param name="i_count">number of elements in the array</param>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static void LibvlcMediaSlavesRelease(global::libvlcpp.LibvlcMediaSlaveT pp_slaves, uint i_count)
        {
            var __arg0 = ReferenceEquals(pp_slaves, null) ? global::System.IntPtr.Zero : pp_slaves.__Instance;
            __Internal.LibvlcMediaSlavesRelease(__arg0, i_count);
        }
    }

    /// <summary>Description for titles</summary>
    public enum LibvlcTitle
    {
        LibvlcTitleMenu = 1,
        LibvlcTitleInteractive = 2
    }

    /// <summary>Marq options definition</summary>
    public enum LibvlcVideoMarqueeOptionT
    {
        LibvlcMarqueeEnable = 0,
        LibvlcMarqueeText = 1,
        /// <summary>string argument</summary>
        LibvlcMarqueeColor = 2,
        /// <summary>string argument</summary>
        LibvlcMarqueeOpacity = 3,
        /// <summary>string argument</summary>
        LibvlcMarqueePosition = 4,
        /// <summary>string argument</summary>
        LibvlcMarqueeRefresh = 5,
        /// <summary>string argument</summary>
        LibvlcMarqueeSize = 6,
        /// <summary>string argument</summary>
        LibvlcMarqueeTimeout = 7,
        /// <summary>string argument</summary>
        LibvlcMarqueeX = 8,
        /// <summary>string argument</summary>
        LibvlcMarqueeY = 9
    }

    /// <summary>Navigation mode</summary>
    public enum LibvlcNavigateModeT
    {
        LibvlcNavigateActivate = 0,
        LibvlcNavigateUp = 1,
        LibvlcNavigateDown = 2,
        LibvlcNavigateLeft = 3,
        LibvlcNavigateRight = 4,
        LibvlcNavigatePopup = 5
    }

    /// <summary>Enumeration of values used to set position (e.g. of video title).</summary>
    public enum LibvlcPositionT
    {
        LibvlcPositionDisable = -1,
        LibvlcPositionCenter = 0,
        LibvlcPositionLeft = 1,
        LibvlcPositionRight = 2,
        LibvlcPositionTop = 3,
        LibvlcPositionTopLeft = 4,
        LibvlcPositionTopRight = 5,
        LibvlcPositionBottom = 6,
        LibvlcPositionBottomLeft = 7,
        LibvlcPositionBottomRight = 8
    }

    /// <summary>
    /// <para>Enumeration of teletext keys than can be passed via</para>
    /// <para>libvlc_video_set_teletext()</para>
    /// </summary>
    public enum LibvlcTeletextKeyT
    {
        LibvlcTeletextKeyRed = 7471104,
        LibvlcTeletextKeyGreen = 6750208,
        LibvlcTeletextKeyYellow = 7929856,
        LibvlcTeletextKeyBlue = 6422528,
        LibvlcTeletextKeyIndex = 6881280
    }

    /// <summary>option values for libvlc_video_{get,set}_logo_{int,string}</summary>
    public enum LibvlcVideoLogoOptionT
    {
        LibvlcLogoEnable = 0,
        /// <summary>string argument, &quot;file,d,t;file,d,t;...&quot;</summary>
        LibvlcLogoFile = 1,
        LibvlcLogoX = 2,
        LibvlcLogoY = 3,
        LibvlcLogoDelay = 4,
        LibvlcLogoRepeat = 5,
        LibvlcLogoOpacity = 6,
        LibvlcLogoPosition = 7
    }

    /// <summary>option values for libvlc_video_{get,set}_adjust_{int,float,bool}</summary>
    public enum LibvlcVideoAdjustOptionT
    {
        LibvlcAdjustEnable = 0,
        LibvlcAdjustContrast = 1,
        LibvlcAdjustBrightness = 2,
        LibvlcAdjustHue = 3,
        LibvlcAdjustSaturation = 4,
        LibvlcAdjustGamma = 5
    }

    /// <summary>Audio device types</summary>
    public enum LibvlcAudioOutputDeviceTypesT
    {
        LibvlcAudioOutputDeviceError = -1,
        LibvlcAudioOutputDeviceMono = 1,
        LibvlcAudioOutputDeviceStereo = 2,
        LibvlcAudioOutputDevice2F2R = 4,
        LibvlcAudioOutputDevice3F2R = 5,
        LibvlcAudioOutputDevice5_1 = 6,
        LibvlcAudioOutputDevice6_1 = 7,
        LibvlcAudioOutputDevice7_1 = 8,
        LibvlcAudioOutputDeviceSPDIF = 10
    }

    /// <summary>Audio channels</summary>
    public enum LibvlcAudioOutputChannelT
    {
        LibvlcAudioChannelError = -1,
        LibvlcAudioChannelStereo = 1,
        LibvlcAudioChannelRStereo = 2,
        LibvlcAudioChannelLeft = 3,
        LibvlcAudioChannelRight = 4,
        LibvlcAudioChannelDolbys = 5
    }

    /// <summary>Media player roles.</summary>
    /// <remarks>
    /// <para>LibVLC 3.0.0 and later.</para>
    /// <para>See</para>
    /// </remarks>
    public enum LibvlcMediaPlayerRole
    {
        /// <summary>Don't use a media player role</summary>
        LibvlcRoleNone = 0,
        /// <summary>Music (or radio) playback</summary>
        LibvlcRoleMusic = 1,
        /// <summary>Video playback</summary>
        LibvlcRoleVideo = 2,
        /// <summary>Speech, real-time communication</summary>
        LibvlcRoleCommunication = 3,
        /// <summary>Video game</summary>
        LibvlcRoleGame = 4,
        /// <summary>User interaction feedback</summary>
        LiblvcRoleNotification = 5,
        /// <summary>Embedded animation (e.g. in web page)</summary>
        LibvlcRoleAnimation = 6,
        /// <summary>Audio editting/production</summary>
        LibvlcRoleProduction = 7,
        /// <summary>Accessibility</summary>
        LibvlcRoleAccessibility = 8,
        LibvlcRoleTest = 9
    }

    /// <summary>
    /// <para>A LibVLC media player plays one media (usually in a custom drawable).</para>
    /// <para>@{</para>
    /// <para></para>
    /// <para>LibVLC simple media player external API</para>
    /// </summary>
    /// <summary>Opaque equalizer handle.</summary>
    /// <remarks>Equalizer settings can be applied to a media player.</remarks>
    /// <summary>Callback prototype to allocate and lock a picture buffer.</summary>
    /// <param name="opaque">private pointer as passed to libvlc_video_set_callbacks() [IN]</param>
    /// <param name="planes">
    /// <para>start address of the pixel planes (LibVLC allocates the array</para>
    /// <para>of void pointers, this callback must initialize the array) [OUT]</para>
    /// </param>
    /// <returns>
    /// <para>a private pointer for the display and unlock callbacks to identify</para>
    /// <para>the picture buffers</para>
    /// </returns>
    /// <remarks>
    /// <para>Whenever a new video frame needs to be decoded, the lock callback is</para>
    /// <para>invoked. Depending on the video chroma, one or three pixel planes of</para>
    /// <para>adequate dimensions must be returned via the second parameter. Those</para>
    /// <para>planes must be aligned on 32-bytes boundaries.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate global::System.IntPtr LibvlcVideoLockCb(global::System.IntPtr opaque, void** planes);

    /// <summary>Callback prototype to unlock a picture buffer.</summary>
    /// <param name="opaque">private pointer as passed to libvlc_video_set_callbacks() [IN]</param>
    /// <param name="picture">private pointer returned from the</param>
    /// <param name="planes">pixel planes as defined by the</param>
    /// <remarks>
    /// <para>When the video frame decoding is complete, the unlock callback is invoked.</para>
    /// <para>This callback might not be needed at all. It is only an indication that the</para>
    /// <para>application can now read the pixel values if it needs to.</para>
    /// <para>A picture buffer is unlocked after the picture is decoded,</para>
    /// <para>but before the picture is displayed.</para>
    /// <para>callback [IN]</para>
    /// <para>callback (this parameter is only for convenience) [IN]</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcVideoUnlockCb(global::System.IntPtr opaque, global::System.IntPtr picture, void** planes);

    /// <summary>Callback prototype to display a picture.</summary>
    /// <param name="opaque">private pointer as passed to libvlc_video_set_callbacks() [IN]</param>
    /// <param name="picture">private pointer returned from the</param>
    /// <remarks>
    /// <para>When the video frame needs to be shown, as determined by the media playback</para>
    /// <para>clock, the display callback is invoked.</para>
    /// <para>callback [IN]</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcVideoDisplayCb(global::System.IntPtr opaque, global::System.IntPtr picture);

    /// <summary>
    /// <para>Callback prototype to configure picture buffers format.</para>
    /// <para>This callback gets the format of the video as output by the video decoder</para>
    /// <para>and the chain of video filters (if any). It can opt to change any parameter</para>
    /// <para>as it needs. In that case, LibVLC will attempt to convert the video format</para>
    /// <para>(rescaling and chroma conversion) but these operations can be CPU intensive.</para>
    /// </summary>
    /// <param name="opaque">
    /// <para>pointer to the private pointer passed to</para>
    /// <para>libvlc_video_set_callbacks() [IN/OUT]</para>
    /// </param>
    /// <param name="chroma">pointer to the 4 bytes video format identifier [IN/OUT]</param>
    /// <param name="width">pointer to the pixel width [IN/OUT]</param>
    /// <param name="height">pointer to the pixel height [IN/OUT]</param>
    /// <param name="pitches">
    /// <para>table of scanline pitches in bytes for each pixel plane</para>
    /// <para>(the table is allocated by LibVLC) [OUT]</para>
    /// </param>
    /// <param name="lines">table of scanlines count for each plane [OUT]</param>
    /// <returns>the number of picture buffers allocated, 0 indicates failure</returns>
    /// <remarks>
    /// <para>For each pixels plane, the scanline pitch must be bigger than or equal to</para>
    /// <para>the number of bytes per pixel multiplied by the pixel width.</para>
    /// <para>Similarly, the number of scanlines must be bigger than of equal to</para>
    /// <para>the pixel height.</para>
    /// <para>Furthermore, we recommend that pitches and lines be multiple of 32</para>
    /// <para>to not break assumptions that might be held by optimized code</para>
    /// <para>in the video decoders, video filters and/or video converters.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate uint LibvlcVideoFormatCb(void** opaque, sbyte* chroma, uint* width, uint* height, uint* pitches, uint* lines);

    /// <summary>Callback prototype to configure picture buffers format.</summary>
    /// <param name="opaque">
    /// <para>private pointer as passed to libvlc_video_set_callbacks()</para>
    /// <para>(and possibly modified by</para>
    /// </param>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcVideoCleanupCb(global::System.IntPtr opaque);

    /// <summary>Callback prototype for audio playback.</summary>
    /// <param name="data">data pointer as passed to libvlc_audio_set_callbacks() [IN]</param>
    /// <param name="samples">pointer to a table of audio samples to play back [IN]</param>
    /// <param name="count">number of audio samples to play back</param>
    /// <param name="pts">expected play time stamp (see libvlc_delay())</param>
    /// <remarks>
    /// <para>The LibVLC media player decodes and post-processes the audio signal</para>
    /// <para>asynchronously (in an internal thread). Whenever audio samples are ready</para>
    /// <para>to be queued to the output, this callback is invoked.</para>
    /// <para>The number of samples provided per invocation may depend on the file format,</para>
    /// <para>the audio coding algorithm, the decoder plug-in, the post-processing</para>
    /// <para>filters and timing. Application must not assume a certain number of samples.</para>
    /// <para>The exact format of audio samples is determined by libvlc_audio_set_format()</para>
    /// <para>or libvlc_audio_set_format_callbacks() as is the channels layout.</para>
    /// <para>Note that the number of samples is per channel. For instance, if the audio</para>
    /// <para>track sampling rate is 48000 Hz, then 1200 samples represent 25 milliseconds</para>
    /// <para>of audio signal - regardless of the number of audio channels.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcAudioPlayCb(global::System.IntPtr data, global::System.IntPtr samples, uint count, long pts);

    /// <summary>Callback prototype for audio pause.</summary>
    /// <param name="data">data pointer as passed to libvlc_audio_set_callbacks() [IN]</param>
    /// <param name="pts">time stamp of the pause request (should be elapsed already)</param>
    /// <remarks>
    /// <para>LibVLC invokes this callback to pause audio playback.</para>
    /// <para>The pause callback is never called if the audio is already paused.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcAudioPauseCb(global::System.IntPtr data, long pts);

    /// <summary>Callback prototype for audio resumption.</summary>
    /// <param name="data">data pointer as passed to libvlc_audio_set_callbacks() [IN]</param>
    /// <param name="pts">time stamp of the resumption request (should be elapsed already)</param>
    /// <remarks>
    /// <para>LibVLC invokes this callback to resume audio playback after it was</para>
    /// <para>previously paused.</para>
    /// <para>The resume callback is never called if the audio is not paused.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcAudioResumeCb(global::System.IntPtr data, long pts);

    /// <summary>Callback prototype for audio buffer flush.</summary>
    /// <param name="data">data pointer as passed to libvlc_audio_set_callbacks() [IN]</param>
    /// <remarks>
    /// <para>LibVLC invokes this callback if it needs to discard all pending buffers and</para>
    /// <para>stop playback as soon as possible. This typically occurs when the media is</para>
    /// <para>stopped.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcAudioFlushCb(global::System.IntPtr data, long pts);

    /// <summary>Callback prototype for audio buffer drain.</summary>
    /// <param name="data">data pointer as passed to libvlc_audio_set_callbacks() [IN]</param>
    /// <remarks>
    /// <para>LibVLC may invoke this callback when the decoded audio track is ending.</para>
    /// <para>There will be no further decoded samples for the track, but playback should</para>
    /// <para>nevertheless continue until all already pending buffers are rendered.</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcAudioDrainCb(global::System.IntPtr data);

    /// <summary>Callback prototype for audio volume change.</summary>
    /// <param name="data">data pointer as passed to libvlc_audio_set_callbacks() [IN]</param>
    /// <param name="volume">software volume (1. = nominal, 0. = mute)</param>
    /// <param name="mute">muted flag</param>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcAudioSetVolumeCb(global::System.IntPtr data, float volume, [MarshalAs(UnmanagedType.I1)] bool mute);

    /// <summary>Callback prototype to setup the audio playback.</summary>
    /// <param name="opaque">
    /// <para>pointer to the data pointer passed to</para>
    /// <para>libvlc_audio_set_callbacks() [IN/OUT]</para>
    /// </param>
    /// <param name="format">4 bytes sample format [IN/OUT]</param>
    /// <param name="rate">sample rate [IN/OUT]</param>
    /// <param name="channels">channels count [IN/OUT]</param>
    /// <returns>0 on success, anything else to skip audio playback</returns>
    /// <remarks>This is called when the media player needs to create a new audio output.</remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate int LibvlcAudioSetupCb(void** data, sbyte* format, uint* rate, uint* channels);

    /// <summary>Callback prototype for audio playback cleanup.</summary>
    /// <param name="opaque">data pointer as passed to libvlc_audio_set_callbacks() [IN]</param>
    /// <remarks>This is called when the media player no longer needs an audio output.</remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void LibvlcAudioCleanupCb(global::System.IntPtr data);

    public unsafe partial class LibvlcMediaPlayerT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaPlayerT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaPlayerT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaPlayerT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaPlayerT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaPlayerT __CreateInstance(global::libvlcpp.LibvlcMediaPlayerT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaPlayerT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaPlayerT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaPlayerT.__Internal));
            *(global::libvlcpp.LibvlcMediaPlayerT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaPlayerT(global::libvlcpp.LibvlcMediaPlayerT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaPlayerT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class LibvlcEqualizerT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcEqualizerT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcEqualizerT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcEqualizerT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcEqualizerT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcEqualizerT __CreateInstance(global::libvlcpp.LibvlcEqualizerT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcEqualizerT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcEqualizerT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcEqualizerT.__Internal));
            *(global::libvlcpp.LibvlcEqualizerT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcEqualizerT(global::libvlcpp.LibvlcEqualizerT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcEqualizerT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    /// <summary>
    /// <para>Description for video, audio tracks and subtitles. It contains</para>
    /// <para>id, name (description string) and pointer to next record.</para>
    /// </summary>
    public unsafe partial class LibvlcTrackDescriptionT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 24)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int i_id;

            [FieldOffset(8)]
            internal global::System.IntPtr psz_name;

            [FieldOffset(16)]
            internal global::System.IntPtr p_next;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_track_description_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcTrackDescriptionT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcTrackDescriptionT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcTrackDescriptionT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcTrackDescriptionT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcTrackDescriptionT __CreateInstance(global::libvlcpp.LibvlcTrackDescriptionT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcTrackDescriptionT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcTrackDescriptionT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcTrackDescriptionT.__Internal));
            *(global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcTrackDescriptionT(global::libvlcpp.LibvlcTrackDescriptionT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcTrackDescriptionT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcTrackDescriptionT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcTrackDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcTrackDescriptionT(global::libvlcpp.LibvlcTrackDescriptionT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcTrackDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcTrackDescriptionT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int IId
        {
            get
            {
                return ((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->i_id;
            }

            set
            {
                ((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->i_id = value;
            }
        }

        public sbyte* PszName
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->psz_name;
            }

            set
            {
                ((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->psz_name = (global::System.IntPtr) value;
            }
        }

        public global::libvlcpp.LibvlcTrackDescriptionT PNext
        {
            get
            {
                global::libvlcpp.LibvlcTrackDescriptionT __result0;
                if (((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->p_next == IntPtr.Zero) __result0 = null;
                else if (global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap.ContainsKey(((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->p_next))
                    __result0 = (global::libvlcpp.LibvlcTrackDescriptionT) global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap[((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->p_next];
                else __result0 = global::libvlcpp.LibvlcTrackDescriptionT.__CreateInstance(((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->p_next);
                return __result0;
            }

            set
            {
                ((global::libvlcpp.LibvlcTrackDescriptionT.__Internal*) __Instance)->p_next = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }
    }

    public unsafe partial class LibvlcTitleDescriptionT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 24)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal long i_duration;

            [FieldOffset(8)]
            internal global::System.IntPtr psz_name;

            [FieldOffset(16)]
            internal uint i_flags;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_title_description_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcTitleDescriptionT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcTitleDescriptionT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcTitleDescriptionT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcTitleDescriptionT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcTitleDescriptionT __CreateInstance(global::libvlcpp.LibvlcTitleDescriptionT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcTitleDescriptionT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcTitleDescriptionT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcTitleDescriptionT.__Internal));
            *(global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcTitleDescriptionT(global::libvlcpp.LibvlcTitleDescriptionT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcTitleDescriptionT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcTitleDescriptionT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcTitleDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcTitleDescriptionT(global::libvlcpp.LibvlcTitleDescriptionT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcTitleDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcTitleDescriptionT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public long IDuration
        {
            get
            {
                return ((global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) __Instance)->i_duration;
            }

            set
            {
                ((global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) __Instance)->i_duration = value;
            }
        }

        public sbyte* PszName
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) __Instance)->psz_name;
            }

            set
            {
                ((global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) __Instance)->psz_name = (global::System.IntPtr) value;
            }
        }

        public uint IFlags
        {
            get
            {
                return ((global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) __Instance)->i_flags;
            }

            set
            {
                ((global::libvlcpp.LibvlcTitleDescriptionT.__Internal*) __Instance)->i_flags = value;
            }
        }
    }

    /// <summary>Description for chapters</summary>
    public unsafe partial class LibvlcChapterDescriptionT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 24)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal long i_time_offset;

            [FieldOffset(8)]
            internal long i_duration;

            [FieldOffset(16)]
            internal global::System.IntPtr psz_name;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_chapter_description_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcChapterDescriptionT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcChapterDescriptionT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcChapterDescriptionT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcChapterDescriptionT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcChapterDescriptionT __CreateInstance(global::libvlcpp.LibvlcChapterDescriptionT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcChapterDescriptionT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcChapterDescriptionT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcChapterDescriptionT.__Internal));
            *(global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcChapterDescriptionT(global::libvlcpp.LibvlcChapterDescriptionT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcChapterDescriptionT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcChapterDescriptionT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcChapterDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcChapterDescriptionT(global::libvlcpp.LibvlcChapterDescriptionT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcChapterDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcChapterDescriptionT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public long ITimeOffset
        {
            get
            {
                return ((global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) __Instance)->i_time_offset;
            }

            set
            {
                ((global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) __Instance)->i_time_offset = value;
            }
        }

        public long IDuration
        {
            get
            {
                return ((global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) __Instance)->i_duration;
            }

            set
            {
                ((global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) __Instance)->i_duration = value;
            }
        }

        public sbyte* PszName
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) __Instance)->psz_name;
            }

            set
            {
                ((global::libvlcpp.LibvlcChapterDescriptionT.__Internal*) __Instance)->psz_name = (global::System.IntPtr) value;
            }
        }
    }

    /// <summary>
    /// <para>Description for audio output. It contains</para>
    /// <para>name, description and pointer to next record.</para>
    /// </summary>
    public unsafe partial class LibvlcAudioOutputT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 24)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr psz_name;

            [FieldOffset(8)]
            internal global::System.IntPtr psz_description;

            [FieldOffset(16)]
            internal global::System.IntPtr p_next;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_audio_output_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcAudioOutputT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcAudioOutputT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcAudioOutputT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcAudioOutputT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcAudioOutputT __CreateInstance(global::libvlcpp.LibvlcAudioOutputT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcAudioOutputT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcAudioOutputT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioOutputT.__Internal));
            *(global::libvlcpp.LibvlcAudioOutputT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcAudioOutputT(global::libvlcpp.LibvlcAudioOutputT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcAudioOutputT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcAudioOutputT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioOutputT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcAudioOutputT(global::libvlcpp.LibvlcAudioOutputT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioOutputT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcAudioOutputT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcAudioOutputT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public sbyte* PszName
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->psz_name;
            }

            set
            {
                ((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->psz_name = (global::System.IntPtr) value;
            }
        }

        public sbyte* PszDescription
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->psz_description;
            }

            set
            {
                ((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->psz_description = (global::System.IntPtr) value;
            }
        }

        public global::libvlcpp.LibvlcAudioOutputT PNext
        {
            get
            {
                global::libvlcpp.LibvlcAudioOutputT __result0;
                if (((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->p_next == IntPtr.Zero) __result0 = null;
                else if (global::libvlcpp.LibvlcAudioOutputT.NativeToManagedMap.ContainsKey(((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->p_next))
                    __result0 = (global::libvlcpp.LibvlcAudioOutputT) global::libvlcpp.LibvlcAudioOutputT.NativeToManagedMap[((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->p_next];
                else __result0 = global::libvlcpp.LibvlcAudioOutputT.__CreateInstance(((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->p_next);
                return __result0;
            }

            set
            {
                ((global::libvlcpp.LibvlcAudioOutputT.__Internal*) __Instance)->p_next = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }
    }

    /// <summary>Description for audio output device.</summary>
    public unsafe partial class LibvlcAudioOutputDeviceT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 24)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr p_next;

            [FieldOffset(8)]
            internal global::System.IntPtr psz_device;

            [FieldOffset(16)]
            internal global::System.IntPtr psz_description;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_audio_output_device_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcAudioOutputDeviceT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcAudioOutputDeviceT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcAudioOutputDeviceT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcAudioOutputDeviceT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcAudioOutputDeviceT __CreateInstance(global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcAudioOutputDeviceT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal));
            *(global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcAudioOutputDeviceT(global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcAudioOutputDeviceT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcAudioOutputDeviceT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcAudioOutputDeviceT(global::libvlcpp.LibvlcAudioOutputDeviceT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcAudioOutputDeviceT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public global::libvlcpp.LibvlcAudioOutputDeviceT PNext
        {
            get
            {
                global::libvlcpp.LibvlcAudioOutputDeviceT __result0;
                if (((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->p_next == IntPtr.Zero) __result0 = null;
                else if (global::libvlcpp.LibvlcAudioOutputDeviceT.NativeToManagedMap.ContainsKey(((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->p_next))
                    __result0 = (global::libvlcpp.LibvlcAudioOutputDeviceT) global::libvlcpp.LibvlcAudioOutputDeviceT.NativeToManagedMap[((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->p_next];
                else __result0 = global::libvlcpp.LibvlcAudioOutputDeviceT.__CreateInstance(((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->p_next);
                return __result0;
            }

            set
            {
                ((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->p_next = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }

        public sbyte* PszDevice
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->psz_device;
            }

            set
            {
                ((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->psz_device = (global::System.IntPtr) value;
            }
        }

        public sbyte* PszDescription
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->psz_description;
            }

            set
            {
                ((global::libvlcpp.LibvlcAudioOutputDeviceT.__Internal*) __Instance)->psz_description = (global::System.IntPtr) value;
            }
        }
    }

    public unsafe partial class libvlc_media_player
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_new")]
            internal static extern global::System.IntPtr LibvlcMediaPlayerNew(global::System.IntPtr p_libvlc_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_new_from_media")]
            internal static extern global::System.IntPtr LibvlcMediaPlayerNewFromMedia(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_release")]
            internal static extern void LibvlcMediaPlayerRelease(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_retain")]
            internal static extern void LibvlcMediaPlayerRetain(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_media")]
            internal static extern void LibvlcMediaPlayerSetMedia(global::System.IntPtr p_mi, global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_media")]
            internal static extern global::System.IntPtr LibvlcMediaPlayerGetMedia(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_event_manager")]
            internal static extern global::System.IntPtr LibvlcMediaPlayerEventManager(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_is_playing")]
            internal static extern int LibvlcMediaPlayerIsPlaying(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_play")]
            internal static extern int LibvlcMediaPlayerPlay(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_pause")]
            internal static extern void LibvlcMediaPlayerSetPause(global::System.IntPtr mp, int do_pause);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_pause")]
            internal static extern void LibvlcMediaPlayerPause(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_stop")]
            internal static extern void LibvlcMediaPlayerStop(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_renderer")]
            internal static extern int LibvlcMediaPlayerSetRenderer(global::System.IntPtr p_mi, global::System.IntPtr p_item);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_callbacks")]
            internal static extern void LibvlcVideoSetCallbacks(global::System.IntPtr mp, global::System.IntPtr @lock, global::System.IntPtr unlock, global::System.IntPtr display, global::System.IntPtr opaque);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_format")]
            internal static extern void LibvlcVideoSetFormat(global::System.IntPtr mp, [MarshalAs(UnmanagedType.LPStr)] string chroma, uint width, uint height, uint pitch);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_format_callbacks")]
            internal static extern void LibvlcVideoSetFormatCallbacks(global::System.IntPtr mp, global::System.IntPtr setup, global::System.IntPtr cleanup);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_nsobject")]
            internal static extern void LibvlcMediaPlayerSetNsobject(global::System.IntPtr p_mi, global::System.IntPtr drawable);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_nsobject")]
            internal static extern global::System.IntPtr LibvlcMediaPlayerGetNsobject(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_xwindow")]
            internal static extern void LibvlcMediaPlayerSetXwindow(global::System.IntPtr p_mi, uint drawable);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_xwindow")]
            internal static extern uint LibvlcMediaPlayerGetXwindow(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_hwnd")]
            internal static extern void LibvlcMediaPlayerSetHwnd(global::System.IntPtr p_mi, global::System.IntPtr drawable);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_hwnd")]
            internal static extern global::System.IntPtr LibvlcMediaPlayerGetHwnd(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_android_context")]
            internal static extern void LibvlcMediaPlayerSetAndroidContext(global::System.IntPtr p_mi, global::System.IntPtr p_awindow_handler);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_evas_object")]
            internal static extern int LibvlcMediaPlayerSetEvasObject(global::System.IntPtr p_mi, global::System.IntPtr p_evas_object);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_callbacks")]
            internal static extern void LibvlcAudioSetCallbacks(global::System.IntPtr mp, global::System.IntPtr play, global::System.IntPtr pause, global::System.IntPtr resume, global::System.IntPtr flush, global::System.IntPtr drain, global::System.IntPtr opaque);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_volume_callback")]
            internal static extern void LibvlcAudioSetVolumeCallback(global::System.IntPtr mp, global::System.IntPtr set_volume);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_format_callbacks")]
            internal static extern void LibvlcAudioSetFormatCallbacks(global::System.IntPtr mp, global::System.IntPtr setup, global::System.IntPtr cleanup);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_format")]
            internal static extern void LibvlcAudioSetFormat(global::System.IntPtr mp, [MarshalAs(UnmanagedType.LPStr)] string format, uint rate, uint channels);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_length")]
            internal static extern long LibvlcMediaPlayerGetLength(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_time")]
            internal static extern long LibvlcMediaPlayerGetTime(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_time")]
            internal static extern void LibvlcMediaPlayerSetTime(global::System.IntPtr p_mi, long i_time);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_position")]
            internal static extern float LibvlcMediaPlayerGetPosition(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_position")]
            internal static extern void LibvlcMediaPlayerSetPosition(global::System.IntPtr p_mi, float f_pos);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_chapter")]
            internal static extern void LibvlcMediaPlayerSetChapter(global::System.IntPtr p_mi, int i_chapter);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_chapter")]
            internal static extern int LibvlcMediaPlayerGetChapter(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_chapter_count")]
            internal static extern int LibvlcMediaPlayerGetChapterCount(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_will_play")]
            internal static extern int LibvlcMediaPlayerWillPlay(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_chapter_count_for_title")]
            internal static extern int LibvlcMediaPlayerGetChapterCountForTitle(global::System.IntPtr p_mi, int i_title);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_title")]
            internal static extern void LibvlcMediaPlayerSetTitle(global::System.IntPtr p_mi, int i_title);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_title")]
            internal static extern int LibvlcMediaPlayerGetTitle(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_title_count")]
            internal static extern int LibvlcMediaPlayerGetTitleCount(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_previous_chapter")]
            internal static extern void LibvlcMediaPlayerPreviousChapter(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_next_chapter")]
            internal static extern void LibvlcMediaPlayerNextChapter(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_rate")]
            internal static extern float LibvlcMediaPlayerGetRate(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_rate")]
            internal static extern int LibvlcMediaPlayerSetRate(global::System.IntPtr p_mi, float rate);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_state")]
            internal static extern global::libvlcpp.LibvlcStateT LibvlcMediaPlayerGetState(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_has_vout")]
            internal static extern uint LibvlcMediaPlayerHasVout(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_is_seekable")]
            internal static extern int LibvlcMediaPlayerIsSeekable(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_can_pause")]
            internal static extern int LibvlcMediaPlayerCanPause(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_program_scrambled")]
            internal static extern int LibvlcMediaPlayerProgramScrambled(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_next_frame")]
            internal static extern void LibvlcMediaPlayerNextFrame(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_navigate")]
            internal static extern void LibvlcMediaPlayerNavigate(global::System.IntPtr p_mi, uint navigate);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_video_title_display")]
            internal static extern void LibvlcMediaPlayerSetVideoTitleDisplay(global::System.IntPtr p_mi, global::libvlcpp.LibvlcPositionT position, uint timeout);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_add_slave")]
            internal static extern int LibvlcMediaPlayerAddSlave(global::System.IntPtr p_mi, global::libvlcpp.LibvlcMediaSlaveTypeT i_type, [MarshalAs(UnmanagedType.LPStr)] string psz_uri, bool b_select);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_track_description_list_release")]
            internal static extern void LibvlcTrackDescriptionListRelease(global::System.IntPtr p_track_description);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_toggle_fullscreen")]
            internal static extern void LibvlcToggleFullscreen(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_set_fullscreen")]
            internal static extern void LibvlcSetFullscreen(global::System.IntPtr p_mi, int b_fullscreen);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_get_fullscreen")]
            internal static extern int LibvlcGetFullscreen(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_key_input")]
            internal static extern void LibvlcVideoSetKeyInput(global::System.IntPtr p_mi, uint on);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_mouse_input")]
            internal static extern void LibvlcVideoSetMouseInput(global::System.IntPtr p_mi, uint on);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_size")]
            internal static extern int LibvlcVideoGetSize(global::System.IntPtr p_mi, uint num, uint* px, uint* py);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_cursor")]
            internal static extern int LibvlcVideoGetCursor(global::System.IntPtr p_mi, uint num, int* px, int* py);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_scale")]
            internal static extern float LibvlcVideoGetScale(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_scale")]
            internal static extern void LibvlcVideoSetScale(global::System.IntPtr p_mi, float f_factor);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_aspect_ratio")]
            internal static extern sbyte* LibvlcVideoGetAspectRatio(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_aspect_ratio")]
            internal static extern void LibvlcVideoSetAspectRatio(global::System.IntPtr p_mi, [MarshalAs(UnmanagedType.LPStr)] string psz_aspect);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_new_viewpoint")]
            internal static extern global::System.IntPtr LibvlcVideoNewViewpoint();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_update_viewpoint")]
            internal static extern int LibvlcVideoUpdateViewpoint(global::System.IntPtr p_mi, global::System.IntPtr p_viewpoint, bool b_absolute);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_spu")]
            internal static extern int LibvlcVideoGetSpu(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_spu_count")]
            internal static extern int LibvlcVideoGetSpuCount(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_spu_description")]
            internal static extern global::System.IntPtr LibvlcVideoGetSpuDescription(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_spu")]
            internal static extern int LibvlcVideoSetSpu(global::System.IntPtr p_mi, int i_spu);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_spu_delay")]
            internal static extern long LibvlcVideoGetSpuDelay(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_spu_delay")]
            internal static extern int LibvlcVideoSetSpuDelay(global::System.IntPtr p_mi, long i_delay);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_full_title_descriptions")]
            internal static extern int LibvlcMediaPlayerGetFullTitleDescriptions(global::System.IntPtr p_mi, global::System.IntPtr titles);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_title_descriptions_release")]
            internal static extern void LibvlcTitleDescriptionsRelease(global::System.IntPtr p_titles, uint i_count);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_full_chapter_descriptions")]
            internal static extern int LibvlcMediaPlayerGetFullChapterDescriptions(global::System.IntPtr p_mi, int i_chapters_of_title, global::System.IntPtr pp_chapters);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_chapter_descriptions_release")]
            internal static extern void LibvlcChapterDescriptionsRelease(global::System.IntPtr p_chapters, uint i_count);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_crop_geometry")]
            internal static extern sbyte* LibvlcVideoGetCropGeometry(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_crop_geometry")]
            internal static extern void LibvlcVideoSetCropGeometry(global::System.IntPtr p_mi, [MarshalAs(UnmanagedType.LPStr)] string psz_geometry);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_teletext")]
            internal static extern int LibvlcVideoGetTeletext(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_teletext")]
            internal static extern void LibvlcVideoSetTeletext(global::System.IntPtr p_mi, int i_page);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_track_count")]
            internal static extern int LibvlcVideoGetTrackCount(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_track_description")]
            internal static extern global::System.IntPtr LibvlcVideoGetTrackDescription(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_track")]
            internal static extern int LibvlcVideoGetTrack(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_track")]
            internal static extern int LibvlcVideoSetTrack(global::System.IntPtr p_mi, int i_track);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_take_snapshot")]
            internal static extern int LibvlcVideoTakeSnapshot(global::System.IntPtr p_mi, uint num, [MarshalAs(UnmanagedType.LPStr)] string psz_filepath, uint i_width, uint i_height);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_deinterlace")]
            internal static extern void LibvlcVideoSetDeinterlace(global::System.IntPtr p_mi, [MarshalAs(UnmanagedType.LPStr)] string psz_mode);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_marquee_int")]
            internal static extern int LibvlcVideoGetMarqueeInt(global::System.IntPtr p_mi, uint option);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_marquee_string")]
            internal static extern sbyte* LibvlcVideoGetMarqueeString(global::System.IntPtr p_mi, uint option);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_marquee_int")]
            internal static extern void LibvlcVideoSetMarqueeInt(global::System.IntPtr p_mi, uint option, int i_val);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_marquee_string")]
            internal static extern void LibvlcVideoSetMarqueeString(global::System.IntPtr p_mi, uint option, [MarshalAs(UnmanagedType.LPStr)] string psz_text);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_logo_int")]
            internal static extern int LibvlcVideoGetLogoInt(global::System.IntPtr p_mi, uint option);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_logo_int")]
            internal static extern void LibvlcVideoSetLogoInt(global::System.IntPtr p_mi, uint option, int value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_logo_string")]
            internal static extern void LibvlcVideoSetLogoString(global::System.IntPtr p_mi, uint option, [MarshalAs(UnmanagedType.LPStr)] string psz_value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_adjust_int")]
            internal static extern int LibvlcVideoGetAdjustInt(global::System.IntPtr p_mi, uint option);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_adjust_int")]
            internal static extern void LibvlcVideoSetAdjustInt(global::System.IntPtr p_mi, uint option, int value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_adjust_float")]
            internal static extern float LibvlcVideoGetAdjustFloat(global::System.IntPtr p_mi, uint option);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_adjust_float")]
            internal static extern void LibvlcVideoSetAdjustFloat(global::System.IntPtr p_mi, uint option, float value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_list_get")]
            internal static extern global::System.IntPtr LibvlcAudioOutputListGet(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_list_release")]
            internal static extern void LibvlcAudioOutputListRelease(global::System.IntPtr p_list);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_set")]
            internal static extern int LibvlcAudioOutputSet(global::System.IntPtr p_mi, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_device_enum")]
            internal static extern global::System.IntPtr LibvlcAudioOutputDeviceEnum(global::System.IntPtr mp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_device_list_get")]
            internal static extern global::System.IntPtr LibvlcAudioOutputDeviceListGet(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string aout);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_device_list_release")]
            internal static extern void LibvlcAudioOutputDeviceListRelease(global::System.IntPtr p_list);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_device_set")]
            internal static extern void LibvlcAudioOutputDeviceSet(global::System.IntPtr mp, [MarshalAs(UnmanagedType.LPStr)] string module, [MarshalAs(UnmanagedType.LPStr)] string device_id);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_device_get")]
            internal static extern sbyte* LibvlcAudioOutputDeviceGet(global::System.IntPtr mp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_toggle_mute")]
            internal static extern void LibvlcAudioToggleMute(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_get_mute")]
            internal static extern int LibvlcAudioGetMute(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_mute")]
            internal static extern void LibvlcAudioSetMute(global::System.IntPtr p_mi, int status);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_get_volume")]
            internal static extern int LibvlcAudioGetVolume(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_volume")]
            internal static extern int LibvlcAudioSetVolume(global::System.IntPtr p_mi, int i_volume);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_get_track_count")]
            internal static extern int LibvlcAudioGetTrackCount(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_get_track_description")]
            internal static extern global::System.IntPtr LibvlcAudioGetTrackDescription(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_get_track")]
            internal static extern int LibvlcAudioGetTrack(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_track")]
            internal static extern int LibvlcAudioSetTrack(global::System.IntPtr p_mi, int i_track);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_get_channel")]
            internal static extern int LibvlcAudioGetChannel(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_channel")]
            internal static extern int LibvlcAudioSetChannel(global::System.IntPtr p_mi, int channel);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_get_delay")]
            internal static extern long LibvlcAudioGetDelay(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_set_delay")]
            internal static extern int LibvlcAudioSetDelay(global::System.IntPtr p_mi, long i_delay);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_get_preset_count")]
            internal static extern uint LibvlcAudioEqualizerGetPresetCount();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_get_preset_name")]
            internal static extern global::System.IntPtr LibvlcAudioEqualizerGetPresetName(uint u_index);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_get_band_count")]
            internal static extern uint LibvlcAudioEqualizerGetBandCount();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_get_band_frequency")]
            internal static extern float LibvlcAudioEqualizerGetBandFrequency(uint u_index);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_new")]
            internal static extern global::System.IntPtr LibvlcAudioEqualizerNew();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_new_from_preset")]
            internal static extern global::System.IntPtr LibvlcAudioEqualizerNewFromPreset(uint u_index);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_release")]
            internal static extern void LibvlcAudioEqualizerRelease(global::System.IntPtr p_equalizer);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_set_preamp")]
            internal static extern int LibvlcAudioEqualizerSetPreamp(global::System.IntPtr p_equalizer, float f_preamp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_get_preamp")]
            internal static extern float LibvlcAudioEqualizerGetPreamp(global::System.IntPtr p_equalizer);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_set_amp_at_index")]
            internal static extern int LibvlcAudioEqualizerSetAmpAtIndex(global::System.IntPtr p_equalizer, float f_amp, uint u_band);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_equalizer_get_amp_at_index")]
            internal static extern float LibvlcAudioEqualizerGetAmpAtIndex(global::System.IntPtr p_equalizer, uint u_band);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_equalizer")]
            internal static extern int LibvlcMediaPlayerSetEqualizer(global::System.IntPtr p_mi, global::System.IntPtr p_equalizer);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_role")]
            internal static extern int LibvlcMediaPlayerGetRole(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_role")]
            internal static extern int LibvlcMediaPlayerSetRole(global::System.IntPtr p_mi, uint role);
        }

        /// <summary>Create an empty Media Player object</summary>
        /// <param name="p_libvlc_instance">
        /// <para>the libvlc instance in which the Media Player</para>
        /// <para>should be created.</para>
        /// </param>
        /// <returns>a new media player object, or NULL on error.</returns>
        public static global::libvlcpp.LibvlcMediaPlayerT LibvlcMediaPlayerNew(global::libvlcpp.LibvlcInstanceT p_libvlc_instance)
        {
            var __arg0 = ReferenceEquals(p_libvlc_instance, null) ? global::System.IntPtr.Zero : p_libvlc_instance.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerNew(__arg0);
            global::libvlcpp.LibvlcMediaPlayerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaPlayerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaPlayerT) global::libvlcpp.LibvlcMediaPlayerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaPlayerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Create a Media Player object from a Media</summary>
        /// <param name="p_md">
        /// <para>the media. Afterwards the p_md can be safely</para>
        /// <para>destroyed.</para>
        /// </param>
        /// <returns>a new media player object, or NULL on error.</returns>
        public static global::libvlcpp.LibvlcMediaPlayerT LibvlcMediaPlayerNewFromMedia(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerNewFromMedia(__arg0);
            global::libvlcpp.LibvlcMediaPlayerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaPlayerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaPlayerT) global::libvlcpp.LibvlcMediaPlayerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaPlayerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Release a media_player after use</para>
        /// <para>Decrement the reference count of a media player object. If the</para>
        /// <para>reference count is 0, then libvlc_media_player_release() will</para>
        /// <para>release the media player object. If the media player object</para>
        /// <para>has been released, then it should not be used again.</para>
        /// </summary>
        /// <param name="p_mi">the Media Player to free</param>
        public static void LibvlcMediaPlayerRelease(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerRelease(__arg0);
        }

        /// <summary>
        /// <para>Retain a reference to a media player object. Use</para>
        /// <para>libvlc_media_player_release() to decrement reference count.</para>
        /// </summary>
        /// <param name="p_mi">media player object</param>
        public static void LibvlcMediaPlayerRetain(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerRetain(__arg0);
        }

        /// <summary>
        /// <para>Set the media that will be used by the media_player. If any,</para>
        /// <para>previous md will be released.</para>
        /// </summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="p_md">
        /// <para>the Media. Afterwards the p_md can be safely</para>
        /// <para>destroyed.</para>
        /// </param>
        public static void LibvlcMediaPlayerSetMedia(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __arg1 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaPlayerSetMedia(__arg0, __arg1);
        }

        /// <summary>Get the media used by the media_player.</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>
        /// <para>the media associated with p_mi, or NULL if no</para>
        /// <para>media is associated</para>
        /// </returns>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaPlayerGetMedia(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetMedia(__arg0);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Get the Event Manager from which the media player send event.</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>the event manager associated with p_mi</returns>
        public static global::libvlcpp.LibvlcEventManagerT LibvlcMediaPlayerEventManager(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerEventManager(__arg0);
            global::libvlcpp.LibvlcEventManagerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEventManagerT) global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEventManagerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>is_playing</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>1 if the media player is playing, 0 otherwise</returns>
        public static int LibvlcMediaPlayerIsPlaying(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerIsPlaying(__arg0);
            return __ret;
        }

        /// <summary>Play</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>0 if playback started (and was already started), or -1 on error.</returns>
        public static int LibvlcMediaPlayerPlay(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerPlay(__arg0);
            return __ret;
        }

        /// <summary>Pause or resume (no effect if there is no media)</summary>
        /// <param name="mp">the Media Player</param>
        /// <param name="do_pause">play/resume if zero, pause if non-zero</param>
        /// <remarks>LibVLC 1.1.1 or later</remarks>
        public static void LibvlcMediaPlayerSetPause(global::libvlcpp.LibvlcMediaPlayerT mp, int do_pause)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            __Internal.LibvlcMediaPlayerSetPause(__arg0, do_pause);
        }

        /// <summary>Toggle pause (no effect if there is no media)</summary>
        /// <param name="p_mi">the Media Player</param>
        public static void LibvlcMediaPlayerPause(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerPause(__arg0);
        }

        /// <summary>Stop (no effect if there is no media)</summary>
        /// <param name="p_mi">the Media Player</param>
        public static void LibvlcMediaPlayerStop(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerStop(__arg0);
        }

        /// <summary>Set a renderer to the media player</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="p_item">an item discovered by libvlc_renderer_discoverer_start()</param>
        /// <returns>0 on success, -1 on error.</returns>
        /// <remarks>
        /// <para>must be called before the first call of libvlc_media_player_play() to</para>
        /// <para>take effect.</para>
        /// <para>libvlc_renderer_discoverer_new</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static int LibvlcMediaPlayerSetRenderer(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::libvlcpp.LibvlcRendererItemT p_item)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __arg1 = ReferenceEquals(p_item, null) ? global::System.IntPtr.Zero : p_item.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerSetRenderer(__arg0, __arg1);
            return __ret;
        }

        /// <summary>
        /// <para>Set callbacks and private data to render decoded video to a custom area</para>
        /// <para>in memory.</para>
        /// <para>Use libvlc_video_set_format() or libvlc_video_set_format_callbacks()</para>
        /// <para>to configure the decoded format.</para>
        /// </summary>
        /// <param name="mp">the media player</param>
        /// <param name="lock">callback to lock video memory (must not be NULL)</param>
        /// <param name="unlock">callback to unlock video memory (or NULL if not needed)</param>
        /// <param name="display">callback to display video (or NULL if not needed)</param>
        /// <param name="opaque">private pointer for the three callbacks (as first parameter)</param>
        /// <remarks>
        /// <para>Rendering video into custom memory buffers is considerably less</para>
        /// <para>efficient than rendering in a custom window as normal.</para>
        /// <para>For optimal perfomances, VLC media player renders into a custom window, and</para>
        /// <para>does not use this function and associated callbacks. It ishighly</para>
        /// <para>recommendedthat other LibVLC-based application do likewise.</para>
        /// <para>To embed video in a window, use libvlc_media_player_set_xid() or equivalent</para>
        /// <para>depending on the operating system.</para>
        /// <para>If window embedding does not fit the application use case, then a custom</para>
        /// <para>LibVLC video output display plugin is required to maintain optimal video</para>
        /// <para>rendering performances.</para>
        /// <para>The following limitations affect performance:</para>
        /// <para>- Hardware video decoding acceleration will either be disabled completely,</para>
        /// <para>or require (relatively slow) copy from video/DSP memory to main memory.</para>
        /// <para>- Sub-pictures (subtitles, on-screen display, etc.) must be blent into the</para>
        /// <para>main picture by the CPU instead of the GPU.</para>
        /// <para>- Depending on the video format, pixel format conversion, picture scaling,</para>
        /// <para>cropping and/or picture re-orientation, must be performed by the CPU</para>
        /// <para>instead of the GPU.</para>
        /// <para>- Memory copying is required between LibVLC reference picture buffers and</para>
        /// <para>application buffers (between lock and unlock callbacks).</para>
        /// <para>LibVLC 1.1.1 or later</para>
        /// </remarks>
        public static void LibvlcVideoSetCallbacks(global::libvlcpp.LibvlcMediaPlayerT mp, global::libvlcpp.LibvlcVideoLockCb @lock, global::libvlcpp.LibvlcVideoUnlockCb unlock, global::libvlcpp.LibvlcVideoDisplayCb display, global::System.IntPtr opaque)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            var __arg1 = @lock == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(@lock);
            var __arg2 = unlock == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(unlock);
            var __arg3 = display == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(display);
            __Internal.LibvlcVideoSetCallbacks(__arg0, __arg1, __arg2, __arg3, opaque);
        }

        /// <summary>
        /// <para>Set decoded video chroma and dimensions.</para>
        /// <para>This only works in combination with libvlc_video_set_callbacks(),</para>
        /// <para>and is mutually exclusive with libvlc_video_set_format_callbacks().</para>
        /// </summary>
        /// <param name="mp">the media player</param>
        /// <param name="chroma">
        /// <para>a four-characters string identifying the chroma</para>
        /// <para>(e.g. &quot;RV32&quot; or &quot;YUYV&quot;)</para>
        /// </param>
        /// <param name="width">pixel width</param>
        /// <param name="height">pixel height</param>
        /// <param name="pitch">line pitch (in bytes)</param>
        /// <remarks>
        /// <para>LibVLC 1.1.1 or later</para>
        /// <para>All pixel planes are expected to have the same pitch.</para>
        /// <para>To use the YCbCr color space with chrominance subsampling,</para>
        /// <para>consider using libvlc_video_set_format_callbacks() instead.</para>
        /// </remarks>
        public static void LibvlcVideoSetFormat(global::libvlcpp.LibvlcMediaPlayerT mp, string chroma, uint width, uint height, uint pitch)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            __Internal.LibvlcVideoSetFormat(__arg0, chroma, width, height, pitch);
        }

        /// <summary>
        /// <para>Set decoded video chroma and dimensions. This only works in combination with</para>
        /// <para>libvlc_video_set_callbacks().</para>
        /// </summary>
        /// <param name="mp">the media player</param>
        /// <param name="setup">callback to select the video format (cannot be NULL)</param>
        /// <param name="cleanup">callback to release any allocated resources (or NULL)</param>
        /// <remarks>LibVLC 2.0.0 or later</remarks>
        public static void LibvlcVideoSetFormatCallbacks(global::libvlcpp.LibvlcMediaPlayerT mp, global::libvlcpp.LibvlcVideoFormatCb setup, global::libvlcpp.LibvlcVideoCleanupCb cleanup)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            var __arg1 = setup == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(setup);
            var __arg2 = cleanup == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(cleanup);
            __Internal.LibvlcVideoSetFormatCallbacks(__arg0, __arg1, __arg2);
        }

        /// <summary>Set the NSView handler where the media player should render its video output.</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="drawable">
        /// <para>the drawable that is either an NSView or an object following</para>
        /// <para>the VLCOpenGLVideoViewEmbedding protocol.</para>
        /// </param>
        /// <remarks>
        /// <para>Use the vout called &quot;macosx&quot;.</para>
        /// <para>The drawable is an NSObject that follow the VLCOpenGLVideoViewEmbedding</para>
        /// <para>protocol:</para>
        /// <para>Or it can be an NSView object.</para>
        /// <para>If you want to use it along with Qt see the QMacCocoaViewContainer. Then</para>
        /// <para>the following code should work:</para>
        /// <para>You can find a live example in VLCVideoView in VLCKit.framework.</para>
        /// </remarks>
        public static void LibvlcMediaPlayerSetNsobject(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::System.IntPtr drawable)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetNsobject(__arg0, drawable);
        }

        /// <summary>Get the NSView handler previously set with libvlc_media_player_set_nsobject().</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>the NSView handler or 0 if none where set</returns>
        public static global::System.IntPtr LibvlcMediaPlayerGetNsobject(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetNsobject(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Set an X Window System drawable where the media player should render its</para>
        /// <para>video output. The call takes effect when the playback starts. If it is</para>
        /// <para>already started, it might need to be stopped before changes apply.</para>
        /// <para>If LibVLC was built without X11 output support, then this function has no</para>
        /// <para>effects.</para>
        /// </summary>
        /// <param name="p_mi">media player</param>
        /// <param name="drawable">X11 window ID</param>
        /// <remarks>
        /// <para>By default, LibVLC will capture input events on the video rendering area.</para>
        /// <para>Use libvlc_video_set_mouse_input() and libvlc_video_set_key_input() to</para>
        /// <para>disable that and deliver events to the parent window / to the application</para>
        /// <para>instead. By design, the X11 protocol delivers input events to only one</para>
        /// <para>recipient.</para>
        /// <para>The application must call the XInitThreads() function from Xlib before</para>
        /// <para>libvlc_new(), and before any call to XOpenDisplay() directly or via any</para>
        /// <para>other library. Failure to call XInitThreads() will seriously impede LibVLC</para>
        /// <para>performance. Calling XOpenDisplay() before XInitThreads() will eventually</para>
        /// <para>crash the process. That is a limitation of Xlib.</para>
        /// <para>The specified identifier must correspond to an existing Input/Output class</para>
        /// <para>X11 window. Pixmaps arenotcurrently supported. The default X11</para>
        /// <para>server is assumed, i.e. that specified in the DISPLAY environment variable.</para>
        /// <para>LibVLC can deal with invalid X11 handle errors, however some display drivers</para>
        /// <para>(EGL, GLX, VA and/or VDPAU) can unfortunately not. Thus the window handle</para>
        /// <para>must remain valid until playback is stopped, otherwise the process may</para>
        /// <para>abort or crash.</para>
        /// <para>No more than one window handle per media player instance can be specified.</para>
        /// <para>If the media has multiple simultaneously active video tracks, extra tracks</para>
        /// <para>will be rendered into external windows beyond the control of the</para>
        /// <para>application.</para>
        /// </remarks>
        public static void LibvlcMediaPlayerSetXwindow(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint drawable)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetXwindow(__arg0, drawable);
        }

        /// <summary>
        /// <para>Get the X Window System window identifier previously set with</para>
        /// <para>libvlc_media_player_set_xwindow(). Note that this will return the identifier</para>
        /// <para>even if VLC is not currently using it (for instance if it is playing an</para>
        /// <para>audio-only input).</para>
        /// </summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>an X window ID, or 0 if none where set.</returns>
        public static uint LibvlcMediaPlayerGetXwindow(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetXwindow(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Set a Win32/Win64 API window handle (HWND) where the media player should</para>
        /// <para>render its video output. If LibVLC was built without Win32/Win64 API output</para>
        /// <para>support, then this has no effects.</para>
        /// </summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="drawable">windows handle of the drawable</param>
        public static void LibvlcMediaPlayerSetHwnd(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::System.IntPtr drawable)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetHwnd(__arg0, drawable);
        }

        /// <summary>
        /// <para>Get the Windows API window handle (HWND) previously set with</para>
        /// <para>libvlc_media_player_set_hwnd(). The handle will be returned even if LibVLC</para>
        /// <para>is not currently outputting any video to it.</para>
        /// </summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>a window handle or NULL if there are none.</returns>
        public static global::System.IntPtr LibvlcMediaPlayerGetHwnd(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetHwnd(__arg0);
            return __ret;
        }

        /// <summary>Set the android context.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="p_awindow_handler">
        /// <para>org.videolan.libvlc.AWindow jobject owned by the</para>
        /// <para>org.videolan.libvlc.MediaPlayer class from the libvlc-android project.</para>
        /// </param>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static void LibvlcMediaPlayerSetAndroidContext(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::System.IntPtr p_awindow_handler)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetAndroidContext(__arg0, p_awindow_handler);
        }

        /// <summary>Set the EFL Evas Object.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="p_evas_object">a valid EFL Evas Object (Evas_Object)</param>
        /// <returns>-1 if an error was detected, 0 otherwise.</returns>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static int LibvlcMediaPlayerSetEvasObject(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::System.IntPtr p_evas_object)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerSetEvasObject(__arg0, p_evas_object);
            return __ret;
        }

        /// <summary>Sets callbacks and private data for decoded audio.</summary>
        /// <param name="mp">the media player</param>
        /// <param name="play">callback to play audio samples (must not be NULL)</param>
        /// <param name="pause">callback to pause playback (or NULL to ignore)</param>
        /// <param name="resume">callback to resume playback (or NULL to ignore)</param>
        /// <param name="flush">callback to flush audio buffers (or NULL to ignore)</param>
        /// <param name="drain">callback to drain audio buffers (or NULL to ignore)</param>
        /// <param name="opaque">private pointer for the audio callbacks (as first parameter)</param>
        /// <remarks>
        /// <para>Use libvlc_audio_set_format() or libvlc_audio_set_format_callbacks()</para>
        /// <para>to configure the decoded audio format.</para>
        /// <para>The audio callbacks override any other audio output mechanism.</para>
        /// <para>If the callbacks are set, LibVLC willnotoutput audio in any way.</para>
        /// <para>LibVLC 2.0.0 or later</para>
        /// </remarks>
        public static void LibvlcAudioSetCallbacks(global::libvlcpp.LibvlcMediaPlayerT mp, global::libvlcpp.LibvlcAudioPlayCb play, global::libvlcpp.LibvlcAudioPauseCb pause, global::libvlcpp.LibvlcAudioResumeCb resume, global::libvlcpp.LibvlcAudioFlushCb flush, global::libvlcpp.LibvlcAudioDrainCb drain, global::System.IntPtr opaque)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            var __arg1 = play == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(play);
            var __arg2 = pause == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(pause);
            var __arg3 = resume == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(resume);
            var __arg4 = flush == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(flush);
            var __arg5 = drain == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(drain);
            __Internal.LibvlcAudioSetCallbacks(__arg0, __arg1, __arg2, __arg3, __arg4, __arg5, opaque);
        }

        /// <summary>
        /// <para>Set callbacks and private data for decoded audio. This only works in</para>
        /// <para>combination with libvlc_audio_set_callbacks().</para>
        /// <para>Use libvlc_audio_set_format() or libvlc_audio_set_format_callbacks()</para>
        /// <para>to configure the decoded audio format.</para>
        /// </summary>
        /// <param name="mp">the media player</param>
        /// <param name="set_volume">
        /// <para>callback to apply audio volume,</para>
        /// <para>or NULL to apply volume in software</para>
        /// </param>
        /// <remarks>LibVLC 2.0.0 or later</remarks>
        public static void LibvlcAudioSetVolumeCallback(global::libvlcpp.LibvlcMediaPlayerT mp, global::libvlcpp.LibvlcAudioSetVolumeCb set_volume)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            var __arg1 = set_volume == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(set_volume);
            __Internal.LibvlcAudioSetVolumeCallback(__arg0, __arg1);
        }

        /// <summary>Sets decoded audio format via callbacks.</summary>
        /// <param name="mp">the media player</param>
        /// <param name="setup">callback to select the audio format (cannot be NULL)</param>
        /// <param name="cleanup">callback to release any allocated resources (or NULL)</param>
        /// <remarks>
        /// <para>This only works in combination with libvlc_audio_set_callbacks().</para>
        /// <para>LibVLC 2.0.0 or later</para>
        /// </remarks>
        public static void LibvlcAudioSetFormatCallbacks(global::libvlcpp.LibvlcMediaPlayerT mp, global::libvlcpp.LibvlcAudioSetupCb setup, global::libvlcpp.LibvlcAudioCleanupCb cleanup)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            var __arg1 = setup == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(setup);
            var __arg2 = cleanup == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(cleanup);
            __Internal.LibvlcAudioSetFormatCallbacks(__arg0, __arg1, __arg2);
        }

        /// <summary>Sets a fixed decoded audio format.</summary>
        /// <param name="mp">the media player</param>
        /// <param name="format">
        /// <para>a four-characters string identifying the sample format</para>
        /// <para>(e.g. &quot;S16N&quot; or &quot;FL32&quot;)</para>
        /// </param>
        /// <param name="rate">sample rate (expressed in Hz)</param>
        /// <param name="channels">channels count</param>
        /// <remarks>
        /// <para>This only works in combination with libvlc_audio_set_callbacks(),</para>
        /// <para>and is mutually exclusive with libvlc_audio_set_format_callbacks().</para>
        /// <para>LibVLC 2.0.0 or later</para>
        /// </remarks>
        public static void LibvlcAudioSetFormat(global::libvlcpp.LibvlcMediaPlayerT mp, string format, uint rate, uint channels)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            __Internal.LibvlcAudioSetFormat(__arg0, format, rate, channels);
        }

        /// <summary>Get the current movie length (in ms).</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>the movie length (in ms), or -1 if there is no media.</returns>
        public static long LibvlcMediaPlayerGetLength(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetLength(__arg0);
            return __ret;
        }

        /// <summary>Get the current movie time (in ms).</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>the movie time (in ms), or -1 if there is no media.</returns>
        public static long LibvlcMediaPlayerGetTime(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetTime(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Set the movie time (in ms). This has no effect if no media is being played.</para>
        /// <para>Not all formats and protocols support this.</para>
        /// </summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="i_time">the movie time (in ms).</param>
        public static void LibvlcMediaPlayerSetTime(global::libvlcpp.LibvlcMediaPlayerT p_mi, long i_time)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetTime(__arg0, i_time);
        }

        /// <summary>Get movie position as percentage between 0.0 and 1.0.</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>movie position, or -1. in case of error</returns>
        public static float LibvlcMediaPlayerGetPosition(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetPosition(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Set movie position as percentage between 0.0 and 1.0.</para>
        /// <para>This has no effect if playback is not enabled.</para>
        /// <para>This might not work depending on the underlying input format and protocol.</para>
        /// </summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="f_pos">the position</param>
        public static void LibvlcMediaPlayerSetPosition(global::libvlcpp.LibvlcMediaPlayerT p_mi, float f_pos)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetPosition(__arg0, f_pos);
        }

        /// <summary>Set movie chapter (if applicable).</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="i_chapter">chapter number to play</param>
        public static void LibvlcMediaPlayerSetChapter(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_chapter)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetChapter(__arg0, i_chapter);
        }

        /// <summary>Get movie chapter.</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>chapter number currently playing, or -1 if there is no media.</returns>
        public static int LibvlcMediaPlayerGetChapter(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetChapter(__arg0);
            return __ret;
        }

        /// <summary>Get movie chapter count</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>number of chapters in movie, or -1.</returns>
        public static int LibvlcMediaPlayerGetChapterCount(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetChapterCount(__arg0);
            return __ret;
        }

        /// <summary>Is the player able to play</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>boolean</returns>
        public static int LibvlcMediaPlayerWillPlay(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerWillPlay(__arg0);
            return __ret;
        }

        /// <summary>Get title chapter count</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="i_title">title</param>
        /// <returns>number of chapters in title, or -1</returns>
        public static int LibvlcMediaPlayerGetChapterCountForTitle(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_title)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetChapterCountForTitle(__arg0, i_title);
            return __ret;
        }

        /// <summary>Set movie title</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="i_title">title number to play</param>
        public static void LibvlcMediaPlayerSetTitle(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_title)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetTitle(__arg0, i_title);
        }

        /// <summary>Get movie title</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>title number currently playing, or -1</returns>
        public static int LibvlcMediaPlayerGetTitle(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetTitle(__arg0);
            return __ret;
        }

        /// <summary>Get movie title count</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>title number count, or -1</returns>
        public static int LibvlcMediaPlayerGetTitleCount(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetTitleCount(__arg0);
            return __ret;
        }

        /// <summary>Set previous chapter (if applicable)</summary>
        /// <param name="p_mi">the Media Player</param>
        public static void LibvlcMediaPlayerPreviousChapter(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerPreviousChapter(__arg0);
        }

        /// <summary>Set next chapter (if applicable)</summary>
        /// <param name="p_mi">the Media Player</param>
        public static void LibvlcMediaPlayerNextChapter(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerNextChapter(__arg0);
        }

        /// <summary>Get the requested movie play rate.</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>movie play rate</returns>
        /// <remarks>
        /// <para>Depending on the underlying media, the requested rate may be</para>
        /// <para>different from the real playback rate.</para>
        /// </remarks>
        public static float LibvlcMediaPlayerGetRate(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetRate(__arg0);
            return __ret;
        }

        /// <summary>Set movie play rate</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="rate">movie play rate to set</param>
        /// <returns>
        /// <para>-1 if an error was detected, 0 otherwise (but even then, it might</para>
        /// <para>not actually work depending on the underlying media protocol)</para>
        /// </returns>
        public static int LibvlcMediaPlayerSetRate(global::libvlcpp.LibvlcMediaPlayerT p_mi, float rate)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerSetRate(__arg0, rate);
            return __ret;
        }

        /// <summary>Get current movie state</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>the current state of the media player (playing, paused, ...)</returns>
        /// <remarks>libvlc_state_t</remarks>
        public static global::libvlcpp.LibvlcStateT LibvlcMediaPlayerGetState(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetState(__arg0);
            return __ret;
        }

        /// <summary>How many video outputs does this media player have?</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>the number of video outputs</returns>
        public static uint LibvlcMediaPlayerHasVout(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerHasVout(__arg0);
            return __ret;
        }

        /// <summary>Is this media player seekable?</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>true if the media player can seek</returns>
        public static int LibvlcMediaPlayerIsSeekable(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerIsSeekable(__arg0);
            return __ret;
        }

        /// <summary>Can this media player be paused?</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>true if the media player can pause</returns>
        public static int LibvlcMediaPlayerCanPause(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerCanPause(__arg0);
            return __ret;
        }

        /// <summary>Check if the current program is scrambled</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>true if the current program is scrambled</returns>
        /// <remarks>LibVLC 2.2.0 or later</remarks>
        public static int LibvlcMediaPlayerProgramScrambled(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerProgramScrambled(__arg0);
            return __ret;
        }

        /// <summary>Display the next frame (if supported)</summary>
        /// <param name="p_mi">the media player</param>
        public static void LibvlcMediaPlayerNextFrame(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerNextFrame(__arg0);
        }

        /// <summary>Navigate through DVD Menu</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <param name="navigate">the Navigation mode</param>
        /// <remarks>libVLC 2.0.0 or later</remarks>
        public static void LibvlcMediaPlayerNavigate(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint navigate)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerNavigate(__arg0, navigate);
        }

        /// <summary>Set if, and how, the video title will be shown when media is played.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="position">position at which to display the title, or libvlc_position_disable to prevent the title from being displayed</param>
        /// <param name="timeout">title display timeout in milliseconds (ignored if libvlc_position_disable)</param>
        /// <remarks>libVLC 2.1.0 or later</remarks>
        public static void LibvlcMediaPlayerSetVideoTitleDisplay(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::libvlcpp.LibvlcPositionT position, uint timeout)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetVideoTitleDisplay(__arg0, position, timeout);
        }

        /// <summary>Add a slave to the current media player.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="i_type">subtitle or audio</param>
        /// <param name="psz_uri">Uri of the slave (should contain a valid scheme).</param>
        /// <param name="b_select">True if this slave should be selected when it's loaded</param>
        /// <returns>0 on success, -1 on error.</returns>
        /// <remarks>
        /// <para>If the player is playing, the slave will be added directly. This call</para>
        /// <para>will also update the slave list of the attached libvlc_media_t.</para>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// <para>libvlc_media_slaves_add</para>
        /// </remarks>
        public static int LibvlcMediaPlayerAddSlave(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::libvlcpp.LibvlcMediaSlaveTypeT i_type, string psz_uri, bool b_select)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerAddSlave(__arg0, i_type, psz_uri, b_select);
            return __ret;
        }

        /// <summary>Release (free) libvlc_track_description_t</summary>
        /// <param name="p_track_description">the structure to release</param>
        public static void LibvlcTrackDescriptionListRelease(global::libvlcpp.LibvlcTrackDescriptionT p_track_description)
        {
            var __arg0 = ReferenceEquals(p_track_description, null) ? global::System.IntPtr.Zero : p_track_description.__Instance;
            __Internal.LibvlcTrackDescriptionListRelease(__arg0);
        }

        /// <summary>Toggle fullscreen status on non-embedded video outputs.</summary>
        /// <param name="p_mi">the media player</param>
        /// <remarks>
        /// <para>The same limitations applies to this function</para>
        /// <para>as to libvlc_set_fullscreen().</para>
        /// </remarks>
        public static void LibvlcToggleFullscreen(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcToggleFullscreen(__arg0);
        }

        /// <summary>Enable or disable fullscreen.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="b_fullscreen">boolean for fullscreen status</param>
        /// <remarks>
        /// <para>With most window managers, only a top-level windows can be in</para>
        /// <para>full-screen mode. Hence, this function will not operate properly if</para>
        /// <para>libvlc_media_player_set_xwindow() was used to embed the video in a</para>
        /// <para>non-top-level window. In that case, the embedding window must be reparented</para>
        /// <para>to the root windowbeforefullscreen mode is enabled. You will want</para>
        /// <para>to reparent it back to its normal parent when disabling fullscreen.</para>
        /// </remarks>
        public static void LibvlcSetFullscreen(global::libvlcpp.LibvlcMediaPlayerT p_mi, int b_fullscreen)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcSetFullscreen(__arg0, b_fullscreen);
        }

        /// <summary>Get current fullscreen status.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>the fullscreen status (boolean)</returns>
        public static int LibvlcGetFullscreen(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcGetFullscreen(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Enable or disable key press events handling, according to the LibVLC hotkeys</para>
        /// <para>configuration. By default and for historical reasons, keyboard events are</para>
        /// <para>handled by the LibVLC video widget.</para>
        /// </summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="on">true to handle key press events, false to ignore them.</param>
        /// <remarks>
        /// <para>On X11, there can be only one subscriber for key press and mouse</para>
        /// <para>click events per window. If your application has subscribed to those events</para>
        /// <para>for the X window ID of the video widget, then LibVLC will not be able to</para>
        /// <para>handle key presses and mouse clicks in any case.</para>
        /// <para>This function is only implemented for X11 and Win32 at the moment.</para>
        /// </remarks>
        public static void LibvlcVideoSetKeyInput(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint on)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetKeyInput(__arg0, on);
        }

        /// <summary>
        /// <para>Enable or disable mouse click events handling. By default, those events are</para>
        /// <para>handled. This is needed for DVD menus to work, as well as a few video</para>
        /// <para>filters such as &quot;puzzle&quot;.</para>
        /// </summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="on">true to handle mouse click events, false to ignore them.</param>
        /// <remarks>
        /// <para>libvlc_video_set_key_input().</para>
        /// <para>This function is only implemented for X11 and Win32 at the moment.</para>
        /// </remarks>
        public static void LibvlcVideoSetMouseInput(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint on)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetMouseInput(__arg0, on);
        }

        /// <summary>Get the pixel dimensions of a video.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="num">number of the video (starting from, and most commonly 0)</param>
        /// <param name="px">pointer to get the pixel width [OUT]</param>
        /// <param name="py">pointer to get the pixel height [OUT]</param>
        /// <returns>0 on success, -1 if the specified video does not exist</returns>
        public static int LibvlcVideoGetSize(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint num, ref uint px, ref uint py)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            fixed (uint* __refParamPtr2 = &px)
            {
                var __arg2 = __refParamPtr2;
                fixed (uint* __refParamPtr3 = &py)
                {
                    var __arg3 = __refParamPtr3;
                    var __ret = __Internal.LibvlcVideoGetSize(__arg0, num, __arg2, __arg3);
                    return __ret;
                }
            }
        }

        /// <summary>
        /// <para>Get the mouse pointer coordinates over a video.</para>
        /// <para>Coordinates are expressed in terms of the decoded video resolution,</para>
        /// <para>notin terms of pixels on the screen/viewport (to get the latter,</para>
        /// <para>you can query your windowing system directly).</para>
        /// </summary>
        /// <param name="p_mi">media player</param>
        /// <param name="num">number of the video (starting from, and most commonly 0)</param>
        /// <param name="px">pointer to get the abscissa [OUT]</param>
        /// <param name="py">pointer to get the ordinate [OUT]</param>
        /// <returns>0 on success, -1 if the specified video does not exist</returns>
        /// <remarks>
        /// <para>Either of the coordinates may be negative or larger than the corresponding</para>
        /// <para>dimension of the video, if the cursor is outside the rendering area.</para>
        /// <para>The coordinates may be out-of-date if the pointer is not located</para>
        /// <para>on the video rendering area. LibVLC does not track the pointer if it is</para>
        /// <para>outside of the video widget.</para>
        /// <para>LibVLC does not support multiple pointers (it does of course support</para>
        /// <para>multiple input devices sharing the same pointer) at the moment.</para>
        /// </remarks>
        public static int LibvlcVideoGetCursor(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint num, ref int px, ref int py)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            fixed (int* __refParamPtr2 = &px)
            {
                var __arg2 = __refParamPtr2;
                fixed (int* __refParamPtr3 = &py)
                {
                    var __arg3 = __refParamPtr3;
                    var __ret = __Internal.LibvlcVideoGetCursor(__arg0, num, __arg2, __arg3);
                    return __ret;
                }
            }
        }

        /// <summary>
        /// <para>Get the current video scaling factor.</para>
        /// <para>See also libvlc_video_set_scale().</para>
        /// </summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>
        /// <para>the currently configured zoom factor, or 0. if the video is set</para>
        /// <para>to fit to the output window/drawable automatically.</para>
        /// </returns>
        public static float LibvlcVideoGetScale(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetScale(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Set the video scaling factor. That is the ratio of the number of pixels on</para>
        /// <para>screen to the number of pixels in the original decoded video in each</para>
        /// <para>dimension. Zero is a special value; it will adjust the video to the output</para>
        /// <para>window/drawable (in windowed mode) or the entire screen.</para>
        /// </summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="f_factor">the scaling factor, or zero</param>
        /// <remarks>Note that not all video outputs support scaling.</remarks>
        public static void LibvlcVideoSetScale(global::libvlcpp.LibvlcMediaPlayerT p_mi, float f_factor)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetScale(__arg0, f_factor);
        }

        /// <summary>Get current video aspect ratio.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>
        /// <para>the video aspect ratio or NULL if unspecified</para>
        /// <para>(the result must be released with free() or libvlc_free()).</para>
        /// </returns>
        public static sbyte* LibvlcVideoGetAspectRatio(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetAspectRatio(__arg0);
            return __ret;
        }

        /// <summary>Set new video aspect ratio.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="psz_aspect">new video aspect-ratio or NULL to reset to default</param>
        /// <remarks>Invalid aspect ratios are ignored.</remarks>
        public static void LibvlcVideoSetAspectRatio(global::libvlcpp.LibvlcMediaPlayerT p_mi, string psz_aspect)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetAspectRatio(__arg0, psz_aspect);
        }

        /// <summary>Create a video viewpoint structure.</summary>
        /// <returns>
        /// <para>video viewpoint or NULL</para>
        /// <para>(the result must be released with free() or libvlc_free()).</para>
        /// </returns>
        /// <remarks>LibVLC 3.0.0 and later</remarks>
        public static global::libvlcpp.LibvlcVideoViewpointT LibvlcVideoNewViewpoint()
        {
            var __ret = __Internal.LibvlcVideoNewViewpoint();
            global::libvlcpp.LibvlcVideoViewpointT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcVideoViewpointT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcVideoViewpointT) global::libvlcpp.LibvlcVideoViewpointT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcVideoViewpointT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Update the video viewpoint information.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="p_viewpoint">video viewpoint allocated via libvlc_video_new_viewpoint()</param>
        /// <param name="b_absolute">
        /// <para>if true replace the old viewpoint with the new one. If</para>
        /// <para>false, increase/decrease it.</para>
        /// </param>
        /// <returns>-1 in case of error, 0 otherwise</returns>
        /// <remarks>
        /// <para>It is safe to call this function before the media player is started.</para>
        /// <para>LibVLC 3.0.0 and later</para>
        /// <para>the values are set asynchronously, it will be used by the next frame displayed.</para>
        /// </remarks>
        public static int LibvlcVideoUpdateViewpoint(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::libvlcpp.LibvlcVideoViewpointT p_viewpoint, bool b_absolute)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __arg1 = ReferenceEquals(p_viewpoint, null) ? global::System.IntPtr.Zero : p_viewpoint.__Instance;
            var __ret = __Internal.LibvlcVideoUpdateViewpoint(__arg0, __arg1, b_absolute);
            return __ret;
        }

        /// <summary>Get current video subtitle.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>the video subtitle selected, or -1 if none</returns>
        public static int LibvlcVideoGetSpu(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetSpu(__arg0);
            return __ret;
        }

        /// <summary>Get the number of available video subtitles.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>the number of available video subtitles</returns>
        public static int LibvlcVideoGetSpuCount(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetSpuCount(__arg0);
            return __ret;
        }

        /// <summary>Get the description of available video subtitles.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>
        /// <para>list containing description of available video subtitles.</para>
        /// <para>It must be freed with libvlc_track_description_list_release()</para>
        /// </returns>
        public static global::libvlcpp.LibvlcTrackDescriptionT LibvlcVideoGetSpuDescription(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetSpuDescription(__arg0);
            global::libvlcpp.LibvlcTrackDescriptionT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcTrackDescriptionT) global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcTrackDescriptionT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Set new video subtitle.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="i_spu">video subtitle track to select (i_id from track description)</param>
        /// <returns>0 on success, -1 if out of range</returns>
        public static int LibvlcVideoSetSpu(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_spu)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoSetSpu(__arg0, i_spu);
            return __ret;
        }

        /// <summary>
        /// <para>Get the current subtitle delay. Positive values means subtitles are being</para>
        /// <para>displayed later, negative values earlier.</para>
        /// </summary>
        /// <param name="p_mi">media player</param>
        /// <returns>time (in microseconds) the display of subtitles is being delayed</returns>
        /// <remarks>LibVLC 2.0.0 or later</remarks>
        public static long LibvlcVideoGetSpuDelay(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetSpuDelay(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Set the subtitle delay. This affects the timing of when the subtitle will</para>
        /// <para>be displayed. Positive values result in subtitles being displayed later,</para>
        /// <para>while negative values will result in subtitles being displayed earlier.</para>
        /// </summary>
        /// <param name="p_mi">media player</param>
        /// <param name="i_delay">time (in microseconds) the display of subtitles should be delayed</param>
        /// <returns>0 on success, -1 on error</returns>
        /// <remarks>
        /// <para>The subtitle delay will be reset to zero each time the media changes.</para>
        /// <para>LibVLC 2.0.0 or later</para>
        /// </remarks>
        public static int LibvlcVideoSetSpuDelay(global::libvlcpp.LibvlcMediaPlayerT p_mi, long i_delay)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoSetSpuDelay(__arg0, i_delay);
            return __ret;
        }

        /// <summary>Get the full description of available titles</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="titles">
        /// <para>address to store an allocated array of title descriptions</para>
        /// <para>descriptions (must be freed with libvlc_title_descriptions_release()</para>
        /// <para>by the caller) [OUT]</para>
        /// </param>
        /// <returns>the number of titles (-1 on error)</returns>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static int LibvlcMediaPlayerGetFullTitleDescriptions(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::libvlcpp.LibvlcTitleDescriptionT titles)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __arg1 = ReferenceEquals(titles, null) ? global::System.IntPtr.Zero : titles.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetFullTitleDescriptions(__arg0, __arg1);
            return __ret;
        }

        /// <summary>Release a title description</summary>
        /// <param name="p_titles">title description array to release</param>
        /// <param name="i_count">number of title descriptions to release</param>
        /// <remarks>LibVLC 3.0.0 and later</remarks>
        public static void LibvlcTitleDescriptionsRelease(global::libvlcpp.LibvlcTitleDescriptionT p_titles, uint i_count)
        {
            var __arg0 = ReferenceEquals(p_titles, null) ? global::System.IntPtr.Zero : p_titles.__Instance;
            __Internal.LibvlcTitleDescriptionsRelease(__arg0, i_count);
        }

        /// <summary>Get the full description of available chapters</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="i_chapters_of_title">index of the title to query for chapters (uses current title if set to -1)</param>
        /// <param name="pp_chapters">
        /// <para>address to store an allocated array of chapter descriptions</para>
        /// <para>descriptions (must be freed with libvlc_chapter_descriptions_release()</para>
        /// <para>by the caller) [OUT]</para>
        /// </param>
        /// <returns>the number of chapters (-1 on error)</returns>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static int LibvlcMediaPlayerGetFullChapterDescriptions(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_chapters_of_title, global::libvlcpp.LibvlcChapterDescriptionT pp_chapters)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __arg2 = ReferenceEquals(pp_chapters, null) ? global::System.IntPtr.Zero : pp_chapters.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetFullChapterDescriptions(__arg0, i_chapters_of_title, __arg2);
            return __ret;
        }

        /// <summary>Release a chapter description</summary>
        /// <param name="p_chapters">chapter description array to release</param>
        /// <param name="i_count">number of chapter descriptions to release</param>
        /// <remarks>LibVLC 3.0.0 and later</remarks>
        public static void LibvlcChapterDescriptionsRelease(global::libvlcpp.LibvlcChapterDescriptionT p_chapters, uint i_count)
        {
            var __arg0 = ReferenceEquals(p_chapters, null) ? global::System.IntPtr.Zero : p_chapters.__Instance;
            __Internal.LibvlcChapterDescriptionsRelease(__arg0, i_count);
        }

        /// <summary>Get current crop filter geometry.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>the crop filter geometry or NULL if unset</returns>
        public static sbyte* LibvlcVideoGetCropGeometry(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetCropGeometry(__arg0);
            return __ret;
        }

        /// <summary>Set new crop filter geometry.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="psz_geometry">new crop filter geometry (NULL to unset)</param>
        public static void LibvlcVideoSetCropGeometry(global::libvlcpp.LibvlcMediaPlayerT p_mi, string psz_geometry)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetCropGeometry(__arg0, psz_geometry);
        }

        /// <summary>Get current teletext page requested or 0 if it's disabled.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>the current teletext page requested.</returns>
        /// <remarks>
        /// <para>Teletext is disabled by default, call libvlc_video_set_teletext() to enable</para>
        /// <para>it.</para>
        /// </remarks>
        public static int LibvlcVideoGetTeletext(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetTeletext(__arg0);
            return __ret;
        }

        /// <summary>Set new teletext page to retrieve.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="i_page">
        /// <para>teletex page number requested. This value can be 0 to disable</para>
        /// <para>teletext, a number in the range ]0;1000[ to show the requested page, or a</para>
        /// </param>
        /// <remarks>This function can also be used to send a teletext key.</remarks>
        public static void LibvlcVideoSetTeletext(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_page)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetTeletext(__arg0, i_page);
        }

        /// <summary>Get number of available video tracks.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>the number of available video tracks (int)</returns>
        public static int LibvlcVideoGetTrackCount(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetTrackCount(__arg0);
            return __ret;
        }

        /// <summary>Get the description of available video tracks.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>
        /// <para>list with description of available video tracks, or NULL on error.</para>
        /// <para>It must be freed with libvlc_track_description_list_release()</para>
        /// </returns>
        public static global::libvlcpp.LibvlcTrackDescriptionT LibvlcVideoGetTrackDescription(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetTrackDescription(__arg0);
            global::libvlcpp.LibvlcTrackDescriptionT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcTrackDescriptionT) global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcTrackDescriptionT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Get current video track.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>the video track ID (int) or -1 if no active input</returns>
        public static int LibvlcVideoGetTrack(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetTrack(__arg0);
            return __ret;
        }

        /// <summary>Set video track.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="i_track">the track ID (i_id field from track description)</param>
        /// <returns>0 on success, -1 if out of range</returns>
        public static int LibvlcVideoSetTrack(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_track)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoSetTrack(__arg0, i_track);
            return __ret;
        }

        /// <summary>Take a snapshot of the current video window.</summary>
        /// <param name="p_mi">media player instance</param>
        /// <param name="num">number of video output (typically 0 for the first/only one)</param>
        /// <param name="psz_filepath">the path of a file or a folder to save the screenshot into</param>
        /// <param name="i_width">the snapshot's width</param>
        /// <param name="i_height">the snapshot's height</param>
        /// <returns>0 on success, -1 if the video was not found</returns>
        /// <remarks>
        /// <para>If i_width AND i_height is 0, original size is used.</para>
        /// <para>If i_width XOR i_height is 0, original aspect-ratio is preserved.</para>
        /// </remarks>
        public static int LibvlcVideoTakeSnapshot(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint num, string psz_filepath, uint i_width, uint i_height)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoTakeSnapshot(__arg0, num, psz_filepath, i_width, i_height);
            return __ret;
        }

        /// <summary>Enable or disable deinterlace filter</summary>
        /// <param name="p_mi">libvlc media player</param>
        /// <param name="psz_mode">type of deinterlace filter, NULL to disable</param>
        public static void LibvlcVideoSetDeinterlace(global::libvlcpp.LibvlcMediaPlayerT p_mi, string psz_mode)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetDeinterlace(__arg0, psz_mode);
        }

        /// <summary>Get an integer marquee option value</summary>
        /// <param name="p_mi">libvlc media player</param>
        /// <param name="option">marq option to get</param>
        /// <remarks>libvlc_video_marquee_int_option_t</remarks>
        public static int LibvlcVideoGetMarqueeInt(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetMarqueeInt(__arg0, option);
            return __ret;
        }

        /// <summary>Get a string marquee option value</summary>
        /// <param name="p_mi">libvlc media player</param>
        /// <param name="option">marq option to get</param>
        /// <remarks>libvlc_video_marquee_string_option_t</remarks>
        public static sbyte* LibvlcVideoGetMarqueeString(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetMarqueeString(__arg0, option);
            return __ret;
        }

        /// <summary>Enable, disable or set an integer marquee option</summary>
        /// <param name="p_mi">libvlc media player</param>
        /// <param name="option">marq option to set</param>
        /// <param name="i_val">marq option value</param>
        /// <remarks>
        /// <para>Setting libvlc_marquee_Enable has the side effect of enabling (arg !0)</para>
        /// <para>or disabling (arg 0) the marq filter.</para>
        /// <para>libvlc_video_marquee_int_option_t</para>
        /// </remarks>
        public static void LibvlcVideoSetMarqueeInt(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option, int i_val)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetMarqueeInt(__arg0, option, i_val);
        }

        /// <summary>Set a marquee string option</summary>
        /// <param name="p_mi">libvlc media player</param>
        /// <param name="option">marq option to set</param>
        /// <param name="psz_text">marq option value</param>
        /// <remarks>libvlc_video_marquee_string_option_t</remarks>
        public static void LibvlcVideoSetMarqueeString(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option, string psz_text)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetMarqueeString(__arg0, option, psz_text);
        }

        /// <summary>Get integer logo option.</summary>
        /// <param name="p_mi">libvlc media player instance</param>
        /// <param name="option">logo option to get, values of libvlc_video_logo_option_t</param>
        public static int LibvlcVideoGetLogoInt(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetLogoInt(__arg0, option);
            return __ret;
        }

        /// <summary>
        /// <para>Set logo option as integer. Options that take a different type value</para>
        /// <para>are ignored.</para>
        /// <para>Passing libvlc_logo_enable as option value has the side effect of</para>
        /// <para>starting (arg !0) or stopping (arg 0) the logo filter.</para>
        /// </summary>
        /// <param name="p_mi">libvlc media player instance</param>
        /// <param name="option">logo option to set, values of libvlc_video_logo_option_t</param>
        /// <param name="value">logo option value</param>
        public static void LibvlcVideoSetLogoInt(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option, int value)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetLogoInt(__arg0, option, value);
        }

        /// <summary>
        /// <para>Set logo option as string. Options that take a different type value</para>
        /// <para>are ignored.</para>
        /// </summary>
        /// <param name="p_mi">libvlc media player instance</param>
        /// <param name="option">logo option to set, values of libvlc_video_logo_option_t</param>
        /// <param name="psz_value">logo option value</param>
        public static void LibvlcVideoSetLogoString(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option, string psz_value)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetLogoString(__arg0, option, psz_value);
        }

        /// <summary>Get integer adjust option.</summary>
        /// <param name="p_mi">libvlc media player instance</param>
        /// <param name="option">adjust option to get, values of libvlc_video_adjust_option_t</param>
        /// <remarks>LibVLC 1.1.1 and later.</remarks>
        public static int LibvlcVideoGetAdjustInt(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetAdjustInt(__arg0, option);
            return __ret;
        }

        /// <summary>
        /// <para>Set adjust option as integer. Options that take a different type value</para>
        /// <para>are ignored.</para>
        /// <para>Passing libvlc_adjust_enable as option value has the side effect of</para>
        /// <para>starting (arg !0) or stopping (arg 0) the adjust filter.</para>
        /// </summary>
        /// <param name="p_mi">libvlc media player instance</param>
        /// <param name="option">adust option to set, values of libvlc_video_adjust_option_t</param>
        /// <param name="value">adjust option value</param>
        /// <remarks>LibVLC 1.1.1 and later.</remarks>
        public static void LibvlcVideoSetAdjustInt(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option, int value)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetAdjustInt(__arg0, option, value);
        }

        /// <summary>Get float adjust option.</summary>
        /// <param name="p_mi">libvlc media player instance</param>
        /// <param name="option">adjust option to get, values of libvlc_video_adjust_option_t</param>
        /// <remarks>LibVLC 1.1.1 and later.</remarks>
        public static float LibvlcVideoGetAdjustFloat(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetAdjustFloat(__arg0, option);
            return __ret;
        }

        /// <summary>
        /// <para>Set adjust option as float. Options that take a different type value</para>
        /// <para>are ignored.</para>
        /// </summary>
        /// <param name="p_mi">libvlc media player instance</param>
        /// <param name="option">adust option to set, values of libvlc_video_adjust_option_t</param>
        /// <param name="value">adjust option value</param>
        /// <remarks>LibVLC 1.1.1 and later.</remarks>
        public static void LibvlcVideoSetAdjustFloat(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint option, float value)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcVideoSetAdjustFloat(__arg0, option, value);
        }

        /// <summary>Gets the list of available audio output modules.</summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <returns>list of available audio outputs. It must be freed with</returns>
        /// <remarks>
        /// <para>libvlc_audio_output_list_release</para>
        /// <para>libvlc_audio_output_t .</para>
        /// <para>In case of error, NULL is returned.</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcAudioOutputT LibvlcAudioOutputListGet(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcAudioOutputListGet(__arg0);
            global::libvlcpp.LibvlcAudioOutputT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcAudioOutputT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcAudioOutputT) global::libvlcpp.LibvlcAudioOutputT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcAudioOutputT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Frees the list of available audio output modules.</summary>
        /// <param name="p_list">list with audio outputs for release</param>
        public static void LibvlcAudioOutputListRelease(global::libvlcpp.LibvlcAudioOutputT p_list)
        {
            var __arg0 = ReferenceEquals(p_list, null) ? global::System.IntPtr.Zero : p_list.__Instance;
            __Internal.LibvlcAudioOutputListRelease(__arg0);
        }

        /// <summary>Selects an audio output module.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="psz_name">
        /// <para>name of audio output,</para>
        /// <para>use psz_name of</para>
        /// </param>
        /// <returns>0 if function succeeded, -1 on error</returns>
        /// <remarks>
        /// <para>Any change will take be effect only after playback is stopped and</para>
        /// <para>restarted. Audio output cannot be changed while playing.</para>
        /// <para>libvlc_audio_output_t</para>
        /// </remarks>
        public static int LibvlcAudioOutputSet(global::libvlcpp.LibvlcMediaPlayerT p_mi, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioOutputSet(__arg0, psz_name);
            return __ret;
        }

        /// <summary>Gets a list of potential audio output devices,</summary>
        /// <param name="mp">media player</param>
        /// <returns>
        /// <para>A NULL-terminated linked list of potential audio output devices.</para>
        /// <para>It must be freed with libvlc_audio_output_device_list_release()</para>
        /// </returns>
        /// <remarks>
        /// <para>libvlc_audio_output_device_set().</para>
        /// <para>Not all audio outputs support enumerating devices.</para>
        /// <para>The audio output may be functional even if the list is empty (NULL).</para>
        /// <para>The list may not be exhaustive.</para>
        /// <para>Some audio output devices in the list might not actually work in</para>
        /// <para>some circumstances. By default, it is recommended to not specify any</para>
        /// <para>explicit audio device.</para>
        /// <para>LibVLC 2.2.0 or later.</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcAudioOutputDeviceT LibvlcAudioOutputDeviceEnum(global::libvlcpp.LibvlcMediaPlayerT mp)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            var __ret = __Internal.LibvlcAudioOutputDeviceEnum(__arg0);
            global::libvlcpp.LibvlcAudioOutputDeviceT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcAudioOutputDeviceT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcAudioOutputDeviceT) global::libvlcpp.LibvlcAudioOutputDeviceT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcAudioOutputDeviceT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Gets a list of audio output devices for a given audio output module,</summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <param name="aout">
        /// <para>audio output name</para>
        /// <para>(as returned by libvlc_audio_output_list_get())</para>
        /// </param>
        /// <returns>
        /// <para>A NULL-terminated linked list of potential audio output devices.</para>
        /// <para>It must be freed with libvlc_audio_output_device_list_release()</para>
        /// </returns>
        /// <remarks>
        /// <para>libvlc_audio_output_device_set().</para>
        /// <para>Not all audio outputs support this. In particular, an empty (NULL)</para>
        /// <para>list of devices doesnotimply that the specified audio output does</para>
        /// <para>not work.</para>
        /// <para>The list might not be exhaustive.</para>
        /// <para>Some audio output devices in the list might not actually work in</para>
        /// <para>some circumstances. By default, it is recommended to not specify any</para>
        /// <para>explicit audio device.</para>
        /// <para>LibVLC 2.1.0 or later.</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcAudioOutputDeviceT LibvlcAudioOutputDeviceListGet(global::libvlcpp.LibvlcInstanceT p_instance, string aout)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcAudioOutputDeviceListGet(__arg0, aout);
            global::libvlcpp.LibvlcAudioOutputDeviceT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcAudioOutputDeviceT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcAudioOutputDeviceT) global::libvlcpp.LibvlcAudioOutputDeviceT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcAudioOutputDeviceT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Frees a list of available audio output devices.</summary>
        /// <param name="p_list">list with audio outputs for release</param>
        /// <remarks>LibVLC 2.1.0 or later.</remarks>
        public static void LibvlcAudioOutputDeviceListRelease(global::libvlcpp.LibvlcAudioOutputDeviceT p_list)
        {
            var __arg0 = ReferenceEquals(p_list, null) ? global::System.IntPtr.Zero : p_list.__Instance;
            __Internal.LibvlcAudioOutputDeviceListRelease(__arg0);
        }

        /// <summary>Configures an explicit audio output device.</summary>
        /// <param name="mp">media player</param>
        /// <param name="module">
        /// <para>If NULL, current audio output module.</para>
        /// <para>if non-NULL, name of audio output module</para>
        /// <para>(</para>
        /// </param>
        /// <param name="device_id">device identifier string</param>
        /// <returns>Nothing. Errors are ignored (this is a design bug).</returns>
        /// <remarks>
        /// <para>If the module paramater is NULL, audio output will be moved to the device</para>
        /// <para>specified by the device identifier string immediately. This is the</para>
        /// <para>recommended usage.</para>
        /// <para>A list of adequate potential device strings can be obtained with</para>
        /// <para>libvlc_audio_output_device_enum().</para>
        /// <para>However passing NULL is supported in LibVLC version 2.2.0 and later only;</para>
        /// <para>in earlier versions, this function would have no effects when the module</para>
        /// <para>parameter was NULL.</para>
        /// <para>If the module parameter is not NULL, the device parameter of the</para>
        /// <para>corresponding audio output, if it exists, will be set to the specified</para>
        /// <para>string. Note that some audio output modules do not have such a parameter</para>
        /// <para>(notably MMDevice and PulseAudio).</para>
        /// <para>A list of adequate potential device strings can be obtained with</para>
        /// <para>libvlc_audio_output_device_list_get().</para>
        /// <para>This function does not select the specified audio output plugin.</para>
        /// <para>libvlc_audio_output_set() is used for that purpose.</para>
        /// <para>The syntax for the device parameter depends on the audio output.</para>
        /// <para>Some audio output modules require further parameters (e.g. a channels map</para>
        /// <para>in the case of ALSA).</para>
        /// <para>libvlc_audio_output_t)</para>
        /// </remarks>
        public static void LibvlcAudioOutputDeviceSet(global::libvlcpp.LibvlcMediaPlayerT mp, string module, string device_id)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            __Internal.LibvlcAudioOutputDeviceSet(__arg0, module, device_id);
        }

        /// <summary>Get the current audio output device identifier.</summary>
        /// <param name="mp">media player</param>
        /// <returns>
        /// <para>the current audio output device identifier</para>
        /// <para>NULL if no device is selected or in case of error</para>
        /// <para>(the result must be released with free() or libvlc_free()).</para>
        /// </returns>
        /// <remarks>
        /// <para>This complements libvlc_audio_output_device_set().</para>
        /// <para>The initial value for the current audio output device identifier</para>
        /// <para>may not be set or may be some unknown value. A LibVLC application should</para>
        /// <para>compare this value against the known device identifiers (e.g. those that</para>
        /// <para>were previously retrieved by a call to libvlc_audio_output_device_enum or</para>
        /// <para>libvlc_audio_output_device_list_get) to find the current audio output device.</para>
        /// <para>It is possible that the selected audio output device changes (an external</para>
        /// <para>change) without a call to libvlc_audio_output_device_set. That may make this</para>
        /// <para>method unsuitable to use if a LibVLC application is attempting to track</para>
        /// <para>dynamic audio device changes as they happen.</para>
        /// <para>LibVLC 3.0.0 or later.</para>
        /// </remarks>
        public static sbyte* LibvlcAudioOutputDeviceGet(global::libvlcpp.LibvlcMediaPlayerT mp)
        {
            var __arg0 = ReferenceEquals(mp, null) ? global::System.IntPtr.Zero : mp.__Instance;
            var __ret = __Internal.LibvlcAudioOutputDeviceGet(__arg0);
            return __ret;
        }

        /// <summary>Toggle mute status.</summary>
        /// <param name="p_mi">media player</param>
        /// <remarks>
        /// <para>Toggling mute atomically is not always possible: On some platforms,</para>
        /// <para>other processes can mute the VLC audio playback stream asynchronously. Thus,</para>
        /// <para>there is a small race condition where toggling will not work.</para>
        /// <para>See also the limitations of libvlc_audio_set_mute().</para>
        /// </remarks>
        public static void LibvlcAudioToggleMute(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcAudioToggleMute(__arg0);
        }

        /// <summary>Get current mute status.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>the mute status (boolean) if defined, -1 if undefined/unapplicable</returns>
        public static int LibvlcAudioGetMute(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioGetMute(__arg0);
            return __ret;
        }

        /// <summary>Set mute status.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="status">If status is true then mute, otherwise unmute</param>
        /// <remarks>
        /// <para>This function does not always work. If there are no active audio</para>
        /// <para>playback stream, the mute status might not be available. If digital</para>
        /// <para>pass-through (S/PDIF, HDMI...) is in use, muting may be unapplicable. Also</para>
        /// <para>some audio output plugins do not support muting at all.</para>
        /// <para>To force silent playback, disable all audio tracks. This is more</para>
        /// <para>efficient and reliable than mute.</para>
        /// </remarks>
        public static void LibvlcAudioSetMute(global::libvlcpp.LibvlcMediaPlayerT p_mi, int status)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcAudioSetMute(__arg0, status);
        }

        /// <summary>Get current software audio volume.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>
        /// <para>the software volume in percents</para>
        /// <para>(0 = mute, 100 = nominal / 0dB)</para>
        /// </returns>
        public static int LibvlcAudioGetVolume(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioGetVolume(__arg0);
            return __ret;
        }

        /// <summary>Set current software audio volume.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="i_volume">the volume in percents (0 = mute, 100 = 0dB)</param>
        /// <returns>0 if the volume was set, -1 if it was out of range</returns>
        public static int LibvlcAudioSetVolume(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_volume)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioSetVolume(__arg0, i_volume);
            return __ret;
        }

        /// <summary>Get number of available audio tracks.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>the number of available audio tracks (int), or -1 if unavailable</returns>
        public static int LibvlcAudioGetTrackCount(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioGetTrackCount(__arg0);
            return __ret;
        }

        /// <summary>Get the description of available audio tracks.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>
        /// <para>list with description of available audio tracks, or NULL.</para>
        /// <para>It must be freed with libvlc_track_description_list_release()</para>
        /// </returns>
        public static global::libvlcpp.LibvlcTrackDescriptionT LibvlcAudioGetTrackDescription(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioGetTrackDescription(__arg0);
            global::libvlcpp.LibvlcTrackDescriptionT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcTrackDescriptionT) global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcTrackDescriptionT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Get current audio track.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>the audio track ID or -1 if no active input.</returns>
        public static int LibvlcAudioGetTrack(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioGetTrack(__arg0);
            return __ret;
        }

        /// <summary>Set current audio track.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="i_track">the track ID (i_id field from track description)</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcAudioSetTrack(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_track)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioSetTrack(__arg0, i_track);
            return __ret;
        }

        /// <summary>Get current audio channel.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>the audio channel</returns>
        /// <remarks>libvlc_audio_output_channel_t</remarks>
        public static int LibvlcAudioGetChannel(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioGetChannel(__arg0);
            return __ret;
        }

        /// <summary>Set current audio channel.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="channel">the audio channel,</param>
        /// <returns>0 on success, -1 on error</returns>
        /// <remarks>libvlc_audio_output_channel_t</remarks>
        public static int LibvlcAudioSetChannel(global::libvlcpp.LibvlcMediaPlayerT p_mi, int channel)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioSetChannel(__arg0, channel);
            return __ret;
        }

        /// <summary>Get current audio delay.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>the audio delay (microseconds)</returns>
        /// <remarks>LibVLC 1.1.1 or later</remarks>
        public static long LibvlcAudioGetDelay(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioGetDelay(__arg0);
            return __ret;
        }

        /// <summary>Set current audio delay. The audio delay will be reset to zero each time the media changes.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="i_delay">the audio delay (microseconds)</param>
        /// <returns>0 on success, -1 on error</returns>
        /// <remarks>LibVLC 1.1.1 or later</remarks>
        public static int LibvlcAudioSetDelay(global::libvlcpp.LibvlcMediaPlayerT p_mi, long i_delay)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioSetDelay(__arg0, i_delay);
            return __ret;
        }

        /// <summary>Get the number of equalizer presets.</summary>
        /// <returns>number of presets</returns>
        /// <remarks>LibVLC 2.2.0 or later</remarks>
        public static uint LibvlcAudioEqualizerGetPresetCount()
        {
            var __ret = __Internal.LibvlcAudioEqualizerGetPresetCount();
            return __ret;
        }

        /// <summary>Get the name of a particular equalizer preset.</summary>
        /// <param name="u_index">index of the preset, counting from zero</param>
        /// <returns>preset name, or NULL if there is no such preset</returns>
        /// <remarks>
        /// <para>This name can be used, for example, to prepare a preset label or menu in a user</para>
        /// <para>interface.</para>
        /// <para>LibVLC 2.2.0 or later</para>
        /// </remarks>
        public static string LibvlcAudioEqualizerGetPresetName(uint u_index)
        {
            var __ret = __Internal.LibvlcAudioEqualizerGetPresetName(u_index);
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>Get the number of distinct frequency bands for an equalizer.</summary>
        /// <returns>number of frequency bands</returns>
        /// <remarks>LibVLC 2.2.0 or later</remarks>
        public static uint LibvlcAudioEqualizerGetBandCount()
        {
            var __ret = __Internal.LibvlcAudioEqualizerGetBandCount();
            return __ret;
        }

        /// <summary>Get a particular equalizer band frequency.</summary>
        /// <param name="u_index">index of the band, counting from zero</param>
        /// <returns>equalizer band frequency (Hz), or -1 if there is no such band</returns>
        /// <remarks>
        /// <para>This value can be used, for example, to create a label for an equalizer band control</para>
        /// <para>in a user interface.</para>
        /// <para>LibVLC 2.2.0 or later</para>
        /// </remarks>
        public static float LibvlcAudioEqualizerGetBandFrequency(uint u_index)
        {
            var __ret = __Internal.LibvlcAudioEqualizerGetBandFrequency(u_index);
            return __ret;
        }

        /// <summary>Create a new default equalizer, with all frequency values zeroed.</summary>
        /// <returns>opaque equalizer handle, or NULL on error</returns>
        /// <remarks>
        /// <para>The new equalizer can subsequently be applied to a media player by invoking</para>
        /// <para>libvlc_media_player_set_equalizer().</para>
        /// <para>The returned handle should be freed via libvlc_audio_equalizer_release() when</para>
        /// <para>it is no longer needed.</para>
        /// <para>LibVLC 2.2.0 or later</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcEqualizerT LibvlcAudioEqualizerNew()
        {
            var __ret = __Internal.LibvlcAudioEqualizerNew();
            global::libvlcpp.LibvlcEqualizerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEqualizerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEqualizerT) global::libvlcpp.LibvlcEqualizerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEqualizerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Create a new equalizer, with initial frequency values copied from an existing</para>
        /// <para>preset.</para>
        /// </summary>
        /// <param name="u_index">index of the preset, counting from zero</param>
        /// <returns>opaque equalizer handle, or NULL on error</returns>
        /// <remarks>
        /// <para>The new equalizer can subsequently be applied to a media player by invoking</para>
        /// <para>libvlc_media_player_set_equalizer().</para>
        /// <para>The returned handle should be freed via libvlc_audio_equalizer_release() when</para>
        /// <para>it is no longer needed.</para>
        /// <para>LibVLC 2.2.0 or later</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcEqualizerT LibvlcAudioEqualizerNewFromPreset(uint u_index)
        {
            var __ret = __Internal.LibvlcAudioEqualizerNewFromPreset(u_index);
            global::libvlcpp.LibvlcEqualizerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEqualizerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEqualizerT) global::libvlcpp.LibvlcEqualizerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEqualizerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Release a previously created equalizer instance.</summary>
        /// <param name="p_equalizer">opaque equalizer handle, or NULL</param>
        /// <remarks>
        /// <para>The equalizer was previously created by using libvlc_audio_equalizer_new() or</para>
        /// <para>libvlc_audio_equalizer_new_from_preset().</para>
        /// <para>It is safe to invoke this method with a NULL p_equalizer parameter for no effect.</para>
        /// <para>LibVLC 2.2.0 or later</para>
        /// </remarks>
        public static void LibvlcAudioEqualizerRelease(global::libvlcpp.LibvlcEqualizerT p_equalizer)
        {
            var __arg0 = ReferenceEquals(p_equalizer, null) ? global::System.IntPtr.Zero : p_equalizer.__Instance;
            __Internal.LibvlcAudioEqualizerRelease(__arg0);
        }

        /// <summary>Set a new pre-amplification value for an equalizer.</summary>
        /// <param name="p_equalizer">valid equalizer handle, must not be NULL</param>
        /// <param name="f_preamp">preamp value (-20.0 to 20.0 Hz)</param>
        /// <returns>zero on success, -1 on error</returns>
        /// <remarks>
        /// <para>The new equalizer settings are subsequently applied to a media player by invoking</para>
        /// <para>libvlc_media_player_set_equalizer().</para>
        /// <para>The supplied amplification value will be clamped to the -20.0 to +20.0 range.</para>
        /// <para>LibVLC 2.2.0 or later</para>
        /// </remarks>
        public static int LibvlcAudioEqualizerSetPreamp(global::libvlcpp.LibvlcEqualizerT p_equalizer, float f_preamp)
        {
            var __arg0 = ReferenceEquals(p_equalizer, null) ? global::System.IntPtr.Zero : p_equalizer.__Instance;
            var __ret = __Internal.LibvlcAudioEqualizerSetPreamp(__arg0, f_preamp);
            return __ret;
        }

        /// <summary>Get the current pre-amplification value from an equalizer.</summary>
        /// <param name="p_equalizer">valid equalizer handle, must not be NULL</param>
        /// <returns>preamp value (Hz)</returns>
        /// <remarks>LibVLC 2.2.0 or later</remarks>
        public static float LibvlcAudioEqualizerGetPreamp(global::libvlcpp.LibvlcEqualizerT p_equalizer)
        {
            var __arg0 = ReferenceEquals(p_equalizer, null) ? global::System.IntPtr.Zero : p_equalizer.__Instance;
            var __ret = __Internal.LibvlcAudioEqualizerGetPreamp(__arg0);
            return __ret;
        }

        /// <summary>Set a new amplification value for a particular equalizer frequency band.</summary>
        /// <param name="p_equalizer">valid equalizer handle, must not be NULL</param>
        /// <param name="f_amp">amplification value (-20.0 to 20.0 Hz)</param>
        /// <param name="u_band">index, counting from zero, of the frequency band to set</param>
        /// <returns>zero on success, -1 on error</returns>
        /// <remarks>
        /// <para>The new equalizer settings are subsequently applied to a media player by invoking</para>
        /// <para>libvlc_media_player_set_equalizer().</para>
        /// <para>The supplied amplification value will be clamped to the -20.0 to +20.0 range.</para>
        /// <para>LibVLC 2.2.0 or later</para>
        /// </remarks>
        public static int LibvlcAudioEqualizerSetAmpAtIndex(global::libvlcpp.LibvlcEqualizerT p_equalizer, float f_amp, uint u_band)
        {
            var __arg0 = ReferenceEquals(p_equalizer, null) ? global::System.IntPtr.Zero : p_equalizer.__Instance;
            var __ret = __Internal.LibvlcAudioEqualizerSetAmpAtIndex(__arg0, f_amp, u_band);
            return __ret;
        }

        /// <summary>Get the amplification value for a particular equalizer frequency band.</summary>
        /// <param name="p_equalizer">valid equalizer handle, must not be NULL</param>
        /// <param name="u_band">index, counting from zero, of the frequency band to get</param>
        /// <returns>amplification value (Hz); NaN if there is no such frequency band</returns>
        /// <remarks>LibVLC 2.2.0 or later</remarks>
        public static float LibvlcAudioEqualizerGetAmpAtIndex(global::libvlcpp.LibvlcEqualizerT p_equalizer, uint u_band)
        {
            var __arg0 = ReferenceEquals(p_equalizer, null) ? global::System.IntPtr.Zero : p_equalizer.__Instance;
            var __ret = __Internal.LibvlcAudioEqualizerGetAmpAtIndex(__arg0, u_band);
            return __ret;
        }

        /// <summary>Apply new equalizer settings to a media player.</summary>
        /// <param name="p_mi">opaque media player handle</param>
        /// <param name="p_equalizer">opaque equalizer handle, or NULL to disable the equalizer for this media player</param>
        /// <returns>zero on success, -1 on error</returns>
        /// <remarks>
        /// <para>The equalizer is first created by invoking libvlc_audio_equalizer_new() or</para>
        /// <para>libvlc_audio_equalizer_new_from_preset().</para>
        /// <para>It is possible to apply new equalizer settings to a media player whether the media</para>
        /// <para>player is currently playing media or not.</para>
        /// <para>Invoking this method will immediately apply the new equalizer settings to the audio</para>
        /// <para>output of the currently playing media if there is any.</para>
        /// <para>If there is no currently playing media, the new equalizer settings will be applied</para>
        /// <para>later if and when new media is played.</para>
        /// <para>Equalizer settings will automatically be applied to subsequently played media.</para>
        /// <para>To disable the equalizer for a media player invoke this method passing NULL for the</para>
        /// <para>p_equalizer parameter.</para>
        /// <para>The media player does not keep a reference to the supplied equalizer so it is safe</para>
        /// <para>for an application to release the equalizer reference any time after this method</para>
        /// <para>returns.</para>
        /// <para>LibVLC 2.2.0 or later</para>
        /// </remarks>
        public static int LibvlcMediaPlayerSetEqualizer(global::libvlcpp.LibvlcMediaPlayerT p_mi, global::libvlcpp.LibvlcEqualizerT p_equalizer)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __arg1 = ReferenceEquals(p_equalizer, null) ? global::System.IntPtr.Zero : p_equalizer.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerSetEqualizer(__arg0, __arg1);
            return __ret;
        }

        /// <summary>Gets the media role.</summary>
        /// <param name="p_mi">media player</param>
        /// <returns>the media player role (</returns>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static int LibvlcMediaPlayerGetRole(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetRole(__arg0);
            return __ret;
        }

        /// <summary>Sets the media role.</summary>
        /// <param name="p_mi">media player</param>
        /// <param name="role">the media player role (</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcMediaPlayerSetRole(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint role)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerSetRole(__arg0, role);
            return __ret;
        }
    }

    /// <summary>A LibVLC media list holds multiple</summary>
    /// <remarks>
    /// <para>@{</para>
    /// <para></para>
    /// <para>LibVLC media list (playlist) external API</para>
    /// </remarks>
    public unsafe partial class libvlc_media_list
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_new")]
            internal static extern global::System.IntPtr LibvlcMediaListNew(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_release")]
            internal static extern void LibvlcMediaListRelease(global::System.IntPtr p_ml);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_retain")]
            internal static extern void LibvlcMediaListRetain(global::System.IntPtr p_ml);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_set_media")]
            internal static extern void LibvlcMediaListSetMedia(global::System.IntPtr p_ml, global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_media")]
            internal static extern global::System.IntPtr LibvlcMediaListMedia(global::System.IntPtr p_ml);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_add_media")]
            internal static extern int LibvlcMediaListAddMedia(global::System.IntPtr p_ml, global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_insert_media")]
            internal static extern int LibvlcMediaListInsertMedia(global::System.IntPtr p_ml, global::System.IntPtr p_md, int i_pos);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_remove_index")]
            internal static extern int LibvlcMediaListRemoveIndex(global::System.IntPtr p_ml, int i_pos);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_count")]
            internal static extern int LibvlcMediaListCount(global::System.IntPtr p_ml);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_item_at_index")]
            internal static extern global::System.IntPtr LibvlcMediaListItemAtIndex(global::System.IntPtr p_ml, int i_pos);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_index_of_item")]
            internal static extern int LibvlcMediaListIndexOfItem(global::System.IntPtr p_ml, global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_is_readonly")]
            internal static extern int LibvlcMediaListIsReadonly(global::System.IntPtr p_ml);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_lock")]
            internal static extern void LibvlcMediaListLock(global::System.IntPtr p_ml);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_unlock")]
            internal static extern void LibvlcMediaListUnlock(global::System.IntPtr p_ml);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_event_manager")]
            internal static extern global::System.IntPtr LibvlcMediaListEventManager(global::System.IntPtr p_ml);
        }

        /// <summary>Create an empty media list.</summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <returns>empty media list, or NULL on error</returns>
        public static global::libvlcpp.LibvlcMediaListT LibvlcMediaListNew(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcMediaListNew(__arg0);
            global::libvlcpp.LibvlcMediaListT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaListT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaListT) global::libvlcpp.LibvlcMediaListT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaListT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Release media list created with libvlc_media_list_new().</summary>
        /// <param name="p_ml">a media list created with libvlc_media_list_new()</param>
        public static void LibvlcMediaListRelease(global::libvlcpp.LibvlcMediaListT p_ml)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            __Internal.LibvlcMediaListRelease(__arg0);
        }

        /// <summary>Retain reference to a media list</summary>
        /// <param name="p_ml">a media list created with libvlc_media_list_new()</param>
        public static void LibvlcMediaListRetain(global::libvlcpp.LibvlcMediaListT p_ml)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            __Internal.LibvlcMediaListRetain(__arg0);
        }

        /// <summary>
        /// <para>Associate media instance with this media list instance.</para>
        /// <para>If another media instance was present it will be released.</para>
        /// <para>The libvlc_media_list_lock should NOT be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <param name="p_md">media instance to add</param>
        public static void LibvlcMediaListSetMedia(global::libvlcpp.LibvlcMediaListT p_ml, global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __arg1 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaListSetMedia(__arg0, __arg1);
        }

        /// <summary>
        /// <para>Get media instance from this media list instance. This action will increase</para>
        /// <para>the refcount on the media instance.</para>
        /// <para>The libvlc_media_list_lock should NOT be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <returns>media instance</returns>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaListMedia(global::libvlcpp.LibvlcMediaListT p_ml)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __ret = __Internal.LibvlcMediaListMedia(__arg0);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Add media instance to media list</para>
        /// <para>The libvlc_media_list_lock should be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <param name="p_md">a media instance</param>
        /// <returns>0 on success, -1 if the media list is read-only</returns>
        public static int LibvlcMediaListAddMedia(global::libvlcpp.LibvlcMediaListT p_ml, global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __arg1 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaListAddMedia(__arg0, __arg1);
            return __ret;
        }

        /// <summary>
        /// <para>Insert media instance in media list on a position</para>
        /// <para>The libvlc_media_list_lock should be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <param name="p_md">a media instance</param>
        /// <param name="i_pos">position in array where to insert</param>
        /// <returns>0 on success, -1 if the media list is read-only</returns>
        public static int LibvlcMediaListInsertMedia(global::libvlcpp.LibvlcMediaListT p_ml, global::libvlcpp.LibvlcMediaT p_md, int i_pos)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __arg1 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaListInsertMedia(__arg0, __arg1, i_pos);
            return __ret;
        }

        /// <summary>
        /// <para>Remove media instance from media list on a position</para>
        /// <para>The libvlc_media_list_lock should be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <param name="i_pos">position in array where to insert</param>
        /// <returns>0 on success, -1 if the list is read-only or the item was not found</returns>
        public static int LibvlcMediaListRemoveIndex(global::libvlcpp.LibvlcMediaListT p_ml, int i_pos)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __ret = __Internal.LibvlcMediaListRemoveIndex(__arg0, i_pos);
            return __ret;
        }

        /// <summary>
        /// <para>Get count on media list items</para>
        /// <para>The libvlc_media_list_lock should be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <returns>number of items in media list</returns>
        public static int LibvlcMediaListCount(global::libvlcpp.LibvlcMediaListT p_ml)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __ret = __Internal.LibvlcMediaListCount(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>List media instance in media list at a position</para>
        /// <para>The libvlc_media_list_lock should be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <param name="i_pos">position in array where to insert</param>
        /// <returns>
        /// <para>media instance at position i_pos, or NULL if not found.</para>
        /// <para>In case of success, libvlc_media_retain() is called to increase the refcount</para>
        /// <para>on the media.</para>
        /// </returns>
        public static global::libvlcpp.LibvlcMediaT LibvlcMediaListItemAtIndex(global::libvlcpp.LibvlcMediaListT p_ml, int i_pos)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __ret = __Internal.LibvlcMediaListItemAtIndex(__arg0, i_pos);
            global::libvlcpp.LibvlcMediaT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaT) global::libvlcpp.LibvlcMediaT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Find index position of List media instance in media list.</para>
        /// <para>Warning: the function will return the first matched position.</para>
        /// <para>The libvlc_media_list_lock should be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <param name="p_md">media instance</param>
        /// <returns>position of media instance or -1 if media not found</returns>
        public static int LibvlcMediaListIndexOfItem(global::libvlcpp.LibvlcMediaListT p_ml, global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __arg1 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaListIndexOfItem(__arg0, __arg1);
            return __ret;
        }

        /// <summary>This indicates if this media list is read-only from a user point of view</summary>
        /// <param name="p_ml">media list instance</param>
        /// <returns>1 on readonly, 0 on readwrite</returns>
        public static int LibvlcMediaListIsReadonly(global::libvlcpp.LibvlcMediaListT p_ml)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __ret = __Internal.LibvlcMediaListIsReadonly(__arg0);
            return __ret;
        }

        /// <summary>Get lock on media list items</summary>
        /// <param name="p_ml">a media list instance</param>
        public static void LibvlcMediaListLock(global::libvlcpp.LibvlcMediaListT p_ml)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            __Internal.LibvlcMediaListLock(__arg0);
        }

        /// <summary>
        /// <para>Release lock on media list items</para>
        /// <para>The libvlc_media_list_lock should be held upon entering this function.</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        public static void LibvlcMediaListUnlock(global::libvlcpp.LibvlcMediaListT p_ml)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            __Internal.LibvlcMediaListUnlock(__arg0);
        }

        /// <summary>
        /// <para>Get libvlc_event_manager from this media list instance.</para>
        /// <para>The p_event_manager is immutable, so you don't have to hold the lock</para>
        /// </summary>
        /// <param name="p_ml">a media list instance</param>
        /// <returns>libvlc_event_manager</returns>
        public static global::libvlcpp.LibvlcEventManagerT LibvlcMediaListEventManager(global::libvlcpp.LibvlcMediaListT p_ml)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __ret = __Internal.LibvlcMediaListEventManager(__arg0);
            global::libvlcpp.LibvlcEventManagerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEventManagerT) global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEventManagerT.__CreateInstance(__ret);
            return __result0;
        }
    }

    /// <summary>Defines playback modes for playlist.</summary>
    public enum LibvlcPlaybackModeT
    {
        LibvlcPlaybackModeDefault = 0,
        LibvlcPlaybackModeLoop = 1,
        LibvlcPlaybackModeRepeat = 2
    }

    /// <summary>The LibVLC media list player plays a</summary>
    /// <remarks>
    /// <para>in a certain order.</para>
    /// <para>This is required to especially support playlist files.</para>
    /// <para>The normal</para>
    /// <para>single media, and does not handle playlist files properly.</para>
    /// <para>@{</para>
    /// <para></para>
    /// <para>LibVLC media list player external API</para>
    /// </remarks>
    public unsafe partial class LibvlcMediaListPlayerT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaListPlayerT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaListPlayerT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaListPlayerT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaListPlayerT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaListPlayerT __CreateInstance(global::libvlcpp.LibvlcMediaListPlayerT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaListPlayerT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaListPlayerT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaListPlayerT.__Internal));
            *(global::libvlcpp.LibvlcMediaListPlayerT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaListPlayerT(global::libvlcpp.LibvlcMediaListPlayerT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaListPlayerT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class libvlc_media_list_player
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_new")]
            internal static extern global::System.IntPtr LibvlcMediaListPlayerNew(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_release")]
            internal static extern void LibvlcMediaListPlayerRelease(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_retain")]
            internal static extern void LibvlcMediaListPlayerRetain(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_event_manager")]
            internal static extern global::System.IntPtr LibvlcMediaListPlayerEventManager(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_set_media_player")]
            internal static extern void LibvlcMediaListPlayerSetMediaPlayer(global::System.IntPtr p_mlp, global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_get_media_player")]
            internal static extern global::System.IntPtr LibvlcMediaListPlayerGetMediaPlayer(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_set_media_list")]
            internal static extern void LibvlcMediaListPlayerSetMediaList(global::System.IntPtr p_mlp, global::System.IntPtr p_mlist);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_play")]
            internal static extern void LibvlcMediaListPlayerPlay(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_pause")]
            internal static extern void LibvlcMediaListPlayerPause(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_is_playing")]
            internal static extern int LibvlcMediaListPlayerIsPlaying(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_get_state")]
            internal static extern global::libvlcpp.LibvlcStateT LibvlcMediaListPlayerGetState(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_play_item_at_index")]
            internal static extern int LibvlcMediaListPlayerPlayItemAtIndex(global::System.IntPtr p_mlp, int i_index);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_play_item")]
            internal static extern int LibvlcMediaListPlayerPlayItem(global::System.IntPtr p_mlp, global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_stop")]
            internal static extern void LibvlcMediaListPlayerStop(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_next")]
            internal static extern int LibvlcMediaListPlayerNext(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_previous")]
            internal static extern int LibvlcMediaListPlayerPrevious(global::System.IntPtr p_mlp);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_player_set_playback_mode")]
            internal static extern void LibvlcMediaListPlayerSetPlaybackMode(global::System.IntPtr p_mlp, global::libvlcpp.LibvlcPlaybackModeT e_mode);
        }

        /// <summary>Create new media_list_player.</summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <returns>media list player instance or NULL on error</returns>
        public static global::libvlcpp.LibvlcMediaListPlayerT LibvlcMediaListPlayerNew(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerNew(__arg0);
            global::libvlcpp.LibvlcMediaListPlayerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaListPlayerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaListPlayerT) global::libvlcpp.LibvlcMediaListPlayerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaListPlayerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Release a media_list_player after use</para>
        /// <para>Decrement the reference count of a media player object. If the</para>
        /// <para>reference count is 0, then libvlc_media_list_player_release() will</para>
        /// <para>release the media player object. If the media player object</para>
        /// <para>has been released, then it should not be used again.</para>
        /// </summary>
        /// <param name="p_mlp">media list player instance</param>
        public static void LibvlcMediaListPlayerRelease(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            __Internal.LibvlcMediaListPlayerRelease(__arg0);
        }

        /// <summary>
        /// <para>Retain a reference to a media player list object. Use</para>
        /// <para>libvlc_media_list_player_release() to decrement reference count.</para>
        /// </summary>
        /// <param name="p_mlp">media player list object</param>
        public static void LibvlcMediaListPlayerRetain(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            __Internal.LibvlcMediaListPlayerRetain(__arg0);
        }

        /// <summary>Return the event manager of this media_list_player.</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <returns>the event manager</returns>
        public static global::libvlcpp.LibvlcEventManagerT LibvlcMediaListPlayerEventManager(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerEventManager(__arg0);
            global::libvlcpp.LibvlcEventManagerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEventManagerT) global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEventManagerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Replace media player in media_list_player with this instance.</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <param name="p_mi">media player instance</param>
        public static void LibvlcMediaListPlayerSetMediaPlayer(global::libvlcpp.LibvlcMediaListPlayerT p_mlp, global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __arg1 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaListPlayerSetMediaPlayer(__arg0, __arg1);
        }

        /// <summary>Get media player of the media_list_player instance.</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <returns>media player instance</returns>
        /// <remarks>the caller is responsible for releasing the returned instance</remarks>
        public static global::libvlcpp.LibvlcMediaPlayerT LibvlcMediaListPlayerGetMediaPlayer(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerGetMediaPlayer(__arg0);
            global::libvlcpp.LibvlcMediaPlayerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaPlayerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaPlayerT) global::libvlcpp.LibvlcMediaPlayerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaPlayerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Set the media list associated with the player</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <param name="p_mlist">list of media</param>
        public static void LibvlcMediaListPlayerSetMediaList(global::libvlcpp.LibvlcMediaListPlayerT p_mlp, global::libvlcpp.LibvlcMediaListT p_mlist)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __arg1 = ReferenceEquals(p_mlist, null) ? global::System.IntPtr.Zero : p_mlist.__Instance;
            __Internal.LibvlcMediaListPlayerSetMediaList(__arg0, __arg1);
        }

        /// <summary>Play media list</summary>
        /// <param name="p_mlp">media list player instance</param>
        public static void LibvlcMediaListPlayerPlay(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            __Internal.LibvlcMediaListPlayerPlay(__arg0);
        }

        /// <summary>Toggle pause (or resume) media list</summary>
        /// <param name="p_mlp">media list player instance</param>
        public static void LibvlcMediaListPlayerPause(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            __Internal.LibvlcMediaListPlayerPause(__arg0);
        }

        /// <summary>Is media list playing?</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <returns>true for playing and false for not playing</returns>
        public static int LibvlcMediaListPlayerIsPlaying(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerIsPlaying(__arg0);
            return __ret;
        }

        /// <summary>Get current libvlc_state of media list player</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <returns>libvlc_state_t for media list player</returns>
        public static global::libvlcpp.LibvlcStateT LibvlcMediaListPlayerGetState(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerGetState(__arg0);
            return __ret;
        }

        /// <summary>Play media list item at position index</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <param name="i_index">index in media list to play</param>
        /// <returns>0 upon success -1 if the item wasn't found</returns>
        public static int LibvlcMediaListPlayerPlayItemAtIndex(global::libvlcpp.LibvlcMediaListPlayerT p_mlp, int i_index)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerPlayItemAtIndex(__arg0, i_index);
            return __ret;
        }

        /// <summary>Play the given media item</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <param name="p_md">the media instance</param>
        /// <returns>0 upon success, -1 if the media is not part of the media list</returns>
        public static int LibvlcMediaListPlayerPlayItem(global::libvlcpp.LibvlcMediaListPlayerT p_mlp, global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __arg1 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerPlayItem(__arg0, __arg1);
            return __ret;
        }

        /// <summary>Stop playing media list</summary>
        /// <param name="p_mlp">media list player instance</param>
        public static void LibvlcMediaListPlayerStop(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            __Internal.LibvlcMediaListPlayerStop(__arg0);
        }

        /// <summary>Play next item from media list</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <returns>0 upon success -1 if there is no next item</returns>
        public static int LibvlcMediaListPlayerNext(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerNext(__arg0);
            return __ret;
        }

        /// <summary>Play previous item from media list</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <returns>0 upon success -1 if there is no previous item</returns>
        public static int LibvlcMediaListPlayerPrevious(global::libvlcpp.LibvlcMediaListPlayerT p_mlp)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            var __ret = __Internal.LibvlcMediaListPlayerPrevious(__arg0);
            return __ret;
        }

        /// <summary>Sets the playback mode for the playlist</summary>
        /// <param name="p_mlp">media list player instance</param>
        /// <param name="e_mode">playback mode specification</param>
        public static void LibvlcMediaListPlayerSetPlaybackMode(global::libvlcpp.LibvlcMediaListPlayerT p_mlp, global::libvlcpp.LibvlcPlaybackModeT e_mode)
        {
            var __arg0 = ReferenceEquals(p_mlp, null) ? global::System.IntPtr.Zero : p_mlp.__Instance;
            __Internal.LibvlcMediaListPlayerSetPlaybackMode(__arg0, e_mode);
        }
    }

    /// <summary>
    /// <para>@{</para>
    /// <para></para>
    /// <para>LibVLC media library external API</para>
    /// </summary>
    public unsafe partial class LibvlcMediaLibraryT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaLibraryT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaLibraryT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaLibraryT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaLibraryT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaLibraryT __CreateInstance(global::libvlcpp.LibvlcMediaLibraryT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaLibraryT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaLibraryT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaLibraryT.__Internal));
            *(global::libvlcpp.LibvlcMediaLibraryT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaLibraryT(global::libvlcpp.LibvlcMediaLibraryT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaLibraryT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class libvlc_media_library
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_library_new")]
            internal static extern global::System.IntPtr LibvlcMediaLibraryNew(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_library_release")]
            internal static extern void LibvlcMediaLibraryRelease(global::System.IntPtr p_mlib);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_library_retain")]
            internal static extern void LibvlcMediaLibraryRetain(global::System.IntPtr p_mlib);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_library_load")]
            internal static extern int LibvlcMediaLibraryLoad(global::System.IntPtr p_mlib);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_library_media_list")]
            internal static extern global::System.IntPtr LibvlcMediaLibraryMediaList(global::System.IntPtr p_mlib);
        }

        /// <summary>Create an new Media Library object</summary>
        /// <param name="p_instance">the libvlc instance</param>
        /// <returns>a new object or NULL on error</returns>
        public static global::libvlcpp.LibvlcMediaLibraryT LibvlcMediaLibraryNew(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcMediaLibraryNew(__arg0);
            global::libvlcpp.LibvlcMediaLibraryT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaLibraryT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaLibraryT) global::libvlcpp.LibvlcMediaLibraryT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaLibraryT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Release media library object. This functions decrements the</para>
        /// <para>reference count of the media library object. If it reaches 0,</para>
        /// <para>then the object will be released.</para>
        /// </summary>
        /// <param name="p_mlib">media library object</param>
        public static void LibvlcMediaLibraryRelease(global::libvlcpp.LibvlcMediaLibraryT p_mlib)
        {
            var __arg0 = ReferenceEquals(p_mlib, null) ? global::System.IntPtr.Zero : p_mlib.__Instance;
            __Internal.LibvlcMediaLibraryRelease(__arg0);
        }

        /// <summary>
        /// <para>Retain a reference to a media library object. This function will</para>
        /// <para>increment the reference counting for this object. Use</para>
        /// <para>libvlc_media_library_release() to decrement the reference count.</para>
        /// </summary>
        /// <param name="p_mlib">media library object</param>
        public static void LibvlcMediaLibraryRetain(global::libvlcpp.LibvlcMediaLibraryT p_mlib)
        {
            var __arg0 = ReferenceEquals(p_mlib, null) ? global::System.IntPtr.Zero : p_mlib.__Instance;
            __Internal.LibvlcMediaLibraryRetain(__arg0);
        }

        /// <summary>Load media library.</summary>
        /// <param name="p_mlib">media library object</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcMediaLibraryLoad(global::libvlcpp.LibvlcMediaLibraryT p_mlib)
        {
            var __arg0 = ReferenceEquals(p_mlib, null) ? global::System.IntPtr.Zero : p_mlib.__Instance;
            var __ret = __Internal.LibvlcMediaLibraryLoad(__arg0);
            return __ret;
        }

        /// <summary>Get media library subitems.</summary>
        /// <param name="p_mlib">media library object</param>
        /// <returns>media list subitems</returns>
        public static global::libvlcpp.LibvlcMediaListT LibvlcMediaLibraryMediaList(global::libvlcpp.LibvlcMediaLibraryT p_mlib)
        {
            var __arg0 = ReferenceEquals(p_mlib, null) ? global::System.IntPtr.Zero : p_mlib.__Instance;
            var __ret = __Internal.LibvlcMediaLibraryMediaList(__arg0);
            global::libvlcpp.LibvlcMediaListT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaListT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaListT) global::libvlcpp.LibvlcMediaListT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaListT.__CreateInstance(__ret);
            return __result0;
        }
    }

    /// <summary>Category of a media discoverer</summary>
    /// <remarks>libvlc_media_discoverer_list_get()</remarks>
    public enum LibvlcMediaDiscovererCategoryT
    {
        /// <summary>devices, like portable music player</summary>
        LibvlcMediaDiscovererDevices = 0,
        /// <summary>LAN/WAN services, like Upnp, SMB, or SAP</summary>
        LibvlcMediaDiscovererLan = 1,
        /// <summary>Podcasts</summary>
        LibvlcMediaDiscovererPodcasts = 2,
        /// <summary>Local directories, like Video, Music or Pictures directories</summary>
        LibvlcMediaDiscovererLocaldirs = 3
    }

    /// <summary>
    /// <para>LibVLC media discovery finds available media via various means.</para>
    /// <para>This corresponds to the service discovery functionality in VLC media player.</para>
    /// <para>Different plugins find potential medias locally (e.g. user media directory),</para>
    /// <para>from peripherals (e.g. video capture device), on the local network</para>
    /// <para>(e.g. SAP) or on the Internet (e.g. Internet radios).</para>
    /// <para>@{</para>
    /// <para></para>
    /// <para>LibVLC media discovery external API</para>
    /// </summary>
    public unsafe partial class LibvlcMediaDiscovererT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaDiscovererT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaDiscovererT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaDiscovererT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaDiscovererT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaDiscovererT __CreateInstance(global::libvlcpp.LibvlcMediaDiscovererT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaDiscovererT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaDiscovererT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaDiscovererT.__Internal));
            *(global::libvlcpp.LibvlcMediaDiscovererT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaDiscovererT(global::libvlcpp.LibvlcMediaDiscovererT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaDiscovererT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    /// <summary>Media discoverer description</summary>
    /// <remarks>libvlc_media_discoverer_list_get()</remarks>
    public unsafe partial class LibvlcMediaDiscovererDescriptionT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 24)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr psz_name;

            [FieldOffset(8)]
            internal global::System.IntPtr psz_longname;

            [FieldOffset(16)]
            internal global::libvlcpp.LibvlcMediaDiscovererCategoryT i_cat;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_media_discoverer_description_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaDiscovererDescriptionT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcMediaDiscovererDescriptionT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcMediaDiscovererDescriptionT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaDiscovererDescriptionT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcMediaDiscovererDescriptionT __CreateInstance(global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcMediaDiscovererDescriptionT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal));
            *(global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcMediaDiscovererDescriptionT(global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcMediaDiscovererDescriptionT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcMediaDiscovererDescriptionT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcMediaDiscovererDescriptionT(global::libvlcpp.LibvlcMediaDiscovererDescriptionT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcMediaDiscovererDescriptionT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public sbyte* PszName
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) __Instance)->psz_name;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) __Instance)->psz_name = (global::System.IntPtr) value;
            }
        }

        public sbyte* PszLongname
        {
            get
            {
                return (sbyte*) ((global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) __Instance)->psz_longname;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) __Instance)->psz_longname = (global::System.IntPtr) value;
            }
        }

        public global::libvlcpp.LibvlcMediaDiscovererCategoryT ICat
        {
            get
            {
                return ((global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) __Instance)->i_cat;
            }

            set
            {
                ((global::libvlcpp.LibvlcMediaDiscovererDescriptionT.__Internal*) __Instance)->i_cat = value;
            }
        }
    }

    public unsafe partial class libvlc_media_discoverer
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_new")]
            internal static extern global::System.IntPtr LibvlcMediaDiscovererNew(global::System.IntPtr p_inst, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_start")]
            internal static extern int LibvlcMediaDiscovererStart(global::System.IntPtr p_mdis);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_stop")]
            internal static extern void LibvlcMediaDiscovererStop(global::System.IntPtr p_mdis);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_release")]
            internal static extern void LibvlcMediaDiscovererRelease(global::System.IntPtr p_mdis);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_media_list")]
            internal static extern global::System.IntPtr LibvlcMediaDiscovererMediaList(global::System.IntPtr p_mdis);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_is_running")]
            internal static extern int LibvlcMediaDiscovererIsRunning(global::System.IntPtr p_mdis);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_list_get")]
            internal static extern ulong LibvlcMediaDiscovererListGet(global::System.IntPtr p_inst, global::libvlcpp.LibvlcMediaDiscovererCategoryT i_cat, global::System.IntPtr ppp_services);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_list_release")]
            internal static extern void LibvlcMediaDiscovererListRelease(global::System.IntPtr pp_services, ulong i_count);
        }

        /// <summary>Create a media discoverer object by name.</summary>
        /// <param name="p_inst">libvlc instance</param>
        /// <param name="psz_name">
        /// <para>service name; use libvlc_media_discoverer_list_get() to get</para>
        /// <para>a list of the discoverer names available in this libVLC instance</para>
        /// </param>
        /// <returns>media discover object or NULL in case of error</returns>
        /// <remarks>
        /// <para>After this object is created, you should attach to media_list events in</para>
        /// <para>order to be notified of new items discovered.</para>
        /// <para>You need to call libvlc_media_discoverer_start() in order to start the</para>
        /// <para>discovery.</para>
        /// <para>libvlc_media_discoverer_media_list</para>
        /// <para>libvlc_media_discoverer_event_manager</para>
        /// <para>libvlc_media_discoverer_start</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcMediaDiscovererT LibvlcMediaDiscovererNew(global::libvlcpp.LibvlcInstanceT p_inst, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_inst, null) ? global::System.IntPtr.Zero : p_inst.__Instance;
            var __ret = __Internal.LibvlcMediaDiscovererNew(__arg0, psz_name);
            global::libvlcpp.LibvlcMediaDiscovererT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaDiscovererT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaDiscovererT) global::libvlcpp.LibvlcMediaDiscovererT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaDiscovererT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Start media discovery.</summary>
        /// <param name="p_mdis">media discover object</param>
        /// <returns>-1 in case of error, 0 otherwise</returns>
        /// <remarks>
        /// <para>To stop it, call libvlc_media_discoverer_stop() or</para>
        /// <para>libvlc_media_discoverer_list_release() directly.</para>
        /// <para>libvlc_media_discoverer_stop</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static int LibvlcMediaDiscovererStart(global::libvlcpp.LibvlcMediaDiscovererT p_mdis)
        {
            var __arg0 = ReferenceEquals(p_mdis, null) ? global::System.IntPtr.Zero : p_mdis.__Instance;
            var __ret = __Internal.LibvlcMediaDiscovererStart(__arg0);
            return __ret;
        }

        /// <summary>Stop media discovery.</summary>
        /// <param name="p_mdis">media discover object</param>
        /// <remarks>
        /// <para>libvlc_media_discoverer_start</para>
        /// <para>LibVLC 3.0.0 or later</para>
        /// </remarks>
        public static void LibvlcMediaDiscovererStop(global::libvlcpp.LibvlcMediaDiscovererT p_mdis)
        {
            var __arg0 = ReferenceEquals(p_mdis, null) ? global::System.IntPtr.Zero : p_mdis.__Instance;
            __Internal.LibvlcMediaDiscovererStop(__arg0);
        }

        /// <summary>
        /// <para>Release media discover object. If the reference count reaches 0, then</para>
        /// <para>the object will be released.</para>
        /// </summary>
        /// <param name="p_mdis">media service discover object</param>
        public static void LibvlcMediaDiscovererRelease(global::libvlcpp.LibvlcMediaDiscovererT p_mdis)
        {
            var __arg0 = ReferenceEquals(p_mdis, null) ? global::System.IntPtr.Zero : p_mdis.__Instance;
            __Internal.LibvlcMediaDiscovererRelease(__arg0);
        }

        /// <summary>Get media service discover media list.</summary>
        /// <param name="p_mdis">media service discover object</param>
        /// <returns>list of media items</returns>
        public static global::libvlcpp.LibvlcMediaListT LibvlcMediaDiscovererMediaList(global::libvlcpp.LibvlcMediaDiscovererT p_mdis)
        {
            var __arg0 = ReferenceEquals(p_mdis, null) ? global::System.IntPtr.Zero : p_mdis.__Instance;
            var __ret = __Internal.LibvlcMediaDiscovererMediaList(__arg0);
            global::libvlcpp.LibvlcMediaListT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaListT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaListT) global::libvlcpp.LibvlcMediaListT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaListT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Query if media service discover object is running.</summary>
        /// <param name="p_mdis">media service discover object</param>
        /// <returns>true if running, false if not</returns>
        public static int LibvlcMediaDiscovererIsRunning(global::libvlcpp.LibvlcMediaDiscovererT p_mdis)
        {
            var __arg0 = ReferenceEquals(p_mdis, null) ? global::System.IntPtr.Zero : p_mdis.__Instance;
            var __ret = __Internal.LibvlcMediaDiscovererIsRunning(__arg0);
            return __ret;
        }

        /// <summary>Get media discoverer services by category</summary>
        /// <param name="p_inst">libvlc instance</param>
        /// <param name="i_cat">category of services to fetch</param>
        /// <param name="ppp_services">
        /// <para>address to store an allocated array of media discoverer</para>
        /// <para>services (must be freed with libvlc_media_discoverer_list_release() by</para>
        /// <para>the caller) [OUT]</para>
        /// </param>
        /// <returns>the number of media discoverer services (0 on error)</returns>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static ulong LibvlcMediaDiscovererListGet(global::libvlcpp.LibvlcInstanceT p_inst, global::libvlcpp.LibvlcMediaDiscovererCategoryT i_cat, global::libvlcpp.LibvlcMediaDiscovererDescriptionT ppp_services)
        {
            var __arg0 = ReferenceEquals(p_inst, null) ? global::System.IntPtr.Zero : p_inst.__Instance;
            var __arg2 = ReferenceEquals(ppp_services, null) ? global::System.IntPtr.Zero : ppp_services.__Instance;
            var __ret = __Internal.LibvlcMediaDiscovererListGet(__arg0, i_cat, __arg2);
            return __ret;
        }

        /// <summary>Release an array of media discoverer services</summary>
        /// <param name="pp_services">array to release</param>
        /// <param name="i_count">number of elements in the array</param>
        /// <remarks>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// <para>libvlc_media_discoverer_list_get()</para>
        /// </remarks>
        public static void LibvlcMediaDiscovererListRelease(global::libvlcpp.LibvlcMediaDiscovererDescriptionT pp_services, ulong i_count)
        {
            var __arg0 = ReferenceEquals(pp_services, null) ? global::System.IntPtr.Zero : pp_services.__Instance;
            __Internal.LibvlcMediaDiscovererListRelease(__arg0, i_count);
        }
    }

    /// <summary>Event types</summary>
    public enum LibvlcEventE
    {
        LibvlcMediaMetaChanged = 0,
        LibvlcMediaSubItemAdded = 1,
        LibvlcMediaDurationChanged = 2,
        LibvlcMediaParsedChanged = 3,
        LibvlcMediaFreed = 4,
        LibvlcMediaStateChanged = 5,
        LibvlcMediaSubItemTreeAdded = 6,
        LibvlcMediaPlayerMediaChanged = 256,
        LibvlcMediaPlayerNothingSpecial = 257,
        LibvlcMediaPlayerOpening = 258,
        LibvlcMediaPlayerBuffering = 259,
        LibvlcMediaPlayerPlaying = 260,
        LibvlcMediaPlayerPaused = 261,
        LibvlcMediaPlayerStopped = 262,
        LibvlcMediaPlayerForward = 263,
        LibvlcMediaPlayerBackward = 264,
        LibvlcMediaPlayerEndReached = 265,
        LibvlcMediaPlayerEncounteredError = 266,
        LibvlcMediaPlayerTimeChanged = 267,
        LibvlcMediaPlayerPositionChanged = 268,
        LibvlcMediaPlayerSeekableChanged = 269,
        LibvlcMediaPlayerPausableChanged = 270,
        LibvlcMediaPlayerTitleChanged = 271,
        LibvlcMediaPlayerSnapshotTaken = 272,
        LibvlcMediaPlayerLengthChanged = 273,
        LibvlcMediaPlayerVout = 274,
        LibvlcMediaPlayerScrambledChanged = 275,
        LibvlcMediaPlayerESAdded = 276,
        LibvlcMediaPlayerESDeleted = 277,
        LibvlcMediaPlayerESSelected = 278,
        LibvlcMediaPlayerCorked = 279,
        LibvlcMediaPlayerUncorked = 280,
        LibvlcMediaPlayerMuted = 281,
        LibvlcMediaPlayerUnmuted = 282,
        LibvlcMediaPlayerAudioVolume = 283,
        LibvlcMediaPlayerAudioDevice = 284,
        LibvlcMediaPlayerChapterChanged = 285,
        LibvlcMediaListItemAdded = 512,
        LibvlcMediaListWillAddItem = 513,
        LibvlcMediaListItemDeleted = 514,
        LibvlcMediaListWillDeleteItem = 515,
        LibvlcMediaListEndReached = 516,
        LibvlcMediaListViewItemAdded = 768,
        LibvlcMediaListViewWillAddItem = 769,
        LibvlcMediaListViewItemDeleted = 770,
        LibvlcMediaListViewWillDeleteItem = 771,
        LibvlcMediaListPlayerPlayed = 1024,
        LibvlcMediaListPlayerNextItemSet = 1025,
        LibvlcMediaListPlayerStopped = 1026,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_start()</para>
        /// </remarks>
        LibvlcMediaDiscovererStarted = 1280,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcMediaDiscovererEnded = 1281,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcRendererDiscovererItemAdded = 1282,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcRendererDiscovererItemDeleted = 1283,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaAdded = 1536,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaRemoved = 1537,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaChanged = 1538,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaInstanceStarted = 1539,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaInstanceStopped = 1540,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaInstanceStatusInit = 1541,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaInstanceStatusOpening = 1542,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaInstanceStatusPlaying = 1543,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaInstanceStatusPause = 1544,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaInstanceStatusEnd = 1545,
        /// <remarks>
        /// <para>Useless event, it will be triggered only when calling</para>
        /// <para>libvlc_media_discoverer_stop()</para>
        /// </remarks>
        LibvlcVlmMediaInstanceStatusError = 1546
    }

    /// <summary>Renderer item</summary>
    /// <remarks>
    /// <para>This struct is passed by a</para>
    /// <para>or deleted.</para>
    /// <para>An item is valid until the</para>
    /// <para>is called with the same pointer.</para>
    /// <para>libvlc_renderer_discoverer_event_manager()</para>
    /// </remarks>
    /// <summary>A LibVLC event</summary>
    public unsafe partial class LibvlcEventT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 32)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int type;

            [FieldOffset(8)]
            internal global::System.IntPtr p_obj;

            [FieldOffset(16)]
            internal global::libvlcpp.LibvlcEventT._.__Internal u;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_event_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public unsafe partial struct _
        {
            [StructLayout(LayoutKind.Explicit, Size = 16)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__.__Internal media_meta_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.___.__Internal media_subitem_added;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.____.__Internal media_duration_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._._____.__Internal media_parsed_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.______.__Internal media_freed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._._______.__Internal media_state_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_subitemtree_added;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_buffering;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_chapter_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_position_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_time_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_title_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_seekable_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_pausable_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_scrambled_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_vout;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_list_item_added;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_list_will_add_item;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_list_item_deleted;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_list_will_delete_item;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_list_player_next_item_set;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_snapshot_taken;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_length_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal vlm_media_event;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_media_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_es_changed;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_audio_volume;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.__________.__Internal media_player_audio_device;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._._________.__Internal renderer_discoverer_item_added;

                [FieldOffset(0)]
                internal global::libvlcpp.LibvlcEventT._.________.__Internal renderer_discoverer_item_deleted;
            }

            public unsafe partial class __
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::libvlcpp.LibvlcMetaT meta_type;
                }
            }

            public unsafe partial class ___
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr new_child;
                }
            }

            public unsafe partial class ____
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal long new_duration;
                }
            }

            public unsafe partial class _____
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal int new_status;
                }
            }

            public unsafe partial class ______
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr md;
                }
            }

            public unsafe partial class _______
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal int new_state;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr item;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal float new_cache;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal int new_chapter;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal float new_position;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal long new_time;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal int new_title;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal int new_seekable;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal int new_pausable;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal int new_scrambled;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal int new_count;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr item;

                    [FieldOffset(8)]
                    internal int index;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr item;

                    [FieldOffset(8)]
                    internal int index;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr item;

                    [FieldOffset(8)]
                    internal int index;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr item;

                    [FieldOffset(8)]
                    internal int index;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr item;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr psz_filename;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal long new_length;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 16)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr psz_media_name;

                    [FieldOffset(8)]
                    internal global::System.IntPtr psz_instance_name;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr new_media;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::libvlcpp.LibvlcTrackTypeT i_type;

                    [FieldOffset(4)]
                    internal int i_id;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 4)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal float volume;
                }
            }

            public unsafe partial class __________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr device;
                }
            }

            public unsafe partial class _________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr item;
                }
            }

            public unsafe partial class ________
            {
                [StructLayout(LayoutKind.Explicit, Size = 8)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::System.IntPtr item;
                }
            }
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcEventT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcEventT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcEventT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcEventT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcEventT __CreateInstance(global::libvlcpp.LibvlcEventT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcEventT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcEventT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcEventT.__Internal));
            *(global::libvlcpp.LibvlcEventT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcEventT(global::libvlcpp.LibvlcEventT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcEventT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcEventT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcEventT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcEventT(global::libvlcpp.LibvlcEventT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcEventT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcEventT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcEventT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcEventT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int Type
        {
            get
            {
                return ((global::libvlcpp.LibvlcEventT.__Internal*) __Instance)->type;
            }

            set
            {
                ((global::libvlcpp.LibvlcEventT.__Internal*) __Instance)->type = value;
            }
        }

        public global::System.IntPtr PObj
        {
            get
            {
                return ((global::libvlcpp.LibvlcEventT.__Internal*) __Instance)->p_obj;
            }

            set
            {
                ((global::libvlcpp.LibvlcEventT.__Internal*) __Instance)->p_obj = (global::System.IntPtr) value;
            }
        }
    }

    /// <summary>
    /// <para>@{</para>
    /// <para></para>
    /// <para>LibVLC dialog external API</para>
    /// </summary>
    public enum LibvlcDialogQuestionType
    {
        LIBVLC_DIALOG_QUESTION_NORMAL = 0,
        LIBVLC_DIALOG_QUESTION_WARNING = 1,
        LIBVLC_DIALOG_QUESTION_CRITICAL = 2
    }

    public unsafe partial class LibvlcDialogId
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcDialogId> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcDialogId>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcDialogId __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcDialogId(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcDialogId __CreateInstance(global::libvlcpp.LibvlcDialogId.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcDialogId(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcDialogId.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcDialogId.__Internal));
            *(global::libvlcpp.LibvlcDialogId.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcDialogId(global::libvlcpp.LibvlcDialogId.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcDialogId(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    /// <summary>Dialog callbacks to be implemented</summary>
    public unsafe partial class LibvlcDialogCbs : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 48)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr pf_display_error;

            [FieldOffset(8)]
            internal global::System.IntPtr pf_display_login;

            [FieldOffset(16)]
            internal global::System.IntPtr pf_display_question;

            [FieldOffset(24)]
            internal global::System.IntPtr pf_display_progress;

            [FieldOffset(32)]
            internal global::System.IntPtr pf_cancel;

            [FieldOffset(40)]
            internal global::System.IntPtr pf_update_progress;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_dialog_cbs@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcDialogCbs> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcDialogCbs>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcDialogCbs __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcDialogCbs(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcDialogCbs __CreateInstance(global::libvlcpp.LibvlcDialogCbs.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcDialogCbs(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcDialogCbs.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcDialogCbs.__Internal));
            *(global::libvlcpp.LibvlcDialogCbs.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcDialogCbs(global::libvlcpp.LibvlcDialogCbs.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcDialogCbs(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcDialogCbs()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcDialogCbs.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcDialogCbs(global::libvlcpp.LibvlcDialogCbs _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcDialogCbs.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcDialogCbs.__Internal*) __Instance) = *((global::libvlcpp.LibvlcDialogCbs.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcDialogCbs __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }
    }

    public unsafe partial class libvlc_dialog
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_dialog_set_callbacks")]
            internal static extern void LibvlcDialogSetCallbacks(global::System.IntPtr p_instance, global::System.IntPtr p_cbs, global::System.IntPtr p_data);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_dialog_set_context")]
            internal static extern void LibvlcDialogSetContext(global::System.IntPtr p_id, global::System.IntPtr p_context);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_dialog_get_context")]
            internal static extern global::System.IntPtr LibvlcDialogGetContext(global::System.IntPtr p_id);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_dialog_post_login")]
            internal static extern int LibvlcDialogPostLogin(global::System.IntPtr p_id, [MarshalAs(UnmanagedType.LPStr)] string psz_username, [MarshalAs(UnmanagedType.LPStr)] string psz_password, bool b_store);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_dialog_post_action")]
            internal static extern int LibvlcDialogPostAction(global::System.IntPtr p_id, int i_action);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_dialog_dismiss")]
            internal static extern int LibvlcDialogDismiss(global::System.IntPtr p_id);
        }

        /// <summary>Register callbacks in order to handle VLC dialogs</summary>
        /// <param name="p_cbs">a pointer to callbacks, or NULL to unregister callbacks.</param>
        /// <param name="p_data">opaque pointer for the callback</param>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static void LibvlcDialogSetCallbacks(global::libvlcpp.LibvlcInstanceT p_instance, global::libvlcpp.LibvlcDialogCbs p_cbs, global::System.IntPtr p_data)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __arg1 = ReferenceEquals(p_cbs, null) ? global::System.IntPtr.Zero : p_cbs.__Instance;
            __Internal.LibvlcDialogSetCallbacks(__arg0, __arg1, p_data);
        }

        /// <summary>Associate an opaque pointer with the dialog id</summary>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static void LibvlcDialogSetContext(global::libvlcpp.LibvlcDialogId p_id, global::System.IntPtr p_context)
        {
            var __arg0 = ReferenceEquals(p_id, null) ? global::System.IntPtr.Zero : p_id.__Instance;
            __Internal.LibvlcDialogSetContext(__arg0, p_context);
        }

        /// <summary>Return the opaque pointer associated with the dialog id</summary>
        /// <remarks>LibVLC 3.0.0 and later.</remarks>
        public static global::System.IntPtr LibvlcDialogGetContext(global::libvlcpp.LibvlcDialogId p_id)
        {
            var __arg0 = ReferenceEquals(p_id, null) ? global::System.IntPtr.Zero : p_id.__Instance;
            var __ret = __Internal.LibvlcDialogGetContext(__arg0);
            return __ret;
        }

        /// <summary>Post a login answer</summary>
        /// <param name="p_id">id of the dialog</param>
        /// <param name="psz_username">valid and non empty string</param>
        /// <param name="psz_password">valid string (can be empty)</param>
        /// <param name="b_store">if true, store the credentials</param>
        /// <returns>0 on success, or -1 on error</returns>
        /// <remarks>
        /// <para>After this call, p_id won't be valid anymore</para>
        /// <para>libvlc_dialog_cbs.pf_display_login</para>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// </remarks>
        public static int LibvlcDialogPostLogin(global::libvlcpp.LibvlcDialogId p_id, string psz_username, string psz_password, bool b_store)
        {
            var __arg0 = ReferenceEquals(p_id, null) ? global::System.IntPtr.Zero : p_id.__Instance;
            var __ret = __Internal.LibvlcDialogPostLogin(__arg0, psz_username, psz_password, b_store);
            return __ret;
        }

        /// <summary>Post a question answer</summary>
        /// <param name="p_id">id of the dialog</param>
        /// <param name="i_action">1 for action1, 2 for action2</param>
        /// <returns>0 on success, or -1 on error</returns>
        /// <remarks>
        /// <para>After this call, p_id won't be valid anymore</para>
        /// <para>libvlc_dialog_cbs.pf_display_question</para>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// </remarks>
        public static int LibvlcDialogPostAction(global::libvlcpp.LibvlcDialogId p_id, int i_action)
        {
            var __arg0 = ReferenceEquals(p_id, null) ? global::System.IntPtr.Zero : p_id.__Instance;
            var __ret = __Internal.LibvlcDialogPostAction(__arg0, i_action);
            return __ret;
        }

        /// <summary>Dismiss a dialog</summary>
        /// <param name="p_id">id of the dialog</param>
        /// <returns>0 on success, or -1 on error</returns>
        /// <remarks>
        /// <para>After this call, p_id won't be valid anymore</para>
        /// <para>libvlc_dialog_cbs.pf_cancel</para>
        /// <para>LibVLC 3.0.0 and later.</para>
        /// </remarks>
        public static int LibvlcDialogDismiss(global::libvlcpp.LibvlcDialogId p_id)
        {
            var __arg0 = ReferenceEquals(p_id, null) ? global::System.IntPtr.Zero : p_id.__Instance;
            var __ret = __Internal.LibvlcDialogDismiss(__arg0);
            return __ret;
        }
    }

    public unsafe partial class libvlc_vlm
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_release")]
            internal static extern void LibvlcVlmRelease(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_add_broadcast")]
            internal static extern int LibvlcVlmAddBroadcast(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, [MarshalAs(UnmanagedType.LPStr)] string psz_input, [MarshalAs(UnmanagedType.LPStr)] string psz_output, int i_options, sbyte** ppsz_options, int b_enabled, int b_loop);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_add_vod")]
            internal static extern int LibvlcVlmAddVod(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, [MarshalAs(UnmanagedType.LPStr)] string psz_input, int i_options, sbyte** ppsz_options, int b_enabled, [MarshalAs(UnmanagedType.LPStr)] string psz_mux);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_del_media")]
            internal static extern int LibvlcVlmDelMedia(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_set_enabled")]
            internal static extern int LibvlcVlmSetEnabled(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, int b_enabled);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_set_output")]
            internal static extern int LibvlcVlmSetOutput(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, [MarshalAs(UnmanagedType.LPStr)] string psz_output);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_set_input")]
            internal static extern int LibvlcVlmSetInput(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, [MarshalAs(UnmanagedType.LPStr)] string psz_input);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_add_input")]
            internal static extern int LibvlcVlmAddInput(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, [MarshalAs(UnmanagedType.LPStr)] string psz_input);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_set_loop")]
            internal static extern int LibvlcVlmSetLoop(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, int b_loop);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_set_mux")]
            internal static extern int LibvlcVlmSetMux(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, [MarshalAs(UnmanagedType.LPStr)] string psz_mux);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_change_media")]
            internal static extern int LibvlcVlmChangeMedia(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, [MarshalAs(UnmanagedType.LPStr)] string psz_input, [MarshalAs(UnmanagedType.LPStr)] string psz_output, int i_options, sbyte** ppsz_options, int b_enabled, int b_loop);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_play_media")]
            internal static extern int LibvlcVlmPlayMedia(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_stop_media")]
            internal static extern int LibvlcVlmStopMedia(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_pause_media")]
            internal static extern int LibvlcVlmPauseMedia(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_seek_media")]
            internal static extern int LibvlcVlmSeekMedia(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, float f_percentage);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_show_media")]
            internal static extern global::System.IntPtr LibvlcVlmShowMedia(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_get_media_instance_position")]
            internal static extern float LibvlcVlmGetMediaInstancePosition(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, int i_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_get_media_instance_time")]
            internal static extern int LibvlcVlmGetMediaInstanceTime(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, int i_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_get_media_instance_length")]
            internal static extern int LibvlcVlmGetMediaInstanceLength(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, int i_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_get_media_instance_rate")]
            internal static extern int LibvlcVlmGetMediaInstanceRate(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_name, int i_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_vlm_get_event_manager")]
            internal static extern global::System.IntPtr LibvlcVlmGetEventManager(global::System.IntPtr p_instance);
        }

        /// <summary>Release the vlm instance related to the given libvlc_instance_t</summary>
        /// <param name="p_instance">the instance</param>
        public static void LibvlcVlmRelease(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcVlmRelease(__arg0);
        }

        /// <summary>Add a broadcast, with one input.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the name of the new broadcast</param>
        /// <param name="psz_input">the input MRL</param>
        /// <param name="psz_output">the output MRL (the parameter to the &quot;sout&quot; variable)</param>
        /// <param name="i_options">number of additional options</param>
        /// <param name="ppsz_options">additional options</param>
        /// <param name="b_enabled">boolean for enabling the new broadcast</param>
        /// <param name="b_loop">Should this broadcast be played in loop ?</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmAddBroadcast(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, string psz_input, string psz_output, int i_options, sbyte** ppsz_options, int b_enabled, int b_loop)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmAddBroadcast(__arg0, psz_name, psz_input, psz_output, i_options, ppsz_options, b_enabled, b_loop);
            return __ret;
        }

        /// <summary>Add a vod, with one input.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the name of the new vod media</param>
        /// <param name="psz_input">the input MRL</param>
        /// <param name="i_options">number of additional options</param>
        /// <param name="ppsz_options">additional options</param>
        /// <param name="b_enabled">boolean for enabling the new vod</param>
        /// <param name="psz_mux">the muxer of the vod media</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmAddVod(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, string psz_input, int i_options, sbyte** ppsz_options, int b_enabled, string psz_mux)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmAddVod(__arg0, psz_name, psz_input, i_options, ppsz_options, b_enabled, psz_mux);
            return __ret;
        }

        /// <summary>Delete a media (VOD or broadcast).</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the media to delete</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmDelMedia(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmDelMedia(__arg0, psz_name);
            return __ret;
        }

        /// <summary>Enable or disable a media (VOD or broadcast).</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the media to work on</param>
        /// <param name="b_enabled">the new status</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmSetEnabled(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, int b_enabled)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmSetEnabled(__arg0, psz_name, b_enabled);
            return __ret;
        }

        /// <summary>Set the output for a media.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the media to work on</param>
        /// <param name="psz_output">the output MRL (the parameter to the &quot;sout&quot; variable)</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmSetOutput(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, string psz_output)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmSetOutput(__arg0, psz_name, psz_output);
            return __ret;
        }

        /// <summary>
        /// <para>Set a media's input MRL. This will delete all existing inputs and</para>
        /// <para>add the specified one.</para>
        /// </summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the media to work on</param>
        /// <param name="psz_input">the input MRL</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmSetInput(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, string psz_input)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmSetInput(__arg0, psz_name, psz_input);
            return __ret;
        }

        /// <summary>Add a media's input MRL. This will add the specified one.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the media to work on</param>
        /// <param name="psz_input">the input MRL</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmAddInput(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, string psz_input)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmAddInput(__arg0, psz_name, psz_input);
            return __ret;
        }

        /// <summary>Set a media's loop status.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the media to work on</param>
        /// <param name="b_loop">the new status</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmSetLoop(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, int b_loop)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmSetLoop(__arg0, psz_name, b_loop);
            return __ret;
        }

        /// <summary>Set a media's vod muxer.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the media to work on</param>
        /// <param name="psz_mux">the new muxer</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmSetMux(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, string psz_mux)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmSetMux(__arg0, psz_name, psz_mux);
            return __ret;
        }

        /// <summary>
        /// <para>Edit the parameters of a media. This will delete all existing inputs and</para>
        /// <para>add the specified one.</para>
        /// </summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the name of the new broadcast</param>
        /// <param name="psz_input">the input MRL</param>
        /// <param name="psz_output">the output MRL (the parameter to the &quot;sout&quot; variable)</param>
        /// <param name="i_options">number of additional options</param>
        /// <param name="ppsz_options">additional options</param>
        /// <param name="b_enabled">boolean for enabling the new broadcast</param>
        /// <param name="b_loop">Should this broadcast be played in loop ?</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmChangeMedia(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, string psz_input, string psz_output, int i_options, sbyte** ppsz_options, int b_enabled, int b_loop)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmChangeMedia(__arg0, psz_name, psz_input, psz_output, i_options, ppsz_options, b_enabled, b_loop);
            return __ret;
        }

        /// <summary>Play the named broadcast.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the name of the broadcast</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmPlayMedia(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmPlayMedia(__arg0, psz_name);
            return __ret;
        }

        /// <summary>Stop the named broadcast.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the name of the broadcast</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmStopMedia(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmStopMedia(__arg0, psz_name);
            return __ret;
        }

        /// <summary>Pause the named broadcast.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the name of the broadcast</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmPauseMedia(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmPauseMedia(__arg0, psz_name);
            return __ret;
        }

        /// <summary>Seek in the named broadcast.</summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">the name of the broadcast</param>
        /// <param name="f_percentage">the percentage to seek to</param>
        /// <returns>0 on success, -1 on error</returns>
        public static int LibvlcVlmSeekMedia(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, float f_percentage)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmSeekMedia(__arg0, psz_name, f_percentage);
            return __ret;
        }

        /// <summary>
        /// <para>Return information about the named media as a JSON</para>
        /// <para>string representation.</para>
        /// </summary>
        /// <param name="p_instance">the instance</param>
        /// <param name="psz_name">
        /// <para>the name of the media,</para>
        /// <para>if the name is an empty string, all media is described</para>
        /// </param>
        /// <returns>string with information about named media, or NULL on error</returns>
        /// <remarks>
        /// <para>This function is mainly intended for debugging use,</para>
        /// <para>if you want programmatic access to the state of</para>
        /// <para>a vlm_media_instance_t, please use the corresponding</para>
        /// <para>libvlc_vlm_get_media_instance_xxx -functions.</para>
        /// <para>Currently there are no such functions available for</para>
        /// <para>vlm_media_t though.</para>
        /// </remarks>
        public static string LibvlcVlmShowMedia(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmShowMedia(__arg0, psz_name);
            return Marshal.PtrToStringAnsi(__ret);
        }

        /// <summary>Get vlm_media instance position by name or instance id</summary>
        /// <param name="p_instance">a libvlc instance</param>
        /// <param name="psz_name">name of vlm media instance</param>
        /// <param name="i_instance">instance id</param>
        /// <returns>position as float or -1. on error</returns>
        public static float LibvlcVlmGetMediaInstancePosition(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, int i_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmGetMediaInstancePosition(__arg0, psz_name, i_instance);
            return __ret;
        }

        /// <summary>Get vlm_media instance time by name or instance id</summary>
        /// <param name="p_instance">a libvlc instance</param>
        /// <param name="psz_name">name of vlm media instance</param>
        /// <param name="i_instance">instance id</param>
        /// <returns>time as integer or -1 on error</returns>
        public static int LibvlcVlmGetMediaInstanceTime(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, int i_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmGetMediaInstanceTime(__arg0, psz_name, i_instance);
            return __ret;
        }

        /// <summary>Get vlm_media instance length by name or instance id</summary>
        /// <param name="p_instance">a libvlc instance</param>
        /// <param name="psz_name">name of vlm media instance</param>
        /// <param name="i_instance">instance id</param>
        /// <returns>length of media item or -1 on error</returns>
        public static int LibvlcVlmGetMediaInstanceLength(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, int i_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmGetMediaInstanceLength(__arg0, psz_name, i_instance);
            return __ret;
        }

        /// <summary>Get vlm_media instance playback rate by name or instance id</summary>
        /// <param name="p_instance">a libvlc instance</param>
        /// <param name="psz_name">name of vlm media instance</param>
        /// <param name="i_instance">instance id</param>
        /// <returns>playback rate or -1 on error</returns>
        public static int LibvlcVlmGetMediaInstanceRate(global::libvlcpp.LibvlcInstanceT p_instance, string psz_name, int i_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmGetMediaInstanceRate(__arg0, psz_name, i_instance);
            return __ret;
        }

        /// <summary>
        /// <para>Get libvlc_event_manager from a vlm media.</para>
        /// <para>The p_event_manager is immutable, so you don't have to hold the lock</para>
        /// </summary>
        /// <param name="p_instance">a libvlc instance</param>
        /// <returns>libvlc_event_manager</returns>
        public static global::libvlcpp.LibvlcEventManagerT LibvlcVlmGetEventManager(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcVlmGetEventManager(__arg0);
            global::libvlcpp.LibvlcEventManagerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEventManagerT) global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEventManagerT.__CreateInstance(__ret);
            return __result0;
        }
    }

    /// <summary>This structure is opaque. It represents a libvlc log iterator</summary>
    public unsafe partial class LibvlcLogIteratorT
    {
        [StructLayout(LayoutKind.Explicit, Size = 0)]
        public partial struct __Internal
        {
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcLogIteratorT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcLogIteratorT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcLogIteratorT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcLogIteratorT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcLogIteratorT __CreateInstance(global::libvlcpp.LibvlcLogIteratorT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcLogIteratorT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcLogIteratorT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcLogIteratorT.__Internal));
            *(global::libvlcpp.LibvlcLogIteratorT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcLogIteratorT(global::libvlcpp.LibvlcLogIteratorT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcLogIteratorT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }
    }

    public unsafe partial class LibvlcLogMessageT : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 40)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int i_severity;

            [FieldOffset(8)]
            internal global::System.IntPtr psz_type;

            [FieldOffset(16)]
            internal global::System.IntPtr psz_name;

            [FieldOffset(24)]
            internal global::System.IntPtr psz_header;

            [FieldOffset(32)]
            internal global::System.IntPtr psz_message;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="??0libvlc_log_message_t@@QEAA@AEBU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcLogMessageT> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.LibvlcLogMessageT>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::libvlcpp.LibvlcLogMessageT __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcLogMessageT(native.ToPointer(), skipVTables);
        }

        internal static global::libvlcpp.LibvlcLogMessageT __CreateInstance(global::libvlcpp.LibvlcLogMessageT.__Internal native, bool skipVTables = false)
        {
            return new global::libvlcpp.LibvlcLogMessageT(native, skipVTables);
        }

        private static void* __CopyValue(global::libvlcpp.LibvlcLogMessageT.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcLogMessageT.__Internal));
            *(global::libvlcpp.LibvlcLogMessageT.__Internal*) ret = native;
            return ret.ToPointer();
        }

        private LibvlcLogMessageT(global::libvlcpp.LibvlcLogMessageT.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected LibvlcLogMessageT(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public LibvlcLogMessageT()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcLogMessageT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public LibvlcLogMessageT(global::libvlcpp.LibvlcLogMessageT _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.LibvlcLogMessageT.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance) = *((global::libvlcpp.LibvlcLogMessageT.__Internal*) _0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::libvlcpp.LibvlcLogMessageT __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int ISeverity
        {
            get
            {
                return ((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->i_severity;
            }

            set
            {
                ((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->i_severity = value;
            }
        }

        public string PszType
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->psz_type);
            }

            set
            {
                ((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->psz_type = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public string PszName
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->psz_name);
            }

            set
            {
                ((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->psz_name = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public string PszHeader
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->psz_header);
            }

            set
            {
                ((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->psz_header = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public string PszMessage
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->psz_message);
            }

            set
            {
                ((global::libvlcpp.LibvlcLogMessageT.__Internal*) __Instance)->psz_message = Marshal.StringToHGlobalAnsi(value);
            }
        }
    }

    public unsafe partial class deprecated
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_fps")]
            internal static extern float LibvlcMediaPlayerGetFps(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_set_agl")]
            internal static extern void LibvlcMediaPlayerSetAgl(global::System.IntPtr p_mi, uint drawable);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_player_get_agl")]
            internal static extern uint LibvlcMediaPlayerGetAgl(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_track_description_release")]
            internal static extern void LibvlcTrackDescriptionRelease(global::System.IntPtr p_track_description);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_height")]
            internal static extern int LibvlcVideoGetHeight(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_width")]
            internal static extern int LibvlcVideoGetWidth(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_title_description")]
            internal static extern global::System.IntPtr LibvlcVideoGetTitleDescription(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_get_chapter_description")]
            internal static extern global::System.IntPtr LibvlcVideoGetChapterDescription(global::System.IntPtr p_mi, int i_title);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_video_set_subtitle_file")]
            internal static extern int LibvlcVideoSetSubtitleFile(global::System.IntPtr p_mi, [MarshalAs(UnmanagedType.LPStr)] string psz_subtitle);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_toggle_teletext")]
            internal static extern void LibvlcToggleTeletext(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_device_count")]
            internal static extern int LibvlcAudioOutputDeviceCount(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_audio_output);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_device_longname")]
            internal static extern sbyte* LibvlcAudioOutputDeviceLongname(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_output, int i_device);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_device_id")]
            internal static extern sbyte* LibvlcAudioOutputDeviceId(global::System.IntPtr p_instance, [MarshalAs(UnmanagedType.LPStr)] string psz_audio_output, int i_device);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_get_device_type")]
            internal static extern int LibvlcAudioOutputGetDeviceType(global::System.IntPtr p_mi);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_audio_output_set_device_type")]
            internal static extern void LibvlcAudioOutputSetDeviceType(global::System.IntPtr p_mp, int device_type);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_parse")]
            internal static extern void LibvlcMediaParse(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_parse_async")]
            internal static extern void LibvlcMediaParseAsync(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_is_parsed")]
            internal static extern int LibvlcMediaIsParsed(global::System.IntPtr p_md);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_get_tracks_info")]
            internal static extern int LibvlcMediaGetTracksInfo(global::System.IntPtr p_md, global::System.IntPtr tracks);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_list_add_file_content")]
            internal static extern int LibvlcMediaListAddFileContent(global::System.IntPtr p_ml, [MarshalAs(UnmanagedType.LPStr)] string psz_uri);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_new_from_name")]
            internal static extern global::System.IntPtr LibvlcMediaDiscovererNewFromName(global::System.IntPtr p_inst, [MarshalAs(UnmanagedType.LPStr)] string psz_name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_localized_name")]
            internal static extern sbyte* LibvlcMediaDiscovererLocalizedName(global::System.IntPtr p_mdis);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_media_discoverer_event_manager")]
            internal static extern global::System.IntPtr LibvlcMediaDiscovererEventManager(global::System.IntPtr p_mdis);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_wait")]
            internal static extern void LibvlcWait(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_get_log_verbosity")]
            internal static extern uint LibvlcGetLogVerbosity(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_set_log_verbosity")]
            internal static extern void LibvlcSetLogVerbosity(global::System.IntPtr p_instance, uint level);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_open")]
            internal static extern global::System.IntPtr LibvlcLogOpen(global::System.IntPtr p_instance);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_close")]
            internal static extern void LibvlcLogClose(global::System.IntPtr p_log);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_count")]
            internal static extern uint LibvlcLogCount(global::System.IntPtr p_log);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_clear")]
            internal static extern void LibvlcLogClear(global::System.IntPtr p_log);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_get_iterator")]
            internal static extern global::System.IntPtr LibvlcLogGetIterator(global::System.IntPtr p_log);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_iterator_free")]
            internal static extern void LibvlcLogIteratorFree(global::System.IntPtr p_iter);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_iterator_has_next")]
            internal static extern int LibvlcLogIteratorHasNext(global::System.IntPtr p_iter);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_log_iterator_next")]
            internal static extern global::System.IntPtr LibvlcLogIteratorNext(global::System.IntPtr p_iter, global::System.IntPtr p_buf);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("vlc", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint="libvlc_playlist_play")]
            internal static extern void LibvlcPlaylistPlay(global::System.IntPtr p_instance, int i_id, int i_options, sbyte** ppsz_options);
        }

        /// <summary>Get movie fps rate</summary>
        /// <param name="p_mi">the Media Player</param>
        /// <returns>frames per second (fps) for this playing movie, or 0 if unspecified</returns>
        /// <remarks>
        /// <para>This function is provided for backward compatibility. It cannot deal with</para>
        /// <para>multiple video tracks. In LibVLC versions prior to 3.0, it would also fail</para>
        /// <para>if the file format did not convey the frame rate explicitly.</para>
        /// <para>Consider using libvlc_media_tracks_get() instead.</para>
        /// </remarks>
        public static float LibvlcMediaPlayerGetFps(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetFps(__arg0);
            return __ret;
        }

        /// <remarks>Use libvlc_media_player_set_nsobject() instead</remarks>
        public static void LibvlcMediaPlayerSetAgl(global::libvlcpp.LibvlcMediaPlayerT p_mi, uint drawable)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcMediaPlayerSetAgl(__arg0, drawable);
        }

        /// <remarks>Use libvlc_media_player_get_nsobject() instead</remarks>
        public static uint LibvlcMediaPlayerGetAgl(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcMediaPlayerGetAgl(__arg0);
            return __ret;
        }

        /// <remarks>Use libvlc_track_description_list_release() instead</remarks>
        public static void LibvlcTrackDescriptionRelease(global::libvlcpp.LibvlcTrackDescriptionT p_track_description)
        {
            var __arg0 = ReferenceEquals(p_track_description, null) ? global::System.IntPtr.Zero : p_track_description.__Instance;
            __Internal.LibvlcTrackDescriptionRelease(__arg0);
        }

        /// <summary>Get current video height.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>the video pixel height or 0 if not applicable</returns>
        /// <remarks>Use libvlc_video_get_size() instead.</remarks>
        public static int LibvlcVideoGetHeight(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetHeight(__arg0);
            return __ret;
        }

        /// <summary>Get current video width.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>the video pixel width or 0 if not applicable</returns>
        /// <remarks>Use libvlc_video_get_size() instead.</remarks>
        public static int LibvlcVideoGetWidth(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetWidth(__arg0);
            return __ret;
        }

        /// <summary>Get the description of available titles.</summary>
        /// <param name="p_mi">the media player</param>
        /// <returns>
        /// <para>list containing description of available titles.</para>
        /// <para>It must be freed with libvlc_track_description_list_release()</para>
        /// </returns>
        public static global::libvlcpp.LibvlcTrackDescriptionT LibvlcVideoGetTitleDescription(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetTitleDescription(__arg0);
            global::libvlcpp.LibvlcTrackDescriptionT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcTrackDescriptionT) global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcTrackDescriptionT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Get the description of available chapters for specific title.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="i_title">selected title</param>
        /// <returns>
        /// <para>list containing description of available chapter for title i_title.</para>
        /// <para>It must be freed with libvlc_track_description_list_release()</para>
        /// </returns>
        public static global::libvlcpp.LibvlcTrackDescriptionT LibvlcVideoGetChapterDescription(global::libvlcpp.LibvlcMediaPlayerT p_mi, int i_title)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoGetChapterDescription(__arg0, i_title);
            global::libvlcpp.LibvlcTrackDescriptionT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcTrackDescriptionT) global::libvlcpp.LibvlcTrackDescriptionT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcTrackDescriptionT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Set new video subtitle file.</summary>
        /// <param name="p_mi">the media player</param>
        /// <param name="psz_subtitle">new video subtitle file</param>
        /// <returns>the success status (boolean)</returns>
        /// <remarks>Use libvlc_media_player_add_slave() instead.</remarks>
        public static int LibvlcVideoSetSubtitleFile(global::libvlcpp.LibvlcMediaPlayerT p_mi, string psz_subtitle)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcVideoSetSubtitleFile(__arg0, psz_subtitle);
            return __ret;
        }

        /// <summary>Toggle teletext transparent status on video output.</summary>
        /// <param name="p_mi">the media player</param>
        /// <remarks>use libvlc_video_set_teletext() instead.</remarks>
        public static void LibvlcToggleTeletext(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            __Internal.LibvlcToggleTeletext(__arg0);
        }

        /// <summary>Backward compatibility stub. Do not use in new code.</summary>
        /// <returns>always 0.</returns>
        /// <remarks>Use libvlc_audio_output_device_list_get() instead.</remarks>
        public static int LibvlcAudioOutputDeviceCount(global::libvlcpp.LibvlcInstanceT p_instance, string psz_audio_output)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcAudioOutputDeviceCount(__arg0, psz_audio_output);
            return __ret;
        }

        /// <summary>Backward compatibility stub. Do not use in new code.</summary>
        /// <returns>always NULL.</returns>
        /// <remarks>Use libvlc_audio_output_device_list_get() instead.</remarks>
        public static sbyte* LibvlcAudioOutputDeviceLongname(global::libvlcpp.LibvlcInstanceT p_instance, string psz_output, int i_device)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcAudioOutputDeviceLongname(__arg0, psz_output, i_device);
            return __ret;
        }

        /// <summary>Backward compatibility stub. Do not use in new code.</summary>
        /// <returns>always NULL.</returns>
        /// <remarks>Use libvlc_audio_output_device_list_get() instead.</remarks>
        public static sbyte* LibvlcAudioOutputDeviceId(global::libvlcpp.LibvlcInstanceT p_instance, string psz_audio_output, int i_device)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcAudioOutputDeviceId(__arg0, psz_audio_output, i_device);
            return __ret;
        }

        /// <summary>Stub for backward compatibility.</summary>
        /// <returns>always -1.</returns>
        public static int LibvlcAudioOutputGetDeviceType(global::libvlcpp.LibvlcMediaPlayerT p_mi)
        {
            var __arg0 = ReferenceEquals(p_mi, null) ? global::System.IntPtr.Zero : p_mi.__Instance;
            var __ret = __Internal.LibvlcAudioOutputGetDeviceType(__arg0);
            return __ret;
        }

        /// <summary>Stub for backward compatibility.</summary>
        public static void LibvlcAudioOutputSetDeviceType(global::libvlcpp.LibvlcMediaPlayerT p_mp, int device_type)
        {
            var __arg0 = ReferenceEquals(p_mp, null) ? global::System.IntPtr.Zero : p_mp.__Instance;
            __Internal.LibvlcAudioOutputSetDeviceType(__arg0, device_type);
        }

        /// <summary>Parse a media.</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <remarks>
        /// <para>This fetches (local) art, meta data and tracks information.</para>
        /// <para>The method is synchronous.</para>
        /// <para>This function could block indefinitely.</para>
        /// <para>Use libvlc_media_parse_with_options() instead</para>
        /// <para>libvlc_media_parse_with_options</para>
        /// <para>libvlc_media_get_meta</para>
        /// <para>libvlc_media_get_tracks_info</para>
        /// </remarks>
        public static void LibvlcMediaParse(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaParse(__arg0);
        }

        /// <summary>Parse a media.</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <remarks>
        /// <para>This fetches (local) art, meta data and tracks information.</para>
        /// <para>The method is the asynchronous of libvlc_media_parse().</para>
        /// <para>To track when this is over you can listen to libvlc_MediaParsedChanged</para>
        /// <para>event. However if the media was already parsed you will not receive this</para>
        /// <para>event.</para>
        /// <para>You can't be sure to receive the libvlc_MediaParsedChanged</para>
        /// <para>event (you can wait indefinitely for this event).</para>
        /// <para>Use libvlc_media_parse_with_options() instead</para>
        /// <para>libvlc_media_parse</para>
        /// <para>libvlc_MediaParsedChanged</para>
        /// <para>libvlc_media_get_meta</para>
        /// <para>libvlc_media_get_tracks_info</para>
        /// </remarks>
        public static void LibvlcMediaParseAsync(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            __Internal.LibvlcMediaParseAsync(__arg0);
        }

        /// <summary>Return true is the media descriptor object is parsed</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <returns>true if media object has been parsed otherwise it returns false</returns>
        /// <remarks>
        /// <para>This can return true in case of failure.</para>
        /// <para>Use libvlc_media_get_parsed_status() instead</para>
        /// <para>libvlc_MediaParsedChanged</para>
        /// </remarks>
        public static int LibvlcMediaIsParsed(global::libvlcpp.LibvlcMediaT p_md)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __ret = __Internal.LibvlcMediaIsParsed(__arg0);
            return __ret;
        }

        /// <summary>Get media descriptor's elementary streams description</summary>
        /// <param name="p_md">media descriptor object</param>
        /// <param name="tracks">
        /// <para>address to store an allocated array of Elementary Streams</para>
        /// <para>descriptions (must be freed by the caller) [OUT]</para>
        /// </param>
        /// <returns>the number of Elementary Streams</returns>
        /// <remarks>
        /// <para>Note, you need to call libvlc_media_parse() or play the media at least once</para>
        /// <para>before calling this function.</para>
        /// <para>Not doing this will result in an empty array.</para>
        /// <para>Use libvlc_media_tracks_get() instead</para>
        /// </remarks>
        public static int LibvlcMediaGetTracksInfo(global::libvlcpp.LibvlcMediaT p_md, global::libvlcpp.LibvlcMediaTrackInfoT tracks)
        {
            var __arg0 = ReferenceEquals(p_md, null) ? global::System.IntPtr.Zero : p_md.__Instance;
            var __arg1 = ReferenceEquals(tracks, null) ? global::System.IntPtr.Zero : tracks.__Instance;
            var __ret = __Internal.LibvlcMediaGetTracksInfo(__arg0, __arg1);
            return __ret;
        }

        /// <summary>@{</summary>
        public static int LibvlcMediaListAddFileContent(global::libvlcpp.LibvlcMediaListT p_ml, string psz_uri)
        {
            var __arg0 = ReferenceEquals(p_ml, null) ? global::System.IntPtr.Zero : p_ml.__Instance;
            var __ret = __Internal.LibvlcMediaListAddFileContent(__arg0, psz_uri);
            return __ret;
        }

        /// <remarks>Use libvlc_media_discoverer_new() and libvlc_media_discoverer_start().</remarks>
        public static global::libvlcpp.LibvlcMediaDiscovererT LibvlcMediaDiscovererNewFromName(global::libvlcpp.LibvlcInstanceT p_inst, string psz_name)
        {
            var __arg0 = ReferenceEquals(p_inst, null) ? global::System.IntPtr.Zero : p_inst.__Instance;
            var __ret = __Internal.LibvlcMediaDiscovererNewFromName(__arg0, psz_name);
            global::libvlcpp.LibvlcMediaDiscovererT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcMediaDiscovererT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcMediaDiscovererT) global::libvlcpp.LibvlcMediaDiscovererT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcMediaDiscovererT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Get media service discover object its localized name.</summary>
        /// <param name="p_mdis">media discover object</param>
        /// <returns>localized name or NULL if the media_discoverer is not started</returns>
        /// <remarks>
        /// <para>Useless, use libvlc_media_discoverer_list_get() to get the</para>
        /// <para>longname of the service discovery.</para>
        /// </remarks>
        public static sbyte* LibvlcMediaDiscovererLocalizedName(global::libvlcpp.LibvlcMediaDiscovererT p_mdis)
        {
            var __arg0 = ReferenceEquals(p_mdis, null) ? global::System.IntPtr.Zero : p_mdis.__Instance;
            var __ret = __Internal.LibvlcMediaDiscovererLocalizedName(__arg0);
            return __ret;
        }

        /// <summary>Get event manager from media service discover object.</summary>
        /// <param name="p_mdis">media service discover object</param>
        /// <returns>event manager object.</returns>
        /// <remarks>
        /// <para>Useless, media_discoverer events are only triggered when calling</para>
        /// <para>libvlc_media_discoverer_start() and libvlc_media_discoverer_stop().</para>
        /// </remarks>
        public static global::libvlcpp.LibvlcEventManagerT LibvlcMediaDiscovererEventManager(global::libvlcpp.LibvlcMediaDiscovererT p_mdis)
        {
            var __arg0 = ReferenceEquals(p_mdis, null) ? global::System.IntPtr.Zero : p_mdis.__Instance;
            var __ret = __Internal.LibvlcMediaDiscovererEventManager(__arg0);
            global::libvlcpp.LibvlcEventManagerT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcEventManagerT) global::libvlcpp.LibvlcEventManagerT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcEventManagerT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>
        /// <para>Waits until an interface causes the instance to exit.</para>
        /// <para>You should start at least one interface first, using libvlc_add_intf().</para>
        /// </summary>
        /// <param name="p_instance">the instance</param>
        /// <remarks>
        /// <para>This function wastes one thread doing basically nothing.</para>
        /// <para>libvlc_set_exit_handler() should be used instead.</para>
        /// </remarks>
        public static void LibvlcWait(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcWait(__arg0);
        }

        /// <summary>
        /// <para>Always returns minus one.</para>
        /// <para>This function is only provided for backward compatibility.</para>
        /// </summary>
        /// <param name="p_instance">ignored</param>
        /// <returns>always -1</returns>
        public static uint LibvlcGetLogVerbosity(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcGetLogVerbosity(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>This function does nothing.</para>
        /// <para>It is only provided for backward compatibility.</para>
        /// </summary>
        /// <param name="p_instance">ignored</param>
        /// <param name="level">ignored</param>
        public static void LibvlcSetLogVerbosity(global::libvlcpp.LibvlcInstanceT p_instance, uint level)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcSetLogVerbosity(__arg0, level);
        }

        /// <summary>
        /// <para>This function does nothing useful.</para>
        /// <para>It is only provided for backward compatibility.</para>
        /// </summary>
        /// <param name="p_instance">libvlc instance</param>
        /// <returns>an unique pointer or NULL on error</returns>
        public static global::libvlcpp.VlcLogT LibvlcLogOpen(global::libvlcpp.LibvlcInstanceT p_instance)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            var __ret = __Internal.LibvlcLogOpen(__arg0);
            global::libvlcpp.VlcLogT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.VlcLogT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.VlcLogT) global::libvlcpp.VlcLogT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.VlcLogT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Frees memory allocated by libvlc_log_open().</summary>
        /// <param name="p_log">libvlc log instance or NULL</param>
        public static void LibvlcLogClose(global::libvlcpp.VlcLogT p_log)
        {
            var __arg0 = ReferenceEquals(p_log, null) ? global::System.IntPtr.Zero : p_log.__Instance;
            __Internal.LibvlcLogClose(__arg0);
        }

        /// <summary>
        /// <para>Always returns zero.</para>
        /// <para>This function is only provided for backward compatibility.</para>
        /// </summary>
        /// <param name="p_log">ignored</param>
        /// <returns>always zero</returns>
        public static uint LibvlcLogCount(global::libvlcpp.VlcLogT p_log)
        {
            var __arg0 = ReferenceEquals(p_log, null) ? global::System.IntPtr.Zero : p_log.__Instance;
            var __ret = __Internal.LibvlcLogCount(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>This function does nothing.</para>
        /// <para>It is only provided for backward compatibility.</para>
        /// </summary>
        /// <param name="p_log">ignored</param>
        public static void LibvlcLogClear(global::libvlcpp.VlcLogT p_log)
        {
            var __arg0 = ReferenceEquals(p_log, null) ? global::System.IntPtr.Zero : p_log.__Instance;
            __Internal.LibvlcLogClear(__arg0);
        }

        /// <summary>
        /// <para>This function does nothing useful.</para>
        /// <para>It is only provided for backward compatibility.</para>
        /// </summary>
        /// <param name="p_log">ignored</param>
        /// <returns>an unique pointer or NULL on error or if the parameter was NULL</returns>
        public static global::libvlcpp.LibvlcLogIteratorT LibvlcLogGetIterator(global::libvlcpp.VlcLogT p_log)
        {
            var __arg0 = ReferenceEquals(p_log, null) ? global::System.IntPtr.Zero : p_log.__Instance;
            var __ret = __Internal.LibvlcLogGetIterator(__arg0);
            global::libvlcpp.LibvlcLogIteratorT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcLogIteratorT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcLogIteratorT) global::libvlcpp.LibvlcLogIteratorT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcLogIteratorT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Frees memory allocated by libvlc_log_get_iterator().</summary>
        /// <param name="p_iter">libvlc log iterator or NULL</param>
        public static void LibvlcLogIteratorFree(global::libvlcpp.LibvlcLogIteratorT p_iter)
        {
            var __arg0 = ReferenceEquals(p_iter, null) ? global::System.IntPtr.Zero : p_iter.__Instance;
            __Internal.LibvlcLogIteratorFree(__arg0);
        }

        /// <summary>
        /// <para>Always returns zero.</para>
        /// <para>This function is only provided for backward compatibility.</para>
        /// </summary>
        /// <param name="p_iter">ignored</param>
        /// <returns>always zero</returns>
        public static int LibvlcLogIteratorHasNext(global::libvlcpp.LibvlcLogIteratorT p_iter)
        {
            var __arg0 = ReferenceEquals(p_iter, null) ? global::System.IntPtr.Zero : p_iter.__Instance;
            var __ret = __Internal.LibvlcLogIteratorHasNext(__arg0);
            return __ret;
        }

        /// <summary>
        /// <para>Always returns NULL.</para>
        /// <para>This function is only provided for backward compatibility.</para>
        /// </summary>
        /// <param name="p_iter">libvlc log iterator or NULL</param>
        /// <param name="p_buf">ignored</param>
        /// <returns>always NULL</returns>
        public static global::libvlcpp.LibvlcLogMessageT LibvlcLogIteratorNext(global::libvlcpp.LibvlcLogIteratorT p_iter, global::libvlcpp.LibvlcLogMessageT p_buf)
        {
            var __arg0 = ReferenceEquals(p_iter, null) ? global::System.IntPtr.Zero : p_iter.__Instance;
            var __arg1 = ReferenceEquals(p_buf, null) ? global::System.IntPtr.Zero : p_buf.__Instance;
            var __ret = __Internal.LibvlcLogIteratorNext(__arg0, __arg1);
            global::libvlcpp.LibvlcLogMessageT __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::libvlcpp.LibvlcLogMessageT.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::libvlcpp.LibvlcLogMessageT) global::libvlcpp.LibvlcLogMessageT.NativeToManagedMap[__ret];
            else __result0 = global::libvlcpp.LibvlcLogMessageT.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Start playing (if there is any item in the playlist).</summary>
        /// <param name="p_instance">the playlist instance</param>
        /// <param name="i_id">
        /// <para>the item to play. If this is a negative number, the next</para>
        /// <para>item will be selected. Otherwise, the item with the given ID will be</para>
        /// <para>played</para>
        /// </param>
        /// <param name="i_options">the number of options to add to the item</param>
        /// <param name="ppsz_options">the options to add to the item</param>
        /// <remarks>
        /// <para>Additionnal playlist item options can be specified for addition to the</para>
        /// <para>item before it is played.</para>
        /// </remarks>
        public static void LibvlcPlaylistPlay(global::libvlcpp.LibvlcInstanceT p_instance, int i_id, int i_options, sbyte** ppsz_options)
        {
            var __arg0 = ReferenceEquals(p_instance, null) ? global::System.IntPtr.Zero : p_instance.__Instance;
            __Internal.LibvlcPlaylistPlay(__arg0, i_id, i_options, ppsz_options);
        }
    }

    namespace VLC
    {
        /// <summary>The ModuleDescription class describes a module</summary>
        public unsafe partial class ModuleDescription : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 128)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.BasicString.__Internal m_name;

                [FieldOffset(32)]
                internal global::Std.BasicString.__Internal m_shortname;

                [FieldOffset(64)]
                internal global::Std.BasicString.__Internal m_longname;

                [FieldOffset(96)]
                internal global::Std.BasicString.__Internal m_help;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0ModuleDescription@VLC@@QEAA@PEAUlibvlc_module_description_t@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr c);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0ModuleDescription@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1ModuleDescription@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?help@ModuleDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Help(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?name@ModuleDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Name(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?shortname@ModuleDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Shortname(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?longname@ModuleDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Longname(global::System.IntPtr instance);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.ModuleDescription> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.ModuleDescription>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.ModuleDescription __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.ModuleDescription(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.ModuleDescription __CreateInstance(global::libvlcpp.VLC.ModuleDescription.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.ModuleDescription(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.ModuleDescription.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.ModuleDescription.__Internal));
                global::libvlcpp.VLC.ModuleDescription.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private ModuleDescription(global::libvlcpp.VLC.ModuleDescription.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected ModuleDescription(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public ModuleDescription(global::libvlcpp.LibvlcModuleDescriptionT c)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.ModuleDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                var __arg0 = ReferenceEquals(c, null) ? global::System.IntPtr.Zero : c.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            public ModuleDescription(global::libvlcpp.VLC.ModuleDescription _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.ModuleDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.ModuleDescription __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            /// <summary>help Returns a basic help string for this module</summary>
            public string Help()
            {
                var __ret = __Internal.Help((__Instance + __PointerAdjustment));
                var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                return global::Std.BasicStringExtensions.CStr(__basicStringRet);
            }

            public static explicit operator global::libvlcpp.VLC.ModuleDescription(global::libvlcpp.LibvlcModuleDescriptionT c)
            {
                return new global::libvlcpp.VLC.ModuleDescription(c);
            }

            /// <summary>name Returns the module name</summary>
            public string Name
            {
                get
                {
                    var __ret = __Internal.Name((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }

            /// <summary>shortname Returns the module short name</summary>
            public string Shortname
            {
                get
                {
                    var __ret = __Internal.Shortname((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }

            /// <summary>longname returns the module long name</summary>
            public string Longname
            {
                get
                {
                    var __ret = __Internal.Longname((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }
        }

        /// <summary>The MediaTrack class describes a track</summary>
        public unsafe partial class MediaTrack : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 168)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal uint m_codec;

                [FieldOffset(4)]
                internal uint m_originalFourcc;

                [FieldOffset(8)]
                internal uint m_id;

                [FieldOffset(12)]
                internal global::libvlcpp.VLC.MediaTrack.Type m_type;

                [FieldOffset(16)]
                internal int m_profile;

                [FieldOffset(20)]
                internal int m_level;

                [FieldOffset(24)]
                internal uint m_bitrate;

                [FieldOffset(32)]
                internal global::Std.BasicString.__Internal m_language;

                [FieldOffset(64)]
                internal global::Std.BasicString.__Internal m_description;

                [FieldOffset(96)]
                internal uint m_channels;

                [FieldOffset(100)]
                internal uint m_rate;

                [FieldOffset(104)]
                internal uint m_height;

                [FieldOffset(108)]
                internal uint m_width;

                [FieldOffset(112)]
                internal uint m_sarNum;

                [FieldOffset(116)]
                internal uint m_sarDen;

                [FieldOffset(120)]
                internal uint m_fpsNum;

                [FieldOffset(124)]
                internal uint m_fpsDen;

                [FieldOffset(128)]
                internal global::libvlcpp.VLC.MediaTrack.Orientation m_orientation;

                [FieldOffset(132)]
                internal global::libvlcpp.VLC.MediaTrack.Projection m_projection;

                [FieldOffset(136)]
                internal global::Std.BasicString.__Internal m_encoding;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaTrack@VLC@@QEAA@PEAUlibvlc_media_track_t@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr c);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaTrack@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaTrack@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?codec@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint Codec(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?originalFourCC@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint OriginalFourCC(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?id@MediaTrack@VLC@@QEBAHXZ")]
                internal static extern int Id(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?type@MediaTrack@VLC@@QEBA?AW4Type@12@XZ")]
                internal static extern global::libvlcpp.VLC.MediaTrack.Type type(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?profile@MediaTrack@VLC@@QEBAHXZ")]
                internal static extern int Profile(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?level@MediaTrack@VLC@@QEBAHXZ")]
                internal static extern int Level(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?bitrate@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint Bitrate(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?language@MediaTrack@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Language(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?description@MediaTrack@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Description(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?channels@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint Channels(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?rate@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint Rate(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?height@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint Height(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?width@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint Width(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?sarNum@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint SarNum(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?sarDen@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint SarDen(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?fpsNum@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint FpsNum(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?fpsDen@MediaTrack@VLC@@QEBAIXZ")]
                internal static extern uint FpsDen(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?orientation@MediaTrack@VLC@@QEBA?AW4Orientation@12@XZ")]
                internal static extern global::libvlcpp.VLC.MediaTrack.Orientation orientation(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?projection@MediaTrack@VLC@@QEBA?AW4Projection@12@XZ")]
                internal static extern global::libvlcpp.VLC.MediaTrack.Projection projection(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?encoding@MediaTrack@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Encoding(global::System.IntPtr instance);
            }

            /// <summary>The Type enum indicates the type of a track</summary>
            public enum Type
            {
                Unknown = -1,
                /// <summary>Audio track</summary>
                Audio = 0,
                /// <summary>Video track</summary>
                Video = 1,
                /// <summary>Subtitle track (also called SPU sometimes)</summary>
                Subtitle = 2
            }

            /// <summary>The Orientation enum indicates the orientation of a video</summary>
            public enum Orientation
            {
                TopLeft = 0,
                TopRight = 1,
                BottomLeft = 2,
                BottomRight = 3,
                LeftTop = 4,
                LeftBottom = 5,
                RightTop = 6,
                RightBottom = 7
            }

            /// <summary>The Projection enum indicates the projection of a video</summary>
            [Flags]
            public enum Projection
            {
                Rectangular = 0,
                /// <summary>360 spherical</summary>
                Equirectangular = 1,
                /// <summary>360 spherical</summary>
                CubemapLayoutStandard = 256
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaTrack> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaTrack>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.MediaTrack __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaTrack(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaTrack __CreateInstance(global::libvlcpp.VLC.MediaTrack.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaTrack(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaTrack.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaTrack.__Internal));
                global::libvlcpp.VLC.MediaTrack.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaTrack(global::libvlcpp.VLC.MediaTrack.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaTrack(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public MediaTrack(global::libvlcpp.LibvlcMediaTrackT c)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaTrack.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                var __arg0 = ReferenceEquals(c, null) ? global::System.IntPtr.Zero : c.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            public MediaTrack(global::libvlcpp.VLC.MediaTrack _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaTrack.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.MediaTrack __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static explicit operator global::libvlcpp.VLC.MediaTrack(global::libvlcpp.LibvlcMediaTrackT c)
            {
                return new global::libvlcpp.VLC.MediaTrack(c);
            }

            public static global::libvlcpp.VLC.MediaTrack.Type Unknown
            {
                get
                {
                    var __ptr = (global::libvlcpp.VLC.MediaTrack.Type*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?Unknown@MediaTrack@VLC@@2W4Type@12@B");
                    return *__ptr;
                }
            }

            public static global::libvlcpp.VLC.MediaTrack.Type Audio
            {
                get
                {
                    var __ptr = (global::libvlcpp.VLC.MediaTrack.Type*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?Audio@MediaTrack@VLC@@2W4Type@12@B");
                    return *__ptr;
                }
            }

            public static global::libvlcpp.VLC.MediaTrack.Type Video
            {
                get
                {
                    var __ptr = (global::libvlcpp.VLC.MediaTrack.Type*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?Video@MediaTrack@VLC@@2W4Type@12@B");
                    return *__ptr;
                }
            }

            public static global::libvlcpp.VLC.MediaTrack.Type Subtitle
            {
                get
                {
                    var __ptr = (global::libvlcpp.VLC.MediaTrack.Type*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?Subtitle@MediaTrack@VLC@@2W4Type@12@B");
                    return *__ptr;
                }
            }

            /// <summary>codec Returns the codec as a fourcc</summary>
            /// <remarks>
            /// <para>This is the fourcc will use to select a codec, but it might be an</para>
            /// <para>interpretation of the original fourcc.</para>
            /// <para>originalFourCC()</para>
            /// </remarks>
            public uint Codec
            {
                get
                {
                    var __ret = __Internal.Codec((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>originalFourCC Returns the fourcc as found in the file.</summary>
            /// <remarks>
            /// <para>VLC might chose to use a different fourcc internally.</para>
            /// <para>For instance, AVC1&amp;H264 fourcc are (almost?) identical. VLC would</para>
            /// <para>use H264 as the codec/fourcc, and store AVC1/H264 as the original fourcc</para>
            /// </remarks>
            public uint OriginalFourCC
            {
                get
                {
                    var __ret = __Internal.OriginalFourCC((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>id The track internal ID.</summary>
            /// <remarks>This can't be assume to grow one by one monotonically.</remarks>
            public int Id
            {
                get
                {
                    var __ret = __Internal.Id((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>type The track type</summary>
            /// <remarks>MediaTrack::Type</remarks>
            public global::libvlcpp.VLC.MediaTrack.Type type
            {
                get
                {
                    var __ret = __Internal.type((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>profile This track profile</summary>
            /// <remarks>This might or might not be set, depending on the codec.</remarks>
            public int Profile
            {
                get
                {
                    var __ret = __Internal.Profile((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>level This track level</summary>
            /// <remarks>This might or might not be set, depending on the codec</remarks>
            public int Level
            {
                get
                {
                    var __ret = __Internal.Level((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>bitrate This track bitrate, in bytes per second</summary>
            public uint Bitrate
            {
                get
                {
                    var __ret = __Internal.Bitrate((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>language This track language, if available.</summary>
            public string Language
            {
                get
                {
                    var __ret = __Internal.Language((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }

            /// <summary>description This track description</summary>
            public string Description
            {
                get
                {
                    var __ret = __Internal.Description((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }

            /// <summary>channels This track number of channels</summary>
            public uint Channels
            {
                get
                {
                    var __ret = __Internal.Channels((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>rate This track samplerate, in hertz (Hz)</summary>
            public uint Rate
            {
                get
                {
                    var __ret = __Internal.Rate((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>height This track video height</summary>
            public uint Height
            {
                get
                {
                    var __ret = __Internal.Height((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>width This track video width</summary>
            public uint Width
            {
                get
                {
                    var __ret = __Internal.Width((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>sarNum This track aspect ratio numerator</summary>
            /// <remarks>sarDen</remarks>
            public uint SarNum
            {
                get
                {
                    var __ret = __Internal.SarNum((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>sarDen This track aspect ratio denominator</summary>
            /// <remarks>sarNum</remarks>
            public uint SarDen
            {
                get
                {
                    var __ret = __Internal.SarDen((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>fpsNum This track frame per second numerator</summary>
            /// <remarks>fpsDen</remarks>
            public uint FpsNum
            {
                get
                {
                    var __ret = __Internal.FpsNum((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>fpsDen This track frame per second denominator</summary>
            /// <remarks>fpsNum</remarks>
            public uint FpsDen
            {
                get
                {
                    var __ret = __Internal.FpsDen((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>Orientation</summary>
            /// <remarks>orientation</remarks>
            public global::libvlcpp.VLC.MediaTrack.Orientation orientation
            {
                get
                {
                    var __ret = __Internal.orientation((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>Projection</summary>
            /// <remarks>projection</remarks>
            public global::libvlcpp.VLC.MediaTrack.Projection projection
            {
                get
                {
                    var __ret = __Internal.projection((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>encoding Subtitles text encoding</summary>
            public string Encoding
            {
                get
                {
                    var __ret = __Internal.Encoding((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }
        }

        /// <summary>The AudioOutputDescription class describes an audio output module</summary>
        public unsafe partial class AudioOutputDescription : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 64)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.BasicString.__Internal m_name;

                [FieldOffset(32)]
                internal global::Std.BasicString.__Internal m_description;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0AudioOutputDescription@VLC@@QEAA@PEAUlibvlc_audio_output_t@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr c);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0AudioOutputDescription@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1AudioOutputDescription@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?name@AudioOutputDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Name(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?description@AudioOutputDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Description(global::System.IntPtr instance);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.AudioOutputDescription> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.AudioOutputDescription>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.AudioOutputDescription __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.AudioOutputDescription(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.AudioOutputDescription __CreateInstance(global::libvlcpp.VLC.AudioOutputDescription.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.AudioOutputDescription(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.AudioOutputDescription.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.AudioOutputDescription.__Internal));
                global::libvlcpp.VLC.AudioOutputDescription.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private AudioOutputDescription(global::libvlcpp.VLC.AudioOutputDescription.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected AudioOutputDescription(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public AudioOutputDescription(global::libvlcpp.LibvlcAudioOutputT c)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.AudioOutputDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                var __arg0 = ReferenceEquals(c, null) ? global::System.IntPtr.Zero : c.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            public AudioOutputDescription(global::libvlcpp.VLC.AudioOutputDescription _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.AudioOutputDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.AudioOutputDescription __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static explicit operator global::libvlcpp.VLC.AudioOutputDescription(global::libvlcpp.LibvlcAudioOutputT c)
            {
                return new global::libvlcpp.VLC.AudioOutputDescription(c);
            }

            /// <summary>name The module name</summary>
            public string Name
            {
                get
                {
                    var __ret = __Internal.Name((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }

            /// <summary>description The module description</summary>
            public string Description
            {
                get
                {
                    var __ret = __Internal.Description((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }
        }

        /// <summary>
        /// <para>The AudioOutputDeviceDescription class describes an audio device, as seen</para>
        /// <para>by an audio output module</para>
        /// </summary>
        public unsafe partial class AudioOutputDeviceDescription : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 64)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.BasicString.__Internal m_device;

                [FieldOffset(32)]
                internal global::Std.BasicString.__Internal m_description;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0AudioOutputDeviceDescription@VLC@@QEAA@PEAUlibvlc_audio_output_device_t@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr d);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0AudioOutputDeviceDescription@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1AudioOutputDeviceDescription@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?device@AudioOutputDeviceDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Device(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?description@AudioOutputDeviceDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Description(global::System.IntPtr instance);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.AudioOutputDeviceDescription> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.AudioOutputDeviceDescription>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.AudioOutputDeviceDescription __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.AudioOutputDeviceDescription(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.AudioOutputDeviceDescription __CreateInstance(global::libvlcpp.VLC.AudioOutputDeviceDescription.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.AudioOutputDeviceDescription(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.AudioOutputDeviceDescription.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.AudioOutputDeviceDescription.__Internal));
                global::libvlcpp.VLC.AudioOutputDeviceDescription.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private AudioOutputDeviceDescription(global::libvlcpp.VLC.AudioOutputDeviceDescription.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected AudioOutputDeviceDescription(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public AudioOutputDeviceDescription(global::libvlcpp.LibvlcAudioOutputDeviceT d)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.AudioOutputDeviceDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                var __arg0 = ReferenceEquals(d, null) ? global::System.IntPtr.Zero : d.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            public AudioOutputDeviceDescription(global::libvlcpp.VLC.AudioOutputDeviceDescription _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.AudioOutputDeviceDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.AudioOutputDeviceDescription __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static explicit operator global::libvlcpp.VLC.AudioOutputDeviceDescription(global::libvlcpp.LibvlcAudioOutputDeviceT d)
            {
                return new global::libvlcpp.VLC.AudioOutputDeviceDescription(d);
            }

            public string Device
            {
                get
                {
                    var __ret = __Internal.Device((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }

            public string Description
            {
                get
                {
                    var __ret = __Internal.Description((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }
        }

        /// <summary>The TrackDescription class describes a track</summary>
        public unsafe partial class TrackDescription : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 40)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal int m_id;

                [FieldOffset(8)]
                internal global::Std.BasicString.__Internal m_name;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0TrackDescription@VLC@@QEAA@PEAUlibvlc_track_description_t@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr c);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0TrackDescription@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1TrackDescription@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?id@TrackDescription@VLC@@QEBAHXZ")]
                internal static extern int Id(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?name@TrackDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Name(global::System.IntPtr instance);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.TrackDescription> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.TrackDescription>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.TrackDescription __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.TrackDescription(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.TrackDescription __CreateInstance(global::libvlcpp.VLC.TrackDescription.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.TrackDescription(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.TrackDescription.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.TrackDescription.__Internal));
                global::libvlcpp.VLC.TrackDescription.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private TrackDescription(global::libvlcpp.VLC.TrackDescription.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected TrackDescription(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public TrackDescription(global::libvlcpp.LibvlcTrackDescriptionT c)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.TrackDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                var __arg0 = ReferenceEquals(c, null) ? global::System.IntPtr.Zero : c.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            public TrackDescription(global::libvlcpp.VLC.TrackDescription _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.TrackDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.TrackDescription __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static explicit operator global::libvlcpp.VLC.TrackDescription(global::libvlcpp.LibvlcTrackDescriptionT c)
            {
                return new global::libvlcpp.VLC.TrackDescription(c);
            }

            /// <summary>id The track id</summary>
            public int Id
            {
                get
                {
                    var __ret = __Internal.Id((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>name The track name</summary>
            public string Name
            {
                get
                {
                    var __ret = __Internal.Name((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }
        }

        /// <summary>The TitleDescription class describes a title</summary>
        public unsafe partial class TitleDescription : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 48)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal long m_duration;

                [FieldOffset(8)]
                internal global::Std.BasicString.__Internal m_name;

                [FieldOffset(40)]
                internal int m_flags;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0TitleDescription@VLC@@QEAA@PEAUlibvlc_title_description_t@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr c);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0TitleDescription@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1TitleDescription@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?duration@TitleDescription@VLC@@QEBA_JXZ")]
                internal static extern long Duration(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?name@TitleDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Name(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?isMenu@TitleDescription@VLC@@QEBA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool IsMenu(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?isInteractive@TitleDescription@VLC@@QEBA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool IsInteractive(global::System.IntPtr instance);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.TitleDescription> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.TitleDescription>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.TitleDescription __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.TitleDescription(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.TitleDescription __CreateInstance(global::libvlcpp.VLC.TitleDescription.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.TitleDescription(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.TitleDescription.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.TitleDescription.__Internal));
                global::libvlcpp.VLC.TitleDescription.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private TitleDescription(global::libvlcpp.VLC.TitleDescription.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected TitleDescription(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public TitleDescription(global::libvlcpp.LibvlcTitleDescriptionT c)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.TitleDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                var __arg0 = ReferenceEquals(c, null) ? global::System.IntPtr.Zero : c.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            public TitleDescription(global::libvlcpp.VLC.TitleDescription _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.TitleDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.TitleDescription __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static explicit operator global::libvlcpp.VLC.TitleDescription(global::libvlcpp.LibvlcTitleDescriptionT c)
            {
                return new global::libvlcpp.VLC.TitleDescription(c);
            }

            /// <summary>duration The title duration in (ms)</summary>
            public long Duration
            {
                get
                {
                    var __ret = __Internal.Duration((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>name The title name</summary>
            public string Name
            {
                get
                {
                    var __ret = __Internal.Name((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }

            /// <summary>name Is the title a menu?</summary>
            public bool IsMenu
            {
                get
                {
                    var __ret = __Internal.IsMenu((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            public bool IsInteractive
            {
                get
                {
                    var __ret = __Internal.IsInteractive((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }
        }

        /// <summary>The ChapterDescription class describes a chapter</summary>
        public unsafe partial class ChapterDescription : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 48)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal long m_duration;

                [FieldOffset(8)]
                internal long m_starttime;

                [FieldOffset(16)]
                internal global::Std.BasicString.__Internal m_name;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0ChapterDescription@VLC@@QEAA@PEAUlibvlc_chapter_description_t@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr c);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0ChapterDescription@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1ChapterDescription@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?starttime@ChapterDescription@VLC@@QEBA_JXZ")]
                internal static extern long Starttime(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?duration@ChapterDescription@VLC@@QEBA_JXZ")]
                internal static extern long Duration(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?name@ChapterDescription@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern global::System.IntPtr Name(global::System.IntPtr instance);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.ChapterDescription> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.ChapterDescription>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.ChapterDescription __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.ChapterDescription(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.ChapterDescription __CreateInstance(global::libvlcpp.VLC.ChapterDescription.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.ChapterDescription(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.ChapterDescription.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.ChapterDescription.__Internal));
                global::libvlcpp.VLC.ChapterDescription.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private ChapterDescription(global::libvlcpp.VLC.ChapterDescription.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected ChapterDescription(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public ChapterDescription(global::libvlcpp.LibvlcChapterDescriptionT c)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.ChapterDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                var __arg0 = ReferenceEquals(c, null) ? global::System.IntPtr.Zero : c.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            public ChapterDescription(global::libvlcpp.VLC.ChapterDescription _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.ChapterDescription.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.ChapterDescription __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static explicit operator global::libvlcpp.VLC.ChapterDescription(global::libvlcpp.LibvlcChapterDescriptionT c)
            {
                return new global::libvlcpp.VLC.ChapterDescription(c);
            }

            /// <summary>timeoffset The chapter start time in (ms)</summary>
            public long Starttime
            {
                get
                {
                    var __ret = __Internal.Starttime((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>duration The chapter duration in (ms)</summary>
            public long Duration
            {
                get
                {
                    var __ret = __Internal.Duration((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>name The chapter name</summary>
            public string Name
            {
                get
                {
                    var __ret = __Internal.Name((__Instance + __PointerAdjustment));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                }
            }
        }

        /// <summary>C++ Type wrapper for libvlc_media_slave_t</summary>
        public unsafe partial class MediaSlave : global::libvlcpp.LibvlcMediaSlaveT, IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 16)]
            public new partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::System.IntPtr psz_uri;

                [FieldOffset(8)]
                internal global::libvlcpp.LibvlcMediaSlaveTypeT i_type;

                [FieldOffset(12)]
                internal uint i_priority;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaSlave@VLC@@QEAA@PEAUlibvlc_media_slave_t@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr other);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaSlave@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?type@MediaSlave@VLC@@QEBA?AW4Type@12@XZ")]
                internal static extern global::libvlcpp.VLC.MediaSlave.Type type(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?priority@MediaSlave@VLC@@QEBAIXZ")]
                internal static extern uint Priority(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?uri@MediaSlave@VLC@@QEBA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern void Uri(global::System.IntPtr instance, global::System.IntPtr @return);
            }

            /// <summary>Type of a media slave: subtitle or audio.</summary>
            public enum Type
            {
                Subtitle = 0,
                Audio = 1
            }

            internal static new global::libvlcpp.VLC.MediaSlave __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaSlave(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaSlave __CreateInstance(global::libvlcpp.VLC.MediaSlave.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaSlave(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaSlave.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaSlave.__Internal));
                *(global::libvlcpp.VLC.MediaSlave.__Internal*) ret = native;
                return ret.ToPointer();
            }

            private MediaSlave(global::libvlcpp.VLC.MediaSlave.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaSlave(void* native, bool skipVTables = false)
                : base((void*) null)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public MediaSlave(global::libvlcpp.LibvlcMediaSlaveT other)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaSlave.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                var __arg0 = ReferenceEquals(other, null) ? global::System.IntPtr.Zero : other.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            public MediaSlave(global::libvlcpp.VLC.MediaSlave _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaSlave.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                *((global::libvlcpp.VLC.MediaSlave.__Internal*) __Instance) = *((global::libvlcpp.VLC.MediaSlave.__Internal*) _0.__Instance);
            }

            public global::libvlcpp.VLC.MediaSlave.Type type
            {
                get
                {
                    var __ret = __Internal.type((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            public uint Priority
            {
                get
                {
                    var __ret = __Internal.Priority((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            public string Uri
            {
                get
                {
                    var __ret = new global::Std.BasicString.__Internal();
                    __Internal.Uri((__Instance + __PointerAdjustment), new IntPtr(&__ret));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    var __stringRet = global::Std.BasicStringExtensions.CStr(__basicStringRet);
                    __basicStringRet.Dispose(false);
                    return __stringRet;
                }
            }
        }

        /// <summary>C++ Type wrapper for libvlc_video_viewpoint_t</summary>
        public unsafe partial class VideoViewpoint : global::libvlcpp.LibvlcVideoViewpointT, IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 16)]
            public new partial struct __Internal
            {
                [FieldOffset(0)]
                internal float f_yaw;

                [FieldOffset(4)]
                internal float f_pitch;

                [FieldOffset(8)]
                internal float f_roll;

                [FieldOffset(12)]
                internal float f_field_of_view;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0VideoViewpoint@VLC@@QEAA@MMMM@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, float yaw, float pitch, float roll, float fieldOfView);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0VideoViewpoint@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?yaw@VideoViewpoint@VLC@@QEBAMXZ")]
                internal static extern float Yaw(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?pitch@VideoViewpoint@VLC@@QEBAMXZ")]
                internal static extern float Pitch(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?roll@VideoViewpoint@VLC@@QEBAMXZ")]
                internal static extern float Roll(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?field_of_view@VideoViewpoint@VLC@@QEBAMXZ")]
                internal static extern float FieldOfView(global::System.IntPtr instance);
            }

            internal static new global::libvlcpp.VLC.VideoViewpoint __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.VideoViewpoint(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.VideoViewpoint __CreateInstance(global::libvlcpp.VLC.VideoViewpoint.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.VideoViewpoint(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.VideoViewpoint.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.VideoViewpoint.__Internal));
                *(global::libvlcpp.VLC.VideoViewpoint.__Internal*) ret = native;
                return ret.ToPointer();
            }

            private VideoViewpoint(global::libvlcpp.VLC.VideoViewpoint.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected VideoViewpoint(void* native, bool skipVTables = false)
                : base((void*) null)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public VideoViewpoint(float yaw, float pitch, float roll, float fieldOfView)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.VideoViewpoint.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                __Internal.ctor((__Instance + __PointerAdjustment), yaw, pitch, roll, fieldOfView);
            }

            public VideoViewpoint(global::libvlcpp.VLC.VideoViewpoint _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.VideoViewpoint.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                *((global::libvlcpp.VLC.VideoViewpoint.__Internal*) __Instance) = *((global::libvlcpp.VLC.VideoViewpoint.__Internal*) _0.__Instance);
            }

            public float Yaw
            {
                get
                {
                    var __ret = __Internal.Yaw((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            public float Pitch
            {
                get
                {
                    var __ret = __Internal.Pitch((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            public float Roll
            {
                get
                {
                    var __ret = __Internal.Roll((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            public float FieldOfView
            {
                get
                {
                    var __ret = __Internal.FieldOfView((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }
        }
    }

    namespace VLC
    {
        /// <summary>The Dialog class exposes libvlc_dialog_id functionalities</summary>
        public unsafe partial class Dialog : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 8)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::System.IntPtr m_id;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1Dialog@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?postLogin@Dialog@VLC@@QEAA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@0_N@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool PostLogin(global::System.IntPtr instance, global::System.IntPtr username, global::System.IntPtr password, bool store);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?postAction@Dialog@VLC@@QEAA_NH@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool PostAction(global::System.IntPtr instance, int actionIndex);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?dismiss@Dialog@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Dismiss(global::System.IntPtr instance);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.Dialog> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.Dialog>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.Dialog __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.Dialog(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.Dialog __CreateInstance(global::libvlcpp.VLC.Dialog.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.Dialog(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.Dialog.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Dialog.__Internal));
                *(global::libvlcpp.VLC.Dialog.__Internal*) ret = native;
                return ret.ToPointer();
            }

            private Dialog(global::libvlcpp.VLC.Dialog.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected Dialog(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.Dialog __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            /// <summary>Post a login answer.</summary>
            /// <param name="username">valid non-empty string</param>
            /// <param name="password">valid string</param>
            /// <param name="store">if true stores the credentials</param>
            /// <returns>true if success, false otherwise</returns>
            /// <remarks>After this call, the instance won't be valid anymore</remarks>
            public bool PostLogin(string username, string password, bool store)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(username, __allocator0);
                var __arg0 = __basicString0.__Instance;
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(password, __allocator1);
                var __arg1 = __basicString1.__Instance;
                var __ret = __Internal.PostLogin((__Instance + __PointerAdjustment), __arg0, __arg1, store);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
                __basicString1.Dispose(false);
                __allocator1.Dispose();
                return __ret;
            }

            /// <summary>Post a question answer.</summary>
            /// <param name="actionIndex">1 for action1, 2 for action2</param>
            /// <returns>true on success, false otherwise</returns>
            /// <remarks>
            /// <para>After this call, this instance won't be valid anymore</para>
            /// <para>QuestionCb</para>
            /// </remarks>
            public bool PostAction(int actionIndex)
            {
                var __ret = __Internal.PostAction((__Instance + __PointerAdjustment), actionIndex);
                return __ret;
            }

            /// <summary>Dismiss a dialog.</summary>
            /// <remarks>
            /// <para>After this call, this instance won't be valid anymore</para>
            /// <para>CancelCb</para>
            /// </remarks>
            public bool Dismiss()
            {
                var __ret = __Internal.Dismiss((__Instance + __PointerAdjustment));
                return __ret;
            }
        }
    }

    namespace VLC
    {
        public unsafe partial class MediaDiscoverer : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 32)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.SharedPtr.__Internal m_mediaList;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaDiscoverer@VLC@@QEAA@AEAVInstance@1@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr inst, global::System.IntPtr name);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaDiscoverer@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaDiscoverer@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?start@MediaDiscoverer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Start(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?stop@MediaDiscoverer@VLC@@QEAAXXZ")]
                internal static extern void Stop(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?isRunning@MediaDiscoverer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool IsRunning(global::System.IntPtr instance);
            }

            public enum Category
            {
                Devices = 0,
                Lan = 1,
                Podcasts = 2,
                Localdirs = 3
            }

            public unsafe partial class Description : IDisposable
            {
                [StructLayout(LayoutKind.Explicit, Size = 72)]
                public partial struct __Internal
                {
                    [FieldOffset(0)]
                    internal global::Std.BasicString.__Internal m_name;

                    [FieldOffset(32)]
                    internal global::Std.BasicString.__Internal m_longName;

                    [FieldOffset(64)]
                    internal global::libvlcpp.VLC.MediaDiscoverer.Category m_category;

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="??0Description@MediaDiscoverer@VLC@@QEAA@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@0W4libvlc_media_discoverer_category_t@@@Z")]
                    internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr name, global::System.IntPtr longName, global::libvlcpp.LibvlcMediaDiscovererCategoryT cat);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="??0Description@MediaDiscoverer@VLC@@QEAA@AEBV012@@Z")]
                    internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="??1Description@MediaDiscoverer@VLC@@QEAA@XZ")]
                    internal static extern void dtor(global::System.IntPtr instance, int delete);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="?name@Description@MediaDiscoverer@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                    internal static extern global::System.IntPtr Name(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="?longName@Description@MediaDiscoverer@VLC@@QEBAAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                    internal static extern global::System.IntPtr LongName(global::System.IntPtr instance);

                    [SuppressUnmanagedCodeSecurity]
                    [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                        EntryPoint="?category@Description@MediaDiscoverer@VLC@@QEBA?AW4Category@23@XZ")]
                    internal static extern global::libvlcpp.VLC.MediaDiscoverer.Category Category(global::System.IntPtr instance);
                }

                public global::System.IntPtr __Instance { get; protected set; }

                protected int __PointerAdjustment;
                internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaDiscoverer.Description> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaDiscoverer.Description>();
                protected void*[] __OriginalVTables;

                protected bool __ownsNativeInstance;

                internal static global::libvlcpp.VLC.MediaDiscoverer.Description __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
                {
                    return new global::libvlcpp.VLC.MediaDiscoverer.Description(native.ToPointer(), skipVTables);
                }

                internal static global::libvlcpp.VLC.MediaDiscoverer.Description __CreateInstance(global::libvlcpp.VLC.MediaDiscoverer.Description.__Internal native, bool skipVTables = false)
                {
                    return new global::libvlcpp.VLC.MediaDiscoverer.Description(native, skipVTables);
                }

                private static void* __CopyValue(global::libvlcpp.VLC.MediaDiscoverer.Description.__Internal native)
                {
                    var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaDiscoverer.Description.__Internal));
                    global::libvlcpp.VLC.MediaDiscoverer.Description.__Internal.cctor(ret, new global::System.IntPtr(&native));
                    return ret.ToPointer();
                }

                private Description(global::libvlcpp.VLC.MediaDiscoverer.Description.__Internal native, bool skipVTables = false)
                    : this(__CopyValue(native), skipVTables)
                {
                    __ownsNativeInstance = true;
                    NativeToManagedMap[__Instance] = this;
                }

                protected Description(void* native, bool skipVTables = false)
                {
                    if (native == null)
                        return;
                    __Instance = new global::System.IntPtr(native);
                }

                public Description(string name, string longName, global::libvlcpp.LibvlcMediaDiscovererCategoryT cat)
                {
                    __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaDiscoverer.Description.__Internal));
                    __ownsNativeInstance = true;
                    NativeToManagedMap[__Instance] = this;
                    var __allocator0 = new global::Std.Allocator<sbyte>();
                    var __basicString0 = global::Std.BasicStringExtensions.BasicString(name, __allocator0);
                    var __arg0 = __basicString0.__Instance;
                    var __allocator1 = new global::Std.Allocator<sbyte>();
                    var __basicString1 = global::Std.BasicStringExtensions.BasicString(longName, __allocator1);
                    var __arg1 = __basicString1.__Instance;
                    __Internal.ctor((__Instance + __PointerAdjustment), __arg0, __arg1, cat);
                    __basicString0.Dispose(false);
                    __allocator0.Dispose();
                    __basicString1.Dispose(false);
                    __allocator1.Dispose();
                }

                public Description(global::libvlcpp.VLC.MediaDiscoverer.Description _0)
                {
                    __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaDiscoverer.Description.__Internal));
                    __ownsNativeInstance = true;
                    NativeToManagedMap[__Instance] = this;
                    if (ReferenceEquals(_0, null))
                        throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                    var __arg0 = _0.__Instance;
                    __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
                }

                public void Dispose()
                {
                    Dispose(disposing: true);
                }

                public virtual void Dispose(bool disposing)
                {
                    if (__Instance == IntPtr.Zero)
                        return;
                    global::libvlcpp.VLC.MediaDiscoverer.Description __dummy;
                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
                    if (disposing)
                        __Internal.dtor((__Instance + __PointerAdjustment), 0);
                    if (__ownsNativeInstance)
                        Marshal.FreeHGlobal(__Instance);
                    __Instance = IntPtr.Zero;
                }

                public string Name
                {
                    get
                    {
                        var __ret = __Internal.Name((__Instance + __PointerAdjustment));
                        var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                        return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                    }
                }

                public string LongName
                {
                    get
                    {
                        var __ret = __Internal.LongName((__Instance + __PointerAdjustment));
                        var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                        return global::Std.BasicStringExtensions.CStr(__basicStringRet);
                    }
                }

                public global::libvlcpp.VLC.MediaDiscoverer.Category Category
                {
                    get
                    {
                        var __ret = __Internal.Category((__Instance + __PointerAdjustment));
                        return __ret;
                    }
                }
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaDiscoverer> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaDiscoverer>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.MediaDiscoverer __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaDiscoverer(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaDiscoverer __CreateInstance(global::libvlcpp.VLC.MediaDiscoverer.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaDiscoverer(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaDiscoverer.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaDiscoverer.__Internal));
                global::libvlcpp.VLC.MediaDiscoverer.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaDiscoverer(global::libvlcpp.VLC.MediaDiscoverer.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaDiscoverer(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            /// <summary>Discover media service by name.</summary>
            /// <param name="p_inst">libvlc instance</param>
            /// <param name="psz_name">service name</param>
            public MediaDiscoverer(global::libvlcpp.VLC.Instance inst, string name)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaDiscoverer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(inst, null))
                    throw new global::System.ArgumentNullException("inst", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = inst.__Instance;
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(name, __allocator1);
                var __arg1 = __basicString1.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0, __arg1);
                __basicString1.Dispose(false);
                __allocator1.Dispose();
            }

            public MediaDiscoverer(global::libvlcpp.VLC.MediaDiscoverer _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaDiscoverer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.MediaDiscoverer __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            /// <summary>Start media discovery.</summary>
            /// <returns>false in case of error, true otherwise</returns>
            /// <remarks>
            /// <para>To stop it, call MediaDiscover::stop() or</para>
            /// <para>destroy the object directly.</para>
            /// <para>MediaDiscover::stop</para>
            /// </remarks>
            public bool Start()
            {
                var __ret = __Internal.Start((__Instance + __PointerAdjustment));
                return __ret;
            }

            /// <summary>Stop media discovery.</summary>
            /// <remarks>MediaDiscoverer::start()</remarks>
            public void Stop()
            {
                __Internal.Stop((__Instance + __PointerAdjustment));
            }

            /// <summary>Query if media service discover object is running.</summary>
            /// <returns>true if running, false if not</returns>
            public bool IsRunning
            {
                get
                {
                    var __ret = __Internal.IsRunning((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }
        }
    }

    namespace VLC
    {
        public unsafe partial class Instance : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 48)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_callbacks;

                [FieldOffset(16)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(32)]
                internal global::Std.SharedPtr.__Internal m_callbacks_pointers;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0Instance@VLC@@QEAA@HPEBQEBD@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, int argc, sbyte** argv);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0Instance@VLC@@QEAA@XZ")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0Instance@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1Instance@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??8Instance@VLC@@QEBA_NAEBV01@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool OperatorEqualEqual(global::System.IntPtr instance, global::System.IntPtr another);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?addIntf@Instance@VLC@@QEAA_NAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool AddIntf(global::System.IntPtr instance, global::System.IntPtr name);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setUserAgent@Instance@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@0@Z")]
                internal static extern void SetUserAgent(global::System.IntPtr instance, global::System.IntPtr name, global::System.IntPtr http);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setAppId@Instance@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@00@Z")]
                internal static extern void SetAppId(global::System.IntPtr instance, global::System.IntPtr id, global::System.IntPtr version, global::System.IntPtr icon);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?logUnset@Instance@VLC@@QEAAXXZ")]
                internal static extern void LogUnset(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?logSetFile@Instance@VLC@@QEAAXPEAU_iobuf@@@Z")]
                internal static extern void LogSetFile(global::System.IntPtr instance, global::System.IntPtr stream);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?unsetDialogHandlers@Instance@VLC@@QEAAXXZ")]
                internal static extern void UnsetDialogHandlers(global::System.IntPtr instance);
            }

            internal enum CallbackIdx : uint
            {
                Exit = 0,
                Log = 1,
                ErrorDisplay = 2,
                LoginDisplay = 3,
                QuestionDisplay = 4,
                ProgressDisplay = 5,
                CancelDialog = 6,
                ProgressUpdate = 7
            }

            /// <summary>Called when an error message needs to be displayed.</summary>
            /// <param name="title">title of the dialog</param>
            /// <param name="text">text of the dialog</param>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate void ErrorCb(global::System.IntPtr title, global::System.IntPtr text);

            /// <summary>Called when a login dialog needs to be displayed.</summary>
            /// <param name="dialog">used to interact with the dialog</param>
            /// <param name="title">title of the dialog</param>
            /// <param name="text">text of the dialog</param>
            /// <param name="defaultUserName">user name that should be set on the user form</param>
            /// <param name="askToStore">if true, ask the user if he wants to save the credentials</param>
            /// <remarks>
            /// <para>You can interact with this dialog by using the postLogin method on dialog to post an answer or the dismiss method to cancel this dialog.</para>
            /// <para>to receive this callack, CancelCb should not be NULL.</para>
            /// </remarks>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate void LoginCb(global::System.IntPtr dialog, global::System.IntPtr title, global::System.IntPtr text, global::System.IntPtr defaultUserName, [MarshalAs(UnmanagedType.I1)] bool askToStore);

            /// <summary>Called when a question dialog needs to be displayed</summary>
            /// <param name="dialog">used to interact with the dialog</param>
            /// <param name="title">title of the diaog</param>
            /// <param name="text">text of the dialog</param>
            /// <param name="qtype">question type (or severity) of the dialog</param>
            /// <param name="cancel">text of the cancel button</param>
            /// <param name="action1">
            /// <para>text of the first button, if NULL, don't display this</para>
            /// <para>button</para>
            /// </param>
            /// <param name="action2">
            /// <para>text of the second button, if NULL, don't display</para>
            /// <para>this button</para>
            /// </param>
            /// <remarks>
            /// <para>You can interact with this dialog by using the postAction method on dialog</para>
            /// <para>to post an answer or dismiss method to cancel this dialog.</para>
            /// <para>to receive this callack, CancelCb should not be</para>
            /// <para>NULL.</para>
            /// </remarks>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate void QuestionCb(global::System.IntPtr dialog, global::System.IntPtr title, global::System.IntPtr text, global::libvlcpp.LibvlcDialogQuestionType qType, global::System.IntPtr cancel, global::System.IntPtr action1, global::System.IntPtr action2);

            /// <summary>Called when a progress dialog needs to be displayed</summary>
            /// <param name="dialog">used to interact with the dialog</param>
            /// <param name="title">title of the diaog</param>
            /// <param name="text">text of the dialog</param>
            /// <param name="indeterminate">true if the progress dialog is indeterminate</param>
            /// <param name="position">
            /// <para>initial position of the progress bar (between 0.0 and</para>
            /// <para>1.0)</para>
            /// </param>
            /// <param name="cancel">
            /// <para>text of the cancel button, if NULL the dialog is not</para>
            /// <para>cancellable</para>
            /// </param>
            /// <remarks>
            /// <para>If cancellable (cancel != NULL), you can cancel this dialog by</para>
            /// <para>calling the dismiss method on dialog</para>
            /// <para>to receive this callack, CancelCb and</para>
            /// <para>UpdtProgressCb should not be NULL.</para>
            /// </remarks>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate void DspProgressCb(global::System.IntPtr dialog, global::System.IntPtr title, global::System.IntPtr text, [MarshalAs(UnmanagedType.I1)] bool intermediate, float position, global::System.IntPtr cancel);

            /// <summary>Called when a displayed dialog needs to be cancelled</summary>
            /// <param name="dialog">used to interact with the dialog</param>
            /// <remarks>
            /// <para>The implementation must call the method dismiss on dialog to really release</para>
            /// <para>the dialog.</para>
            /// </remarks>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate void CancelCb(global::System.IntPtr dialog);

            /// <summary>Called when a progress dialog needs to be updated</summary>
            /// <param name="dialog">used to interact with the dialog</param>
            /// <param name="position">osition of the progress bar (between 0.0 and 1.0)</param>
            /// <param name="text">new text of the progress dialog</param>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate void UpdtProgressCb(global::System.IntPtr dialog, float position, global::System.IntPtr text);

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.Instance> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.Instance>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.Instance __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.Instance(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.Instance __CreateInstance(global::libvlcpp.VLC.Instance.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.Instance(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.Instance.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Instance.__Internal));
                global::libvlcpp.VLC.Instance.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private Instance(global::libvlcpp.VLC.Instance.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected Instance(void* native, bool skipVTables = false)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            /// <summary>
            /// <para>Create and initialize a libvlc instance. This functions accept a list</para>
            /// <para>of &quot;command line&quot; arguments similar to the main(). These arguments</para>
            /// <para>affect the LibVLC instance default configuration.</para>
            /// </summary>
            /// <param name="argc">the number of arguments (should be 0)</param>
            /// <param name="argv">list of arguments (should be NULL)</param>
            /// <remarks>
            /// <para>Arguments are meant to be passed from the command line to</para>
            /// <para>LibVLC, just like VLC media player does. The list of valid arguments</para>
            /// <para>depends on the LibVLC version, the operating system and platform, and</para>
            /// <para>set of available LibVLC plugins. Invalid or unsupported arguments will</para>
            /// <para>cause the function to fail (i.e. return NULL). Also, some arguments</para>
            /// <para>may alter the behaviour or otherwise interfere with other LibVLC</para>
            /// <para>functions.</para>
            /// <para>There is absolutely no warranty or promise of forward,</para>
            /// <para>backward and cross-platform compatibility with regards to</para>
            /// <para>Instance::Instance() arguments. We recommend that you do not use them,</para>
            /// <para>other than when debugging.</para>
            /// </remarks>
            public Instance(int argc, sbyte** argv)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Instance.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                __Internal.ctor((__Instance), argc, argv);
            }

            /// <summary>Create an empty VLC instance.</summary>
            /// <remarks>Calling any method on such an instance is undefined.</remarks>
            public Instance()
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Instance.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                __Internal.ctor((__Instance));
            }

            public Instance(global::libvlcpp.VLC.Instance _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Instance.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor((__Instance), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.Instance __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static bool operator !=(global::libvlcpp.VLC.Instance __op, global::libvlcpp.VLC.Instance another)
            {
                return !(__op == another);
            }

            /// <summary>Check if 2 Instance objects contain the same libvlc_instance_t.</summary>
            /// <param name="another">another Instance</param>
            /// <returns>true if they contain the same libvlc_instance_t</returns>
            public static bool operator ==(global::libvlcpp.VLC.Instance __op, global::libvlcpp.VLC.Instance another)
            {
                bool __opNull = ReferenceEquals(__op, null);
                bool anotherNull = ReferenceEquals(another, null);
                if (__opNull || anotherNull)
                    return __opNull && anotherNull;
                var __arg0 = __op.__Instance;
                var __arg1 = another.__Instance;
                var __ret = __Internal.OperatorEqualEqual(__arg0, __arg1);
                return __ret;
            }

            public override bool Equals(object obj)
            {
                return this == obj as global::libvlcpp.VLC.Instance;
            }

            public override int GetHashCode()
            {
                if (__Instance == global::System.IntPtr.Zero)
                    return global::System.IntPtr.Zero.GetHashCode();
                return (*(global::libvlcpp.VLC.Instance.__Internal*) __Instance).GetHashCode();
            }

            /// <summary>Try to start a user interface for the libvlc instance.</summary>
            /// <param name="name">interface name, or empty string for default</param>
            public bool AddIntf(string name)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(name, __allocator0);
                var __arg0 = __basicString0.__Instance;
                var __ret = __Internal.AddIntf((__Instance), __arg0);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
                return __ret;
            }

            /// <summary>
            /// <para>Sets the application name. LibVLC passes this as the user agent string</para>
            /// <para>when a protocol requires it.</para>
            /// </summary>
            /// <param name="name">
            /// <para>human-readable application name, e.g. &quot;FooBar player</para>
            /// <para>1.2.3&quot;</para>
            /// </param>
            /// <param name="http">HTTP User Agent, e.g. &quot;FooBar/1.2.3 Python/2.6.0&quot;</param>
            /// <remarks>LibVLC 1.1.1 or later</remarks>
            public void SetUserAgent(string name, string http)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(name, __allocator0);
                var __arg0 = __basicString0.__Instance;
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(http, __allocator1);
                var __arg1 = __basicString1.__Instance;
                __Internal.SetUserAgent((__Instance), __arg0, __arg1);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
                __basicString1.Dispose(false);
                __allocator1.Dispose();
            }

            /// <summary>
            /// <para>Sets some meta-information about the application. See also</para>
            /// <para>Instance::setUserAgent() .</para>
            /// </summary>
            /// <param name="id">Java-style application identifier, e.g. &quot;com.acme.foobar&quot;</param>
            /// <param name="version">application version numbers, e.g. &quot;1.2.3&quot;</param>
            /// <param name="icon">application icon name, e.g. &quot;foobar&quot;</param>
            /// <remarks>LibVLC 2.1.0 or later.</remarks>
            public void SetAppId(string id, string version, string icon)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(id, __allocator0);
                var __arg0 = __basicString0.__Instance;
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(version, __allocator1);
                var __arg1 = __basicString1.__Instance;
                var __allocator2 = new global::Std.Allocator<sbyte>();
                var __basicString2 = global::Std.BasicStringExtensions.BasicString(icon, __allocator2);
                var __arg2 = __basicString2.__Instance;
                __Internal.SetAppId((__Instance), __arg0, __arg1, __arg2);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
                __basicString1.Dispose(false);
                __allocator1.Dispose();
                __basicString2.Dispose(false);
                __allocator2.Dispose();
            }

            /// <summary>
            /// <para>Unsets the logging callback for a LibVLC instance. This is rarely</para>
            /// <para>needed: the callback is implicitly unset when the instance is</para>
            /// <para>destroyed. This function will wait for any pending callbacks</para>
            /// <para>invocation to complete (causing a deadlock if called from within the</para>
            /// <para>callback).</para>
            /// </summary>
            /// <remarks>LibVLC 2.1.0 or later</remarks>
            public void LogUnset()
            {
                __Internal.LogUnset((__Instance));
            }

            /// <summary>Sets up logging to a file.</summary>
            /// <param name="stream">
            /// <para>FILE pointer opened for writing (the FILE pointer must</para>
            /// <para>remain valid until Instance::logUnset() )</para>
            /// </param>
            /// <remarks>LibVLC 2.1.0 or later</remarks>
            public void LogSetFile(global::System.IntPtr stream)
            {
                __Internal.LogSetFile((__Instance), stream);
            }

            /// <summary>Unset all callbacks</summary>
            public void UnsetDialogHandlers()
            {
                __Internal.UnsetDialogHandlers((__Instance));
            }

            public global::System.IntPtr __PointerToInternal
            {
                get
                {
                    return __Instance + 0;
                }
            }
        }

        namespace DialogType
        {
            public unsafe partial class Instance
            {
                public partial struct __Internal
                {
                }

                public static global::libvlcpp.LibvlcDialogQuestionType Normal
                {
                    get
                    {
                        var __ptr = (global::libvlcpp.LibvlcDialogQuestionType*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?normal@DialogType@VLC@@3W4libvlc_dialog_question_type@@B");
                        return *__ptr;
                    }
                }

                public static global::libvlcpp.LibvlcDialogQuestionType Warning
                {
                    get
                    {
                        var __ptr = (global::libvlcpp.LibvlcDialogQuestionType*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?warning@DialogType@VLC@@3W4libvlc_dialog_question_type@@B");
                        return *__ptr;
                    }
                }

                public static global::libvlcpp.LibvlcDialogQuestionType Critical
                {
                    get
                    {
                        var __ptr = (global::libvlcpp.LibvlcDialogQuestionType*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?critical@DialogType@VLC@@3W4libvlc_dialog_question_type@@B");
                        return *__ptr;
                    }
                }
            }
        }
    }

    namespace VLC
    {
        public unsafe partial class Media : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 48)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_callbacks;

                [FieldOffset(16)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(32)]
                internal global::Std.SharedPtr.__Internal m_eventManager;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0Media@VLC@@QEAA@AEAVInstance@1@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4FromType@01@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr instance, global::System.IntPtr mrl, global::libvlcpp.VLC.Media.FromType type);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0Media@VLC@@QEAA@AEAVInstance@1@H@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr instance, int fd);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0Media@VLC@@QEAA@AEAVMediaList@1@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr list);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0Media@VLC@@QEAA@XZ")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0Media@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1Media@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??8Media@VLC@@QEBA_NAEBV01@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool OperatorEqualEqual(global::System.IntPtr instance, global::System.IntPtr another);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?addOption@Media@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern void AddOption(global::System.IntPtr instance, global::System.IntPtr psz_options);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?addOptionFlag@Media@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@I@Z")]
                internal static extern void AddOptionFlag(global::System.IntPtr instance, global::System.IntPtr psz_options, uint i_flags);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?meta@Media@VLC@@QEAA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4libvlc_meta_t@@@Z")]
                internal static extern void Meta(global::System.IntPtr instance, global::System.IntPtr @return, global::libvlcpp.LibvlcMetaT e_meta);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMeta@Media@VLC@@QEAAXW4libvlc_meta_t@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern void SetMeta(global::System.IntPtr instance, global::libvlcpp.LibvlcMetaT e_meta, global::System.IntPtr psz_value);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?saveMeta@Media@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool SaveMeta(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?stats@Media@VLC@@QEAA_NPEAUlibvlc_media_stats_t@@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Stats(global::System.IntPtr instance, global::System.IntPtr p_stats);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?parseWithOptions@Media@VLC@@QEAA_NW4ParseFlags@12@H@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool ParseWithOptions(global::System.IntPtr instance, global::libvlcpp.VLC.Media.ParseFlags flags, int timeout);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?addSlave@Media@VLC@@QEAA_NW4Type@MediaSlave@2@IAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool AddSlave(global::System.IntPtr instance, global::libvlcpp.VLC.MediaSlave.Type type, uint priority, global::System.IntPtr uri);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?slavesClear@Media@VLC@@QEAAXXZ")]
                internal static extern void SlavesClear(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?userData@Media@VLC@@QEAAPEAXXZ")]
                internal static extern global::System.IntPtr UserData(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setUserData@Media@VLC@@QEAAXPEAX@Z")]
                internal static extern void SetUserData(global::System.IntPtr instance, global::System.IntPtr p_new_user_data);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?mrl@Media@VLC@@QEAA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern void Mrl(global::System.IntPtr instance, global::System.IntPtr @return);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?duplicate@Media@VLC@@QEAA?AV12@XZ")]
                internal static extern void Duplicate(global::System.IntPtr instance, global::System.IntPtr @return);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?state@Media@VLC@@QEAA?AW4libvlc_state_t@@XZ")]
                internal static extern global::libvlcpp.LibvlcStateT State(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?eventManager@Media@VLC@@QEAAAEAVMediaEventManager@2@XZ")]
                internal static extern global::System.IntPtr EventManager(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?duration@Media@VLC@@QEAA_JXZ")]
                internal static extern long Duration(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?parsedStatus@Media@VLC@@QEAA?AW4ParsedStatus@12@XZ")]
                internal static extern global::libvlcpp.VLC.Media.ParsedStatus parsedStatus(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?type@Media@VLC@@QEAA?AW4Type@12@XZ")]
                internal static extern global::libvlcpp.VLC.Media.Type type(global::System.IntPtr instance);
            }

            internal enum CallbackIdx : uint
            {
                Open = 0,
                Read = 1,
                Seek = 2,
                Close = 3
            }

            /// <summary>
            /// <para>The FromType enum is used to drive the media creation.</para>
            /// <para>A media is usually created using a string, which can represent one of 3 things:</para>
            /// </summary>
            public enum FromType
            {
                /// <summary>Create a media for a certain file path.</summary>
                FromPath = 0,
                /// <summary>
                /// <para>Create a media with a certain given media resource location,</para>
                /// <para>for instance a valid URL.</para>
                /// </summary>
                /// <remarks>
                /// <para>To refer to a local file with this function,</para>
                /// <para>the file://... URI syntaxmustbe used (see IETF RFC3986).</para>
                /// <para>We recommend using FromPath instead when dealing with</para>
                /// <para>local files.</para>
                /// </remarks>
                FromLocation = 1,
                /// <summary>Create a media as an empty node with a given name.</summary>
                AsNode = 2
            }

            [Flags]
            public enum ParseFlags
            {
                /// <summary>Parse media if it's a local file</summary>
                Local = 0,
                /// <summary>Parse media even if it's a network file</summary>
                Network = 1,
                /// <summary>Fetch meta and covert art using local resources</summary>
                FetchLocal = 2,
                /// <summary>Fetch meta and covert art using network resources</summary>
                FetchNetwork = 4,
                /// <summary>
                /// <para>Interact with the user (via libvlc_dialog_cbs) when preparsing this item</para>
                /// <para>(and not its sub items). Set this flag in order to receive a callback</para>
                /// <para>when the input is asking for credentials.</para>
                /// </summary>
                Interact = 8
            }

            public enum ParsedStatus
            {
                Skipped = 1,
                Failed = 2,
                Done = 4,
                Timeout = 3
            }

            public enum Type
            {
                Unknown = 0,
                File = 1,
                Directory = 2,
                Disc = 3,
                Stream = 4,
                Playlist = 5
            }

            /// <summary>Callback prototype to open a custom bitstream input media.</summary>
            /// <param name="opaque">private pointer as passed to libvlc_media_new_callbacks()</param>
            /// <param name="datap">storage space for a private data pointer [OUT]</param>
            /// <param name="sizep">byte length of the bitstream or 0 if unknown [OUT]</param>
            /// <returns>
            /// <para>0 on success, non-zero on error. In case of failure, the other</para>
            /// <para>callbacks will not be invoked and any value stored in *datap and *sizep is</para>
            /// <para>discarded.</para>
            /// </returns>
            /// <remarks>
            /// <para>The same media item can be opened multiple times. Each time, this callback</para>
            /// <para>is invoked. It should allocate and initialize any instance-specific</para>
            /// <para>resources, then store them in *datap. The instance resources can be freed</para>
            /// <para>in the</para>
            /// <para>For convenience, *datap is initially NULL and *sizep is initially 0.</para>
            /// </remarks>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate int ExpectedMediaOpenCb(global::System.IntPtr _0, void** datap, ulong* sizep);

            /// <summary>Callback prototype to read data from a custom bitstream input media.</summary>
            /// <param name="opaque">private pointer as set by the</param>
            /// <param name="buf">start address of the buffer to read data into</param>
            /// <param name="len">bytes length of the buffer</param>
            /// <returns>
            /// <para>strictly positive number of bytes read, 0 on end-of-stream,</para>
            /// <para>or -1 on non-recoverable error</para>
            /// </returns>
            /// <remarks>
            /// <para>callback</para>
            /// <para>If no data is immediately available, then the callback should sleep.</para>
            /// <para>The application is responsible for avoiding deadlock situations.</para>
            /// <para>In particular, the callback should return an error if playback is stopped;</para>
            /// <para>if it does not return, then libvlc_media_player_stop() will never return.</para>
            /// </remarks>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate int ExpectedMediaReadCb(global::System.IntPtr opaque, byte* buf, ulong len);

            /// <summary>Callback prototype to seek a custom bitstream input media.</summary>
            /// <param name="opaque">private pointer as set by the</param>
            /// <param name="offset">absolute byte offset to seek to</param>
            /// <returns>0 on success, -1 on error.</returns>
            /// <remarks>callback</remarks>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate int ExpectedMediaSeekCb(global::System.IntPtr opaque, ulong _0);

            /// <summary>Callback prototype to close a custom bitstream input media.</summary>
            /// <param name="opaque">private pointer as set by the</param>
            /// <remarks>callback</remarks>
            [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
            public unsafe delegate void ExpectedMediaCloseCb(global::System.IntPtr opaque);

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.Media> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.Media>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.Media __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.Media(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.Media __CreateInstance(global::libvlcpp.VLC.Media.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.Media(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.Media.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Media.__Internal));
                global::libvlcpp.VLC.Media.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private Media(global::libvlcpp.VLC.Media.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected Media(void* native, bool skipVTables = false)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            /// <summary>Media Constructs a libvlc Media instance</summary>
            /// <param name="instance">A libvlc instance</param>
            /// <param name="mrl">A path, location, or node name, depending on the 3rd parameter</param>
            /// <param name="type">The type of the 2nd argument.</param>
            /// <remarks>{FromType}</remarks>
            public Media(global::libvlcpp.VLC.Instance instance, string mrl, global::libvlcpp.VLC.Media.FromType type)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Media.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(instance, null))
                    throw new global::System.ArgumentNullException("instance", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = instance.__Instance;
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(mrl, __allocator1);
                var __arg1 = __basicString1.__Instance;
                __Internal.ctor((__Instance + 16), __arg0, __arg1, type);
                __basicString1.Dispose(false);
                __allocator1.Dispose();
            }

            /// <summary>
            /// <para>Create a media for an already open file descriptor.</para>
            /// <para>The file descriptor shall be open for reading (or reading and writing).</para>
            /// </summary>
            /// <param name="instance">the instance</param>
            /// <param name="fd">open file descriptor</param>
            /// <returns>the newly created media</returns>
            /// <remarks>
            /// <para>Regular file descriptors, pipe read descriptors and character device</para>
            /// <para>descriptors (including TTYs) are supported on all platforms.</para>
            /// <para>Block device descriptors are supported where available.</para>
            /// <para>Directory descriptors are supported on systems that provide fdopendir().</para>
            /// <para>Sockets are supported on all platforms where they are file descriptors,</para>
            /// <para>i.e. all except Windows.</para>
            /// <para>This library willnotautomatically close the file descriptor</para>
            /// <para>under any circumstance. Nevertheless, a file descriptor can usually only be</para>
            /// <para>rendered once in a media player. To render it a second time, the file</para>
            /// <para>descriptor should probably be rewound to the beginning with lseek().</para>
            /// </remarks>
            public Media(global::libvlcpp.VLC.Instance instance, int fd)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Media.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(instance, null))
                    throw new global::System.ArgumentNullException("instance", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = instance.__Instance;
                __Internal.ctor((__Instance + 16), __arg0, fd);
            }

            /// <summary>
            /// <para>Get media instance from this media list instance. This action will increase</para>
            /// <para>the refcount on the media instance.</para>
            /// <para>The libvlc_media_list_lock should NOT be held upon entering this function.</para>
            /// </summary>
            /// <param name="list">a media list instance</param>
            /// <returns>media instance</returns>
            public Media(global::libvlcpp.VLC.MediaList list)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Media.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(list, null))
                    throw new global::System.ArgumentNullException("list", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = list.__Instance;
                __Internal.ctor((__Instance + 16), __arg0);
            }

            /// <summary>Create an empty VLC Media instance.</summary>
            /// <remarks>Calling any method on such an instance is undefined.</remarks>
            public Media()
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Media.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                __Internal.ctor((__Instance + 16));
            }

            public Media(global::libvlcpp.VLC.Media _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.Media.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + 16), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.Media __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + 16), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static bool operator !=(global::libvlcpp.VLC.Media __op, global::libvlcpp.VLC.Media another)
            {
                return !(__op == another);
            }

            /// <summary>Check if 2 Media objects contain the same libvlc_media_t.</summary>
            /// <param name="another">another Media</param>
            /// <returns>true if they contain the same libvlc_media_t</returns>
            public static bool operator ==(global::libvlcpp.VLC.Media __op, global::libvlcpp.VLC.Media another)
            {
                bool __opNull = ReferenceEquals(__op, null);
                bool anotherNull = ReferenceEquals(another, null);
                if (__opNull || anotherNull)
                    return __opNull && anotherNull;
                var __arg0 = __op.__Instance;
                var __arg1 = another.__Instance;
                var __ret = __Internal.OperatorEqualEqual(__arg0, __arg1);
                return __ret;
            }

            public override bool Equals(object obj)
            {
                return this == obj as global::libvlcpp.VLC.Media;
            }

            public override int GetHashCode()
            {
                if (__Instance == global::System.IntPtr.Zero)
                    return global::System.IntPtr.Zero.GetHashCode();
                return (*(global::libvlcpp.VLC.Media.__Internal*) __Instance).GetHashCode();
            }

            /// <summary>Add an option to the media.</summary>
            /// <param name="psz_options">the options (as a string)</param>
            /// <remarks>
            /// <para>This option will be used to determine how the media_player will read</para>
            /// <para>the media. This allows to use VLC's advanced reading/streaming options</para>
            /// <para>on a per-media basis.</para>
            /// <para>The options are listed in 'vlc long-help' from the command line,</para>
            /// <para>e.g. &quot;-sout-all&quot;. Keep in mind that available options and their</para>
            /// <para>semantics vary across LibVLC versions and builds.</para>
            /// <para>Not all options affects libvlc_media_t objects: Specifically,</para>
            /// <para>due to architectural issues most audio and video options, such as text</para>
            /// <para>renderer options, have no effects on an individual media. These</para>
            /// <para>options must be set through Instance::Instance() instead.</para>
            /// </remarks>
            public void AddOption(string psz_options)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(psz_options, __allocator0);
                var __arg0 = __basicString0.__Instance;
                __Internal.AddOption((__Instance + 16), __arg0);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
            }

            /// <summary>Add an option to the media with configurable flags.</summary>
            /// <param name="psz_options">the options (as a string)</param>
            /// <param name="i_flags">the flags for this option</param>
            /// <remarks>
            /// <para>This option will be used to determine how the media_player will read</para>
            /// <para>the media. This allows to use VLC's advanced reading/streaming options</para>
            /// <para>on a per-media basis.</para>
            /// <para>The options are detailed in vlc long-help, for instance &quot;--sout-all&quot;.</para>
            /// <para>Note that all options are not usable on medias: specifically, due to</para>
            /// <para>architectural issues, video-related options such as text renderer</para>
            /// <para>options cannot be set on a single media. They must be set on the whole</para>
            /// <para>libvlc instance instead.</para>
            /// </remarks>
            public void AddOptionFlag(string psz_options, uint i_flags)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(psz_options, __allocator0);
                var __arg0 = __basicString0.__Instance;
                __Internal.AddOptionFlag((__Instance + 16), __arg0, i_flags);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
            }

            /// <summary>Read the meta of the media.</summary>
            /// <param name="e_meta">the meta to read</param>
            /// <returns>the media's meta</returns>
            /// <remarks>
            /// <para>If the media has not yet been parsed this will return NULL.</para>
            /// <para>This methods automatically calls parseAsync() , so after</para>
            /// <para>calling it you may receive a libvlc_MediaMetaChanged event. If you</para>
            /// <para>prefer a synchronous version ensure that you call parse()</para>
            /// <para>before get_meta().</para>
            /// <para>parse()</para>
            /// <para>parseAsync()</para>
            /// <para>libvlc_MediaMetaChanged</para>
            /// </remarks>
            public string Meta(global::libvlcpp.LibvlcMetaT e_meta)
            {
                var __ret = new global::Std.BasicString.__Internal();
                __Internal.Meta((__Instance + 16), new IntPtr(&__ret), e_meta);
                var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                var __stringRet = global::Std.BasicStringExtensions.CStr(__basicStringRet);
                __basicStringRet.Dispose(false);
                return __stringRet;
            }

            /// <summary>
            /// <para>Set the meta of the media (this function will not save the meta, call</para>
            /// <para>libvlc_media_save_meta in order to save the meta)</para>
            /// </summary>
            /// <param name="e_meta">the meta to write</param>
            /// <param name="psz_value">the media's meta</param>
            public void SetMeta(global::libvlcpp.LibvlcMetaT e_meta, string psz_value)
            {
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(psz_value, __allocator1);
                var __arg1 = __basicString1.__Instance;
                __Internal.SetMeta((__Instance + 16), e_meta, __arg1);
                __basicString1.Dispose(false);
                __allocator1.Dispose();
            }

            /// <summary>Save the meta previously set</summary>
            /// <returns>true if the write operation was successful</returns>
            public bool SaveMeta()
            {
                var __ret = __Internal.SaveMeta((__Instance + 16));
                return __ret;
            }

            /// <summary>Get the current statistics about the media</summary>
            /// <param name="p_stats">
            /// <para>structure that contain the statistics about the media</para>
            /// <para>(this structure must be allocated by the caller)</para>
            /// </param>
            /// <returns>true if the statistics are available, false otherwise</returns>
            public bool Stats(global::libvlcpp.LibvlcMediaStatsT p_stats)
            {
                var __arg0 = ReferenceEquals(p_stats, null) ? global::System.IntPtr.Zero : p_stats.__Instance;
                var __ret = __Internal.Stats((__Instance + 16), __arg0);
                return __ret;
            }

            /// <summary>Parse the media asynchronously with options.</summary>
            /// <param name="flags">parse options</param>
            /// <param name="timeout">
            /// <para>maximum time allowed to preparse the media. If -1, the</para>
            /// <para>default &quot;preparse-timeout&quot; option will be used as a timeout. If 0, it will</para>
            /// <para>wait indefinitely. If &gt; 0, the timeout will be used (in milliseconds).</para>
            /// </param>
            /// <returns>true on success, false otherwise</returns>
            /// <remarks>
            /// <para>This fetches (local or network) art, meta data and/or tracks information.</para>
            /// <para>This method is the extended version of libvlc_media_parse_async().</para>
            /// <para>To track when this is over you can listen to libvlc_MediaParsedStatus</para>
            /// <para>event. However if this functions returns an error, you will not receive any</para>
            /// <para>events.</para>
            /// <para>It uses a flag to specify parse options (see libvlc_media_parse_flag_t). All</para>
            /// <para>these flags can be combined. By default, media is parsed if it's a local</para>
            /// <para>file.</para>
            /// <para>ParsedStatus</para>
            /// <para>meta()</para>
            /// <para>tracks()</para>
            /// <para>parsedStatus</para>
            /// <para>ParseFlag</para>
            /// <para>LibVLC 3.0.0 or later</para>
            /// </remarks>
            public bool ParseWithOptions(global::libvlcpp.VLC.Media.ParseFlags flags, int timeout)
            {
                var __ret = __Internal.ParseWithOptions((__Instance + 16), flags, timeout);
                return __ret;
            }

            /// <summary>Add a slave to the current media.</summary>
            /// <param name="uri">Uri of the slave (should contain a valid scheme).</param>
            /// <param name="type">subtitle or audio</param>
            /// <param name="priority">from 0 (low priority) to 4 (high priority)</param>
            /// <returns>true on success, false on error.</returns>
            /// <remarks>
            /// <para>A slave is an external input source that may contains an additional subtitle</para>
            /// <para>track (like a .srt) or an additional audio track (like a .ac3).</para>
            /// <para>This function must be called before the media is parsed (via parseWithOptions())</para>
            /// <para>or before the media is played (via MediaPlayer::play())</para>
            /// <para>LibVLC 3.0.0 and later.</para>
            /// </remarks>
            public bool AddSlave(global::libvlcpp.VLC.MediaSlave.Type type, uint priority, string uri)
            {
                var __allocator2 = new global::Std.Allocator<sbyte>();
                var __basicString2 = global::Std.BasicStringExtensions.BasicString(uri, __allocator2);
                var __arg2 = __basicString2.__Instance;
                var __ret = __Internal.AddSlave((__Instance + 16), type, priority, __arg2);
                __basicString2.Dispose(false);
                __allocator2.Dispose();
                return __ret;
            }

            /// <summary>
            /// <para>Clear all slaves previously added by addSlave() or</para>
            /// <para>internally.</para>
            /// </summary>
            /// <remarks>LibVLC 3.0.0 and later.</remarks>
            public void SlavesClear()
            {
                __Internal.SlavesClear((__Instance + 16));
            }

            public static implicit operator global::libvlcpp.VLC.Media(global::libvlcpp.VLC.MediaList list)
            {
                return new global::libvlcpp.VLC.Media(list);
            }

            public static global::libvlcpp.VLC.Media.FromType FromPath
            {
                get
                {
                    var __ptr = (global::libvlcpp.VLC.Media.FromType*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?FromPath@Media@VLC@@2W4FromType@12@B");
                    return *__ptr;
                }
            }

            public static global::libvlcpp.VLC.Media.FromType FromLocation
            {
                get
                {
                    var __ptr = (global::libvlcpp.VLC.Media.FromType*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?FromLocation@Media@VLC@@2W4FromType@12@B");
                    return *__ptr;
                }
            }

            public static global::libvlcpp.VLC.Media.FromType AsNode
            {
                get
                {
                    var __ptr = (global::libvlcpp.VLC.Media.FromType*)CppSharp.SymbolResolver.ResolveSymbol("vlcpp", "?AsNode@Media@VLC@@2W4FromType@12@B");
                    return *__ptr;
                }
            }

            public global::System.IntPtr __PointerToInternal
            {
                get
                {
                    return __Instance + 16;
                }
            }

            /// <summary>
            /// <para>Get media descriptor's user_data. user_data is specialized data</para>
            /// <para>accessed by the host application, VLC.framework uses it as a pointer</para>
            /// <para>to an native object that references a libvlc_media_t pointer</para>
            /// </summary>
            /// <param name="p_new_user_data">pointer to user data</param>
            /// <remarks>
            /// <para>Sets media descriptor's user_data. user_data is specialized data</para>
            /// <para>accessed by the host application, VLC.framework uses it as a pointer</para>
            /// <para>to an native object that references a libvlc_media_t pointer</para>
            /// </remarks>
            public global::System.IntPtr UserData
            {
                get
                {
                    var __ret = __Internal.UserData((__Instance + 16));
                    return __ret;
                }

                set
                {
                    __Internal.SetUserData((__Instance + 16), value);
                }
            }

            /// <summary>Get the media resource locator (mrl) from a media descriptor object</summary>
            /// <returns>string with mrl of media descriptor object</returns>
            public string Mrl
            {
                get
                {
                    var __ret = new global::Std.BasicString.__Internal();
                    __Internal.Mrl((__Instance + 16), new IntPtr(&__ret));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    var __stringRet = global::Std.BasicStringExtensions.CStr(__basicStringRet);
                    __basicStringRet.Dispose(false);
                    return __stringRet;
                }
            }

            /// <summary>Duplicate a media descriptor object.</summary>
            public global::libvlcpp.VLC.Media Duplicate
            {
                get
                {
                    var __ret = new global::libvlcpp.VLC.Media.__Internal();
                    __Internal.Duplicate((__Instance + 16), new IntPtr(&__ret));
                    return global::libvlcpp.VLC.Media.__CreateInstance(__ret);
                }
            }

            /// <summary>
            /// <para>Get current state of media descriptor object. Possible media states</para>
            /// <para>are defined in libvlc_structures.c ( libvlc_NothingSpecial=0,</para>
            /// <para>libvlc_Opening, libvlc_Buffering, libvlc_Playing, libvlc_Paused,</para>
            /// <para>libvlc_Stopped, libvlc_Ended, libvlc_Error).</para>
            /// </summary>
            /// <returns>state of media descriptor object</returns>
            /// <remarks>libvlc_state_t</remarks>
            public global::libvlcpp.LibvlcStateT State
            {
                get
                {
                    var __ret = __Internal.State((__Instance + 16));
                    return __ret;
                }
            }

            /// <summary>
            /// <para>Get event manager from media descriptor object. NOTE: this function</para>
            /// <para>doesn't increment reference counting.</para>
            /// </summary>
            /// <returns>event manager object</returns>
            public global::libvlcpp.VLC.MediaEventManager EventManager
            {
                get
                {
                    var __ret = __Internal.EventManager((__Instance + 16));
                    global::libvlcpp.VLC.MediaEventManager __result0;
                    if (__ret == IntPtr.Zero) __result0 = null;
                    else if (global::libvlcpp.VLC.MediaEventManager.NativeToManagedMap.ContainsKey(__ret))
                        __result0 = (global::libvlcpp.VLC.MediaEventManager) global::libvlcpp.VLC.MediaEventManager.NativeToManagedMap[__ret];
                    else __result0 = global::libvlcpp.VLC.MediaEventManager.__CreateInstance(__ret);
                    return __result0;
                }
            }

            /// <summary>Get duration (in ms) of media descriptor object item.</summary>
            /// <returns>duration of media item or -1 on error</returns>
            public long Duration
            {
                get
                {
                    var __ret = __Internal.Duration((__Instance + 16));
                    return __ret;
                }
            }

            public global::libvlcpp.VLC.Media.ParsedStatus parsedStatus
            {
                get
                {
                    var __ret = __Internal.parsedStatus((__Instance + 16));
                    return __ret;
                }
            }

            public global::libvlcpp.VLC.Media.Type type
            {
                get
                {
                    var __ret = __Internal.type((__Instance + 16));
                    return __ret;
                }
            }
        }
    }

    namespace VLC
    {
        /// <summary>The MediaPlayer class exposes libvlc_media_player_t functionnalities</summary>
        public unsafe partial class MediaPlayer : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 48)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_callbacks;

                [FieldOffset(16)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(32)]
                internal global::Std.SharedPtr.__Internal m_eventManager;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaPlayer@VLC@@QEAA@AEAVInstance@1@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaPlayer@VLC@@QEAA@AEAVMedia@1@@Z")]
                internal static extern global::System.IntPtr ctor_1(global::System.IntPtr instance, global::System.IntPtr md);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaPlayer@VLC@@QEAA@XZ")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaPlayer@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_2(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaPlayer@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??8MediaPlayer@VLC@@QEBA_NAEBV01@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool OperatorEqualEqual(global::System.IntPtr instance, global::System.IntPtr another);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMedia@MediaPlayer@VLC@@QEAAXAEAVMedia@2@@Z")]
                internal static extern void SetMedia(global::System.IntPtr instance, global::System.IntPtr md);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setPause@MediaPlayer@VLC@@QEAAX_N@Z")]
                internal static extern void SetPause(global::System.IntPtr instance, bool pause);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?pause@MediaPlayer@VLC@@QEAAXXZ")]
                internal static extern void Pause(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?stop@MediaPlayer@VLC@@QEAAXXZ")]
                internal static extern void Stop(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?chapterCountForTitle@MediaPlayer@VLC@@QEAAHH@Z")]
                internal static extern int ChapterCountForTitle(global::System.IntPtr instance, int i_title);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?previousChapter@MediaPlayer@VLC@@QEAAXXZ")]
                internal static extern void PreviousChapter(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?nextChapter@MediaPlayer@VLC@@QEAAXXZ")]
                internal static extern void NextChapter(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setRate@MediaPlayer@VLC@@QEAAHM@Z")]
                internal static extern int SetRate(global::System.IntPtr instance, float rate);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?canPause@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool CanPause(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?nextFrame@MediaPlayer@VLC@@QEAAXXZ")]
                internal static extern void NextFrame(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?navigate@MediaPlayer@VLC@@QEAAXI@Z")]
                internal static extern void Navigate(global::System.IntPtr instance, uint navigate);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setVideoTitleDisplay@MediaPlayer@VLC@@QEAAXW4libvlc_position_t@@I@Z")]
                internal static extern void SetVideoTitleDisplay(global::System.IntPtr instance, global::libvlcpp.LibvlcPositionT position, uint timeout);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?toggleFullscreen@MediaPlayer@VLC@@QEAAXXZ")]
                internal static extern void ToggleFullscreen(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setEqualizer@MediaPlayer@VLC@@QEAA_NAEAVEqualizer@2@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool SetEqualizer(global::System.IntPtr instance, global::System.IntPtr equalizer);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setAudioFormat@MediaPlayer@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@II@Z")]
                internal static extern void SetAudioFormat(global::System.IntPtr instance, global::System.IntPtr format, uint rate, uint channels);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setAudioOutput@MediaPlayer@VLC@@QEAAHAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern int SetAudioOutput(global::System.IntPtr instance, global::System.IntPtr name);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?outputDeviceSet@MediaPlayer@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@0@Z")]
                internal static extern void OutputDeviceSet(global::System.IntPtr instance, global::System.IntPtr module, global::System.IntPtr device_id);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?outputDeviceSet@MediaPlayer@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern void OutputDeviceSet(global::System.IntPtr instance, global::System.IntPtr device_id);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?toggleMute@MediaPlayer@VLC@@QEAAXXZ")]
                internal static extern void ToggleMute(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setVideoFormat@MediaPlayer@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@III@Z")]
                internal static extern void SetVideoFormat(global::System.IntPtr instance, global::System.IntPtr chroma, uint width, uint height, uint pitch);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setKeyInput@MediaPlayer@VLC@@QEAAX_N@Z")]
                internal static extern void SetKeyInput(global::System.IntPtr instance, bool enable);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMouseInput@MediaPlayer@VLC@@QEAAX_N@Z")]
                internal static extern void SetMouseInput(global::System.IntPtr instance, bool enable);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?size@MediaPlayer@VLC@@QEAA_NIPEAI0@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Size(global::System.IntPtr instance, uint num, uint* px, uint* py);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?cursor@MediaPlayer@VLC@@QEAA_NIPEAH0@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Cursor(global::System.IntPtr instance, uint num, int* px, int* py);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setSpu@MediaPlayer@VLC@@QEAAHH@Z")]
                internal static extern int SetSpu(global::System.IntPtr instance, int i_spu);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setSpuDelay@MediaPlayer@VLC@@QEAAH_J@Z")]
                internal static extern int SetSpuDelay(global::System.IntPtr instance, long i_delay);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setVideoTrack@MediaPlayer@VLC@@QEAAHH@Z")]
                internal static extern int SetVideoTrack(global::System.IntPtr instance, int i_track);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?takeSnapshot@MediaPlayer@VLC@@QEAA_NIAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@II@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool TakeSnapshot(global::System.IntPtr instance, uint num, global::System.IntPtr filepath, uint i_width, uint i_height);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setDeinterlace@MediaPlayer@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern void SetDeinterlace(global::System.IntPtr instance, global::System.IntPtr mode);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?marqueeInt@MediaPlayer@VLC@@QEAAHI@Z")]
                internal static extern int MarqueeInt(global::System.IntPtr instance, uint option);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?marqueeString@MediaPlayer@VLC@@QEAA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@I@Z")]
                internal static extern void MarqueeString(global::System.IntPtr instance, global::System.IntPtr @return, uint option);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMarqueeInt@MediaPlayer@VLC@@QEAAXIH@Z")]
                internal static extern void SetMarqueeInt(global::System.IntPtr instance, uint option, int i_val);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMarqueeString@MediaPlayer@VLC@@QEAAXIAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern void SetMarqueeString(global::System.IntPtr instance, uint option, global::System.IntPtr text);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?logoInt@MediaPlayer@VLC@@QEAAHI@Z")]
                internal static extern int LogoInt(global::System.IntPtr instance, uint option);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setLogoInt@MediaPlayer@VLC@@QEAAXIH@Z")]
                internal static extern void SetLogoInt(global::System.IntPtr instance, uint option, int value);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setLogoString@MediaPlayer@VLC@@QEAAXIAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern void SetLogoString(global::System.IntPtr instance, uint option, global::System.IntPtr value);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?adjustInt@MediaPlayer@VLC@@QEAAHI@Z")]
                internal static extern int AdjustInt(global::System.IntPtr instance, uint option);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setAdjustInt@MediaPlayer@VLC@@QEAAXIH@Z")]
                internal static extern void SetAdjustInt(global::System.IntPtr instance, uint option, int value);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?adjustFloat@MediaPlayer@VLC@@QEAAMI@Z")]
                internal static extern float AdjustFloat(global::System.IntPtr instance, uint option);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setAdjustFloat@MediaPlayer@VLC@@QEAAXIM@Z")]
                internal static extern void SetAdjustFloat(global::System.IntPtr instance, uint option, float value);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?addSlave@MediaPlayer@VLC@@QEAA_NW4Type@MediaSlave@2@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool AddSlave(global::System.IntPtr instance, global::libvlcpp.VLC.MediaSlave.Type type, global::System.IntPtr uri, bool select);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?updateViewpoint@MediaPlayer@VLC@@QEAA_NAEBVVideoViewpoint@2@_N@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool UpdateViewpoint(global::System.IntPtr instance, global::System.IntPtr viewpoint, bool b_absolute);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?nsobject@MediaPlayer@VLC@@QEAAPEAXXZ")]
                internal static extern global::System.IntPtr Nsobject(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setNsobject@MediaPlayer@VLC@@QEAAXPEAX@Z")]
                internal static extern void SetNsobject(global::System.IntPtr instance, global::System.IntPtr drawable);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?xwindow@MediaPlayer@VLC@@QEAAIXZ")]
                internal static extern uint Xwindow(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setXwindow@MediaPlayer@VLC@@QEAAXI@Z")]
                internal static extern void SetXwindow(global::System.IntPtr instance, uint drawable);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?hwnd@MediaPlayer@VLC@@QEAAPEAXXZ")]
                internal static extern global::System.IntPtr Hwnd(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setHwnd@MediaPlayer@VLC@@QEAAXPEAX@Z")]
                internal static extern void SetHwnd(global::System.IntPtr instance, global::System.IntPtr drawable);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?time@MediaPlayer@VLC@@QEAA_JXZ")]
                internal static extern long Time(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setTime@MediaPlayer@VLC@@QEAAX_J@Z")]
                internal static extern void SetTime(global::System.IntPtr instance, long i_time);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?position@MediaPlayer@VLC@@QEAAMXZ")]
                internal static extern float Position(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setPosition@MediaPlayer@VLC@@QEAAXM@Z")]
                internal static extern void SetPosition(global::System.IntPtr instance, float f_pos);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?chapter@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int Chapter(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setChapter@MediaPlayer@VLC@@QEAAXH@Z")]
                internal static extern void SetChapter(global::System.IntPtr instance, int i_chapter);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?title@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int Title(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setTitle@MediaPlayer@VLC@@QEAAXH@Z")]
                internal static extern void SetTitle(global::System.IntPtr instance, int i_title);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?fullscreen@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Fullscreen(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setFullscreen@MediaPlayer@VLC@@QEAAX_N@Z")]
                internal static extern void SetFullscreen(global::System.IntPtr instance, bool fullscreen);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?mute@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Mute(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMute@MediaPlayer@VLC@@QEAAX_N@Z")]
                internal static extern void SetMute(global::System.IntPtr instance, bool mute);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?volume@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int Volume(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setVolume@MediaPlayer@VLC@@QEAA_NH@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool SetVolume(global::System.IntPtr instance, int i_volume);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?audioTrack@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int AudioTrack(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setAudioTrack@MediaPlayer@VLC@@QEAA_NH@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool SetAudioTrack(global::System.IntPtr instance, int i_track);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?channel@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int Channel(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setChannel@MediaPlayer@VLC@@QEAA_NH@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool SetChannel(global::System.IntPtr instance, int channel);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?audioDelay@MediaPlayer@VLC@@QEAA_JXZ")]
                internal static extern long AudioDelay(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setAudioDelay@MediaPlayer@VLC@@QEAA_N_J@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool SetAudioDelay(global::System.IntPtr instance, long i_delay);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?scale@MediaPlayer@VLC@@QEAAMXZ")]
                internal static extern float Scale(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setScale@MediaPlayer@VLC@@QEAAXM@Z")]
                internal static extern void SetScale(global::System.IntPtr instance, float f_factor);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?aspectRatio@MediaPlayer@VLC@@QEAA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern void AspectRatio(global::System.IntPtr instance, global::System.IntPtr @return);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setAspectRatio@MediaPlayer@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern void SetAspectRatio(global::System.IntPtr instance, global::System.IntPtr ar);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?cropGeometry@MediaPlayer@VLC@@QEAA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ")]
                internal static extern void CropGeometry(global::System.IntPtr instance, global::System.IntPtr @return);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setCropGeometry@MediaPlayer@VLC@@QEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z")]
                internal static extern void SetCropGeometry(global::System.IntPtr instance, global::System.IntPtr geometry);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?teletext@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int Teletext(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setTeletext@MediaPlayer@VLC@@QEAAXH@Z")]
                internal static extern void SetTeletext(global::System.IntPtr instance, int i_page);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?eventManager@MediaPlayer@VLC@@QEAAAEAVMediaPlayerEventManager@2@XZ")]
                internal static extern global::System.IntPtr EventManager(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?isPlaying@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool IsPlaying(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?play@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Play(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?length@MediaPlayer@VLC@@QEAA_JXZ")]
                internal static extern long Length(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?chapterCount@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int ChapterCount(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?willPlay@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool WillPlay(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?titleCount@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int TitleCount(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?rate@MediaPlayer@VLC@@QEAAMXZ")]
                internal static extern float Rate(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?state@MediaPlayer@VLC@@QEAA?AW4libvlc_state_t@@XZ")]
                internal static extern global::libvlcpp.LibvlcStateT State(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?hasVout@MediaPlayer@VLC@@QEAAIXZ")]
                internal static extern uint HasVout(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?isSeekable@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool IsSeekable(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?programScrambled@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool ProgramScrambled(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?unsetEqualizer@MediaPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool UnsetEqualizer(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?audioTrackCount@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int AudioTrackCount(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?spu@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int Spu(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?spuCount@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int SpuCount(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?spuDelay@MediaPlayer@VLC@@QEAA_JXZ")]
                internal static extern long SpuDelay(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?videoTrackCount@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int VideoTrackCount(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?videoTrack@MediaPlayer@VLC@@QEAAHXZ")]
                internal static extern int VideoTrack(global::System.IntPtr instance);
            }

            internal enum CallbackIdx : uint
            {
                AudioPlay = 0,
                AudioPause = 1,
                AudioResume = 2,
                AudioFlush = 3,
                AudioDrain = 4,
                AudioVolume = 5,
                AudioSetup = 6,
                AudioCleanup = 7,
                VideoLock = 8,
                VideoUnlock = 9,
                VideoDisplay = 10,
                VideoFormat = 11,
                VideoCleanup = 12
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaPlayer> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaPlayer>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.MediaPlayer __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaPlayer(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaPlayer __CreateInstance(global::libvlcpp.VLC.MediaPlayer.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaPlayer(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaPlayer.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaPlayer.__Internal));
                global::libvlcpp.VLC.MediaPlayer.__Internal.cctor_2(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaPlayer(global::libvlcpp.VLC.MediaPlayer.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaPlayer(void* native, bool skipVTables = false)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            /// <summary>Create an empty Media Player object</summary>
            /// <param name="p_libvlc_instance">
            /// <para>the libvlc instance in which the Media</para>
            /// <para>Player should be created.</para>
            /// </param>
            public MediaPlayer(global::libvlcpp.VLC.Instance instance)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaPlayer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(instance, null))
                    throw new global::System.ArgumentNullException("instance", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = instance.__Instance;
                __Internal.ctor((__Instance), __arg0);
            }

            /// <summary>Create a Media Player object from a Media</summary>
            /// <param name="p_md">the media. Afterwards the p_md can be safely destroyed.</param>
            public MediaPlayer(global::libvlcpp.VLC.Media md)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaPlayer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(md, null))
                    throw new global::System.ArgumentNullException("md", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = md.__Instance;
                __Internal.ctor_1((__Instance), __arg0);
            }

            /// <summary>Create an empty VLC MediaPlayer instance.</summary>
            /// <remarks>Calling any method on such an instance is undefined.</remarks>
            public MediaPlayer()
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaPlayer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                __Internal.ctor((__Instance));
            }

            public MediaPlayer(global::libvlcpp.VLC.MediaPlayer _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaPlayer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_2((__Instance), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.MediaPlayer __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static bool operator !=(global::libvlcpp.VLC.MediaPlayer __op, global::libvlcpp.VLC.MediaPlayer another)
            {
                return !(__op == another);
            }

            /// <summary>Check if 2 MediaPlayer objects contain the same libvlc_media_player_t.</summary>
            /// <param name="another">another MediaPlayer</param>
            /// <returns>true if they contain the same libvlc_media_player_t</returns>
            public static bool operator ==(global::libvlcpp.VLC.MediaPlayer __op, global::libvlcpp.VLC.MediaPlayer another)
            {
                bool __opNull = ReferenceEquals(__op, null);
                bool anotherNull = ReferenceEquals(another, null);
                if (__opNull || anotherNull)
                    return __opNull && anotherNull;
                var __arg0 = __op.__Instance;
                var __arg1 = another.__Instance;
                var __ret = __Internal.OperatorEqualEqual(__arg0, __arg1);
                return __ret;
            }

            public override bool Equals(object obj)
            {
                return this == obj as global::libvlcpp.VLC.MediaPlayer;
            }

            public override int GetHashCode()
            {
                if (__Instance == global::System.IntPtr.Zero)
                    return global::System.IntPtr.Zero.GetHashCode();
                return (*(global::libvlcpp.VLC.MediaPlayer.__Internal*) __Instance).GetHashCode();
            }

            /// <summary>
            /// <para>Set the media that will be used by the media_player. If any, previous</para>
            /// <para>md will be released.</para>
            /// </summary>
            /// <param name="p_md">the Media. Afterwards the p_md can be safely destroyed.</param>
            public void SetMedia(global::libvlcpp.VLC.Media md)
            {
                if (ReferenceEquals(md, null))
                    throw new global::System.ArgumentNullException("md", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = md.__Instance;
                __Internal.SetMedia((__Instance), __arg0);
            }

            /// <summary>Pause or resume (no effect if there is no media)</summary>
            /// <param name="do_pause">play/resume if true, pause if false</param>
            /// <remarks>LibVLC 1.1.1 or later</remarks>
            public void SetPause(bool pause)
            {
                __Internal.SetPause((__Instance), pause);
            }

            /// <summary>pause Toggle pause (no effect if there is no media)</summary>
            public void Pause()
            {
                __Internal.Pause((__Instance));
            }

            /// <summary>stop Stop the playback (no effect if there is no media)</summary>
            /// <remarks>
            /// <para>This is synchronous, and will block until all VLC threads have</para>
            /// <para>been joined.</para>
            /// <para>Calling this from a VLC callback is a bound to cause a deadlock.</para>
            /// </remarks>
            public void Stop()
            {
                __Internal.Stop((__Instance));
            }

            /// <summary>Get title chapter count</summary>
            /// <param name="i_title">title</param>
            /// <returns>number of chapters in title, or -1</returns>
            public int ChapterCountForTitle(int i_title)
            {
                var __ret = __Internal.ChapterCountForTitle((__Instance), i_title);
                return __ret;
            }

            /// <summary>Set previous chapter (if applicable)</summary>
            public void PreviousChapter()
            {
                __Internal.PreviousChapter((__Instance));
            }

            /// <summary>Set next chapter (if applicable)</summary>
            public void NextChapter()
            {
                __Internal.NextChapter((__Instance));
            }

            /// <summary>Set movie play rate</summary>
            /// <param name="rate">movie play rate to set</param>
            /// <returns>
            /// <para>-1 if an error was detected, 0 otherwise (but even then, it</para>
            /// <para>might not actually work depending on the underlying media protocol)</para>
            /// </returns>
            public int SetRate(float rate)
            {
                var __ret = __Internal.SetRate((__Instance), rate);
                return __ret;
            }

            /// <summary>Can this media player be paused?</summary>
            /// <returns>true if the media player can pause</returns>
            public bool CanPause()
            {
                var __ret = __Internal.CanPause((__Instance));
                return __ret;
            }

            /// <summary>Display the next frame (if supported)</summary>
            public void NextFrame()
            {
                __Internal.NextFrame((__Instance));
            }

            /// <summary>Navigate through DVD Menu</summary>
            /// <param name="navigate">the Navigation mode</param>
            /// <remarks>libVLC 2.0.0 or later</remarks>
            public void Navigate(uint navigate)
            {
                __Internal.Navigate((__Instance), navigate);
            }

            /// <summary>Set if, and how, the video title will be shown when media is played.</summary>
            /// <param name="position">
            /// <para>position at which to display the title, or</para>
            /// <para>libvlc_position_disable to prevent the title from being displayed</para>
            /// </param>
            /// <param name="timeout">
            /// <para>title display timeout in milliseconds (ignored if</para>
            /// <para>libvlc_position_disable)</para>
            /// </param>
            /// <remarks>libVLC 2.1.0 or later</remarks>
            public void SetVideoTitleDisplay(global::libvlcpp.LibvlcPositionT position, uint timeout)
            {
                __Internal.SetVideoTitleDisplay((__Instance), position, timeout);
            }

            /// <summary>Toggle fullscreen status on non-embedded video outputs.</summary>
            /// <remarks>
            /// <para>The same limitations applies to this function as to</para>
            /// <para>MediaPlayer::setFullscreen() .</para>
            /// </remarks>
            public void ToggleFullscreen()
            {
                __Internal.ToggleFullscreen((__Instance));
            }

            /// <summary>Apply new equalizer settings to a media player.</summary>
            /// <param name="equalizer">The equalizer to be used by this media player</param>
            /// <returns>true on success, false otherwise</returns>
            /// <remarks>
            /// <para>The equalizer is first created by invoking</para>
            /// <para>libvlc_audio_equalizer_new() or</para>
            /// <para>libvlc_audio_equalizer_new_from_preset() .</para>
            /// <para>It is possible to apply new equalizer settings to a media player</para>
            /// <para>whether the media player is currently playing media or not.</para>
            /// <para>Invoking this method will immediately apply the new equalizer settings</para>
            /// <para>to the audio output of the currently playing media if there is any.</para>
            /// <para>If there is no currently playing media, the new equalizer settings</para>
            /// <para>will be applied later if and when new media is played.</para>
            /// <para>Equalizer settings will automatically be applied to subsequently</para>
            /// <para>played media.</para>
            /// <para>To disable the equalizer for a media player invoke this method passing</para>
            /// <para>NULL for the p_equalizer parameter.</para>
            /// <para>The media player does not keep a reference to the supplied equalizer</para>
            /// <para>so it is safe for an application to release the equalizer reference</para>
            /// <para>any time after this method returns.</para>
            /// <para>LibVLC 2.2.0 or later</para>
            /// </remarks>
            public bool SetEqualizer(global::libvlcpp.VLC.Equalizer equalizer)
            {
                if (ReferenceEquals(equalizer, null))
                    throw new global::System.ArgumentNullException("equalizer", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = equalizer.__Instance;
                var __ret = __Internal.SetEqualizer((__Instance), __arg0);
                return __ret;
            }

            /// <summary>
            /// <para>Set decoded audio format. This only works in combination with</para>
            /// <para>MediaPlayer::setCallbacks() , and is mutually exclusive with</para>
            /// <para>MediaPlayer::setFormatCallbacks() .</para>
            /// </summary>
            /// <param name="format">
            /// <para>a four-characters string identifying the sample format</para>
            /// <para>(e.g. &quot;S16N&quot; or &quot;FL32&quot;)</para>
            /// </param>
            /// <param name="rate">sample rate (expressed in Hz)</param>
            /// <param name="channels">channels count</param>
            /// <remarks>LibVLC 2.0.0 or later</remarks>
            public void SetAudioFormat(string format, uint rate, uint channels)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(format, __allocator0);
                var __arg0 = __basicString0.__Instance;
                __Internal.SetAudioFormat((__Instance), __arg0, rate, channels);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
            }

            /// <summary>Selects an audio output module.</summary>
            /// <param name="name">name of audio output, use psz_name of</param>
            /// <returns>0 if function succeded, -1 on error</returns>
            /// <remarks>
            /// <para>Any change will take be effect only after playback is stopped</para>
            /// <para>and restarted. Audio output cannot be changed while playing.</para>
            /// <para>AudioOutputDescription</para>
            /// </remarks>
            public int SetAudioOutput(string name)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(name, __allocator0);
                var __arg0 = __basicString0.__Instance;
                var __ret = __Internal.SetAudioOutput((__Instance), __arg0);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
                return __ret;
            }

            /// <summary>Configures an explicit audio output device.</summary>
            /// <param name="module">
            /// <para>If NULL, current audio output module. if non-NULL, name</para>
            /// <para>of audio output module (</para>
            /// </param>
            /// <param name="device_id">device identifier string</param>
            /// <returns>Nothing. Errors are ignored (this is a design bug).</returns>
            /// <remarks>
            /// <para>If the module paramater is NULL, audio output will be moved to the</para>
            /// <para>device specified by the device identifier string immediately. This is</para>
            /// <para>the recommended usage.</para>
            /// <para>A list of adequate potential device strings can be obtained with</para>
            /// <para>MediaPlayer::outputDeviceEnum() .</para>
            /// <para>However passing NULL is supported in LibVLC version 2.2.0 and later</para>
            /// <para>only; in earlier versions, this function would have no effects when</para>
            /// <para>the module parameter was NULL.</para>
            /// <para>If the module parameter is not NULL, the device parameter of the</para>
            /// <para>corresponding audio output, if it exists, will be set to the specified</para>
            /// <para>string. Note that some audio output modules do not have such a</para>
            /// <para>parameter (notably MMDevice and PulseAudio).</para>
            /// <para>A list of adequate potential device strings can be obtained with</para>
            /// <para>Instance::audioOutputDeviceList() .</para>
            /// <para>This function does not select the specified audio output plugin.</para>
            /// <para>MediaPlayer::outputSet() is used for that purpose.</para>
            /// <para>The syntax for the device parameter depends on the audio</para>
            /// <para>output. Some audio output modules require further parameters (e.g. a</para>
            /// <para>channels map in the case of ALSA).</para>
            /// <para>AudioOutputDescription )</para>
            /// </remarks>
            public void OutputDeviceSet(string module, string device_id)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(module, __allocator0);
                var __arg0 = __basicString0.__Instance;
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(device_id, __allocator1);
                var __arg1 = __basicString1.__Instance;
                __Internal.OutputDeviceSet((__Instance), __arg0, __arg1);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
                __basicString1.Dispose(false);
                __allocator1.Dispose();
            }

            public void OutputDeviceSet(string device_id)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(device_id, __allocator0);
                var __arg0 = __basicString0.__Instance;
                __Internal.OutputDeviceSet((__Instance), __arg0);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
            }

            /// <summary>Toggle mute status.</summary>
            /// <remarks>
            /// <para>Toggling mute atomically is not always possible: On some</para>
            /// <para>platforms, other processes can mute the VLC audio playback stream</para>
            /// <para>asynchronously. Thus, there is a small race condition where toggling</para>
            /// <para>will not work. See also the limitations of MediaPlayer::setMute() .</para>
            /// </remarks>
            public void ToggleMute()
            {
                __Internal.ToggleMute((__Instance));
            }

            /// <summary>
            /// <para>Set decoded video chroma and dimensions. This only works in</para>
            /// <para>combination with MediaPlayer::setCallbacks() , and is mutually exclusive</para>
            /// <para>with MediaPlayer::setFormatCallbacks() .</para>
            /// </summary>
            /// <param name="chroma">
            /// <para>a four-characters string identifying the chroma (e.g.</para>
            /// <para>&quot;RV32&quot; or &quot;YUYV&quot;)</para>
            /// </param>
            /// <param name="width">pixel width</param>
            /// <param name="height">pixel height</param>
            /// <param name="pitch">line pitch (in bytes)</param>
            /// <remarks>LibVLC 1.1.1 or later</remarks>
            public void SetVideoFormat(string chroma, uint width, uint height, uint pitch)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(chroma, __allocator0);
                var __arg0 = __basicString0.__Instance;
                __Internal.SetVideoFormat((__Instance), __arg0, width, height, pitch);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
            }

            /// <summary>
            /// <para>Enable or disable key press events handling, according to the LibVLC</para>
            /// <para>hotkeys configuration. By default and for historical reasons, keyboard</para>
            /// <para>events are handled by the LibVLC video widget.</para>
            /// </summary>
            /// <param name="on">true to handle key press events, false to ignore them.</param>
            /// <remarks>
            /// <para>On X11, there can be only one subscriber for key press and mouse</para>
            /// <para>click events per window. If your application has subscribed to those</para>
            /// <para>events for the X window ID of the video widget, then LibVLC will not</para>
            /// <para>be able to handle key presses and mouse clicks in any case.</para>
            /// <para>This function is only implemented for X11 and Win32 at the</para>
            /// <para>moment.</para>
            /// </remarks>
            public void SetKeyInput(bool enable)
            {
                __Internal.SetKeyInput((__Instance), enable);
            }

            /// <summary>
            /// <para>Enable or disable mouse click events handling. By default, those</para>
            /// <para>events are handled. This is needed for DVD menus to work, as well as a</para>
            /// <para>few video filters such as &quot;puzzle&quot;.</para>
            /// </summary>
            /// <param name="on">true to handle mouse click events, false to ignore them.</param>
            /// <remarks>
            /// <para>MediaPlayer::setKeyInput() .</para>
            /// <para>This function is only implemented for X11 and Win32 at the</para>
            /// <para>moment.</para>
            /// </remarks>
            public void SetMouseInput(bool enable)
            {
                __Internal.SetMouseInput((__Instance), enable);
            }

            /// <summary>Get the pixel dimensions of a video.</summary>
            /// <param name="num">number of the video (starting from, and most commonly 0)</param>
            /// <param name="px">pointer to get the pixel width [OUT]</param>
            /// <param name="py">pointer to get the pixel height [OUT]</param>
            public bool Size(uint num, ref uint px, ref uint py)
            {
                fixed (uint* __refParamPtr1 = &px)
                {
                    var __arg1 = __refParamPtr1;
                    fixed (uint* __refParamPtr2 = &py)
                    {
                        var __arg2 = __refParamPtr2;
                        var __ret = __Internal.Size((__Instance), num, __arg1, __arg2);
                        return __ret;
                    }
                }
            }

            /// <summary>
            /// <para>Get the mouse pointer coordinates over a video. Coordinates are</para>
            /// <para>expressed in terms of the decoded video resolution, in terms of pixels</para>
            /// <para>on the screen/viewport (to get the latter, you can query your</para>
            /// <para>windowing system directly).</para>
            /// </summary>
            /// <param name="num">number of the video (starting from, and most commonly 0)</param>
            /// <param name="px">pointer to get the abscissa [OUT]</param>
            /// <param name="py">pointer to get the ordinate [OUT]</param>
            /// <remarks>
            /// <para>Either of the coordinates may be negative or larger than the</para>
            /// <para>corresponding dimension of the video, if the cursor is outside the</para>
            /// <para>rendering area.</para>
            /// <para>The coordinates may be out-of-date if the pointer is not</para>
            /// <para>located on the video rendering area. LibVLC does not track the pointer</para>
            /// <para>if it is outside of the video widget.</para>
            /// <para>LibVLC does not support multiple pointers (it does of course</para>
            /// <para>support multiple input devices sharing the same pointer) at the</para>
            /// <para>moment.</para>
            /// </remarks>
            public bool Cursor(uint num, ref int px, ref int py)
            {
                fixed (int* __refParamPtr1 = &px)
                {
                    var __arg1 = __refParamPtr1;
                    fixed (int* __refParamPtr2 = &py)
                    {
                        var __arg2 = __refParamPtr2;
                        var __ret = __Internal.Cursor((__Instance), num, __arg1, __arg2);
                        return __ret;
                    }
                }
            }

            /// <summary>Set new video subtitle.</summary>
            /// <param name="i_spu">
            /// <para>video subtitle track to select (i_id from track</para>
            /// <para>description)</para>
            /// </param>
            /// <returns>0 on success, -1 if out of range</returns>
            public int SetSpu(int i_spu)
            {
                var __ret = __Internal.SetSpu((__Instance), i_spu);
                return __ret;
            }

            /// <summary>
            /// <para>Set the subtitle delay. This affects the timing of when the subtitle</para>
            /// <para>will be displayed. Positive values result in subtitles being displayed</para>
            /// <para>later, while negative values will result in subtitles being displayed</para>
            /// <para>earlier.</para>
            /// </summary>
            /// <param name="i_delay">
            /// <para>time (in microseconds) the display of subtitles should</para>
            /// <para>be delayed</para>
            /// </param>
            /// <returns>0 on success, -1 on error</returns>
            /// <remarks>
            /// <para>The subtitle delay will be reset to zero each time the media changes.</para>
            /// <para>LibVLC 2.0.0 or later</para>
            /// </remarks>
            public int SetSpuDelay(long i_delay)
            {
                var __ret = __Internal.SetSpuDelay((__Instance), i_delay);
                return __ret;
            }

            /// <summary>Set video track.</summary>
            /// <param name="i_track">the track ID (i_id field from track description)</param>
            /// <returns>0 on success, -1 if out of range</returns>
            public int SetVideoTrack(int i_track)
            {
                var __ret = __Internal.SetVideoTrack((__Instance), i_track);
                return __ret;
            }

            /// <summary>Take a snapshot of the current video window.</summary>
            /// <param name="num">
            /// <para>number of video output (typically 0 for the first/only</para>
            /// <para>one)</para>
            /// </param>
            /// <param name="filepath">the path where to save the screenshot to</param>
            /// <param name="i_width">the snapshot's width</param>
            /// <param name="i_height">the snapshot's height</param>
            /// <remarks>
            /// <para>If i_width AND i_height is 0, original size is used. If i_width XOR</para>
            /// <para>i_height is 0, original aspect-ratio is preserved.</para>
            /// </remarks>
            public bool TakeSnapshot(uint num, string filepath, uint i_width, uint i_height)
            {
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(filepath, __allocator1);
                var __arg1 = __basicString1.__Instance;
                var __ret = __Internal.TakeSnapshot((__Instance), num, __arg1, i_width, i_height);
                __basicString1.Dispose(false);
                __allocator1.Dispose();
                return __ret;
            }

            /// <summary>Enable or disable deinterlace filter</summary>
            /// <param name="psz_mode">type of deinterlace filter, empty string to disable</param>
            public void SetDeinterlace(string mode)
            {
                var __allocator0 = new global::Std.Allocator<sbyte>();
                var __basicString0 = global::Std.BasicStringExtensions.BasicString(mode, __allocator0);
                var __arg0 = __basicString0.__Instance;
                __Internal.SetDeinterlace((__Instance), __arg0);
                __basicString0.Dispose(false);
                __allocator0.Dispose();
            }

            /// <summary>Get an integer marquee option value</summary>
            /// <param name="option">marq option to get</param>
            /// <remarks>libvlc_video_marquee_int_option_t</remarks>
            public int MarqueeInt(uint option)
            {
                var __ret = __Internal.MarqueeInt((__Instance), option);
                return __ret;
            }

            /// <summary>Get a string marquee option value</summary>
            /// <param name="option">marq option to get</param>
            /// <remarks>libvlc_video_marquee_string_option_t</remarks>
            public string MarqueeString(uint option)
            {
                var __ret = new global::Std.BasicString.__Internal();
                __Internal.MarqueeString((__Instance), new IntPtr(&__ret), option);
                var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                var __stringRet = global::Std.BasicStringExtensions.CStr(__basicStringRet);
                __basicStringRet.Dispose(false);
                return __stringRet;
            }

            /// <summary>Enable, disable or set an integer marquee option</summary>
            /// <param name="option">marq option to set</param>
            /// <param name="i_val">marq option value</param>
            /// <remarks>
            /// <para>Setting libvlc_marquee_Enable has the side effect of enabling (arg !0)</para>
            /// <para>or disabling (arg 0) the marq filter.</para>
            /// <para>libvlc_video_marquee_int_option_t</para>
            /// </remarks>
            public void SetMarqueeInt(uint option, int i_val)
            {
                __Internal.SetMarqueeInt((__Instance), option, i_val);
            }

            /// <summary>Set a marquee string option</summary>
            /// <param name="option">marq option to set</param>
            /// <param name="text">marq option value</param>
            /// <remarks>libvlc_video_marquee_string_option_t</remarks>
            public void SetMarqueeString(uint option, string text)
            {
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(text, __allocator1);
                var __arg1 = __basicString1.__Instance;
                __Internal.SetMarqueeString((__Instance), option, __arg1);
                __basicString1.Dispose(false);
                __allocator1.Dispose();
            }

            /// <summary>Get integer logo option.</summary>
            /// <param name="option">
            /// <para>logo option to get, values of</para>
            /// <para>libvlc_video_logo_option_t</para>
            /// </param>
            public int LogoInt(uint option)
            {
                var __ret = __Internal.LogoInt((__Instance), option);
                return __ret;
            }

            /// <summary>
            /// <para>Set logo option as integer. Options that take a different type value</para>
            /// <para>are ignored. Passing libvlc_logo_enable as option value has the side</para>
            /// <para>effect of starting (arg !0) or stopping (arg 0) the logo filter.</para>
            /// </summary>
            /// <param name="option">
            /// <para>logo option to set, values of</para>
            /// <para>libvlc_video_logo_option_t</para>
            /// </param>
            /// <param name="value">logo option value</param>
            public void SetLogoInt(uint option, int value)
            {
                __Internal.SetLogoInt((__Instance), option, value);
            }

            /// <summary>
            /// <para>Set logo option as string. Options that take a different type value</para>
            /// <para>are ignored.</para>
            /// </summary>
            /// <param name="option">
            /// <para>logo option to set, values of</para>
            /// <para>libvlc_video_logo_option_t</para>
            /// </param>
            /// <param name="psz_value">logo option value</param>
            public void SetLogoString(uint option, string value)
            {
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(value, __allocator1);
                var __arg1 = __basicString1.__Instance;
                __Internal.SetLogoString((__Instance), option, __arg1);
                __basicString1.Dispose(false);
                __allocator1.Dispose();
            }

            /// <summary>Get integer adjust option.</summary>
            /// <param name="option">
            /// <para>adjust option to get, values of</para>
            /// <para>libvlc_video_adjust_option_t</para>
            /// </param>
            /// <remarks>LibVLC 1.1.1 and later.</remarks>
            public int AdjustInt(uint option)
            {
                var __ret = __Internal.AdjustInt((__Instance), option);
                return __ret;
            }

            /// <summary>
            /// <para>Set adjust option as integer. Options that take a different type value</para>
            /// <para>are ignored. Passing libvlc_adjust_enable as option value has the side</para>
            /// <para>effect of starting (arg !0) or stopping (arg 0) the adjust filter.</para>
            /// </summary>
            /// <param name="option">
            /// <para>adust option to set, values of</para>
            /// <para>libvlc_video_adjust_option_t</para>
            /// </param>
            /// <param name="value">adjust option value</param>
            /// <remarks>LibVLC 1.1.1 and later.</remarks>
            public void SetAdjustInt(uint option, int value)
            {
                __Internal.SetAdjustInt((__Instance), option, value);
            }

            /// <summary>Get float adjust option.</summary>
            /// <param name="option">
            /// <para>adjust option to get, values of</para>
            /// <para>libvlc_video_adjust_option_t</para>
            /// </param>
            /// <remarks>LibVLC 1.1.1 and later.</remarks>
            public float AdjustFloat(uint option)
            {
                var __ret = __Internal.AdjustFloat((__Instance), option);
                return __ret;
            }

            /// <summary>
            /// <para>Set adjust option as float. Options that take a different type value</para>
            /// <para>are ignored.</para>
            /// </summary>
            /// <param name="option">
            /// <para>adust option to set, values of</para>
            /// <para>libvlc_video_adjust_option_t</para>
            /// </param>
            /// <param name="value">adjust option value</param>
            /// <remarks>LibVLC 1.1.1 and later.</remarks>
            public void SetAdjustFloat(uint option, float value)
            {
                __Internal.SetAdjustFloat((__Instance), option, value);
            }

            /// <summary>Add a slave to the current media player.</summary>
            /// <param name="type">subtitle or audio</param>
            /// <param name="uri">Uri of the slave (should contain a valid scheme).</param>
            /// <param name="select">True if this slave should be selected when it's loaded</param>
            /// <returns>true on success, false on error.</returns>
            /// <remarks>
            /// <para>If the player is playing, the slave will be added directly. This call</para>
            /// <para>will also update the slave list of the attached VLC::Media.</para>
            /// <para>LibVLC 3.0.0 and later.</para>
            /// <para>Media::addSlave</para>
            /// </remarks>
            public bool AddSlave(global::libvlcpp.VLC.MediaSlave.Type type, string uri, bool select)
            {
                var __allocator1 = new global::Std.Allocator<sbyte>();
                var __basicString1 = global::Std.BasicStringExtensions.BasicString(uri, __allocator1);
                var __arg1 = __basicString1.__Instance;
                var __ret = __Internal.AddSlave((__Instance), type, __arg1, select);
                __basicString1.Dispose(false);
                __allocator1.Dispose();
                return __ret;
            }

            public bool UpdateViewpoint(global::libvlcpp.VLC.VideoViewpoint viewpoint, bool b_absolute)
            {
                if (ReferenceEquals(viewpoint, null))
                    throw new global::System.ArgumentNullException("viewpoint", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = viewpoint.__Instance;
                var __ret = __Internal.UpdateViewpoint((__Instance), __arg0, b_absolute);
                return __ret;
            }

            public static implicit operator global::libvlcpp.VLC.MediaPlayer(global::libvlcpp.VLC.Instance instance)
            {
                return new global::libvlcpp.VLC.MediaPlayer(instance);
            }

            public static implicit operator global::libvlcpp.VLC.MediaPlayer(global::libvlcpp.VLC.Media md)
            {
                return new global::libvlcpp.VLC.MediaPlayer(md);
            }

            public global::System.IntPtr __PointerToInternal
            {
                get
                {
                    return __Instance + 0;
                }
            }

            /// <summary>
            /// <para>Get the NSView handler previously set with MediaPlayer::setNsobject()</para>
            /// <para>.</para>
            /// </summary>
            /// <param name="drawable">
            /// <para>the drawable that is either an NSView or an object</para>
            /// <para>following the VLCOpenGLVideoViewEmbedding protocol.</para>
            /// </param>
            /// <returns>
            /// <para>the NSView handler or 0 if none where set</para>
            /// <para>Set the NSView handler where the media player should render its video</para>
            /// <para>output.</para>
            /// <para>Use the vout called &quot;macosx&quot;.</para>
            /// <para>The drawable is an NSObject that follow the</para>
            /// <para>VLCOpenGLVideoViewEmbedding protocol: VLCOpenGLVideoViewEmbedding</para>
            /// <para>Or it can be an NSView object.</para>
            /// <para>If you want to use it along with Qt4 see the QMacCocoaViewContainer.</para>
            /// <para>Then the following code should work:  { NSView *video = [[NSView</para>
            /// <para>alloc] init]; QMacCocoaViewContainer *container = new</para>
            /// <para>QMacCocoaViewContainer(video, parent);</para>
            /// <para>libvlc_media_player_set_nsobject(mp, video); [video release]; }</para>
            /// <para>You can find a live example in VLCVideoView in VLCKit.framework.</para>
            /// </returns>
            public global::System.IntPtr Nsobject
            {
                get
                {
                    var __ret = __Internal.Nsobject((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetNsobject((__Instance), value);
                }
            }

            /// <summary>
            /// <para>Get the X Window System window identifier previously set with</para>
            /// <para>MediaPlayer::setXwindow() . Note that this will return the identifier</para>
            /// <para>even if VLC is not currently using it (for instance if it is playing</para>
            /// <para>an audio-only input).</para>
            /// </summary>
            /// <param name="drawable">the ID of the X window</param>
            /// <returns>
            /// <para>an X window ID, or 0 if none where set.</para>
            /// <para>Set an X Window System drawable where the media player should render</para>
            /// <para>its video output. If LibVLC was built without X11 output support, then</para>
            /// <para>this has no effects.</para>
            /// <para>The specified identifier must correspond to an existing Input/Output</para>
            /// <para>class X11 window. Pixmaps are supported. The caller shall ensure that</para>
            /// <para>the X11 server is the same as the one the VLC instance has been</para>
            /// <para>configured with. This function must be called before video playback is</para>
            /// <para>started; otherwise it will only take effect after playback stop and</para>
            /// <para>restart.</para>
            /// </returns>
            public uint Xwindow
            {
                get
                {
                    var __ret = __Internal.Xwindow((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetXwindow((__Instance), value);
                }
            }

            /// <summary>
            /// <para>Get the Windows API window handle (HWND) previously set with</para>
            /// <para>MediaPlayer::setHwnd() . The handle will be returned even if LibVLC is</para>
            /// <para>not currently outputting any video to it.</para>
            /// </summary>
            /// <param name="drawable">windows handle of the drawable</param>
            /// <returns>
            /// <para>a window handle or nullptr if there are none.</para>
            /// <para>Set a Win32/Win64 API window handle (HWND) where the media player</para>
            /// <para>should render its video output. If LibVLC was built without</para>
            /// <para>Win32/Win64 API output support, then this has no effects.</para>
            /// </returns>
            public global::System.IntPtr Hwnd
            {
                get
                {
                    var __ret = __Internal.Hwnd((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetHwnd((__Instance), value);
                }
            }

            /// <summary>Get the current movie time (in ms).</summary>
            /// <param name="i_time">the movie time (in ms).</param>
            /// <returns>
            /// <para>the movie time (in ms), or -1 if there is no media.</para>
            /// <para>Set the movie time (in ms). This has no effect if no media is being</para>
            /// <para>played. Not all formats and protocols support this.</para>
            /// </returns>
            public long Time
            {
                get
                {
                    var __ret = __Internal.Time((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetTime((__Instance), value);
                }
            }

            /// <summary>Get movie position as percentage between 0.0 and 1.0.</summary>
            /// <param name="f_pos">the position</param>
            /// <returns>
            /// <para>movie position, or -1. in case of error</para>
            /// <para>Set movie position as percentage between 0.0 and 1.0. This has no</para>
            /// <para>effect if playback is not enabled. This might not work depending on</para>
            /// <para>the underlying input format and protocol.</para>
            /// </returns>
            public float Position
            {
                get
                {
                    var __ret = __Internal.Position((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetPosition((__Instance), value);
                }
            }

            /// <summary>Get movie chapter.</summary>
            /// <param name="i_chapter">chapter number to play</param>
            /// <returns>
            /// <para>chapter number currently playing, or -1 if there is no media.</para>
            /// <para>Set movie chapter (if applicable).</para>
            /// </returns>
            public int Chapter
            {
                get
                {
                    var __ret = __Internal.Chapter((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetChapter((__Instance), value);
                }
            }

            /// <summary>Get movie title</summary>
            /// <param name="i_title">title number to play</param>
            /// <returns>
            /// <para>title number currently playing, or -1</para>
            /// <para>Set movie title</para>
            /// </returns>
            public int Title
            {
                get
                {
                    var __ret = __Internal.Title((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetTitle((__Instance), value);
                }
            }

            /// <summary>Get current fullscreen status.</summary>
            /// <param name="b_fullscreen">boolean for fullscreen status</param>
            /// <returns>
            /// <para>the fullscreen status (boolean)</para>
            /// <para>Enable or disable fullscreen.</para>
            /// </returns>
            /// <remarks>
            /// <para>With most window managers, only a top-level windows can be in</para>
            /// <para>full-screen mode. Hence, this function will not operate properly if</para>
            /// <para>MediaPlayer::setXwindow() was used to embed the video in a non-top-</para>
            /// <para>level window. In that case, the embedding window must be reparented to</para>
            /// <para>the root window fullscreen mode is enabled. You will want to reparent</para>
            /// <para>it back to its normal parent when disabling fullscreen.</para>
            /// </remarks>
            public bool Fullscreen
            {
                get
                {
                    var __ret = __Internal.Fullscreen((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetFullscreen((__Instance), value);
                }
            }

            /// <summary>Get current mute status.</summary>
            /// <param name="status">If status is true then mute, otherwise unmute</param>
            /// <remarks>
            /// <para>Set mute status.</para>
            /// <para>This function does not always work. If there are no active</para>
            /// <para>audio playback stream, the mute status might not be available. If</para>
            /// <para>digital pass-through (S/PDIF, HDMI...) is in use, muting may be</para>
            /// <para>unapplicable. Also some audio output plugins do not support muting at</para>
            /// <para>all.</para>
            /// <para>To force silent playback, disable all audio tracks. This is more</para>
            /// <para>efficient and reliable than mute.</para>
            /// </remarks>
            public bool Mute
            {
                get
                {
                    var __ret = __Internal.Mute((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetMute((__Instance), value);
                }
            }

            /// <summary>Get current software audio volume.</summary>
            /// <param name="i_volume">the volume in percents (0 = mute, 100 = 0dB)</param>
            /// <returns>
            /// <para>the software volume in percents (0 = mute, 100 = nominal /</para>
            /// <para>0dB)</para>
            /// <para>Set current software audio volume.</para>
            /// </returns>
            public int Volume
            {
                get
                {
                    var __ret = __Internal.Volume((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetVolume((__Instance), value);
                }
            }

            /// <summary>Get current audio track.</summary>
            /// <param name="i_track">the track ID (i_id field from track description)</param>
            /// <returns>
            /// <para>the audio track ID or -1 if no active input.</para>
            /// <para>Set current audio track.</para>
            /// </returns>
            public int AudioTrack
            {
                get
                {
                    var __ret = __Internal.AudioTrack((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetAudioTrack((__Instance), value);
                }
            }

            /// <summary>Get current audio channel.</summary>
            /// <param name="channel">the audio channel,</param>
            /// <returns>the audio channel</returns>
            /// <remarks>
            /// <para>libvlc_audio_output_channel_t</para>
            /// <para>Set current audio channel.</para>
            /// <para>libvlc_audio_output_channel_t</para>
            /// </remarks>
            public int Channel
            {
                get
                {
                    var __ret = __Internal.Channel((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetChannel((__Instance), value);
                }
            }

            /// <summary>Get current audio delay.</summary>
            /// <param name="i_delay">the audio delay (microseconds)</param>
            /// <returns>the audio delay (microseconds)</returns>
            /// <remarks>
            /// <para>LibVLC 1.1.1 or later</para>
            /// <para>Set current audio delay. The audio delay will be reset to zero each</para>
            /// <para>time the media changes.</para>
            /// <para>LibVLC 1.1.1 or later</para>
            /// </remarks>
            public long AudioDelay
            {
                get
                {
                    var __ret = __Internal.AudioDelay((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetAudioDelay((__Instance), value);
                }
            }

            /// <summary>Get the current video scaling factor. See also MediaPlayer::setScale() .</summary>
            /// <param name="f_factor">the scaling factor, or zero</param>
            /// <returns>
            /// <para>the currently configured zoom factor, or 0. if the video is</para>
            /// <para>set to fit to the output window/drawable automatically.</para>
            /// <para>Set the video scaling factor. That is the ratio of the number of</para>
            /// <para>pixels on screen to the number of pixels in the original decoded video</para>
            /// <para>in each dimension. Zero is a special value; it will adjust the video</para>
            /// <para>to the output window/drawable (in windowed mode) or the entire screen.</para>
            /// <para>Note that not all video outputs support scaling.</para>
            /// </returns>
            public float Scale
            {
                get
                {
                    var __ret = __Internal.Scale((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetScale((__Instance), value);
                }
            }

            /// <summary>Get current video aspect ratio.</summary>
            /// <param name="psz_aspect">new video aspect-ratio or empty string to reset to default</param>
            /// <returns>
            /// <para>the video aspect ratio or an empty string if unspecified.</para>
            /// <para>Set new video aspect ratio.</para>
            /// </returns>
            /// <remarks>Invalid aspect ratios are ignored.</remarks>
            public string AspectRatio
            {
                get
                {
                    var __ret = new global::Std.BasicString.__Internal();
                    __Internal.AspectRatio((__Instance), new IntPtr(&__ret));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    var __stringRet = global::Std.BasicStringExtensions.CStr(__basicStringRet);
                    __basicStringRet.Dispose(false);
                    return __stringRet;
                }

                set
                {
                    var __allocator0 = new global::Std.Allocator<sbyte>();
                    var __basicString0 = global::Std.BasicStringExtensions.BasicString(value, __allocator0);
                    var __arg0 = __basicString0.__Instance;
                    __Internal.SetAspectRatio((__Instance), __arg0);
                    __basicString0.Dispose(false);
                    __allocator0.Dispose();
                }
            }

            /// <summary>Get current crop filter geometry.</summary>
            /// <param name="psz_geometry">new crop filter geometry (empty string to unset)</param>
            /// <returns>
            /// <para>the crop filter geometry or an empty string if unset</para>
            /// <para>Set new crop filter geometry.</para>
            /// </returns>
            public string CropGeometry
            {
                get
                {
                    var __ret = new global::Std.BasicString.__Internal();
                    __Internal.CropGeometry((__Instance), new IntPtr(&__ret));
                    var __basicStringRet = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__CreateInstance(__ret);
                    var __stringRet = global::Std.BasicStringExtensions.CStr(__basicStringRet);
                    __basicStringRet.Dispose(false);
                    return __stringRet;
                }

                set
                {
                    var __allocator0 = new global::Std.Allocator<sbyte>();
                    var __basicString0 = global::Std.BasicStringExtensions.BasicString(value, __allocator0);
                    var __arg0 = __basicString0.__Instance;
                    __Internal.SetCropGeometry((__Instance), __arg0);
                    __basicString0.Dispose(false);
                    __allocator0.Dispose();
                }
            }

            /// <summary>Get current teletext page requested.</summary>
            /// <param name="i_page">teletex page number requested</param>
            /// <returns>
            /// <para>the current teletext page requested.</para>
            /// <para>Set new teletext page to retrieve.</para>
            /// </returns>
            public int Teletext
            {
                get
                {
                    var __ret = __Internal.Teletext((__Instance));
                    return __ret;
                }

                set
                {
                    __Internal.SetTeletext((__Instance), value);
                }
            }

            /// <summary>Get the Event Manager from which the media player send event.</summary>
            /// <returns>the event manager associated with p_mi</returns>
            public global::libvlcpp.VLC.MediaPlayerEventManager EventManager
            {
                get
                {
                    var __ret = __Internal.EventManager((__Instance));
                    global::libvlcpp.VLC.MediaPlayerEventManager __result0;
                    if (__ret == IntPtr.Zero) __result0 = null;
                    else if (global::libvlcpp.VLC.MediaPlayerEventManager.NativeToManagedMap.ContainsKey(__ret))
                        __result0 = (global::libvlcpp.VLC.MediaPlayerEventManager) global::libvlcpp.VLC.MediaPlayerEventManager.NativeToManagedMap[__ret];
                    else __result0 = global::libvlcpp.VLC.MediaPlayerEventManager.__CreateInstance(__ret);
                    return __result0;
                }
            }

            /// <returns>true if the media player is playing, 0 otherwise</returns>
            public bool IsPlaying
            {
                get
                {
                    var __ret = __Internal.IsPlaying((__Instance));
                    return __ret;
                }
            }

            /// <summary>play Start playback</summary>
            /// <remarks>If playback was already started, this method has no effect</remarks>
            public bool Play
            {
                get
                {
                    var __ret = __Internal.Play((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get the current movie length (in ms).</summary>
            /// <returns>the movie length (in ms), or -1 if there is no media.</returns>
            public long Length
            {
                get
                {
                    var __ret = __Internal.Length((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get movie chapter count</summary>
            /// <returns>number of chapters in movie, or -1.</returns>
            public int ChapterCount
            {
                get
                {
                    var __ret = __Internal.ChapterCount((__Instance));
                    return __ret;
                }
            }

            /// <summary>Is the player able to play</summary>
            /// <returns>boolean</returns>
            public bool WillPlay
            {
                get
                {
                    var __ret = __Internal.WillPlay((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get movie title count</summary>
            /// <returns>title number count, or -1</returns>
            public int TitleCount
            {
                get
                {
                    var __ret = __Internal.TitleCount((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get the requested movie play rate.</summary>
            /// <returns>movie play rate</returns>
            /// <remarks>
            /// <para>Depending on the underlying media, the requested rate may be</para>
            /// <para>different from the real playback rate.</para>
            /// </remarks>
            public float Rate
            {
                get
                {
                    var __ret = __Internal.Rate((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get current movie state</summary>
            /// <returns>the current state of the media player (playing, paused, ...)</returns>
            /// <remarks>libvlc_state_t</remarks>
            public global::libvlcpp.LibvlcStateT State
            {
                get
                {
                    var __ret = __Internal.State((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get the amount of video outputs this media player has?</summary>
            /// <returns>the number of video outputs</returns>
            public uint HasVout
            {
                get
                {
                    var __ret = __Internal.HasVout((__Instance));
                    return __ret;
                }
            }

            /// <summary>Is this media player seekable?</summary>
            /// <returns>true if the media player can seek</returns>
            public bool IsSeekable
            {
                get
                {
                    var __ret = __Internal.IsSeekable((__Instance));
                    return __ret;
                }
            }

            /// <summary>Check if the current program is scrambled</summary>
            /// <returns>true if the current program is scrambled</returns>
            /// <remarks>LibVLC 2.2.0 or later</remarks>
            public bool ProgramScrambled
            {
                get
                {
                    var __ret = __Internal.ProgramScrambled((__Instance));
                    return __ret;
                }
            }

            /// <summary>unsetEqualizer disable equalizer for this media player</summary>
            /// <returns>true on success, false otherwise.</returns>
            public bool UnsetEqualizer
            {
                get
                {
                    var __ret = __Internal.UnsetEqualizer((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get number of available audio tracks.</summary>
            /// <returns>
            /// <para>the number of available audio tracks (int), or -1 if</para>
            /// <para>unavailable</para>
            /// </returns>
            public int AudioTrackCount
            {
                get
                {
                    var __ret = __Internal.AudioTrackCount((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get current video subtitle.</summary>
            /// <returns>the video subtitle selected, or -1 if none</returns>
            public int Spu
            {
                get
                {
                    var __ret = __Internal.Spu((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get the number of available video subtitles.</summary>
            /// <returns>the number of available video subtitles</returns>
            public int SpuCount
            {
                get
                {
                    var __ret = __Internal.SpuCount((__Instance));
                    return __ret;
                }
            }

            /// <summary>
            /// <para>Get the current subtitle delay. Positive values means subtitles are</para>
            /// <para>being displayed later, negative values earlier.</para>
            /// </summary>
            /// <returns>
            /// <para>time (in microseconds) the display of subtitles is being</para>
            /// <para>delayed</para>
            /// </returns>
            /// <remarks>LibVLC 2.0.0 or later</remarks>
            public long SpuDelay
            {
                get
                {
                    var __ret = __Internal.SpuDelay((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get number of available video tracks.</summary>
            /// <returns>the number of available video tracks (int)</returns>
            public int VideoTrackCount
            {
                get
                {
                    var __ret = __Internal.VideoTrackCount((__Instance));
                    return __ret;
                }
            }

            /// <summary>Get current video track.</summary>
            /// <returns>the video track ID (int) or -1 if no active input</returns>
            public int VideoTrack
            {
                get
                {
                    var __ret = __Internal.VideoTrack((__Instance));
                    return __ret;
                }
            }
        }
    }

    namespace VLC
    {
        /// <summary>This class serves as a base for all event managers.</summary>
        /// <remarks>
        /// <para>All events can be handled by providing a std::function.</para>
        /// <para>libvlcpp will take ownership (ie. the function will be moved inside an internal list)</para>
        /// <para>If the provided std::function is a lambda, it may capture anything you desire</para>
        /// </remarks>
        public unsafe partial class EventManager : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 40)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.Vector.__Internal m_lambdas;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0EventManager@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr em);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1EventManager@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.EventManager> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.EventManager>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.EventManager __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.EventManager(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.EventManager __CreateInstance(global::libvlcpp.VLC.EventManager.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.EventManager(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.EventManager.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.EventManager.__Internal));
                global::libvlcpp.VLC.EventManager.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private EventManager(global::libvlcpp.VLC.EventManager.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected EventManager(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            /// <summary>EventManager Wraps the same EventManager</summary>
            /// <remarks>
            /// <para>This will copy the underlying libvlc_event_manager_t, but will not copy</para>
            /// <para>the already registered events.</para>
            /// <para>This allows you to copy an event manager, register a few events for a</para>
            /// <para>punctual task, and unregister those events by destroying the new instance.</para>
            /// </remarks>
            public EventManager(global::libvlcpp.VLC.EventManager em)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.EventManager.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(em, null))
                    throw new global::System.ArgumentNullException("em", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = em.__Instance;
                __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.EventManager __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }
        }

        /// <summary>The MediaEventManager class allows one to register Media related events</summary>
        public unsafe partial class MediaEventManager : global::libvlcpp.VLC.EventManager, IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 40)]
            public new partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.Vector.__Internal m_lambdas;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaEventManager@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaEventManager@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);
            }

            internal static new global::libvlcpp.VLC.MediaEventManager __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaEventManager(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaEventManager __CreateInstance(global::libvlcpp.VLC.MediaEventManager.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaEventManager(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaEventManager.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaEventManager.__Internal));
                global::libvlcpp.VLC.MediaEventManager.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaEventManager(global::libvlcpp.VLC.MediaEventManager.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaEventManager(void* native, bool skipVTables = false)
                : base((void*) null)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public MediaEventManager(global::libvlcpp.VLC.MediaEventManager _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaEventManager.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
            }

            public override void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.EventManager __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static implicit operator global::libvlcpp.VLC.MediaEventManager(global::libvlcpp.LibvlcEventManagerT ptr)
            {
                return new global::libvlcpp.VLC.MediaEventManager(ptr);
            }
        }

        /// <summary>The MediaPlayerEventManager class allows one to register MediaPlayer related events</summary>
        public unsafe partial class MediaPlayerEventManager : global::libvlcpp.VLC.EventManager, IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 40)]
            public new partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.Vector.__Internal m_lambdas;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaPlayerEventManager@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaPlayerEventManager@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);
            }

            internal static new global::libvlcpp.VLC.MediaPlayerEventManager __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaPlayerEventManager(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaPlayerEventManager __CreateInstance(global::libvlcpp.VLC.MediaPlayerEventManager.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaPlayerEventManager(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaPlayerEventManager.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaPlayerEventManager.__Internal));
                global::libvlcpp.VLC.MediaPlayerEventManager.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaPlayerEventManager(global::libvlcpp.VLC.MediaPlayerEventManager.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaPlayerEventManager(void* native, bool skipVTables = false)
                : base((void*) null)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public MediaPlayerEventManager(global::libvlcpp.VLC.MediaPlayerEventManager _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaPlayerEventManager.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
            }

            public override void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.EventManager __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static implicit operator global::libvlcpp.VLC.MediaPlayerEventManager(global::libvlcpp.LibvlcEventManagerT ptr)
            {
                return new global::libvlcpp.VLC.MediaPlayerEventManager(ptr);
            }
        }

        /// <summary>The MediaListEventManager class allows one to register MediaList related events</summary>
        public unsafe partial class MediaListEventManager : global::libvlcpp.VLC.EventManager, IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 40)]
            public new partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.Vector.__Internal m_lambdas;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaListEventManager@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaListEventManager@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);
            }

            internal static new global::libvlcpp.VLC.MediaListEventManager __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaListEventManager(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaListEventManager __CreateInstance(global::libvlcpp.VLC.MediaListEventManager.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaListEventManager(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaListEventManager.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaListEventManager.__Internal));
                global::libvlcpp.VLC.MediaListEventManager.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaListEventManager(global::libvlcpp.VLC.MediaListEventManager.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaListEventManager(void* native, bool skipVTables = false)
                : base((void*) null)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public MediaListEventManager(global::libvlcpp.VLC.MediaListEventManager _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaListEventManager.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
            }

            public override void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.EventManager __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static implicit operator global::libvlcpp.VLC.MediaListEventManager(global::libvlcpp.LibvlcEventManagerT ptr)
            {
                return new global::libvlcpp.VLC.MediaListEventManager(ptr);
            }
        }

        /// <summary>
        /// <para>The MediaListPlayerEventManager class</para>
        /// <para>Those events aren't sent by VLC so far.</para>
        /// </summary>
        public unsafe partial class MediaListPlayerEventManager : global::libvlcpp.VLC.EventManager, IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 40)]
            public new partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.Vector.__Internal m_lambdas;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaListPlayerEventManager@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaListPlayerEventManager@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);
            }

            internal static new global::libvlcpp.VLC.MediaListPlayerEventManager __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaListPlayerEventManager(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaListPlayerEventManager __CreateInstance(global::libvlcpp.VLC.MediaListPlayerEventManager.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaListPlayerEventManager(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaListPlayerEventManager.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaListPlayerEventManager.__Internal));
                global::libvlcpp.VLC.MediaListPlayerEventManager.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaListPlayerEventManager(global::libvlcpp.VLC.MediaListPlayerEventManager.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaListPlayerEventManager(void* native, bool skipVTables = false)
                : base((void*) null)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public MediaListPlayerEventManager(global::libvlcpp.VLC.MediaListPlayerEventManager _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaListPlayerEventManager.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
            }

            public override void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.EventManager __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static implicit operator global::libvlcpp.VLC.MediaListPlayerEventManager(global::libvlcpp.LibvlcEventManagerT ptr)
            {
                return new global::libvlcpp.VLC.MediaListPlayerEventManager(ptr);
            }
        }

        /// <summary>The VLMEventManager class allows one to register VLM related events</summary>
        public unsafe partial class VLMEventManager : global::libvlcpp.VLC.EventManager, IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 40)]
            public new partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.Vector.__Internal m_lambdas;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0VLMEventManager@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1VLMEventManager@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);
            }

            internal static new global::libvlcpp.VLC.VLMEventManager __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.VLMEventManager(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.VLMEventManager __CreateInstance(global::libvlcpp.VLC.VLMEventManager.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.VLMEventManager(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.VLMEventManager.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.VLMEventManager.__Internal));
                global::libvlcpp.VLC.VLMEventManager.__Internal.cctor(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private VLMEventManager(global::libvlcpp.VLC.VLMEventManager.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected VLMEventManager(void* native, bool skipVTables = false)
                : base((void*) null)
            {
                __PointerAdjustment = 0;
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            public VLMEventManager(global::libvlcpp.VLC.VLMEventManager _0)
                : this((void*) null)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.VLMEventManager.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor((__Instance + __PointerAdjustment), __arg0);
            }

            public override void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.EventManager __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static implicit operator global::libvlcpp.VLC.VLMEventManager(global::libvlcpp.LibvlcEventManagerT ptr)
            {
                return new global::libvlcpp.VLC.VLMEventManager(ptr);
            }
        }
    }

    namespace VLC
    {
        public unsafe partial class MediaList : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 32)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.SharedPtr.__Internal m_eventManager;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaList@VLC@@QEAA@AEAVMedia@1@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr md);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaList@VLC@@QEAA@AEAVMediaDiscoverer@1@@Z")]
                internal static extern global::System.IntPtr ctor_1(global::System.IntPtr instance, global::System.IntPtr mdis);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaList@VLC@@QEAA@AEAVMediaLibrary@1@@Z")]
                internal static extern global::System.IntPtr ctor_2(global::System.IntPtr instance, global::System.IntPtr mlib);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaList@VLC@@QEAA@AEAVInstance@1@@Z")]
                internal static extern global::System.IntPtr ctor_3(global::System.IntPtr instance, global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaList@VLC@@QEAA@XZ")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaList@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_4(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaList@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??8MediaList@VLC@@QEBA_NAEBV01@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool OperatorEqualEqual(global::System.IntPtr instance, global::System.IntPtr another);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMedia@MediaList@VLC@@QEAAXAEAVMedia@2@@Z")]
                internal static extern void SetMedia(global::System.IntPtr instance, global::System.IntPtr md);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?addMedia@MediaList@VLC@@QEAA_NAEAVMedia@2@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool AddMedia(global::System.IntPtr instance, global::System.IntPtr md);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?insertMedia@MediaList@VLC@@QEAA_NAEAVMedia@2@H@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool InsertMedia(global::System.IntPtr instance, global::System.IntPtr md, int pos);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?removeIndex@MediaList@VLC@@QEAA_NH@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool RemoveIndex(global::System.IntPtr instance, int i_pos);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?indexOfItem@MediaList@VLC@@QEAAHAEAVMedia@2@@Z")]
                internal static extern int IndexOfItem(global::System.IntPtr instance, global::System.IntPtr md);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?lock@MediaList@VLC@@QEAAXXZ")]
                internal static extern void Lock(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?unlock@MediaList@VLC@@QEAAXXZ")]
                internal static extern void Unlock(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?count@MediaList@VLC@@QEAAHXZ")]
                internal static extern int Count(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?isReadonly@MediaList@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool IsReadonly(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?eventManager@MediaList@VLC@@QEAAAEAVMediaListEventManager@2@XZ")]
                internal static extern global::System.IntPtr EventManager(global::System.IntPtr instance);
            }

            /// <summary>A convenience RAII type to handle MediaList's lock</summary>
            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaList> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaList>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.MediaList __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaList(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaList __CreateInstance(global::libvlcpp.VLC.MediaList.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaList(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaList.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaList.__Internal));
                global::libvlcpp.VLC.MediaList.__Internal.cctor_4(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaList(global::libvlcpp.VLC.MediaList.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaList(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            /// <summary>Get subitems of media descriptor object.</summary>
            public MediaList(global::libvlcpp.VLC.Media md)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaList.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(md, null))
                    throw new global::System.ArgumentNullException("md", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = md.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            /// <summary>Get media service discover media list.</summary>
            /// <param name="p_mdis">media service discover object</param>
            public MediaList(global::libvlcpp.VLC.MediaDiscoverer mdis)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaList.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(mdis, null))
                    throw new global::System.ArgumentNullException("mdis", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = mdis.__Instance;
                __Internal.ctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            /// <summary>Get media library subitems.</summary>
            /// <param name="p_mlib">media library object</param>
            public MediaList(global::libvlcpp.VLC.MediaLibrary mlib)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaList.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(mlib, null))
                    throw new global::System.ArgumentNullException("mlib", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = mlib.__Instance;
                __Internal.ctor_2((__Instance + __PointerAdjustment), __arg0);
            }

            /// <summary>Create an empty media list.</summary>
            /// <param name="p_instance">libvlc instance</param>
            public MediaList(global::libvlcpp.VLC.Instance instance)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaList.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(instance, null))
                    throw new global::System.ArgumentNullException("instance", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = instance.__Instance;
                __Internal.ctor_3((__Instance + __PointerAdjustment), __arg0);
            }

            /// <summary>Create an empty VLC MediaList instance.</summary>
            /// <remarks>Calling any method on such an instance is undefined.</remarks>
            public MediaList()
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaList.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                __Internal.ctor((__Instance + __PointerAdjustment));
            }

            public MediaList(global::libvlcpp.VLC.MediaList _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaList.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_4((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.MediaList __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static bool operator !=(global::libvlcpp.VLC.MediaList __op, global::libvlcpp.VLC.MediaList another)
            {
                return !(__op == another);
            }

            /// <summary>Check if 2 MediaList objects contain the same libvlc_media_list_t.</summary>
            /// <param name="another">another MediaList</param>
            /// <returns>true if they contain the same libvlc_media_list_t</returns>
            public static bool operator ==(global::libvlcpp.VLC.MediaList __op, global::libvlcpp.VLC.MediaList another)
            {
                bool __opNull = ReferenceEquals(__op, null);
                bool anotherNull = ReferenceEquals(another, null);
                if (__opNull || anotherNull)
                    return __opNull && anotherNull;
                var __arg0 = __op.__Instance;
                var __arg1 = another.__Instance;
                var __ret = __Internal.OperatorEqualEqual(__arg0, __arg1);
                return __ret;
            }

            public override bool Equals(object obj)
            {
                return this == obj as global::libvlcpp.VLC.MediaList;
            }

            public override int GetHashCode()
            {
                if (__Instance == global::System.IntPtr.Zero)
                    return global::System.IntPtr.Zero.GetHashCode();
                return (*(global::libvlcpp.VLC.MediaList.__Internal*) __Instance).GetHashCode();
            }

            /// <summary>
            /// <para>Associate media instance with this media list instance. If another</para>
            /// <para>media instance was present it will be released. The</para>
            /// <para>MediaList lock should NOT be held upon entering this function.</para>
            /// </summary>
            /// <param name="p_md">media instance to add</param>
            public void SetMedia(global::libvlcpp.VLC.Media md)
            {
                if (ReferenceEquals(md, null))
                    throw new global::System.ArgumentNullException("md", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = md.__Instance;
                __Internal.SetMedia((__Instance + __PointerAdjustment), __arg0);
            }

            /// <summary>
            /// <para>Add media instance to media list The MediaList lock should be</para>
            /// <para>held upon entering this function.</para>
            /// </summary>
            /// <param name="p_md">a media instance</param>
            public bool AddMedia(global::libvlcpp.VLC.Media md)
            {
                if (ReferenceEquals(md, null))
                    throw new global::System.ArgumentNullException("md", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = md.__Instance;
                var __ret = __Internal.AddMedia((__Instance + __PointerAdjustment), __arg0);
                return __ret;
            }

            /// <summary>
            /// <para>Insert media instance in media list on a position The</para>
            /// <para>MediaList lock should be held upon entering this function.</para>
            /// </summary>
            /// <param name="p_md">a media instance</param>
            /// <param name="i_pos">position in array where to insert</param>
            public bool InsertMedia(global::libvlcpp.VLC.Media md, int pos)
            {
                if (ReferenceEquals(md, null))
                    throw new global::System.ArgumentNullException("md", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = md.__Instance;
                var __ret = __Internal.InsertMedia((__Instance + __PointerAdjustment), __arg0, pos);
                return __ret;
            }

            /// <summary>
            /// <para>Remove media instance from media list on a position The</para>
            /// <para>MediaList lock should be held upon entering this function.</para>
            /// </summary>
            /// <param name="i_pos">position in array where to insert</param>
            public bool RemoveIndex(int i_pos)
            {
                var __ret = __Internal.RemoveIndex((__Instance + __PointerAdjustment), i_pos);
                return __ret;
            }

            /// <summary>
            /// <para>Find index position of List media instance in media list. Warning: the</para>
            /// <para>function will return the first matched position. The</para>
            /// <para>MediaList lock should be held upon entering this function.</para>
            /// </summary>
            /// <param name="p_md">media instance</param>
            /// <returns>position of media instance or -1 if media not found</returns>
            public int IndexOfItem(global::libvlcpp.VLC.Media md)
            {
                if (ReferenceEquals(md, null))
                    throw new global::System.ArgumentNullException("md", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = md.__Instance;
                var __ret = __Internal.IndexOfItem((__Instance + __PointerAdjustment), __arg0);
                return __ret;
            }

            /// <summary>Get lock on media list items</summary>
            public void Lock()
            {
                __Internal.Lock((__Instance + __PointerAdjustment));
            }

            /// <summary>
            /// <para>Release lock on media list items The MediaList lock should be</para>
            /// <para>held upon entering this function.</para>
            /// </summary>
            public void Unlock()
            {
                __Internal.Unlock((__Instance + __PointerAdjustment));
            }

            public static implicit operator global::libvlcpp.VLC.MediaList(global::libvlcpp.VLC.Media md)
            {
                return new global::libvlcpp.VLC.MediaList(md);
            }

            public static implicit operator global::libvlcpp.VLC.MediaList(global::libvlcpp.VLC.MediaDiscoverer mdis)
            {
                return new global::libvlcpp.VLC.MediaList(mdis);
            }

            public static implicit operator global::libvlcpp.VLC.MediaList(global::libvlcpp.VLC.MediaLibrary mlib)
            {
                return new global::libvlcpp.VLC.MediaList(mlib);
            }

            public static implicit operator global::libvlcpp.VLC.MediaList(global::libvlcpp.VLC.Instance instance)
            {
                return new global::libvlcpp.VLC.MediaList(instance);
            }

            public static implicit operator global::libvlcpp.VLC.MediaList(global::libvlcpp.LibvlcMediaListT mediaList)
            {
                return new global::libvlcpp.VLC.MediaList(mediaList);
            }

            /// <summary>
            /// <para>Get count on media list items The MediaList lock should be</para>
            /// <para>held upon entering this function.</para>
            /// </summary>
            /// <returns>number of items in media list</returns>
            public int Count
            {
                get
                {
                    var __ret = __Internal.Count((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>
            /// <para>This indicates if this media list is read-only from a user point of</para>
            /// <para>view</para>
            /// </summary>
            /// <returns>true if readonly, false otherwise</returns>
            public bool IsReadonly
            {
                get
                {
                    var __ret = __Internal.IsReadonly((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>
            /// <para>Get libvlc_event_manager from this media list instance. The</para>
            /// <para>p_event_manager is immutable, so you don't have to hold the lock</para>
            /// </summary>
            /// <returns>libvlc_event_manager</returns>
            public global::libvlcpp.VLC.MediaListEventManager EventManager
            {
                get
                {
                    var __ret = __Internal.EventManager((__Instance + __PointerAdjustment));
                    global::libvlcpp.VLC.MediaListEventManager __result0;
                    if (__ret == IntPtr.Zero) __result0 = null;
                    else if (global::libvlcpp.VLC.MediaListEventManager.NativeToManagedMap.ContainsKey(__ret))
                        __result0 = (global::libvlcpp.VLC.MediaListEventManager) global::libvlcpp.VLC.MediaListEventManager.NativeToManagedMap[__ret];
                    else __result0 = global::libvlcpp.VLC.MediaListEventManager.__CreateInstance(__ret);
                    return __result0;
                }
            }
        }
    }

    namespace VLC
    {
        public unsafe partial interface IInternal
        {
            global::System.IntPtr __Instance { get; }

            global::System.IntPtr __PointerToInternal { get; }
        }
    }

    namespace VLC
    {
        public unsafe partial class MediaListPlayer : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 32)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [FieldOffset(16)]
                internal global::Std.SharedPtr.__Internal m_eventManager;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaListPlayer@VLC@@QEAA@AEAVInstance@1@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaListPlayer@VLC@@QEAA@XZ")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaListPlayer@VLC@@QEAA@AEBV01@@Z")]
                internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??1MediaListPlayer@VLC@@QEAA@XZ")]
                internal static extern void dtor(global::System.IntPtr instance, int delete);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??8MediaListPlayer@VLC@@QEBA_NAEBV01@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool OperatorEqualEqual(global::System.IntPtr instance, global::System.IntPtr another);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMediaPlayer@MediaListPlayer@VLC@@QEAAXAEBVMediaPlayer@2@@Z")]
                internal static extern void SetMediaPlayer(global::System.IntPtr instance, global::System.IntPtr mi);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setMediaList@MediaListPlayer@VLC@@QEAAXAEBVMediaList@2@@Z")]
                internal static extern void SetMediaList(global::System.IntPtr instance, global::System.IntPtr mlist);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?play@MediaListPlayer@VLC@@QEAAXXZ")]
                internal static extern void Play(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?pause@MediaListPlayer@VLC@@QEAAXXZ")]
                internal static extern void Pause(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?playItemAtIndex@MediaListPlayer@VLC@@QEAA_NH@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool PlayItemAtIndex(global::System.IntPtr instance, int i_index);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?playItem@MediaListPlayer@VLC@@QEAA_NAEBVMedia@2@@Z")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool PlayItem(global::System.IntPtr instance, global::System.IntPtr md);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?stop@MediaListPlayer@VLC@@QEAAXXZ")]
                internal static extern void Stop(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?setPlaybackMode@MediaListPlayer@VLC@@QEAAXW4libvlc_playback_mode_t@@@Z")]
                internal static extern void SetPlaybackMode(global::System.IntPtr instance, global::libvlcpp.LibvlcPlaybackModeT e_mode);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?eventManager@MediaListPlayer@VLC@@QEAAAEAVMediaListPlayerEventManager@2@XZ")]
                internal static extern global::System.IntPtr EventManager(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?isPlaying@MediaListPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool IsPlaying(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?state@MediaListPlayer@VLC@@QEAA?AW4libvlc_state_t@@XZ")]
                internal static extern global::libvlcpp.LibvlcStateT State(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?next@MediaListPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Next(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="?previous@MediaListPlayer@VLC@@QEAA_NXZ")]
                [return: MarshalAs(UnmanagedType.I1)]
                internal static extern bool Previous(global::System.IntPtr instance);
            }

            public global::System.IntPtr __Instance { get; protected set; }

            protected int __PointerAdjustment;
            internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaListPlayer> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::libvlcpp.VLC.MediaListPlayer>();
            protected void*[] __OriginalVTables;

            protected bool __ownsNativeInstance;

            internal static global::libvlcpp.VLC.MediaListPlayer __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaListPlayer(native.ToPointer(), skipVTables);
            }

            internal static global::libvlcpp.VLC.MediaListPlayer __CreateInstance(global::libvlcpp.VLC.MediaListPlayer.__Internal native, bool skipVTables = false)
            {
                return new global::libvlcpp.VLC.MediaListPlayer(native, skipVTables);
            }

            private static void* __CopyValue(global::libvlcpp.VLC.MediaListPlayer.__Internal native)
            {
                var ret = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaListPlayer.__Internal));
                global::libvlcpp.VLC.MediaListPlayer.__Internal.cctor_1(ret, new global::System.IntPtr(&native));
                return ret.ToPointer();
            }

            private MediaListPlayer(global::libvlcpp.VLC.MediaListPlayer.__Internal native, bool skipVTables = false)
                : this(__CopyValue(native), skipVTables)
            {
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
            }

            protected MediaListPlayer(void* native, bool skipVTables = false)
            {
                if (native == null)
                    return;
                __Instance = new global::System.IntPtr(native);
            }

            /// <summary>Create new media_list_player.</summary>
            /// <param name="p_instance">libvlc instance</param>
            public MediaListPlayer(global::libvlcpp.VLC.Instance instance)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaListPlayer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(instance, null))
                    throw new global::System.ArgumentNullException("instance", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = instance.__Instance;
                __Internal.ctor((__Instance + __PointerAdjustment), __arg0);
            }

            /// <summary>Create an empty VLC MediaListPlayer instance.</summary>
            /// <remarks>Calling any method on such an instance is undefined.</remarks>
            public MediaListPlayer()
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaListPlayer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                __Internal.ctor((__Instance + __PointerAdjustment));
            }

            public MediaListPlayer(global::libvlcpp.VLC.MediaListPlayer _0)
            {
                __Instance = Marshal.AllocHGlobal(sizeof(global::libvlcpp.VLC.MediaListPlayer.__Internal));
                __ownsNativeInstance = true;
                NativeToManagedMap[__Instance] = this;
                if (ReferenceEquals(_0, null))
                    throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = _0.__Instance;
                __Internal.cctor_1((__Instance + __PointerAdjustment), __arg0);
            }

            public void Dispose()
            {
                Dispose(disposing: true);
            }

            public virtual void Dispose(bool disposing)
            {
                if (__Instance == IntPtr.Zero)
                    return;
                global::libvlcpp.VLC.MediaListPlayer __dummy;
                NativeToManagedMap.TryRemove(__Instance, out __dummy);
                if (disposing)
                    __Internal.dtor((__Instance + __PointerAdjustment), 0);
                if (__ownsNativeInstance)
                    Marshal.FreeHGlobal(__Instance);
                __Instance = IntPtr.Zero;
            }

            public static bool operator !=(global::libvlcpp.VLC.MediaListPlayer __op, global::libvlcpp.VLC.MediaListPlayer another)
            {
                return !(__op == another);
            }

            /// <summary>Check if 2 MediaListPlayer objects contain the same libvlc_media_list_player_t.</summary>
            /// <param name="another">another MediaListPlayer</param>
            /// <returns>true if they contain the same libvlc_media_list_player_t</returns>
            public static bool operator ==(global::libvlcpp.VLC.MediaListPlayer __op, global::libvlcpp.VLC.MediaListPlayer another)
            {
                bool __opNull = ReferenceEquals(__op, null);
                bool anotherNull = ReferenceEquals(another, null);
                if (__opNull || anotherNull)
                    return __opNull && anotherNull;
                var __arg0 = __op.__Instance;
                var __arg1 = another.__Instance;
                var __ret = __Internal.OperatorEqualEqual(__arg0, __arg1);
                return __ret;
            }

            public override bool Equals(object obj)
            {
                return this == obj as global::libvlcpp.VLC.MediaListPlayer;
            }

            public override int GetHashCode()
            {
                if (__Instance == global::System.IntPtr.Zero)
                    return global::System.IntPtr.Zero.GetHashCode();
                return (*(global::libvlcpp.VLC.MediaListPlayer.__Internal*) __Instance).GetHashCode();
            }

            /// <summary>Replace media player in media_list_player with this instance.</summary>
            /// <param name="p_mi">media player instance</param>
            public void SetMediaPlayer(global::libvlcpp.VLC.MediaPlayer mi)
            {
                if (ReferenceEquals(mi, null))
                    throw new global::System.ArgumentNullException("mi", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = mi.__Instance;
                __Internal.SetMediaPlayer((__Instance + __PointerAdjustment), __arg0);
            }

            /// <summary>Set the media list associated with the player</summary>
            /// <param name="p_mlist">list of media</param>
            public void SetMediaList(global::libvlcpp.VLC.MediaList mlist)
            {
                if (ReferenceEquals(mlist, null))
                    throw new global::System.ArgumentNullException("mlist", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = mlist.__Instance;
                __Internal.SetMediaList((__Instance + __PointerAdjustment), __arg0);
            }

            /// <summary>Play media list</summary>
            public void Play()
            {
                __Internal.Play((__Instance + __PointerAdjustment));
            }

            /// <summary>Toggle pause (or resume) media list</summary>
            public void Pause()
            {
                __Internal.Pause((__Instance + __PointerAdjustment));
            }

            /// <summary>Play media list item at position index</summary>
            /// <param name="i_index">index in media list to play</param>
            public bool PlayItemAtIndex(int i_index)
            {
                var __ret = __Internal.PlayItemAtIndex((__Instance + __PointerAdjustment), i_index);
                return __ret;
            }

            /// <summary>Play the given media item</summary>
            /// <param name="p_md">the media instance</param>
            public bool PlayItem(global::libvlcpp.VLC.Media md)
            {
                if (ReferenceEquals(md, null))
                    throw new global::System.ArgumentNullException("md", "Cannot be null because it is a C++ reference (&).");
                var __arg0 = md.__Instance;
                var __ret = __Internal.PlayItem((__Instance + __PointerAdjustment), __arg0);
                return __ret;
            }

            /// <summary>Stop playing media list</summary>
            public void Stop()
            {
                __Internal.Stop((__Instance + __PointerAdjustment));
            }

            /// <summary>Sets the playback mode for the playlist</summary>
            /// <param name="e_mode">playback mode specification</param>
            public void SetPlaybackMode(global::libvlcpp.LibvlcPlaybackModeT e_mode)
            {
                __Internal.SetPlaybackMode((__Instance + __PointerAdjustment), e_mode);
            }

            public static implicit operator global::libvlcpp.VLC.MediaListPlayer(global::libvlcpp.VLC.Instance instance)
            {
                return new global::libvlcpp.VLC.MediaListPlayer(instance);
            }

            /// <summary>Return the event manager of this media_list_player.</summary>
            /// <returns>the event manager</returns>
            public global::libvlcpp.VLC.MediaListPlayerEventManager EventManager
            {
                get
                {
                    var __ret = __Internal.EventManager((__Instance + __PointerAdjustment));
                    global::libvlcpp.VLC.MediaListPlayerEventManager __result0;
                    if (__ret == IntPtr.Zero) __result0 = null;
                    else if (global::libvlcpp.VLC.MediaListPlayerEventManager.NativeToManagedMap.ContainsKey(__ret))
                        __result0 = (global::libvlcpp.VLC.MediaListPlayerEventManager) global::libvlcpp.VLC.MediaListPlayerEventManager.NativeToManagedMap[__ret];
                    else __result0 = global::libvlcpp.VLC.MediaListPlayerEventManager.__CreateInstance(__ret);
                    return __result0;
                }
            }

            /// <summary>Is media list playing?</summary>
            /// <returns>true for playing and false for not playing</returns>
            public bool IsPlaying
            {
                get
                {
                    var __ret = __Internal.IsPlaying((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>Get current libvlc_state of media list player</summary>
            /// <returns>libvlc_state_t for media list player</returns>
            public global::libvlcpp.LibvlcStateT State
            {
                get
                {
                    var __ret = __Internal.State((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>Play next item from media list</summary>
            public bool Next
            {
                get
                {
                    var __ret = __Internal.Next((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }

            /// <summary>Play previous item from media list</summary>
            public bool Previous
            {
                get
                {
                    var __ret = __Internal.Previous((__Instance + __PointerAdjustment));
                    return __ret;
                }
            }
        }
    }

    namespace VLC
    {
        public unsafe partial class MediaLibrary : IDisposable
        {
            [StructLayout(LayoutKind.Explicit, Size = 16)]
            public partial struct __Internal
            {
                [FieldOffset(0)]
                internal global::Std.SharedPtr.__Internal m_obj;

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaLibrary@VLC@@QEAA@AEAVInstance@1@@Z")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance, global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                    EntryPoint="??0MediaLibrary@VLC@@QEAA@XZ")]
                internal static extern global::System.IntPtr ctor(global::System.IntPtr instance);

                [SuppressUnmanagedCodeSecurity]
                [DllImport("vlcpp", CallingConvention = gl