public BassAsioHandler(int asioDevice, int asioChannel, int outputChannel) { this._input = false; this._device = asioDevice; this._channel = asioChannel; this._outputChannel = outputChannel; BassAsio.BASS_ASIO_Init(asioDevice, BassAsioHandler.UseDedicatedThreads ? BASSASIOInit.BASS_ASIO_THREAD : BASSASIOInit.BASS_ASIO_DEFAULT); BassAsio.BASS_ASIO_SetDevice(asioDevice); this.GetChannelInfo(outputChannel); this._numchans = this._outputChannelInfo.chans; this._format = BASSASIOFormat.BASS_ASIO_FORMAT_16BIT; if ((this._outputChannelInfo.flags & BASSFlag.BASS_SAMPLE_FLOAT) != BASSFlag.BASS_DEFAULT) { this._format = BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT; } this._samplerate = (double)this._outputChannelInfo.freq; BassAsio.BASS_ASIO_SetRate(this._samplerate); this._internalAsioProc = new ASIOPROC(this.AsioOutputCallback); bool flag = BassAsio.BASS_ASIO_IsStarted(); BASSASIOActive bassasioactive = BassAsio.BASS_ASIO_ChannelIsActive(this._input, this._channel); if (flag && bassasioactive == BASSASIOActive.BASS_ASIO_ACTIVE_DISABLED) { BassAsio.BASS_ASIO_Stop(); } this.EnableAndJoin(this._input, this._channel, this._numchans, this._internalAsioProc, this._format); if (flag) { BassAsio.BASS_ASIO_Start(0, 0); } }
public bool AssignOutputChannel(int outputChannel) { if (this._input) { return(false); } bool flag = true; int num = BassAsio.BASS_ASIO_GetDevice(); if (num != this._device) { flag &= BassAsio.BASS_ASIO_SetDevice(this._device); } if (flag) { BASSASIOActive bassasioactive = BassAsio.BASS_ASIO_ChannelIsActive(this._input, this._channel); if (bassasioactive == BASSASIOActive.BASS_ASIO_ACTIVE_ENABLED) { BassAsio.BASS_ASIO_ChannelPause(this._input, this._channel); } this._outputChannel = outputChannel; if (this._outputChannel == 0) { this._samplerate = BassAsio.BASS_ASIO_GetRate(); this._numchans = 1; this._format = BASSASIOFormat.BASS_ASIO_FORMAT_16BIT; this._internalAsioProc = new ASIOPROC(this.AsioOutputCallback); } else { this.GetChannelInfo(this._outputChannel); this._numchans = this._outputChannelInfo.chans; this._format = BASSASIOFormat.BASS_ASIO_FORMAT_16BIT; if ((this._outputChannelInfo.flags & BASSFlag.BASS_SAMPLE_FLOAT) != BASSFlag.BASS_DEFAULT) { this._format = BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT; } this._samplerate = (double)this._outputChannelInfo.freq; } BassAsio.BASS_ASIO_SetRate(this._samplerate); if (bassasioactive == BASSASIOActive.BASS_ASIO_ACTIVE_DISABLED) { this._internalAsioProc = new ASIOPROC(this.AsioOutputCallback); } flag &= this.EnableAndJoin(this._input, this._channel, this._numchans, this._internalAsioProc, this._format); if (bassasioactive == BASSASIOActive.BASS_ASIO_ACTIVE_ENABLED) { BassAsio.BASS_ASIO_ChannelReset(this._input, this._channel, BASSASIOReset.BASS_ASIO_RESET_PAUSE); } } BassAsio.BASS_ASIO_SetDevice(num); return(flag); }
private int AsioCallback(bool input, int channel, IntPtr buffer, int length, IntPtr user) { //We deal only with outputs here //And if the channel has it's own handler, we ignore it if (!this.FOutputHandled.Contains(channel) && !input) { if (this.manager.Exists(user.ToInt32())) { ChannelInfo channelinfo = this.manager.GetChannel(user.ToInt32()); if (channelinfo.Play && channelinfo.IsDecoding) { int _decLength; BASSASIOActive _status = BassAsio.BASS_ASIO_ChannelIsActive(false, channel); //BASSActive _status = Bass.BASS_ChannelIsActive(user.ToInt32()); // now we evaluate the status... if (_status != BASSASIOActive.BASS_ASIO_ACTIVE_ENABLED) { //BassAsio.BASS_ASIO_ChannelPause(false, channel); return(0); } else { //BassAsio.BASS_ASIO_ChannelReset(false, channel, BASSASIOReset.BASS_ASIO_RESET_PAUSE); _decLength = Bass.BASS_ChannelGetData(channelinfo.BassHandle.Value, buffer, length); if (_decLength < 0) { _decLength = 0; } return(_decLength); } } else { return(0); } } else { return(0); } } else { return(0); } }
public bool SetMirror(int asioChannel) { if (!this._input && this._channel == asioChannel) { return(false); } bool flag = true; int num = BassAsio.BASS_ASIO_GetDevice(); if (num != this._device) { flag &= BassAsio.BASS_ASIO_SetDevice(this._device); } if (flag) { bool flag2 = BassAsio.BASS_ASIO_IsStarted(); BASSASIOActive bassasioactive = BassAsio.BASS_ASIO_ChannelIsActive(false, asioChannel); if (flag2) { BassAsio.BASS_ASIO_Stop(); } for (int i = 0; i < this._numchans; i++) { flag &= BassAsio.BASS_ASIO_ChannelEnableMirror(asioChannel + i, this._input, this._channel + i); } if (flag) { this._mirrorChannel = asioChannel; } else if (bassasioactive == BASSASIOActive.BASS_ASIO_ACTIVE_DISABLED) { for (int j = 0; j < this._numchans; j++) { BassAsio.BASS_ASIO_ChannelEnable(false, asioChannel + j, null, IntPtr.Zero); BassAsio.BASS_ASIO_ChannelReset(false, asioChannel + j, BASSASIOReset.BASS_ASIO_RESET_ENABLE | BASSASIOReset.BASS_ASIO_RESET_FORMAT | BASSASIOReset.BASS_ASIO_RESET_RATE | BASSASIOReset.BASS_ASIO_RESET_VOLUME); } } if (flag2) { BassAsio.BASS_ASIO_Start(0, 0); } } BassAsio.BASS_ASIO_SetDevice(num); return(flag); }
public BassAsioHandler(bool input, int asioDevice, int asioChannel, int asioNumChans, BASSASIOFormat asioFormat, double asioSamplerate) { this._input = input; this._device = asioDevice; this._channel = asioChannel; this._numchans = asioNumChans; this._format = asioFormat; BassAsio.BASS_ASIO_Init(asioDevice, BassAsioHandler.UseDedicatedThreads ? BASSASIOInit.BASS_ASIO_THREAD : BASSASIOInit.BASS_ASIO_DEFAULT); BassAsio.BASS_ASIO_SetDevice(asioDevice); if (asioSamplerate <= 0.0) { this._samplerate = BassAsio.BASS_ASIO_GetRate(); } else { BassAsio.BASS_ASIO_SetRate(asioSamplerate); this._samplerate = BassAsio.BASS_ASIO_GetRate(); } if (this._input) { this._internalAsioProc = new ASIOPROC(this.AsioInputCallback); this.UseInput = true; } else { this._internalAsioProc = new ASIOPROC(this.AsioOutputCallback); } bool flag = BassAsio.BASS_ASIO_IsStarted(); BASSASIOActive bassasioactive = BassAsio.BASS_ASIO_ChannelIsActive(this._input, this._channel); if (flag && bassasioactive == BASSASIOActive.BASS_ASIO_ACTIVE_DISABLED) { BassAsio.BASS_ASIO_Stop(); } this.EnableAndJoin(this._input, this._channel, this._numchans, this._internalAsioProc, this._format); if (flag) { BassAsio.BASS_ASIO_Start(0, 0); } }
public bool RemoveFullDuplex(bool disableOutput) { if (!this.IsInputFullDuplex) { return(false); } bool flag = true; int num = BassAsio.BASS_ASIO_GetDevice(); if (this._fullDuplexChannel != -1 && num != this._fullDuplexDevice) { flag &= BassAsio.BASS_ASIO_SetDevice(this._fullDuplexDevice); } if (flag) { bool flag2 = false; if (this._fullDuplexChannel != -1) { flag2 = BassAsio.BASS_ASIO_IsStarted(); BASSASIOActive bassasioactive = BassAsio.BASS_ASIO_ChannelIsActive(false, this._fullDuplexChannel); if (flag2 && disableOutput && bassasioactive != BASSASIOActive.BASS_ASIO_ACTIVE_DISABLED) { BassAsio.BASS_ASIO_Stop(); flag &= BassAsio.BASS_ASIO_ChannelEnable(false, this._fullDuplexChannel, null, IntPtr.Zero); if (flag) { BassAsio.BASS_ASIO_ChannelReset(false, this._fullDuplexChannel, BASSASIOReset.BASS_ASIO_RESET_ENABLE | BASSASIOReset.BASS_ASIO_RESET_FORMAT | BASSASIOReset.BASS_ASIO_RESET_RATE | BASSASIOReset.BASS_ASIO_RESET_VOLUME); for (int i = 1; i < this._numchans; i++) { BassAsio.BASS_ASIO_ChannelReset(false, this._fullDuplexChannel + i, BASSASIOReset.BASS_ASIO_RESET_JOIN); } } } } if (flag) { this._fullDuplexChannel = -1; this._fullDuplexDevice = -1; this._fullDuplex = false; } if (flag2) { BassAsio.BASS_ASIO_Start(0, 0); } if (flag) { if (this._fullDuplexDevice != this._device) { flag &= BassAsio.BASS_ASIO_SetDevice(this._device); } if (flag) { this._internalAsioProc = new ASIOPROC(this.AsioInputCallback); flag &= this.EnableAndJoin(this._input, this._channel, this._numchans, this._internalAsioProc, this._format); } Bass.Bass.BASS_StreamFree(this._outputChannel); this._outputChannel = 0; this._fullDuplexBuffer = null; this.BypassFullDuplex = false; } } BassAsio.BASS_ASIO_SetDevice(num); return(flag); }
public bool SetFullDuplex(int asioDevice, int asioChannel) { if (!this._input) { return(false); } bool flag = true; int num = BassAsio.BASS_ASIO_GetDevice(); if (num != this._device) { flag &= BassAsio.BASS_ASIO_SetDevice(this._device); } if (flag) { if (this._outputChannel != 0) { Bass.Bass.BASS_StreamFree(this._outputChannel); } BASSFlag bassflag = BASSFlag.BASS_STREAM_DECODE; if (this._format == BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT) { bassflag |= BASSFlag.BASS_SAMPLE_FLOAT; } this._outputChannel = Bass.Bass.BASS_StreamCreateDummy((int)BassAsio.BASS_ASIO_GetRate(), this._numchans, bassflag, IntPtr.Zero); BASS_ASIO_INFO bass_ASIO_INFO = BassAsio.BASS_ASIO_GetInfo(); this._fullDuplexBuffer = new byte[bass_ASIO_INFO.bufmax * this._numchans * 4]; this._internalAsioProc = new ASIOPROC(this.AsioToAsioFullDuplexCallback); flag &= this.EnableAndJoin(this._input, this._channel, this._numchans, this._internalAsioProc, this._format); if (flag) { if (this._device != asioDevice) { flag &= BassAsio.BASS_ASIO_SetDevice(asioDevice); } if (flag) { BassAsio.BASS_ASIO_SetRate(this._samplerate); bool flag2 = BassAsio.BASS_ASIO_IsStarted(); BASSASIOActive bassasioactive = BassAsio.BASS_ASIO_ChannelIsActive(false, asioChannel); if (flag2 && bassasioactive == BASSASIOActive.BASS_ASIO_ACTIVE_DISABLED) { BassAsio.BASS_ASIO_Stop(); } flag &= this.EnableAndJoin(false, asioChannel, this._numchans, this._internalAsioProc, this._format); if (flag) { this._fullDuplexDevice = asioDevice; this._fullDuplexChannel = asioChannel; this._fullDuplex = true; } if (flag2) { BassAsio.BASS_ASIO_Start(0, 0); } } } } BassAsio.BASS_ASIO_SetDevice(num); return(flag); }