#define TRACE
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using LibVLCSharp.Shared.Helpers;
using LibVLCSharp.Shared.Structures;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("LibVLCSharp.Forms")]
[assembly: InternalsVisibleTo("LibVLCSharp.MAUI")]
[assembly: InternalsVisibleTo("LibVLCSharp.Uno")]
[assembly: TargetFramework(".NETFramework,Version=v4.0", FrameworkDisplayName = ".NET Framework 4")]
[assembly: AssemblyCompany("VideoLAN")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("LibVLCSharp is a cross-platform audio and video API for .NET platforms based on VideoLAN's LibVLC Library. It provides a comprehensive multimedia API that can be used across mobile, server and desktop to render video and output audio. Mono, .NET Framework and .NET Core runtimes are supported.\n\nThis package contains the core features of LibVLCSharp (libvlc loading and initialization, .NET-friendly classes to ease the use of libvlc...). All other `LibVLCSharp.*` packages depend on this one.\nFeatures:\n- Play every media file formats, every codec and every streaming protocols\n- Run on every platform, from desktop (Windows, Linux, Mac) to mobile (Android, iOS) and TVs\n- Hardware and efficient decoding on every platform, up to 8K\n- Network browsing for distant filesystems (SMB, FTP, SFTP, NFS...) and servers (UPnP, DLNA)\n- Playback of Audio CD, DVD and Bluray with menu navigation\n- Support for HDR, including tonemapping for SDR streams\n- Audio passthrough with SPDIF and HDMI, including for Audio HD codecs, like DD+, TrueHD or DTS-HD\n- Support for video and audio filters\n- Support for 360 video and 3D audio playback, including Ambisonics\n- Able to cast and stream to distant renderers, like Chromecast and UPnP renderers.\n\nThis package also contains the views for the following platforms:\n\n- Android\n- iOS\n- Mac\n- tvOS\n- UWP\n\nIf you need Xamarin.Forms support, see LibVLCSharp.Forms. \n\nLibVLC needs to be installed separately, see VideoLAN.LibVLC.* packages.")]
[assembly: AssemblyFileVersion("3.9.4.0")]
[assembly: AssemblyInformationalVersion("3.9.4+f08446b3fda43c7801b156a581fac8962bbf5466")]
[assembly: AssemblyProduct("LibVLCSharp")]
[assembly: AssemblyTitle("LibVLCSharp")]
[assembly: NeutralResourcesLanguage("en")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.9.4.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace LibVLCSharp.Shared
{
	internal static class Constants
	{
		internal const string LibraryName = "libvlc";

		internal const string CoreLibraryName = "libvlccore";

		internal const string LibrariesRepositoryFolderName = "libvlc";

		internal const string Msvcrt = "msvcrt";

		internal const string Libc = "libc";

		internal const string LibSystem = "libSystem";

		internal const string Kernel32 = "kernel32";

		internal const string WindowsLibraryExtension = ".dll";

		internal const string MacLibraryExtension = ".dylib";

		internal const string Lib = "lib";

		internal const string LibVLC = "libvlc";
	}
	internal static class ArchitectureNames
	{
		internal const string Win64 = "win-x64";

		internal const string Win86 = "win-x86";

		internal const string MacOS64 = "osx-x64";
	}
	[Flags]
	internal enum ErrorModes : uint
	{
		SYSTEM_DEFAULT = 0u,
		SEM_FAILCRITICALERRORS = 1u,
		SEM_NOALIGNMENTFAULTEXCEPT = 4u,
		SEM_NOGPFAULTERRORBOX = 2u,
		SEM_NOOPENFILEERRORBOX = 0x8000u
	}
	public static class Core
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private struct Native
		{
			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_get_version")]
			internal static extern IntPtr LibVLCVersion();

			[DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]
			internal static extern IntPtr LoadLibraryW(string dllToLoad);

			[DllImport("libSystem", EntryPoint = "dlopen")]
			internal static extern IntPtr Dlopen(string libraryPath, int mode = 1);

			[DllImport("kernel32", SetLastError = true)]
			internal static extern ErrorModes SetErrorMode(ErrorModes uMode);
		}

		private static bool _libvlcLoaded;

		private static IntPtr LibvlcHandle;

		private static IntPtr LibvlccoreHandle;

		private static string LibraryExtension
		{
			get
			{
				if (!PlatformHelper.IsWindows)
				{
					return ".dylib";
				}
				return ".dll";
			}
		}

		internal static bool LibVLCLoaded
		{
			get
			{
				if (!_libvlcLoaded)
				{
					return LibvlcHandle != IntPtr.Zero;
				}
				return true;
			}
			set
			{
				_libvlcLoaded = value;
			}
		}

		private static void EnsureVersionsMatch()
		{
			int num = int.Parse(Native.LibVLCVersion().FromUtf8()?.Split(new char[1] { '.' }).FirstOrDefault() ?? "0");
			int? num2 = Assembly.GetExecutingAssembly().GetName().Version?.Major;
			if (num != num2)
			{
				throw new VLCException($"Version mismatch between LibVLC {num} and LibVLCSharp {num2}. " + "They must share the same major version number");
			}
		}

		private static string LibVLCPath(string dir)
		{
			return Path.Combine(dir, "libvlc" + LibraryExtension);
		}

		private static string LibVLCCorePath(string dir)
		{
			return Path.Combine(dir, "libvlccore" + LibraryExtension);
		}

		private static void Log(string message)
		{
			Trace.WriteLine(message);
		}

		private static List<(string libvlccore, string libvlc)> ComputeLibVLCSearchPaths()
		{
			List<(string, string)> list = new List<(string, string)>();
			string path = ((!PlatformHelper.IsMac) ? (PlatformHelper.IsX64BitProcess ? "win-x64" : "win-x86") : Path.Combine("osx-x64", "lib"));
			string location = typeof(LibVLC).Assembly.Location;
			string dir = Path.Combine(Path.GetDirectoryName(location), "libvlc", path);
			string item = LibVLCCorePath(dir);
			string item2 = LibVLCPath(dir);
			list.Add((item, item2));
			string text = Assembly.GetEntryAssembly()?.Location ?? Assembly.GetExecutingAssembly()?.Location;
			if (!string.IsNullOrEmpty(text))
			{
				string dir2 = Path.Combine(Path.GetDirectoryName(text), "libvlc", path);
				string item3 = string.Empty;
				if (PlatformHelper.IsWindows)
				{
					item3 = LibVLCCorePath(dir2);
				}
				string item4 = LibVLCPath(dir2);
				list.Add((item3, item4));
			}
			string item5 = LibVLCPath(Path.GetDirectoryName(location));
			list.Add((string.Empty, item5));
			if (PlatformHelper.IsMac)
			{
				string item6 = Path.Combine(Path.Combine(Path.GetDirectoryName(location), "lib"), "libvlc" + LibraryExtension);
				string item7 = LibVLCCorePath(Path.Combine(Path.GetDirectoryName(location), "lib"));
				list.Add((item7, item6));
			}
			return list;
		}

		private static void LoadLibVLC(string? libvlcDirectoryPath = null)
		{
			if (!string.IsNullOrEmpty(libvlcDirectoryPath))
			{
				string text = LibVLCCorePath(libvlcDirectoryPath);
				if (!LoadNativeLibrary(text, out LibvlccoreHandle))
				{
					Log("Failed to load required native libraries at " + text);
					return;
				}
				string text2 = LibVLCPath(libvlcDirectoryPath);
				if (!LoadNativeLibrary(text2, out LibvlcHandle))
				{
					Log("Failed to load required native libraries at " + text2);
				}
				return;
			}
			List<(string, string)> list = ComputeLibVLCSearchPaths();
			foreach (var (nativeLibraryPath, nativeLibraryPath2) in list)
			{
				LoadNativeLibrary(nativeLibraryPath, out LibvlccoreHandle);
				if (LoadNativeLibrary(nativeLibraryPath2, out LibvlcHandle))
				{
					break;
				}
			}
			if (LibVLCLoaded)
			{
				return;
			}
			throw new VLCException("Failed to load required native libraries. " + Environment.NewLine + "Have you installed the latest LibVLC package from nuget for your target platform?" + Environment.NewLine + "Search paths include " + string.Join("; ", list.Select<(string, string), string>(((string libvlccore, string libvlc) p) => p.libvlc + "," + p.libvlccore)));
		}

		internal static void EnsureLoaded()
		{
			if (!LibVLCLoaded)
			{
				Initialize();
			}
		}

		private static bool LoadNativeLibrary(string nativeLibraryPath, out IntPtr handle)
		{
			handle = IntPtr.Zero;
			Log("Loading " + nativeLibraryPath);
			if (!File.Exists(nativeLibraryPath))
			{
				Log("Cannot find " + nativeLibraryPath);
				return false;
			}
			if (PlatformHelper.IsMac)
			{
				handle = Native.Dlopen(nativeLibraryPath);
			}
			else
			{
				handle = Native.LoadLibraryW(nativeLibraryPath);
			}
			return handle != IntPtr.Zero;
		}

		public static void Initialize(string? libvlcDirectoryPath = null)
		{
			DisableMessageErrorBox();
			InitializeDesktop(libvlcDirectoryPath);
			EnsureVersionsMatch();
			LibVLCLoaded = true;
		}

		private static void DisableMessageErrorBox()
		{
			if (PlatformHelper.IsWindows)
			{
				Native.SetErrorMode(Native.SetErrorMode(ErrorModes.SYSTEM_DEFAULT) | ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOOPENFILEERRORBOX);
			}
		}

		private static void InitializeDesktop(string? libvlcDirectoryPath = null)
		{
			if (PlatformHelper.IsLinux)
			{
				if (!string.IsNullOrEmpty(libvlcDirectoryPath))
				{
					throw new InvalidOperationException("Using libvlcDirectoryPath is not supported on the Linux platform. The recommended way is to have the libvlc librairies in /usr/lib. Use LD_LIBRARY_PATH if you need more customization");
				}
			}
			else
			{
				LoadLibVLC(libvlcDirectoryPath);
			}
		}
	}
	public class Dialog
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private struct Native
		{
			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_dialog_post_login")]
			internal static extern int LibVLCDialogPostLogin(IntPtr dialogId, IntPtr username, IntPtr password, bool store);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_dialog_post_action")]
			internal static extern int LibVLCDialogPostAction(IntPtr dialogId, int actionIndex);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_dialog_dismiss")]
			internal static extern int LibVLCDialogDismiss(IntPtr dialogId);
		}

		private IntPtr _id;

		private Dialog(IntPtr id)
		{
			if (id == IntPtr.Zero)
			{
				throw new ArgumentNullException("id");
			}
			_id = id;
		}

		internal Dialog(DialogId id)
			: this(id.NativeReference)
		{
		}

		public bool PostLogin(string? username, string? password, bool store)
		{
			if (_id == IntPtr.Zero)
			{
				throw new VLCException("Calling method on dismissed Dialog instance");
			}
			if (username == null)
			{
				username = string.Empty;
			}
			if (password == null)
			{
				password = string.Empty;
			}
			IntPtr usernamePtr = username.ToUtf8();
			IntPtr passwordPtr = password.ToUtf8();
			bool result = MarshalUtils.PerformInteropAndFree(() => Native.LibVLCDialogPostLogin(_id, usernamePtr, passwordPtr, store), usernamePtr, passwordPtr) == 0;
			_id = IntPtr.Zero;
			return result;
		}

		public bool PostAction(int actionIndex)
		{
			if (_id == IntPtr.Zero)
			{
				throw new VLCException("Calling method on dismissed Dialog instance");
			}
			bool result = Native.LibVLCDialogPostAction(_id, actionIndex) == 0;
			_id = IntPtr.Zero;
			return result;
		}

		public bool Dismiss()
		{
			if (_id == IntPtr.Zero)
			{
				return false;
			}
			bool result = Native.LibVLCDialogDismiss(_id) == 0;
			_id = IntPtr.Zero;
			return result;
		}
	}
	internal readonly struct DialogId
	{
		internal IntPtr NativeReference { get; }

		internal DialogId(IntPtr nativeReference)
		{
			NativeReference = nativeReference;
		}
	}
	public enum DialogQuestionType
	{
		Normal,
		Warning,
		Critical
	}
	public delegate Task DisplayError(string? title, string? text);
	public delegate Task DisplayLogin(Dialog dialog, string? title, string? text, string? defaultUsername, bool askStore, CancellationToken token);
	public delegate Task DisplayQuestion(Dialog dialog, string? title, string? text, DialogQuestionType type, string? cancelText, string? firstActionText, string? secondActionText, CancellationToken token);
	public delegate Task DisplayProgress(Dialog dialog, string? title, string? text, bool indeterminate, float position, string? cancelText, CancellationToken token);
	public delegate Task UpdateProgress(Dialog dialog, float position, string? text);
	public class Equalizer : Internal
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private struct Native
		{
			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_new")]
			internal static extern IntPtr LibVLCAudioEqualizerNew();

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_release")]
			internal static extern void LibVLCAudioEqualizerRelease(IntPtr equalizer);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_new_from_preset")]
			internal static extern IntPtr LibVLCAudioEqualizerNewFromPreset(uint index);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_set_preamp")]
			internal static extern int LibVLCAudioEqualizerSetPreamp(IntPtr equalizer, float preamp);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_get_preamp")]
			internal static extern float LibVLCAudioEqualizerGetPreamp(IntPtr equalizer);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_set_amp_at_index")]
			internal static extern int LibVLCAudioEqualizerSetAmpAtIndex(IntPtr equalizer, float amp, uint band);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_get_amp_at_index")]
			internal static extern float LibVLCAudioEqualizerGetAmpAtIndex(IntPtr equalizer, uint band);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_get_preset_count")]
			internal static extern uint LibVLCAudioEqualizerGetPresetCount();

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_get_preset_name")]
			internal static extern IntPtr LibVLCAudioEqualizerGetPresetName(uint index);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_get_band_count")]
			internal static extern uint LibVLCAudioEqualizerGetBandCount();

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_equalizer_get_band_frequency")]
			internal static extern float LibVLCAudioEqualizerGetBandFrequency(uint index);
		}

		public float Preamp => Native.LibVLCAudioEqualizerGetPreamp(base.NativeReference);

		public uint PresetCount => Native.LibVLCAudioEqualizerGetPresetCount();

		public uint BandCount => Native.LibVLCAudioEqualizerGetBandCount();

		public Equalizer()
			: base(Native.LibVLCAudioEqualizerNew, Native.LibVLCAudioEqualizerRelease)
		{
		}

		public Equalizer(uint index)
			: base(() => Native.LibVLCAudioEqualizerNewFromPreset(index), Native.LibVLCAudioEqualizerRelease)
		{
		}

		public bool SetPreamp(float preamp)
		{
			return Native.LibVLCAudioEqualizerSetPreamp(base.NativeReference, preamp) == 0;
		}

		public bool SetAmp(float amp, uint band)
		{
			return Native.LibVLCAudioEqualizerSetAmpAtIndex(base.NativeReference, amp, band) == 0;
		}

		public float Amp(uint band)
		{
			return Native.LibVLCAudioEqualizerGetAmpAtIndex(base.NativeReference, band);
		}

		public string? PresetName(uint index)
		{
			return Native.LibVLCAudioEqualizerGetPresetName(index).FromUtf8();
		}

		public float BandFrequency(uint index)
		{
			return Native.LibVLCAudioEqualizerGetBandFrequency(index);
		}
	}
	internal abstract class EventManager
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		internal readonly struct Native
		{
			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_event_attach")]
			internal static extern int LibVLCEventAttach(IntPtr eventManager, EventType eventType, InternalEventCallback eventCallback, IntPtr userData);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_event_detach")]
			internal static extern void LibVLCEventDetach(IntPtr eventManager, EventType eventType, InternalEventCallback eventCallback, IntPtr userData);
		}

		internal class EventTypeManager : IDisposable
		{
			internal Action<IntPtr> EventHandler { get; }

			internal GCHandle Handle { get; }

			internal int HandlerCount { get; set; }

			internal EventTypeManager(Action<IntPtr> eventHandler)
			{
				EventHandler = eventHandler;
				Handle = GCHandle.Alloc(this);
			}

			public void Dispose()
			{
				Handle.Free();
			}
		}

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalEventCallback(IntPtr evt, IntPtr userData);

		internal IntPtr NativeReference;

		private readonly Dictionary<EventType, EventTypeManager> _eventManagers = new Dictionary<EventType, EventTypeManager>();

		private static readonly InternalEventCallback EventCallbackHandle = EventCallback;

		protected internal EventManager(IntPtr ptr)
		{
			if (ptr == IntPtr.Zero)
			{
				throw new NullReferenceException("ptr");
			}
			NativeReference = ptr;
		}

		private bool AttachNativeEvent(EventType eventType, EventTypeManager eventManager)
		{
			return Native.LibVLCEventAttach(NativeReference, eventType, EventCallbackHandle, GCHandle.ToIntPtr(eventManager.Handle)) == 0;
		}

		private void DetachNativeEvent(EventType eventType, EventTypeManager eventManager)
		{
			Native.LibVLCEventDetach(NativeReference, eventType, EventCallbackHandle, GCHandle.ToIntPtr(eventManager.Handle));
		}

		protected void Attach(EventType eventType, Action<IntPtr> eventHandler)
		{
			lock (_eventManagers)
			{
				if (!_eventManagers.TryGetValue(eventType, out EventTypeManager value))
				{
					value = new EventTypeManager(eventHandler);
					if (!AttachNativeEvent(eventType, value))
					{
						value.Dispose();
						throw new VLCException($"Could not attach event {eventType}");
					}
					_eventManagers.Add(eventType, value);
				}
				value.HandlerCount++;
			}
		}

		protected void Detach(EventType eventType)
		{
			lock (_eventManagers)
			{
				if (_eventManagers.TryGetValue(eventType, out EventTypeManager value))
				{
					value.HandlerCount--;
					if (value.HandlerCount == 0)
					{
						DetachNativeEvent(eventType, value);
						value.Dispose();
						_eventManagers.Remove(eventType);
					}
				}
			}
		}

		[MonoPInvokeCallback(typeof(InternalEventCallback))]
		private static void EventCallback(IntPtr evt, IntPtr userData)
		{
			MarshalUtils.GetInstance<EventTypeManager>(userData)?.EventHandler(evt);
		}

		protected internal LibVLCEvent RetrieveEvent(IntPtr eventPtr)
		{
			return MarshalUtils.PtrToStructure<LibVLCEvent>(eventPtr);
		}

		protected internal void OnEventUnhandled(object sender, EventType eventType)
		{
			throw new InvalidOperationException("eventType eventType unhandled by type " + sender.GetType().Name);
		}

		protected internal abstract void AttachEvent<T>(EventType eventType, EventHandler<T> eventHandler) where T : EventArgs;

		protected internal abstract void DetachEvent<T>(EventType eventType, EventHandler<T> eventHandler) where T : EventArgs;
	}
	internal class MediaDiscovererEventManager : EventManager
	{
		private EventHandler<EventArgs>? _mediaDiscovererStarted;

		private EventHandler<EventArgs>? _mediaDiscovererStopped;

		public MediaDiscovererEventManager(IntPtr ptr)
			: base(ptr)
		{
		}

		protected internal override void AttachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.MediaDiscovererStarted:
				_mediaDiscovererStarted = (EventHandler<EventArgs>)Delegate.Combine(_mediaDiscovererStarted, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnStarted);
				break;
			case EventType.MediaDiscovererStopped:
				_mediaDiscovererStopped = (EventHandler<EventArgs>)Delegate.Combine(_mediaDiscovererStopped, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnStopped);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		protected internal override void DetachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.MediaDiscovererStarted:
				_mediaDiscovererStarted = (EventHandler<EventArgs>)Delegate.Remove(_mediaDiscovererStarted, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaDiscovererStopped:
				_mediaDiscovererStopped = (EventHandler<EventArgs>)Delegate.Remove(_mediaDiscovererStopped, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		private void OnStarted(IntPtr ptr)
		{
			_mediaDiscovererStarted?.Invoke(this, EventArgs.Empty);
		}

		private void OnStopped(IntPtr ptr)
		{
			_mediaDiscovererStopped?.Invoke(this, EventArgs.Empty);
		}
	}
	internal class MediaEventManager : EventManager
	{
		private EventHandler<MediaMetaChangedEventArgs>? _mediaMetaChanged;

		private EventHandler<MediaParsedChangedEventArgs>? _mediaParsedChanged;

		private EventHandler<MediaSubItemAddedEventArgs>? _mediaSubItemAdded;

		private EventHandler<MediaDurationChangedEventArgs>? _mediaDurationChanged;

		private EventHandler<MediaFreedEventArgs>? _mediaFreed;

		private EventHandler<MediaStateChangedEventArgs>? _mediaStateChanged;

		private EventHandler<MediaSubItemTreeAddedEventArgs>? _mediaSubItemTreeAdded;

		public MediaEventManager(IntPtr ptr)
			: base(ptr)
		{
		}

		protected internal override void AttachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.MediaMetaChanged:
				_mediaMetaChanged = (EventHandler<MediaMetaChangedEventArgs>)Delegate.Combine(_mediaMetaChanged, eventHandler as EventHandler<MediaMetaChangedEventArgs>);
				Attach(eventType, OnMetaChanged);
				break;
			case EventType.MediaParsedChanged:
				_mediaParsedChanged = (EventHandler<MediaParsedChangedEventArgs>)Delegate.Combine(_mediaParsedChanged, eventHandler as EventHandler<MediaParsedChangedEventArgs>);
				Attach(eventType, OnParsedChanged);
				break;
			case EventType.MediaSubItemAdded:
				_mediaSubItemAdded = (EventHandler<MediaSubItemAddedEventArgs>)Delegate.Combine(_mediaSubItemAdded, eventHandler as EventHandler<MediaSubItemAddedEventArgs>);
				Attach(eventType, OnSubItemAdded);
				break;
			case EventType.MediaDurationChanged:
				_mediaDurationChanged = (EventHandler<MediaDurationChangedEventArgs>)Delegate.Combine(_mediaDurationChanged, eventHandler as EventHandler<MediaDurationChangedEventArgs>);
				Attach(eventType, OnDurationChanged);
				break;
			case EventType.MediaFreed:
				_mediaFreed = (EventHandler<MediaFreedEventArgs>)Delegate.Combine(_mediaFreed, eventHandler as EventHandler<MediaFreedEventArgs>);
				Attach(eventType, OnMediaFreed);
				break;
			case EventType.MediaStateChanged:
				_mediaStateChanged = (EventHandler<MediaStateChangedEventArgs>)Delegate.Combine(_mediaStateChanged, eventHandler as EventHandler<MediaStateChangedEventArgs>);
				Attach(eventType, OnMediaStateChanged);
				break;
			case EventType.MediaSubItemTreeAdded:
				_mediaSubItemTreeAdded = (EventHandler<MediaSubItemTreeAddedEventArgs>)Delegate.Combine(_mediaSubItemTreeAdded, eventHandler as EventHandler<MediaSubItemTreeAddedEventArgs>);
				Attach(eventType, OnSubItemTreeAdded);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		protected internal override void DetachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.MediaMetaChanged:
				_mediaMetaChanged = (EventHandler<MediaMetaChangedEventArgs>)Delegate.Remove(_mediaMetaChanged, eventHandler as EventHandler<MediaMetaChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaParsedChanged:
				_mediaParsedChanged = (EventHandler<MediaParsedChangedEventArgs>)Delegate.Remove(_mediaParsedChanged, eventHandler as EventHandler<MediaParsedChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaSubItemAdded:
				_mediaSubItemAdded = (EventHandler<MediaSubItemAddedEventArgs>)Delegate.Remove(_mediaSubItemAdded, eventHandler as EventHandler<MediaSubItemAddedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaDurationChanged:
				_mediaDurationChanged = (EventHandler<MediaDurationChangedEventArgs>)Delegate.Remove(_mediaDurationChanged, eventHandler as EventHandler<MediaDurationChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaFreed:
				_mediaFreed = (EventHandler<MediaFreedEventArgs>)Delegate.Remove(_mediaFreed, eventHandler as EventHandler<MediaFreedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaStateChanged:
				_mediaStateChanged = (EventHandler<MediaStateChangedEventArgs>)Delegate.Remove(_mediaStateChanged, eventHandler as EventHandler<MediaStateChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaSubItemTreeAdded:
				_mediaSubItemTreeAdded = (EventHandler<MediaSubItemTreeAddedEventArgs>)Delegate.Remove(_mediaSubItemTreeAdded, eventHandler as EventHandler<MediaSubItemTreeAddedEventArgs>);
				Detach(eventType);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		private void OnSubItemTreeAdded(IntPtr ptr)
		{
			_mediaSubItemTreeAdded?.Invoke(this, new MediaSubItemTreeAddedEventArgs(RetrieveEvent(ptr).Union.MediaSubItemTreeAdded.MediaInstance));
		}

		private void OnMediaStateChanged(IntPtr ptr)
		{
			_mediaStateChanged?.Invoke(this, new MediaStateChangedEventArgs(RetrieveEvent(ptr).Union.MediaStateChanged.NewState));
		}

		private void OnMediaFreed(IntPtr ptr)
		{
			_mediaFreed?.Invoke(this, new MediaFreedEventArgs(RetrieveEvent(ptr).Union.MediaFreed.MediaInstance));
		}

		private void OnDurationChanged(IntPtr ptr)
		{
			_mediaDurationChanged?.Invoke(this, new MediaDurationChangedEventArgs(RetrieveEvent(ptr).Union.MediaDurationChanged.NewDuration));
		}

		private void OnSubItemAdded(IntPtr ptr)
		{
			_mediaSubItemAdded?.Invoke(this, new MediaSubItemAddedEventArgs(RetrieveEvent(ptr).Union.MediaSubItemAdded.NewChild));
		}

		private void OnParsedChanged(IntPtr ptr)
		{
			_mediaParsedChanged?.Invoke(this, new MediaParsedChangedEventArgs(RetrieveEvent(ptr).Union.MediaParsedChanged.NewStatus));
		}

		private void OnMetaChanged(IntPtr ptr)
		{
			_mediaMetaChanged?.Invoke(this, new MediaMetaChangedEventArgs(RetrieveEvent(ptr).Union.MediaMetaChanged.MetaType));
		}
	}
	internal class MediaListEventManager : EventManager
	{
		private EventHandler<MediaListItemAddedEventArgs>? _mediaListItemAdded;

		private EventHandler<MediaListWillAddItemEventArgs>? _mediaListWillAddItem;

		private EventHandler<MediaListItemDeletedEventArgs>? _mediaListItemDeleted;

		private EventHandler<MediaListWillDeleteItemEventArgs>? _mediaListWillDeleteItem;

		private EventHandler<EventArgs>? _mediaListEndReached;

		public MediaListEventManager(IntPtr ptr)
			: base(ptr)
		{
		}

		protected internal override void AttachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.MediaListItemAdded:
				_mediaListItemAdded = (EventHandler<MediaListItemAddedEventArgs>)Delegate.Combine(_mediaListItemAdded, eventHandler as EventHandler<MediaListItemAddedEventArgs>);
				Attach(eventType, OnItemAdded);
				break;
			case EventType.MediaListWillAddItem:
				_mediaListWillAddItem = (EventHandler<MediaListWillAddItemEventArgs>)Delegate.Combine(_mediaListWillAddItem, eventHandler as EventHandler<MediaListWillAddItemEventArgs>);
				Attach(eventType, OnWillAddItem);
				break;
			case EventType.MediaListItemDeleted:
				_mediaListItemDeleted = (EventHandler<MediaListItemDeletedEventArgs>)Delegate.Combine(_mediaListItemDeleted, eventHandler as EventHandler<MediaListItemDeletedEventArgs>);
				Attach(eventType, OnItemDeleted);
				break;
			case EventType.MediaListViewWillDeleteItem:
				_mediaListWillDeleteItem = (EventHandler<MediaListWillDeleteItemEventArgs>)Delegate.Combine(_mediaListWillDeleteItem, eventHandler as EventHandler<MediaListWillDeleteItemEventArgs>);
				Attach(eventType, OnWillDeleteItem);
				break;
			case EventType.MediaListEndReached:
				_mediaListEndReached = (EventHandler<EventArgs>)Delegate.Combine(_mediaListEndReached, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnEndReached);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		protected internal override void DetachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.MediaListItemAdded:
				_mediaListItemAdded = (EventHandler<MediaListItemAddedEventArgs>)Delegate.Remove(_mediaListItemAdded, eventHandler as EventHandler<MediaListItemAddedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaListWillAddItem:
				_mediaListWillAddItem = (EventHandler<MediaListWillAddItemEventArgs>)Delegate.Remove(_mediaListWillAddItem, eventHandler as EventHandler<MediaListWillAddItemEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaListItemDeleted:
				_mediaListItemDeleted = (EventHandler<MediaListItemDeletedEventArgs>)Delegate.Remove(_mediaListItemDeleted, eventHandler as EventHandler<MediaListItemDeletedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaListViewWillDeleteItem:
				_mediaListWillDeleteItem = (EventHandler<MediaListWillDeleteItemEventArgs>)Delegate.Remove(_mediaListWillDeleteItem, eventHandler as EventHandler<MediaListWillDeleteItemEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaListEndReached:
				_mediaListEndReached = (EventHandler<EventArgs>)Delegate.Remove(_mediaListEndReached, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		private void OnItemAdded(IntPtr ptr)
		{
			LibVLCEvent.MediaListItemAdded mediaListItemAdded = RetrieveEvent(ptr).Union.MediaListItemAdded;
			_mediaListItemAdded?.Invoke(this, new MediaListItemAddedEventArgs(new Media(mediaListItemAdded.MediaInstance), mediaListItemAdded.Index));
		}

		private void OnWillAddItem(IntPtr ptr)
		{
			LibVLCEvent.MediaListWillAddItem mediaListWillAddItem = RetrieveEvent(ptr).Union.MediaListWillAddItem;
			_mediaListWillAddItem?.Invoke(this, new MediaListWillAddItemEventArgs(new Media(mediaListWillAddItem.MediaInstance), mediaListWillAddItem.Index));
		}

		private void OnItemDeleted(IntPtr ptr)
		{
			LibVLCEvent.MediaListItemDeleted mediaListItemDeleted = RetrieveEvent(ptr).Union.MediaListItemDeleted;
			_mediaListItemDeleted?.Invoke(this, new MediaListItemDeletedEventArgs(new Media(mediaListItemDeleted.MediaInstance), mediaListItemDeleted.Index));
		}

		private void OnWillDeleteItem(IntPtr ptr)
		{
			LibVLCEvent.MediaListWillDeleteItem mediaListWillDeleteItem = RetrieveEvent(ptr).Union.MediaListWillDeleteItem;
			_mediaListWillDeleteItem?.Invoke(this, new MediaListWillDeleteItemEventArgs(new Media(mediaListWillDeleteItem.MediaInstance), mediaListWillDeleteItem.Index));
		}

		private void OnEndReached(IntPtr ptr)
		{
			_mediaListEndReached?.Invoke(this, EventArgs.Empty);
		}
	}
	public class MediaPlayerChangedEventArgs : EventArgs
	{
		public MediaPlayer? OldMediaPlayer { get; }

		public MediaPlayer? NewMediaPlayer { get; }

		public MediaPlayerChangedEventArgs(MediaPlayer? oldMediaPlayer, MediaPlayer? newMediaPlayer)
		{
			OldMediaPlayer = oldMediaPlayer;
			NewMediaPlayer = newMediaPlayer;
		}
	}
	public class MediaPlayerChangingEventArgs : EventArgs
	{
		public MediaPlayer? OldMediaPlayer { get; }

		public MediaPlayer? NewMediaPlayer { get; }

		public MediaPlayerChangingEventArgs(MediaPlayer? oldMediaPlayer, MediaPlayer? newMediaPlayer)
		{
			OldMediaPlayer = oldMediaPlayer;
			NewMediaPlayer = newMediaPlayer;
		}
	}
	internal class MediaPlayerEventManager : EventManager
	{
		private EventHandler<MediaPlayerPositionChangedEventArgs>? _mediaPlayerPositionChanged;

		private EventHandler<MediaPlayerMediaChangedEventArgs>? _mediaPlayerMediaChanged;

		private EventHandler<EventArgs>? _mediaPlayerNothingSpecial;

		private EventHandler<EventArgs>? _mediaPlayerOpening;

		private EventHandler<MediaPlayerBufferingEventArgs>? _mediaPlayerBuffering;

		private EventHandler<EventArgs>? _mediaPlayerPlaying;

		private EventHandler<EventArgs>? _mediaPlayerPaused;

		private EventHandler<EventArgs>? _mediaPlayerStopped;

		private EventHandler<EventArgs>? _mediaPlayerForward;

		private EventHandler<EventArgs>? _mediaPlayerBackward;

		private EventHandler<EventArgs>? _mediaPlayerEndReached;

		private EventHandler<EventArgs>? _mediaPlayerEncounteredError;

		private EventHandler<MediaPlayerTimeChangedEventArgs>? _mediaPlayerTimeChanged;

		private EventHandler<MediaPlayerSeekableChangedEventArgs>? _mediaPlayerSeekableChanged;

		private EventHandler<MediaPlayerPausableChangedEventArgs>? _mediaPlayerPausableChanged;

		private EventHandler<MediaPlayerTitleChangedEventArgs>? _mediaPlayerTitleChanged;

		private EventHandler<MediaPlayerChapterChangedEventArgs>? _mediaPlayerChapterChanged;

		private EventHandler<MediaPlayerSnapshotTakenEventArgs>? _mediaPlayerSnapshotTaken;

		private EventHandler<MediaPlayerLengthChangedEventArgs>? _mediaPlayerLengthChanged;

		private EventHandler<MediaPlayerVoutEventArgs>? _mediaPlayerVout;

		private EventHandler<MediaPlayerScrambledChangedEventArgs>? _mediaPlayerScrambledChanged;

		private EventHandler<MediaPlayerESAddedEventArgs>? _mediaPlayerESAdded;

		private EventHandler<MediaPlayerESDeletedEventArgs>? _mediaPlayerESDeleted;

		private EventHandler<MediaPlayerESSelectedEventArgs>? _mediaPlayerESSelected;

		private EventHandler<MediaPlayerAudioDeviceEventArgs>? _mediaPlayerAudioDevice;

		private EventHandler<EventArgs>? _mediaPlayerCorked;

		private EventHandler<EventArgs>? _mediaPlayerUncorked;

		private EventHandler<EventArgs>? _mediaPlayerMuted;

		private EventHandler<EventArgs>? _mediaPlayerUnmuted;

		private EventHandler<MediaPlayerVolumeChangedEventArgs>? _mediaPlayerVolumeChanged;

		public MediaPlayerEventManager(IntPtr ptr)
			: base(ptr)
		{
		}

		protected internal override void AttachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.MediaPlayerPositionChanged:
				_mediaPlayerPositionChanged = (EventHandler<MediaPlayerPositionChangedEventArgs>)Delegate.Combine(_mediaPlayerPositionChanged, eventHandler as EventHandler<MediaPlayerPositionChangedEventArgs>);
				Attach(eventType, OnPositionChanged);
				break;
			case EventType.MediaPlayerMediaChanged:
				_mediaPlayerMediaChanged = (EventHandler<MediaPlayerMediaChangedEventArgs>)Delegate.Combine(_mediaPlayerMediaChanged, eventHandler as EventHandler<MediaPlayerMediaChangedEventArgs>);
				Attach(eventType, OnMediaChanged);
				break;
			case EventType.MediaPlayerNothingSpecial:
				_mediaPlayerNothingSpecial = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerNothingSpecial, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnNothingSpecial);
				break;
			case EventType.MediaPlayerOpening:
				_mediaPlayerOpening = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerOpening, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnOpening);
				break;
			case EventType.MediaPlayerBuffering:
				_mediaPlayerBuffering = (EventHandler<MediaPlayerBufferingEventArgs>)Delegate.Combine(_mediaPlayerBuffering, eventHandler as EventHandler<MediaPlayerBufferingEventArgs>);
				Attach(eventType, OnBuffering);
				break;
			case EventType.MediaPlayerPlaying:
				_mediaPlayerPlaying = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerPlaying, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnPlaying);
				break;
			case EventType.MediaPlayerPaused:
				_mediaPlayerPaused = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerPaused, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnPaused);
				break;
			case EventType.MediaPlayerStopped:
				_mediaPlayerStopped = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerStopped, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnStopped);
				break;
			case EventType.MediaPlayerForward:
				_mediaPlayerForward = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerForward, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnForward);
				break;
			case EventType.MediaPlayerBackward:
				_mediaPlayerBackward = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerBackward, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnBackward);
				break;
			case EventType.MediaPlayerEndReached:
				_mediaPlayerEndReached = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerEndReached, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnEndReached);
				break;
			case EventType.MediaPlayerEncounteredError:
				_mediaPlayerEncounteredError = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerEncounteredError, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnEncounteredError);
				break;
			case EventType.MediaPlayerTimeChanged:
				_mediaPlayerTimeChanged = (EventHandler<MediaPlayerTimeChangedEventArgs>)Delegate.Combine(_mediaPlayerTimeChanged, eventHandler as EventHandler<MediaPlayerTimeChangedEventArgs>);
				Attach(eventType, OnTimeChanged);
				break;
			case EventType.MediaPlayerSeekableChanged:
				_mediaPlayerSeekableChanged = (EventHandler<MediaPlayerSeekableChangedEventArgs>)Delegate.Combine(_mediaPlayerSeekableChanged, eventHandler as EventHandler<MediaPlayerSeekableChangedEventArgs>);
				Attach(eventType, OnSeekableChanged);
				break;
			case EventType.MediaPlayerPausableChanged:
				_mediaPlayerPausableChanged = (EventHandler<MediaPlayerPausableChangedEventArgs>)Delegate.Combine(_mediaPlayerPausableChanged, eventHandler as EventHandler<MediaPlayerPausableChangedEventArgs>);
				Attach(eventType, OnPausableChanged);
				break;
			case EventType.MediaPlayerTitleChanged:
				_mediaPlayerTitleChanged = (EventHandler<MediaPlayerTitleChangedEventArgs>)Delegate.Combine(_mediaPlayerTitleChanged, eventHandler as EventHandler<MediaPlayerTitleChangedEventArgs>);
				Attach(eventType, OnTitleChanged);
				break;
			case EventType.MediaPlayerChapterChanged:
				_mediaPlayerChapterChanged = (EventHandler<MediaPlayerChapterChangedEventArgs>)Delegate.Combine(_mediaPlayerChapterChanged, eventHandler as EventHandler<MediaPlayerChapterChangedEventArgs>);
				Attach(eventType, OnChapterChanged);
				break;
			case EventType.MediaPlayerSnapshotTaken:
				_mediaPlayerSnapshotTaken = (EventHandler<MediaPlayerSnapshotTakenEventArgs>)Delegate.Combine(_mediaPlayerSnapshotTaken, eventHandler as EventHandler<MediaPlayerSnapshotTakenEventArgs>);
				Attach(eventType, OnSnapshotTaken);
				break;
			case EventType.MediaPlayerLengthChanged:
				_mediaPlayerLengthChanged = (EventHandler<MediaPlayerLengthChangedEventArgs>)Delegate.Combine(_mediaPlayerLengthChanged, eventHandler as EventHandler<MediaPlayerLengthChangedEventArgs>);
				Attach(eventType, OnLengthChanged);
				break;
			case EventType.MediaPlayerVout:
				_mediaPlayerVout = (EventHandler<MediaPlayerVoutEventArgs>)Delegate.Combine(_mediaPlayerVout, eventHandler as EventHandler<MediaPlayerVoutEventArgs>);
				Attach(eventType, OnVout);
				break;
			case EventType.MediaPlayerScrambledChanged:
				_mediaPlayerScrambledChanged = (EventHandler<MediaPlayerScrambledChangedEventArgs>)Delegate.Combine(_mediaPlayerScrambledChanged, eventHandler as EventHandler<MediaPlayerScrambledChangedEventArgs>);
				Attach(eventType, OnScrambledChanged);
				break;
			case EventType.MediaPlayerESAdded:
				_mediaPlayerESAdded = (EventHandler<MediaPlayerESAddedEventArgs>)Delegate.Combine(_mediaPlayerESAdded, eventHandler as EventHandler<MediaPlayerESAddedEventArgs>);
				Attach(eventType, OnESAdded);
				break;
			case EventType.MediaPlayerESDeleted:
				_mediaPlayerESDeleted = (EventHandler<MediaPlayerESDeletedEventArgs>)Delegate.Combine(_mediaPlayerESDeleted, eventHandler as EventHandler<MediaPlayerESDeletedEventArgs>);
				Attach(eventType, OnESDeleted);
				break;
			case EventType.MediaPlayerESSelected:
				_mediaPlayerESSelected = (EventHandler<MediaPlayerESSelectedEventArgs>)Delegate.Combine(_mediaPlayerESSelected, eventHandler as EventHandler<MediaPlayerESSelectedEventArgs>);
				Attach(eventType, OnESSelected);
				break;
			case EventType.MediaPlayerAudioDevice:
				_mediaPlayerAudioDevice = (EventHandler<MediaPlayerAudioDeviceEventArgs>)Delegate.Combine(_mediaPlayerAudioDevice, eventHandler as EventHandler<MediaPlayerAudioDeviceEventArgs>);
				Attach(eventType, OnAudioDevice);
				break;
			case EventType.MediaPlayerCorked:
				_mediaPlayerCorked = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerCorked, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnCorked);
				break;
			case EventType.MediaPlayerUncorked:
				_mediaPlayerUncorked = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerUncorked, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnUncorked);
				break;
			case EventType.MediaPlayerMuted:
				_mediaPlayerMuted = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerMuted, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnMuted);
				break;
			case EventType.MediaPlayerUnmuted:
				_mediaPlayerUnmuted = (EventHandler<EventArgs>)Delegate.Combine(_mediaPlayerUnmuted, eventHandler as EventHandler<EventArgs>);
				Attach(eventType, OnUnmuted);
				break;
			case EventType.MediaPlayerAudioVolume:
				_mediaPlayerVolumeChanged = (EventHandler<MediaPlayerVolumeChangedEventArgs>)Delegate.Combine(_mediaPlayerVolumeChanged, eventHandler as EventHandler<MediaPlayerVolumeChangedEventArgs>);
				Attach(eventType, OnVolumeChanged);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		protected internal override void DetachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.MediaPlayerPositionChanged:
				_mediaPlayerPositionChanged = (EventHandler<MediaPlayerPositionChangedEventArgs>)Delegate.Remove(_mediaPlayerPositionChanged, eventHandler as EventHandler<MediaPlayerPositionChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerMediaChanged:
				_mediaPlayerMediaChanged = (EventHandler<MediaPlayerMediaChangedEventArgs>)Delegate.Remove(_mediaPlayerMediaChanged, eventHandler as EventHandler<MediaPlayerMediaChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerNothingSpecial:
				_mediaPlayerNothingSpecial = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerNothingSpecial, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerOpening:
				_mediaPlayerOpening = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerOpening, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerBuffering:
				_mediaPlayerBuffering = (EventHandler<MediaPlayerBufferingEventArgs>)Delegate.Remove(_mediaPlayerBuffering, eventHandler as EventHandler<MediaPlayerBufferingEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerPlaying:
				_mediaPlayerPlaying = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerPlaying, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerPaused:
				_mediaPlayerPaused = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerPaused, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerStopped:
				_mediaPlayerStopped = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerStopped, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerForward:
				_mediaPlayerForward = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerForward, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerBackward:
				_mediaPlayerBackward = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerBackward, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerEndReached:
				_mediaPlayerEndReached = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerEndReached, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerEncounteredError:
				_mediaPlayerEncounteredError = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerEncounteredError, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerTimeChanged:
				_mediaPlayerTimeChanged = (EventHandler<MediaPlayerTimeChangedEventArgs>)Delegate.Remove(_mediaPlayerTimeChanged, eventHandler as EventHandler<MediaPlayerTimeChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerSeekableChanged:
				_mediaPlayerSeekableChanged = (EventHandler<MediaPlayerSeekableChangedEventArgs>)Delegate.Remove(_mediaPlayerSeekableChanged, eventHandler as EventHandler<MediaPlayerSeekableChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerPausableChanged:
				_mediaPlayerPausableChanged = (EventHandler<MediaPlayerPausableChangedEventArgs>)Delegate.Remove(_mediaPlayerPausableChanged, eventHandler as EventHandler<MediaPlayerPausableChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerTitleChanged:
				_mediaPlayerTitleChanged = (EventHandler<MediaPlayerTitleChangedEventArgs>)Delegate.Remove(_mediaPlayerTitleChanged, eventHandler as EventHandler<MediaPlayerTitleChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerChapterChanged:
				_mediaPlayerChapterChanged = (EventHandler<MediaPlayerChapterChangedEventArgs>)Delegate.Remove(_mediaPlayerChapterChanged, eventHandler as EventHandler<MediaPlayerChapterChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerSnapshotTaken:
				_mediaPlayerSnapshotTaken = (EventHandler<MediaPlayerSnapshotTakenEventArgs>)Delegate.Remove(_mediaPlayerSnapshotTaken, eventHandler as EventHandler<MediaPlayerSnapshotTakenEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerLengthChanged:
				_mediaPlayerLengthChanged = (EventHandler<MediaPlayerLengthChangedEventArgs>)Delegate.Remove(_mediaPlayerLengthChanged, eventHandler as EventHandler<MediaPlayerLengthChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerVout:
				_mediaPlayerVout = (EventHandler<MediaPlayerVoutEventArgs>)Delegate.Remove(_mediaPlayerVout, eventHandler as EventHandler<MediaPlayerVoutEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerScrambledChanged:
				_mediaPlayerScrambledChanged = (EventHandler<MediaPlayerScrambledChangedEventArgs>)Delegate.Remove(_mediaPlayerScrambledChanged, eventHandler as EventHandler<MediaPlayerScrambledChangedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerESAdded:
				_mediaPlayerESAdded = (EventHandler<MediaPlayerESAddedEventArgs>)Delegate.Remove(_mediaPlayerESAdded, eventHandler as EventHandler<MediaPlayerESAddedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerESDeleted:
				_mediaPlayerESDeleted = (EventHandler<MediaPlayerESDeletedEventArgs>)Delegate.Remove(_mediaPlayerESDeleted, eventHandler as EventHandler<MediaPlayerESDeletedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerESSelected:
				_mediaPlayerESSelected = (EventHandler<MediaPlayerESSelectedEventArgs>)Delegate.Remove(_mediaPlayerESSelected, eventHandler as EventHandler<MediaPlayerESSelectedEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerAudioDevice:
				_mediaPlayerAudioDevice = (EventHandler<MediaPlayerAudioDeviceEventArgs>)Delegate.Remove(_mediaPlayerAudioDevice, eventHandler as EventHandler<MediaPlayerAudioDeviceEventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerCorked:
				_mediaPlayerCorked = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerCorked, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerUncorked:
				_mediaPlayerUncorked = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerUncorked, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerMuted:
				_mediaPlayerMuted = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerMuted, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerUnmuted:
				_mediaPlayerUnmuted = (EventHandler<EventArgs>)Delegate.Remove(_mediaPlayerUnmuted, eventHandler as EventHandler<EventArgs>);
				Detach(eventType);
				break;
			case EventType.MediaPlayerAudioVolume:
				_mediaPlayerVolumeChanged = (EventHandler<MediaPlayerVolumeChangedEventArgs>)Delegate.Remove(_mediaPlayerVolumeChanged, eventHandler as EventHandler<MediaPlayerVolumeChangedEventArgs>);
				Detach(eventType);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		private void OnMediaChanged(IntPtr ptr)
		{
			_mediaPlayerMediaChanged?.Invoke(this, new MediaPlayerMediaChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerMediaChanged.NewMedia));
		}

		private void OnNothingSpecial(IntPtr ptr)
		{
			_mediaPlayerNothingSpecial?.Invoke(this, EventArgs.Empty);
		}

		private void OnOpening(IntPtr ptr)
		{
			_mediaPlayerOpening?.Invoke(this, EventArgs.Empty);
		}

		private void OnBuffering(IntPtr ptr)
		{
			_mediaPlayerBuffering?.Invoke(this, new MediaPlayerBufferingEventArgs(RetrieveEvent(ptr).Union.MediaPlayerBuffering.NewCache));
		}

		private void OnPlaying(IntPtr ptr)
		{
			_mediaPlayerPlaying?.Invoke(this, EventArgs.Empty);
		}

		private void OnPaused(IntPtr ptr)
		{
			_mediaPlayerPaused?.Invoke(this, EventArgs.Empty);
		}

		private void OnStopped(IntPtr ptr)
		{
			_mediaPlayerStopped?.Invoke(this, EventArgs.Empty);
		}

		private void OnForward(IntPtr ptr)
		{
			_mediaPlayerForward?.Invoke(this, EventArgs.Empty);
		}

		private void OnBackward(IntPtr ptr)
		{
			_mediaPlayerBackward?.Invoke(this, EventArgs.Empty);
		}

		private void OnEndReached(IntPtr ptr)
		{
			_mediaPlayerEndReached?.Invoke(this, EventArgs.Empty);
		}

		private void OnEncounteredError(IntPtr ptr)
		{
			_mediaPlayerEncounteredError?.Invoke(this, EventArgs.Empty);
		}

		private void OnTimeChanged(IntPtr ptr)
		{
			_mediaPlayerTimeChanged?.Invoke(this, new MediaPlayerTimeChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerTimeChanged.NewTime));
		}

		private void OnPositionChanged(IntPtr ptr)
		{
			_mediaPlayerPositionChanged?.Invoke(this, new MediaPlayerPositionChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerPositionChanged.NewPosition));
		}

		private void OnSeekableChanged(IntPtr ptr)
		{
			_mediaPlayerSeekableChanged?.Invoke(this, new MediaPlayerSeekableChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerSeekableChanged.NewSeekable));
		}

		private void OnPausableChanged(IntPtr ptr)
		{
			_mediaPlayerPausableChanged?.Invoke(this, new MediaPlayerPausableChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerPausableChanged.NewPausable));
		}

		private void OnTitleChanged(IntPtr ptr)
		{
			_mediaPlayerTitleChanged?.Invoke(this, new MediaPlayerTitleChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerTitleChanged.NewTitle));
		}

		private void OnChapterChanged(IntPtr ptr)
		{
			_mediaPlayerChapterChanged?.Invoke(this, new MediaPlayerChapterChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerChapterChanged.NewChapter));
		}

		private void OnSnapshotTaken(IntPtr ptr)
		{
			IntPtr filename = RetrieveEvent(ptr).Union.MediaPlayerSnapshotTaken.Filename;
			_mediaPlayerSnapshotTaken?.Invoke(this, new MediaPlayerSnapshotTakenEventArgs(filename.FromUtf8()));
		}

		private void OnLengthChanged(IntPtr ptr)
		{
			_mediaPlayerLengthChanged?.Invoke(this, new MediaPlayerLengthChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerLengthChanged.NewLength));
		}

		private void OnVout(IntPtr ptr)
		{
			_mediaPlayerVout?.Invoke(this, new MediaPlayerVoutEventArgs(RetrieveEvent(ptr).Union.MediaPlayerVoutChanged.NewCount));
		}

		private void OnScrambledChanged(IntPtr ptr)
		{
			_mediaPlayerScrambledChanged?.Invoke(this, new MediaPlayerScrambledChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerScrambledChanged.NewScrambled));
		}

		private LibVLCEvent.EsChanged GetEsChanged(IntPtr ptr)
		{
			return RetrieveEvent(ptr).Union.EsChanged;
		}

		private void OnESAdded(IntPtr ptr)
		{
			LibVLCEvent.EsChanged esChanged = GetEsChanged(ptr);
			_mediaPlayerESAdded?.Invoke(this, new MediaPlayerESAddedEventArgs(esChanged.Id, esChanged.Type));
		}

		private void OnESDeleted(IntPtr ptr)
		{
			LibVLCEvent.EsChanged esChanged = GetEsChanged(ptr);
			_mediaPlayerESDeleted?.Invoke(this, new MediaPlayerESDeletedEventArgs(esChanged.Id, esChanged.Type));
		}

		private void OnESSelected(IntPtr ptr)
		{
			LibVLCEvent.EsChanged esChanged = GetEsChanged(ptr);
			_mediaPlayerESSelected?.Invoke(this, new MediaPlayerESSelectedEventArgs(esChanged.Id, esChanged.Type));
		}

		private void OnAudioDevice(IntPtr ptr)
		{
			IntPtr device = RetrieveEvent(ptr).Union.AudioDeviceChanged.Device;
			_mediaPlayerAudioDevice?.Invoke(this, new MediaPlayerAudioDeviceEventArgs(device.FromUtf8()));
		}

		private void OnCorked(IntPtr ptr)
		{
			_mediaPlayerCorked?.Invoke(this, EventArgs.Empty);
		}

		private void OnUncorked(IntPtr ptr)
		{
			_mediaPlayerUncorked?.Invoke(this, EventArgs.Empty);
		}

		private void OnMuted(IntPtr ptr)
		{
			_mediaPlayerMuted?.Invoke(this, EventArgs.Empty);
		}

		private void OnUnmuted(IntPtr ptr)
		{
			_mediaPlayerUnmuted?.Invoke(this, EventArgs.Empty);
		}

		private void OnVolumeChanged(IntPtr ptr)
		{
			_mediaPlayerVolumeChanged?.Invoke(this, new MediaPlayerVolumeChangedEventArgs(RetrieveEvent(ptr).Union.MediaPlayerVolumeChanged.Volume));
		}
	}
	internal class RendererDiscovererEventManager : EventManager
	{
		private EventHandler<RendererDiscovererItemAddedEventArgs>? _itemAdded;

		private EventHandler<RendererDiscovererItemDeletedEventArgs>? _itemDeleted;

		internal RendererDiscovererEventManager(IntPtr ptr)
			: base(ptr)
		{
		}

		protected internal override void AttachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.RendererDiscovererItemAdded:
				_itemAdded = (EventHandler<RendererDiscovererItemAddedEventArgs>)Delegate.Combine(_itemAdded, eventHandler as EventHandler<RendererDiscovererItemAddedEventArgs>);
				Attach(eventType, OnItemAdded);
				break;
			case EventType.RendererDiscovererItemDeleted:
				_itemDeleted = (EventHandler<RendererDiscovererItemDeletedEventArgs>)Delegate.Combine(_itemDeleted, eventHandler as EventHandler<RendererDiscovererItemDeletedEventArgs>);
				Attach(eventType, OnItemDeleted);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		protected internal override void DetachEvent<T>(EventType eventType, EventHandler<T> eventHandler)
		{
			switch (eventType)
			{
			case EventType.RendererDiscovererItemAdded:
				_itemAdded = (EventHandler<RendererDiscovererItemAddedEventArgs>)Delegate.Remove(_itemAdded, eventHandler as EventHandler<RendererDiscovererItemAddedEventArgs>);
				Detach(eventType);
				break;
			case EventType.RendererDiscovererItemDeleted:
				_itemDeleted = (EventHandler<RendererDiscovererItemDeletedEventArgs>)Delegate.Remove(_itemDeleted, eventHandler as EventHandler<RendererDiscovererItemDeletedEventArgs>);
				Detach(eventType);
				break;
			default:
				OnEventUnhandled(this, eventType);
				break;
			}
		}

		private void OnItemDeleted(IntPtr args)
		{
			LibVLCEvent.RendererDiscovererItemDeleted rendererDiscovererItemDeleted = RetrieveEvent(args).Union.RendererDiscovererItemDeleted;
			_itemDeleted?.Invoke(this, new RendererDiscovererItemDeletedEventArgs(new RendererItem(rendererDiscovererItemDeleted.item)));
		}

		private void OnItemAdded(IntPtr args)
		{
			LibVLCEvent.RendererDiscovererItemAdded rendererDiscovererItemAdded = RetrieveEvent(args).Union.RendererDiscovererItemAdded;
			_itemAdded?.Invoke(this, new RendererDiscovererItemAddedEventArgs(new RendererItem(rendererDiscovererItemAdded.item)));
		}
	}
	public class PlatformHelper
	{
		public static bool IsWindows => Environment.OSVersion.Platform == PlatformID.Win32NT;

		public static bool IsLinux => Environment.OSVersion.Platform == PlatformID.Unix;

		public static bool IsLinuxDesktop => IsLinux;

		public static bool IsMac => false;

		public static bool IsX64BitProcess => IntPtr.Size == 8;
	}
	public abstract class Internal : IDisposable
	{
		protected readonly Action<IntPtr> Release;

		protected bool IsDisposed;

		public IntPtr NativeReference { get; private set; }

		protected Internal(Func<IntPtr> create, Action<IntPtr> release)
		{
			Release = release;
			IntPtr intPtr = create();
			if (intPtr == IntPtr.Zero)
			{
				OnNativeInstanciationError();
			}
			NativeReference = intPtr;
		}

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

		protected virtual void Dispose(bool disposing)
		{
			if (!IsDisposed && !(NativeReference == IntPtr.Zero))
			{
				Release(NativeReference);
				NativeReference = IntPtr.Zero;
				IsDisposed = true;
			}
		}

		internal virtual void OnNativeInstanciationError()
		{
			throw new VLCException("Failed to perform instanciation on the native side. Make sure you installed the correct VideoLAN.LibVLC.[YourPlatform] package in your platform specific project");
		}
	}
	internal interface IVideoControl : IVideoView
	{
		double Width { get; }

		double Height { get; }

		event EventHandler SizeChanged;
	}
	public interface IVideoView
	{
		MediaPlayer? MediaPlayer { get; set; }
	}
	public class LibVLC : Internal
	{
		[StructLayout(LayoutKind.Explicit)]
		internal struct Native
		{
			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_new")]
			internal static extern IntPtr LibVLCNew(int argc, IntPtr[] argv);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_release")]
			internal static extern void LibVLCRelease(IntPtr libVLC);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_add_intf")]
			internal static extern int LibVLCAddInterface(IntPtr libVLC, IntPtr name);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_set_exit_handler")]
			internal static extern void LibVLCSetExitHandler(IntPtr libVLC, IntPtr cb, IntPtr opaque);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_set_user_agent")]
			internal static extern void LibVLCSetUserAgent(IntPtr libVLC, IntPtr name, IntPtr http);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_set_app_id")]
			internal static extern void LibVLCSetAppId(IntPtr libVLC, IntPtr id, IntPtr version, IntPtr icon);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_log_unset")]
			internal static extern void LibVLCLogUnset(IntPtr libVLC);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_log_set_file")]
			internal static extern void LibVLCLogSetFile(IntPtr libVLC, IntPtr stream);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "libvlc_log_get_context")]
			internal static extern void LibVLCLogGetContext(IntPtr ctx, out IntPtr module, out IntPtr file, out UIntPtr line);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_log_set")]
			internal static extern void LibVLCLogSet(IntPtr libVLC, InternalLogCallback cb, IntPtr data);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_module_description_list_release")]
			internal static extern void LibVLCModuleDescriptionListRelease(IntPtr moduleDescriptionList);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_filter_list_get")]
			internal static extern IntPtr LibVLCAudioFilterListGet(IntPtr libVLC);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_video_filter_list_get")]
			internal static extern IntPtr LibVLCVideoFilterListGet(IntPtr libVLC);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_output_list_get")]
			internal static extern IntPtr LibVLCAudioOutputListGet(IntPtr libVLC);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_output_list_release")]
			internal static extern void LibVLCAudioOutputListRelease(IntPtr list);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_output_device_list_get")]
			internal static extern IntPtr LibVLCAudioOutputDeviceListGet(IntPtr libVLC, IntPtr aout);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_audio_output_device_list_release")]
			internal static extern void LibVLCAudioOutputDeviceListRelease(IntPtr list);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_discoverer_list_get")]
			internal static extern UIntPtr LibVLCMediaDiscovererListGet(IntPtr libVLC, MediaDiscovererCategory category, out IntPtr pppServices);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_discoverer_list_release")]
			internal static extern void LibVLCMediaDiscovererListRelease(IntPtr ppServices, UIntPtr count);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_dialog_set_callbacks")]
			internal static extern void LibVLCDialogSetCallbacks(IntPtr libVLC, DialogCallbacks callbacks, IntPtr data);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_renderer_discoverer_list_get")]
			internal static extern UIntPtr LibVLCRendererDiscovererGetList(IntPtr libVLC, out IntPtr discovererList);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_renderer_discoverer_list_release")]
			internal static extern void LibVLCRendererDiscovererReleaseList(IntPtr discovererList, UIntPtr count);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_retain")]
			internal static extern void LibVLCRetain(IntPtr libVLC);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_get_version")]
			internal static extern IntPtr LibVLCVersion();

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_get_changeset")]
			internal static extern IntPtr LibVLCChangeset();

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_errmsg")]
			internal static extern IntPtr LibVLCErrorMessage();

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_clearerr")]
			internal static extern void LibVLCClearError();

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_get_compiler")]
			internal static extern IntPtr LibVLCGetCompiler();

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_clock")]
			internal static extern long LibVLCClock();
		}

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalExitCallback(IntPtr libVLCHandle);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalLogCallback(IntPtr data, LogLevel logLevel, IntPtr logContext, IntPtr format, IntPtr args);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalDisplayErrorCallback(IntPtr data, IntPtr title, IntPtr text);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalDisplayLoginCallback(IntPtr data, IntPtr dialogId, IntPtr title, IntPtr text, IntPtr defaultUsername, bool askStore);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalDisplayQuestionCallback(IntPtr data, IntPtr dialogId, IntPtr title, IntPtr text, DialogQuestionType type, IntPtr cancelText, IntPtr firstActionText, IntPtr secondActionText);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalDisplayProgressCallback(IntPtr data, IntPtr dialogId, IntPtr title, IntPtr text, bool indeterminate, float position, IntPtr cancelText);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalCancelCallback(IntPtr data, IntPtr dialogId);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void InternalUpdateProgressCallback(IntPtr data, IntPtr dialogId, float position, IntPtr text);

		internal readonly struct DialogCallbacks
		{
			internal readonly IntPtr DisplayError;

			internal readonly IntPtr DisplayLogin;

			internal readonly IntPtr DisplayQuestion;

			internal readonly IntPtr DisplayProgress;

			internal readonly IntPtr Cancel;

			internal readonly IntPtr UpdateProgress;

			internal DialogCallbacks(InternalDisplayErrorCallback displayError, InternalDisplayLoginCallback displayLogin, InternalDisplayQuestionCallback displayQuestion, InternalDisplayProgressCallback displayProgress, InternalCancelCallback cancel, InternalUpdateProgressCallback updateProgress)
			{
				DisplayError = Marshal.GetFunctionPointerForDelegate((Delegate)displayError);
				DisplayLogin = Marshal.GetFunctionPointerForDelegate((Delegate)displayLogin);
				DisplayQuestion = Marshal.GetFunctionPointerForDelegate((Delegate)displayQuestion);
				DisplayProgress = Marshal.GetFunctionPointerForDelegate((Delegate)displayProgress);
				Cancel = Marshal.GetFunctionPointerForDelegate((Delegate)cancel);
				UpdateProgress = Marshal.GetFunctionPointerForDelegate((Delegate)updateProgress);
			}
		}

		private readonly object _logLock = new object();

		private EventHandler<LogEventArgs>? _log;

		private IntPtr _logFileHandle;

		private GCHandle _gcHandle;

		internal ExitCallback? _exitCallback;

		private int _logSubscriberCount;

		private DisplayError? _error;

		private DisplayLogin? _login;

		private DisplayQuestion? _question;

		private DisplayProgress? _displayProgress;

		private UpdateProgress? _updateProgress;

		private readonly Dictionary<IntPtr, CancellationTokenSource> _cts = new Dictionary<IntPtr, CancellationTokenSource>();

		private static readonly InternalExitCallback ExitCallbackHandle = ExitCallback;

		private static readonly InternalLogCallback LogCallbackHandle = LogCallback;

		private static readonly InternalDisplayErrorCallback DisplayErrorCallbackHandle = DisplayErrorCallback;

		private static readonly InternalDisplayLoginCallback DisplayLoginCallbackHandle = DisplayLoginCallback;

		private static readonly InternalDisplayQuestionCallback DisplayQuestionCallbackHandle = DisplayQuestionCallback;

		private static readonly InternalDisplayProgressCallback DisplayProgressCallbackHandle = DisplayProgressCallback;

		private static readonly InternalCancelCallback CancelCallbackHandle = CancelCallback;

		private static readonly InternalUpdateProgressCallback UpdateProgressCallbackHandle = UpdateProgressCallback;

		private static readonly DialogCallbacks DialogCb = new DialogCallbacks(DisplayErrorCallbackHandle, DisplayLoginCallbackHandle, DisplayQuestionCallbackHandle, DisplayProgressCallbackHandle, CancelCallbackHandle, UpdateProgressCallbackHandle);

		public ModuleDescription[] AudioFilters => MarshalUtils.Retrieve(() => Native.LibVLCAudioFilterListGet(base.NativeReference), MarshalUtils.PtrToStructure<ModuleDescriptionStructure>, (ModuleDescriptionStructure s) => s.Build(), (ModuleDescriptionStructure module) => module.Next, Native.LibVLCModuleDescriptionListRelease);

		public ModuleDescription[] VideoFilters => MarshalUtils.Retrieve(() => Native.LibVLCVideoFilterListGet(base.NativeReference), MarshalUtils.PtrToStructure<ModuleDescriptionStructure>, (ModuleDescriptionStructure s) => s.Build(), (ModuleDescriptionStructure module) => module.Next, Native.LibVLCModuleDescriptionListRelease);

		public AudioOutputDescription[] AudioOutputs => MarshalUtils.Retrieve(() => Native.LibVLCAudioOutputListGet(base.NativeReference), (IntPtr ptr) => MarshalUtils.PtrToStructure<AudioOutputDescriptionStructure>(ptr), (AudioOutputDescriptionStructure s) => s.Build(), (AudioOutputDescriptionStructure s) => s.Next, Native.LibVLCAudioOutputListRelease);

		public bool DialogHandlersSet => _error != null;

		public RendererDescription[] RendererList => MarshalUtils.Retrieve(base.NativeReference, delegate(IntPtr nativeRef, out IntPtr array)
		{
			return Native.LibVLCRendererDiscovererGetList(nativeRef, out array);
		}, MarshalUtils.PtrToStructure<RendererDescriptionStructure>, (RendererDescriptionStructure m) => m.Build(), Native.LibVLCRendererDiscovererReleaseList);

		public string Version => Native.LibVLCVersion().FromUtf8();

		public string Changeset => Native.LibVLCChangeset().FromUtf8();

		public string? LastLibVLCError => Native.LibVLCErrorMessage().FromUtf8();

		public string LibVLCCompiler => Native.LibVLCGetCompiler().FromUtf8();

		public long Clock => Native.LibVLCClock();

		public event EventHandler<LogEventArgs> Log
		{
			add
			{
				lock (_logLock)
				{
					_log = (EventHandler<LogEventArgs>)Delegate.Combine(_log, value);
					if (_logSubscriberCount == 0)
					{
						Native.LibVLCLogSet(base.NativeReference, LogCallbackHandle, GCHandle.ToIntPtr(_gcHandle));
					}
					_logSubscriberCount++;
				}
			}
			remove
			{
				lock (_logLock)
				{
					_log = (EventHandler<LogEventArgs>)Delegate.Remove(_log, value);
					if (_logSubscriberCount > 0)
					{
						_logSubscriberCount--;
					}
					if (_logSubscriberCount == 0)
					{
						Native.LibVLCLogUnset(base.NativeReference);
					}
				}
			}
		}

		protected bool Equals(LibVLC other)
		{
			return base.NativeReference.Equals((object?)(nint)other.NativeReference);
		}

		public override bool Equals(object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (this == obj)
			{
				return true;
			}
			if (obj.GetType() != GetType())
			{
				return false;
			}
			return Equals((LibVLC)obj);
		}

		public override int GetHashCode()
		{
			return base.NativeReference.GetHashCode();
		}

		public LibVLC(params string[] options)
			: base(() => MarshalUtils.CreateWithOptions(PatchOptions(options), Native.LibVLCNew), Native.LibVLCRelease)
		{
			_gcHandle = GCHandle.Alloc(this);
		}

		public LibVLC(bool enableDebugLogs, params string[] options)
			: base(() => MarshalUtils.CreateWithOptions(PatchOptions(options, enableDebugLogs), Native.LibVLCNew), Native.LibVLCRelease)
		{
			_gcHandle = GCHandle.Alloc(this);
		}

		public LibVLC(bool enableDebugLogs, bool useDefaultLibVLCOptions, params string[] options)
			: base(() => MarshalUtils.CreateWithOptions(PatchOptions(options, enableDebugLogs, useDefaultLibVLCOptions), Native.LibVLCNew), Native.LibVLCRelease)
		{
			_gcHandle = GCHandle.Alloc(this);
		}

		private static string[] PatchOptions(string[] options, bool enableDebugLogs = false, bool useDefaultLibVLCOptions = true)
		{
			if (options == null)
			{
				options = new string[0];
			}
			if (enableDebugLogs)
			{
				options = options.Concat(new string[1] { "--verbose=2" }).ToArray();
			}
			return options;
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				UnsetDialogHandlers();
				Native.LibVLCLogUnset(base.NativeReference);
				_gcHandle.Free();
				_exitCallback = null;
				_log = null;
			}
			base.Dispose(disposing);
		}

		public static bool operator ==(LibVLC? libvlc1, LibVLC? libvlc2)
		{
			IntPtr? intPtr = libvlc1?.NativeReference;
			IntPtr? intPtr2 = libvlc2?.NativeReference;
			if (intPtr.HasValue != intPtr2.HasValue)
			{
				return false;
			}
			if (!intPtr.HasValue)
			{
				return true;
			}
			return intPtr.GetValueOrDefault() == intPtr2.GetValueOrDefault();
		}

		public static bool operator !=(LibVLC? libvlc1, LibVLC? libvlc2)
		{
			IntPtr? intPtr = libvlc1?.NativeReference;
			IntPtr? intPtr2 = libvlc2?.NativeReference;
			if (intPtr.HasValue != intPtr2.HasValue)
			{
				return true;
			}
			if (!intPtr.HasValue)
			{
				return false;
			}
			return intPtr.GetValueOrDefault() != intPtr2.GetValueOrDefault();
		}

		public bool AddInterface(string? name)
		{
			IntPtr namePtr = name.ToUtf8();
			return MarshalUtils.PerformInteropAndFree(() => Native.LibVLCAddInterface(base.NativeReference, namePtr) == 0, namePtr);
		}

		public void SetExitHandler(ExitCallback cb)
		{
			_exitCallback = cb;
			if (cb == null)
			{
				Native.LibVLCSetExitHandler(base.NativeReference, IntPtr.Zero, IntPtr.Zero);
			}
			else
			{
				Native.LibVLCSetExitHandler(base.NativeReference, Marshal.GetFunctionPointerForDelegate((Delegate)ExitCallbackHandle), GCHandle.ToIntPtr(_gcHandle));
			}
		}

		public void SetUserAgent(string name, string http)
		{
			IntPtr nameUtf8 = name.ToUtf8();
			IntPtr httpUtf8 = http.ToUtf8();
			MarshalUtils.PerformInteropAndFree(delegate
			{
				Native.LibVLCSetUserAgent(base.NativeReference, nameUtf8, httpUtf8);
			}, nameUtf8, httpUtf8);
		}

		public void SetAppId(string? id, string? version, string? icon)
		{
			IntPtr idUtf8 = id.ToUtf8();
			IntPtr versionUtf8 = version.ToUtf8();
			IntPtr iconUtf8 = icon.ToUtf8();
			MarshalUtils.PerformInteropAndFree(delegate
			{
				Native.LibVLCSetAppId(base.NativeReference, idUtf8, versionUtf8, iconUtf8);
			}, idUtf8, versionUtf8, iconUtf8);
		}

		public bool CloseLogFile()
		{
			if (_logFileHandle == IntPtr.Zero)
			{
				return true;
			}
			return MarshalUtils.Close(_logFileHandle);
		}

		public void SetLogFile(string filename)
		{
			if (string.IsNullOrEmpty(filename))
			{
				throw new NullReferenceException("filename");
			}
			_logFileHandle = NativeFilePtr(filename);
			Native.LibVLCLogSetFile(base.NativeReference, _logFileHandle);
		}

		private IntPtr NativeFilePtr(string filename)
		{
			if (!MarshalUtils.Open(filename, out var fileHandle))
			{
				throw new VLCException("Could not get FILE * for log_set_file");
			}
			return fileHandle;
		}

		public AudioOutputDevice[] AudioOutputDevices(string audioOutputName)
		{
			return MarshalUtils.Retrieve(delegate
			{
				IntPtr audioOutputNameUtf8 = audioOutputName.ToUtf8();
				return MarshalUtils.PerformInteropAndFree(() => Native.LibVLCAudioOutputDeviceListGet(base.NativeReference, audioOutputNameUtf8), audioOutputNameUtf8);
			}, MarshalUtils.PtrToStructure<AudioOutputDeviceStructure>, (AudioOutputDeviceStructure s) => s.Build(), (AudioOutputDeviceStructure device) => device.Next, Native.LibVLCAudioOutputDeviceListRelease);
		}

		public MediaDiscovererDescription[] MediaDiscoverers(MediaDiscovererCategory discovererCategory)
		{
			return MarshalUtils.Retrieve(base.NativeReference, discovererCategory, delegate(IntPtr nativeRef, MediaDiscovererCategory enumType, out IntPtr array)
			{
				return Native.LibVLCMediaDiscovererListGet(nativeRef, enumType, out array);
			}, MarshalUtils.PtrToStructure<MediaDiscovererDescriptionStructure>, (MediaDiscovererDescriptionStructure m) => m.Build(), Native.LibVLCMediaDiscovererListRelease);
		}

		public void SetDialogHandlers(DisplayError error, DisplayLogin login, DisplayQuestion question, DisplayProgress displayProgress, UpdateProgress updateProgress)
		{
			_error = error ?? throw new ArgumentNullException("error");
			_login = login ?? throw new ArgumentNullException("login");
			_question = question ?? throw new ArgumentNullException("question");
			_displayProgress = displayProgress ?? throw new ArgumentNullException("displayProgress");
			_updateProgress = updateProgress ?? throw new ArgumentNullException("updateProgress");
			Native.LibVLCDialogSetCallbacks(base.NativeReference, DialogCb, GCHandle.ToIntPtr(_gcHandle));
		}

		public void UnsetDialogHandlers()
		{
			if (DialogHandlersSet)
			{
				Native.LibVLCDialogSetCallbacks(base.NativeReference, default(DialogCallbacks), IntPtr.Zero);
				_error = null;
				_login = null;
				_question = null;
				_displayProgress = null;
				_updateProgress = null;
			}
		}

		private void OnDisplayError(string? title, string? text)
		{
			_error?.Invoke(title, text);
		}

		private void OnDisplayLogin(IntPtr dialogId, string? title, string? text, string? defaultUsername, bool askStore)
		{
			if (_login != null)
			{
				CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
				Dialog dialog = new Dialog(new DialogId(dialogId));
				_cts[dialogId] = cancellationTokenSource;
				_login(dialog, title, text, defaultUsername, askStore, cancellationTokenSource.Token);
			}
		}

		private void OnDisplayQuestion(IntPtr dialogId, string? title, string? text, DialogQuestionType type, string? cancelText, string? firstActionText, string? secondActionText)
		{
			if (_question != null)
			{
				CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
				Dialog dialog = new Dialog(new DialogId(dialogId));
				_cts[dialogId] = cancellationTokenSource;
				_question(dialog, title, text, type, cancelText, firstActionText, secondActionText, cancellationTokenSource.Token);
			}
		}

		private void OnDisplayProgress(IntPtr dialogId, string? title, string? text, bool indeterminate, float position, string? cancelText)
		{
			if (_displayProgress != null)
			{
				CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
				Dialog dialog = new Dialog(new DialogId(dialogId));
				_cts[dialogId] = cancellationTokenSource;
				_displayProgress(dialog, title, text, indeterminate, position, cancelText, cancellationTokenSource.Token);
			}
		}

		private void OnCancel(IntPtr dialogId)
		{
			if (_cts.TryGetValue(dialogId, out CancellationTokenSource value))
			{
				value.Cancel();
				_cts.Remove(dialogId);
			}
		}

		private void OnUpdateProgress(IntPtr dialogId, float position, string? text)
		{
			if (_updateProgress != null)
			{
				Dialog dialog = new Dialog(new DialogId(dialogId));
				_updateProgress(dialog, position, text);
			}
		}

		private static void GetLogContext(IntPtr logContext, out string? module, out string? file, out uint? line)
		{
			Native.LibVLCLogGetContext(logContext, out var module2, out var file2, out var line2);
			line = ((line2 == UIntPtr.Zero) ? ((uint?)null) : new uint?(line2.ToUInt32()));
			module = module2.FromUtf8();
			file = file2.FromUtf8();
		}

		internal void Retain()
		{
			Native.LibVLCRetain(base.NativeReference);
		}

		public void ClearLibVLCError()
		{
			Native.LibVLCClearError();
		}

		[MonoPInvokeCallback(typeof(InternalExitCallback))]
		private static void ExitCallback(IntPtr libVLCHandle)
		{
			MarshalUtils.GetInstance<LibVLC>(libVLCHandle)?._exitCallback?.Invoke();
		}

		[MonoPInvokeCallback(typeof(InternalLogCallback))]
		private static void LogCallback(IntPtr libVLCHandle, LogLevel logLevel, IntPtr logContext, IntPtr format, IntPtr args)
		{
			LibVLC libVLC = MarshalUtils.GetInstance<LibVLC>(libVLCHandle);
			string message;
			string module;
			string file;
			uint? line;
			try
			{
				message = MarshalUtils.GetLogMessage(format, args);
				GetLogContext(logContext, out module, out file, out line);
				Task.Factory.StartNew(logAction);
			}
			catch
			{
			}
			void logAction()
			{
				libVLC?._log?.Invoke(null, new LogEventArgs(logLevel, message, module, file, line));
			}
		}

		[MonoPInvokeCallback(typeof(InternalDisplayErrorCallback))]
		private static void DisplayErrorCallback(IntPtr libVLCHandle, IntPtr title, IntPtr text)
		{
			MarshalUtils.GetInstance<LibVLC>(libVLCHandle)?.OnDisplayError(title.FromUtf8(), text.FromUtf8());
		}

		[MonoPInvokeCallback(typeof(InternalDisplayLoginCallback))]
		private static void DisplayLoginCallback(IntPtr libVLCHandle, IntPtr dialogId, IntPtr title, IntPtr text, IntPtr defaultUsername, bool askStore)
		{
			MarshalUtils.GetInstance<LibVLC>(libVLCHandle)?.OnDisplayLogin(dialogId, title.FromUtf8(), text.FromUtf8(), defaultUsername.FromUtf8(), askStore);
		}

		[MonoPInvokeCallback(typeof(InternalDisplayQuestionCallback))]
		private static void DisplayQuestionCallback(IntPtr libVLCHandle, IntPtr dialogId, IntPtr title, IntPtr text, DialogQuestionType type, IntPtr cancelText, IntPtr firstActionText, IntPtr secondActionText)
		{
			MarshalUtils.GetInstance<LibVLC>(libVLCHandle)?.OnDisplayQuestion(dialogId, title.FromUtf8(), text.FromUtf8(), type, cancelText.FromUtf8(), firstActionText.FromUtf8(), secondActionText.FromUtf8());
		}

		[MonoPInvokeCallback(typeof(InternalDisplayProgressCallback))]
		private static void DisplayProgressCallback(IntPtr libVLCHandle, IntPtr dialogId, IntPtr title, IntPtr text, bool indeterminate, float position, IntPtr cancelText)
		{
			MarshalUtils.GetInstance<LibVLC>(libVLCHandle)?.OnDisplayProgress(dialogId, title.FromUtf8(), text.FromUtf8(), indeterminate, position, cancelText.FromUtf8());
		}

		[MonoPInvokeCallback(typeof(InternalCancelCallback))]
		private static void CancelCallback(IntPtr libVLCHandle, IntPtr dialogId)
		{
			MarshalUtils.GetInstance<LibVLC>(libVLCHandle)?.OnCancel(dialogId);
		}

		[MonoPInvokeCallback(typeof(InternalUpdateProgressCallback))]
		private static void UpdateProgressCallback(IntPtr libVLCHandle, IntPtr dialogId, float position, IntPtr text)
		{
			MarshalUtils.GetInstance<LibVLC>(libVLCHandle)?.OnUpdateProgress(dialogId, position, text.FromUtf8());
		}
	}
	public enum LogLevel
	{
		Debug = 0,
		Notice = 2,
		Warning = 3,
		Error = 4
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public delegate void ExitCallback();
	internal enum EventType
	{
		MediaMetaChanged = 0,
		MediaSubItemAdded = 1,
		MediaDurationChanged = 2,
		MediaParsedChanged = 3,
		MediaFreed = 4,
		MediaStateChanged = 5,
		MediaSubItemTreeAdded = 6,
		MediaPlayerMediaChanged = 256,
		MediaPlayerNothingSpecial = 257,
		MediaPlayerOpening = 258,
		MediaPlayerBuffering = 259,
		MediaPlayerPlaying = 260,
		MediaPlayerPaused = 261,
		MediaPlayerStopped = 262,
		MediaPlayerForward = 263,
		MediaPlayerBackward = 264,
		MediaPlayerEndReached = 265,
		MediaPlayerEncounteredError = 266,
		MediaPlayerTimeChanged = 267,
		MediaPlayerPositionChanged = 268,
		MediaPlayerSeekableChanged = 269,
		MediaPlayerPausableChanged = 270,
		MediaPlayerTitleChanged = 271,
		MediaPlayerSnapshotTaken = 272,
		MediaPlayerLengthChanged = 273,
		MediaPlayerVout = 274,
		MediaPlayerScrambledChanged = 275,
		MediaPlayerESAdded = 276,
		MediaPlayerESDeleted = 277,
		MediaPlayerESSelected = 278,
		MediaPlayerCorked = 279,
		MediaPlayerUncorked = 280,
		MediaPlayerMuted = 281,
		MediaPlayerUnmuted = 282,
		MediaPlayerAudioVolume = 283,
		MediaPlayerAudioDevice = 284,
		MediaPlayerChapterChanged = 285,
		MediaListItemAdded = 512,
		MediaListWillAddItem = 513,
		MediaListItemDeleted = 514,
		MediaListWillDeleteItem = 515,
		MediaListEndReached = 516,
		MediaListViewItemAdded = 768,
		MediaListViewWillAddItem = 769,
		MediaListViewItemDeleted = 770,
		MediaListViewWillDeleteItem = 771,
		MediaListPlayerPlayed = 1024,
		MediaListPlayerNextItemSet = 1025,
		MediaListPlayerStopped = 1026,
		MediaDiscovererStarted = 1280,
		MediaDiscovererStopped = 1281,
		RendererDiscovererItemAdded = 1282,
		RendererDiscovererItemDeleted = 1283,
		VlmMediaAdded = 1536,
		VlmMediaRemoved = 1537,
		VlmMediaChanged = 1538,
		VlmMediaInstanceStarted = 1539,
		VlmMediaInstanceStopped = 1540,
		VlmMediaInstanceStatusInit = 1541,
		VlmMediaInstanceStatusOpening = 1542,
		VlmMediaInstanceStatusPlaying = 1543,
		VlmMediaInstanceStatusPause = 1544,
		VlmMediaInstanceStatusEnd = 1545,
		VlmMediaInstanceStatusError = 1546
	}
	internal readonly struct LibVLCEvent
	{
		[StructLayout(LayoutKind.Explicit)]
		internal readonly struct EventUnion
		{
			[FieldOffset(0)]
			internal readonly MediaMetaChanged MediaMetaChanged;

			[FieldOffset(0)]
			internal readonly MediaSubItemAdded MediaSubItemAdded;

			[FieldOffset(0)]
			internal readonly MediaDurationChanged MediaDurationChanged;

			[FieldOffset(0)]
			internal readonly MediaParsedChanged MediaParsedChanged;

			[FieldOffset(0)]
			internal readonly MediaFreed MediaFreed;

			[FieldOffset(0)]
			internal readonly MediaStateChanged MediaStateChanged;

			[FieldOffset(0)]
			internal readonly MediaSubItemTreeAdded MediaSubItemTreeAdded;

			[FieldOffset(0)]
			internal readonly MediaPlayerBuffering MediaPlayerBuffering;

			[FieldOffset(0)]
			internal readonly MediaPlayerChapterChanged MediaPlayerChapterChanged;

			[FieldOffset(0)]
			internal readonly MediaPlayerPositionChanged MediaPlayerPositionChanged;

			[FieldOffset(0)]
			internal readonly MediaPlayerTimeChanged MediaPlayerTimeChanged;

			[FieldOffset(0)]
			internal readonly MediaPlayerTitleChanged MediaPlayerTitleChanged;

			[FieldOffset(0)]
			internal readonly MediaPlayerSeekableChanged MediaPlayerSeekableChanged;

			[FieldOffset(0)]
			internal readonly MediaPlayerPausableChanged MediaPlayerPausableChanged;

			[FieldOffset(0)]
			internal readonly MediaPlayerScrambledChanged MediaPlayerScrambledChanged;

			[FieldOffset(0)]
			internal readonly MediaPlayerVoutChanged MediaPlayerVoutChanged;

			[FieldOffset(0)]
			internal readonly MediaListItemAdded MediaListItemAdded;

			[FieldOffset(0)]
			internal readonly MediaListWillAddItem MediaListWillAddItem;

			[FieldOffset(0)]
			internal readonly MediaListItemDeleted MediaListItemDeleted;

			[FieldOffset(0)]
			internal readonly MediaListWillDeleteItem MediaListWillDeleteItem;

			[FieldOffset(0)]
			internal readonly MediaListPlayerNextItemSet MediaListPlayerNextItemSet;

			[FieldOffset(0)]
			internal readonly MediaPlayerSnapshotTaken MediaPlayerSnapshotTaken;

			[FieldOffset(0)]
			internal readonly MediaPlayerLengthChanged MediaPlayerLengthChanged;

			[FieldOffset(0)]
			internal readonly VlmMediaEvent VlmMediaEvent;

			[FieldOffset(0)]
			internal readonly MediaPlayerMediaChanged MediaPlayerMediaChanged;

			[FieldOffset(0)]
			internal readonly EsChanged EsChanged;

			[FieldOffset(0)]
			internal readonly VolumeChanged MediaPlayerVolumeChanged;

			[FieldOffset(0)]
			internal readonly AudioDeviceChanged AudioDeviceChanged;

			[FieldOffset(0)]
			internal readonly RendererDiscovererItemAdded RendererDiscovererItemAdded;

			[FieldOffset(0)]
			internal readonly RendererDiscovererItemDeleted RendererDiscovererItemDeleted;
		}

		internal readonly struct MediaMetaChanged
		{
			internal readonly MetadataType MetaType;
		}

		internal readonly struct MediaSubItemAdded
		{
			internal readonly IntPtr NewChild;
		}

		internal readonly struct MediaDurationChanged
		{
			internal readonly long NewDuration;
		}

		internal readonly struct MediaParsedChanged
		{
			internal readonly MediaParsedStatus NewStatus;
		}

		internal readonly struct MediaFreed
		{
			internal readonly IntPtr MediaInstance;
		}

		internal readonly struct MediaStateChanged
		{
			internal readonly VLCState NewState;
		}

		internal readonly struct MediaSubItemTreeAdded
		{
			internal readonly IntPtr MediaInstance;
		}

		internal readonly struct MediaPlayerBuffering
		{
			internal readonly float NewCache;
		}

		internal readonly struct MediaPlayerChapterChanged
		{
			internal readonly int NewChapter;
		}

		internal readonly struct MediaPlayerPositionChanged
		{
			internal readonly float NewPosition;
		}

		internal readonly struct MediaPlayerTimeChanged
		{
			internal readonly long NewTime;
		}

		internal readonly struct MediaPlayerTitleChanged
		{
			internal readonly int NewTitle;
		}

		internal readonly struct MediaPlayerSeekableChanged
		{
			internal readonly int NewSeekable;
		}

		internal readonly struct MediaPlayerPausableChanged
		{
			internal readonly int NewPausable;
		}

		internal readonly struct MediaPlayerScrambledChanged
		{
			internal readonly int NewScrambled;
		}

		internal readonly struct MediaPlayerVoutChanged
		{
			internal readonly int NewCount;
		}

		internal readonly struct MediaPlayerSnapshotTaken
		{
			internal readonly IntPtr Filename;
		}

		internal readonly struct MediaPlayerLengthChanged
		{
			internal readonly long NewLength;
		}

		internal readonly struct EsChanged
		{
			internal readonly TrackType Type;

			internal readonly int Id;
		}

		internal readonly struct AudioDeviceChanged
		{
			internal readonly IntPtr Device;
		}

		internal readonly struct MediaPlayerMediaChanged
		{
			internal readonly IntPtr NewMedia;
		}

		internal readonly struct VolumeChanged
		{
			internal readonly float Volume;
		}

		internal readonly struct MediaListItemAdded
		{
			internal readonly IntPtr MediaInstance;

			internal readonly int Index;
		}

		internal readonly struct MediaListWillAddItem
		{
			internal readonly IntPtr MediaInstance;

			internal readonly int Index;
		}

		internal readonly struct MediaListItemDeleted
		{
			internal readonly IntPtr MediaInstance;

			internal readonly int Index;
		}

		internal readonly struct MediaListWillDeleteItem
		{
			internal readonly IntPtr MediaInstance;

			internal readonly int Index;
		}

		internal readonly struct MediaListPlayerNextItemSet
		{
			internal readonly IntPtr MediaInstance;
		}

		internal readonly struct VlmMediaEvent
		{
			internal readonly IntPtr MediaName;

			internal readonly IntPtr InstanceName;
		}

		internal readonly struct RendererDiscovererItemAdded
		{
			internal readonly IntPtr item;
		}

		internal readonly struct RendererDiscovererItemDeleted
		{
			internal readonly IntPtr item;
		}

		internal readonly EventType Type;

		internal readonly IntPtr Sender;

		internal readonly EventUnion Union;
	}
	public class MediaMetaChangedEventArgs : EventArgs
	{
		public readonly MetadataType MetadataType;

		internal MediaMetaChangedEventArgs(MetadataType metadataType)
		{
			MetadataType = metadataType;
		}
	}
	public class MediaParsedChangedEventArgs : EventArgs
	{
		public readonly MediaParsedStatus ParsedStatus;

		internal MediaParsedChangedEventArgs(MediaParsedStatus parsedStatus)
		{
			ParsedStatus = parsedStatus;
		}
	}
	public class MediaSubItemAddedEventArgs : EventArgs
	{
		public readonly Media SubItem;

		internal MediaSubItemAddedEventArgs(IntPtr mediaPtr)
		{
			SubItem = new Media(mediaPtr);
		}
	}
	public class MediaDurationChangedEventArgs : EventArgs
	{
		public readonly long Duration;

		internal MediaDurationChangedEventArgs(long duration)
		{
			Duration = duration;
		}
	}
	public class MediaFreedEventArgs : EventArgs
	{
		public readonly Media Media;

		internal MediaFreedEventArgs(IntPtr mediaPtr)
		{
			Media = new Media(mediaPtr);
		}
	}
	public class MediaStateChangedEventArgs : EventArgs
	{
		public readonly VLCState State;

		internal MediaStateChangedEventArgs(VLCState state)
		{
			State = state;
		}
	}
	public class MediaSubItemTreeAddedEventArgs : EventArgs
	{
		public readonly Media SubItem;

		internal MediaSubItemTreeAddedEventArgs(IntPtr subItemPtr)
		{
			SubItem = new Media(subItemPtr);
		}
	}
	public class MediaPlayerMediaChangedEventArgs : EventArgs
	{
		public readonly Media Media;

		internal MediaPlayerMediaChangedEventArgs(IntPtr mediaPtr)
		{
			Media = new Media(mediaPtr);
		}
	}
	public class MediaPlayerBufferingEventArgs : EventArgs
	{
		public readonly float Cache;

		internal MediaPlayerBufferingEventArgs(float cache)
		{
			Cache = cache;
		}
	}
	public class MediaPlayerTimeChangedEventArgs : EventArgs
	{
		public readonly long Time;

		internal MediaPlayerTimeChangedEventArgs(long time)
		{
			Time = time;
		}
	}
	public class MediaPlayerPositionChangedEventArgs : EventArgs
	{
		public readonly float Position;

		internal MediaPlayerPositionChangedEventArgs(float position)
		{
			Position = position;
		}
	}
	public class MediaPlayerSeekableChangedEventArgs : EventArgs
	{
		public readonly int Seekable;

		internal MediaPlayerSeekableChangedEventArgs(int seekable)
		{
			Seekable = seekable;
		}
	}
	public class MediaPlayerPausableChangedEventArgs : EventArgs
	{
		public readonly int Pausable;

		internal MediaPlayerPausableChangedEventArgs(int pausable)
		{
			Pausable = pausable;
		}
	}
	public class MediaPlayerTitleChangedEventArgs : EventArgs
	{
		public readonly int Title;

		internal MediaPlayerTitleChangedEventArgs(int title)
		{
			Title = title;
		}
	}
	public class MediaPlayerChapterChangedEventArgs : EventArgs
	{
		public readonly int Chapter;

		internal MediaPlayerChapterChangedEventArgs(int chapter)
		{
			Chapter = chapter;
		}
	}
	public class MediaPlayerSnapshotTakenEventArgs : EventArgs
	{
		public readonly string Filename;

		internal MediaPlayerSnapshotTakenEventArgs(string filename)
		{
			Filename = filename;
		}
	}
	public class MediaPlayerLengthChangedEventArgs : EventArgs
	{
		public readonly long Length;

		internal MediaPlayerLengthChangedEventArgs(long length)
		{
			Length = length;
		}
	}
	public class MediaPlayerVoutEventArgs : EventArgs
	{
		public readonly int Count;

		internal MediaPlayerVoutEventArgs(int count)
		{
			Count = count;
		}
	}
	public class MediaPlayerScrambledChangedEventArgs : EventArgs
	{
		public readonly int Scrambled;

		internal MediaPlayerScrambledChangedEventArgs(int scrambled)
		{
			Scrambled = scrambled;
		}
	}
	public class MediaPlayerESAddedEventArgs : EventArgs
	{
		public readonly int Id;

		public readonly TrackType Type;

		internal MediaPlayerESAddedEventArgs(int id, TrackType type)
		{
			Id = id;
			Type = type;
		}
	}
	public class MediaPlayerESDeletedEventArgs : EventArgs
	{
		public readonly int Id;

		public readonly TrackType Type;

		internal MediaPlayerESDeletedEventArgs(int id, TrackType type)
		{
			Id = id;
			Type = type;
		}
	}
	public class MediaPlayerESSelectedEventArgs : EventArgs
	{
		public readonly int Id;

		public readonly TrackType Type;

		internal MediaPlayerESSelectedEventArgs(int id, TrackType type)
		{
			Id = id;
			Type = type;
		}
	}
	public class MediaPlayerAudioDeviceEventArgs : EventArgs
	{
		public readonly string AudioDevice;

		internal MediaPlayerAudioDeviceEventArgs(string audioDevice)
		{
			AudioDevice = audioDevice;
		}
	}
	public class MediaPlayerVolumeChangedEventArgs : EventArgs
	{
		public readonly float Volume;

		internal MediaPlayerVolumeChangedEventArgs(float volume)
		{
			Volume = volume;
		}
	}
	public abstract class MediaListBaseEventArgs : EventArgs
	{
		public readonly Media Media;

		public readonly int Index;

		protected internal MediaListBaseEventArgs(Media media, int index)
		{
			Media = media;
			Index = index;
		}
	}
	public class MediaListItemAddedEventArgs : MediaListBaseEventArgs
	{
		internal MediaListItemAddedEventArgs(Media media, int index)
			: base(media, index)
		{
		}
	}
	public class MediaListWillAddItemEventArgs : MediaListBaseEventArgs
	{
		internal MediaListWillAddItemEventArgs(Media media, int index)
			: base(media, index)
		{
		}
	}
	public class MediaListItemDeletedEventArgs : MediaListBaseEventArgs
	{
		internal MediaListItemDeletedEventArgs(Media media, int index)
			: base(media, index)
		{
		}
	}
	public class MediaListWillDeleteItemEventArgs : MediaListBaseEventArgs
	{
		internal MediaListWillDeleteItemEventArgs(Media media, int index)
			: base(media, index)
		{
		}
	}
	public class RendererDiscovererItemAddedEventArgs : EventArgs
	{
		public RendererItem RendererItem { get; }

		internal RendererDiscovererItemAddedEventArgs(RendererItem rendererItem)
		{
			RendererItem = rendererItem;
		}
	}
	public class RendererDiscovererItemDeletedEventArgs : EventArgs
	{
		public RendererItem RendererItem { get; }

		internal RendererDiscovererItemDeletedEventArgs(RendererItem rendererItem)
		{
			RendererItem = rendererItem;
		}
	}
	public sealed class LogEventArgs : EventArgs
	{
		public LogLevel Level { get; }

		public string Message { get; }

		public string? Module { get; }

		public string? SourceFile { get; }

		public uint? SourceLine { get; }

		public string FormattedLog { get; }

		internal LogEventArgs(LogLevel level, string message, string? module, string? sourceFile, uint? sourceLine)
		{
			Level = level;
			Message = message;
			Module = module;
			SourceFile = sourceFile;
			SourceLine = sourceLine;
			FormattedLog = $"{module} {level}: {message}";
		}
	}
	public class Media : Internal
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		internal struct Native
		{
			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_new_location")]
			internal static extern IntPtr LibVLCMediaNewLocation(IntPtr libVLC, IntPtr mrl);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_new_path")]
			internal static extern IntPtr LibVLCMediaNewPath(IntPtr libVLC, IntPtr path);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_new_as_node")]
			internal static extern IntPtr LibVLCMediaNewAsNode(IntPtr libVLC, IntPtr name);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_new_fd")]
			internal static extern IntPtr LibVLCMediaNewFd(IntPtr libVLC, int fd);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_release")]
			internal static extern void LibVLCMediaRelease(IntPtr media);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_list_media")]
			internal static extern IntPtr LibVLCMediaListMedia(IntPtr mediaList);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_new_callbacks")]
			internal static extern IntPtr LibVLCMediaNewCallbacks(IntPtr libVLC, InternalOpenMedia openCb, InternalReadMedia readCb, InternalSeekMedia? seekCb, InternalCloseMedia closeCb, IntPtr opaque);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_add_option")]
			internal static extern void LibVLCMediaAddOption(IntPtr media, IntPtr option);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_add_option_flag")]
			internal static extern void LibVLCMediaAddOptionFlag(IntPtr media, IntPtr options, uint flags);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_get_mrl")]
			internal static extern IntPtr LibVLCMediaGetMrl(IntPtr media);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_duplicate")]
			internal static extern IntPtr LibVLCMediaDuplicate(IntPtr media);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_get_meta")]
			internal static extern IntPtr LibVLCMediaGetMeta(IntPtr media, MetadataType metadataType);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_set_meta")]
			internal static extern void LibVLCMediaSetMeta(IntPtr media, MetadataType metadataType, IntPtr value);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_save_meta")]
			internal static extern int LibVLCMediaSaveMeta(IntPtr media);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_get_state")]
			internal static extern VLCState LibVLCMediaGetState(IntPtr media);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_event_manager")]
			internal static extern IntPtr LibVLCMediaEventManager(IntPtr media);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_get_stats")]
			internal static extern int LibVLCMediaGetStats(IntPtr media, out MediaStats statistics);

			[DllImport("libvlc", CallingConvention = CallingConvention.Cdecl, EntryPoint = "libvlc_media_get_duration")]
			internal static extern long LibVLCMediaGetDuration(IntPtr