using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("OpusDotNet")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("OpusDotNet")]
[assembly: AssemblyTitle("OpusDotNet")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace OpusDotNet;

internal static class API
{
	[DllImport("opus", CallingConvention = CallingConvention.Cdecl)]
	public static extern SafeEncoderHandle opus_encoder_create(int Fs, int channels, int application, out int error);

	[DllImport("opus", CallingConvention = CallingConvention.Cdecl)]
	[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
	public static extern void opus_encoder_destroy(IntPtr st);

	[DllImport("opus", CallingConvention = CallingConvention.Cdecl)]
	public static extern int opus_encode(SafeEncoderHandle st, IntPtr pcm, int frame_size, IntPtr data, int max_data_bytes);

	[DllImport("opus", CallingConvention = CallingConvention.Cdecl)]
	public static extern int opus_encoder_ctl(SafeEncoderHandle st, int request, out int value);

	[DllImport("opus", CallingConvention = CallingConvention.Cdecl)]
	public static extern int opus_encoder_ctl(SafeEncoderHandle st, int request, int value);

	[DllImport("opus", CallingConvention = CallingConvention.Cdecl)]
	public static extern SafeDecoderHandle opus_decoder_create(int Fs, int channels, out int error);

	[DllImport("opus", CallingConvention = CallingConvention.Cdecl)]
	[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
	public static extern void opus_decoder_destroy(IntPtr st);

	[DllImport("opus", CallingConvention = CallingConvention.Cdecl)]
	public static extern int opus_decode(SafeDecoderHandle st, IntPtr data, int len, IntPtr pcm, int frame_size, int decode_fec);

	public static int GetSampleCount(double frameSize, int sampleRate)
	{
		return (int)(frameSize * (double)sampleRate / 1000.0);
	}

	public static int GetPCMLength(int samples, int channels)
	{
		return samples * channels * 2;
	}

	public static double GetFrameSize(int pcmLength, int sampleRate, int channels)
	{
		return (double)pcmLength / (double)sampleRate / (double)channels / 2.0 * 1000.0;
	}

	public static void ThrowIfError(int result)
	{
		if (result < 0)
		{
			throw new OpusException(result);
		}
	}
}
public enum Application
{
	VoIP = 2048,
	Audio = 2049,
	RestrictedLowDelay = 2051
}
public enum Bandwidth
{
	NarrowBand = 1101,
	MediumBand,
	WideBand,
	SuperWideBand,
	FullBand
}
internal enum Control
{
	SetBitrate = 4002,
	SetMaxBandwidth = 4004,
	GetMaxBandwidth = 4005,
	SetVBR = 4006,
	GetVBR = 4007,
	SetComplexity = 4010,
	GetComplexity = 4011,
	SetInbandFEC = 4012,
	GetInbandFEC = 4013,
	SetPacketLossPerc = 4014,
	GetPacketLossPerc = 4015,
	SetDTX = 4016,
	GetDTX = 4017,
	SetForceChannels = 4022,
	GetForceChannels = 4023
}
public enum ForceChannels
{
	None = -1000,
	Mono = 1,
	Stereo = 2
}
public class OpusDecoder : IDisposable
{
	private readonly SafeDecoderHandle _handle;

	private readonly int _samples;

	private readonly int _pcmLength;

	private bool _fec;

	[Obsolete("This property was used for the old decode method and is deprecated, please use the new decode method instead.")]
	public double? FrameSize { get; }

	public int SampleRate { get; }

	public int Channels { get; }

	[Obsolete("This property was used for the old decode method and is deprecated, please use the new decode method instead.")]
	public bool FEC
	{
		get
		{
			return _fec;
		}
		set
		{
			if (!FrameSize.HasValue)
			{
				throw new InvalidOperationException("A frame size has to be specified in the constructor for FEC to work.");
			}
			_fec = value;
		}
	}

	public OpusDecoder()
		: this(60.0, 48000, 2, frameSizeWasSpecified: false)
	{
	}

	[Obsolete("This constructor was used for the old decode method and is deprecated, please use the new decode method instead.")]
	public OpusDecoder(double frameSize)
		: this(frameSize, 48000, 2, frameSizeWasSpecified: true)
	{
	}

	public OpusDecoder(int sampleRate, int channels)
		: this(60.0, sampleRate, channels, frameSizeWasSpecified: false)
	{
	}

	[Obsolete("This constructor was used for the old decode method and is deprecated, please use the new decode method instead.")]
	public OpusDecoder(double frameSize, int sampleRate, int channels)
		: this(frameSize, sampleRate, channels, frameSizeWasSpecified: true)
	{
	}

	private OpusDecoder(double frameSize, int sampleRate, int channels, bool frameSizeWasSpecified)
	{
		if (frameSize != 2.5 && frameSize != 5.0 && frameSize != 10.0 && frameSize != 20.0 && frameSize != 40.0 && frameSize != 60.0)
		{
			throw new ArgumentException("Value must be one of the following: 2.5, 5, 10, 20, 40 or 60.", "frameSize");
		}
		switch (sampleRate)
		{
		default:
			throw new ArgumentException("Value must be one of the following: 8000, 12000, 16000, 24000 or 48000.", "sampleRate");
		case 8000:
		case 12000:
		case 16000:
		case 24000:
		case 48000:
		{
			if (channels < 1 || channels > 2)
			{
				throw new ArgumentOutOfRangeException("channels", "Value must be between 1 and 2.");
			}
			if (frameSizeWasSpecified)
			{
				FrameSize = frameSize;
			}
			SampleRate = sampleRate;
			Channels = channels;
			_samples = API.GetSampleCount(frameSize, sampleRate);
			_pcmLength = API.GetPCMLength(_samples, channels);
			_handle = API.opus_decoder_create(sampleRate, channels, out var error);
			API.ThrowIfError(error);
			break;
		}
		}
	}

	[Obsolete("This method is deprecated, please use the new decode method instead.")]
	public unsafe byte[] Decode(byte[] opusBytes, int length, out int decodedLength)
	{
		if (opusBytes == null && !FEC)
		{
			throw new ArgumentNullException("opusBytes", "Value cannot be null when FEC is disabled.");
		}
		if (length < 0 && (!FEC || opusBytes != null))
		{
			throw new ArgumentOutOfRangeException("length", "Value cannot be negative when opusBytes is not null or FEC is disabled.");
		}
		if (opusBytes != null && opusBytes.Length < length)
		{
			throw new ArgumentOutOfRangeException("length", "Value cannot be greater than the length of opusBytes.");
		}
		ThrowIfDisposed();
		byte[] array = new byte[_pcmLength];
		int num;
		fixed (byte* ptr = opusBytes)
		{
			fixed (byte* ptr2 = array)
			{
				IntPtr data = (IntPtr)ptr;
				IntPtr pcm = (IntPtr)ptr2;
				num = ((opusBytes == null) ? API.opus_decode(_handle, IntPtr.Zero, 0, pcm, _samples, FEC ? 1 : 0) : API.opus_decode(_handle, data, length, pcm, _samples, 0));
			}
		}
		API.ThrowIfError(num);
		decodedLength = num * Channels * 2;
		return array;
	}

	public unsafe int Decode(byte[] opusBytes, int opusLength, byte[] pcmBytes, int pcmLength)
	{
		if (opusLength < 0 && opusBytes != null)
		{
			throw new ArgumentOutOfRangeException("opusLength", "Value cannot be negative when opusBytes is not null.");
		}
		if (opusBytes != null && opusBytes.Length < opusLength)
		{
			throw new ArgumentOutOfRangeException("opusLength", "Value cannot be greater than the length of opusBytes.");
		}
		if (pcmBytes == null)
		{
			throw new ArgumentNullException("pcmBytes");
		}
		if (pcmLength < 0)
		{
			throw new ArgumentOutOfRangeException("pcmLength", "Value cannot be negative.");
		}
		if (pcmBytes.Length < pcmLength)
		{
			throw new ArgumentOutOfRangeException("pcmLength", "Value cannot be greater than the length of pcmBytes.");
		}
		double frameSize = API.GetFrameSize(pcmLength, SampleRate, Channels);
		if (opusBytes == null && frameSize != 2.5 && frameSize != 5.0 && frameSize != 10.0 && frameSize != 20.0 && frameSize != 40.0 && frameSize != 60.0)
		{
			throw new ArgumentException("When using FEC the frame size must be one of the following: 2.5, 5, 10, 20, 40 or 60.", "pcmLength");
		}
		ThrowIfDisposed();
		int sampleCount = API.GetSampleCount(frameSize, SampleRate);
		int num;
		fixed (byte* ptr = opusBytes)
		{
			fixed (byte* ptr2 = pcmBytes)
			{
				IntPtr data = (IntPtr)ptr;
				IntPtr pcm = (IntPtr)ptr2;
				num = ((opusBytes == null) ? API.opus_decode(_handle, IntPtr.Zero, 0, pcm, sampleCount, 1) : API.opus_decode(_handle, data, opusLength, pcm, sampleCount, 0));
			}
		}
		API.ThrowIfError(num);
		return API.GetPCMLength(num, Channels);
	}

	public void Dispose()
	{
		_handle?.Dispose();
	}

	private void ThrowIfDisposed()
	{
		if (_handle.IsClosed)
		{
			throw new ObjectDisposedException(GetType().FullName);
		}
	}
}
public class OpusEncoder : IDisposable
{
	private readonly SafeEncoderHandle _handle;

	private int _bitrate;

	public Application Application { get; }

	public int SampleRate { get; }

	public int Channels { get; }

	[Obsolete("This property was used for the old encode method and is deprecated, please use the new encode method instead.")]
	public int Bitrate
	{
		get
		{
			return _bitrate;
		}
		set
		{
			if (value < 8000 || value > 512000)
			{
				throw new ArgumentOutOfRangeException("value", "Value must be between 8000 and 512000.");
			}
			_bitrate = value;
		}
	}

	public bool VBR
	{
		get
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4007, out var value));
			return value == 1;
		}
		set
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4006, value ? 1 : 0));
		}
	}

	public Bandwidth MaxBandwidth
	{
		get
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4005, out var value));
			return (Bandwidth)value;
		}
		set
		{
			if (!Enum.IsDefined(typeof(Bandwidth), value))
			{
				throw new ArgumentException("Value is not defined in the enumeration.", "value");
			}
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4004, (int)value));
		}
	}

	public int Complexity
	{
		get
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4011, out var value));
			return value;
		}
		set
		{
			if (value < 0 || value > 10)
			{
				throw new ArgumentOutOfRangeException("value", "Value must be between 0 and 10.");
			}
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4010, value));
		}
	}

	public bool FEC
	{
		get
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4013, out var value));
			return value == 1;
		}
		set
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4012, value ? 1 : 0));
		}
	}

	public int ExpectedPacketLoss
	{
		get
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4015, out var value));
			return value;
		}
		set
		{
			if (value < 0 || value > 100)
			{
				throw new ArgumentOutOfRangeException("value", "Value must be between 0 and 100.");
			}
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4014, value));
		}
	}

	public bool DTX
	{
		get
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4017, out var value));
			return value == 1;
		}
		set
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4016, value ? 1 : 0));
		}
	}

	public ForceChannels ForceChannels
	{
		get
		{
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4023, out var value));
			return (ForceChannels)value;
		}
		set
		{
			if (!Enum.IsDefined(typeof(ForceChannels), value))
			{
				throw new ArgumentException("Value is not defined in the enumeration.", "value");
			}
			ThrowIfDisposed();
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4022, (int)value));
		}
	}

	public OpusEncoder(Application application)
		: this(application, 48000, 2)
	{
	}

	public OpusEncoder(Application application, int sampleRate, int channels)
	{
		if (!Enum.IsDefined(typeof(Application), application))
		{
			throw new ArgumentException("Value is not defined in the enumeration.", "application");
		}
		switch (sampleRate)
		{
		default:
			throw new ArgumentException("Value must be one of the following: 8000, 12000, 16000, 24000 or 48000.", "sampleRate");
		case 8000:
		case 12000:
		case 16000:
		case 24000:
		case 48000:
		{
			if (channels < 1 || channels > 2)
			{
				throw new ArgumentOutOfRangeException("channels", "Value must be between 1 and 2.");
			}
			Application = application;
			SampleRate = sampleRate;
			Channels = channels;
			Bitrate = 128000;
			_handle = API.opus_encoder_create(sampleRate, channels, (int)application, out var error);
			API.ThrowIfError(error);
			API.ThrowIfError(API.opus_encoder_ctl(_handle, 4002, -1));
			break;
		}
		}
	}

	[Obsolete("This method is deprecated, please use the new encode method instead.")]
	public unsafe byte[] Encode(byte[] pcmBytes, int length, out int encodedLength)
	{
		if (pcmBytes == null)
		{
			throw new ArgumentNullException("pcmBytes");
		}
		if (length < 0)
		{
			throw new ArgumentOutOfRangeException("length", "Value cannot be negative.");
		}
		if (pcmBytes.Length < length)
		{
			throw new ArgumentOutOfRangeException("length", "Value cannot be greater than the length of pcmBytes.");
		}
		double frameSize = API.GetFrameSize(length, SampleRate, Channels);
		if (frameSize != 2.5 && frameSize != 5.0 && frameSize != 10.0 && frameSize != 20.0 && frameSize != 40.0 && frameSize != 60.0)
		{
			throw new ArgumentException("The frame size must be one of the following: 2.5, 5, 10, 20, 40 or 60.", "length");
		}
		ThrowIfDisposed();
		byte[] array = new byte[(int)(frameSize * (double)Bitrate / 8.0 / 1000.0)];
		int sampleCount = API.GetSampleCount(frameSize, SampleRate);
		int num;
		fixed (byte* ptr = pcmBytes)
		{
			fixed (byte* ptr2 = array)
			{
				IntPtr pcm = (IntPtr)ptr;
				IntPtr data = (IntPtr)ptr2;
				num = API.opus_encode(_handle, pcm, sampleCount, data, array.Length);
			}
		}
		API.ThrowIfError(num);
		encodedLength = num;
		return array;
	}

	public unsafe int Encode(byte[] pcmBytes, int pcmLength, byte[] opusBytes, int opusLength)
	{
		if (pcmBytes == null)
		{
			throw new ArgumentNullException("pcmBytes");
		}
		if (pcmLength < 0)
		{
			throw new ArgumentOutOfRangeException("pcmLength", "Value cannot be negative.");
		}
		if (pcmBytes.Length < pcmLength)
		{
			throw new ArgumentOutOfRangeException("pcmLength", "Value cannot be greater than the length of pcmBytes.");
		}
		if (opusBytes == null)
		{
			throw new ArgumentNullException("opusBytes");
		}
		if (opusLength < 0)
		{
			throw new ArgumentOutOfRangeException("opusLength", "Value cannot be negative.");
		}
		if (opusBytes.Length < opusLength)
		{
			throw new ArgumentOutOfRangeException("opusLength", "Value cannot be greater than the length of opusBytes.");
		}
		double frameSize = API.GetFrameSize(pcmLength, SampleRate, Channels);
		if (frameSize != 2.5 && frameSize != 5.0 && frameSize != 10.0 && frameSize != 20.0 && frameSize != 40.0 && frameSize != 60.0)
		{
			throw new ArgumentException("The frame size must be one of the following: 2.5, 5, 10, 20, 40 or 60.", "pcmLength");
		}
		ThrowIfDisposed();
		int sampleCount = API.GetSampleCount(frameSize, SampleRate);
		int result;
		fixed (byte* ptr = pcmBytes)
		{
			fixed (byte* ptr2 = opusBytes)
			{
				IntPtr pcm = (IntPtr)ptr;
				IntPtr data = (IntPtr)ptr2;
				result = API.opus_encode(_handle, pcm, sampleCount, data, opusLength);
			}
		}
		API.ThrowIfError(result);
		return result;
	}

	public void Dispose()
	{
		_handle?.Dispose();
	}

	private void ThrowIfDisposed()
	{
		if (_handle.IsClosed)
		{
			throw new ObjectDisposedException(GetType().FullName);
		}
	}
}
public enum OpusError
{
	BadArg = -1,
	BufferTooSmall = -2,
	InternalError = -3,
	InvalidPacket = -4,
	Unimplemented = -5,
	InvalidState = -6,
	AllocFail = -7
}
public class OpusException : Exception
{
	public OpusError Error { get; }

