using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LethalVoiceRouter.Audio")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+258e5d578787605554f3f95238b41255d59850fc")]
[assembly: AssemblyProduct("LethalVoiceRouter.Audio")]
[assembly: AssemblyTitle("LethalVoiceRouter.Audio")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LethalVoiceRouter.Audio
{
	public sealed class AudioDevice
	{
		public string Id { get; }

		public string Name { get; }

		public AudioDevice(string id, string name)
		{
			Id = id;
			Name = name;
		}
	}
	public static class AudioDevices
	{
		public const string DefaultMultimedia = "default";

		public const string DefaultCommunications = "communications";

		public static AudioDevice[] Enumerate()
		{
			using (new ComApartment())
			{
				IntPtr instance = CreateEnumerator();
				IntPtr collection = IntPtr.Zero;
				try
				{
					CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.EnumEndpointsDelegate>(instance, 3)(instance, 0, 1u, out collection));
					CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.CountDelegate>(collection, 3)(collection, out var count));
					List<AudioDevice> list = new List<AudioDevice>();
					for (uint num = 0u; num < count; num++)
					{
						CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.ItemDelegate>(collection, 4)(collection, num, out var device));
						try
						{
							list.Add(Describe(device));
						}
						finally
						{
							CoreAudioNative.Release(ref device);
						}
					}
					return list.OrderBy<AudioDevice, string>((AudioDevice audioDevice) => audioDevice.Name, StringComparer.CurrentCultureIgnoreCase).ToArray();
				}
				finally
				{
					CoreAudioNative.Release(ref collection);
					CoreAudioNative.Release(ref instance);
				}
			}
		}

		public static AudioDevice Resolve(string selection)
		{
			using (new ComApartment())
			{
				IntPtr instance = Open(selection);
				try
				{
					return Describe(instance);
				}
				finally
				{
					CoreAudioNative.Release(ref instance);
				}
			}
		}

		internal static IntPtr Open(string selection)
		{
			IntPtr instance = CreateEnumerator();
			try
			{
				IntPtr device;
				if (selection == "default" || selection == "communications")
				{
					int role = ((!(selection == "communications")) ? 1 : 2);
					CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.DefaultEndpointDelegate>(instance, 4)(instance, 0, role, out device));
				}
				else
				{
					CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.GetDeviceDelegate>(instance, 5)(instance, selection, out device));
				}
				return device;
			}
			finally
			{
				CoreAudioNative.Release(ref instance);
			}
		}

		private static IntPtr CreateEnumerator()
		{
			CoreAudioNative.Check(CoreAudioNative.CoCreateInstance(in CoreAudioNative.DeviceEnumeratorClass, IntPtr.Zero, 1u, in CoreAudioNative.DeviceEnumeratorInterface, out var instance));
			return instance;
		}

		internal static AudioDevice Describe(IntPtr device)
		{
			CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.GetIdDelegate>(device, 5)(device, out var id));
			string text;
			try
			{
				text = Marshal.PtrToStringUni(id) ?? throw new InvalidOperationException("장치 ID가 없습니다.");
			}
			finally
			{
				Marshal.FreeCoTaskMem(id);
			}
			CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.OpenPropertiesDelegate>(device, 4)(device, 0u, out var store));
			try
			{
				CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.PropertyDelegate>(store, 5)(store, in CoreAudioNative.FriendlyName, out var value));
				try
				{
					string name = ((value.Type == 31) ? (Marshal.PtrToStringUni(value.Pointer) ?? text) : text);
					return new AudioDevice(text, name);
				}
				finally
				{
					CoreAudioNative.PropVariantClear(ref value);
				}
			}
			finally
			{
				CoreAudioNative.Release(ref store);
			}
		}
	}
	public static class ClearVoicePolicy
	{
		public const int MinimumBitrateKbps = 6;

		public const int MaximumBitrateKbps = 300;

		public const int MaximumPayloadBytes = 900;

		public const int MaximumPacketBytes = 1024;

		public const int VoiceHeaderBytes = 16;

		public const int ChannelHeaderBytes = 4;

		public const int RelayHeaderBytes = 10;

		public const int RecipientHeaderBytes = 2;

		public static bool FitsPacket(int payloadBytes, int channels, int recipients)
		{
			if (payloadBytes < 1 || payloadBytes > 900 || channels < 1 || channels > 65535 || recipients < 1 || recipients > 255)
			{
				return false;
			}
			return payloadBytes + 16 + 4L * (long)channels + 10 + 2L * (long)recipients <= 1024;
		}
	}
	internal static class CoreAudioNative
	{
		internal struct PropertyKey
		{
			public Guid FormatId;

			public uint PropertyId;
		}

		[StructLayout(LayoutKind.Explicit, Size = 24)]
		internal struct PropVariant
		{
			[FieldOffset(0)]
			public ushort Type;

			[FieldOffset(8)]
			public IntPtr Pointer;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 2)]
		internal struct WaveFormat
		{
			public ushort FormatTag;

			public ushort Channels;

			public uint SamplesPerSecond;

			public uint AverageBytesPerSecond;

			public ushort BlockAlign;

			public ushort BitsPerSample;

			public ushort ExtraSize;
		}

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate uint ReleaseDelegate(IntPtr self);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int EnumEndpointsDelegate(IntPtr self, int flow, uint stateMask, out IntPtr collection);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int DefaultEndpointDelegate(IntPtr self, int flow, int role, out IntPtr device);

		[UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
		internal delegate int GetDeviceDelegate(IntPtr self, [MarshalAs(UnmanagedType.LPWStr)] string id, out IntPtr device);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int CountDelegate(IntPtr self, out uint count);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int ItemDelegate(IntPtr self, uint index, out IntPtr device);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int GetIdDelegate(IntPtr self, out IntPtr id);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int OpenPropertiesDelegate(IntPtr self, uint access, out IntPtr store);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int PropertyDelegate(IntPtr self, in PropertyKey key, out PropVariant value);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int ActivateDelegate(IntPtr self, in Guid iid, uint context, IntPtr parameters, out IntPtr client);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int InitializeDelegate(IntPtr self, int shareMode, uint flags, long duration, long periodicity, in WaveFormat format, IntPtr sessionGuid);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int CommandDelegate(IntPtr self);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int ServiceDelegate(IntPtr self, in Guid iid, out IntPtr service);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int BufferDelegate(IntPtr self, uint frames, out IntPtr data);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		internal delegate int ReleaseBufferDelegate(IntPtr self, uint frames, uint flags);

		internal static readonly Guid DeviceEnumeratorClass = new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E");

		internal static readonly Guid DeviceEnumeratorInterface = new Guid("A95664D2-9614-4F35-A746-DE8DB63617E6");

		internal static readonly Guid AudioClientInterface = new Guid("1CB9AD4C-DBFA-4C32-B178-C2F568A703B2");

		internal static readonly Guid RenderClientInterface = new Guid("F294ACFC-3146-4483-A7BF-ADDCA7C260E2");

		internal static readonly PropertyKey FriendlyName = new PropertyKey
		{
			FormatId = new Guid("A45C254E-DF1C-4EFD-8020-67D146A850E0"),
			PropertyId = 14u
		};

		[DllImport("ole32.dll", ExactSpelling = true)]
		internal static extern int CoInitializeEx(IntPtr reserved, uint flags);

		[DllImport("ole32.dll", ExactSpelling = true)]
		internal static extern void CoUninitialize();

		[DllImport("ole32.dll", ExactSpelling = true)]
		internal static extern int CoCreateInstance(in Guid clsid, IntPtr outer, uint context, in Guid iid, out IntPtr instance);

		[DllImport("ole32.dll", ExactSpelling = true)]
		internal static extern int PropVariantClear(ref PropVariant value);

		internal static T Method<T>(IntPtr instance, int slot) where T : Delegate
		{
			return Marshal.GetDelegateForFunctionPointer<T>(Marshal.ReadIntPtr(Marshal.ReadIntPtr(instance), slot * IntPtr.Size));
		}

		internal static void Check(int result)
		{
			if (result < 0)
			{
				throw new COMException($"Windows 오디오 오류 (0x{result:X8})", result);
			}
		}

		internal static void Release(ref IntPtr instance)
		{
			if (!(instance == IntPtr.Zero))
			{
				Method<ReleaseDelegate>(instance, 2)(instance);
				instance = IntPtr.Zero;
			}
		}
	}
	internal sealed class ComApartment : IDisposable
	{
		private readonly bool initialized;

		public ComApartment()
		{
			if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || IntPtr.Size != 8)
			{
				throw new PlatformNotSupportedException("64비트 Windows가 필요합니다.");
			}
			int num = CoreAudioNative.CoInitializeEx(IntPtr.Zero, 0u);
			if (num != -2147417850)
			{
				CoreAudioNative.Check(num);
			}
			initialized = num >= 0;
		}

		public void Dispose()
		{
			if (initialized)
			{
				CoreAudioNative.CoUninitialize();
			}
		}
	}
	public sealed class DeviceChoices
	{
		public const string MultimediaLabel = "Windows 기본 출력 장치";

		public const string GameOriginalId = "game";

		public const string GameOriginalLabel = "기존 게임 출력";

		private readonly Dictionary<string, string> ids = new Dictionary<string, string>(StringComparer.Ordinal);

		private readonly Dictionary<string, string> names = new Dictionary<string, string>(StringComparer.Ordinal);

		public IReadOnlyList<string> Labels => ids.Keys.ToArray();

		private DeviceChoices()
		{
		}

		public static DeviceChoices Create(IReadOnlyList<AudioDevice> devices, string currentId, bool includeGameOutput = false)
		{
			DeviceChoices deviceChoices = new DeviceChoices();
			if (includeGameOutput)
			{
				deviceChoices.Add("game", "기존 게임 출력");
			}
			deviceChoices.Add("default", "Windows 기본 출력 장치");
			foreach (AudioDevice device in devices)
			{
				bool flag = devices.Count((AudioDevice other) => other.Name == device.Name) > 1 || deviceChoices.ids.ContainsKey(device.Name);
				deviceChoices.Add(device.Id, flag ? (device.Name + " [" + device.Id + "]") : device.Name);
			}
			if (!string.IsNullOrWhiteSpace(currentId) && currentId != "communications" && !deviceChoices.names.ContainsKey(currentId))
			{
				deviceChoices.Add(currentId, "연결되지 않은 장치 [" + currentId + "]");
			}
			return deviceChoices;
		}

		private void Add(string id, string name)
		{
			if (!names.ContainsKey(id))
			{
				names.Add(id, name);
				ids.Add(name, id);
			}
		}

		public bool TryGetDeviceId(string label, out string id)
		{
			return ids.TryGetValue(label, out id);
		}

		public string GetLabel(string id)
		{
			if (!names.TryGetValue(id, out string value))
			{
				return "Windows 기본 출력 장치";
			}
			return value;
		}
	}
	public sealed class FileProcessAudioBackup : IProcessAudioBackup
	{
		private readonly string path;

		public FileProcessAudioBackup(string path)
		{
			this.path = path;
		}

		public string?[]? Load()
		{
			if (!File.Exists(path))
			{
				return null;
			}
			string[] array = File.ReadAllLines(path, Encoding.UTF8);
			if (array.Length != 3 || array[0] != "LethalVoiceRouter.GameOutput.1")
			{
				throw new InvalidDataException("게임 출력 복구 파일이 올바르지 않습니다.");
			}
			return (from line in array.Skip(1)
				select (line.Length != 0) ? Encoding.UTF8.GetString(Convert.FromBase64String(line)) : null).ToArray();
		}

		public void Save(string?[] endpoints)
		{
			if (endpoints.Length != 2)
			{
				throw new ArgumentException("두 출력 역할의 설정이 필요합니다.", "endpoints");
			}
			string s = "LethalVoiceRouter.GameOutput.1\n" + string.Join("\n", endpoints.Select((string endpoint) => (endpoint != null) ? Convert.ToBase64String(Encoding.UTF8.GetBytes(endpoint)) : "")) + "\n";
			string sourceFileName = path + "." + Guid.NewGuid().ToString("N") + ".tmp";
			try
			{
				using (FileStream fileStream = new FileStream(sourceFileName, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					byte[] bytes = Encoding.UTF8.GetBytes(s);
					fileStream.Write(bytes, 0, bytes.Length);
					fileStream.Flush(flushToDisk: true);
				}
				File.Move(sourceFileName, path);
			}
			finally
			{
				if (File.Exists(sourceFileName))
				{
					File.Delete(sourceFileName);
				}
			}
		}

		public void Clear()
		{
			File.Delete(path);
		}
	}
	public sealed class GameOutputController : IDisposable
	{
		private readonly uint processId;

		private readonly string backupPath;

		private readonly AutoResetEvent wake = new AutoResetEvent(initialState: false);

		private readonly Thread thread;

		private string selection = "game";

		private OutputStatus status = new OutputStatus(ready: false, "게임 출력 준비 중");

		private string? restoreError;

		private int shutdown;

		public OutputStatus Status => Volatile.Read(in status);

		public string? RestoreError => Volatile.Read(in restoreError);

		public GameOutputController(uint processId, string backupPath)
		{
			this.processId = processId;
			this.backupPath = backupPath;
			thread = new Thread(Run)
			{
				IsBackground = true,
				Name = "Lethal Voice Router game output"
			};
			thread.Start();
		}

		public void Configure(string deviceId)
		{
			if (Volatile.Read(in shutdown) == 0)
			{
				Volatile.Write(ref selection, string.IsNullOrWhiteSpace(deviceId) ? "game" : deviceId.Trim());
				Volatile.Write(ref status, new OutputStatus(ready: false, "게임 출력 전환 중"));
				wake.Set();
			}
		}

		private void Run()
		{
			WindowsProcessAudioPolicy windowsProcessAudioPolicy = null;
			ProcessOutputRoute processOutputRoute = null;
			try
			{
				while (Volatile.Read(in shutdown) == 0)
				{
					try
					{
						string text = Volatile.Read(in selection);
						if (processOutputRoute == null && (text != "game" || File.Exists(backupPath)))
						{
							if (windowsProcessAudioPolicy == null)
							{
								windowsProcessAudioPolicy = new WindowsProcessAudioPolicy(processId);
							}
							processOutputRoute = new ProcessOutputRoute(windowsProcessAudioPolicy, new FileProcessAudioBackup(backupPath));
							processOutputRoute.Restore();
						}
						if (text == "game")
						{
							processOutputRoute?.Restore();
							Volatile.Write(ref status, new OutputStatus(ready: true, "게임 · 기존 게임 출력 사용", "game"));
							goto IL_0125;
						}
						AudioDevice audioDevice = ((text == "default") ? null : AudioDevices.Resolve(text));
						if (Volatile.Read(in shutdown) != 0 || text != Volatile.Read(in selection))
						{
							continue;
						}
						processOutputRoute.Apply(audioDevice?.Id);
						Volatile.Write(ref status, new OutputStatus(ready: true, "게임 출력 설정 · " + (audioDevice?.Name ?? "Windows 기본 출력 장치"), audioDevice?.Id ?? "default"));
						goto IL_0125;
						IL_0125:
						Volatile.Write(ref restoreError, null);
						goto IL_0193;
					}
					catch (Exception ex)
					{
						string text2 = (Restore(processOutputRoute) ? "이전 게임 출력으로 복구" : "이전 출력 복구 대기");
						Volatile.Write(ref status, new OutputStatus(ready: false, "게임 · " + text2 + " · " + ex.Message + " · 자동 재시도 중", null, failed: true));
						goto IL_0193;
					}
					IL_0193:
					wake.WaitOne(1000);
				}
			}
			finally
			{
				Restore(processOutputRoute);
				windowsProcessAudioPolicy?.Dispose();
			}
		}

		private bool Restore(ProcessOutputRoute? route)
		{
			try
			{
				if (route == null && File.Exists(backupPath))
				{
					throw new InvalidOperationException("게임 출력 복구 파일을 아직 읽지 못했습니다.");
				}
				route?.Restore();
				Volatile.Write(ref restoreError, null);
				return true;
			}
			catch (Exception ex)
			{
				Volatile.Write(ref restoreError, ex.Message);
				return false;
			}
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref shutdown, 1) == 0)
			{
				wake.Set();
				if (thread.Join(3000))
				{
					wake.Dispose();
				}
				else
				{
					Volatile.Write(ref restoreError, "게임 출력 복구 스레드가 아직 종료되지 않았습니다.");
				}
			}
		}
	}
	public sealed class OutputStatus
	{
		public bool Ready { get; }

		public string Message { get; }

		public string? DeviceId { get; }

		public bool Failed { get; }

		public OutputStatus(bool ready, string message, string? deviceId = null, bool failed = false)
		{
			Ready = ready;
			Message = message;
			DeviceId = deviceId;
			Failed = failed;
		}
	}
	public sealed class OutputController : IDisposable
	{
		private sealed class EndpointObservation
		{
			public readonly string Selection;

			public readonly string Id;

			public readonly long Timestamp;

			public EndpointObservation(string selection, string id)
			{
				Selection = selection;
				Id = id;
				Timestamp = Stopwatch.GetTimestamp();
			}
		}

		private sealed class Configuration
		{
			public readonly string Selection;

			public readonly int SampleRate;

			public readonly int Latency;

			public readonly int MaximumQueue;

			public Configuration(string selection, int sampleRate, int latency, int maximumQueue)
			{
				Selection = selection;
				SampleRate = sampleRate;
				Latency = latency;
				MaximumQueue = maximumQueue;
			}
		}

		private readonly VoiceRouter router;

		private readonly AutoResetEvent wake = new AutoResetEvent(initialState: false);

		private readonly AutoResetEvent discoveryWake = new AutoResetEvent(initialState: false);

		private readonly Thread thread;

		private readonly Thread discoveryThread;

		private Configuration configuration = new Configuration("default", 48000, 40, 100);

		private OutputStatus status = new OutputStatus(ready: false, "음성 출력 준비 중");

		private AudioDevice[] devices = Array.Empty<AudioDevice>();

		private AudioDevice? defaultOutputDevice;

		private int shutdown;

		private EndpointObservation? observedEndpoint;

		private string? discoveryError;

		private long droppedFrames;

		public OutputStatus Status => Volatile.Read(in status);

		public AudioDevice[] Devices => Volatile.Read(in devices);

		public AudioDevice? DefaultOutputDevice => Volatile.Read(in defaultOutputDevice);

		public string? DiscoveryError => Volatile.Read(in discoveryError);

		public long DroppedFrames => Interlocked.Read(in droppedFrames);

		public OutputController(VoiceRouter router)
		{
			this.router = router;
			thread = new Thread(Run)
			{
				IsBackground = true,
				Name = "Lethal Voice Router WASAPI"
			};
			discoveryThread = new Thread(DiscoverDevices)
			{
				IsBackground = true,
				Name = "Lethal Voice Router devices"
			};
			discoveryThread.Start();
			thread.Start();
		}

		public void Configure(string selection, int sampleRate, int latencyMilliseconds, int maximumQueueMilliseconds)
		{
			if (string.IsNullOrWhiteSpace(selection))
			{
				throw new ArgumentException("출력 장치를 지정해야 합니다.", "selection");
			}
			if (sampleRate < 8000 || sampleRate > 192000)
			{
				throw new ArgumentOutOfRangeException("sampleRate");
			}
			if (latencyMilliseconds < 20 || latencyMilliseconds > 200)
			{
				throw new ArgumentOutOfRangeException("latencyMilliseconds");
			}
			if (maximumQueueMilliseconds < 20 || maximumQueueMilliseconds > 500)
			{
				throw new ArgumentOutOfRangeException("maximumQueueMilliseconds");
			}
			if (Volatile.Read(in shutdown) == 0)
			{
				Configuration value = new Configuration(selection, sampleRate, latencyMilliseconds, maximumQueueMilliseconds);
				router.RetireCurrentSession();
				Volatile.Write(ref configuration, value);
				Volatile.Write(ref status, new OutputStatus(ready: false, "음성 출력 연결 중"));
				wake.Set();
				discoveryWake.Set();
			}
		}

		public void RefreshDevices()
		{
			if (Volatile.Read(in shutdown) == 0)
			{
				discoveryWake.Set();
			}
		}

		private bool ShouldRun(Configuration expected)
		{
			if (Volatile.Read(in shutdown) == 0 && router.Enabled)
			{
				return expected == Volatile.Read(in configuration);
			}
			return false;
		}

		private void Run()
		{
			while (Volatile.Read(in shutdown) == 0)
			{
				Configuration requested = Volatile.Read(in configuration);
				try
				{
					if (!router.Enabled)
					{
						Volatile.Write(ref status, new OutputStatus(ready: false, "분리 꺼짐 · 기존 게임 출력 사용"));
						wake.WaitOne(100);
					}
					else
					{
						Render(requested);
					}
				}
				catch (Exception ex)
				{
					string text = (router.FallbackToGameOutput ? "게임 출력으로 복구" : "음성 음소거");
					Volatile.Write(ref status, new OutputStatus(ready: false, text + " · " + ex.Message + " · 자동 재연결 중", null, failed: true));
					wake.WaitOne(1000);
				}
			}
			Volatile.Write(ref status, new OutputStatus(ready: false, "음성 출력 종료"));
		}

		private void Render(Configuration requested)
		{
			using WasapiOutput wasapiOutput = new WasapiOutput(requested.Selection, requested.SampleRate, requested.Latency);
			float[] destination = new float[checked(wasapiOutput.BufferFrames * 2)];
			wasapiOutput.Start();
			if (!ShouldRun(requested))
			{
				return;
			}
			RoutingSession routingSession = router.BeginSession(requested.SampleRate, requested.MaximumQueue);
			Action<float[], int> write = wasapiOutput.Write;
			long timestamp = Stopwatch.GetTimestamp();
			try
			{
				Volatile.Write(ref status, new OutputStatus(ready: true, "분리 출력 중 · " + wasapiOutput.Device.Name, wasapiOutput.Device.Id));
				long num = Stopwatch.GetTimestamp();
				while (ShouldRun(requested) && routingSession.IsActive)
				{
					int availableFrames = wasapiOutput.AvailableFrames;
					if (availableFrames > 0)
					{
						routingSession.Render(destination, availableFrames, write);
					}
					Interlocked.Exchange(ref droppedFrames, routingSession.DroppedFrames);
					long timestamp2 = Stopwatch.GetTimestamp();
					if (timestamp2 >= num && (requested.Selection == "default" || requested.Selection == "communications"))
					{
						num = timestamp2 + Stopwatch.Frequency;
						EndpointObservation endpointObservation = Volatile.Read(in observedEndpoint);
						if (endpointObservation != null && endpointObservation.Timestamp > timestamp && endpointObservation.Selection == requested.Selection && endpointObservation.Id != wasapiOutput.Device.Id)
						{
							break;
						}
					}
					wake.WaitOne(3);
				}
			}
			finally
			{
				router.EndSession(routingSession);
				Volatile.Write(ref status, new OutputStatus(ready: false, "음성 출력 다시 연결 중"));
			}
		}

		private void DiscoverDevices()
		{
			while (Volatile.Read(in shutdown) == 0)
			{
				try
				{
					Volatile.Write(ref devices, AudioDevices.Enumerate());
					AudioDevice audioDevice = AudioDevices.Resolve("default");
					Volatile.Write(ref defaultOutputDevice, audioDevice);
					Configuration configuration = Volatile.Read(in this.configuration);
					if (configuration.Selection == "default" || configuration.Selection == "communications")
					{
						AudioDevice audioDevice2 = ((configuration.Selection == "default") ? audioDevice : AudioDevices.Resolve(configuration.Selection));
						Volatile.Write(ref observedEndpoint, new EndpointObservation(configuration.Selection, audioDevice2.Id));
					}
					Volatile.Write(ref discoveryError, null);
				}
				catch (Exception ex)
				{
					Volatile.Write(ref defaultOutputDevice, null);
					Volatile.Write(ref discoveryError, ex.Message);
				}
				discoveryWake.WaitOne(1000);
			}
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref shutdown, 1) == 0)
			{
				router.RetireCurrentSession();
				wake.Set();
				discoveryWake.Set();
				if (thread.Join(3000))
				{
					wake.Dispose();
				}
				if (discoveryThread.Join(3000))
				{
					discoveryWake.Dispose();
				}
			}
		}
	}
	public interface IProcessAudioPolicy
	{
		string? GetEndpoint(int role);

		void SetEndpoint(int role, string? endpointId);
	}
	public interface IProcessAudioBackup
	{
		string?[]? Load();

		void Save(string?[] endpoints);

		void Clear();
	}
	public sealed class ProcessOutputRoute
	{
		private readonly IProcessAudioPolicy policy;

		private readonly IProcessAudioBackup backup;

		private string?[]? original;

		public ProcessOutputRoute(IProcessAudioPolicy policy, IProcessAudioBackup backup)
		{
			this.policy = policy;
			this.backup = backup;
			original = backup.Load();
			if (original != null && original.Length != 2)
			{
				throw new InvalidDataException("게임 출력 복구 파일이 올바르지 않습니다.");
			}
		}

		public void Apply(string? endpointId)
		{
			string[] array = ReadEndpoints();
			if (!array.All((string endpoint) => endpoint == endpointId))
			{
				if (original == null)
				{
					backup.Save(array);
					original = array;
				}
				ChangeEndpoints(new string[2] { endpointId, endpointId }, array);
			}
		}

		public void Restore()
		{
			if (original != null)
			{
				ChangeEndpoints(original, ReadEndpoints());
				backup.Clear();
				original = null;
			}
		}

		private string?[] ReadEndpoints()
		{
			return new string[2]
			{
				policy.GetEndpoint(0),
				policy.GetEndpoint(1)
			};
		}

		private void ChangeEndpoints(string?[] desired, string?[] current)
		{
			try
			{
				for (int i = 0; i < 2; i++)
				{
					if (current[i] != desired[i])
					{
						policy.SetEndpoint(i, desired[i]);
					}
				}
			}
			catch (Exception item)
			{
				List<Exception> list = new List<Exception> { item };
				for (int j = 0; j < 2; j++)
				{
					try
					{
						policy.SetEndpoint(j, current[j]);
					}
					catch (Exception item2)
					{
						list.Add(item2);
					}
				}
				if (list.Count > 1)
				{
					throw new AggregateException("게임 출력 변경과 이전 설정 복구에 실패했습니다.", list);
				}
				throw;
			}
		}
	}
	public sealed class StereoFrameQueue
	{
		private readonly float[] samples;

		private readonly int capacity;

		private long readFrame;

		private long writeFrame;

		private long droppedFrames;

		public long DroppedFrames => Interlocked.Read(in droppedFrames);

		public StereoFrameQueue(int capacityFrames)
		{
			if (capacityFrames < 1)
			{
				throw new ArgumentOutOfRangeException("capacityFrames");
			}
			capacity = capacityFrames;
			samples = new float[checked(capacityFrames * 2)];
		}

		public bool TryWrite(float[] source, int channels, float gain)
		{
			if (channels < 1 || source.Length % channels != 0)
			{
				return false;
			}
			int num = source.Length / channels;
			long num2 = writeFrame;
			if (num > capacity - (num2 - Volatile.Read(in readFrame)))
			{
				Interlocked.Add(ref droppedFrames, num);
				return false;
			}
			if (float.IsNaN(gain) || float.IsInfinity(gain))
			{
				gain = 0f;
			}
			for (int i = 0; i < num; i++)
			{
				int num3 = i * channels;
				int num4 = (int)((num2 + i) % capacity) * 2;
				float num5 = source[num3];
				float num6 = ((channels == 1) ? num5 : source[num3 + 1]);
				if (channels == 4)
				{
					num5 += source[num3 + 2] * 0.70710677f;
					num6 += source[num3 + 3] * 0.70710677f;
				}
				else if (channels > 2)
				{
					float num7 = source[num3 + 2] * 0.70710677f;
					num5 += num7;
					num6 += num7;
					if (channels == 5)
					{
						num5 += source[num3 + 3] * 0.70710677f;
						num6 += source[num3 + 4] * 0.70710677f;
					}
					else if (channels > 5)
					{
						num5 += source[num3 + 4] * 0.70710677f;
						num6 += source[num3 + 5] * 0.70710677f;
					}
					if (channels > 6)
					{
						num5 += source[num3 + 6] * 0.70710677f;
					}
					if (channels > 7)
					{
						num6 += source[num3 + 7] * 0.70710677f;
					}
				}
				samples[num4] = Finite(num5 * gain);
				samples[num4 + 1] = Finite(num6 * gain);
			}
			Volatile.Write(ref writeFrame, num2 + num);
			return true;
		}

		public int MixInto(float[] destination, int frames, int maximumQueuedFrames)
		{
			if (frames < 0 || frames > destination.Length / 2)
			{
				throw new ArgumentOutOfRangeException("frames");
			}
			if (maximumQueuedFrames < 1)
			{
				throw new ArgumentOutOfRangeException("maximumQueuedFrames");
			}
			long num = readFrame;
			long num2 = Volatile.Read(in writeFrame) - num;
			if (num2 > maximumQueuedFrames)
			{
				long num3 = num2 - maximumQueuedFrames;
				num += num3;
				num2 -= num3;
				Interlocked.Add(ref droppedFrames, num3);
			}
			int num4 = (int)Math.Min(frames, num2);
			for (int i = 0; i < num4; i++)
			{
				int num5 = (int)((num + i) % capacity) * 2;
				destination[i * 2] += samples[num5];
				destination[i * 2 + 1] += samples[num5 + 1];
			}
			Volatile.Write(ref readFrame, num + num4);
			return num4;
		}

		private static float Finite(float sample)
		{
			if (!float.IsNaN(sample) && !float.IsInfinity(sample))
			{
				return sample;
			}
			return 0f;
		}
	}
	public sealed class VoiceRouter
	{
		private readonly object gate = new object();

		private readonly List<VoiceStream> streams = new List<VoiceStream>();

		private RoutingSession? currentSession;

		private int enabled = 1;

		private int fallbackToGameOutput = 1;

		private float volume = 1f;

		public bool Enabled
		{
			get
			{
				return Volatile.Read(in enabled) != 0;
			}
			set
			{
				Volatile.Write(ref enabled, value ? 1 : 0);
				if (!value)
				{
					RetireCurrentSession();
				}
			}
		}

		public bool FallbackToGameOutput
		{
			get
			{
				return Volatile.Read(in fallbackToGameOutput) != 0;
			}
			set
			{
				Volatile.Write(ref fallbackToGameOutput, value ? 1 : 0);
			}
		}

		public float Volume
		{
			get
			{
				return Volatile.Read(in volume);
			}
			set
			{
				Volatile.Write(ref volume, (float.IsNaN(value) || float.IsInfinity(value)) ? 0f : Math.Max(0f, Math.Min(2f, value)));
			}
		}

		public int SourceCount
		{
			get
			{
				lock (gate)
				{
					return streams.Count;
				}
			}
		}

		public VoiceStream RegisterSource()
		{
			lock (gate)
			{
				VoiceStream voiceStream = new VoiceStream(this);
				streams.Add(voiceStream);
				if (currentSession != null && !voiceStream.Muted)
				{
					voiceStream.Target = currentSession.AddSource();
				}
				return voiceStream;
			}
		}

		internal void UnregisterSource(VoiceStream stream)
		{
			lock (gate)
			{
				stream.Target?.Retire();
				stream.Target = null;
				streams.Remove(stream);
				currentSession?.RemoveRetiredSources();
			}
		}

		internal void RefreshSource(VoiceStream stream)
		{
			lock (gate)
			{
				if (streams.Contains(stream))
				{
					stream.Target?.Retire();
					currentSession?.RemoveRetiredSources();
					stream.Target = ((currentSession != null && !stream.Muted) ? currentSession.AddSource() : null);
				}
			}
		}

		public RoutingSession BeginSession(int sampleRate, int maximumQueuedMilliseconds = 100)
		{
			if (sampleRate < 8000 || sampleRate > 192000)
			{
				throw new ArgumentOutOfRangeException("sampleRate");
			}
			if (maximumQueuedMilliseconds < 20 || maximumQueuedMilliseconds > 500)
			{
				throw new ArgumentOutOfRangeException("maximumQueuedMilliseconds");
			}
			lock (gate)
			{
				RetireCurrentSession();
				RoutingSession routingSession = new RoutingSession(sampleRate, maximumQueuedMilliseconds);
				foreach (VoiceStream stream in streams)
				{
					stream.Target = (stream.Muted ? null : routingSession.AddSource());
				}
				currentSession = routingSession;
				return routingSession;
			}
		}

		public void RetireCurrentSession()
		{
			lock (gate)
			{
				currentSession?.Retire();
				currentSession = null;
				foreach (VoiceStream stream in streams)
				{
					stream.Target = null;
				}
			}
		}

		public void EndSession(RoutingSession session)
		{
			lock (gate)
			{
				session.Retire();
				if (currentSession == session)
				{
					RetireCurrentSession();
				}
			}
		}
	}
	public sealed class VoiceStream : IDisposable
	{
		private readonly VoiceRouter router;

		private CaptureTarget? target;

		private int disposed;

		private int muted;

		private float gain = 1f;

		internal CaptureTarget? Target
		{
			get
			{
				return Volatile.Read(in target);
			}
			set
			{
				Volatile.Write(ref target, value);
			}
		}

		public float Gain
		{
			get
			{
				return Volatile.Read(in gain);
			}
			set
			{
				Volatile.Write(ref gain, value);
			}
		}

		public bool Muted
		{
			get
			{
				return Volatile.Read(in muted) != 0;
			}
			set
			{
				if (Interlocked.Exchange(ref muted, value ? 1 : 0) == (value ? 1 : 0))
				{
					if (value)
					{
						return;
					}
					CaptureTarget? captureTarget = Target;
					if (captureTarget == null || !captureTarget.IsRetired)
					{
						return;
					}
				}
				router.RefreshSource(this);
			}
		}

		internal VoiceStream(VoiceRouter router)
		{
			this.router = router;
		}

		public void DiscardBufferedAudio()
		{
			Target?.Retire();
		}

		public void Process(float[] data, int channels)
		{
			if (router.Enabled && Volatile.Read(in disposed) == 0)
			{
				CaptureTarget captureTarget = Target;
				if ((!Muted && captureTarget != null && captureTarget.IsActive && captureTarget.Queue.TryWrite(data, channels, Gain * router.Volume)) || !router.FallbackToGameOutput)
				{
					Array.Clear(data, 0, data.Length);
				}
			}
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref disposed, 1) == 0)
			{
				router.UnregisterSource(this);
			}
		}
	}
	internal sealed class CaptureTarget
	{
		private readonly RoutingSession session;

		private int active = 1;

		public StereoFrameQueue Queue { get; }

		public bool IsActive
		{
			get
			{
				if (Volatile.Read(in active) != 0)
				{
					return session.IsActive;
				}
				return false;
			}
		}

		public bool IsRetired => Volatile.Read(in active) == 0;

		public CaptureTarget(RoutingSession session, int capacityFrames)
		{
			this.session = session;
			Queue = new StereoFrameQueue(capacityFrames);
		}

		public void Retire()
		{
			lock (session.RenderGate)
			{
				Volatile.Write(ref active, 0);
			}
		}
	}
	public sealed class RoutingSession
	{
		internal readonly object RenderGate = new object();

		private CaptureTarget[] sources = Array.Empty<CaptureTarget>();

		private int active = 1;

		private readonly int maximumQueuedFrames;

		public int SampleRate { get; }

		public bool IsActive => Volatile.Read(in active) != 0;

		public long DroppedFrames => Volatile.Read(in sources).Sum((CaptureTarget source) => source.Queue.DroppedFrames);

		internal RoutingSession(int sampleRate, int maximumQueuedMilliseconds)
		{
			SampleRate = sampleRate;
			maximumQueuedFrames = sampleRate * maximumQueuedMilliseconds / 1000;
		}

		internal CaptureTarget AddSource()
		{
			CaptureTarget captureTarget = new CaptureTarget(this, Math.Max(SampleRate / 2, 4096));
			CaptureTarget[] array = Volatile.Read(in sources);
			CaptureTarget[] array2 = new CaptureTarget[array.Length + 1];
			Array.Copy(array, array2, array.Length);
			array2[array.Length] = captureTarget;
			Volatile.Write(ref sources, array2);
			return captureTarget;
		}

		internal void RemoveRetiredSources()
		{
			Volatile.Write(ref sources, (from source in Volatile.Read(in sources)
				where !source.IsRetired
				select source).ToArray());
		}

		public void Mix(float[] destination, int frames)
		{
			lock (RenderGate)
			{
				MixFrames(destination, frames);
			}
		}

		internal void Render(float[] destination, int frames, Action<float[], int> write)
		{
			lock (RenderGate)
			{
				MixFrames(destination, frames);
				if (IsActive)
				{
					write(destination, frames);
				}
			}
		}

		private void MixFrames(float[] destination, int frames)
		{
			if (frames < 0 || frames > destination.Length / 2)
			{
				throw new ArgumentOutOfRangeException("frames");
			}
			int num = frames * 2;
			Array.Clear(destination, 0, num);
			if (!IsActive)
			{
				return;
			}
			CaptureTarget[] array = Volatile.Read(in sources);
			foreach (CaptureTarget captureTarget in array)
			{
				if (captureTarget.IsActive)
				{
					captureTarget.Queue.MixInto(destination, frames, maximumQueuedFrames);
				}
			}
			for (int j = 0; j < num; j++)
			{
				destination[j] = Math.Max(-1f, Math.Min(1f, destination[j]));
			}
		}

		public void Retire()
		{
			lock (RenderGate)
			{
				Volatile.Write(ref active, 0);
			}
		}
	}
	public sealed class WasapiOutput : IDisposable
	{
		private readonly ComApartment apartment;

		private IntPtr device;

		private IntPtr client;

		private IntPtr renderer;

		private readonly CoreAudioNative.CountDelegate padding;

		private readonly CoreAudioNative.BufferDelegate getBuffer;

		private readonly CoreAudioNative.ReleaseBufferDelegate releaseBuffer;

		private readonly CoreAudioNative.CommandDelegate stop;

		private bool started;

		private bool disposed;

		public AudioDevice Device { get; }

		public int BufferFrames { get; }

		public int AvailableFrames
		{
			get
			{
				ThrowIfDisposed();
				CoreAudioNative.Check(padding(client, out var count));
				return BufferFrames - checked((int)count);
			}
		}

		public WasapiOutput(string selection, int sampleRate, int latencyMilliseconds)
		{
			if (sampleRate < 8000 || sampleRate > 192000)
			{
				throw new ArgumentOutOfRangeException("sampleRate");
			}
			if (latencyMilliseconds < 20 || latencyMilliseconds > 200)
			{
				throw new ArgumentOutOfRangeException("latencyMilliseconds");
			}
			apartment = new ComApartment();
			try
			{
				device = AudioDevices.Open(selection);
				Device = AudioDevices.Describe(device);
				CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.ActivateDelegate>(device, 3)(device, in CoreAudioNative.AudioClientInterface, 23u, IntPtr.Zero, out client));
				CoreAudioNative.WaveFormat format = new CoreAudioNative.WaveFormat
				{
					FormatTag = 3,
					Channels = 2,
					SamplesPerSecond = (uint)sampleRate,
					AverageBytesPerSecond = (uint)(sampleRate * 8),
					BlockAlign = 8,
					BitsPerSample = 32
				};
				CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.InitializeDelegate>(client, 3)(client, 0, 2281701376u, (long)latencyMilliseconds * 10000L, 0L, in format, IntPtr.Zero));
				CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.CountDelegate>(client, 4)(client, out var count));
				BufferFrames = checked((int)count);
				CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.ServiceDelegate>(client, 14)(client, in CoreAudioNative.RenderClientInterface, out renderer));
				padding = CoreAudioNative.Method<CoreAudioNative.CountDelegate>(client, 6);
				getBuffer = CoreAudioNative.Method<CoreAudioNative.BufferDelegate>(renderer, 3);
				releaseBuffer = CoreAudioNative.Method<CoreAudioNative.ReleaseBufferDelegate>(renderer, 4);
				stop = CoreAudioNative.Method<CoreAudioNative.CommandDelegate>(client, 11);
			}
			catch
			{
				CoreAudioNative.Release(ref renderer);
				CoreAudioNative.Release(ref client);
				CoreAudioNative.Release(ref device);
				apartment.Dispose();
				throw;
			}
		}

		public void Start()
		{
			ThrowIfDisposed();
			if (!started)
			{
				CoreAudioNative.Check(CoreAudioNative.Method<CoreAudioNative.CommandDelegate>(client, 10)(client));
				started = true;
			}
		}

		public void Write(float[] samples, int frames)
		{
			ThrowIfDisposed();
			if (frames < 0 || frames > samples.Length / 2 || frames > BufferFrames)
			{
				throw new ArgumentOutOfRangeException("frames");
			}
			if (frames != 0)
			{
				CoreAudioNative.Check(getBuffer(renderer, (uint)frames, out var data));
				try
				{
					Marshal.Copy(samples, 0, data, frames * 2);
				}
				catch
				{
					releaseBuffer(renderer, (uint)frames, 2u);
					throw;
				}
				CoreAudioNative.Check(releaseBuffer(renderer, (uint)frames, 0u));
			}
		}

		private void ThrowIfDisposed()
		{
			if (disposed)
			{
				throw new ObjectDisposedException("WasapiOutput");
			}
		}

		public void Dispose()
		{
			if (!disposed)
			{
				disposed = true;
				if (started)
				{
					stop(client);
				}
				CoreAudioNative.Release(ref renderer);
				CoreAudioNative.Release(ref client);
				CoreAudioNative.Release(ref device);
				apartment.Dispose();
			}
		}
	}
	public sealed class WindowsProcessAudioPolicy : IProcessAudioPolicy, IDisposable
	{
		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int GetEndpointDelegate(IntPtr self, uint processId, int flow, int role, out IntPtr endpoint);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int SetEndpointDelegate(IntPtr self, uint processId, int flow, int role, IntPtr endpoint);

		private sealed class WindowsString : IDisposable
		{
			public IntPtr Handle { get; }

			public WindowsString(string? value)
			{
				if (value != null)
				{
					CoreAudioNative.Check(WindowsCreateString(value, checked((uint)value.Length), out var result));
					Handle = result;
				}
			}

			public void Dispose()
			{
				if (Handle != IntPtr.Zero)
				{
					WindowsDeleteString(Handle);
				}
			}
		}

		private const string DevicePrefix = "\\\\?\\SWD#MMDEVAPI#";

		private const string RenderSuffix = "#{e6327cad-dcec-4949-ae8a-991e976a79d2}";

		private readonly ComApartment apartment;

		private readonly uint processId;

		private IntPtr factory;

		private bool disposed;

		public WindowsProcessAudioPolicy(uint processId)
		{
			this.processId = processId;
			apartment = new ComApartment();
			try
			{
				using WindowsString windowsString = new WindowsString("Windows.Media.Internal.AudioPolicyConfig");
				int num = RoGetActivationFactory(windowsString.Handle, new Guid("ab3d4648-e242-459f-b02f-541c70306324"), out factory);
				if (num == -2147467262)
				{
					CoreAudioNative.Release(ref factory);
					num = RoGetActivationFactory(windowsString.Handle, new Guid("2a59116d-6c4f-45e0-a74f-707e3fef9258"), out factory);
				}
				CoreAudioNative.Check(num);
			}
			catch
			{
				Dispose();
				throw;
			}
		}

		public string? GetEndpoint(int role)
		{
			ValidateRole(role);
			IntPtr endpoint = IntPtr.Zero;
			try
			{
				int num = CoreAudioNative.Method<GetEndpointDelegate>(factory, 26)(factory, processId, 0, role, out endpoint);
				switch (num)
				{
				case -2147023728:
					return null;
				case -2147024809:
					throw new InvalidOperationException("앱 오디오 세션이 아직 준비되지 않았습니다.");
				default:
				{
					CoreAudioNative.Check(num);
					uint length;
					IntPtr ptr = WindowsGetStringRawBuffer(endpoint, out length);
					string text = ((length == 0) ? null : Marshal.PtrToStringUni(ptr, checked((int)length)));
					if (text != null && text.StartsWith("\\\\?\\SWD#MMDEVAPI#", StringComparison.OrdinalIgnoreCase))
					{
						text = text.Substring("\\\\?\\SWD#MMDEVAPI#".Length);
					}
					if (text != null && text.EndsWith("#{e6327cad-dcec-4949-ae8a-991e976a79d2}", StringComparison.OrdinalIgnoreCase))
					{
						text = text.Substring(0, text.Length - "#{e6327cad-dcec-4949-ae8a-991e976a79d2}".Length);
					}
					return string.IsNullOrWhiteSpace(text) ? null : text;
				}
				}
			}
			finally
			{
				if (endpoint != IntPtr.Zero)
				{
					WindowsDeleteString(endpoint);
				}
			}
		}

		public void SetEndpoint(int role, string? endpointId)
		{
			ValidateRole(role);
			using WindowsString windowsString = new WindowsString(string.IsNullOrWhiteSpace(endpointId) ? null : ("\\\\?\\SWD#MMDEVAPI#" + endpointId + "#{e6327cad-dcec-4949-ae8a-991e976a79d2}"));
			CoreAudioNative.Check(CoreAudioNative.Method<SetEndpointDelegate>(factory, 25)(factory, processId, 0, role, windowsString.Handle));
		}

		private void ValidateRole(int role)
		{
			if (factory == IntPtr.Zero)
			{
				throw new ObjectDisposedException("WindowsProcessAudioPolicy");
			}
			if (role < 0 || role > 1)
			{
				throw new ArgumentOutOfRangeException("role");
			}
		}

		public void Dispose()
		{
			if (!disposed)
			{
				disposed = true;
				CoreAudioNative.Release(ref factory);
				apartment.Dispose();
			}
		}

		[DllImport("combase.dll", ExactSpelling = true)]
		private static extern int RoGetActivationFactory(IntPtr name, in Guid iid, out IntPtr instance);

		[DllImport("combase.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
		private static extern int WindowsCreateString([MarshalAs(UnmanagedType.LPWStr)] string value, uint length, out IntPtr result);

		[DllImport("combase.dll", ExactSpelling = true)]
		private static extern int WindowsDeleteString(IntPtr value);

		[DllImport("combase.dll", ExactSpelling = true)]
		private static extern IntPtr WindowsGetStringRawBuffer(IntPtr value, out uint length);
	}
}