/// <summary> /// Register the Stream Freed Event /// </summary> /// <param name="stream"></param> /// <returns></returns> private int RegisterStreamFreedEvent(int stream) { int syncHandle = 0; syncHandle = Bass.BASS_ChannelSetSync(stream, BASSSync.BASS_SYNC_FREE | BASSSync.BASS_SYNC_MIXTIME, 0, _streamFreedDelegate, IntPtr.Zero); if (syncHandle == 0) { Log.Debug("BASS: RegisterStreamFreedEvent of stream {0} failed with error {1}", stream, Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode())); } return(syncHandle); }
private void PlayInternal(string path, double offset, double volume, double speed) { Queue <int> freelist; lock (handles) { if (!handles.ContainsKey(path)) { throw new InvalidOperationException("sound source was not registered."); } freelist = handles[path]; } int handle; lock (freelist) { if (freelist.Count > 0) { handle = freelist.Dequeue(); } else { handle = GetHandle(path); var proc = new SYNCPROC((h, channel, data, user) => { lock (freelist) freelist.Enqueue(handle); }); int syncHandle; syncHandle = Bass.BASS_ChannelSetSync(handle, BASSSync.BASS_SYNC_END, 0, proc, IntPtr.Zero); if (syncHandle == 0) { throw new InvalidOperationException("cannot set sync"); } lock (syncProcs) syncProcs.Add(proc); // avoid GC } } lock (playing) playing.Add(handle); Bass.BASS_ChannelSetPosition(handle, offset); Bass.BASS_ChannelSetAttribute(handle, BASSAttribute.BASS_ATTRIB_VOL, (float)volume); Bass.BASS_ChannelSetAttribute(handle, BASSAttribute.BASS_ATTRIB_TEMPO, (float)((speed - 1.0) * 100)); Bass.BASS_ChannelPlay(handle, false); }
public SoundEffectInstance(int bassHandle, bool loop, int loopstart, int loopend) { handle = bassHandle; // Store the handle Bass.BASS_ChannelGetAttribute(handle, BASSAttribute.BASS_ATTRIB_FREQ, ref baseSRate); // Store the original sample rate (for pitch bending) var sz = Bass.BASS_ChannelGetLength(handle); if (loopend > sz | (loopend - loopstart) < 3000) // Hax until i figure out wtf is going on with looping. { loopend = (int)sz; } //Console.WriteLine("{0} {1}", loopstart, loopend); if (loop) // If we loop { syncHandle = Bass.BASS_ChannelSetSync(handle, BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME, loopend, Engine.globalLoopProc, new IntPtr(loopstart)); // Set the global loop proc to take place at the loop end position, then return to the start. } looping = loop; // Loopyes }
/// <summary> /// Register the Playback end Event /// </summary> private int RegisterPlaybackEndEvent() { int syncHandle = 0; syncHandle = Bass.BASS_ChannelSetSync(_stream, BASSSync.BASS_SYNC_END, 0, PlaybackEndProcDelegate, IntPtr.Zero); if (syncHandle == 0) { int error = (int)Bass.BASS_ErrorGetCode(); log.Error("Player: RegisterPlaybackEndEvent of stream {0} failed with error {1}", _stream, error); } return(syncHandle); }
/// <summary> /// Called when a stream has been created. This actually starts the playback of the stream. /// </summary> /// <param name="track">The track that is to be played.</param> /// <param name="stream">The BASS.NET stream pointer to play.</param> protected virtual void StreamCreated(IAudioItem track, int stream) { // Init mixer if (_mixer == -1) { _mixer = BassMix.BASS_Mixer_StreamCreate(44100, 6, BASSFlag.BASS_MIXER_END); // Set playback done callback on mixer _channelEndCallback = new SYNCPROC(ChannelEnd); Bass.BASS_ChannelSetSync(_mixer, BASSSync.BASS_SYNC_END | BASSSync.BASS_SYNC_MIXTIME, 0, _channelEndCallback, IntPtr.Zero); } // Load streamin mixer bool ok = BassMix.BASS_Mixer_StreamAddChannel(_mixer, stream, BASSFlag.BASS_STREAM_AUTOFREE | BASSFlag.BASS_MIXER_MATRIX); if (!ok) { Log(Bass.BASS_ErrorGetCode().ToString(), Logger.LogLevel.Error); } // Set matrix SetMatrix(stream); // Remove current channel from mixer if (_currentStream != -1) { BassMix.BASS_Mixer_ChannelRemove(_currentStream); Bass.BASS_StreamFree(_currentStream); } // if (track is IWebcast) { SYNCPROC _mySync = new SYNCPROC(MetaSync); Bass.BASS_ChannelSetSync(_currentStream, BASSSync.BASS_SYNC_META, 0, _mySync, IntPtr.Zero); } // Play it! Bass.BASS_ChannelSetPosition(_mixer, 0); Bass.BASS_Start(); Bass.BASS_ChannelPlay(_mixer, false); // Set current stuff _currentStream = stream; }
public void StopFile(int handle, bool fadeOut, int fadeOutTime, bool isCrossFade) { if (!fadeOut || fadeOutTime == 0) { Bass.BASS_ChannelStop(handle); // no error handling, unimportant FileFinished(handle, true); } else { long pos = Bass.BASS_ChannelGetPosition(handle); long length = Bass.BASS_ChannelGetLength(handle); long remaining = length - pos; long fadeOutLength = Bass.BASS_ChannelSeconds2Bytes(handle, 0.001 * fadeOutTime); if (fadeOutLength == -1) { // on error, just stop the file Bass.BASS_ChannelStop(handle); FileFinished(handle, true); return; } if (pos == -1 || length == -1 || remaining <= 0) { // web radio doesn't have a length remaining = fadeOutLength; } if (fadeOutLength > remaining) { fadeOutLength = remaining; } // if (Bass.BASS_ChannelSetSync(handle, BASSSync.BASS_SYNC_POS, pos + fadeOutLength, m_StopSync, new IntPtr(0)) == 0) if (Bass.BASS_ChannelSetSync(handle, BASSSync.BASS_SYNC_SLIDE | BASSSync.BASS_SYNC_ONETIME, 0, m_StopSync, new IntPtr(handle)) == 0) { // on error, just stop the file Bass.BASS_ChannelStop(handle); FileFinished(handle, true); return; } FadeOut(handle, fadeOutTime); if (isCrossFade) { // call finished immediately to start the next file FileFinished(handle, false); } } }
public async Task OpenFile(string fileName) { _openningStream = fileName; Stop(); await Task.Run(() => { if (ActiveStreamHandle != 0) { ChannelPosition = 0; Bass.BASS_StreamFree(ActiveStreamHandle); } if (File.Exists(fileName)) { ActiveStreamHandle = Bass.BASS_StreamCreateFile(fileName, 0, 0, openFileConfig); if (ActiveStreamHandle != 0) { ChannelLength = Bass.BASS_ChannelBytes2Seconds(ActiveStreamHandle, Bass.BASS_ChannelGetLength(ActiveStreamHandle, 0)); //Obtain the sample rate of the sstream var info = new BASS_CHANNELINFO(); Bass.BASS_ChannelGetInfo(ActiveStreamHandle, info); sampleFrequency = info.freq; // Set the stream to call Stop() when it ends. int syncHandle = Bass.BASS_ChannelSetSync(ActiveStreamHandle, BASSSync.BASS_SYNC_END, 0, endTrackSyncProc, IntPtr.Zero); if (syncHandle == 0) { throw new ArgumentException("Error establishing End Sync on file stream.", "path"); } CanPlay = true; } else { Debug.WriteLine($"Failed to open file: {fileName},Error Code: {Bass.BASS_ErrorGetCode()}"); } } }); }
// callback that handles end of measure private void LoopEnd(int handle, int c, int data, IntPtr user) { // switch to random measure if not on hold if (!form.GetHold(nr)) { measure = random.Next(0, length + 1); form.SetTrackbar(nr, measure); // set end pos callback Bass.BASS_ChannelRemoveSync(channel, synchandle); synchandle = Bass.BASS_ChannelSetSync(channel, BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME, MeasuresToBytes(measure + 1), sync, IntPtr.Zero); } // move to start point Bass.BASS_ChannelSetPosition(channel, MeasuresToBytes(measure), BASSMode.BASS_POS_BYTE); //Console.WriteLine("Channel: " + channel + " Measure: " + measure); }
public async Task OpenUrl(string url) { _openningStream = url; Stop(); await Task.Run(() => { int handle = Bass.BASS_StreamCreateURL(url, 0, openUrlConfig, null, IntPtr.Zero); if (handle != 0) { if (_openningStream == url) { ActiveStreamHandle = handle; ChannelLength = Bass.BASS_ChannelBytes2Seconds(ActiveStreamHandle, Bass.BASS_ChannelGetLength(ActiveStreamHandle)); var info = new BASS_CHANNELINFO(); Bass.BASS_ChannelGetInfo(ActiveStreamHandle, info); sampleFrequency = info.freq; int syncHandle = Bass.BASS_ChannelSetSync(ActiveStreamHandle, BASSSync.BASS_SYNC_END, 0, endTrackSyncProc, IntPtr.Zero); if (syncHandle == 0) { throw new ArgumentException("Error establishing End Sync on file stream.", "url"); } CanPlay = true; } else { if (!Un4seen.Bass.Bass.BASS_StreamFree(handle)) { Debug.WriteLine("BASS_StreamFree() Failed:" + Un4seen.Bass.Bass.BASS_ErrorGetCode()); } } } else { Debug.WriteLine($"Failed to open URL: {url}, Error Code: {Bass.BASS_ErrorGetCode()}"); } }); }
private void PlayInternal(string path, TimeSpan offset) { Queue <int> freelist; lock (handles) { if (!handles.ContainsKey(path)) { throw new InvalidOperationException("sound source was not registered."); } freelist = handles[path]; } int handle; lock (freelist) { if (freelist.Count > 0) { handle = freelist.Dequeue(); } else { handle = GetHandle(path); var proc = new SYNCPROC((h, channel, data, user) => { lock (freelist) freelist.Enqueue(handle); }); int syncHandle; syncHandle = Bass.BASS_ChannelSetSync(handle, BASSSync.BASS_SYNC_END, 0, proc, IntPtr.Zero); if (syncHandle == 0) { throw new InvalidOperationException("cannot set sync"); } lock (syncProcs) syncProcs.Add(proc); // avoid GC } } lock (playing) playing.Add(handle); Bass.BASS_ChannelSetPosition(handle, offset.TotalSeconds); Bass.BASS_ChannelPlay(handle, false); }
public void PlaySound(string filename) { Bass.BASS_StreamFree(stream); syncCallback = new SYNCPROC(OnSongFinished); BASSActive isActive = default(BASSActive); isActive = Bass.BASS_ChannelIsActive(stream); if (isActive == BASSActive.BASS_ACTIVE_PLAYING) { Bass.BASS_ChannelStop(stream); } stream = Bass.BASS_StreamCreateURL(filename, 0, 0, null, IntPtr.Zero); Bass.BASS_ChannelSetAttribute(stream, BASSAttribute.BASS_ATTRIB_VOL, tbVolume.Value / 100F); Bass.BASS_ChannelSetSync(stream, BASSSync.BASS_SYNC_END, 0, syncCallback, IntPtr.Zero); //Bass.BASS_Init(deviceIndex, 44100, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero); Bass.BASS_SetDevice(deviceIndex); Bass.BASS_ChannelSetDevice(stream, deviceIndex); Bass.BASS_ChannelPlay(stream, false); }
/// <summary> /// Register the Fade out Event /// </summary> /// <param name="stream"></param> /// <returns></returns> private int RegisterCrossFadeEvent(int stream) { int syncHandle = 0; double fadeOutSeconds = Config.CrossFadeIntervalMs / 1000.0; long bytePos = Bass.BASS_ChannelSeconds2Bytes(stream, TotalStreamSeconds - fadeOutSeconds); syncHandle = Bass.BASS_ChannelSetSync(stream, BASSSync.BASS_SYNC_POS, bytePos, _playbackCrossFadeProcDelegate, IntPtr.Zero); if (syncHandle == 0) { Log.Debug("BASS: RegisterCrossFadeEvent of stream {0} failed with error {1}", stream, Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode())); } return(syncHandle); }
public Sync(ChannelHandle channelHandle, BASSSync syncType, Action <int, int, int, IntPtr> sync) { ChannelHandle = channelHandle; if (!ChannelHandle.Valid) { throw new ArgumentException("Invalid handle provided for sync."); } SyncType = syncType; _syncProcedure = new SYNCPROC(sync); Handle = Bass.BASS_ChannelSetSync(ChannelHandle.Handle, syncType, 0, _syncProcedure, IntPtr.Zero); if (!Valid) { throw new Exception($"Couldn't set sync procedure for channel handle {ChannelHandle.Handle.ToString("X8")}, file name {ChannelHandle.FileName}."); } }
/// <summary> /// Sets a SyncPos on the mixer stream /// </summary> /// <param name="stream"></param> /// <param name="timePos"></param> public void SetSyncPos(MusicStream stream, double timePos) { double fadeOutSeconds = Config.CrossFadeIntervalMs / 1000.0; double totalStreamLen = Bass.BASS_ChannelBytes2Seconds(stream.BassStream, Bass.BASS_ChannelGetLength(stream.BassStream, BASSMode.BASS_POS_BYTES)); long mixerPos = Bass.BASS_ChannelGetPosition(_mixer, BASSMode.BASS_POS_BYTES | BASSMode.BASS_POS_DECODE); long syncPos = mixerPos + Bass.BASS_ChannelSeconds2Bytes(_mixer, totalStreamLen - timePos - fadeOutSeconds); if (_syncProc != 0) { Bass.BASS_ChannelRemoveSync(_mixer, _syncProc); } GCHandle pFilePath = GCHandle.Alloc(stream); _syncProc = Bass.BASS_ChannelSetSync(_mixer, BASSSync.BASS_SYNC_ONETIME | BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME, syncPos, _playbackEndProcDelegate, GCHandle.ToIntPtr(pFilePath)); }
public void ChangeSpeed(float newValue) { speed = newValue; if (lysnc != 0) { Bass.BASS_ChannelRemoveSync(chan, lysnc); } chan = bass.ChangeSpeed(chan, SelectedSong.FilePath, newValue); if (lysnc != 0) { lysnc = Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_POS, endPos, LoopSync, (IntPtr)0); } if (this.PlayPause == "Pause") { Bass.BASS_ChannelPlay(chan, false); } }
private async Task PlayFileAsync(int currentIndex) { Bass.BASS_StreamFree(stream); try { var streamInfoSet = await client.GetVideoMediaStreamInfosAsync(videos[currentIndex].Id); var streamInfo = streamInfoSet.Muxed.WithHighestVideoQuality(); syncCallback = new SYNCPROC(OnSongFinished); stream = Bass.BASS_StreamCreateURL(streamInfo.Url, 0, 0, null, IntPtr.Zero); Bass.BASS_ChannelSetAttribute(stream, BASSAttribute.BASS_ATTRIB_VOL, tbVolume.Value / 100f); Bass.BASS_ChannelSetSync(stream, BASSSync.BASS_SYNC_END, 0, syncCallback, IntPtr.Zero); Bass.BASS_ChannelPlay(stream, false); tmSeek.Enabled = true; } catch (YoutubeExplode.Exceptions.VideoUnplayableException ex) { MessageBox.Show($"Видео не может быть воспроизведено, {ex.Message}", "Ошибка"); return; } }
public void playSong(int number, double position = 0) { playlist.config.currState = "play"; if (playlist.config.playlist.Count > 0) { playlist.config.currPlay = number; string file = playlist.config.playlist[playlist.config.currPlay].Path; Console.WriteLine(file); Stream = Bass.BASS_StreamCreateFile(file, 0, 0, BASSFlag.BASS_DEFAULT); if (Stream != 0) { setPosition(position); Bass.BASS_ChannelPlay(stream, false); } else { Console.WriteLine("Stream error: {0}", Bass.BASS_ErrorGetCode()); } handleSynchronizationEndStream = Bass.BASS_ChannelSetSync(Stream, BASSSync.BASS_SYNC_END, 0, syncProcEndStream, IntPtr.Zero); } }
static TrackViewModel BuildNetTags() { var t = new TrackViewModel(); // get the meta tags (manually - will not work for WMA streams here) string[] icy = Bass.BASS_ChannelGetTagsICY(Player.Instance.Wave.Handle); if (icy == null) { // try http... icy = Bass.BASS_ChannelGetTagsHTTP(Player.Instance.Wave.Handle); } if (icy != null) { t.Title = icy.Where(c => c.Contains("icy-name:")).First().Replace("icy-name:", ""); t.Bitrate = Convert.ToUInt32(icy.Where(c => c.Contains("icy-br:")).First().Replace("icy-br:", "")); } _tagInfo = new TAG_INFO(Player.Instance.Wave.Path); t.Path = Player.Instance.Wave.Path; if (BassTags.BASS_TAG_GetFromURL(Player.Instance.Wave.Handle, _tagInfo)) { // and display what we get t.Album = _tagInfo.album; t.Artist = _tagInfo.artist; if (!String.IsNullOrEmpty(_tagInfo.title)) { t.Title = _tagInfo.title; } t.Genre = _tagInfo.genre; if (t.Bitrate == 0) { t.Bitrate = (uint)_tagInfo.bitrate; } } mySync = new SYNCPROC(MetaSync); Bass.BASS_ChannelSetSync(Player.Instance.Wave.Handle, BASSSync.BASS_SYNC_META, 0, mySync, IntPtr.Zero); return(t); }
public static void Play(string file, bool loadOnly) { Stop(); baseStreamHandle = Bass.BASS_StreamCreateFile(file, 0, 0, BASSFlag.BASS_STREAM_DECODE); BASS_CHANNELINFO info = Bass.BASS_ChannelGetInfo(baseStreamHandle); mixStreamHandle = BassMix.BASS_Mixer_StreamCreate(info.freq, info.chans, BASSFlag.BASS_STREAM_DECODE); BassMix.BASS_Mixer_StreamAddChannel(mixStreamHandle, baseStreamHandle, BASSFlag.BASS_MIXER_MATRIX); streamHandle = BassFx.BASS_FX_TempoCreate(mixStreamHandle, BASSFlag.BASS_FX_FREESOURCE); Mono = mono; Speed = speed; if (!loadOnly) { Bass.BASS_ChannelPlay(streamHandle, false); } BASSError er = Bass.BASS_ErrorGetCode(); syncProc = new SYNCPROC(AudioEnded); Bass.BASS_ChannelSetSync(streamHandle, BASSSync.BASS_SYNC_END, 0, syncProc, IntPtr.Zero); Playing = !loadOnly; FileLoaded = true; }
public void Play(int volume) { Stop(); if (InitBass(HZ)) { Stream = Bass.BASS_StreamCreateURL(URL, 0, BASSFlag.BASS_DEFAULT, null, IntPtr.Zero); tagInfo = new TAG_INFO(URL); if (BassTags.BASS_TAG_GetFromURL(Stream, tagInfo)) { UpdatePlayList(); } mySync = new SYNCPROC(MetaSync); Bass.BASS_ChannelSetSync(Stream, BASSSync.BASS_SYNC_META, 0, mySync, IntPtr.Zero); Bass.BASS_ChannelPlay(Stream, false); //Установка громкости Bass.BASS_ChannelSetAttribute(Stream, BASSAttribute.BASS_ATTRIB_VOL, volume / 100f); } }
private void Play_B_Click(object sender, System.Windows.RoutedEventArgs e) { if (IsClosing) { return; } if (Sound_List.SelectedIndex == -1) { return; } else if (!File.Exists(Voice_Set.Special_Path + "/Wwise/Temp_02.ogg")) { Message_Feed_Out("サウンドファイルが変換されませんでした。"); return; } if (SelectIndex == Sound_List.SelectedIndex) { Bass.BASS_ChannelPlay(Stream, false); } else { Bass.BASS_ChannelStop(Stream); Location_S.Value = 0; Bass.BASS_StreamFree(Stream); int StreamHandle = Bass.BASS_StreamCreateFile(Voice_Set.Special_Path + "/Wwise/Temp_02.wav", 0, 0, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_LOOP); Stream = BassFx.BASS_FX_TempoCreate(StreamHandle, BASSFlag.BASS_FX_FREESOURCE); IsMusicEnd = new SYNCPROC(EndSync); Bass.BASS_ChannelSetDevice(Stream, Video_Mode.Sound_Device); Bass.BASS_ChannelSetSync(Stream, BASSSync.BASS_SYNC_END | BASSSync.BASS_SYNC_MIXTIME, 0, IsMusicEnd, IntPtr.Zero); Bass.BASS_ChannelPlay(Stream, true); Bass.BASS_ChannelSetAttribute(Stream, BASSAttribute.BASS_ATTRIB_VOL, (float)Volume_S.Value / 100); Bass.BASS_ChannelGetAttribute(Stream, BASSAttribute.BASS_ATTRIB_TEMPO_FREQ, ref SetFirstFreq); Bass.BASS_ChannelSetAttribute(Stream, BASSAttribute.BASS_ATTRIB_TEMPO_FREQ, SetFirstFreq + (float)Speed_S.Value); SelectIndex = Sound_List.SelectedIndex; Location_S.Maximum = Bass.BASS_ChannelBytes2Seconds(Stream, Bass.BASS_ChannelGetLength(Stream, BASSMode.BASS_POS_BYTES)); Speed_T.Text = "速度:" + (SetFirstFreq + Math.Floor(Speed_S.Value)); } IsPaused = false; }
private void SetRepeatRange(TimeSpan startTime, TimeSpan endTime) { if (repeatSyncId != 0) { Bass.BASS_ChannelRemoveSync(ActiveStreamHandle, repeatSyncId); } if ((endTime - startTime) > TimeSpan.FromMilliseconds(repeatThreshold)) { long channelLength = Bass.BASS_ChannelGetLength(ActiveStreamHandle); long endPosition = (long)((endTime.TotalSeconds / ChannelLength) * channelLength); repeatSyncId = Bass.BASS_ChannelSetSync(ActiveStreamHandle, BASSSync.BASS_SYNC_POS, (long)endPosition, repeatSyncProc, IntPtr.Zero); ChannelPosition = SelectionBegin.TotalSeconds; } else { ClearRepeatRange(); } }
public void Loop(Preset preset) { this.Pause(); startPos = Bass.BASS_ChannelSeconds2Bytes(chan, preset.Begin); endPos = Bass.BASS_ChannelSeconds2Bytes(chan, preset.End); LoopSync = new SYNCPROC(ProcSync); if (lysnc != 0) { Bass.BASS_ChannelRemoveSync(chan, lysnc); } lysnc = Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_POS, endPos, LoopSync, (IntPtr)0); long curPos = Bass.BASS_ChannelGetPosition(chan); if (curPos < startPos || curPos >= endPos) { Bass.BASS_ChannelSetPosition(chan, startPos, BASSMode.BASS_POS_BYTES); } this.Play(); }
protected override void OnLoopEndUpdated() { if (this.BassHandle.HasValue) { if (loopSyncHandle > 0) { Bass.BASS_ChannelRemoveSync(this.BassHandle.Value, loopSyncHandle); _mySyncProc = null; } _mySyncProc = new SYNCPROC(LoopEndReached); long end; if (this.LoopEnd == 0) { end = Bass.BASS_ChannelSeconds2Bytes(this.BassHandle.Value, this.Length); } else { end = Bass.BASS_ChannelSeconds2Bytes(this.BassHandle.Value, this.LoopEnd); } loopSyncHandle = Bass.BASS_ChannelSetSync(this.BassHandle.Value, BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME, end, _mySyncProc, IntPtr.Zero); } }
private void AudioToSpeaker(byte[] buffer, int offset, int length) { // Write compressed audio data to Circulairbuffer lock (lockObject) { cbbListenAudio.Write(buffer, offset, length); // When not listening to audio clear buffer up to 16 kb if (listenHandle == 0) { // Purge circulair buffer // we only keep 16 kb in memory while (cbbListenAudio.UsedBytes > (16 * 1024)) { byte[] dummyBuffer = new byte[1024]; cbbListenAudio.Read(dummyBuffer, 1024); } //while } } if (!listen && listenHandle == 0) { return; } // Geluid wordt uitgezet if (!listen && listenHandle != 0) { Bass.BASS_ChannelStop(listenHandle); Bass.BASS_StreamFree(listenHandle); listenHandle = 0; return; } // Geluid wordt aangezet if (listen && listenHandle == 0 && cbbListenAudio.UsedBytes >= 8000) { // bass needs for mp3 atleast 4000 bytes before is can play listenHandle = Bass.BASS_StreamCreateFileUser(BASSStreamSystem.STREAMFILE_BUFFERPUSH, BASSFlag.BASS_DEFAULT, bassFileProcsOut, GCHandle.ToIntPtr((GCHandle)gcHandle)); Bass.BASS_ChannelSetSync(listenHandle, BASSSync.BASS_SYNC_STALL, 0, bassStalledSync, GCHandle.ToIntPtr((GCHandle)gcHandle)); Bass.BASS_ChannelSetSync(listenHandle, BASSSync.BASS_SYNC_END, 0, bassEndSync, GCHandle.ToIntPtr((GCHandle)gcHandle)); Bass.BASS_ChannelPlay(listenHandle, false); } // push new audiodata when available (and basstream is opened) if (listenHandle != 0) { // voed bass met audio data zodat deze het naar pcm data kan decompressen long bassBufLen = Bass.BASS_StreamGetFilePosition(listenHandle, BASSStreamFilePosition.BASS_FILEPOS_END); long bassBufPos = Bass.BASS_StreamGetFilePosition(listenHandle, BASSStreamFilePosition.BASS_FILEPOS_BUFFER); int todo = Convert.ToInt32(bassBufLen - bassBufPos); if (todo > 0) { int count = todo; int writeBytes = 0; while (!cbbListenAudio.IsEmpty && todo > 0 && writeBytes > -1) { if (count > 16384) { count = 16384; } byte[] tmpBuffer = new byte[count]; lock (lockObject) { count = cbbListenAudio.Read(tmpBuffer, count); } if (count > 0) { writeBytes = Bass.BASS_StreamPutFileData(listenHandle, tmpBuffer, count); todo -= writeBytes; } } //while audio buffer not empty } } }
private void ProcessStreamData(byte[] buffer, int offset, int length) { if (length < 1) { return; } // Write compressed audio data to Circulairbuffer byte[] data = new byte[length]; Buffer.BlockCopy(buffer, offset, data, 0, length); lock (lockObject) { cbbChunkAudio.Write(buffer, offset, length); } // If basshandle wasn't opened then open it now (when there is enough data. Min 4010 bytes) if (inputHandle == 0 && cbbChunkAudio.UsedBytes >= 8000) { // bass needs for mp3 atleast 4000 bytes before is can play inputHandle = Bass.BASS_StreamCreateFileUser(BASSStreamSystem.STREAMFILE_BUFFERPUSH, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT, bassFileProcs, GCHandle.ToIntPtr((GCHandle)gcHandle)); Bass.BASS_ChannelSetSync(inputHandle, BASSSync.BASS_SYNC_STALL, 0, bassStalledSync, GCHandle.ToIntPtr((GCHandle)gcHandle)); Bass.BASS_ChannelSetSync(inputHandle, BASSSync.BASS_SYNC_END, 0, bassEndSync, GCHandle.ToIntPtr((GCHandle)gcHandle)); mixerHandle = BassMix.BASS_Mixer_StreamCreate(44100, 2, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT); BassMix.BASS_Mixer_StreamAddChannel(mixerHandle, inputHandle, BASSFlag.BASS_MIXER_FILTER | BASSFlag.BASS_MIXER_DOWNMIX); Bass.BASS_ChannelPlay(inputHandle, false); Bass.BASS_ChannelPlay(mixerHandle, false); return; } // push new audiodata when available (and basstream is opened) if (inputHandle != 0) { // voed bass met audio data zodat deze het naar pcm data kan decompressen long bassBufLen = Bass.BASS_StreamGetFilePosition(inputHandle, BASSStreamFilePosition.BASS_FILEPOS_END); long bassBufPos = Bass.BASS_StreamGetFilePosition(inputHandle, BASSStreamFilePosition.BASS_FILEPOS_BUFFER); int todo = Convert.ToInt32(bassBufLen - bassBufPos); if (todo > 0) { int count = todo; int writeBytes = 0; while (!cbbChunkAudio.IsEmpty && todo > 0 && writeBytes > -1) { if (count > 16384) { count = 16384; } byte[] tmpBuffer = new byte[count]; lock (lockObject) { count = cbbChunkAudio.Read(tmpBuffer, count); } if (count > 0) { writeBytes = Bass.BASS_StreamPutFileData(inputHandle, tmpBuffer, count); todo -= writeBytes; } } //while audio buffer not empty } ProcessDecompressedData(); } }
private void OpenMIDIButton_Click(object sender, EventArgs e) { if (OpenMIDI.ShowDialog() == DialogResult.OK) { Bass.BASS_StreamFree(chan); if (!IsWinXPOrOlder()) { BassWasapi.BASS_WASAPI_Free(); WasapiProc = new WASAPIPROC(MyWasapiProc); BassWasapi.BASS_WASAPI_Init(-1, 0, 2, BASSWASAPIInit.BASS_WASAPI_BUFFER | BASSWASAPIInit.BASS_WASAPI_SHARED, 0.5f, 0, WasapiProc, IntPtr.Zero); } LoopSyncProc = null; LyricSyncProc = null; EndSyncProc = null; TempoSyncProc = null; LyricsFromStream.Text = ""; if ((chan = BassMidi.BASS_MIDI_StreamCreateFile(OpenMIDI.FileName, 0L, 0L, (IsWinXPOrOlder() ? BASSFlag.BASS_DEFAULT : (BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT)) | BASSFlag.BASS_MIDI_DECAYEND | (RvAndChr.Checked ? BASSFlag.BASS_MIDI_NOFX : 0), 0)) == 0) { OpenMIDIButton.Text = "Click here to open a file..."; MIDITitle.Text = ""; Position.Text = "-"; Error("Can't play the file"); return; } Bass.BASS_ChannelSetAttribute(chan, BASSAttribute.BASS_ATTRIB_MIDI_VOICES, VoiceBar.Value); // apply to current MIDI file too Bass.BASS_ChannelSetAttribute(chan, BASSAttribute.BASS_ATTRIB_MIDI_CPU, CPUBar.Value); // apply to current MIDI file too OpenMIDIButton.Text = OpenMIDI.FileName; { // set the title (track name of first track) BASS_MIDI_MARK mark = new BASS_MIDI_MARK(); if (BassMidi.BASS_MIDI_StreamGetMark(chan, BASSMIDIMarker.BASS_MIDI_MARK_TRACK, 0, mark) && mark.track == 0) { MIDITitle.Text = mark.text; } else { MIDITitle.Text = ""; } } TrackbarStream.Value = 0; TrackbarStream.Minimum = 0; TrackbarStream.Maximum = (int)Bass.BASS_ChannelGetLength(chan, BASSMode.BASS_POS_MIDI_TICK) / 120; { // set looping syncs BASS_MIDI_MARK mark = new BASS_MIDI_MARK(); LoopSyncProc = new SYNCPROC(LoopSync); if (FindMarker(chan, "loopend", mark)) // found a loop end point { Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME, mark.pos, LoopSyncProc, IntPtr.Zero); // set a sync there } Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_END | BASSSync.BASS_SYNC_MIXTIME, 0, LoopSyncProc, IntPtr.Zero); // set one at the end too (eg. in case of seeking past the loop point) } { // clear lyrics buffer and set lyrics syncs BASS_MIDI_MARK mark = new BASS_MIDI_MARK(); LyricSyncProc = new SYNCPROC(LyricSync); EndSyncProc = new SYNCPROC(EndSync); lyrics = ""; if (BassMidi.BASS_MIDI_StreamGetMark(chan, BASSMIDIMarker.BASS_MIDI_MARK_LYRIC, 0, mark)) // got lyrics { Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_MIDI_MARKER, (long)BASSMIDIMarker.BASS_MIDI_MARK_LYRIC, LyricSyncProc, (IntPtr)BASSMIDIMarker.BASS_MIDI_MARK_LYRIC); } else if (BassMidi.BASS_MIDI_StreamGetMark(chan, BASSMIDIMarker.BASS_MIDI_MARK_TEXT, 20, mark)) // got text instead (over 20 of them) { Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_MIDI_MARKER, (long)BASSMIDIMarker.BASS_MIDI_MARK_TEXT, LyricSyncProc, (IntPtr)BASSMIDIMarker.BASS_MIDI_MARK_TEXT); } Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_END, 0, EndSyncProc, IntPtr.Zero); } { // override the initial tempo, and set a sync to override tempo events and another to override after seeking SetTempo(true); TempoSyncProc = new SYNCPROC(TempoSync); Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_MIDI_EVENT | BASSSync.BASS_SYNC_MIXTIME, (long)BASSMIDIEvent.MIDI_EVENT_TEMPO, TempoSyncProc, IntPtr.Zero); Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_SETPOS | BASSSync.BASS_SYNC_MIXTIME, 0, TempoSyncProc, IntPtr.Zero); } { // get default soundfont in case of matching soundfont being used BASS_MIDI_FONT[] sf = { new BASS_MIDI_FONT(font, fontp, fontb) }; // now set them BassMidi.BASS_MIDI_StreamSetFonts(chan, sf, sf.Length); } } Bass.BASS_ChannelSetAttribute(chan, BASSAttribute.BASS_ATTRIB_MIDI_CPU, 95); if (PlayPauseBtn.Text != "Pause") { if (IsWinXPOrOlder()) { Bass.BASS_ChannelPlay(chan, true); } else { BassWasapi.BASS_WASAPI_Start(); } } }
/// <summary> /// Create the stream for the file assigned to the Musicstream /// </summary> private void CreateStream() { if (!_temporaryStream) { Log.Info("BASS: ---------------------------------------------"); Log.Info("BASS: Creating BASS audio stream"); } BASSFlag streamFlags = BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE; _fileType = Utils.GetFileType(_filePath); switch (_fileType.FileMainType) { case FileMainType.Unknown: return; case FileMainType.AudioFile: case FileMainType.MidiFile: _stream = Bass.BASS_StreamCreateFile(_filePath, 0, 0, streamFlags); if (!_temporaryStream) { // Read the Tag _musicTag = TagReader.TagReader.ReadTag(_filePath); } break; case FileMainType.CDTrack: // StreamCreateFile causes problems with Multisession disks, so use StreamCreate with driveindex and track index int driveindex = Config.CdDriveLetters.IndexOf(_filePath.Substring(0, 1)); int tracknum = Convert.ToInt16(_filePath.Substring(_filePath.IndexOf(".cda") - 2, 2)); _stream = BassCd.BASS_CD_StreamCreate(driveindex, tracknum - 1, streamFlags); break; case FileMainType.MODFile: _stream = Bass.BASS_MusicLoad(_filePath, 0, 0, BASSFlag.BASS_SAMPLE_SOFTWARE | BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_MUSIC_DECODE | BASSFlag.BASS_MUSIC_PRESCAN | BASSFlag.BASS_MUSIC_RAMP, 0); break; case FileMainType.WebStream: // Turn on parsing of ASX files Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_NET_PLAYLIST, 2); _stream = Bass.BASS_StreamCreateURL(_filePath, 0, streamFlags, null, IntPtr.Zero); if (_stream != 0 && !_temporaryStream) { // Get the Tags and set the Meta Tag SyncProc _tagInfo = new TAG_INFO(_filePath); SetStreamTags(_stream); if (BassTags.BASS_TAG_GetFromURL(_stream, _tagInfo)) { GetMetaTags(); } Bass.BASS_ChannelSetSync(_stream, BASSSync.BASS_SYNC_META, 0, _metaTagSyncProcDelegate, IntPtr.Zero); Log.Debug("BASS: Webstream found - fetching stream {0}", Convert.ToString(_stream)); } break; } if (_stream == 0) { Log.Error("BASS: Unable to create Stream for {0}. Reason: {1}.", _filePath, Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode())); return; } // When we have a MIDI file, we need to assign the sound banks to the stream if (_fileType.FileMainType == FileMainType.MidiFile && Config.SoundFonts != null) { BassMidi.BASS_MIDI_StreamSetFonts(_stream, Config.SoundFonts, Config.SoundFonts.Length); } _channelInfo = Bass.BASS_ChannelGetInfo(_stream); if (Bass.BASS_ErrorGetCode() != BASSError.BASS_OK) { Log.Error("BASS: Unable to get information for stream {0}. Reason: {1}.", _filePath, Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode())); return; } // This stream has just been created to check upfront, the sample rate // We don't need further processing of this stream if (_temporaryStream) { return; } Log.Info("BASS: Stream Information"); Log.Info("BASS: ---------------------------------------------"); Log.Info("BASS: File: {0}", _filePath); Log.Debug("BASS: Type of Stream: {0}", _channelInfo.ctype); Log.Info("BASS: Number of Channels: {0}", _channelInfo.chans); Log.Info("BASS: Stream Samplerate: {0}", _channelInfo.freq); Log.Debug("BASS: Stream Flags: {0}", _channelInfo.flags); Log.Info("BASS: ---------------------------------------------"); Log.Debug("BASS: Registering stream playback events"); RegisterPlaybackEvents(); AttachDspToStream(); if (Config.EnableReplayGain && _musicTag != null) { SetReplayGain(); } Log.Info("BASS: Successfully created BASS audio stream"); Log.Info("BASS: ---------------------------------------------"); }
private void btnPlay_Click(object sender, EventArgs e) { updateTimer.Stop(); Bass.BASS_StreamFree(stream); if (filename != string.Empty) { stream = Bass.BASS_StreamCreateFile(filename, 0, 0, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_PRESCAN); if (stream != 0) { mslength = (int)Bass.BASS_ChannelSeconds2Bytes(stream, 0.03); deviceLatencyBytes = (int)Bass.BASS_ChannelSeconds2Bytes(stream, deviceLatencyMS / 1000.0); myDSPAddr = new DSPPROC(MyDSPGain); Bass.BASS_ChannelSetDSP(stream, myDSPAddr, IntPtr.Zero, 2); if (WF2 != null && WF2.IsRendered) { WF2.SyncPlayback(stream); long cuein = WF2.GetMarker("CUE"); long cueout = WF2.GetMarker("END"); int cueinFrame = WF2.Position2Frames(cuein); int cueoutFrame = WF2.Position2Frames(cueout); if (cuein >= 0) { Bass.BASS_ChannelSetPosition(stream, cuein); } if (cueout >= 0) { Bass.BASS_ChannelRemoveSync(stream, syncer); syncer = Bass.BASS_ChannelSetSync(stream, BASSSync.BASS_SYNC_POS, cueout, sync, IntPtr.Zero); } } } if (stream != 0 && Bass.BASS_ChannelPlay(stream, false)) { textBox1.Text = ""; updateTimer.Start(); BASS_CHANNELINFO info = new BASS_CHANNELINFO(); Bass.BASS_ChannelGetInfo(stream, info); textBox1.Text += "Info: " + info.ToString() + Environment.NewLine; TAG_INFO tagInfo = new TAG_INFO(); if (BassTags.BASS_TAG_GetFromFile(stream, tagInfo)) { textBoxAlbum.Text = tagInfo.album; textBoxArtist.Text = tagInfo.artist; textBoxTitle.Text = tagInfo.title; textBoxComment.Text = tagInfo.comment; textBoxGenre.Text = tagInfo.genre; textBoxYear.Text = tagInfo.year; textBoxTrack.Text = tagInfo.track; } btnStop.Enabled = true; btnPlay.Enabled = false; } } }
public int PlayFile(ISoundFile file, int fadeInTime, PlayingFinished callback, bool loop) { int channel = 0; BASSFlag speakerFlag = GetSpeakerFlag(file); BASSFlag decodeFlag = BASSFlag.BASS_STREAM_DECODE; if (file.SoundFileType == SoundFileType.Music && file.Effects.SpeakerAssignment.Active) { switch (file.Effects.SpeakerAssignment.Assignment) { case Data.SpeakerAssignment.AllSpeakers: case Data.SpeakerAssignment.BothCenterRears: case Data.SpeakerAssignment.BothFronts: case Data.SpeakerAssignment.BothRears: case Data.SpeakerAssignment.CenterAndSubwoofer: case Data.SpeakerAssignment.Default: break; default: decodeFlag |= BASSFlag.BASS_SAMPLE_MONO; break; } } #if MONO System.Runtime.InteropServices.GCHandle gcHandle = new System.Runtime.InteropServices.GCHandle(); #endif if (file.SoundFileType == SoundFileType.WebRadio) { channel = Bass.BASS_StreamCreateURL(file.Path, 0, decodeFlag | BASSFlag.BASS_STREAM_BLOCK, null, IntPtr.Zero); } else { #if MONO byte[] buffer = null; long length = 0; try { #if ANDROID if (file.Path.IsSmbFile()) { buffer = SambaHelpers.GetFileContent(file.Path); length = buffer.Length; } else { #endif System.IO.FileStream fs = System.IO.File.OpenRead(file.Path); length = fs.Length; buffer = new byte[length]; fs.Read(buffer, 0, (int)length); fs.Close(); #if ANDROID } #endif } catch (System.IO.IOException e) { ErrorHandling.ErrorOccurred(file.Id, e.Message); return(0); } gcHandle = System.Runtime.InteropServices.GCHandle.Alloc(buffer, System.Runtime.InteropServices.GCHandleType.Pinned); channel = Bass.BASS_StreamCreateFile(gcHandle.AddrOfPinnedObject(), 0L, length, decodeFlag); #else // #if MONO channel = Bass.BASS_StreamCreateFile(file.Path, 0, 0, decodeFlag); #endif } if (channel == 0) { #if MONO if (gcHandle.IsAllocated) { gcHandle.Free(); } #endif ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); return(0); } RunningFileInfo info = new RunningFileInfo(); bool isStreaming = BassStreamer.Instance.IsStreaming; bool useMultiSpeakerChannels = false; int speakers = 2; int origChannel = channel; if (!isStreaming && file.Effects != null && file.Effects.SpeakerAssignment.Active && file.Effects.SpeakerAssignment.Assignment == Data.SpeakerAssignment.AllSpeakers && !file.Effects.Balance.Active && !file.Effects.Pitch.Active && !file.Effects.Tempo.Active) { speakers = Bass.BASS_GetInfo().speakers; if (speakers > 2) { useMultiSpeakerChannels = true; } } Un4seen.Bass.BASSFlag flags = BASSFlag.BASS_DEFAULT; if (isStreaming) { flags = BASSFlag.BASS_FX_FREESOURCE | BASSFlag.BASS_STREAM_DECODE; } else if (useMultiSpeakerChannels) { flags = BASSFlag.BASS_FX_FREESOURCE | BASSFlag.BASS_STREAM_DECODE; } else { flags = BASSFlag.BASS_STREAM_AUTOFREE | BASSFlag.BASS_FX_FREESOURCE | speakerFlag; } channel = Un4seen.Bass.AddOn.Fx.BassFx.BASS_FX_TempoCreate(channel, flags); if (channel == 0) { #if MONO if (gcHandle.IsAllocated) { gcHandle.Free(); } #endif ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); return(0); } bool result = true; if (useMultiSpeakerChannels) { int splitStream = Un4seen.Bass.AddOn.Mix.BassMix.BASS_Split_StreamCreate(channel, BASSFlag.BASS_STREAM_AUTOFREE | BASSFlag.BASS_SPEAKER_FRONT, null); if (splitStream == 0) { result = false; } else { int splitStream2 = Un4seen.Bass.AddOn.Mix.BassMix.BASS_Split_StreamCreate(channel, BASSFlag.BASS_STREAM_AUTOFREE | BASSFlag.BASS_SPEAKER_REAR, null); if (splitStream2 == 0) { result = false; } else { Bass.BASS_ChannelSetLink(splitStream, splitStream2); info.LinkedChannels = new List <int>(); info.LinkedChannels.Add(splitStream2); } if (result && speakers > 4) { int splitStream3 = Un4seen.Bass.AddOn.Mix.BassMix.BASS_Split_StreamCreate(channel, BASSFlag.BASS_STREAM_AUTOFREE | BASSFlag.BASS_SPEAKER_CENLFE, null); if (splitStream3 == 0) { result = false; } else { Bass.BASS_ChannelSetLink(splitStream, splitStream3); info.LinkedChannels.Add(splitStream3); } } if (result && speakers > 6) { int splitStream4 = Un4seen.Bass.AddOn.Mix.BassMix.BASS_Split_StreamCreate(channel, BASSFlag.BASS_STREAM_AUTOFREE | BASSFlag.BASS_SPEAKER_REAR2, null); if (splitStream4 == 0) { result = false; } else { Bass.BASS_ChannelSetLink(splitStream, splitStream4); info.LinkedChannels.Add(splitStream4); } } if (result) { channel = splitStream; } } } if (result) { lock (m_Mutex) { info.EndAction = new Action(() => { callback(file.Id, channel); }); info.Volume = file.Volume; } if (!loop) { int sync = 0; // If CueOut is active ... if (file.Effects.CueOut.Active) { // Convert the CueOut position (seconds) into a byte offset long cueOutPos = Bass.BASS_ChannelSeconds2Bytes(channel, file.Effects.CueOut.Position); // Set the "end" sync to that position sync = Bass.BASS_ChannelSetSync(channel, BASSSync.BASS_SYNC_POS, cueOutPos, m_CueOutSync, new IntPtr(file.Id)); } else { long totalLength = Bass.BASS_ChannelGetLength(channel); long endingTime = Bass.BASS_ChannelSeconds2Bytes(channel, 0.1); // Default: set the "end" sync to the end of the stream, minus one ms sync = Bass.BASS_ChannelSetSync(channel, BASSSync.BASS_SYNC_POS, totalLength - endingTime, m_StartNextSync, IntPtr.Zero); } if (sync == 0) { #if MONO if (gcHandle.IsAllocated) { gcHandle.Free(); } #endif ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); return(0); } else { lock (m_Mutex) { m_NotLoops[channel] = sync; } } } if (!SetStartVolume(file, fadeInTime, channel, info)) { return(0); } info.CrossFade = false; if (file.Effects != null && file.Effects.FadeOutTime != 0) { long totalLength = Bass.BASS_ChannelGetLength(channel); if (totalLength == -1) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetVolumeError); return(0); } long fadeOutLength = Bass.BASS_ChannelSeconds2Bytes(channel, 0.001 * file.Effects.FadeOutTime); if (fadeOutLength == -1) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetVolumeError); return(0); } if (fadeOutLength > totalLength) { fadeOutLength = totalLength; } // If CueOut is active ... if (file.Effects.CueOut.Active) { // Convert the CueOut position (seconds) into a byte offset long cueOutPos = Bass.BASS_ChannelSeconds2Bytes(channel, file.Effects.CueOut.Position); // Set the "end" sync to that position if (Bass.BASS_ChannelSetSync(channel, BASSSync.BASS_SYNC_POS, cueOutPos - fadeOutLength, m_FadeOutSync, new IntPtr(file.Effects.FadeOutTime)) == 0) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); return(0); } } else { if (Bass.BASS_ChannelSetSync(channel, BASSSync.BASS_SYNC_POS, totalLength - fadeOutLength, m_FadeOutSync, new IntPtr(file.Effects.FadeOutTime)) == 0) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); return(0); } } if (loop) { // If CueOut is active ... if (file.Effects.CueOut.Active) { // Convert the CueOut position (seconds) into a byte offset long cueOutPos = Bass.BASS_ChannelSeconds2Bytes(channel, file.Effects.CueOut.Position); // Set the "end" sync to that position if (Bass.BASS_ChannelSetSync(channel, BASSSync.BASS_SYNC_POS, cueOutPos, m_LoopSync, new IntPtr(file.Id)) == 0) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); return(0); } } else { if (Bass.BASS_ChannelSetSync(channel, BASSSync.BASS_SYNC_POS, totalLength, m_LoopSync, new IntPtr(file.Id)) == 0) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); return(0); } } } else { info.CrossFade = file.Effects.CrossFading; } } if (file.Effects != null && file.Effects.Pitch.Active) { float pitchValue = DetermineIntEffectValue(file.Effects.Pitch); if (!Bass.BASS_ChannelSetAttribute(channel, BASSAttribute.BASS_ATTRIB_TEMPO_PITCH, pitchValue)) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } } if (file.Effects != null && file.Effects.Tempo.Active) { float tempoValue = DetermineIntEffectValue(file.Effects.Tempo); if (!Bass.BASS_ChannelSetAttribute(channel, BASSAttribute.BASS_ATTRIB_TEMPO, tempoValue)) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } } if (file.Effects != null && file.Effects.Balance.Active && !useMultiSpeakerChannels) { SetBalanceEffect(channel, file.Id, file.Effects.Balance); } if (file.Effects != null && file.Effects.VolumeDB.Active) { float volumeDB = DetermineIntEffectValue(file.Effects.VolumeDB); float linear = (float)Math.Pow(10d, volumeDB / 20); int volFx = Bass.BASS_ChannelSetFX(channel, BASSFXType.BASS_FX_BFX_VOLUME, 1); if (volFx == 0) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } Un4seen.Bass.AddOn.Fx.BASS_BFX_VOLUME fxVol = new Un4seen.Bass.AddOn.Fx.BASS_BFX_VOLUME(linear, Un4seen.Bass.AddOn.Fx.BASSFXChan.BASS_BFX_CHANALL); if (!Bass.BASS_FXSetParameters(volFx, fxVol)) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } if (info.LinkedChannels != null) { foreach (int splitStream2 in info.LinkedChannels) { int volFx2 = splitStream2 != 0 ? Bass.BASS_ChannelSetFX(splitStream2, BASSFXType.BASS_FX_BFX_VOLUME, 1) : 0; if (splitStream2 != 0 && volFx2 == 0) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } if (volFx2 != 0 && !Bass.BASS_FXSetParameters(volFx2, fxVol)) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } } } } #pragma warning disable CS0618 // Type or member is obsolete if (file.Effects != null && file.Effects.Reverb.Active) { float linearLevel = (float)Math.Pow(10d, file.Effects.Reverb.Level / 20); int reverbFx = Bass.BASS_ChannelSetFX(channel, BASSFXType.BASS_FX_BFX_REVERB, 1); if (reverbFx == 0) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } Un4seen.Bass.AddOn.Fx.BASS_BFX_REVERB fxReverb = new Un4seen.Bass.AddOn.Fx.BASS_BFX_REVERB(linearLevel, file.Effects.Reverb.Delay); if (!Bass.BASS_FXSetParameters(reverbFx, fxReverb)) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } if (info.LinkedChannels != null) { foreach (int splitStream2 in info.LinkedChannels) { int reverbFx2 = splitStream2 != 0 ? Bass.BASS_ChannelSetFX(splitStream2, BASSFXType.BASS_FX_BFX_REVERB, 1) : 0; if (splitStream2 != 0 && reverbFx2 == 0) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } if (reverbFx2 != 0 && !Bass.BASS_FXSetParameters(reverbFx2, fxReverb)) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.SetEffectError); return(0); } } } } #pragma warning restore CS0618 // Type or member is obsolete if (loop) { Bass.BASS_ChannelFlags(channel, BASSFlag.BASS_SAMPLE_LOOP, BASSFlag.BASS_SAMPLE_LOOP); } lock (m_Mutex) { m_Loops[file.Id] = file; if (file.Effects != null && file.Effects.CueOut.Active) { m_CueOutRepeats[channel] = loop; } } if (file.Effects.CueIn.Active) { Bass.BASS_ChannelSetPosition(channel, file.Effects.CueIn.Position); } if (isStreaming) { result = BassStreamer.Instance.AddChannel(channel); } else { result = Bass.BASS_ChannelPlay(channel, false); } if (!result) { ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); Bass.BASS_StreamFree(channel); #if MONO if (gcHandle.IsAllocated) { gcHandle.Free(); } #endif return(0); } lock (m_Mutex) { m_RunningFiles[channel] = info; #if MONO if (gcHandle.IsAllocated) { m_GCHandles[channel] = gcHandle; } #endif } return(channel); } else { ErrorHandling.BassErrorOccurred(file.Id, StringResources.FilePlayingError); return(0); } }