	public OpusException(int errorCode)
		: base(GetMessage((OpusError)errorCode))
	{
		Error = (OpusError)errorCode;
	}

	private static string GetMessage(OpusError error)
	{
		return error switch
		{
			OpusError.BadArg => "One or more invalid/out of range arguments.", 
			OpusError.BufferTooSmall => "Not enough bytes allocated in the buffer.", 
			OpusError.InternalError => "An internal error was detected.", 
			OpusError.InvalidPacket => "The compressed data passed is corrupted.", 
			OpusError.Unimplemented => "Invalid/unsupported request number.", 
			OpusError.InvalidState => "An encoder or decoder structure is invalid or already freed.", 
			OpusError.AllocFail => "Memory allocation has failed.", 
			_ => "An unknown error has occurred.", 
		};
	}
}
internal sealed class SafeDecoderHandle : SafeHandle
{
	public override bool IsInvalid => handle == IntPtr.Zero;

	private SafeDecoderHandle()
		: base(IntPtr.Zero, ownsHandle: true)
	{
	}

	[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
	protected override bool ReleaseHandle()
	{
		API.opus_decoder_destroy(handle);
		return true;
	}
}
internal sealed class SafeEncoderHandle : SafeHandle
{
	public override bool IsInvalid => handle == IntPtr.Zero;

	private SafeEncoderHandle()
		: base(IntPtr.Zero, ownsHandle: true)
	{
	}

	[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
	protected override bool ReleaseHandle()
	{
		API.opus_encoder_destroy(handle);
		return true;
	}
}