/// <summary>
/// Removes and audio stream from a mixer.
/// </summary>
/// <param name="audioStream">The audio stream.</param>
/// <param name="mixerChannel">The mixer channel.</param>
public static void RemoveFromMixer(AudioStream audioStream, MixerChannel mixerChannel)
{
if (audioStream == null || !audioStream.IsAudioLoaded())
{
return;
}
//throw new Exception("Audio file null or not audio not loaded");
if (mixerChannel.ChannelId == int.MinValue)
{
throw new Exception("Mixer channel not initialized");
}
//lock (Lock)
{
// DebugHelper.WriteLine($"RemoveFromMixer {audioStream.Description} {audioStream.Channel}...");
BassMix.BASS_Mixer_ChannelPause(audioStream.ChannelId);
Bass.BASS_ChannelLock(mixerChannel.ChannelId, true);
foreach (var channel in audioStream.ChannelIds)
{
BassMix.BASS_Mixer_ChannelRemove(channel);
}
Bass.BASS_ChannelLock(mixerChannel.ChannelId, false);
// DebugHelper.WriteLine("done");
if (audioStream.MixerChannelId == mixerChannel.ChannelId)
{
audioStream.MixerChannelId = int.MinValue;
}
}
}
/// <summary>
/// Recode the file
/// </summary>
/// <param name = "fileName">Initial file</param>
/// <param name = "outFileName">Target file</param>
/// <param name = "targetSampleRate">Target sample rate</param>
public void RecodeTheFile(string fileName, string outFileName, int targetSampleRate)
{
int stream = Un4seen.Bass.Bass.BASS_StreamCreateFile(fileName, 0, 0, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_MONO | BASSFlag.BASS_SAMPLE_FLOAT);
TAG_INFO tags = new TAG_INFO();
BassTags.BASS_TAG_GetFromFile(stream, tags);
int mixerStream = BassMix.BASS_Mixer_StreamCreate(targetSampleRate, 1, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_MONO | BASSFlag.BASS_SAMPLE_FLOAT);
if (BassMix.BASS_Mixer_StreamAddChannel(mixerStream, stream, BASSFlag.BASS_MIXER_FILTER))
{
WaveWriter waveWriter = new WaveWriter(outFileName, mixerStream, true);
const int length = 5512 * 10 * 4;
float[] buffer = new float[length];
while (true)
{
int bytesRead = Un4seen.Bass.Bass.BASS_ChannelGetData(mixerStream, buffer, length);
if (bytesRead == 0)
{
break;
}
waveWriter.Write(buffer, bytesRead);
}
waveWriter.Close();
}
else
{
throw new Exception(Un4seen.Bass.Bass.BASS_ErrorGetCode().ToString());
}
}
/// <summary>
/// Attach a stream to the Mixer
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public bool AttachStream(MusicStream stream)
{
Bass.BASS_ChannelLock(_mixer, true);
// Set SynyPos at end of stream
SetSyncPos(stream, 0.0);
bool result = BassMix.BASS_Mixer_StreamAddChannel(_mixer, stream.BassStream,
BASSFlag.BASS_MIXER_NORAMPIN | BASSFlag.BASS_MIXER_BUFFER |
BASSFlag.BASS_MIXER_MATRIX | BASSFlag.BASS_MIXER_DOWNMIX |
BASSFlag.BASS_STREAM_AUTOFREE);
if (!result)
{
Log.Error("BASS: Error attaching stream to mixer. {0}", Bass.BASS_ErrorGetCode());
}
Bass.BASS_ChannelLock(_mixer, false);
if (result && _mixingMatrix != null)
{
Log.Debug("BASS: Setting mixing matrix...");
result = BassMix.BASS_Mixer_ChannelSetMatrix(stream.BassStream, _mixingMatrix);
if (!result)
{
Log.Error("BASS: Error attaching Mixing Matrix. {0}", Bass.BASS_ErrorGetCode());
}
}
return(result);
}
internal override void DisconnectFile(clsMP3Bass mp3bass)
{
CheckOK(Bass.ChannelStop(mp3bass.StreamHandle));
CheckOK(BassMix.MixerRemoveChannel(mp3bass.StreamHandle));
CheckOK(Bass.StreamFree(mp3bass.StreamHandle));
mp3bass.StreamHandle = 0;
}
/// <summary>
/// Creates a new instance of <see cref="MixedAudioProvider"/>.
/// </summary>
public MixedAudioProvider(IEnumerable <BassItem> Devices, int FrameRate, bool MuteOutput = true)
{
if (Devices == null)
{
throw new ArgumentNullException();
}
var updatePeriod = 1000 / FrameRate;
Bass.UpdatePeriod = updatePeriod.Clip(5, 100);
Console.WriteLine($"BASS Update Period: {Bass.UpdatePeriod}");
for (var i = 0; i < BufferCount; ++i)
{
_buffers.Add(new byte[0]);
}
_mixer = BassMix.CreateMixerStream(44100, 2, BassFlags.MixerNonStop);
foreach (var recordingDevice in Devices)
{
InitDevice(recordingDevice);
}
if (MuteOutput)
{
// mute the mixer
Bass.ChannelSetAttribute(_mixer, ChannelAttribute.Volume, 0);
}
Bass.ChannelSetDSP(_mixer, Procedure);
}
private void buttonAddFile_Click(object sender, EventArgs e)
{
if (DialogResult.OK == openFileDialog.ShowDialog(this))
{
if (File.Exists(openFileDialog.FileName))
{
lock (listBoxPlaylist)
{
Track track = new Track(openFileDialog.FileName);
listBoxPlaylist.Items.Add(track);
// in the demo we already add each new track to the mixer
// this is in real life not the best place to do so (especially with larger playlists)
// but for the demo it is okay ;-)
// add the new track to the mixer (in PAUSED mode!)
BassMix.BASS_Mixer_StreamAddChannel(_mixer, track.Channel, BASSFlag.BASS_MIXER_PAUSE | BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_STREAM_AUTOFREE);
// an BASS_SYNC_END is used to trigger the next track in the playlist (if no POS sync was set)
track.TrackSync = new SYNCPROC(OnTrackSync);
BassMix.BASS_Mixer_ChannelSetSync(track.Channel, BASSSync.BASS_SYNC_END, 0L, track.TrackSync, new IntPtr(0));
}
if (_currentTrack == null)
{
PlayNextTrack();
}
}
}
}
private void buttonRemoveEnvelope_Click(object sender, EventArgs e)
{
BassMix.BASS_Mixer_ChannelSetEnvelope(_currentTrack.Channel, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, null);
_WF.ClearAllVolumePoints();
_WF.DrawVolume = WaveForm.VOLUMEDRAWTYPE.None;
DrawWave();
}
/// <summary>
/// Clears the automation sync positions.
/// </summary>
/// <param name="track">The track.</param>
private void ClearAutomationSyncPositions(AudioStream track)
{
foreach (var trigger in AutomationAttributesHelper.GetAutomationAttributes(track.Description).TrackFXTriggers)
{
if (trigger.StartSyncId != int.MinValue)
{
BassMix.BASS_Mixer_ChannelRemoveSync(track.ChannelId, trigger.StartSyncId);
trigger.StartSyncId = int.MinValue;
}
if (trigger.EndSyncId == int.MinValue)
{
continue;
}
BassMix.BASS_Mixer_ChannelRemoveSync(track.ChannelId, trigger.EndSyncId);
trigger.EndSyncId = int.MinValue;
}
foreach (var trigger in GetCurrentSampleTriggers())
{
if (trigger.StartSyncId != int.MinValue)
{
BassMix.BASS_Mixer_ChannelRemoveSync(track.ChannelId, trigger.StartSyncId);
trigger.StartSyncId = int.MinValue;
}
if (trigger.EndSyncId == int.MinValue)
{
continue;
}
BassMix.BASS_Mixer_ChannelRemoveSync(track.ChannelId, trigger.EndSyncId);
trigger.EndSyncId = int.MinValue;
}
}
public SplitDecoder(Decoder Source, Resolution BufferKind = Resolution.Short)
: base(BufferKind)
{
this.Source = Source;
Handle = BassMix.CreateSplitStream(Source.Handle, BassFlags.Decode | BufferKind.ToBassFlag(), null);
}
protected override void Update()
{
base.Update();
if (!(Mixer is BassAudioMixer bassMixer))
{
return;
}
int[] channels = BassMix.MixerGetChannels(bassMixer.Handle);
if (channels == null)
{
return;
}
foreach (int channel in channels)
{
if (mixerChannelsContainer.All(ch => ch.ChannelHandle != channel))
{
mixerChannelsContainer.Add(new AudioChannelDisplay(channel));
}
}
mixerChannelsContainer.RemoveAll(ch => !channels.Contains(ch.ChannelHandle));
}
/// <summary>
/// Adds to the mixer channel, and sets the sync points.
/// </summary>
/// <param name="sample">The sample to sync.</param>
private void AddSampleToMixer(Sample sample)
{
if (sample == null)
{
return;
}
Debug.Print("Add sample to mixer " + sample.Description);
// load audio data if not loaded
if (sample.Channel == int.MinValue)
{
LoadSampleAudioData(sample);
}
//if (sample != this.PreviousSample && sample != this.CurrentSample)
//{
// add the new sample to the mixer (in paused mode)
//BassMix.BASS_Mixer_StreamAddChannel(_mixerChannel, sample.Channel, BASSFlag.BASS_MIXER_PAUSE | BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_STREAM_AUTOFREE);
BassMix.BASS_Mixer_StreamAddChannel(_sampleMixerChannel, sample.Channel, BASSFlag.BASS_MIXER_PAUSE | BASSFlag.BASS_MIXER_DOWNMIX);
//// set sample sync event
//sample.SampleSync = new SYNCPROC(OnSampleSync);
//// set replay gain
//BassHelper.SetSampleReplayGain(sample.Channel, sample.Gain);
//}
}
protected override void Update()
{
base.Update();
float[] levels = new float[2];
BassMix.ChannelGetLevel(ChannelHandle, levels, 1 / 1000f * sample_window, LevelRetrievalFlags.Stereo);
float curPeakL = levels[0];
float curPeakR = levels[1];
float curPeak = (curPeakL + curPeakR) / 2f;
if (curPeak > maxPeak || Clock.CurrentTime - lastMaxPeakTime > peak_hold_time)
{
lastMaxPeakTime = Clock.CurrentTime;
maxPeak = float.MinValue;
}
maxPeak = Math.Max(maxPeak, curPeak);
volBarL.ResizeHeightTo(curPeakL, sample_window * 4);
volBarR.ResizeHeightTo(curPeakR, sample_window * 4);
string peakDisplay = curPeak == 0 ? "-∞ " : $"{BassUtils.LevelToDb(curPeak):F}";
string maxPeakDisplay = maxPeak == 0 ? "-∞ " : $"{BassUtils.LevelToDb(maxPeak):F}";
peakText.Text = $"curr: {peakDisplay}dB";
maxPeakText.Text = $"peak: {maxPeakDisplay}dB";
peakText.Colour = BassUtils.LevelToDb(curPeak) > 0 ? Colour4.Red : Colour4.White;
maxPeakText.Colour = BassUtils.LevelToDb(maxPeak) > 0 ? Colour4.Red : Colour4.White;
}
private Player()
{
var enginedir = AppDomain.CurrentDomain.BaseDirectory;
if (Is64Bit)
{
enginedir = Path.Combine(enginedir, @"Engine\x64");
}
else
{
enginedir = Path.Combine(enginedir, @"Engine\x86");
}
Bass.Load(enginedir);
BassMix.Load(enginedir);
BassCd.Load(enginedir);
BassFx.Load(enginedir);
Bass.PluginLoad(enginedir + "\\bass_aac.dll");
Bass.PluginLoad(enginedir + "\\bass_ac3.dll");
Bass.PluginLoad(enginedir + "\\bass_ape.dll");
Bass.PluginLoad(enginedir + "\\bass_mpc.dll");
Bass.PluginLoad(enginedir + "\\bass_spx.dll");
Bass.PluginLoad(enginedir + "\\bass_tta.dll");
Bass.PluginLoad(enginedir + "\\bassalac.dll");
Bass.PluginLoad(enginedir + "\\bassdsd.dll");
Bass.PluginLoad(enginedir + "\\bassflac.dll");
Bass.PluginLoad(enginedir + "\\bassopus.dll");
Bass.PluginLoad(enginedir + "\\basswma.dll");
Bass.PluginLoad(enginedir + "\\basswv.dll");
Bass.PluginLoad(enginedir + "\\bassmidi.dll");
_callback = MyDownloadProc;
_maxfft = (int)(DataFlags.Available | DataFlags.FFT2048);
}
/// <summary>
/// Free used resources
/// </summary>
public void Dispose()
{
if (_source != 0)
{
if (_mixer != 0)
{
Stop();
}
RemoveEq(ref _mixer);
Bass.StreamFree(_source);
Bass.MusicFree(_source);
Bass.StreamFree(_mixer);
_mixer = 0;
_source = 0;
}
if (_handle.IsAllocated)
{
_handle.Free();
}
if (_initialized)
{
Bass.Free();
}
BassCd.Unload();
BassFx.Unload();
BassMix.Unload();
Bass.PluginFree(0);
}
private void MyWaveFormCallback(int framesDone, int framesTotal, TimeSpan elapsedTime, bool finished)
{
if (finished)
{
_WF.SyncPlayback(_currentTrack.Channel);
// and do pre-calculate the next track position
// in this example we will only use the end-position
long startPos = 0L;
long endPos = 0L;
if (_WF.GetCuePoints(ref startPos, ref endPos, -24.0, -12.0, true))
{
_currentTrack.NextTrackPos = endPos;
// if there is already a sync set, remove it first
if (_currentTrack.NextTrackSync != 0)
{
BassMix.BASS_Mixer_ChannelRemoveSync(_currentTrack.Channel, _currentTrack.NextTrackSync);
}
// set the next track sync automatically
_currentTrack.NextTrackSync = BassMix.BASS_Mixer_ChannelSetSync(_currentTrack.Channel, BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME, _currentTrack.NextTrackPos, _currentTrack.TrackSync, new IntPtr(1));
_WF.AddMarker("Next", _currentTrack.NextTrackPos);
}
}
// will be called during rendering...
DrawWave();
}
protected void Dispose(bool bManagedDispose)
{
this.e出力デバイス = ESoundDeviceType.Unknown; // まず出力停止する(Dispose中にクラス内にアクセスされることを防ぐ)
if (hMixer_DeviceOut != 0)
{
BassMix.BASS_Mixer_ChannelPause(this.hMixer_DeviceOut);
Bass.BASS_StreamFree(this.hMixer_DeviceOut);
this.hMixer_DeviceOut = 0;
}
if (hMixer != 0)
{
BassMix.BASS_Mixer_ChannelPause(this.hMixer);
Bass.BASS_StreamFree(this.hMixer);
this.hMixer = 0;
}
if (!this.bIsBASSFree)
{
BassAsio.BASS_ASIO_Free(); // システムタイマより先に呼び出すこと。（tAsio処理() の中でシステムタイマを参照してるため）
Bass.BASS_Free();
}
if (bManagedDispose)
{
CCommon.tDispose(this.tmシステムタイマ);
this.tmシステムタイマ = null;
}
}
private void ToggleZoom()
{
if (_WF == null)
{
return;
}
// WF is not null, so the stream must be playing...
if (_zoomed)
{
// unzoom...(display the whole wave form)
_zoomStart = -1;
_zoomStartBytes = -1;
_zoomEnd = -1;
}
else
{
// zoom...(display only a partial wave form)
long pos = BassMix.BASS_Mixer_ChannelGetPosition(_currentTrack.Channel);
// calculate the window to display
_zoomStart = _WF.Position2Frames(pos);
_zoomStartBytes = _WF.Frame2Bytes(_zoomStart);
_zoomEnd = _zoomStart + _WF.Position2Frames(_zoomDistance) - 1;
if (_zoomEnd >= _WF.Wave.data.Length)
{
// beyond the end, so we zoom from end - _zoomDistance.
_zoomEnd = _WF.Wave.data.Length - 1;
_zoomStart = _zoomEnd - _WF.Position2Frames(_zoomDistance) + 1;
_zoomStartBytes = _WF.Frame2Bytes(_zoomStart);
}
}
_zoomed = !_zoomed;
// and display this new wave form
DrawWave();
}
/// <summary>
/// Creates a new instance of <see cref="MixedAudioProvider"/>.
/// </summary>
public MixedAudioProvider(IEnumerable <BassItem> Devices, bool MuteOutput = true)
{
if (Devices == null)
{
throw new ArgumentNullException();
}
for (var i = 0; i < BufferCount; ++i)
{
_buffers.Add(new byte[0]);
}
_mixer = BassMix.CreateMixerStream(44100, 2, BassFlags.MixerNonStop);
foreach (var recordingDevice in Devices)
{
InitDevice(recordingDevice);
}
if (MuteOutput)
{
// mute the mixer
Bass.ChannelSetAttribute(_mixer, ChannelAttribute.Volume, 0);
}
Bass.ChannelSetDSP(_mixer, Procedure);
}
private void buttonSetEnvelope_Click(object sender, EventArgs e)
{
if (_currentTrack.Channel != 0)
{
BASS_MIXER_NODE[] nodes =
{
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(_mixer, 10d), 1f),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(_mixer, 13d), 0f),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(_mixer, 17d), 0f),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(_mixer, 20d), 1f)
};
BassMix.BASS_Mixer_ChannelSetEnvelope(_currentTrack.Channel, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, nodes);
// already align the envelope position to the current playback position
// pause mixer
Bass.BASS_ChannelLock(_mixer, true);
long pos = BassMix.BASS_Mixer_ChannelGetPosition(_currentTrack.Channel);
// convert source pos to mixer pos
long envPos = Bass.BASS_ChannelSeconds2Bytes(_mixer, Bass.BASS_ChannelBytes2Seconds(_currentTrack.Channel, pos));
BassMix.BASS_Mixer_ChannelSetEnvelopePos(_currentTrack.Channel, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, envPos);
// resume mixer
Bass.BASS_ChannelLock(_mixer, false);
// and show it in our waveform
_WF.DrawVolume = WaveForm.VOLUMEDRAWTYPE.Solid;
foreach (BASS_MIXER_NODE node in nodes)
{
_WF.AddVolumePoint(node.pos, node.val);
}
DrawWave();
}
}
public override int GetData(float[] buffer)
{
var length = default(uint);
switch (buffer.Length)
{
case 128:
length = FFT256;
break;
case 256:
length = FFT512;
break;
case 512:
length = FFT1024;
break;
default:
throw new NotImplementedException();
}
foreach (var channelHandle in this.MixerChannelHandles)
{
return(BassMix.ChannelGetData(channelHandle, buffer, unchecked ((int)length)));
}
return(0);
}
/// <summary>
/// Attach a stream to the Mixer
/// </summary>
/// <returns></returns>
public bool AttachStream()
{
try
{
Bass.BASS_ChannelLock(_mixerHandle, true);
RegisterStreamFreedEvent(_inputStream);
bool result = BassMix.BASS_Mixer_StreamAddChannel(_mixerHandle, _inputStream.Handle,
BASSFlag.BASS_MIXER_NORAMPIN | BASSFlag.BASS_MIXER_BUFFER |
BASSFlag.BASS_MIXER_MATRIX | BASSFlag.BASS_MIXER_DOWNMIX |
BASSFlag.BASS_STREAM_AUTOFREE
);
if (!result)
{
throw new BassLibraryException("BASS_Mixer_StreamAddChannel");
}
return(true);
}
finally
{
Bass.BASS_ChannelLock(_mixerHandle, false);
}
}
public void TestFreedChannelRemovedFromDefault()
{
track.Dispose();
bass.Update();
Assert.That(BassMix.ChannelGetMixer(getHandle()), Is.Zero);
}
internal override void DisconnectMidiDev(clsBassOutMidi bassoutmidi)
{
CheckOK(Bass.ChannelStop(bassoutmidi.MidiStream));
CheckOK(BassMix.MixerRemoveChannel(bassoutmidi.MidiStream));
CheckOK(Bass.StreamFree(bassoutmidi.MidiStream));
bassoutmidi.MidiStream = 0;
}
public void TestCannotBeRemovedFromGlobalMixer()
{
bass.Mixer.Remove(track);
bass.Update();
Assert.That(BassMix.ChannelGetMixer(getHandle()), Is.EqualTo(bass.Mixer.Handle));
}
private bool HasPotentialHumanSpeech(int visualChannel, long pos)
{
Bass.ChannelSetPosition(visualChannel, pos);
const int scaleFactor = _scaleFactorSqr * ushort.MaxValue;
var buffer = new float[2048];
var bufferResult = _isMixerUsed
? BassMix.ChannelGetData(visualChannel, buffer, (int)_maxFft)
: Bass.ChannelGetData(visualChannel, buffer, (int)_maxFft);
var verticalSamplesWithSound = 0;
if (bufferResult > 0)
{
for (var n = 0; n < buffer.Length; n++)
{
// TODO: Don't convert to percentage, just check the threshold raw from the buffer
// TODO: Skip parts of the spectrogram that cannot be human speech
var percentage = (float)Math.Min(1d, Math.Sqrt(buffer[n]) * scaleFactor / ushort.MaxValue);
if (percentage > 0.35)
{
verticalSamplesWithSound++;
if (verticalSamplesWithSound > 4)
{
return(true);
}
}
}
}
return(false);
}
public void clearDeckB()
{
// remove deck A, set to zero
BassMix.BASS_Mixer_ChannelRemove(_deckB);
Bass.BASS_StreamFree(_deckB);
_deckB = 0;
}
/// <summary>
/// Initialize Bass Library
/// </summary>
public static void Init()
{
if (!_initialized)
{
//Call to avoid the freeware splash screen. Didn't see it, but maybe it will appear if the Forms are used :D
BassNet.Registration("*****@*****.**", "2X155323152222");
//Dummy calls made for loading the assemblies
int bassVersion = Un4seen.Bass.Bass.BASS_GetVersion();
int bassMixVersion = BassMix.BASS_Mixer_GetVersion();
int bassfxVersion = BassFx.BASS_FX_GetVersion();
int plg = Un4seen.Bass.Bass.BASS_PluginLoad("bassflac.dll");
if (plg == 0)
{
throw new Exception(Un4seen.Bass.Bass.BASS_ErrorGetCode().ToString());
}
if (!Un4seen.Bass.Bass.BASS_Init(-1, DEFAULT_SAMPLE_RATE, BASSInit.BASS_DEVICE_DEFAULT | BASSInit.BASS_DEVICE_MONO, IntPtr.Zero)) //Set Sample Rate / MONO
{
throw new Exception(Un4seen.Bass.Bass.BASS_ErrorGetCode().ToString());
}
if (!Un4seen.Bass.Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_MIXER_FILTER, 50)) /*Set filter for anti aliasing*/
{
throw new Exception(Un4seen.Bass.Bass.BASS_ErrorGetCode().ToString());
}
if (!Un4seen.Bass.Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_FLOATDSP, true)) /*Set floating parameters to be passed*/
{
throw new Exception(Un4seen.Bass.Bass.BASS_ErrorGetCode().ToString());
}
_initialized = true;
}
}
private void Simple_Load(object sender, System.EventArgs e)
{
// BassNet.Registration("your email", "your regkey");
if (!Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, this.Handle))
{
MessageBox.Show(this, "Bass_Init error!");
this.Close();
return;
}
Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_BUFFER, 200);
Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_UPDATEPERIOD, 20);
// already create a mixer
_mixer = BassMix.BASS_Mixer_StreamCreate(44100, 2, BASSFlag.BASS_SAMPLE_FLOAT);
if (_mixer == 0)
{
MessageBox.Show(this, "Could not create mixer!");
Bass.BASS_Free();
this.Close();
return;
}
_mixerStallSync = new SYNCPROC(OnMixerStall);
Bass.BASS_ChannelSetSync(_mixer, BASSSync.BASS_SYNC_STALL, 0L, _mixerStallSync, IntPtr.Zero);
timerUpdate.Start();
Bass.BASS_ChannelPlay(_mixer, false);
}
public void AttachChannel(ChannelInfo info)
{
if (info is InputChannelInfo)
{
InputChannelInfo iinfo = (InputChannelInfo)info;
if (this.BassHandle.HasValue)
{
BassMix.BASS_Mixer_StreamAddChannel(this.BassHandle.Value, iinfo.Handler.OutputChannel, BASSFlag.BASS_MIXER_MATRIX | BASSFlag.BASS_MIXER_BUFFER);
}
}
else
{
if (!info.BassHandle.HasValue)
{
//Initialize to no sound as it's decoding anyway
info.Initialize(0);
}
this.streams.Add(info);
if (this.BassHandle.HasValue)
{
BassMix.BASS_Mixer_StreamAddChannel(this.BassHandle.Value, info.BassHandle.Value, BASSFlag.BASS_MIXER_MATRIX | BASSFlag.BASS_MIXER_BUFFER);
}
//Simple trick to refresh play status now it's attached
}
info.Play = info.Play;
}
/// <summary>
/// Creates a new instance of <see cref="MixedAudioProvider"/>.
/// </summary>
public MixedAudioProvider(IEnumerable <BassItem> RecordingDevices, IEnumerable <BassItem> LoopbackDevices)
{
if (RecordingDevices == null || LoopbackDevices == null)
{
throw new ArgumentNullException();
}
_mixer = BassMix.CreateMixerStream(44100, 2, BassFlags.Default);
_filler = Bass.CreateStream(44100, 2, BassFlags.Float | BassFlags.Decode, ManagedBass.Extensions.SilenceStreamProcedure);
foreach (var recordingDevice in RecordingDevices)
{
InitRecordingDevice(recordingDevice);
}
foreach (var loopbackDevice in LoopbackDevices)
{
InitLoopbackDevice(loopbackDevice);
}
// mute the mixer
Bass.ChannelSetAttribute(_mixer, ChannelAttribute.Volume, 0);
Bass.ChannelSetDSP(_mixer, Procedure);
}
