using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
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 System.Threading.Tasks;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v1.4", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("MathewSachin")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription(".Net wrapper for un4seen BASS audio library")]
[assembly: AssemblyFileVersion("3.1.1.0")]
[assembly: AssemblyInformationalVersion("3.1.1")]
[assembly: AssemblyProduct("ManagedBass")]
[assembly: AssemblyTitle("ManagedBass")]
[assembly: AssemblyVersion("3.1.1.0")]
namespace ManagedBass
{
	public enum DSInterface
	{
		IDirectSound = 1,
		IDirectSound3DListener
	}
	public enum EAXEnvironment
	{
		LeaveCurrent = -1,
		Generic,
		PaddedCell,
		Room,
		Bathroom,
		Livingroom,
		Stoneroom,
		Auditorium,
		ConcertHall,
		Cave,
		Arena,
		Hangar,
		CarpetedHallway,
		Hallway,
		StoneCorridor,
		Alley,
		Forest,
		City,
		Mountains,
		Quarry,
		Plain,
		ParkingLot,
		SewerPipe,
		Underwater,
		Drugged,
		Dizzy,
		Psychotic,
		Count
	}
	public abstract class Effect<T> : INotifyPropertyChanged, IDisposable where T : class, IEffectParameter, new()
	{
		private int _channel;

		private int _effectHandle;

		private int _hfsync;

		private GCHandle _gch;

		private int _priority;

		protected T Parameters { get; private set; } = new T();


		public int Priority
		{
			get
			{
				return _priority;
			}
			set
			{
				if (IsActive && Bass.FXSetPriority(_effectHandle, value))
				{
					_priority = value;
				}
			}
		}

		public bool IsActive
		{
			get
			{
				if (_channel != 0)
				{
					return _effectHandle != 0;
				}
				return false;
			}
			set
			{
				if (_channel != 0)
				{
					if (value && !IsActive)
					{
						_effectHandle = Bass.ChannelSetFX(_channel, Parameters.FXType, 1);
					}
					else if (!value && IsActive && Bass.ChannelRemoveFX(_channel, _effectHandle))
					{
						_effectHandle = 0;
					}
					OnPropertyChanged("IsActive");
				}
			}
		}

		public event PropertyChangedEventHandler PropertyChanged;

		public void ApplyOn(int Channel, int Priority = 0)
		{
			_channel = Channel;
			_priority = Priority;
			if (!_gch.IsAllocated)
			{
				_gch = GCHandle.Alloc(Parameters, GCHandleType.Pinned);
			}
			_hfsync = Bass.ChannelSetSync(Channel, SyncFlags.Free, 0L, delegate
			{
				Dispose();
			}, (IntPtr)0);
		}

		public void Dispose()
		{
			Bass.ChannelRemoveSync(_channel, _hfsync);
			_channel = (_effectHandle = 0);
			if (_gch.IsAllocated)
			{
				_gch.Free();
			}
		}

		public void Default()
		{
			_gch.Free();
			Parameters = new T();
			_gch = GCHandle.Alloc(Parameters, GCHandleType.Pinned);
			OnPreset();
		}

		protected void OnPreset()
		{
			OnPropertyChanged("");
		}

