mirror of
https://gitlab.com/Kwoth/nadekobot.git
synced 2025-09-11 09:48:26 -04:00
Killed history
This commit is contained in:
Kwoth
717
NadekoBot.Core/Modules/Music/Common/_OldMusicPlayer.cs
Normal file
717
NadekoBot.Core/Modules/Music/Common/_OldMusicPlayer.cs
Normal file
@@ -0,0 +1,717 @@
|
||||
// using Discord;
|
||||
// using Discord.Audio;
|
||||
// using System;
|
||||
// using System.Threading;
|
||||
// using System.Threading.Tasks;
|
||||
// using System.Linq;
|
||||
// using System.Runtime.InteropServices;
|
||||
// using NadekoBot.Extensions;
|
||||
// using NadekoBot.Common.Collections;
|
||||
// using NadekoBot.Modules.Music.Services;
|
||||
// using NadekoBot.Core.Services;
|
||||
// using NadekoBot.Core.Services.Database.Models;
|
||||
// using Discord.WebSocket;
|
||||
// using Serilog;
|
||||
//
|
||||
// namespace NadekoBot.Modules.Music.Common
|
||||
// {
|
||||
// public enum StreamState
|
||||
// {
|
||||
// Resolving,
|
||||
// Queued,
|
||||
// Playing,
|
||||
// Completed
|
||||
// }
|
||||
// public class MusicPlayer
|
||||
// {
|
||||
// private readonly Thread _player;
|
||||
// public IVoiceChannel VoiceChannel { get; private set; }
|
||||
//
|
||||
// public ITextChannel OriginalTextChannel { get; set; }
|
||||
//
|
||||
// private MusicQueue Queue { get; } = new MusicQueue();
|
||||
//
|
||||
// public bool Exited { get; set; } = false;
|
||||
// public bool Stopped { get; private set; } = false;
|
||||
// public float Volume { get; private set; } = 1.0f;
|
||||
// public bool Paused => PauseTaskSource != null;
|
||||
// private TaskCompletionSource<bool> PauseTaskSource { get; set; } = null;
|
||||
//
|
||||
// public string PrettyVolume => $"🔉 {(int)(Volume * 100)}%";
|
||||
// public string PrettyCurrentTime
|
||||
// {
|
||||
// get
|
||||
// {
|
||||
// var time = CurrentTime.ToString(@"mm\:ss");
|
||||
// var hrs = (int)CurrentTime.TotalHours;
|
||||
//
|
||||
// if (hrs > 0)
|
||||
// return hrs + ":" + time;
|
||||
// else
|
||||
// return time;
|
||||
// }
|
||||
// }
|
||||
// public string PrettyFullTime => PrettyCurrentTime + " / " + (Queue.Current.Song?.PrettyTotalTime ?? "?");
|
||||
// private CancellationTokenSource SongCancelSource { get; set; }
|
||||
// public ITextChannel OutputTextChannel { get; set; }
|
||||
// public (int Index, SongInfo Current) Current
|
||||
// {
|
||||
// get
|
||||
// {
|
||||
// if (Stopped)
|
||||
// return (0, null);
|
||||
// return Queue.Current;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public bool RepeatCurrentSong { get; private set; }
|
||||
// public bool Shuffle { get; private set; }
|
||||
// public bool Autoplay { get; private set; }
|
||||
// public bool RepeatPlaylist { get; private set; } = false;
|
||||
// public uint MaxQueueSize
|
||||
// {
|
||||
// get => Queue.MaxQueueSize;
|
||||
// set { lock (locker) Queue.MaxQueueSize = value; }
|
||||
// }
|
||||
// private bool _fairPlay;
|
||||
// public bool FairPlay
|
||||
// {
|
||||
// get => _fairPlay;
|
||||
// set
|
||||
// {
|
||||
// if (value)
|
||||
// {
|
||||
// var (Index, Song) = Queue.Current;
|
||||
// if (Song != null)
|
||||
// RecentlyPlayedUsers.Add(Song.QueuerName);
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// RecentlyPlayedUsers.Clear();
|
||||
// }
|
||||
//
|
||||
// _fairPlay = value;
|
||||
// }
|
||||
// }
|
||||
// public bool AutoDelete { get; set; }
|
||||
// public uint MaxPlaytimeSeconds { get; set; }
|
||||
//
|
||||
//
|
||||
// const int _frameBytes = 3840;
|
||||
// const float _miliseconds = 20.0f;
|
||||
// public TimeSpan CurrentTime => TimeSpan.FromSeconds(_bytesSent / (float)_frameBytes / (1000 / _miliseconds));
|
||||
//
|
||||
// private int _bytesSent = 0;
|
||||
//
|
||||
// private IAudioClient _audioClient;
|
||||
// private readonly object locker = new object();
|
||||
// private MusicService _musicService;
|
||||
//
|
||||
// #region events
|
||||
// public event Action<MusicPlayer, (int Index, SongInfo Song)> OnStarted;
|
||||
// public event Action<MusicPlayer, SongInfo> OnCompleted;
|
||||
// public event Action<MusicPlayer, bool> OnPauseChanged;
|
||||
// #endregion
|
||||
//
|
||||
// private bool manualSkip = false;
|
||||
// private bool manualIndex = false;
|
||||
// private bool newVoiceChannel = false;
|
||||
// private readonly IGoogleApiService _google;
|
||||
//
|
||||
// private bool cancel = false;
|
||||
//
|
||||
// private ConcurrentHashSet<string> RecentlyPlayedUsers { get; } = new ConcurrentHashSet<string>();
|
||||
// public TimeSpan TotalPlaytime
|
||||
// {
|
||||
// get
|
||||
// {
|
||||
// var songs = Queue.ToArray().Songs;
|
||||
// return songs.Any(s => s.TotalTime == TimeSpan.MaxValue)
|
||||
// ? TimeSpan.MaxValue
|
||||
// : new TimeSpan(songs.Sum(s => s.TotalTime.Ticks));
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public MusicPlayer(MusicService musicService, MusicSettings ms, IGoogleApiService google,
|
||||
// IVoiceChannel vch, ITextChannel original, float volume)
|
||||
// {
|
||||
// this.Volume = volume;
|
||||
// this.VoiceChannel = vch;
|
||||
// this.OriginalTextChannel = original;
|
||||
// this.SongCancelSource = new CancellationTokenSource();
|
||||
// if (ms.MusicChannelId is ulong cid)
|
||||
// {
|
||||
// this.OutputTextChannel = ((SocketGuild)original.Guild).GetTextChannel(cid) ?? original;
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// this.OutputTextChannel = original;
|
||||
// }
|
||||
// this._musicService = musicService;
|
||||
// this.AutoDelete = ms.SongAutoDelete;
|
||||
// this._google = google;
|
||||
//
|
||||
// _player = new Thread(new ThreadStart(PlayerLoop))
|
||||
// {
|
||||
// Priority = ThreadPriority.AboveNormal
|
||||
// };
|
||||
// _player.Start();
|
||||
// }
|
||||
//
|
||||
// private async void PlayerLoop()
|
||||
// {
|
||||
// while (!Exited)
|
||||
// {
|
||||
// _bytesSent = 0;
|
||||
// cancel = false;
|
||||
// CancellationToken cancelToken;
|
||||
// (int Index, SongInfo Song) data;
|
||||
// lock (locker)
|
||||
// {
|
||||
// data = Queue.Current;
|
||||
// cancelToken = SongCancelSource.Token;
|
||||
// manualSkip = false;
|
||||
// manualIndex = false;
|
||||
// }
|
||||
// if (data.Song != null)
|
||||
// {
|
||||
// Log.Information("Starting");
|
||||
// AudioOutStream pcm = null;
|
||||
// SongBuffer b = null;
|
||||
// try
|
||||
// {
|
||||
// var streamUrl = await data.Song.Uri().ConfigureAwait(false);
|
||||
// b = new SongBuffer(streamUrl, data.Song.ProviderType == MusicType.Local);
|
||||
// //Log.Information("Created buffer, buffering...");
|
||||
//
|
||||
// //var bufferTask = b.StartBuffering(cancelToken);
|
||||
// //var timeout = Task.Delay(10000);
|
||||
// //if (Task.WhenAny(bufferTask, timeout) == timeout)
|
||||
// //{
|
||||
// // Log.Information("Buffering failed due to a timeout.");
|
||||
// // continue;
|
||||
// //}
|
||||
// //else if (!bufferTask.Result)
|
||||
// //{
|
||||
// // Log.Information("Buffering failed due to a cancel or error.");
|
||||
// // continue;
|
||||
// //}
|
||||
// //Log.Information("Buffered. Getting audio client...");
|
||||
// var ac = await GetAudioClient().ConfigureAwait(false);
|
||||
// Log.Information("Got Audio client");
|
||||
// if (ac == null)
|
||||
// {
|
||||
// Log.Information("Can't join");
|
||||
// await Task.Delay(900, cancelToken).ConfigureAwait(false);
|
||||
// // just wait some time, maybe bot doesn't even have perms to join that voice channel,
|
||||
// // i don't want to spam connection attempts
|
||||
// continue;
|
||||
// }
|
||||
// b.StartBuffering();
|
||||
// await Task.WhenAny(Task.Delay(10000), b.PrebufferingCompleted.Task).ConfigureAwait(false);
|
||||
// pcm = ac.CreatePCMStream(AudioApplication.Music, bufferMillis: 1, packetLoss: 5);
|
||||
// Log.Information("Created pcm stream");
|
||||
// OnStarted?.Invoke(this, data);
|
||||
//
|
||||
// while (MaxPlaytimeSeconds <= 0 || MaxPlaytimeSeconds >= CurrentTime.TotalSeconds)
|
||||
// {
|
||||
// var buffer = b.Read(3840);
|
||||
// if (buffer.Length == 0)
|
||||
// break;
|
||||
// AdjustVolume(buffer, Volume);
|
||||
// await pcm.WriteAsync(buffer, 0, buffer.Length, cancelToken).ConfigureAwait(false);
|
||||
// unchecked { _bytesSent += buffer.Length; }
|
||||
//
|
||||
// await (PauseTaskSource?.Task ?? Task.CompletedTask).ConfigureAwait(false);
|
||||
// }
|
||||
// }
|
||||
// catch (OperationCanceledException)
|
||||
// {
|
||||
// Log.Information("Song Canceled");
|
||||
// cancel = true;
|
||||
// }
|
||||
// catch (Exception ex)
|
||||
// {
|
||||
// Log.Warning(ex, "Error sending song data");
|
||||
// }
|
||||
// finally
|
||||
// {
|
||||
// if (pcm != null)
|
||||
// {
|
||||
// // flush is known to get stuck from time to time,
|
||||
// // just skip flushing if it takes more than 1 second
|
||||
// var flushCancel = new CancellationTokenSource();
|
||||
// var flushToken = flushCancel.Token;
|
||||
// var flushDelay = Task.Delay(1000, flushToken);
|
||||
// await Task.WhenAny(flushDelay, pcm.FlushAsync(flushToken)).ConfigureAwait(false);
|
||||
// flushCancel.Cancel();
|
||||
// pcm.Dispose();
|
||||
// }
|
||||
//
|
||||
// if (b != null)
|
||||
// b.Dispose();
|
||||
//
|
||||
// OnCompleted?.Invoke(this, data.Song);
|
||||
//
|
||||
// if (_bytesSent == 0 && !cancel)
|
||||
// {
|
||||
// lock (locker)
|
||||
// Queue.RemoveSong(data.Song);
|
||||
// Log.Information("Song removed because it can't play");
|
||||
// }
|
||||
// }
|
||||
// try
|
||||
// {
|
||||
// //if repeating current song, just ignore other settings,
|
||||
// // and play this song again (don't change the index)
|
||||
// // ignore rcs if song is manually skipped
|
||||
//
|
||||
// int queueCount;
|
||||
// bool stopped;
|
||||
// int currentIndex;
|
||||
// lock (locker)
|
||||
// {
|
||||
// queueCount = Queue.Count;
|
||||
// stopped = Stopped;
|
||||
// currentIndex = Queue.CurrentIndex;
|
||||
// }
|
||||
//
|
||||
// if (AutoDelete && !RepeatCurrentSong && !RepeatPlaylist && data.Song != null)
|
||||
// {
|
||||
// Queue.RemoveSong(data.Song);
|
||||
// }
|
||||
//
|
||||
// if (!manualIndex && (!RepeatCurrentSong || manualSkip))
|
||||
// {
|
||||
// if (Shuffle)
|
||||
// {
|
||||
// Log.Information("Random song");
|
||||
// Queue.Random(); //if shuffle is set, set current song index to a random number
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// //if last song, and autoplay is enabled, and if it's a youtube song
|
||||
// // do autplay magix
|
||||
// if (queueCount - 1 == data.Index && Autoplay && data.Song?.ProviderType == MusicType.YouTube)
|
||||
// {
|
||||
// try
|
||||
// {
|
||||
// Log.Information("Loading related song");
|
||||
// await _musicService.TryQueueRelatedSongAsync(data.Song, OutputTextChannel, VoiceChannel).ConfigureAwait(false);
|
||||
// if (!AutoDelete)
|
||||
// Queue.Next();
|
||||
// }
|
||||
// catch
|
||||
// {
|
||||
// Log.Information("Loading related song failed");
|
||||
// }
|
||||
// }
|
||||
// else if (FairPlay)
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// Log.Information("Next fair song");
|
||||
// var queueList = Queue.ToList();
|
||||
// var q = queueList.Shuffle().ToArray();
|
||||
//
|
||||
// bool found = false;
|
||||
// for (var i = 0; i < q.Length; i++) //first try to find a queuer who didn't have their song played recently
|
||||
// {
|
||||
// var item = q[i];
|
||||
// if (RecentlyPlayedUsers.Add(item.QueuerName)) // if it's found, set current song to that index
|
||||
// {
|
||||
// Queue.CurrentIndex = queueList.IndexOf(q[i]);
|
||||
// found = true;
|
||||
// break;
|
||||
// }
|
||||
// }
|
||||
// if (!found) //if it's not
|
||||
// {
|
||||
// RecentlyPlayedUsers.Clear(); //clear all recently played users (that means everyone from the playlist has had their song played)
|
||||
// Queue.Random(); //go to a random song (to prevent looping on the first few songs)
|
||||
// var cur = Current;
|
||||
// if (cur.Current != null) // add newely scheduled song's queuer to the recently played list
|
||||
// RecentlyPlayedUsers.Add(cur.Current.QueuerName);
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// else if (queueCount - 1 == data.Index && !RepeatPlaylist && !manualSkip)
|
||||
// {
|
||||
// Log.Information("Stopping because repeatplaylist is disabled");
|
||||
// lock (locker)
|
||||
// {
|
||||
// Stop();
|
||||
// }
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// Log.Information("Next song");
|
||||
// lock (locker)
|
||||
// {
|
||||
// if (!Stopped)
|
||||
// if (!AutoDelete)
|
||||
// Queue.Next();
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// catch (Exception ex)
|
||||
// {
|
||||
// Log.Error(ex, "Error in queue");
|
||||
// }
|
||||
// }
|
||||
// do
|
||||
// {
|
||||
// await Task.Delay(500).ConfigureAwait(false);
|
||||
// }
|
||||
// while ((Queue.Count == 0 || Stopped) && !Exited);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// private async Task<IAudioClient> GetAudioClient(bool reconnect = false)
|
||||
// {
|
||||
// if (_audioClient == null ||
|
||||
// _audioClient.ConnectionState != ConnectionState.Connected ||
|
||||
// reconnect ||
|
||||
// newVoiceChannel)
|
||||
// try
|
||||
// {
|
||||
// try
|
||||
// {
|
||||
// var t = _audioClient?.StopAsync();
|
||||
// if (t != null)
|
||||
// {
|
||||
//
|
||||
// Log.Information("Stopping audio client");
|
||||
// await t.ConfigureAwait(false);
|
||||
//
|
||||
// Log.Information("Disposing audio client");
|
||||
// _audioClient.Dispose();
|
||||
// }
|
||||
// }
|
||||
// catch
|
||||
// {
|
||||
// }
|
||||
// newVoiceChannel = false;
|
||||
//
|
||||
// var curUser = await VoiceChannel.Guild.GetCurrentUserAsync().ConfigureAwait(false);
|
||||
// if (curUser.VoiceChannel != null)
|
||||
// {
|
||||
// Log.Information("Connecting");
|
||||
// var ac = await VoiceChannel.ConnectAsync().ConfigureAwait(false);
|
||||
// Log.Information("Connected, stopping");
|
||||
// await ac.StopAsync().ConfigureAwait(false);
|
||||
// Log.Information("Disconnected");
|
||||
// await Task.Delay(1000).ConfigureAwait(false);
|
||||
// }
|
||||
// Log.Information("Connecting");
|
||||
// _audioClient = await VoiceChannel.ConnectAsync().ConfigureAwait(false);
|
||||
// }
|
||||
// catch (Exception ex)
|
||||
// {
|
||||
// Log.Warning("Error while getting audio client: {0}", ex.ToString());
|
||||
// return null;
|
||||
// }
|
||||
// return _audioClient;
|
||||
// }
|
||||
//
|
||||
// public int Enqueue(SongInfo song, bool forcePlay = false)
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// if (Exited)
|
||||
// return -1;
|
||||
// Queue.Add(song);
|
||||
// var result = Queue.Count - 1;
|
||||
//
|
||||
// if (forcePlay)
|
||||
// {
|
||||
// if (Stopped)
|
||||
// {
|
||||
// Stopped = false;
|
||||
// SetIndex(result);
|
||||
// }
|
||||
// Unpause();
|
||||
// }
|
||||
// return result;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public int EnqueueNext(SongInfo song, bool forcePlay = false)
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// if (Exited)
|
||||
// return -1;
|
||||
// var toReturn = Queue.AddNext(song);
|
||||
// if (forcePlay)
|
||||
// {
|
||||
// Unpause();
|
||||
// if (Stopped)
|
||||
// {
|
||||
// SetIndex(toReturn);
|
||||
// }
|
||||
// }
|
||||
// return toReturn;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public void SetIndex(int index)
|
||||
// {
|
||||
// if (index < 0)
|
||||
// throw new ArgumentOutOfRangeException(nameof(index));
|
||||
// lock (locker)
|
||||
// {
|
||||
// if (Exited)
|
||||
// return;
|
||||
// if (AutoDelete && index >= Queue.CurrentIndex && index > 0)
|
||||
// index--;
|
||||
// Queue.CurrentIndex = index;
|
||||
// manualIndex = true;
|
||||
// Stopped = false;
|
||||
// CancelCurrentSong();
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public void Next(int skipCount = 1)
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// if (Exited)
|
||||
// return;
|
||||
// manualSkip = true;
|
||||
// // if player is stopped, and user uses .n, it should play current song.
|
||||
// // It's a bit weird, but that's the least annoying solution
|
||||
// if (!Stopped)
|
||||
// if (!RepeatPlaylist && Queue.IsLast() && !Autoplay) // if it's the last song in the queue, and repeat playlist is disabled
|
||||
// { //stop the queue
|
||||
// Stop();
|
||||
// return;
|
||||
// }
|
||||
// else
|
||||
// Queue.Next(skipCount - 1);
|
||||
// else
|
||||
// Queue.CurrentIndex = 0;
|
||||
// Stopped = false;
|
||||
// CancelCurrentSong();
|
||||
// Unpause();
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public void Stop(bool clearQueue = false)
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// Stopped = true;
|
||||
// Autoplay = false;
|
||||
// //Queue.ResetCurrent();
|
||||
// if (clearQueue)
|
||||
// Queue.Clear();
|
||||
// Unpause();
|
||||
// CancelCurrentSong();
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// private void Unpause()
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// if (PauseTaskSource != null)
|
||||
// {
|
||||
// PauseTaskSource.TrySetResult(true);
|
||||
// PauseTaskSource = null;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public void TogglePause()
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// if (PauseTaskSource == null)
|
||||
// PauseTaskSource = new TaskCompletionSource<bool>();
|
||||
// else
|
||||
// {
|
||||
// Unpause();
|
||||
// }
|
||||
// }
|
||||
// OnPauseChanged?.Invoke(this, PauseTaskSource != null);
|
||||
// }
|
||||
//
|
||||
// public void SetVolume(int volume)
|
||||
// {
|
||||
// if (volume < 0 || volume > 100)
|
||||
// throw new ArgumentOutOfRangeException(nameof(volume));
|
||||
// lock (locker)
|
||||
// {
|
||||
// Volume = ((float)volume) / 100;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public SongInfo RemoveAt(int index)
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// var (Index, Song) = Queue.Current;
|
||||
// var toReturn = Queue.RemoveAt(index);
|
||||
// if (Index == index)
|
||||
// Next();
|
||||
// return toReturn;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// private void CancelCurrentSong()
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// var cs = SongCancelSource;
|
||||
// SongCancelSource = new CancellationTokenSource();
|
||||
// cs.Cancel();
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public void ClearQueue()
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// Queue.Clear();
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public (int CurrentIndex, SongInfo[] Songs) QueueArray()
|
||||
// {
|
||||
// lock (locker)
|
||||
// return Queue.ToArray();
|
||||
// }
|
||||
//
|
||||
// //aidiakapi ftw
|
||||
// // public static unsafe byte[] AdjustVolume(byte[] audioSamples, float volume)
|
||||
// // {
|
||||
// // if (Math.Abs(volume - 1f) < 0.0001f) return audioSamples;
|
||||
// //
|
||||
// // // 16-bit precision for the multiplication
|
||||
// // var volumeFixed = (int)Math.Round(volume * 65536d);
|
||||
// //
|
||||
// // var count = audioSamples.Length / 2;
|
||||
// //
|
||||
// // fixed (byte* srcBytes = audioSamples)
|
||||
// // {
|
||||
// // var src = (short*)srcBytes;
|
||||
// //
|
||||
// // for (var i = count; i != 0; i--, src++)
|
||||
// // *src = (short)(((*src) * volumeFixed) >> 16);
|
||||
// // }
|
||||
// //
|
||||
// // return audioSamples;
|
||||
// // }
|
||||
//
|
||||
// private static void AdjustVolume(byte[] audioSamples, float volume)
|
||||
// {
|
||||
// if (Math.Abs(volume - 1f) < 0.0001f) return;
|
||||
//
|
||||
// var samples = MemoryMarshal.Cast<byte, short>(audioSamples);
|
||||
//
|
||||
// for (var i = 0; i < samples.Length; i++)
|
||||
// {
|
||||
// ref var sample = ref samples[i];
|
||||
// sample = (short) (sample * volume);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public bool ToggleRepeatSong()
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// return RepeatCurrentSong = !RepeatCurrentSong;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public async Task Destroy()
|
||||
// {
|
||||
// Log.Information("Destroying");
|
||||
// lock (locker)
|
||||
// {
|
||||
// Stop();
|
||||
// Exited = true;
|
||||
// Unpause();
|
||||
//
|
||||
// OnCompleted = null;
|
||||
// OnPauseChanged = null;
|
||||
// OnStarted = null;
|
||||
// }
|
||||
// var ac = _audioClient;
|
||||
// if (ac != null)
|
||||
// await ac.StopAsync().ConfigureAwait(false);
|
||||
// }
|
||||
//
|
||||
// public bool ToggleShuffle()
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// return Shuffle = !Shuffle;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public bool ToggleAutoplay()
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// return Autoplay = !Autoplay;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public bool ToggleRepeatPlaylist()
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// return RepeatPlaylist = !RepeatPlaylist;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public async Task SetVoiceChannel(IVoiceChannel vch)
|
||||
// {
|
||||
// lock (locker)
|
||||
// {
|
||||
// if (Exited)
|
||||
// return;
|
||||
// VoiceChannel = vch;
|
||||
// }
|
||||
// _audioClient = await vch.ConnectAsync().ConfigureAwait(false);
|
||||
// }
|
||||
//
|
||||
// public async Task UpdateSongDurationsAsync()
|
||||
// {
|
||||
// var (_, songs) = Queue.ToArray();
|
||||
// var toUpdate = songs
|
||||
// .Where(x => x.ProviderType == MusicType.YouTube
|
||||
// && x.TotalTime == TimeSpan.Zero);
|
||||
//
|
||||
// var vIds = toUpdate.Select(x => x.VideoId);
|
||||
// if (!vIds.Any())
|
||||
// return;
|
||||
//
|
||||
// var durations = await _google.GetVideoDurationsAsync(vIds).ConfigureAwait(false);
|
||||
//
|
||||
// foreach (var x in toUpdate)
|
||||
// {
|
||||
// if (durations.TryGetValue(x.VideoId, out var dur))
|
||||
// x.TotalTime = dur;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// public SongInfo MoveSong(int n1, int n2)
|
||||
// => Queue.MoveSong(n1, n2);
|
||||
//
|
||||
// public void SetMusicChannelToOriginal()
|
||||
// {
|
||||
// this.OutputTextChannel = OriginalTextChannel;
|
||||
// }
|
||||
//
|
||||
// //// this should be written better
|
||||
// //public TimeSpan TotalPlaytime =>
|
||||
// // _playlist.Any(s => s.TotalTime == TimeSpan.MaxValue) ?
|
||||
// // TimeSpan.MaxValue :
|
||||
// // new TimeSpan(_playlist.Sum(s => s.TotalTime.Ticks));
|
||||
// }
|
||||
// }
|
||||
Reference in New Issue
Block a user