\CayciV2Bot\CayciV2Bot\Services\Audio\AudioService.cs

Return Back
using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
using System.IO;
using System.Diagnostics;
using System.Linq;
using CayciV2Bot.Core;
using CayciV2Bot.Services.Audio;
using Discord;
using Discord.Audio;
using Discord.WebSocket;
using NAudio.Wave;
using YoutubeExplode;
using YoutubeExplode.Common;
using YoutubeExplode.Videos.Streams;
using CayciV2Bot.Models;
using System.Collections.Generic;
using System.Web;

namespace CayciV2Bot.Services
{
public class AudioService
{
// Allow bots to play music in multiple threads
private readonly ConcurrentDictionary<ulong, Models.Audio> _container;
public DiscordSocketClient _client;
private readonly FunctionsModule _functionsModule;

public AudioService(DiscordSocketClient client)
{
_container = new ConcurrentDictionary<ulong, Models.Audio>();
_client = client;
_functionsModule = new FunctionsModule();
}

public async Task<bool> JoinAsync(IVoiceChannel voiceChannel, IMessageChannel channel)
{
if (voiceChannel == null)
{
await channel.SendMessageAsync("__User must be in the voice channel__");
return false;
}
var guildId = voiceChannel.Guild.Id;
if (_container.TryGetValue(guildId, out _))
{
return false;
}

var container = new Models.Audio
{
AudioClient = await voiceChannel.ConnectAsync(),
CancellationTokenSource = new CancellationTokenSource(),
QueueManager = new QueueManager(),
};
container.AudioOutStream = container.AudioClient.CreatePCMStream(AudioApplication.Music, bitrate: 128000);
_container.TryAdd(guildId, container);

return true;
}

public async Task AddAsync(IGuild guild, IVoiceChannel voiceChannel, IMessageChannel channel, IGuildUser user, string item, bool isNext)
{
if (!_container.TryGetValue(guild.Id, out var _) && !await JoinAsync(voiceChannel, channel)) // may out null
{
return;
}

_container.TryGetValue(guild.Id, out var container);

await AddSingleAsync(guild, channel, item, isNext);

var queue = container.QueueManager;
if (!queue.IsPlaying)
{
queue.StartPlay();
await SendingAsync(guild, channel, user);
}
}

private async Task AddSingleAsync(IGuild guild, IMessageChannel channel, string path, bool isNext)
{
_container.TryGetValue(guild.Id, out var container);
var queue = container.QueueManager;
if (isNext)
{
queue.AddTo(path, 0); // Add the song to the top of the queue
}
else
{
queue.Add(path);
}

await channel.SendMessageAsync($"`{path} added`");
}

private async Task SendingAsync(IGuild guild, IMessageChannel channel, IUser user)
{
_container.TryGetValue(guild.Id, out var container);
var queue = container.QueueManager;

while (queue.IsPlaying)
{
await channel.SendMessageAsync($"`Now playing {queue.NowPlaying}`");
await _client.SetGameAsync(queue.NowPlaying, "https://cryalp.com", ActivityType.Playing);

await SendSingleAsync(guild, channel, user, queue.NowPlayingPath);

Thread.Sleep(2000);
queue.PlayNext();
}

if (container.QueueManager.RemainingNumber == 0)
{
await LeaveAsync(guild, channel);
}
// Set back game
await _client.SetGameAsync(ConfigModule.Game, "https://cryalp.com", ActivityType.Playing);
}

private async Task<YoutubeExplode.Videos.Video> FindYoutubeVideo(string path)
{
try
{
var youtube = new YoutubeClient();

if (path.Contains("://") && (path.Contains("youtube.com") || path.Contains("youtu.be")))
{
var myUri = new Uri(path);
if (path.Contains("youtube.com"))
{
var videoId = HttpUtility.ParseQueryString(myUri.Query).Get("v");
path = "https://www.youtube.com/watch?v=" + videoId;
}
return await youtube.Videos.GetAsync(path);
}
else
{
var videoSearchResult = (await youtube.Search.GetVideosAsync(path).CollectAsync(1)).FirstOrDefault();
return new YoutubeExplode.Videos.Video(videoSearchResult.Id, videoSearchResult.Title, videoSearchResult.Author, new DateTimeOffset(DateTime.MinValue, TimeSpan.Zero), "", videoSearchResult.Duration, null, null, null);
}
}
catch (Exception ex)
{
_functionsModule.LogPrinter(ex.Message);
return null;
}
}

private async Task SendSingleAsync(IGuild guild, IMessageChannel channel, IUser user, string path)
{
try
{
_container.TryGetValue(guild.Id, out var container);
var audioOutStream = container.AudioOutStream;
var token = container.CancellationTokenSource.Token;
const int bitRate = 48000;
const int bitsPerRawSample = 16;

var youtubeVideo = await FindYoutubeVideo(path);
var videoFullName = _functionsModule.RemoveSpecialCharacters(youtubeVideo.Title).Replace(" ", "");
const string savePath = @"\resources\audio\";
var outputFile = $"{Environment.CurrentDirectory}{savePath}{videoFullName}.mp3";
if (!File.Exists(outputFile))
{
var youtube = new YoutubeClient();
var streamManifest = await youtube.Videos.Streams.GetManifestAsync(youtubeVideo.Id, token);
var streamInfo = streamManifest.GetAudioOnlyStreams().GetWithHighestBitrate();
var stream = await youtube.Videos.Streams.GetAsync(streamInfo);

var inputFile = $"{Environment.CurrentDirectory}{savePath}{videoFullName}.{streamInfo.Container.Name}";

var saveFile = youtube.Videos.Streams.DownloadAsync(streamInfo, inputFile, cancellationToken: token);
await saveFile;
if (!saveFile.IsCompletedSuccessfully)
{
throw new Exception("Save error while saving file");
}

var converted = ConvertMp4ToMp3(inputFile, outputFile, bitRate, bitsPerRawSample);
if (converted && File.Exists(inputFile) && File.Exists(outputFile) && inputFile != outputFile)
{
File.Delete(inputFile);
}
else
{
throw new Exception("Conversion error while converting MP4 file to MP3");
}
}

using (var _dbContext = new Entities.Models())
{
var music = _dbContext.Music.FirstOrDefault(m => m.Title == youtubeVideo.Title);
if (music == null)
{
music = new Music
{
Title = youtubeVideo.Title,
VideoFullName = videoFullName,
Author = youtubeVideo.Author.ChannelTitle,
Duration = (int?)youtubeVideo.Duration.Value.TotalSeconds,
URL = youtubeVideo.Url,
CreationDate = DateTime.Now,
UniqueId = Guid.NewGuid()
};
_dbContext.Music.Add(music);
_dbContext.SaveChanges();
}

if (!_functionsModule.Log(guild, channel, user, music.Id, path))
{
throw new Exception("Logging error while logging operation to database");
}
}

var format = new WaveFormat(bitRate, bitsPerRawSample, 2);
var reader = new MediaFoundationReader(outputFile);
var resamplerDmo = new ResamplerDmoStream(reader, format);
try
{
container.ResamplerDmoStream = resamplerDmo;
await resamplerDmo.CopyToAsync(audioOutStream, token);
}
finally
{
await audioOutStream.FlushAsync();
container.CancellationTokenSource = new CancellationTokenSource();
}
}
catch (Exception ex)
{
_functionsModule.LogPrinter(ex.Message);
}
}

private async Task<List<YoutubeExplode.Playlists.PlaylistVideo>> FindYoutubePlayList(string path)
{
try
{
var youtube = new YoutubeClient();
var youtubePlayList = new List<YoutubeExplode.Playlists.PlaylistVideo>();

await foreach (var video in youtube.Playlists.GetVideosAsync(path))
{
youtubePlayList.Add(video);
}
return youtubePlayList;
}
catch (Exception ex)
{
_functionsModule.LogPrinter(ex.Message);
return null;
}
}

public async Task AddPlayListAsync(IGuild guild, IVoiceChannel voiceChannel, IMessageChannel channel, IGuildUser user, string path)
{
if (!await JoinAsync(voiceChannel, channel))
{
return;
}

var playList = await FindYoutubePlayList(path);

foreach (var video in playList)
{
await AddSingleAsync(guild, channel, video.Title, false);
Thread.Sleep(1000);
}

_container.TryGetValue(guild.Id, out var container);
var queue = container.QueueManager;
if (!queue.IsPlaying)
{
queue.StartPlay();
await SendingAsync(guild, channel, user);
}
}

public bool ConvertMp4ToMp3(string inputFile, string outputFile, int audioBitRate, int bitsPerRawSample)
{
try
{
var ffmpegProcess = Process.Start(new ProcessStartInfo
{
FileName = Environment.CurrentDirectory + "/ffmpeg/ffmpeg.exe",
Arguments = $" -y -loglevel panic -i {inputFile} -bits_per_raw_sample {bitsPerRawSample} -vn -f mp3 -ac 1 -ar {audioBitRate} {outputFile}",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardInput = true,
RedirectStandardError = true,
CreateNoWindow = true
});
ffmpegProcess.StandardOutput.ReadToEnd();
var mp3out = ffmpegProcess.StandardError.ReadToEnd();
ffmpegProcess.WaitForExit();
if (!ffmpegProcess.HasExited)
{
ffmpegProcess.Kill();
}

return true;
}
catch (Exception ex)
{
_functionsModule.LogPrinter(ex.Message);
return false;
}
}

public async Task SkipAsync(IGuild guild, IMessageChannel channel)
{
if (_container.TryGetValue(guild.Id, out var container))
{
container.CancellationTokenSource.Cancel();
await channel.SendMessageAsync("__Music skipped__");
if (container.QueueManager.RemainingNumber == 0)
{
await LeaveAsync(guild, channel);
}
}
else
{
await channel.SendMessageAsync("__Nothing is playing now__");
}
}

public async Task GetNowPlayingAsync(IGuild guild, IMessageChannel channel)
{
if (_container.TryGetValue(guild.Id, out var container))
{
if (container.QueueManager.IsPlaying && container.ResamplerDmoStream != null)
{
var current = container.ResamplerDmoStream.CurrentTime;
var total = container.ResamplerDmoStream.TotalTime;
var diff = (int)(current.TotalSeconds / total.TotalSeconds * 15); // Bar's length
var bar = ":arrow_forward: ";
for (int i = 0; i < 15; i++)
{
if (i == diff)
{
bar += ":radio_button:";
}
else
{
bar += "▬";
}
}
bar += $" [{current:mm\\:ss}/{total:mm\\:ss}]";

await channel.SendMessageAsync($"`Now Playing {container.QueueManager.NowPlaying}`\n{bar}");
}
}
else
{
await channel.SendMessageAsync("__Nothing is playing now__");
}
}

public async Task GetQueueAsync(IGuild guild, IMessageChannel channel)
{
if (_container.TryGetValue(guild.Id, out var container))
{
var contents = container.QueueManager.GetRestQueue();
if (contents?.Length == 0)
{
await channel.SendMessageAsync("__Queue is empty__");
}
else
{
await channel.SendMessageAsync($">>> Music Queue\n```{contents}```");
}
}
else
{
await channel.SendMessageAsync("__Queue is empty__");
}
}

public async Task QMoveToTopAsync(IGuild guild, IMessageChannel channel, int pos)
{
if (!_container.TryGetValue(guild.Id, out var container))
{
await channel.SendMessageAsync("__Queue is empty__");
return;
}

if (container.QueueManager.MoveToTop(pos))
{
await channel.SendMessageAsync("__Operation successed__");
}
else
{
await channel.SendMessageAsync($"__Failed to move song(at {pos}) to top__");
}
}

public async Task QShuffleAsync(IGuild guild, IMessageChannel channel)
{
if (!_container.TryGetValue(guild.Id, out var container))
{
await channel.SendMessageAsync("__Queue is empty__");
return;
}

if (container.QueueManager.Shuffle())
{
await channel.SendMessageAsync("__Operation successed__");
}
else
{
await channel.SendMessageAsync("__Queue is empty__");
}
}

public async Task QRemoveAsync(IGuild guild, IMessageChannel channel, int pos)
{
if (!_container.TryGetValue(guild.Id, out var container))
{
await channel.SendMessageAsync("__Queue is empty__");
return;
}

if (container.QueueManager.Remove(pos))
{
await channel.SendMessageAsync("__Operation successed__");
}
else
{
await channel.SendMessageAsync($"__Failed to remove song(at {pos})__");
}
}

public async Task QRemoveAllAsync(IGuild guild, IMessageChannel channel)
{
if (!_container.TryGetValue(guild.Id, out var container))
{
await channel.SendMessageAsync("__Queue is empty__");
return;
}

if (container.QueueManager.RemoveAll())
{
await channel.SendMessageAsync("__Operation successed__");
}
else
{
await channel.SendMessageAsync("__Queue is empty__");
}
}

public async Task StopAsync(IGuild guild, IMessageChannel channel)
{
if (_container.TryGetValue(guild.Id, out var container))
{
container.CancellationTokenSource.Cancel();
container.QueueManager.RemoveAll();
await channel.SendMessageAsync("__Music stopped__");
await LeaveAsync(guild, channel);
}
else
{
await channel.SendMessageAsync("__Nothing is playing now__");
}
}

public async Task LeaveAsync(IGuild guild, IMessageChannel channel)
{
if (!_container.TryRemove(guild.Id, out var container))
{
await channel.SendMessageAsync("__Bot has not joined to audio channel yet__");
return;
}
await channel.SendMessageAsync("__Disconnected from audio channel__");
await _client.SetGameAsync(ConfigModule.Game, "https://cryalp.com", ActivityType.Playing);
await container.AudioClient.StopAsync();
}

public async Task LeaveAllAsync()
{
foreach (var item in _container)
{
await item.Value.AudioClient.StopAsync();
}
_container.Clear();
}
}
}