		protected virtual void OnPropertyChanged([CallerMemberName] string PropertyName = null)
		{
			this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName));
		}
	}
	public class GCPin : IDisposable
	{
		private GCHandle _gcHandle;

		public IntPtr Pointer => _gcHandle.AddrOfPinnedObject();

		public GCPin(object Item)
		{
			_gcHandle = GCHandle.Alloc(Item, GCHandleType.Pinned);
		}

		public static int CreateStreamHelper(Func<IntPtr, int> Function, object Memory)
		{
			GCHandle GCPin = GCHandle.Alloc(Memory, GCHandleType.Pinned);
			int num = Function(GCPin.AddrOfPinnedObject());
			if (num == 0)
			{
				GCPin.Free();
			}
			else
			{
				Bass.ChannelSetSync(num, SyncFlags.Free, 0L, delegate
				{
					GCPin.Free();
				}, (IntPtr)0);
			}
			return num;
		}

		public void Dispose()
		{
			_gcHandle.Free();
		}
	}
	public class BassException : Exception
	{
		public Errors ErrorCode { get; }

		public BassException()
			: this(Bass.LastError)
		{
		}

		public BassException(Errors ErrorCode)
			: base($"Error: {ErrorCode}")
		{
			this.ErrorCode = ErrorCode;
		}
	}
	public delegate void DownloadProcedure(IntPtr Buffer, int Length, IntPtr User);
	public delegate void DSPProcedure(int Handle, int Channel, IntPtr Buffer, int Length, IntPtr User);
	public delegate void FileCloseProcedure(IntPtr User);
	public delegate long FileLengthProcedure(IntPtr User);
	public delegate int FileReadProcedure(IntPtr Buffer, int Length, IntPtr User);
	public delegate bool FileSeekProcedure(long Offset, IntPtr User);
	public delegate bool RecordProcedure(int Handle, IntPtr Buffer, int Length, IntPtr User);
	public delegate int StreamProcedure(int Handle, IntPtr Buffer, int Length, IntPtr User);
	public delegate void SyncProcedure(int Handle, int Channel, int Data, IntPtr User);
	public enum Algorithm3D
	{
		Default,
		Off,
		Full,
		Light
	}
	[Flags]
	public enum BassFlags : uint
	{
		Default = 0u,
		Byte = 1u,
		Mono = 2u,
		Loop = 4u,
		Bass3D = 8u,
		SoftwareMixing = 0x10u,
		FX = 0x80u,
		Float = 0x100u,
		Prescan = 0x20000u,
		AutoFree = 0x40000u,
		RestrictDownloadRate = 0x80000u,
		StreamDownloadBlocks = 0x100000u,
		Decode = 0x200000u,
		StreamStatus = 0x800000u,
		AsyncFile = 0x40000000u,
		Unicode = 0x80000000u,
		FxBpmBackground = 1u,
		FXBpmMult2 = 2u,
		FxTempoAlgorithmLinear = 0x200u,
		FxTempoAlgorithmCubic = 0x400u,
		FxTempoAlgorithmShannon = 0x800u,
		FxFreeSource = 0x10000u,
		MidiNoHeader = 1u,
		Midi16Bit = 2u,
		MidiNoSystemReset = 0x800u,
		MidiDecayEnd = 0x1000u,
		MidiNoFx = 0x2000u,
		MidiDecaySeek = 0x4000u,
		MidiNoCrop = 0x8000u,
		MidiNoteOff1 = 0x10000u,
		MidiFontMemoryMap = 0x20000u,
		MidiFontXGDRUMS = 0x40000u,
		SincInterpolation = 0x800000u,
		MusicRamp = 0x200u,
		MusicSensitiveRamping = 0x400u,
		MusicSurround = 0x800u,
		MusicSurround2 = 0x1000u,
		MusicFT2Mod = 0x2000u,
		MusicFT2PAN = 0x2000u,
		MusicPT1Mod = 0x4000u,
		MusicPositionReset = 0x8000u,
		MusicNonInterpolated = 0x10000u,
		MusicStopBack = 0x80000u,
		MusicNoSample = 0x100000u,
		MusicPositionResetEx = 0x400000u,
		MuteMax = 0x20u,
		VAM = 0x40u,
		SampleOverrideLowestVolume = 0x10000u,
		SampleOverrideLongestPlaying = 0x20000u,
		SampleOverrideDistance = 0x30000u,
		SampleChannelNew = 1u,
		SampleChannelStream = 2u,
		CDSubChannel = 0x200u,
		CDSubchannelNoHW = 0x400u,
		CdC2Errors = 0x800u,
		MixerChanAbsolute = 0x1000u,
		SplitSlave = 0x1000u,
		SplitPosition = 0x2000u,
		MixerResume = 0x1000u,
		MixerPositionEx = 0x2000u,
		MixerChanBuffer = 0x2000u,
		[Obsolete("Renamed to MixerChanBuffer for clarity.")]
		MixerBuffer = 0x2000u,
		MixerChanLimit = 0x4000u,
		[Obsolete("Renamed to MixerChanLimit for clarity.")]
		MixerLimit = 0x4000u,
		MixerEnd = 0x10000u,
		MixerChanMatrix = 0x10000u,
		[Obsolete("Renamed to MixerChanMatrix for clarity.")]
		MixerMatrix = 0x10000u,
		MixerNonStop = 0x20000u,
		MixerChanPause = 0x20000u,
		[Obsolete("Renamed to MixerChanPause for clarity.")]
		MixerPause = 0x20000u,
		MixerChanDownMix = 0x400000u,
		[Obsolete("Renamed to MixerChanDownMix for clarity.")]
		MixerDownMix = 0x400000u,
		MixerChanNoRampin = 0x800000u,
		[Obsolete("Renamed to MixerChanNoRampin for clarity.")]
		MixerNoRampin = 0x800000u,
		RecordPause = 0x8000u,
		RecordEchoCancel = 0x2000u,
		RecordAGC = 0x4000u,
		SpeakerFront = 0x1000000u,
		SpeakerRear = 0x2000000u,
		SpeakerCenterLFE = 0x3000000u,
		SpeakerRearCenter = 0x4000000u,
		SpeakerPair1 = 0x1000000u,
		SpeakerPair2 = 0x2000000u,
		SpeakerPair3 = 0x3000000u,
		SpeakerPair4 = 0x4000000u,
		SpeakerPair5 = 0x5000000u,
		SpeakerPair6 = 0x6000000u,
		SpeakerPair7 = 0x7000000u,
		SpeakerPair8 = 0x8000000u,
		SpeakerPair9 = 0x9000000u,
		SpeakerPair10 = 0xA000000u,
		SpeakerPair11 = 0xB000000u,
		SpeakerPair12 = 0xC000000u,
		SpeakerPair13 = 0xD000000u,
		SpeakerPair14 = 0xE000000u,
		SpeakerPair15 = 0xF000000u,
		SpeakerLeft = 0x10000000u,
		SpeakerRight = 0x20000000u,
		SpeakerFrontLeft = 0x11000000u,
		SpeakerRearLeft = 0x12000000u,
		SpeakerCenter = 0x13000000u,
		SpeakerRearCenterLeft = 0x14000000u,
		SpeakerFrontRight = 0x21000000u,
		SpeakerRearRight = 0x22000000u,
		SpeakerLFE = 0x23000000u,
		SpeakerRearCenterRight = 0x24000000u,
		AacFrame960 = 0x1000u,
		AacStereo = 0x400000u,
		DSDOverPCM = 0x400u,
		DSDRaw = 0x200u,
		Ac3DownmixStereo = 0x200u,
		Ac3DownmixQuad = 0x400u,
		Ac3DownmixDolby = 0x600u,
		Ac3DRC = 0x800u,
		DShowNoAudioProcessing = 0x80000u,
		DShowStreamMix = 0x1000000u,
		DShowAutoDVD = 0x4000000u,
		DShowLoop = 0x8000000u,
		DShowVideoProcessing = 0x20000u,
		WVStereo = 0x400000u
	}
	[Flags]
	internal enum BASSInfoFlags
	{
		None = 0,
		ContinuousRate = 0x10,
		EmulatedDrivers = 0x20,
		Certified = 0x40,
		Mono = 0x100,
		Stereo = 0x200,
		Secondary8Bit = 0x400,
		Secondary16Bit = 0x800
	}
	public enum ChannelAttribute
	{
		Frequency = 1,
		Volume = 2,
		Pan = 3,
		EaxMix = 4,
		NoBuffer = 5,
		CPUUsage = 7,
		SampleRateConversion = 8,
		NetworkResumeBufferLevel = 9,
		ScannedInfo = 10,
		NoRamp = 11,
		Bitrate = 12,
		Buffer = 13,
		Granule = 14,
		MusicAmplify = 256,
		MusicPanSeparation = 257,
		MusicPositionScaler = 258,
		MusicBPM = 259,
		MusicSpeed = 260,
		MusicVolumeGlobal = 261,
		MusicActiveChannelCount = 262,
		MusicVolumeChannel = 512,
		MusicVolumeInstrument = 768,
		Tempo = 65536,
		Pitch = 65537,
		TempoFrequency = 65538,
		TempoUseAAFilter = 65552,
		TempoAAFilterLength = 65553,
		TempoUseQuickAlgorithm = 65554,
		TempoSequenceMilliseconds = 65555,
		TempoSeekWindowMilliseconds = 65556,
		TempoOverlapMilliseconds = 65557,
		TempoPreventClick = 65558,
		ReverseDirection = 69632,
		MidiPPQN = 73728,
		MidiCPU = 73729,
		MidiChannels = 73730,
		MidiVoices = 73731,
		MidiVoicesActive = 73732,
		MidiState = 73733,
		MidiSRC = 73734,
		MidiKill = 73735,
		MidiTrackVolume = 73984,
		OpusOriginalFrequency = 77824,
		DSDGain = 81920,
		DSDRate = 81921,
		MixerLatency = 86016,
		SplitAsyncBuffer = 86032,
		SplitAsyncPeriod = 86033
	}
	[Flags]
	public enum ChannelType
	{
		Unknown = 0,
		Sample = 1,
		Recording = 2,
		MO3 = 0x100,
		ZXTune = -820183040,
		Stream = 0x10000,
		OGG = 0x10002,
		MP1 = 0x10003,
		MP2 = 0x10004,
		MP3 = 0x10005,
		AIFF = 0x10006,
		CA = 0x10007,
		MF = 0x10008,
		CD = 0x10200,
		WMA = 0x10300,
		WMA_MP3 = 0x10301,
		WINAMP = 0x10400,
		WV = 0x10500,
		WV_H = 0x10501,
		WV_L = 0x10502,
		WV_LH = 0x10503,
		OFR = 0x10600,
		APE = 0x10700,
		Mixer = 0x10800,
		Split = 0x10801,
		FLAC = 0x10900,
		FLAC_OGG = 0x10901,
		MPC = 0x10A00,
		AAC = 0x10B00,
		MP4 = 0x10B01,
		SPX = 0x10C00,
		MIDI = 0x10D00,
		ALAC = 0x10E00,
		TTA = 0x10F00,
		AC3 = 0x11000,
		Video = 0x11100,
		OPUS = 0x11200,
		DSD = 0x11700,
		ADX = 0x1F000,
		AIX = 0x1F001,
		Tempo = 0x1F200,
		Reverse = 0x1F201,
		MOD = 0x20000,
		MTM = 0x20001,
		S3M = 0x20002,
		XM = 0x20003,
		IT = 0x20004,
		Wave = 0x40000,
		WavePCM = 0x50001,
		WaveFloat = 0x50003,
		Dummy = 0x18000,
		Device = 0x18001
	}
	public enum Configuration
	{
		PlaybackBufferLength = 0,
		UpdatePeriod = 1,
		GlobalSampleVolume = 4,
		GlobalStreamVolume = 5,
		GlobalMusicVolume = 6,
		LogarithmicVolumeCurve = 7,
		LogarithmicPanCurve = 8,
		FloatDSP = 9,
		Algorithm3D = 10,
		NetTimeOut = 11,
		NetBufferLength = 12,
		PauseNoPlay = 13,
		NetPreBuffer = 15,
		NetAgent = 16,
		NetProxy = 17,
		NetPassive = 18,
		RecordingBufferLength = 19,
		NetPlaylist = 21,
		MusicVirtual = 22,
		FileVerificationBytes = 23,
		UpdateThreads = 24,
		DeviceBufferLength = 27,
		LoopbackRecording = 28,
		NoTimerResolution = 29,
		TruePlayPosition = 30,
		IOSMixAudio = 34,
		IOSSession = 34,
		SuppressMP3ErrorCorruptionSilence = 35,
		IncludeDefaultDevice = 36,
		NetReadTimeOut = 37,
		VistaSpeakerAssignment = 38,
		IOSSpeaker = 39,
		MFDisable = 40,
		HandleCount = 41,
		UnicodeDeviceInformation = 42,
		SRCQuality = 43,
		SampleSRCQuality = 44,
		AsyncFileBufferLength = 45,
		IOSNotify = 46,
		OggPreScan = 47,
		MFVideo = 48,
		Airplay = 49,
		DevNonStop = 50,
		IOSNoCategory = 51,
		NetVerificationBytes = 52,
		DevicePeriod = 53,
		Float = 54,
		AndroidSessionId = 62,
		AndroidAAudio = 67,
		AC3DynamicRangeCompression = 65537,
		WmaNetPreBuffer = 65793,
		WmaBassFileHandling = 65795,
		WmaNetSeek = 65796,
		WmaVideo = 65797,
		WmaAsync = 65807,
		CDFreeOld = 66048,
		CDRetry = 66049,
		CDAutoSpeed = 66050,
		CDSkipError = 66051,
		CDDBServer = 66052,
		EncodePriority = 66304,
		EncodeQueue = 66305,
		EncodeACMLoad = 66306,
		EncodeCastTimeout = 66320,
		EncodeCastProxy = 66321,
		MidiCompact = 66560,
		MidiVoices = 66561,
		MidiAutoFont = 66562,
		MidiDefaultFont = 66563,
		MidiInputPorts = 66564,
		MixerBufferLength = 67073,
		MixerPositionEx = 67074,
		SplitBufferLength = 67088,
		PlayAudioFromMp4 = 67328,
		AacSupportMp4 = 67329,
		DSDFrequency = 67584,
		WinampInputTimeout = 67584,
		DSDGain = 67585,
		ZXTuneMaxFileSize = -820182784
	}
	[Flags]
	public enum DataFlags
	{
		Available = 0,
		FFTIndividual = 0x10,
		FFTNoWindow = 0x20,
		FFTRemoveDC = 0x40,
		FFTComplex = 0x80,
		Fixed = 0x20000000,
		Float = 0x40000000,
		FFT256 = int.MinValue,
		FFT512 = -2147483647,
		FFT1024 = -2147483646,
		FFT2048 = -2147483645,
		FFT4096 = -2147483644,
		FFT8192 = -2147483643,
		FFT16384 = -2147483642,
		FFT32768 = -2147483641
	}
	[Flags]
	public enum DeviceInfoFlags
	{
		None = 0,
		Enabled = 1,
		Default = 2,
		Initialized = 4,
		Loopback = 8,
		TypeMask = -16777216
	}
	[Flags]
	public enum DeviceInitFlags
	{
		Default = 0,
		Byte = 1,
		Mono = 2,
		Device3D = 4,
		Bits16 = 8,
		Latency = 0x100,
		CPSpeakers = 0x400,
		ForcedSpeakerAssignment = 0x800,
		NoSpeakerAssignment = 0x1000,
		DMix = 0x2000,
		Frequency = 0x4000,
		Stereo = 0x8000,
		Hog = 0x10000,
		AudioTrack = 0x20000,
		DirectSound = 0x40000
	}
	public enum DeviceType
	{
		Network = 16777216,
		Speakers = 33554432,
		Line = 50331648,
		Headphones = 67108864,
		Microphone = 83886080,
		Headset = 100663296,
		Handset = 117440512,
		Digital = 134217728,
		SPDIF = 150994944,
		HDMI = 167772160,
		DisplayPort = 1073741824
	}
	public enum DXPhase
	{
		Negative180,
		Negative90,
		Zero,
		Positive90,
		Positive180
	}
	public enum DXWaveform
	{
		Triangle,
		Sine
	}
	public enum EffectType
	{
		DXChorus = 0,
		DXDistortion = 1,
		DXEcho = 2,
		DXFlanger = 3,
		DXCompressor = 4,
		DXGargle = 5,
		DX_I3DL2Reverb = 6,
		DXParamEQ = 7,
		DXReverb = 8,
		Rotate = 65536,
		Volume = 65539,
		PeakEQ = 65540,
		Mix = 65543,
		Damp = 65544,
		AutoWah = 65545,
		Phaser = 65547,
		Chorus = 65549,
		Distortion = 65552,
		Compressor = 65553,
		VolumeEnvelope = 65554,
		BQF = 65555,
		Echo = 65556,
		PitchShift = 65557,
		Freeverb = 65558
	}
	public enum FileStreamPosition
	{
		Current = 0,
		Download = 1,
		End = 2,
		Start = 3,
		Connected = 4,
		Buffer = 5,
		Socket = 6,
		AsyncBuffer = 7,
		WmaBuffer = 1000,
		HlsSegment = 65536
	}
	[Flags]
	public enum FXChannelFlags
	{
		All = -1,
		None = 0,
		Channel1 = 1,
		Channel2 = 2,
		Channel3 = 4,
		Channel4 = 8,
		Channel5 = 0x10,
		Channel6 = 0x20,
		Channel7 = 0x40,
		Channel8 = 0x80,
		Channel9 = 0x100,
		Channel10 = 0x200,
		Channel11 = 0x400,
		Channel12 = 0x800,
		Channel13 = 0x1000,
		Channel14 = 0x2000,
		Channel15 = 0x4000,
		Channel16 = 0x8000,
		Channel17 = 0x10000,
		Channel18 = 0x20000,
		Channel19 = 0x40000,
		Channel20 = 0x80000,
		Channel21 = 0x100000,
		Channel22 = 0x200000,
		Channel23 = 0x400000,
		Channel24 = 0x800000,
		Channel25 = 0x1000000,
		Channel26 = 0x2000000,
		Channel27 = 0x4000000,
		Channel28 = 0x8000000,
		Channel29 = 0x10000000,
		Channel30 = 0x20000000
	}
	[Flags]
	public enum InputFlags
	{
		None = 0,
		Off = 0x10000,
		On = 0x20000
	}
	[Flags]
	public enum InputTypeFlags
	{
		InputTypeMask = -16777216,
		Error = -1,
		Undefined = 0,
		Digital = 0x1000000,
		Line = 0x2000000,
		Microphone = 0x3000000,
		MIDISynthesizer = 0x4000000,
		AnalogCD = 0x5000000,
		Phone = 0x6000000,
		Speaker = 0x7000000,
		Wave = 0x8000000,
		Auxiliary = 0x9000000,
		Analog = 0xA000000
	}
	[Flags]
	public enum LevelRetrievalFlags
	{
		All = 0,
		Mono = 1,
		Stereo = 2,
		RMS = 4,
		VolPan = 8
	}
	public enum Mode3D
	{
		LeaveCurrent = -1,
		Normal,
		Relative,
		Off
	}
	public enum PlaybackState
	{
		Stopped,
		Playing,
		Stalled,
		Paused
	}
	[Flags]
	public enum PositionFlags
	{
		Bytes = 0,
		MusicOrders = 1,
		MIDITick = 2,
		OGG = 3,
		CDTrack = 4,
		ZXTuneSubCount = 0xF10000,
		ZXTuneSubLength = 0xF20000,
		MIDIDecaySeek = 0x4000,
		MixerReset = 0x10000,
		MusicPositionReset = 0x8000,
		MusicPositionResetEx = 0x400000,
		MixerNoRampIn = 0x800000,
		Inexact = 0x8000000,
		Relative = 0x4000000,
		Decode = 0x10000000,
		DecodeTo = 0x20000000,
		Scan = 0x40000000,
		HlsSegment = 0x10000
	}
	[Flags]
	public enum RecordFormatFlags
	{
		Unknown = 0,
		WF1M08 = 1,
		WF1S08 = 2,
		WF1M16 = 4,
		WF1S16 = 8,
		WF2M08 = 0x10,
		WF2S08 = 0x20,
		WF2M16 = 0x40,
		WF2S16 = 0x80,
		WF4M08 = 0x100,
		WF4S08 = 0x200,
		WF4M16 = 0x400,
		WF4S16 = 0x800,
		WF48M08 = 0x1000,
		WF48S08 = 0x2000,
		WF48M16 = 0x4000,
		WF48S16 = 0x8000,
		WF96M08 = 0x10000,
		WF96S08 = 0x20000,
		WF96M16 = 0x40000,
		WF96S16 = 0x80000
	}
	[Flags]
	internal enum RecordInfoFlags
	{
		None = 0,
		EmulatedDrivers = 0x20,
		Certified = 0x40
	}
	public enum StreamProcedureType
	{
		End = int.MinValue,
		Push = -1,
		Dummy = 0,
		Device = -2
	}
	public enum StreamSystem
	{
		NoBuffer,
		Buffer,
		BufferPush
	}
	[Flags]
	public enum SyncFlags
	{
		Onetime = int.MinValue,
		Mixtime = 0x40000000,
		Thread = 0x20000000,
		Position = 0,
		MusicInstrument = 1,
		End = 2,
		MusicFx = 3,
		MetadataReceived = 4,
		Slided = 5,
		Stalled = 6,
		Downloaded = 7,
		Free = 8,
		MusicPosition = 0xA,
		Seeking = 0xB,
		OggChange = 0xC,
		Stop = 0xE,
		WinampBitRate = 0x64,
		CDError = 0x3E8,
		CDSpeed = 0x3EA,
		MidiMarker = 0x10000,
		MidiCue = 0x10001,
		MidiLyric = 0x10002,
		MidiText = 0x10003,
		MidiEvent = 0x10004,
		MidiTick = 0x10005,
		MidiTimeSignature = 0x10006,
		MidiKeySignature = 0x10007,
		WmaChange = 0x10100,
		WmaMeta = 0x10101,
		MixerEnvelope = 0x10200,
		MixerEnvelopeNode = 0x10201,
		HlsSegement = 0x10300
	}
	public enum TagType
	{
		ID3 = 0,
		ID3v2 = 1,
		OGG = 2,
		HTTP = 3,
		ICY = 4,
		META = 5,
		APE = 6,
		MP4 = 7,
		WMA = 8,
		OggEncoder = 9,
		Lyrics3v2 = 10,
		WmaMeta = 11,
		CoreAudioCodec = 11,
		WmaCodec = 12,
		FlacCue = 12,
		MF = 13,
		WaveFormat = 14,
		ZXTuneSuOgg = 15794176,
		RiffInfo = 256,
		RiffBext = 257,
		RiffCart = 258,
		RiffDISP = 259,
		ApeBinary = 4096,
		MusicName = 65536,
		MusicMessage = 65537,
		MusicOrders = 65538,
		MusicAuth = 65539,
		MusicInstrument = 65792,
		MusicSample = 66304,
		MidiTrack = 69632,
		FlacPicture = 73728,
		AdxLoop = 73728,
		DSDArtist = 77824,
		DSDTitle = 77825,
		DSDComment = 78080,
		HlsExtInf = 81920,
		HlsStreamInf = 81921,
		HlsDate = 81922
	}
	[Flags]
	public enum VAMMode
	{
		Hardware = 1,
		Software = 2,
		TerminateTime = 4,
		TerminateDistance = 8,
		TerminatePriority = 0x10
	}
	public enum WaveFormatTag : short
	{
		Extensible = -2,
		Unknown = 0,
		Pcm = 1,
		Adpcm = 2,
		IeeeFloat = 3,
		Vselp = 4,
		IbmCvsd = 5,
		ALaw = 6,
		MuLaw = 7,
		Dts = 8,
		Drm = 9,
		WmaVoice9 = 10,
		OkiAdpcm = 16,
		DviAdpcm = 17,
		ImaAdpcm = 17,
		MediaspaceAdpcm = 18,
		SierraAdpcm = 19,
		G723Adpcm = 20,
		DigiStd = 21,
		DigiFix = 22,
		DialogicOkiAdpcm = 23,
		MediaVisionAdpcm = 24,
		CUCodec = 25,
		YamahaAdpcm = 32,
		SonarC = 33,
		DspGroupTrueSpeech = 34,
		EchoSpeechCorporation1 = 35,
		AudioFileAf36 = 36,
		Aptx = 37,
		AudioFileAf10 = 38,
		Prosody1612 = 39,
		Lrc = 40,
		DolbyAc2 = 48,
		Gsm610 = 49,
		MsnAudio = 50,
		AntexAdpcme = 51,
		ControlResVqlpc = 52,
		DigiReal = 53,
		DigiAdpcm = 54,
		ControlResCr10 = 55,
		NMS_VBXADPCM = 56,
		CS_IMAADPCM = 57,
		ECHOSC3 = 58,
		ROCKWELL_ADPCM = 59,
		ROCKWELL_DIGITALK = 60,
		XEBEC = 61,
		G721_ADPCM = 64,
		G728_CELP = 65,
		MSG723 = 66,
		Mpeg = 80,
		RT24 = 82,
		PAC = 83,
		Mp3 = 85,
		LUCENT_G723 = 89,
		CIRRUS = 96,
		ESPCM = 97,
		VOXWARE = 98,
		CANOPUS_ATRAC = 99,
		G726_ADPCM = 100,
		G722_ADPCM = 101,
		DSAT_DISPLAY = 103,
		VOXWARE_BYTE_ALIGNED = 105,
		VOXWARE_AC8 = 112,
		VOXWARE_AC10 = 113,
		VOXWARE_AC16 = 114,
		VOXWARE_AC20 = 115,
		VOXWARE_RT24 = 116,
		VOXWARE_RT29 = 117,
		VOXWARE_RT29HW = 118,
		VOXWARE_VR12 = 119,
		VOXWARE_VR18 = 120,
		VOXWARE_TQ40 = 121,
		SOFTSOUND = 128,
		VOXWARE_TQ60 = 129,
		MSRT24 = 130,
		G729A = 131,
		MVI_MVI2 = 132,
		DF_G726 = 133,
		DF_GSM610 = 134,
		ISIAUDIO = 136,
		ONLIVE = 137,
		SBC24 = 145,
		DOLBY_AC3_SPDIF = 146,
		MEDIASONIC_G723 = 147,
		PROSODY_8KBPS = 148,
		ZYXEL_ADPCM = 151,
		PHILIPS_LPCBB = 152,
		PACKED = 153,
		MALDEN_PHONYTALK = 160,
		Gsm = 161,
		G729 = 162,
		G723 = 163,
		Acelp = 164,
		RawAac = 255,
		RHETOREX_ADPCM = 256,
		IRAT = 257,
		VIVO_G723 = 273,
		VIVO_SIREN = 274,
		DIGITAL_G723 = 291,
		SANYO_LD_ADPCM = 293,
		SIPROLAB_ACEPLNET = 304,
		SIPROLAB_ACELP4800 = 305,
		SIPROLAB_ACELP8V3 = 306,
		SIPROLAB_G729 = 307,
		SIPROLAB_G729A = 308,
		SIPROLAB_KELVIN = 309,
		G726ADPCM = 320,
		QUALCOMM_PUREVOICE = 336,
		QUALCOMM_HALFRATE = 337,
		TUBGSM = 341,
		MSAUDIO1 = 352,
		WMA = 353,
		WMAProfessional = 354,
		WMALosseless = 355,
		WMA_SPDIF = 356,
		UNISYS_NAP_ADPCM = 368,
		UNISYS_NAP_ULAW = 369,
		UNISYS_NAP_ALAW = 370,
		UNISYS_NAP_16K = 371,
		CREATIVE_ADPCM = 512,
		CREATIVE_FASTSPEECH8 = 514,
		CREATIVE_FASTSPEECH10 = 515,
		UHER_ADPCM = 528,
		QUARTERDECK = 544,
		ILINK_VC = 560,
		RAW_SPORT = 576,
		ESST_AC3 = 577,
		IPI_HSX = 592,
		IPI_RPELP = 593,
		CS2 = 608,
		SONY_SCX = 624,
		FM_TOWNS_SND = 768,
		BTV_DIGITAL = 1024,
		QDESIGN_MUSIC = 1104,
		VME_VMPCM = 1664,
		TPC = 1665,
		OLIGSM = 4096,
		OLIADPCM = 4097,
		OLICELP = 4098,
		OLISBC = 4099,
		OLIOPR = 4100,
		LH_CODEC = 4352,
		NORRIS = 5120,
		SOUNDSPACE_MUSICOMPRESS = 5376,
		MPEG_ADTS_AAC = 5632,
		MPEG_RAW_AAC = 5633,
		MPEG_LOAS = 5634,
		NOKIA_MPEG_ADTS_AAC = 5640,
		NOKIA_MPEG_RAW_AAC = 5641,
		VODAFONE_MPEG_ADTS_AAC = 5642,
		VODAFONE_MPEG_RAW_AAC = 5643,
		MPEG_HEAAC = 5648,
		DVM = 8192,
		Vorbis1 = 26447,
		Vorbis2 = 26448,
		Vorbis3 = 26449,
		Vorbis1P = 26479,
		Vorbis2P = 26480,
		Vorbis3P = 26481
	}
	public static class Bass
	{
		private const string DllName = "bass";

		private const int SlideLog = 16777216;

		public const int NoSoundDevice = 0;

		public const int DefaultDevice = -1;

		public static Algorithm3D Algorithm3D
		{
			get
			{
				return (Algorithm3D)GetConfig(Configuration.Algorithm3D);
			}
			set
			{
				Configure(Configuration.Algorithm3D, (int)value);
			}
		}

		public static string SupportedFormats => "*.mp3;*.mp2;*.mp1;*.ogg;*.wav;*.aif";

		public static double CPUUsage => BASS_GetCPU();

		public static Version Version => Extensions.GetVersion(BASS_GetVersion());

		public static Errors LastError => BASS_ErrorGetCode();

		public static bool Float => GetConfigBool(Configuration.Float);

		public static int PlaybackBufferLength
		{
			get
			{
				return GetConfig(Configuration.PlaybackBufferLength);
			}
			set
			{
				Configure(Configuration.PlaybackBufferLength, value);
			}
		}

		public static int UpdatePeriod
		{
			get
			{
				return GetConfig(Configuration.UpdatePeriod);
			}
			set
			{
				Configure(Configuration.UpdatePeriod, value);
			}
		}

		public static int GlobalSampleVolume
		{
			get
			{
				return GetConfig(Configuration.GlobalSampleVolume);
			}
			set
			{
				Configure(Configuration.GlobalSampleVolume, value);
			}
		}

		public static int GlobalStreamVolume
		{
			get
			{
				return GetConfig(Configuration.GlobalStreamVolume);
			}
			set
			{
				Configure(Configuration.GlobalStreamVolume, value);
			}
		}

		public static int GlobalMusicVolume
		{
			get
			{
				return GetConfig(Configuration.GlobalMusicVolume);
			}
			set
			{
				Configure(Configuration.GlobalMusicVolume, value);
			}
		}

		public static bool LogarithmicVolumeCurve
		{
			get
			{
				return GetConfigBool(Configuration.LogarithmicVolumeCurve);
			}
			set
			{
				Configure(Configuration.LogarithmicVolumeCurve, value);
			}
		}

		public static bool LogarithmicPanningCurve
		{
			get
			{
				return GetConfigBool(Configuration.LogarithmicPanCurve);
			}
			set
			{
				Configure(Configuration.LogarithmicPanCurve, value);
			}
		}

		public static bool FloatingPointDSP
		{
			get
			{
				return GetConfigBool(Configuration.FloatDSP);
			}
			set
			{
				Configure(Configuration.FloatDSP, value);
			}
		}

		public static int UpdateThreads
		{
			get
			{
				return GetConfig(Configuration.UpdateThreads);
			}
			set
			{
				Configure(Configuration.UpdateThreads, value);
			}
		}

		public static int AsyncFileBufferLength
		{
			get
			{
				return GetConfig(Configuration.AsyncFileBufferLength);
			}
			set
			{
				Configure(Configuration.AsyncFileBufferLength, value);
			}
		}

		public static int HandleCount => GetConfig(Configuration.HandleCount);

		public static int NetTimeOut
		{
			get
			{
				return GetConfig(Configuration.NetTimeOut);
			}
			set
			{
				Configure(Configuration.NetTimeOut, value);
			}
		}

		public static int NetReadTimeOut
		{
			get
			{
				return GetConfig(Configuration.NetReadTimeOut);
			}
			set
			{
				Configure(Configuration.NetReadTimeOut, value);
			}
		}

		public static int NetBufferLength
		{
			get
			{
				return GetConfig(Configuration.NetBufferLength);
			}
			set
			{
				Configure(Configuration.NetBufferLength, value);
			}
		}

		public static int PauseNoPlay
		{
			get
			{
				return GetConfig(Configuration.PauseNoPlay);
			}
			set
			{
				Configure(Configuration.PauseNoPlay, value);
			}
		}

		public static int NetPreBuffer
		{
			get
			{
				return GetConfig(Configuration.NetPreBuffer);
			}
			set
			{
				Configure(Configuration.NetPreBuffer, value);
			}
		}

		public static bool FTPPassive
		{
			get
			{
				return GetConfigBool(Configuration.NetPassive);
			}
			set
			{
				Configure(Configuration.NetPassive, value);
			}
		}

		public static int NetPlaylist
		{
			get
			{
				return GetConfig(Configuration.NetPlaylist);
			}
			set
			{
				Configure(Configuration.NetPlaylist, value);
			}
		}

		public static string NetAgent
		{
			get
			{
				return Marshal.PtrToStringAnsi(GetConfigPtr(Configuration.NetAgent));
			}
			set
			{
				IntPtr intPtr = Marshal.StringToHGlobalAnsi(value);
				Configure(Configuration.NetAgent, intPtr);
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public static string NetProxy
		{
			get
			{
				return Marshal.PtrToStringAnsi(GetConfigPtr(Configuration.NetProxy));
			}
			set
			{
				IntPtr intPtr = Marshal.StringToHGlobalAnsi(value);
				Configure(Configuration.NetProxy, intPtr);
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public static int MusicVirtial
		{
			get
			{
				return GetConfig(Configuration.MusicVirtual);
			}
			set
			{
				Configure(Configuration.MusicVirtual, value);
			}
		}

		public static int FileVerificationBytes
		{
			get
			{
				return GetConfig(Configuration.FileVerificationBytes);
			}
			set
			{
				Configure(Configuration.FileVerificationBytes, value);
			}
		}

		public static int NetVerificationBytes
		{
			get
			{
				return GetConfig(Configuration.NetVerificationBytes);
			}
			set
			{
				Configure(Configuration.NetVerificationBytes, value);
			}
		}

		public static int DeviceBufferLength
		{
			get
			{
				return GetConfig(Configuration.DeviceBufferLength);
			}
			set
			{
				Configure(Configuration.DeviceBufferLength, value);
			}
		}

		public static bool SuppressMP3ErrorCorruptionSilence
		{
			get
			{
				return GetConfigBool(Configuration.SuppressMP3ErrorCorruptionSilence);
			}
			set
			{
				Configure(Configuration.SuppressMP3ErrorCorruptionSilence, value);
			}
		}

		public static int SRCQuality
		{
			get
			{
				return GetConfig(Configuration.SRCQuality);
			}
			set
			{
				Configure(Configuration.SRCQuality, value);
			}
		}

		public static int SampleSRCQuality
		{
			get
			{
				return GetConfig(Configuration.SampleSRCQuality);
			}
			set
			{
				Configure(Configuration.SampleSRCQuality, value);
			}
		}

		public static bool OggPreScan
		{
			get
			{
				return GetConfigBool(Configuration.OggPreScan);
			}
			set
			{
				Configure(Configuration.OggPreScan, value);
			}
		}

		public static bool DeviceNonStop
		{
			get
			{
				return GetConfigBool(Configuration.DevNonStop);
			}
			set
			{
				Configure(Configuration.DevNonStop, value);
			}
		}

		public static int DeviceCount
		{
			get
			{
				int i;
				DeviceInfo Info;
				for (i = 0; GetDeviceInfo(i, out Info); i++)
				{
				}
				return i;
			}
		}

		public static double Volume
		{
			get
			{
				return BASS_GetVolume();
			}
			set
			{
				if (!BASS_SetVolume((float)value))
				{
					throw new BassException();
				}
			}
		}

		public static int CurrentDevice
		{
			get
			{
				return BASS_GetDevice();
			}
			set
			{
				if (!BASS_SetDevice(value))
				{
					throw new BassException();
				}
			}
		}

		public static BassInfo Info
		{
			get
			{
				if (!GetInfo(out var Info))
				{
					throw new BassException();
				}
				return Info;
			}
		}

		public static int CurrentRecordingDevice
		{
			get
			{
				return BASS_RecordGetDevice();
			}
			set
			{
				if (!BASS_RecordSetDevice(value))
				{
					throw new BassException();
				}
			}
		}

		public static RecordInfo RecordingInfo
		{
			get
			{
				if (!RecordGetInfo(out var info))
				{
					throw new BassException();
				}
				return info;
			}
		}

		public static int RecordingBufferLength
		{
			get
			{
				return GetConfig(Configuration.RecordingBufferLength);
			}
			set
			{
				Configure(Configuration.RecordingBufferLength, value);
			}
		}

		public static int RecordingDeviceCount
		{
			get
			{
				int i;
				DeviceInfo Info;
				for (i = 0; RecordGetDeviceInfo(i, out Info); i++)
				{
				}
				return i;
			}
		}

		[DllImport("bass", EntryPoint = "BASS_Apply3D")]
		public static extern void Apply3D();

		[DllImport("bass", EntryPoint = "BASS_Get3DFactors")]
		public static extern bool Get3DFactors(ref float Distance, ref float RollOff, ref float Doppler);

		[DllImport("bass", EntryPoint = "BASS_Set3DFactors")]
		public static extern bool Set3DFactors(float Distance, float RollOff, float Doppler);

		[DllImport("bass", EntryPoint = "BASS_Get3DPosition")]
		public static extern bool Get3DPosition(ref Vector3D Position, ref Vector3D Velocity, ref Vector3D Front, ref Vector3D Top);

		[DllImport("bass", EntryPoint = "BASS_Set3DPosition")]
		public static extern bool Set3DPosition(Vector3D Position, Vector3D Velocity, Vector3D Front, Vector3D Top);

		[DllImport("bass", EntryPoint = "BASS_ChannelGet3DAttributes")]
		public static extern bool ChannelGet3DAttributes(int Handle, ref Mode3D Mode, ref float Min, ref float Max, ref int iAngle, ref int oAngle, ref float OutVol);

		[DllImport("bass", EntryPoint = "BASS_ChannelSet3DAttributes")]
		public static extern bool ChannelSet3DAttributes(int Handle, Mode3D Mode, float Min, float Max, int iAngle, int oAngle, float OutVol);

		[DllImport("bass", EntryPoint = "BASS_ChannelGet3DPosition")]
		public static extern bool ChannelGet3DPosition(int Handle, ref Vector3D Position, ref Vector3D Orientation, ref Vector3D Velocity);

		[DllImport("bass", EntryPoint = "BASS_ChannelSet3DPosition")]
		public static extern bool ChannelSet3DPosition(int Handle, Vector3D Position, Vector3D Orientation, Vector3D Velocity);

		[DllImport("bass", EntryPoint = "BASS_Update")]
		public static extern bool Update(int Length);

		[DllImport("bass")]
		private static extern float BASS_GetCPU();

		[DllImport("bass")]
		private static extern int BASS_GetVersion();

		[DllImport("bass")]
		private static extern Errors BASS_ErrorGetCode();

		[DllImport("bass", EntryPoint = "BASS_ChannelGetInfo")]
		public static extern bool ChannelGetInfo(int Handle, out ChannelInfo Info);

		public static ChannelInfo ChannelGetInfo(int Handle)
		{
			if (!ChannelGetInfo(Handle, out var Info))
			{
				throw new BassException();
			}
			return Info;
		}

		[DllImport("bass")]
		private static extern int BASS_ChannelSetDSP(int Handle, DSPProcedure Procedure, IntPtr User, int Priority);

		public static int ChannelSetDSP(int Handle, DSPProcedure Procedure, IntPtr User = default(IntPtr), int Priority = 0)
		{
			int num = BASS_ChannelSetDSP(Handle, Procedure, User, Priority);
			if (num != 0)
			{
				ChannelReferences.Add(Handle, num, Procedure);
			}
			return num;
		}

		[DllImport("bass")]
		private static extern bool BASS_ChannelRemoveDSP(int Handle, int DSP);

		public static bool ChannelRemoveDSP(int Handle, int DSP)
		{
			bool num = BASS_ChannelRemoveDSP(Handle, DSP);
			if (num)
			{
				ChannelReferences.Remove(Handle, DSP);
			}
			return num;
		}

		[DllImport("bass")]
		private static extern int BASS_ChannelSetSync(int Handle, SyncFlags Type, long Parameter, SyncProcedure Procedure, IntPtr User);

		public static int ChannelSetSync(int Handle, SyncFlags Type, long Parameter, SyncProcedure Procedure, IntPtr User = default(IntPtr))
		{
			SyncProcedure syncProcedure = (Type.HasFlag(SyncFlags.Onetime) ? ((SyncProcedure)delegate(int I, int Channel, int Data, IntPtr Ptr)
			{
				Procedure(I, Channel, Data, Ptr);
				ChannelReferences.Remove(Channel, I);
			}) : Procedure);
			int num = BASS_ChannelSetSync(Handle, Type, Parameter, syncProcedure, User);
			if (num != 0)
			{
				ChannelReferences.Add(Handle, num, syncProcedure);
			}
			return num;
		}

		[DllImport("bass")]
		private static extern bool BASS_ChannelRemoveSync(int Handle, int Sync);

		public static bool ChannelRemoveSync(int Handle, int Sync)
		{
			bool num = BASS_ChannelRemoveSync(Handle, Sync);
			if (num)
			{
				ChannelReferences.Remove(Handle, Sync);
			}
			return num;
		}

		[DllImport("bass", EntryPoint = "BASS_ChannelPlay")]
		public static extern bool ChannelPlay(int Handle, bool Restart = false);

		[DllImport("bass", EntryPoint = "BASS_ChannelPause")]
		public static extern bool ChannelPause(int Handle);

		[DllImport("bass", EntryPoint = "BASS_ChannelStop")]
		public static extern bool ChannelStop(int Handle);

		[DllImport("bass", EntryPoint = "BASS_ChannelLock")]
		public static extern bool ChannelLock(int Handle, bool Lock = true);

		[DllImport("bass", EntryPoint = "BASS_ChannelIsActive")]
		public static extern PlaybackState ChannelIsActive(int Handle);

		[DllImport("bass", EntryPoint = "BASS_ChannelSetLink")]
		public static extern bool ChannelSetLink(int Handle, int Channel);

		[DllImport("bass", EntryPoint = "BASS_ChannelRemoveLink")]
		public static extern bool ChannelRemoveLink(int Handle, int Channel);

		[DllImport("bass", EntryPoint = "BASS_ChannelFlags")]
		public static extern BassFlags ChannelFlags(int Handle, BassFlags Flags, BassFlags Mask);

		public static bool ChannelHasFlag(int Handle, BassFlags Flag)
		{
			return ChannelFlags(Handle, BassFlags.Default, BassFlags.Default).HasFlag(Flag);
		}

		public static bool ChannelAddFlag(int Handle, BassFlags Flag)
		{
			return ChannelFlags(Handle, Flag, Flag).HasFlag(Flag);
		}

		public static bool ChannelRemoveFlag(int Handle, BassFlags Flag)
		{
			return !ChannelFlags(Handle, BassFlags.Default, Flag).HasFlag(Flag);
		}

		[DllImport("bass", EntryPoint = "BASS_ChannelGetAttribute")]
		public static extern bool ChannelGetAttribute(int Handle, ChannelAttribute Attribute, out float Value);

		public static double ChannelGetAttribute(int Handle, ChannelAttribute Attribute)
		{
			ChannelGetAttribute(Handle, Attribute, out var Value);
			return Value;
		}

		[DllImport("bass", EntryPoint = "BASS_ChannelGetAttributeEx")]
		public static extern int ChannelGetAttribute(int Handle, ChannelAttribute Attribute, IntPtr Value, int Size);

		[DllImport("bass", EntryPoint = "BASS_ChannelSetAttribute")]
		public static extern bool ChannelSetAttribute(int Handle, ChannelAttribute Attribute, float Value);

		public static bool ChannelSetAttribute(int Handle, ChannelAttribute Attribute, double Value)
		{
			return ChannelSetAttribute(Handle, Attribute, (float)Value);
		}

		[DllImport("bass", EntryPoint = "BASS_ChannelSetAttributeEx")]
		public static extern bool ChannelSetAttribute(int Handle, ChannelAttribute Attribute, IntPtr Value, int Size);

		[DllImport("bass", EntryPoint = "BASS_ChannelGetTags")]
		public static extern IntPtr ChannelGetTags(int Handle, TagType Tags);

		[DllImport("bass", EntryPoint = "BASS_ChannelGetLength")]
		public static extern long ChannelGetLength(int Handle, PositionFlags Mode = PositionFlags.Bytes);

		[DllImport("bass", EntryPoint = "BASS_ChannelBytes2Seconds")]
		public static extern double ChannelBytes2Seconds(int Handle, long Position);

		[DllImport("bass", EntryPoint = "BASS_ChannelSeconds2Bytes")]
		public static extern long ChannelSeconds2Bytes(int Handle, double Position);

		[DllImport("bass", EntryPoint = "BASS_ChannelGetPosition")]
		public static extern long ChannelGetPosition(int Handle, PositionFlags Mode = PositionFlags.Bytes);

		[DllImport("bass", EntryPoint = "BASS_ChannelSetPosition")]
		public static extern bool ChannelSetPosition(int Handle, long Position, PositionFlags Mode = PositionFlags.Bytes);

		[DllImport("bass", EntryPoint = "BASS_ChannelIsSliding")]
		public static extern bool ChannelIsSliding(int Handle, ChannelAttribute Attribute);

		[DllImport("bass")]
		private static extern bool BASS_ChannelSlideAttribute(int Handle, int Attribute, float Value, int Time);

		public static bool ChannelSlideAttribute(int Handle, ChannelAttribute Attribute, float Value, int Time, bool Logarithmic = false)
		{
			int num = (int)Attribute;
			if (Logarithmic)
			{
				num |= 0x1000000;
			}
			return BASS_ChannelSlideAttribute(Handle, num, Value, Time);
		}

		[DllImport("bass", EntryPoint = "BASS_ChannelGetLevel")]
		public static extern int ChannelGetLevel(int Handle);

		public static int ChannelGetLevelLeft(int Handle)
		{
			int num = ChannelGetLevel(Handle);
			if (num == -1)
			{
				return -1;
			}
			return num.LoWord();
		}

		public static int ChannelGetLevelRight(int Handle)
		{
			int num = ChannelGetLevel(Handle);
			if (num == -1)
			{
				return -1;
			}
			return num.HiWord();
		}

		[DllImport("bass", EntryPoint = "BASS_ChannelGetLevelEx")]
		public static extern bool ChannelGetLevel(int Handle, [In][Out] float[] Levels, float Length, LevelRetrievalFlags Flags);

		public static float[] ChannelGetLevel(int Handle, float Length, LevelRetrievalFlags Flags)
		{
			int num = ChannelGetInfo(Handle).Channels;
			if (Flags.HasFlag(LevelRetrievalFlags.Mono))
			{
				num = 1;
			}
			else if (Flags.HasFlag(LevelRetrievalFlags.Stereo))
			{
				num = 2;
			}
			float[] array = new float[num];
			if (!ChannelGetLevel(Handle, array, Length, Flags))
			{
				return null;
			}
			return array;
		}

		[DllImport("bass", EntryPoint = "BASS_ChannelGetData")]
		public static extern int ChannelGetData(int Handle, IntPtr Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_ChannelGetData")]
		public static extern int ChannelGetData(int Handle, [In][Out] byte[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_ChannelGetData")]
		public static extern int ChannelGetData(int Handle, [In][Out] short[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_ChannelGetData")]
		public static extern int ChannelGetData(int Handle, [In][Out] int[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_ChannelGetData")]
		public static extern int ChannelGetData(int Handle, [In][Out] float[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_ChannelUpdate")]
		public static extern bool ChannelUpdate(int Handle, int Length);

		[DllImport("bass", EntryPoint = "BASS_SetConfig")]
		public static extern bool Configure(Configuration Option, bool NewValue);

		[DllImport("bass", EntryPoint = "BASS_SetConfig")]
		public static extern bool Configure(Configuration Option, int NewValue);

		[DllImport("bass", EntryPoint = "BASS_SetConfigPtr")]
		public static extern bool Configure(Configuration Option, IntPtr NewValue);

		[DllImport("bass", EntryPoint = "BASS_GetConfig")]
		public static extern int GetConfig(Configuration Option);

		[DllImport("bass", EntryPoint = "BASS_GetConfigPtr")]
		public static extern IntPtr GetConfigPtr(Configuration Option);

		public static bool GetConfigBool(Configuration Option)
		{
			int config = GetConfig(Option);
			if (config != -1)
			{
				return config != 0;
			}
			return false;
		}

		[DllImport("bass", CharSet = CharSet.Unicode)]
		private static extern int BASS_StreamCreateFile(bool mem, string file, long offset, long length, BassFlags flags);

		[DllImport("bass")]
		private static extern int BASS_StreamCreateFile(bool mem, IntPtr file, long offset, long length, BassFlags flags);

		public static int CreateStream(string File, long Offset = 0L, long Length = 0L, BassFlags Flags = BassFlags.Default)
		{
			return BASS_StreamCreateFile(mem: false, File, Offset, Length, Flags | BassFlags.Unicode);
		}

		public static int CreateStream(IntPtr Memory, long Offset, long Length, BassFlags Flags = BassFlags.Default)
		{
			return BASS_StreamCreateFile(mem: true, new IntPtr(Memory.ToInt64() + Offset), 0L, Length, Flags);
		}

		public static int CreateStream(byte[] Memory, long Offset, long Length, BassFlags Flags)
		{
			return GCPin.CreateStreamHelper((IntPtr Pointer) => CreateStream(Pointer, Offset, Length, Flags), Memory);
		}

		[DllImport("bass")]
		private static extern int BASS_StreamCreateFileUser(StreamSystem system, BassFlags flags, [In][Out] FileProcedures procs, IntPtr user);

		public static int CreateStream(StreamSystem System, BassFlags Flags, FileProcedures Procedures, IntPtr User = default(IntPtr))
		{
			int num = BASS_StreamCreateFileUser(System, Flags, Procedures, User);
			if (num != 0)
			{
				ChannelReferences.Add(num, 0, Procedures);
			}
			return num;
		}

		[DllImport("bass", CharSet = CharSet.Unicode)]
		private static extern int BASS_StreamCreateURL(string Url, int Offset, BassFlags Flags, DownloadProcedure Procedure, IntPtr User);

		public static int CreateStream(string Url, int Offset, BassFlags Flags, DownloadProcedure Procedure, IntPtr User = default(IntPtr))
		{
			int num = BASS_StreamCreateURL(Url, Offset, Flags | BassFlags.Unicode, Procedure, User);
			if (num != 0)
			{
				ChannelReferences.Add(num, 0, Procedure);
			}
			return num;
		}

		[DllImport("bass", EntryPoint = "BASS_Init")]
		public static extern bool Init(int Device = -1, int Frequency = 44100, DeviceInitFlags Flags = DeviceInitFlags.Default, IntPtr Win = default(IntPtr), IntPtr ClsID = default(IntPtr));

		[DllImport("bass", EntryPoint = "BASS_Start")]
		public static extern bool Start();

		[DllImport("bass", EntryPoint = "BASS_Pause")]
		public static extern bool Pause();

		[DllImport("bass", EntryPoint = "BASS_Stop")]
		public static extern bool Stop();

		[DllImport("bass", EntryPoint = "BASS_Free")]
		public static extern bool Free();

		[DllImport("bass", EntryPoint = "BASS_ChannelGetDevice")]
		public static extern int ChannelGetDevice(int Handle);

		[DllImport("bass", EntryPoint = "BASS_ChannelSetDevice")]
		public static extern bool ChannelSetDevice(int Handle, int Device);

		[DllImport("bass")]
		private static extern float BASS_GetVolume();

		[DllImport("bass")]
		private static extern bool BASS_SetVolume(float volume);

		[DllImport("bass")]
		private static extern int BASS_GetDevice();

		[DllImport("bass")]
		private static extern bool BASS_SetDevice(int Device);

		[DllImport("bass", EntryPoint = "BASS_GetDeviceInfo")]
		public static extern bool GetDeviceInfo(int Device, out DeviceInfo Info);

		public static DeviceInfo GetDeviceInfo(int Device)
		{
			if (!GetDeviceInfo(Device, out var Info))
			{
				throw new BassException();
			}
			return Info;
		}

		[DllImport("bass", EntryPoint = "BASS_GetInfo")]
		public static extern bool GetInfo(out BassInfo Info);

		[DllImport("bass", EntryPoint = "BASS_FXSetParameters")]
		public static extern bool FXSetParameters(int Handle, IntPtr Parameters);

		public static bool FXSetParameters(int Handle, IEffectParameter Parameters)
		{
			using GCPin gCPin = new GCPin(Parameters);
			return FXSetParameters(Handle, gCPin.Pointer);
		}

		[DllImport("bass", EntryPoint = "BASS_FXGetParameters")]
		public static extern bool FXGetParameters(int Handle, IntPtr Parameters);

		public static bool FXGetParameters(int Handle, IEffectParameter Parameters)
		{
			using GCPin gCPin = new GCPin(Parameters);
			return FXGetParameters(Handle, gCPin.Pointer);
		}

		[DllImport("bass", EntryPoint = "BASS_FXReset")]
		public static extern bool FXReset(int Handle);

		[DllImport("bass", EntryPoint = "BASS_ChannelSetFX")]
		public static extern int ChannelSetFX(int Handle, EffectType Type, int Priority);

		[DllImport("bass", EntryPoint = "BASS_ChannelRemoveFX")]
		public static extern bool ChannelRemoveFX(int Handle, int FX);

		[DllImport("bass", EntryPoint = "BASS_FXSetPriority")]
		public static extern bool FXSetPriority(int Handle, int Priority);

		[DllImport("bass", EntryPoint = "BASS_MusicFree")]
		public static extern bool MusicFree(int Handle);

		[DllImport("bass", CharSet = CharSet.Unicode)]
		private static extern int BASS_MusicLoad(bool mem, string file, long offset, int Length, BassFlags flags, int freq);

		[DllImport("bass")]
		private static extern int BASS_MusicLoad(bool mem, IntPtr file, long offset, int Length, BassFlags flags, int freq);

		public static int MusicLoad(string File, long Offset = 0L, int Length = 0, BassFlags Flags = BassFlags.Default, int Frequency = 0)
		{
			return BASS_MusicLoad(mem: false, File, Offset, Length, Flags | BassFlags.Unicode, Frequency);
		}

		public static int MusicLoad(IntPtr Memory, long Offset, int Length, BassFlags Flags = BassFlags.Default, int Frequency = 0)
		{
			return BASS_MusicLoad(mem: true, new IntPtr(Memory.ToInt64() + Offset), 0L, Length, Flags, Frequency);
		}

		public static int MusicLoad(byte[] Memory, long Offset, int Length, BassFlags Flags = BassFlags.Default, int Frequency = 0)
		{
			return GCPin.CreateStreamHelper((IntPtr Pointer) => MusicLoad(Pointer, Offset, Length, Flags), Memory);
		}

		[DllImport("bass")]
		private static extern IntPtr BASS_PluginGetInfo(int Handle);

		public static PluginInfo PluginGetInfo(int Handle)
		{
			return Marshal.PtrToStructure<PluginInfo>(BASS_PluginGetInfo(Handle));
		}

		[DllImport("bass", CharSet = CharSet.Unicode)]
		private static extern int BASS_PluginLoad(string FileName, BassFlags Flags = BassFlags.Unicode);

		public static int PluginLoad(string FilePath)
		{
			if (Path.HasExtension(FilePath))
			{
				return BASS_PluginLoad(FilePath);
			}
			string directoryName = Path.GetDirectoryName(FilePath);
			string fileName = Path.GetFileName(FilePath);
			string[] array = new string[3]
			{
				Path.Combine(directoryName, fileName + ".dll"),
				Path.Combine(directoryName, "lib" + fileName + ".so"),
				Path.Combine(directoryName, "lib" + fileName + ".dylib")
			};
			foreach (string text in array)
			{
				if (File.Exists(text))
				{
					int num = BASS_PluginLoad(text);
					if (num != 0 || LastError == Errors.Already)
					{
						return num;
					}
				}
			}
			return BASS_PluginLoad(FilePath);
		}

		[DllImport("bass", EntryPoint = "BASS_PluginFree")]
		public static extern bool PluginFree(int Handle);

		[DllImport("bass", EntryPoint = "BASS_RecordInit")]
		public static extern bool RecordInit(int Device = -1);

		[DllImport("bass", EntryPoint = "BASS_RecordFree")]
		public static extern bool RecordFree();

		[DllImport("bass")]
		private static extern int BASS_RecordStart(int freq, int chans, BassFlags flags, RecordProcedure proc, IntPtr User);

		public static int RecordStart(int Frequency, int Channels, BassFlags Flags, RecordProcedure Procedure, IntPtr User = default(IntPtr))
		{
			int num = BASS_RecordStart(Frequency, Channels, Flags, Procedure, User);
			if (num != 0)
			{
				ChannelReferences.Add(num, 0, Procedure);
			}
			return num;
		}

		public static int RecordStart(int Frequency, int Channels, BassFlags Flags, int Period, RecordProcedure Procedure, IntPtr User = default(IntPtr))
		{
			return RecordStart(Frequency, Channels, (BassFlags)BitHelper.MakeLong((short)Flags, (short)Period), Procedure, User);
		}

		[DllImport("bass")]
		private static extern int BASS_RecordGetDevice();

		[DllImport("bass")]
		private static extern bool BASS_RecordSetDevice(int Device);

		[DllImport("bass", EntryPoint = "BASS_RecordGetDeviceInfo")]
		public static extern bool RecordGetDeviceInfo(int Device, out DeviceInfo Info);

		public static DeviceInfo RecordGetDeviceInfo(int Device)
		{
			if (!RecordGetDeviceInfo(Device, out var Info))
			{
				throw new BassException();
			}
			return Info;
		}

		[DllImport("bass", EntryPoint = "BASS_RecordGetInfo")]
		public static extern bool RecordGetInfo(out RecordInfo info);

		[DllImport("bass", EntryPoint = "BASS_RecordGetInput")]
		public static extern int RecordGetInput(int Input, out float Volume);

		[DllImport("bass")]
		private static extern int BASS_RecordGetInput(int Input, IntPtr Volume);

		public static int RecordGetInput(int Input)
		{
			return BASS_RecordGetInput(Input, IntPtr.Zero);
		}

		[DllImport("bass")]
		private static extern IntPtr BASS_RecordGetInputName(int input);

		public static string RecordGetInputName(int Input)
		{
			IntPtr intPtr = BASS_RecordGetInputName(Input);
			if (intPtr == IntPtr.Zero)
			{
				return null;
			}
			return GetConfig(Configuration.UnicodeDeviceInformation) switch
			{
				-1 => Extensions.PtrToStringUtf8(intPtr), 
				0 => Marshal.PtrToStringAnsi(intPtr), 
				_ => Extensions.PtrToStringUtf8(intPtr), 
			};
		}

		[DllImport("bass", EntryPoint = "BASS_RecordSetInput")]
		public static extern bool RecordSetInput(int Input, InputFlags Setting, float Volume);

		public static int SampleGetChannel(int Sample, bool OnlyNew = false)
		{
			return SampleGetChannel(Sample, OnlyNew ? BassFlags.Byte : BassFlags.Default);
		}

		[DllImport("bass", EntryPoint = "BASS_SampleGetChannel")]
		public static extern int SampleGetChannel(int Sample, BassFlags Flags);

		[DllImport("bass", EntryPoint = "BASS_SampleFree")]
		public static extern bool SampleFree(int Handle);

		[DllImport("bass", EntryPoint = "BASS_SampleSetData")]
		public static extern bool SampleSetData(int Handle, IntPtr Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleSetData")]
		public static extern bool SampleSetData(int Handle, byte[] Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleSetData")]
		public static extern bool SampleSetData(int Handle, int[] Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleSetData")]
		public static extern bool SampleSetData(int Handle, short[] Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleSetData")]
		public static extern bool SampleSetData(int Handle, float[] Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleCreate")]
		public static extern int CreateSample(int Length, int Frequency, int Channels, int Max, BassFlags Flags);

		[DllImport("bass", EntryPoint = "BASS_SampleGetData")]
		public static extern bool SampleGetData(int Handle, IntPtr Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleGetData")]
		public static extern bool SampleGetData(int Handle, [In][Out] byte[] Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleGetData")]
		public static extern bool SampleGetData(int Handle, [In][Out] short[] Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleGetData")]
		public static extern bool SampleGetData(int Handle, [In][Out] int[] Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleGetData")]
		public static extern bool SampleGetData(int Handle, [In][Out] float[] Buffer);

		[DllImport("bass", EntryPoint = "BASS_SampleGetInfo")]
		public static extern bool SampleGetInfo(int Handle, [In][Out] SampleInfo Info);

		public static SampleInfo SampleGetInfo(int Handle)
		{
			SampleInfo sampleInfo = new SampleInfo();
			if (!SampleGetInfo(Handle, sampleInfo))
			{
				throw new BassException();
			}
			return sampleInfo;
		}

		[DllImport("bass", EntryPoint = "BASS_SampleSetInfo")]
		public static extern bool SampleSetInfo(int Handle, SampleInfo Info);

		[DllImport("bass")]
		private static extern int BASS_SampleGetChannels(int handle, [In][Out] int[] channels);

		public static int[] SampleGetChannels(int Handle)
		{
			int num = BASS_SampleGetChannels(Handle, null);
			if (num < 0)
			{
				return null;
			}
			int[] array = new int[num];
			num = BASS_SampleGetChannels(Handle, array);
			if (num >= 0)
			{
				return array;
			}
			return null;
		}

		[DllImport("bass", EntryPoint = "BASS_SampleStop")]
		public static extern bool SampleStop(int Handle);

		[DllImport("bass", CharSet = CharSet.Unicode)]
		private static extern int BASS_SampleLoad(bool mem, string file, long offset, int Length, int max, BassFlags flags);

		[DllImport("bass")]
		private static extern int BASS_SampleLoad(bool mem, IntPtr file, long offset, int Length, int max, BassFlags flags);

		public static int SampleLoad(string File, long Offset, int Length, int MaxNoOfPlaybacks, BassFlags Flags)
		{
			return BASS_SampleLoad(mem: false, File, Offset, Length, MaxNoOfPlaybacks, Flags | BassFlags.Unicode);
		}

		public static int SampleLoad(IntPtr Memory, long Offset, int Length, int MaxNoOfPlaybacks, BassFlags Flags)
		{
			return BASS_SampleLoad(mem: true, new IntPtr(Memory.ToInt64() + Offset), 0L, Length, MaxNoOfPlaybacks, Flags);
		}

		public static int SampleLoad(byte[] Memory, long Offset, int Length, int MaxNoOfPlaybacks, BassFlags Flags)
		{
			return GCPin.CreateStreamHelper((IntPtr Pointer) => SampleLoad(Pointer, Offset, Length, MaxNoOfPlaybacks, Flags), Memory);
		}

		[DllImport("bass", EntryPoint = "BASS_StreamGetFilePosition")]
		public static extern long StreamGetFilePosition(int Handle, FileStreamPosition Mode = FileStreamPosition.Current);

		[DllImport("bass")]
		private static extern int BASS_StreamCreate(int Frequency, int Channels, BassFlags Flags, StreamProcedure Procedure, IntPtr User);

		public static int CreateStream(int Frequency, int Channels, BassFlags Flags, StreamProcedure Procedure, IntPtr User = default(IntPtr))
		{
			int num = BASS_StreamCreate(Frequency, Channels, Flags, Procedure, User);
			if (num != 0)
			{
				ChannelReferences.Add(num, 0, Procedure);
			}
			return num;
		}

		[DllImport("bass")]
		private static extern int BASS_StreamCreate(int Frequency, int Channels, BassFlags Flags, IntPtr ProcedureType, IntPtr User = default(IntPtr));

		public static int CreateStream(int Frequency, int Channels, BassFlags Flags, StreamProcedureType ProcedureType)
		{
			return BASS_StreamCreate(Frequency, Channels, Flags, new IntPtr((int)ProcedureType), (IntPtr)0);
		}

		[DllImport("bass", EntryPoint = "BASS_StreamPutData")]
		public static extern int StreamPutData(int Handle, IntPtr Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutData")]
		public static extern int StreamPutData(int Handle, byte[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutData")]
		public static extern int StreamPutData(int Handle, short[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutData")]
		public static extern int StreamPutData(int Handle, int[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutData")]
		public static extern int StreamPutData(int Handle, float[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutFileData")]
		public static extern int StreamPutFileData(int Handle, IntPtr Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutFileData")]
		public static extern int StreamPutFileData(int Handle, byte[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutFileData")]
		public static extern int StreamPutFileData(int Handle, short[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutFileData")]
		public static extern int StreamPutFileData(int Handle, int[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamPutFileData")]
		public static extern int StreamPutFileData(int Handle, float[] Buffer, int Length);

		[DllImport("bass", EntryPoint = "BASS_StreamFree")]
		public static extern bool StreamFree(int Handle);
	}
	public struct BassInfo
	{
		private BASSInfoFlags flags;

		private int hwsize;

		private int hwfree;

		private int freesam;

		private int free3d;

		private int minrate;

		private int maxrate;

		private bool eax;

		private int minbuf;

		private int dsver;

		private int latency;

		private DeviceInitFlags initFlags;

		private int speakers;

		private int freq;

		public int TotalHardwareMemory => hwsize;

		public int FreeHardwareMemory => hwsize;

		public int FreeSampleSlots => freesam;

		public int Free3DSampleSlots => free3d;

		public int MinSampleRate => minrate;

		public int MaxSampleRate => maxrate;

		public bool EAXEnabled => eax;

		public int MinBufferLength => minbuf;

		public int DSVersion => dsver;

		public int Latency => latency;

		public DeviceInitFlags InitFlags => initFlags;

		public int SpeakerCount => speakers;

		public int SampleRate => freq;

		public bool IsCertified => flags.HasFlag(BASSInfoFlags.Certified);

		public bool Supports16BitSamples => flags.HasFlag(BASSInfoFlags.Secondary16Bit);

		public bool Supports8BitSamples => flags.HasFlag(BASSInfoFlags.Secondary8Bit);

		public bool SupportsContinuousRate => flags.HasFlag(BASSInfoFlags.ContinuousRate);

		public bool SupportsDirectSound => !flags.HasFlag(BASSInfoFlags.EmulatedDrivers);

		public bool SupportsMonoSamples => flags.HasFlag(BASSInfoFlags.Mono);

		public bool SupportsStereoSamples => flags.HasFlag(BASSInfoFlags.Stereo);
	}
	public struct ChannelInfo
	{
		private int freq;

		private int chans;

		private BassFlags flags;

		private ChannelType ctype;

		private int origres;

		private int plugin;

		private int sample;

		private IntPtr filename;

		public int Frequency => freq;

		public int Channels => chans;

		public BassFlags Flags => flags;

		public ChannelType ChannelType => ctype;

		public int Plugin => plugin;

		public int Sample => sample;

		public Resolution Resolution
		{
			get
			{
				if (flags.HasFlag(BassFlags.Byte))
				{
					return Resolution.Byte;
				}
				if (!flags.HasFlag(BassFlags.Float))
				{
					return Resolution.Short;
				}
				return Resolution.Float;
			}
		}

		public int OriginalResolution => origres;

		public string FileName
		{
			get
			{
				if (!(filename == IntPtr.Zero))
				{
					return Marshal.PtrToStringAnsi(filename);
				}
				return null;
			}
		}

		public bool IsDecodingChannel => flags.HasFlag(BassFlags.Decode);
	}
	public struct DeviceInfo
	{
		private IntPtr name;

		private IntPtr driver;

		private DeviceInfoFlags flags;

		public string Name => PtrToString(name);

		public string Driver => PtrToString(driver);

		public bool IsDefault => flags.HasFlag(DeviceInfoFlags.Default);

		public bool IsEnabled => flags.HasFlag(DeviceInfoFlags.Enabled);

		public bool IsInitialized => flags.HasFlag(DeviceInfoFlags.Initialized);

		public bool IsLoopback => flags.HasFlag(DeviceInfoFlags.Loopback);

		public DeviceType Type => (DeviceType)(flags & DeviceInfoFlags.TypeMask);

		private static string PtrToString(IntPtr ptr)
		{
			if (ptr == IntPtr.Zero)
			{
				return null;
			}
			return Bass.GetConfig(Configuration.UnicodeDeviceInformation) switch
			{
				-1 => Extensions.PtrToStringUtf8(ptr), 
				0 => Marshal.PtrToStringAnsi(ptr), 
				_ => Extensions.PtrToStringUtf8(ptr), 
			};
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	public class FileProcedures
	{
		public FileCloseProcedure Close;

		public FileLengthProcedure Length;

		public FileReadProcedure Read;

		public FileSeekProcedure Seek;
	}
	public struct PluginFormat
	{
		private ChannelType ctype;

		private IntPtr name;

		private IntPtr exts;

		public ChannelType ChannelType => ctype;

		public string Name
		{
			get
			{
				if (!(name == IntPtr.Zero))
				{
					return Marshal.PtrToStringAnsi(name);
				}
				return null;
			}
		}

		public string FileExtensions
		{
			get
			{
				if (!(exts == IntPtr.Zero))
				{
					return Marshal.PtrToStringAnsi(exts);
				}
				return null;
			}
		}
	}
	public struct PluginInfo
	{
		private int version;

		private int formatc;

		private IntPtr formats;

		public Version Version => Extensions.GetVersion(version);

		public PluginFormat[] Formats
		{
			get
			{
				PluginFormat[] array = new PluginFormat[formatc];
				int num = Marshal.SizeOf<PluginFormat>();
				int num2 = 0;
				while (num2 < formatc)
				{
					array[num2] = Marshal.PtrToStructure<PluginFormat>(formats);
					num2++;
					formats += num;
				}
				return array;
			}
		}
	}
	public struct RecordInfo
	{
		private RecordInfoFlags flags;

		private int formats;

		private int inputs;

		private bool singlein;

		private int freq;

		public RecordFormatFlags SupportedFormats => (RecordFormatFlags)(formats & 0xFFFFFF);

		public int Inputs => inputs;

		public bool SingleInput => singlein;

		public int Frequency => freq;

		public int Channels => formats >> 24;

		public bool IsCertified => flags.HasFlag(RecordInfoFlags.Certified);

		public bool SupportsDirectSound => flags.HasFlag(RecordInfoFlags.EmulatedDrivers);
	}
	[StructLayout(LayoutKind.Sequential)]
	public class SampleInfo
	{
		public int Frequency = 44100;

		public float Volume = 1f;

		public float Pan;

		public BassFlags Flags;

		public int Length;

		public int Max = 1;

		public int OriginalResolution;

		public int Channels = 2;

		public int MinGap;

		public Mode3D Mode3D;

		public float MinDistance;

		public float MaxDistance;

		public int InsideAngle;

		public int OutsideAngle;

		public float OutsideVolume = 1f;

		public VAMMode VAM = VAMMode.Hardware;

		public int Priority;
	}
	[StructLayout(LayoutKind.Sequential)]
	public class Vector3D
	{
		public float X;

		public float Y;

		public float Z;

		public Vector3D()
		{
		}

		public Vector3D(float X, float Y, float Z)
		{
			this.X = X;
			this.Y = Y;
			this.Z = Z;
		}

		public override string ToString()
		{
			return $"({X}, {Y}, {Z})";
		}
	}
	public static class BitHelper
	{
		public static long HiDword(this long DWord)
		{
			return DWord >>> 32;
		}

		public static long LoDword(this long DWord)
		{
			return DWord & 0xFFFFFFFFu;
		}

		public static int HiWord(this int DWord)
		{
			return DWord >>> 16;
		}

		public static int LoWord(this int DWord)
		{
			return DWord & 0xFFFF;
		}

		public static byte HiByte(this short Word)
		{
			return (byte)(Word >> 8);
		}

		public static byte LoByte(this short Word)
		{
			return (byte)((uint)Word & 0xFFu);
		}

		public static short MakeWord(byte Low, byte High)
		{
			return (short)(Low | (ushort)(High << 8));
		}

		public static int MakeLong(short Low, short High)
		{
			return (ushort)Low | (High << 16);
		}
	}
	public enum Errors
	{
		Unknown = -1,
		OK = 0,
		Memory = 1,
		FileOpen = 2,
		Driver = 3,
		BufferLost = 4,
		Handle = 5,
		SampleFormat = 6,
		Position = 7,
		Init = 8,
		Start = 9,
		[Obsolete("Use SSL instead.")]
		SLL = 10,
		SSL = 10,
		NoCD = 12,
		CDTrack = 13,
		Already = 14,
		NotPaused = 16,
		NotAudioTrack = 17,
		NoChannel = 18,
		Type = 19,
		Parameter = 20,
		No3D = 21,
		NoEAX = 22,
		Device = 23,
		NotPlaying = 24,
		SampleRate = 25,
		NotFile = 27,
		NoHW = 29,
		Empty = 31,
		NoInternet = 32,
		Create = 33,
		NoFX = 34,
		Playing = 35,
		NotAvailable = 37,
		Decode = 38,
		DirectX = 39,
		Timeout = 40,
		FileFormat = 41,
		Speaker = 42,
		Version = 43,
		Codec = 44,
		Ended = 45,
		Busy = 46,
		Unstreamable = 47,
		WmaLicense = 1000,
		WM9 = 1001,
		WmaAccesDenied = 1002,
		WmaCodec = 1003,
		WmaIndividual = 1004,
		Wasapi = 5000,
		AcmCancel = 2000,
		CastDenied = 2100,
		Mp4NoStream = 6000
	}
	public static class Extensions
	{
		private static bool? _floatable;

		public static bool SupportsFloatingPoint
		{
			get
			{
				if (_floatable.HasValue)
				{
					return _floatable.Value;
				}
				int num = Bass.CreateStream(44100, 1, BassFlags.Float, StreamProcedureType.Dummy);
				_floatable = num != 0;
				if (_floatable.Value)
				{
					Bass.StreamFree(num);
				}
				return _floatable.Value;
			}
		}

		public static StreamProcedure SilenceStreamProcedure { get; } = delegate(int Handle, IntPtr Buffer, int Length, IntPtr User)
		{
			for (int i = 0; i < Length; i++)
			{
				Marshal.WriteByte(Buffer, i, 0);
			}
			return Length;
		};


		public static T Clip<T>(this T Item, T MinValue, T MaxValue) where T : IComparable<T>
		{
			if (Item.CompareTo(MaxValue) > 0)
			{
				return MaxValue;
			}
			if (Item.CompareTo(MinValue) >= 0)
			{
				return Item;
			}
			return MinValue;
		}

		public static BassFlags ToBassFlag(this Resolution Resolution)
		{
			return Resolution switch
			{
				Resolution.Byte => BassFlags.Byte, 
				Resolution.Float => BassFlags.Float, 
				_ => BassFlags.Default, 
			};
		}

		public static BassFlags SpeakerN(int N)
		{
			return (BassFlags)(N << 24);
		}

		public static Version GetVersion(int Num)
		{
			return new Version((Num >> 24) & 0xFF, (Num >> 16) & 0xFF, (Num >> 8) & 0xFF, Num & 0xFF);
		}

		public static string ChannelCountToString(int Channels)
		{
			switch (Channels)
			{
			case 1:
				return "Mono";
			case 2:
				return "Stereo";
			case 3:
				return "2.1";
			case 4:
				return "Quad";
			case 5:
				return "4.1";
			case 6:
				return "5.1";
			case 7:
				return "6.1";
			default:
				if (Channels < 1)
				{
					throw new ArgumentException("Channels must be greater than Zero.");
				}
				return Channels + " Channels";
			}
		}

		public static string[] ExtractMultiStringAnsi(IntPtr Ptr)
		{
			List<string> list = new List<string>();
			while (true)
			{
				string text = ((Ptr == IntPtr.Zero) ? null : Marshal.PtrToStringAnsi(Ptr));
				if (string.IsNullOrEmpty(text))
				{
					break;
				}
				list.Add(text);
				Ptr += text.Length + 1;
			}
			return list.ToArray();
		}

		public static string[] ExtractMultiStringUtf8(IntPtr Ptr)
		{
			List<string> list = new List<string>();
			while (true)
			{
				int Size;
				string text = PtrToStringUtf8(Ptr, out Size);
				if (string.IsNullOrEmpty(text))
				{
					break;
				}
				list.Add(text);
				Ptr += Size + 1;
			}
			return list.ToArray();
		}

		private unsafe static string PtrToStringUtf8(IntPtr Ptr, out int Size)
		{
			Size = 0;
			byte* ptr = (byte*)Ptr.ToPointer();
			if (Ptr == IntPtr.Zero || *ptr == 0)
			{
				return null;
			}
			while (ptr[Size] != 0)
			{
				Size++;
			}
			byte[] array = new byte[Size];
			Marshal.Copy(Ptr, array, 0, Size);
			return Encoding.UTF8.GetString(array, 0, array.Length);
		}

		public static string PtrToStringUtf8(IntPtr Ptr)
		{
			int Size;
			return PtrToStringUtf8(Ptr, out Size);
		}

		public static FileProcedures StreamFileProcedures(Stream InputStream)
		{
			return new StreamFileProcedures(InputStream);
		}

		public static void ApplyOn<T>(this Effect<T> Effect, MediaPlayer Player, int Priority = 0) where T : class, IEffectParameter, new()
		{
			Effect.ApplyOn(Player.Handle, Priority);
			Player.MediaLoaded += delegate(int NewHandle)
			{
				Effect.Dispose();
				Effect.ApplyOn(NewHandle, Priority);
			};
		}
	}
	public interface IEffectParameter
	{
		EffectType FXType { get; }
	}
	public class MediaPlayer : INotifyPropertyChanged, IDisposable
	{
		private readonly SynchronizationContext _syncContext;

		private int _handle;

		private bool _restartOnNextPlayback;

		private double _freq = 44100.0;

		private double _pan;

		private int _dev = -1;

		private double _vol = 0.5;

		private bool _loop;

		private string _title = "";

		private string _artist = "";

		private string _album = "";

		protected internal int Handle
		{
			get
			{
				return _handle;
			}
			private set
			{
				if (!Bass.ChannelGetInfo(value, out var _))
				{
					throw new ArgumentException("Invalid Channel Handle: " + value);
				}
				_handle = value;
				Bass.ChannelSetSync(Handle, SyncFlags.Free, 0L, GetSyncProcedure(delegate
				{
					this.Disposed?.Invoke(this, EventArgs.Empty);
				}), (IntPtr)0);
				Bass.ChannelSetSync(Handle, SyncFlags.Stop, 0L, GetSyncProcedure(delegate
				{
					this.MediaFailed?.Invoke(this, EventArgs.Empty);
				}), (IntPtr)0);
				Bass.ChannelSetSync(Handle, SyncFlags.End, 0L, GetSyncProcedure(delegate
				{
					try
					{
						if (!Bass.ChannelHasFlag(Handle, BassFlags.Loop))
						{
							this.MediaEnded?.Invoke(this, EventArgs.Empty);
						}
					}
					finally
					{
						OnStateChanged();
					}
				}), (IntPtr)0);
			}
		}

		public double Frequency
		{
			get
			{
				return _freq;
			}
			set
			{
				if (Bass.ChannelSetAttribute(Handle, ChannelAttribute.Frequency, value))
				{
					_freq = value;
					OnPropertyChanged("Frequency");
				}
			}
		}

		public double Balance
		{
			get
			{
				return _pan;
			}
			set
			{
				if (Bass.ChannelSetAttribute(Handle, ChannelAttribute.Pan, value))
				{
					_pan = value;
					OnPropertyChanged("Balance");
				}
			}
		}

		public int Device
		{
			get
			{
				return _dev = ((_dev == -1) ? Bass.ChannelGetDevice(Handle) : _dev);
			}
			set
			{
				if ((Bass.GetDeviceInfo(value).IsInitialized || Bass.Init(value, 44100, DeviceInitFlags.Default, (IntPtr)0, (IntPtr)0)) && Bass.ChannelSetDevice(Handle, value))
				{
					_dev = value;
					OnPropertyChanged("Device");
				}
			}
		}

		public double Volume
		{
			get
			{
				return _vol;
			}
			set
			{
				if (Bass.ChannelSetAttribute(Handle, ChannelAttribute.Volume, value))
				{
					_vol = value;
					OnPropertyChanged("Volume");
				}
			}
		}

		public bool Loop
		{
			get
			{
				return _loop;
			}
			set
			{
				if (!(value ? (!Bass.ChannelAddFlag(Handle, BassFlags.Loop)) : (!Bass.ChannelRemoveFlag(Handle, BassFlags.Loop))))
				{
					_loop = value;
					OnPropertyChanged("Loop");
				}
			}
		}

		public string Title
		{
			get
			{
				return _title;
			}
			private set
			{
				_title = value;
				OnPropertyChanged("Title");
			}
		}

		public string Artist
		{
			get
			{
				return _artist;
			}
			private set
			{
				_artist = value;
				OnPropertyChanged("Artist");
			}
		}

		public string Album
		{
			get
			{
				return _album;
			}
			private set
			{
				_album = value;
				OnPropertyChanged("Album");
			}
		}

		public PlaybackState State
		{
			get
			{
				if (Handle != 0)
				{
					return Bass.ChannelIsActive(Handle);
				}
				return PlaybackState.Stopped;
			}
		}

		public TimeSpan Duration => TimeSpan.FromSeconds(Bass.ChannelBytes2Seconds(Handle, Bass.ChannelGetLength(Handle)));

		public TimeSpan Position
		{
			get
			{
				return TimeSpan.FromSeconds(Bass.ChannelBytes2Seconds(Handle, Bass.ChannelGetPosition(Handle)));
			}
			set
			{
				Bass.ChannelSetPosition(Handle, Bass.ChannelSeconds2Bytes(Handle, value.TotalSeconds));
			}
		}

		public event EventHandler Disposed;

		public event EventHandler MediaEnded;

		public event EventHandler MediaFailed;

		public event Action<int> MediaLoaded;

		public event PropertyChangedEventHandler PropertyChanged;

		private SyncProcedure GetSyncProcedure(Action Handler)
		{
			return delegate
			{
				if (Handler != null)
				{
					if (_syncContext == null)
					{
						Handler();
					}
					else
					{
						_syncContext.Post(delegate
						{
							Handler();
						}, null);
					}
				}
			};
		}

		static MediaPlayer()
		{
			int currentDevice = Bass.CurrentDevice;
			if (currentDevice == -1 || !Bass.GetDeviceInfo(Bass.CurrentDevice).IsInitialized)
			{
				Bass.Init(currentDevice, 44100, DeviceInitFlags.Default, (IntPtr)0, (IntPtr)0);
			}
		}

		public MediaPlayer()
		{
			_syncContext = SynchronizationContext.Current;
		}

		protected virtual int OnLoad(string FileName)
		{
			return Bass.CreateStream(FileName, 0L, 0L);
		}

		public bool Play()
		{
			try
			{
				bool num = Bass.ChannelPlay(Handle, _restartOnNextPlayback);
				if (num)
				{
					_restartOnNextPlayback = false;
				}
				return num;
			}
			finally
			{
				OnStateChanged();
			}
		}

		public bool Pause()
		{
			try
			{
				return Bass.ChannelPause(Handle);
			}
			finally
			{
				OnStateChanged();
			}
		}

		public bool Stop()
		{
			try
			{
				_restartOnNextPlayback = true;
				return Bass.ChannelStop(Handle);
			}
			finally
			{
				OnStateChanged();
			}
		}

		public async Task<bool> LoadAsync(string FileName)
		{
			try
			{
				if (Handle != 0)
				{
					Bass.StreamFree(Handle);
				}
			}
			catch
			{
			}
			if (_dev != -1)
			{
				Bass.CurrentDevice = _dev;
			}
			int currentDevice = Bass.CurrentDevice;
			if (currentDevice == -1 || !Bass.GetDeviceInfo(Bass.CurrentDevice).IsInitialized)
			{
				Bass.Init(currentDevice, 44100, DeviceInitFlags.Default, (IntPtr)0, (IntPtr)0);
			}
			int num = await Task.Run(() => OnLoad(FileName));
			if (num == 0)
			{
				return false;
			}
			Handle = num;
			TagReader tagReader = TagReader.Read(Handle);
			Title = ((!string.IsNullOrWhiteSpace(tagReader.Title)) ? tagReader.Title : Path.GetFileNameWithoutExtension(FileName));
			Artist = tagReader.Artist;
			Album = tagReader.Album;
			InitProperties();
			this.MediaLoaded?.Invoke(num);
			OnPropertyChanged("");
			return true;
		}

		public virtual void Dispose()
		{
			try
			{
				if (Bass.StreamFree(Handle))
				{
					_handle = 0;
				}
			}
			finally
			{
				OnStateChanged();
			}
		}

		protected virtual void InitProperties()
		{
			Frequency = _freq;
			Balance = _pan;
			Volume = _vol;
			Loop = _loop;
		}

		private void OnStateChanged()
		{
			OnPropertyChanged("State");
		}

		protected virtual void OnPropertyChanged([CallerMemberName] string PropertyName = null)
		{
			Action f = delegate
			{
				this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName));
			};
			if (_syncContext == null)
			{
				f();
				return;
			}
			_syncContext.Post(delegate
			{
				f();
			}, null);
		}
	}
	public static class ChannelReferences
	{
		private static readonly ConcurrentDictionary<Tuple<int, int>, object> Procedures = new ConcurrentDictionary<Tuple<int, int>, object>();

		private static readonly SyncProcedure Freeproc = Callback;

		public static void Add(int Handle, int SpecificHandle, object proc)
		{
			if (proc != null && !proc.Equals(Freeproc))
			{
				Tuple<int, int> key = Tuple.Create(Handle, SpecificHandle);
				bool num = Procedures.ContainsKey(key);
				if (Freeproc != null && Procedures.All((KeyValuePair<Tuple<int, int>, object> pair) => pair.Key.Item1 != Handle))
				{
					Bass.ChannelSetSync(Handle, SyncFlags.Free, 0L, Freeproc, (IntPtr)0);
				}
				if (num)
				{
					Procedures[key] = proc;
				}
				else
				{
					Procedures.TryAdd(key, proc);
				}
			}
		}

		public static void Remove(int Handle, int SpecialHandle)
		{
			Tuple<int, int> key = Tuple.Create(Handle, SpecialHandle);
			Procedures.TryRemove(key, out var _);
		}

		private static void Callback(int Handle, int Channel, int Data, IntPtr User)
		{
			Tuple<int, int>[] array = (from Pair in Procedures
				where Pair.Key.Item1 == Channel
				select Pair.Key).ToArray();
			foreach (Tuple<int, int> key in array)
			{
				Procedures.TryRemove(key, out var _);
			}
		}
	}
	public enum Resolution
	{
		Short,
		Byte,
		Float
	}
	internal class StreamFileProcedures : FileProcedures
	{
		private readonly Stream _stream;

		private byte[] b;

		public StreamFileProcedures(Stream InputStream)
		{
			_stream = InputStream;
			if (!_stream.CanRead)
			{
				throw new ArgumentException("Provide a readable stream", "InputStream");
			}
			Close = delegate
			{
				_stream.Dispose();
			};
			Length = (IntPtr M) => _stream.Length;
			Read = ReadProc;
			Seek = SeekProc;
		}

		private int ReadProc(IntPtr Buffer, int Length, IntPtr User)
		{
			try
			{
				if (b == null || b.Length < Length)
				{
					b = new byte[Length];
				}
				int num = _stream.Read(b, 0, Length);
				Marshal.Copy(b, 0, Buffer, num);
				return num;
			}
			catch
			{
				return 0;
			}
		}

		private bool SeekProc(long Offset, IntPtr User)
		{
			if (!_stream.CanSeek)
			{
				return false;
			}
			try
			{
				_stream.Seek(Offset, SeekOrigin.Current);
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	public class ID3v2Tag
	{
		private enum TextEncodings
		{
			Ascii,
			Utf16,
			Utf16Be,
			Utf8
		}

		private IntPtr _ptr;

		private readonly Version _versionInfo;

		public Dictionary<string, string> TextFrames { get; } = new Dictionary<string, string>();


		public List<PictureTag> PictureFrames { get; } = new List<PictureTag>();


		public ID3v2Tag(IntPtr Pointer)
		{
			_ptr = Pointer;
			if (ReadText(3, TextEncodings.Ascii) != "ID3")
			{
				throw new DataMisalignedException("ID3v2 info not found");
			}
			_versionInfo = new Version(2, ReadByte(), ReadByte());
			_ptr += 1;
			ReadAllFrames(ReadSize());
		}

		public ID3v2Tag(int Channel)
			: this(Bass.ChannelGetTags(Channel, TagType.ID3v2))
		{
		}

		private void ReadAllFrames(int Length)
		{
			int num = ((_versionInfo.Minor == 2) ? 3 : 4);
			while (Length > 10)
			{
				if (ReadByte() == 0)
				{
					Length--;
					continue;
				}
				_ptr -= 1;
				string frameID = ReadText(num, TextEncodings.Ascii);
				int val = Convert.ToInt32(ReadUInt(num));
				if (num == 4)
				{
					ReadUInt(2);
				}
				val = Math.Min(val, Length - 10);
				if (!AddFrame(frameID, val))
				{
					_ptr += val;
				}
				Length -= val + 10;
			}
		}

		private bool AddFrame(string FrameID, int Length)
		{
			if (FrameID == null || !IsValidFrameID(FrameID))
			{
				return false;
			}
			if (FrameID[0] == 'T' || FrameID[0] == 'W')
			{
				TextEncodings textEncodings;
				if (FrameID[0] == 'W')
				{
					textEncodings = TextEncodings.Ascii;
				}
				else
				{
					textEncodings = (TextEncodings)ReadByte();
					Length--;
					if (!Enum.IsDefined(typeof(TextEncodings), textEncodings))
					{
						return false;
					}
				}
				string value = ReadText(Length, textEncodings);
				AddTextFrame(FrameID, value);
				return true;
			}
			switch (FrameID)
			{
			case "POPM":
			{
				ReadText(Length, TextEncodings.Ascii, ref Length, DetectEncoding: true);
				string value2 = ReadByte().ToString();
				if (--Length > 8)
				{
					return false;
				}
				_ptr += Length;
				AddTextFrame("POPM", value2);
				return true;
			}
			case "COM":
			case "COMM":
			{
				TextEncodings textEncodings3 = (TextEncodings)ReadByte();
				Length--;
				if (!Enum.IsDefined(typeof(TextEncodings), textEncodings3))
				{
					return false;
				}
				_ptr += 3;
				Length -= 3;
				ReadText(Length, textEncodings3, ref Length, DetectEncoding: true);
				AddTextFrame("COMM", ReadText(Length, textEncodings3));
				return true;
			}
			case "APIC":
			{
				TextEncodings textEncodings2 = (TextEncodings)ReadByte();
				Length--;
				if (!Enum.IsDefined(typeof(TextEncodings), textEncodings2))
				{
					return false;
				}
				string mimeType = ReadText(Length, TextEncodings.Ascii, ref Length, DetectEncoding: true);
				PictureTypes pictureType = (PictureTypes)ReadByte();
				Length--;
				ReadText(Length, textEncodings2, ref Length, DetectEncoding: true);
				byte[] array = new byte[Length];
				Read(array, 0, Length);
				PictureFrames.Add(new PictureTag
				{
					Data = array,
					MimeType = mimeType,
					PictureType = pictureType
				});
				return true;
			}
			default:
				return false;
			}
		}

		private static bool IsValidFrameID(string FrameID)
		{
			if (FrameID == null || (FrameID.Length != 3 && FrameID.Length != 4))
			{
				return false;
			}
			return FrameID.Cast<char>().All((char ch) => char.IsUpper(ch) || char.IsDigit(ch));
		}

		private void AddTextFrame(string Key, string Value)
		{
			if (TextFrames.ContainsKey(Key))
			{
				Dictionary<string, string> textFrames = TextFrames;
				textFrames[Key] = textFrames[Key] + ";" + Value;
			}
			else
			{
				TextFrames.Add(Key, Value);
			}
		}

		private string ReadText(int MaxLength, TextEncodings TEncoding)
		{
			int ReadedLength = 0;
			return ReadText(MaxLength, TEncoding, ref ReadedLength, DetectEncoding: false);
		}

		private string ReadText(int MaxLength, TextEncodings TEncoding, ref int ReadedLength, bool DetectEncoding)
		{
			if (MaxLength <= 0)
			{
				return "";
			}
			int num = 0;
			using MemoryStream memoryStream = new MemoryStream();
			if (DetectEncoding && MaxLength >= 3)
			{
				byte[] array = new byte[3];
				Read(array, 0, array.Length);
				if (array[0] == byte.MaxValue && array[1] == 254)
				{
					TEncoding = TextEncodings.Utf16;
					_ptr -= 1;
					num++;
					MaxLength -= 2;
				}
				else if (array[0] == 254 && array[1] == byte.MaxValue)
				{
					TEncoding = TextEncodings.Utf16Be;
					_ptr -= 1;
					num++;
					MaxLength -= 2;
				}
				else if (array[0] == 239 && array[1] == 187 && array[2] == 191)
				{
					TEncoding = TextEncodings.Utf8;
					MaxLength -= 3;
				}
				_ptr -= 3;
				num += 3;
			}
			bool flag = TEncoding == TextEncodings.Utf16 || TEncoding == TextEncodings.Utf16Be;
			while (MaxLength > 0)
			{
				byte b = ReadByte();
				if (b != 0)
				{
					memoryStream.WriteByte(b);
				}
				else
				{
					if (!flag)
					{
						break;
					}
					byte b2 = ReadByte();
					if (b2 == 0)
					{
						break;
					}
					memoryStream.WriteByte(b);
					memoryStream.WriteByte(b2);
					MaxLength--;
				}
				MaxLength--;
			}
			if (MaxLength < 0)
			{
				_ptr += MaxLength;
			}
			ReadedLength -= num;
			return GetEncoding(TEncoding).GetString(memoryStream.ToArray(), 0, (int)memoryStream.Length);
		}

		private byte ReadByte()
		{
			byte[] array = new byte[1];
			Read(array, 0, 1);
			return array[0];
		}

		private uint ReadUInt(int Length)
		{
			if (Length > 4 || Length < 1)
			{
				throw new ArgumentOutOfRangeException("Length", "ReadUInt method can read 1-4 byte(s)");
			}
			byte[] array = new byte[Length];
			byte[] array2 = new byte[4];
			Read(array, 0, Length);
			array.CopyTo(array2, 4 - array.Length);
			Array.Reverse((Array)array2);
			return BitConverter.ToUInt32(array2, 0);
		}

		private int ReadSize()
		{
			return ReadByte() * 2097152 + ReadByte() * 16384 + ReadByte() * 128 + ReadByte();
		}

		private static Encoding GetEncoding(TextEncodings TEncoding)
		{
			return TEncoding switch
			{
				TextEncodings.Utf16 => Encoding.Unicode, 
				TextEncodings.Utf16Be => Encoding.GetEncoding("UTF-16BE"), 
				_ => Encoding.UTF8, 
			};
		}

		private void Read(byte[] Buffer, int Offset, int Count)
		{
			Marshal.Copy(_ptr, Buffer, Offset, Count);
			_ptr += Count;
		}
	}
	public class PictureTag
	{
		public string MimeType;

		public PictureTypes PictureType;

		public byte[] Data;
	}
	public enum PictureTypes
	{
		Other,
		FileIcon,
		OtherFileIcon,
		FrontCover,
		BackCover,
		LeafletPage,
		Media,
		Soloist,
		Artist,
		Conductor,
		Band,
		Composer,
		Lyricist,
		RecordingLocation,
		DuringRecording,
		DuringPerformance,
		Movie,
		ABrightColouredFish,
		Illustration,
		BandLogo,
		PublisherLogo
	}
	internal static class LookupTables
	{
		public static readonly TagProperties<IEnumerable<string>> Ape = new TagProperties<IEnumerable<string>>
		{
			Title = new string[1] { "title" },
			Artist = new string[1] { "artist" },
			Album = new string[1] { "album" },
			AlbumArtist = new string[1] { "album artist" },
			Track = new string[1] { "track" },
			Year = new string[1] { "year" },
			Genre = new string[1] { "genre" },
			Copyright = new string[1] { "copyright" },
			Encoder = new string[1] { "encodedby" },
			Publisher = new string[1] { "label" },
			Composer = new string[1] { "composer" },
			Conductor = new string[1] { "conductor" },
			Lyricist = new string[1] { "lyricist" },
			Remixer = new string[1] { "remixer" },
			Producer = new string[1] { "producer" },
			Comment = new string[1] { "comment" },
			Grouping = new string[1] { "grouping" },
			Mood = new string[1] { "mood" },
			Rating = new string[1] { "rating" },
			ISRC = new string[1] { "isrc" },
			BPM = new string[1] { "bpm" }
		};

		public static readonly TagProperties<IEnumerable<string>> Ogg = new TagProperties<IEnumerable<string>>
		{
			Title = new string[1] { "title" },
			Artist = new string[1] { "artist" },
			Album = new string[1] { "album" },
			AlbumArtist = new string[1] { "albumartist" },
			Track = new string[1] { "tracknumber" },
			Year = new string[1] { "date" },
			Genre = new string[1] { "genre" },
			Copyright = new string[1] { "copyright" },
			Encoder = new string[1] { "encodedby" },
			Publisher = new string[1] { "label" },
			Composer = new string[1] { "composer" },
			Conductor = new string[1] { "conductor" },
			Lyricist = new string[1] { "lyricist" },
			Remixer = new string[1] { "remixer" },
			Producer = new string[1] { "producer" },
			Comment = new string[1] { "comment" },
			Grouping = new string[1] { "grouping" },
			Mood = new string[1] { "mood" },
			Rating = new string[1] { "rating" },
			ISRC = new string[1] { "isrc" },
			BPM = new string[1] { "bpm" }
		};

		public static readonly TagProperties<IEnumerable<string>> RiffInfo = new TagProperties<IEnumerable<string>>
		{
			Title = new string[1] { "inam" },
			Artist = new string[1] { "iart" },
			Album = new string[1] { "iprd" },
			AlbumArtist = new string[1] { "isbj" },
			Track = new string[2] { "itrk", "iprt" },
			Year = new string[1] { "icrd" },
			Genre = new string[1] { "ignr" },
			Copyright = new string[1] { "icop" },
			Encoder = new string[1] { "isft" },
			Publisher = new string[1] { "icms" },
			Composer = new string[1] { "ieng" },
			Conductor = new string[1] { "itch" },
			Lyricist = new string[1] { "iwri" },
			Remixer = new string[1] { "iedt" },
			Producer = new string[1] { "ipro" },
			Comment = new string[1] { "icmt" },
			Grouping = new string[1] { "isrf" },
			Mood = new string[1] { "ikey" },
			Rating = new string[1] { "ishp" },
			ISRC = new string[1] { "isrc" },
			BPM = new string[1] { "ibpm" }
		};

		public static readonly TagProperties<IEnumerable<string>> Mp4 = new TagProperties<IEnumerable<string>>
		{
			Title = new string[1] { "©nam" },
			Artist = new string[1] { "©art" },
			Album = new string[1] { "©alb" },
			AlbumArtist = new string[1] { "aart" },
			Track = new string[1] { "trkn" },
			Year = new string[1] { "©day" },
			Genre = new string[1] { "©gen" },
			Copyright = new string[1] { "cprt" },
			Encoder = new string[1] { "©too" },
			Composer = new string[1] { "©wrt" },
			Comment = new string[1] { "©cmt" },
			Grouping = new string[1] { "©grp" },
			Rating = new string[1] { "rtng" }
		};

		public static readonly TagProperties<IEnumerable<string>> Id3v2 = new TagProperties<IEnumerable<string>>
		{
			Title = new string[2] { "TIT2", "TT2" },
			Artist = new string[2] { "TPE1", "TP1" },
			Album = new string[2] { "TALB", "TAL" },
			AlbumArtist = new string[2] { "TPE2", "TP2" },
			Subtitle = new string[2] { "TIT3", "TT3" },
			Track = new string[2] { "TRK", "TRCK" },
			Year = new string[2] { "TYER", "TYE" },
			Genre = new string[2] { "TCON", "TCO" },
			Copyright = new string[2] { "TCOP", "TCR" },
			Encoder = new string[2] { "TENC", "TEN" },
			Publisher = new string[2] { "TPUB", "TPB" },
			Composer = new string[2] { "TCOM", "TCM" },
			Conductor = new string[2] { "TPE3", "TP3" },
			Lyricist = new string[2] { "TEXT", "TXT" },
			Remixer = new string[2] { "TPE4", "TP4" },
			Producer = new string[1] { "TIPL" },
			Comment = new string[2] { "COMM", "COM" },
			Grouping = new string[2] { "TIT1", "TT1" },
			Mood = new string[1] { "TMOO" },
			Rating = new string[1] { "POPM" },
			ISRC = new string[1] { "TSCR" },
			BPM = new string[2] { "TBPM", "TBP" }
		};
	}
	public class TagProperties<T>
	{
		public T Title { get; set; }

		public T Artist { get; set; }

		public T Album { get; set; }

		public T AlbumArtist { get; set; }

		public T Subtitle { get; set; }

		public T BPM { get; set; }

		public T Composer { get; set; }

		public T Copyright { get; set; }

		public T Genre { get; set; }

		public T Grouping { get; set; }

		public T Publisher { get; set; }

		public T Encoder { get; set; }

		public T Lyricist { get; set; }

		public T Year { get; set; }

		public T Conductor { get; set; }

		public T Track { get; set; }

		public T Producer { get; set; }

		public T Comment { get; set; }

		public T Mood { get; set; }

		public T Rating { get; set; }

		public T ISRC { get; set; }

		public T Remixer { get; set; }
	}
	public sealed class TagReader : TagProperties<string>
	{
		public Dictionary<string, string> Other { get; } = new Dictionary<string, string>();


		public List<PictureTag> Pictures { get; } = new List<PictureTag>();


		public string Lyrics { get; set; }

		public static TagReader Read(string FileName)
		{
			Bass.Init(-1, 44100, DeviceInitFlags.Default, (IntPtr)0, (IntPtr)0);
			int num = Bass.CreateStream(FileName, 0L, 0L, BassFlags.Prescan);
			TagReader tagReader = null;
			if (num != 0)
			{
				tagReader = Read(num);
				Bass.StreamFree(num);
			}
			else
			{
				num = Bass.MusicLoad(FileName, 0L, 0, BassFlags.Prescan);
				if (num != 0)
				{
					tagReader = Read(num);
					Bass.MusicFree(num);
				}
			}
			if (!string.IsNullOrWhiteSpace(tagReader?.Title))
			{
				tagReader.Title = Path.GetFileNameWithoutExtension(FileName);
			}
			return tagReader;
		}

		public static TagReader Read(int Channel)
		{
			TagReader tagReader = new TagReader();
			switch (Bass.ChannelGetInfo(Channel).ChannelType)
			{
			case ChannelType.MP1:
			case ChannelType.MP2:
			case ChannelType.MP3:
				if (!tagReader.ReadID3v2(Channel) && !tagReader.ReadID3v1(Channel) && !tagReader.ReadApe(Channel) && !tagReader.ReadBWF(Channel))
				{
				}
				break;
			case ChannelType.OGG:
				if (!tagReader.ReadOgg(Channel) && !tagReader.ReadApe(Channel))
				{
				}
				break;
			case ChannelType.AAC:
			case ChannelType.MP4:
				if (!tagReader.ReadMp4(Channel) && !tagReader.ReadID3v2(Channel) && !tagReader.ReadApe(Channel) && !tagReader.ReadOgg(Channel))
				{
				}
				break;
			case ChannelType.Wave:
			case ChannelType.WavePCM:
			case ChannelType.WaveFloat:
				if (!tagReader.ReadRiffInfo(Channel) && !tagReader.ReadBWF(Channel) && !tagReader.ReadID3v2(Channel))
				{
				}
				break;
			case ChannelType.DSD:
				tagReader.Title = Marshal.PtrToStringAnsi(Bass.ChannelGetTags(Channel, TagType.DSDTitle));
				tagReader.Artist = Marshal.PtrToStringAnsi(Bass.ChannelGetTags(Channel, TagType.DSDArtist));
				break;
			case ChannelType.MOD:
				tagReader.Title = Marshal.PtrToStringAnsi(Bass.ChannelGetTags(Channel, TagType.MusicName));
				tagReader.Artist = Marshal.PtrToStringAnsi(Bass.ChannelGetTags(Channel, TagType.MusicAuth));
				tagReader.Comment = Marshal.PtrToStringAnsi(Bass.ChannelGetTags(Channel, TagType.MusicMessage));
				break;
			default:
				if (!tagReader.ReadApe(Channel) && !tagReader.ReadOgg(Channel) && !tagReader.ReadID3v2(Channel))
				{
					tagReader.ReadID3v1(Channel);
				}
				break;
			}
			if (string.IsNullOrWhiteSpace(tagReader.Lyrics))
			{
				IntPtr intPtr = Bass.ChannelGetTags(Channel, TagType.Lyrics3v2);
				if (intPtr != IntPtr.Zero)
				{
					tagReader.Lyrics = Marshal.PtrToStringAnsi(intPtr);
				}
			}
			return tagReader;
		}

		private IEnumerable<KeyValuePair<string, string>> ReadUsingLookupTable(IEnumerable<string> Tags, TagProperties<IEnumerable<string>> LookupTable, char Separator)
		{
			foreach (string Tag in Tags)
			{
				string[] array = Tag.Split(new char[1] { Separator });
				string key = array[0].ToLower();
				string value = array[1];
				if (!SetTagUsingLookupTable(key, value, LookupTable))
				{
					yield return new KeyValuePair<string, string>(array[0], value);
				}
			}
		}

		private bool SetTagUsingLookupTable(string Key, string Value, TagProperties<IEnumerable<string>> LookupTable)
		{
			if (LookupTable.Title != null && LookupTable.Title.Contains(Key))
			{
				base.Title = Value;
			}
			else if (LookupTable.Artist != null && LookupTable.Artist.Contains(Key))
			{
				base.Artist = Value;
			}
			else if (LookupTable.Album != null && LookupTable.Album.Contains(Key))
			{
				base.Album = Value;
			}
			else if (LookupTable.AlbumArtist != null && LookupTable.AlbumArtist.Contains(Key))
			{
				base.AlbumArtist = Value;
			}
			else if (LookupTable.Subtitle != null && LookupTable.Subtitle.Contains(Key))
			{
				base.Subtitle = Value;
			}
			else if (LookupTable.BPM != null && LookupTable.BPM.Contains(Key))
			{
				base.BPM = Value;
			}
			else if (LookupTable.Composer != null && LookupTable.Composer.Contains(Key))
			{
				base.Composer = Value;
			}
			else if (LookupTable.Copyright != null && LookupTable.Copyright.Contains(Key))
			{
				base.Copyright = Value;
			}
			else if (LookupTable.Genre != null && LookupTable.Genre.Contains(Key))
			{
				base.Genre = Value;
			}
			else if (LookupTable.Grouping != null && LookupTable.Grouping.Contains(Key))
			{
				base.Grouping = Value;
			}
			else if (LookupTable.Publisher != null && LookupTable.Publisher.Contains(Key))
			{
				base.Publisher = Value;
			}
			else if (LookupTable.Encoder != null && LookupTable.Encoder.Contains(Key))
			{
				base.Encoder = Value;
			}
			else if (LookupTable.Lyricist != null && LookupTable.Lyricist.Contains(Key))
			{
				base.Lyricist = Value;
			}
			else if (LookupTable.Year != null && LookupTable.Year.Contains(Key))
			{
				base.Year = Value;
			}
			else if (LookupTable.Conductor != null && LookupTable.Conductor.Contains(Key))
			{
				base.Conductor = Value;
			}
			else if (LookupTable.Track != null && LookupTable.Track.Contains(Key))
			{
				base.Track = Value;
			}
			else if (LookupTable.Producer != null && LookupTable.Producer.Contains(Key))
			{
				base.Producer = Value;
			}
			else if (LookupTable.Comment != null && LookupTable.Comment.Contains(Key))
			{
				base.Comment = Value;
			}
			else if (LookupTable.Mood != null && LookupTable.Mood.Contains(Key))
			{
				base.Mood = Value;
			}
			else if (LookupTable.Rating != null && LookupTable.Rating.Contains(Key))
			{
				base.Rating = Value;
			}
			else if (LookupTable.ISRC != null && LookupTable.ISRC.Contains(Key))
			{
				base.ISRC = Value;
			}
			else
			{
				if (LookupTable.Remixer == null || !LookupTable.Remixer.Contains(Key))
				{
					return false;
				}
				base.Remixer = Value;
			}
			return true;
		}

		public bool ReadApe(int Channel)
		{
			IntPtr intPtr = Bass.ChannelGetTags(Channel, TagType.APE);
			if (intPtr == IntPtr.Zero)
			{
				return false;
			}
			foreach (KeyValuePair<string, string> item in ReadUsingLookupTable(Extensions.ExtractMultiStringUtf8(intPtr), LookupTables.Ape, '='))
			{
				Other.Add(item.Key, item.Value);
			}
			return true;
		}

		public bool ReadOgg(int Channel)
		{
			IntPtr intPtr = Bass.ChannelGetTags(Channel, TagType.OGG);
			if (intPtr == IntPtr.Zero)
			{
				return false;
			}
			foreach (KeyValuePair<string, string> item in ReadUsingLookupTable(Extensions.ExtractMultiStringUtf8(intPtr), LookupTables.Ogg, '='))
			{
				Other.Add(item.Key, item.Value);
			}
			if (string.IsNullOrWhiteSpace(base.Encoder))
			{
				IntPtr intPtr2 = Bass.ChannelGetTags(Channel, TagType.OggEncoder);
				if (intPtr2 != IntPtr.Zero)
				{
					base.Encoder = Extensions.PtrToStringUtf8(intPtr2);
				}
			}
			return true;
		}

		public bool ReadRiffInfo(int Channel)
		{
			IntPtr intPtr = Bass.ChannelGetTags(Channel, TagType.RiffInfo);
			if (intPtr == IntPtr.Zero)
			{
				return false;
			}
			foreach (KeyValuePair<string, string> item in ReadUsingLookupTable(Extensions.ExtractMultiStringAnsi(intPtr), LookupTables.RiffInfo, '='))
			{
				Other.Add(item.Key, item.Value);
			}
			return true;
		}

		public bool ReadMp4(int Channel)
		{
			IntPtr intPtr = Bass.ChannelGetTags(Channel, TagType.MP4);
			if (intPtr == IntPtr.Zero)
			{
				return false;
			}
			foreach (KeyValuePair<string, string> item in ReadUsingLookupTable(Extensions.ExtractMultiStringUtf8(intPtr), LookupTables.Mp4, '='))
			{
				Other.Add(item.Key, item.Value);
			}
			return true;
		}

		public bool ReadID3v1(int Channel)
		{
			IntPtr intPtr = Bass.ChannelGetTags(Channel, TagType.ID3);
			if (intPtr == IntPtr.Zero)
			{
				return false;
			}
			ID3v1Tag iD3v1Tag = Marshal.PtrToStructure<ID3v1Tag>(intPtr);
			base.Title = iD3v1Tag.Title;
			base.Artist = iD3v1Tag.Artist;
			base.Album = iD3v1Tag.Album;
			base.Year = iD3v1Tag.Year;
			base.Genre = iD3v1Tag.Genre;
			base.Track = iD3v1Tag.TrackNo.ToString();
			base.Comment = iD3v1Tag.Comment;
			return true;
		}

		public bool ReadID3v2(int Channel)
		{
			IntPtr intPtr = Bass.ChannelGetTags(Channel, TagType.ID3v2);
			if (intPtr == IntPtr.Zero)
			{
				return false;
			}
			ID3v2Tag iD3v2Tag = new ID3v2Tag(intPtr);
			foreach (KeyValuePair<string, string> textFrame in iD3v2Tag.TextFrames)
			{
				if (!SetTagUsingLookupTable(textFrame.Key, textFrame.Value, LookupTables.Id3v2))
				{
					Other.Add(textFrame.Key, textFrame.Value);
				}
			}
			Pictures.AddRange(iD3v2Tag.PictureFrames);
			return true;
		}

		public bool ReadBWF(int Channel)
		{
			IntPtr intPtr = Bass.ChannelGetTags(Channel, TagType.RiffBext);
			if (intPtr == IntPtr.Zero)
			{
				return false;
			}
			BextTag bextTag = Marshal.PtrToStructure<BextTag>(intPtr);
			base.Title = bextTag.Description;
			base.Artist = bextTag.Originator;
			base.Encoder = bextTag.OriginatorReference;
			base.Year = bextTag.OriginationDate.Split(new char[1] { '-' })[0];
			return true;
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	public class BextTag
	{
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
		public string Description;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
		public string Originator;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
		public string OriginatorReference;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
		public string OriginationDate;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
		public string OriginationTime;

		public long TimeReference;

		public short Version;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
		public byte[] UMID;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 190)]
		private byte[] reserved;

		private IntPtr codinghistory;

		public DateTime OriginationDateTime
		{
			get
			{
				int year = int.Parse(OriginationDate.Substring(0, 4));
				int month = int.Parse(OriginationDate.Substring(5, 2));
				int day = int.Parse(OriginationDate.Substring(8, 2));
				int hour = int.Parse(OriginationTime.Substring(0, 2));
				int minute = int.Parse(OriginationTime.Substring(3, 2));
				int second = int.Parse(OriginationTime.Substring(6, 2));
				return new DateTime(year, month, day, hour, minute, second);
			}
		}

		public string CodingHistory
		{
			get
			{
				if (!(codinghistory == IntPtr.Zero))
				{
					return Marshal.PtrToStringAnsi(codinghistory);
				}
				return null;
			}
		}

		public static BextTag Read(int Channel)
		{
			return Marshal.PtrToStructure<BextTag>(Bass.ChannelGetTags(Channel, TagType.RiffBext));
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	public class CACodecTag
	{
		public int ftype;

		public int atype;

		private IntPtr name;

		public string Name
		{
			get
			{
				if (!(name == IntPtr.Zero))
				{
					return Marshal.PtrToStringAnsi(name);
				}
				return null;
			}
		}

		public static CACodecTag Read(int Channel)
		{
			return Marshal.PtrToStructure<CACodecTag>(Bass.ChannelGetTags(Channel, TagType.WmaMeta));
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	public class CartTimer
	{
		public int Usage;

		public int Value;
	}
	[StructLayout(LayoutKind.Sequential)]
	public class CartTag
	{
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4)]
		public string Version;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string Title;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string Artist;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string CutID;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string ClientID;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string Category;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string Classification;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string OutCue;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
		private string startDate;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
		private string startTime;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
		private string endDate;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
		private string endTime;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string ProducerAppID;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string ProducerAppVersion;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
		public string UserDef;

		public int dwLevelReference;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
		public CartTimer[] PostTimer;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 276)]
		private char[] Reserved;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 1024)]
		public string URL;

		private IntPtr tagText;

		public string TagText
		{
			get
			{
				if (!(tagText == IntPtr.Zero))
				{
					return Marshal.PtrToStringAnsi(tagText);
				}
				return null;
			}
		}

		public DateTime StartTime
		{
			get
			{
				string[] array = startDate.Split(new char[1] { '-' });
				string[] array2 = startTime.Split(new char[1] { ':' });
				return new DateTime(int.Parse(array[0]), int.Parse(array[1]), int.Parse(array[2]), int.Parse(array2[0]), int.Parse(array2[1]), int.Parse(array2[2]));
			}
		}

		public DateTime EndTime
		{
			get
			{
				string[] array = endDate.Split(new char[1] { '-' });
				string[] array2 = endTime.Split(new char[1] { ':' });
				return new DateTime(int.Parse(array[0]), int.Parse(array[1]), int.Parse(array[2]), int.Parse(array2[0]), int.Parse(array2[1]), int.Parse(array2[2]));
			}