Decompiled source of ManagedBass v3.1.101
BepInEx/core/ManagedBass/netstandard1.4/ManagedBass.dll
Decompiled 2 days ago
The result has been truncated due to the large size, download it to view full contents!
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])); }
