static async Task Main(string[] args)
{
var url = args[0];
var dl = new YoutubeDL();
dl.Options.FilesystemOptions.Output = ".";
dl.Options.PostProcessingOptions.ExtractAudio = true;
dl.VideoUrl = url;
dl.StandardErrorEvent += (s, o) => {
Console.WriteLine("?? {0}", o);
};
dl.StandardOutputEvent += (s, o) => {
Console.WriteLine(":: {0}", o);
};
// dl.Info.PropertyChanged += (s, o) => {
// Console.WriteLine("~ {0}", o);
// };
var rs = await dl.PrepareDownloadAsync();
Console.WriteLine("> {0}", rs);
}
/// <summary>
/// Synchronously download a video/playlist
/// </summary>
/// <param name="ydl">
/// The client
/// </param>
/// <param name="cancellationToken">
/// The cancellation token
/// </param>
internal static void Download(this YoutubeDL ydl, CancellationToken cancellationToken)
{
cancellationToken.Register(() =>
{
Cancel(ydl);
});
if (!ydl.isGettingInfo)
{
ydl.IsDownloading = true;
}
if (ydl.processStartInfo == null)
{
ydl.isGettingInfo = true;
PreparationService.PrepareDownload(ydl, cancellationToken);
if (ydl.processStartInfo == null)
{
throw new NullReferenceException();
}
ydl.isGettingInfo = false;
}
SetupDownload(ydl, cancellationToken);
ydl.process?.WaitForExit();
if (!ydl.isGettingInfo)
{
ydl.IsDownloading = false;
ydl.processStartInfo = null;
}
}
// Token: 0x060059CA RID: 22986 RVA: 0x001F290C File Offset: 0x001F0D0C
private IEnumerator FindURIs(string url, Action onDone = null)
{
if (this.foundURIs.ContainsKey(url))
{
this.foundURIs.Remove(url);
}
yield return(YoutubeDL.FindBestVideoURL(url, false, delegate(string found)
{
if (!this.foundURIs.ContainsKey(url))
{
this.foundURIs.Add(url, new List <string>
{
found
});
}
else
{
this.foundURIs[url].Add(found);
}
}, delegate(string err)
{
Debug.LogError(err);
}));
if (!this.foundURIs.ContainsKey(url))
{
this.foundURIs.Add(url, new List <string>());
}
if (onDone != null)
{
onDone();
}
yield break;
}
/// <summary>
/// Performs the download of the specified video with the given YoutubeDL instance and a prior overwrite check.
/// </summary>
public async Task <RunResult <string> > RunDownload(YoutubeDL ydl, VideoEntry video,
CancellationToken ct, IProgress <DownloadProgress> progress, OptionSet overrideOptions = null)
{
if ((Settings.Default.OverwriteMode != OverwriteMode.Overwrite) && allowsOverwriteCheck)
{
bool restricted = ydl.RestrictFilenames;
string ext = GetExt();
string fileName = Utils.Sanitize(video.Title, restricted);
string path = Path.Combine(ydl.OutputFolder, $"{fileName}.{ext}");
if (File.Exists(path))
{
if (Settings.Default.OverwriteMode == OverwriteMode.None)
{
// Don't redownload if file exists.
progress?.Report(new DownloadProgress(DownloadState.Success, data: path));
return(new RunResult <string>(true, new string[0], path));
}
else
{
// Set download path to a new location to prevent overwriting existing file.
string downloadPath = getNotExistingFilePath(ydl.OutputFolder, fileName, ext);
if (overrideOptions == null)
{
overrideOptions = new OptionSet();
}
overrideOptions.Output = downloadPath;
}
}
}
return(await RunRealDownload(ydl, video.Url, ct, progress, overrideOptions));
}
/// <summary>
/// Verifies if the url of a job is valid and adding the result to it.
/// </summary>
/// <param name="job">The job object that should be verified.</param>
private static async Task VerifyUrl(DownloadJob job)
{
var dl = new YoutubeDL();
var result = await dl.RunVideoDataFetch(job.Url);
if (result.Data == null)
{
if (result.ErrorOutput.Contains("Forbidden"))
{
job.VerificationResult = VerificationResult.DrmProtected;
return;
}
if (result.ErrorOutput.Contains("Unsupported Url"))
{
job.VerificationResult = VerificationResult.NoVideoFound;
return;
}
job.VerificationResult = VerificationResult.GenericError;
return;
}
if (result.Data.Entries != null)
{
job.VerificationResult = VerificationResult.IsPlaylist;
return;
}
job.VideoData = result.Data;
job.VerificationResult = VerificationResult.Valid;
}
/// <summary>
/// Performs the download of the specified playlist with the given YoutubeDL instance and a prior overwrite check.
/// </summary>
public async Task <RunResult <string[]> > RunDownload(YoutubeDL ydl, PlaylistEntry playlist,
CancellationToken ct, IProgress <DownloadProgress> progress, OptionSet overrideOptions = null)
{
if (!ydl.OverwriteFiles && allowsOverwriteCheck)
{
bool restricted = ydl.RestrictFilenames;
string ext = GetExt();
// Check if some videos have already been downloaded.
var indices = new List <int>();
int index = 1;
foreach (var video in playlist.Metadata.Entries)
{
string path = Path.Combine(ydl.OutputFolder, $"{Utils.Sanitize(video.Title, restricted)}.{ext}");
System.Diagnostics.Debug.WriteLine(path);
if (!File.Exists(path))
{
indices.Add(index);
}
else
{
progress?.Report(new DownloadProgress(DownloadState.Success, data: path));
}
index++;
}
return(await RunRealPlaylistDownload(ydl, playlist.Url,
indices.ToArray(), ct, progress, overrideOptions));
}
else
{
return(await RunRealPlaylistDownload(ydl, playlist.Url, null, ct, progress, overrideOptions));
}
}
//public async Task<IActionResult> Download(string url = null, FormatoDescarga format = FormatoDescarga.mp3, TimeSpan? TiempoInicio = null, TimeSpan? TiempoFin = null)
public async Task <IActionResult> Download(string url = null, FormatoDescarga format = FormatoDescarga.mp3)
{
var youtubeDL = new YoutubeDL();
var metaClient = new YoutubeClient();
string mediaUrl = WebUtility.UrlDecode(url);
var mediaMetadata = await metaClient.GetVideoAsync(YoutubeClient.ParseVideoId(mediaUrl));
Task <string> fileTask = null;
switch (format)
{
case FormatoDescarga.mp3:
fileTask = Utils.DownloadMP3Async(mediaUrl);
break;
case FormatoDescarga.mp4:
fileTask = Utils.DownloadMP4Async(mediaUrl);
break;
}
MemoryStream media = new MemoryStream(System.IO.File.ReadAllBytes(fileTask.Result));
media.Seek(0, SeekOrigin.Begin);
System.IO.File.Delete(fileTask.Result);
return(new FileStreamResult(media, "application/octet-stream")
{
FileDownloadName = (mediaMetadata.Title + Path.GetExtension(fileTask.Result))
});
}
public static void Initialize(TestContext context)
{
ydl = new YoutubeDL();
ydl.YoutubeDLPath = "Lib\\youtube-dl.exe";
ydl.FFmpegPath = "Lib\\ffmpeg.exe";
downloadedFiles = new List <string>();
}
/// <summary>
/// synchronously prepare a youtube-dl command
/// </summary>
/// <param name="ydl">
/// The client.
/// </param>
/// <param name="cancellationToken">
/// The cancellation token
/// </param>
/// <returns>
/// The youtube-dl command that will be executed
/// </returns>
internal static string PrepareDownload(this YoutubeDL ydl, CancellationToken cancellationToken)
{
if (!ydl.Info.set)
{
Delegate[] originalDelegates = null;
if (ydl.Info.propertyChangedEvent != null)
{
originalDelegates = ydl.Info.propertyChangedEvent.GetInvocationList();
}
ydl.Info = InfoService.GetDownloadInfo(ydl, cancellationToken) ?? new DownloadInfo();
if (originalDelegates != null)
{
foreach (Delegate del in originalDelegates)
{
ydl.Info.PropertyChanged += (PropertyChangedEventHandler)del;
}
}
ydl.Info.set = true;
}
SetupPrepare(ydl);
return(ydl.RunCommand);
}
/// <summary>
/// Asynchronously retrieve video / playlist information
/// </summary>
/// <param name="ydl">
/// The client
/// </param>
/// <param name="url">
/// URL of video / playlist
/// </param>
/// <returns>
/// An object containing the download information
/// </returns>
internal static async Task <DownloadInfo> GetDownloadInfoAsync(this YoutubeDL ydl, string url)
{
ydl.VideoUrl = url;
await GetDownloadInfoAsync(ydl);
return(ydl.Info);
}
/// <summary>
/// Setup a youtube-dl command using the given options
/// </summary>
/// <param name="ydl">
/// Client with configured options
/// </param>
internal static void SetupPrepare(YoutubeDL ydl)
{
string arguments = ydl.Options.ToCliParameters() + " " + ydl.VideoUrl;
ydl.processStartInfo = new ProcessStartInfo
{
FileName = YoutubeDL.YoutubeDlPath,
Arguments = arguments,
CreateNoWindow = true,
RedirectStandardError = true,
RedirectStandardOutput = true,
UseShellExecute = false
};
if (string.IsNullOrWhiteSpace(ydl.processStartInfo.FileName))
{
throw new FileNotFoundException("youtube-dl not found on path!");
}
if (!File.Exists(ydl.processStartInfo.FileName))
{
throw new FileNotFoundException($"{ydl.processStartInfo.FileName} not found!");
}
ydl.RunCommand = ydl.processStartInfo.FileName + " " + ydl.processStartInfo.Arguments;
}
/// <summary>
/// Setup a youtube-dl command using the given options
/// </summary>
/// <param name="ydl">
/// Client with configured options
/// </param>
internal static void SetupPrepare(YoutubeDL ydl)
{
string urls = string.IsNullOrWhiteSpace(ydl.VideoUrl) ? string.Empty : string.Join(" ", ydl.VideoUrl.Split(null).Select(url => $"\"{url}\""));
string arguments = ydl.Options.ToCliParameters() + " " + urls;
ydl.processStartInfo = new ProcessStartInfo
{
FileName = ydl.YoutubeDlPath,
Arguments = arguments,
CreateNoWindow = true,
RedirectStandardError = true,
RedirectStandardOutput = true,
UseShellExecute = false
};
if (!string.IsNullOrWhiteSpace(ydl.PythonPath))
{
ydl.processStartInfo.Arguments = ydl.YoutubeDlPath + " " + ydl.processStartInfo.Arguments;
ydl.processStartInfo.FileName = ydl.PythonPath;
}
if (string.IsNullOrWhiteSpace(ydl.processStartInfo.FileName))
{
throw new FileNotFoundException("youtube-dl not found on path!");
}
if (!File.Exists(ydl.processStartInfo.FileName))
{
throw new FileNotFoundException($"{ydl.processStartInfo.FileName} not found!");
}
ydl.RunCommand = ydl.processStartInfo.FileName + " " + ydl.processStartInfo.Arguments;
}
public async Task YTDL(CommandContext ctx, string link)
{
if (link.Contains("youtu") || link.Contains("nico"))
{
var msg = await ctx.RespondAsync("Download started!");
System.Random random = new System.Random();
const string pool = "abcdefghijklmnopqrstuvwxyz0123456789";
var chars = Enumerable.Range(0, 20)
.Select(x => pool[random.Next(0, pool.Length)]);
string finalString = new string(chars.ToArray());
var youtubeDl = new YoutubeDL();
if (link.Contains("youtu"))
{
youtubeDl.Options.FilesystemOptions.Output = $"/var/www/vhosts/srgg.de/why-is-this-a-me.me/ytdl/{finalString}.mp4";
youtubeDl.Options.VideoSelectionOptions.NoPlaylist = true;
}
if (link.Contains("nico"))
{
youtubeDl.Options.FilesystemOptions.Output = $"/var/www/vhosts/srgg.de/why-is-this-a-me.me/nnddl/{finalString}.mp4";
youtubeDl.Options.FilesystemOptions.NoCacheDir = true;
}
youtubeDl.Options.PostProcessingOptions.ExtractAudio = true;
youtubeDl.Options.VideoFormatOptions.Format = NYoutubeDL.Helpers.Enums.VideoFormat.best;
youtubeDl.Options.PostProcessingOptions.ExtractAudio = true;
youtubeDl.Options.PostProcessingOptions.AudioFormat = NYoutubeDL.Helpers.Enums.AudioFormat.mp3;
youtubeDl.Options.PostProcessingOptions.AudioQuality = "320k";
youtubeDl.Options.PostProcessingOptions.AddMetadata = true;
youtubeDl.Options.PostProcessingOptions.EmbedThumbnail = true;
youtubeDl.Options.GeneralOptions.Update = true;
youtubeDl.VideoUrl = link;
youtubeDl.YoutubeDlPath = "youtube-dl";
youtubeDl.StandardErrorEvent += (sender, errorOutput) => ctx.RespondAsync($"{errorOutput} (If its 403 blame NNDs Servers, hella slow sometimes and thus cancel the download uwu)");
await youtubeDl.DownloadAsync();
if (File.Exists($"/var/www/vhosts/srgg.de/why-is-this-a-me.me/ytdl/{finalString}.mp3"))
{
await msg.ModifyAsync("https://why-is-this-a-me.me/ytdl/" + finalString + ".mp3 \n" +
"**This file will be deleted in about 30min!**");
await Task.Delay((60000 * 30));
File.Delete($"/var/www/vhosts/srgg.de/why-is-this-a-me.me/ytdl/{finalString}.mp3");
}
else if (File.Exists($"/var/www/vhosts/srgg.de/why-is-this-a-me.me/nnddl/{finalString}.mp3"))
{
await msg.ModifyAsync("https://why-is-this-a-me.me/nnddl/" + finalString + ".mp3 \n" +
"**This file will be deleted in about 30min!**");
await Task.Delay((60000 * 30));
File.Delete($"/var/www/vhosts/srgg.de/why-is-this-a-me.me/nnddl/{finalString}.mp3");
}
}
else
{
await ctx.RespondAsync("no YouTube or NND link detected, please try again");
}
}
public async Task DownloadLatest()
{
// This will download the new version and add it to "Versions" map
log.LogInformation("Checking for new youtube-dl version...");
await ytdlManager.DownloadLatestVersion();
// Critical section - replace ytdl when nobody uses it
var latest = ytdlManager.Versions.Keys.Max();
if (CurrentVersion != latest)
{
log.LogInformation("New version found {0}!", CurrentVersion);
using (var @lock = await ytdlLock.WriterLockAsync())
{
// replace ytdl
CurrentVersion = ytdlManager.Versions.Keys.Max();
ytdl = ytdlManager.Versions[CurrentVersion];
log.LogInformation("Update to {0} completed.", CurrentVersion);
}
}
else
{
log.LogInformation("No new version found!");
}
// Delete old versions which are no longer required
log.LogInformation("Cleaning up old youtube-dl versions...");
await ytdlManager.CleanupOldVersions(2);
}
private static void SetupDownload(YoutubeDL ydl)
{
ydl.process = new Process {
StartInfo = ydl.processStartInfo, EnableRaisingEvents = true
};
ydl.stdOutputTokenSource = new CancellationTokenSource();
ydl.stdErrorTokenSource = new CancellationTokenSource();
ydl.process.Exited += (sender, args) => ydl.KillProcess();
// Note that synchronous calls are needed in order to process the output line by line.
// Asynchronous output reading results in batches of output lines coming in all at once.
// The following two threads convert synchronous output reads into asynchronous events.
ThreadPool.QueueUserWorkItem(ydl.StandardOutput, ydl.stdOutputTokenSource.Token);
ThreadPool.QueueUserWorkItem(ydl.StandardError, ydl.stdErrorTokenSource.Token);
if (ydl.Info != null)
{
ydl.StandardOutputEvent += (sender, output) => ydl.Info.ParseOutput(sender, output.Trim());
ydl.StandardErrorEvent += (sender, output) => ydl.Info.ParseError(sender, output.Trim());
}
ydl.process.Start();
}
public async Task DownloadYoutubeVideo(string videoUrl, string localPath, Action <string, string, string> progressCallback)
{
var youtubeDl = new YoutubeDL();
youtubeDl.VideoUrl = videoUrl;
youtubeDl.Options.FilesystemOptions.Output = localPath;
youtubeDl.Options.PostProcessingOptions.ExtractAudio = false;
youtubeDl.Options.DownloadOptions.FragmentRetries = -1;
youtubeDl.Options.DownloadOptions.Retries = -1;
youtubeDl.Options.VideoFormatOptions.Format = Enums.VideoFormat.best;
youtubeDl.Options.PostProcessingOptions.AudioFormat = Enums.AudioFormat.best;
youtubeDl.Options.PostProcessingOptions.AudioQuality = "0";
youtubeDl.StandardOutputEvent += (sender, s) =>
{
var pattern = @"(?<progress>[^ ]{1,10}%).*?at.*?(?<rate>\d[^ ]{1,10}MiB\/s).*?(?<ETA>ETA [^ ]*)";
var match = Regex.Match(s, pattern);
if (match.Success)
{
progressCallback(match.Groups["progress"].Value, match.Groups["rate"].Value, match.Groups["ETA"].Value);
}
};
await youtubeDl.DownloadAsync();
}
public MediaEntry(YoutubeDL ydl, VideoData metadata, OptionSet overrideOptions = null)
{
this.ydl = ydl;
this.Metadata = metadata;
this.OverrideOptions = overrideOptions;
this.progress = new Progress <DownloadProgress>(p => RaiseDownloadStateChanged(p));
}
/// https://github.com/BrianAllred/NYoutubeDL/commit/2bd39515eebb8c5fb866687781165804e3b0579f
public async Task YouTubeDownloader(string _link, string _extension, string _path)
{
try
{
var youtubeDl = new YoutubeDL();
#region File Name
string name = Random(100000, 999999).ToString();
while (File.Exists(_path + @"\" + name + _extension))
{
name = Random(100000, 999999).ToString();
}
#endregion File Name
youtubeDl.Options.FilesystemOptions.Output = _path + @"\" + name + _extension;
if (_extension == ".mp3")
{
youtubeDl.Options.PostProcessingOptions.ExtractAudio = true;
}
youtubeDl.VideoUrl = _link;
youtubeDl.YoutubeDlPath = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Milkenm\Bronze Player", "Path", null).ToString() + "youtube-dl.exe";
await youtubeDl.PrepareDownloadAsync();
await youtubeDl.DownloadAsync();
}
#region DE3UG
catch (Exception exception)
{
tools.Exception(exception);
}
#endregion DE3UG
}
public YoutubeDlService(DownloadQueueService queueService, StreamableUploadService streamableService)
{
_queueService = queueService;
_streamableService = streamableService;
_youtubeDl = new();
_youtubeDl.Options.FilesystemOptions.Output = "/app/video.mp4";
}
static async Task GetAudio(string location, string fileName)
{
var yt = new YoutubeDL();
yt.Options.FilesystemOptions.Output = $@"e:\test\{fileName}";
yt.Options.PostProcessingOptions.ExtractAudio = true;
yt.Options.PostProcessingOptions.AudioFormat = Enums.AudioFormat.mp3;
yt.VideoUrl = location;
yt.Options.GeneralOptions.Update = true;
yt.YoutubeDlPath = $@"e:\test\youtube-dl.exe";
yt.StandardOutputEvent += (sender, output) => Console.WriteLine(output);
yt.StandardErrorEvent += (sender, errorOutput) => Console.WriteLine(errorOutput);
// string commandToRun = await yt.PrepareDownloadAsync();
// Alternatively
string commandToRun = yt.PrepareDownload();
// Just let it run
await yt.DownloadAsync();
// Wait for it
// yt.Download();
}
/// <summary>
/// Asynchronously retrieve video / playlist information
/// </summary>
/// <param name="ydl">
/// The client
/// </param>
/// <param name="url">
/// URL of video / playlist
/// </param>
/// <param name="cancellationToken">
/// The cancellation token
/// </param>
/// <returns>
/// An object containing the download information
/// </returns>
internal static async Task <DownloadInfo> GetDownloadInfoAsync(this YoutubeDL ydl, string url, CancellationToken cancellationToken)
{
ydl.VideoUrl = url;
await GetDownloadInfoAsync(ydl, cancellationToken);
return(ydl.Info);
}
private async Task <VideoQualityFormat> getVideoFormatsAsync(string url)
{
VideoQualityFormat data = null;
var updateGUIThread = new Progress <string>((value) =>
{
});
var updateMainForm = updateGUIThread as IProgress <string>;
await Task.Run(() => {
string x = "";
var youtubeDL1 = new YoutubeDL();
youtubeDL1.StandardOutputEvent += (sender, output) => {
Console.WriteLine(output);
x = output;
};
youtubeDL1.StandardErrorEvent += (sender, errorOutput) => Console.WriteLine(errorOutput);
youtubeDL1.VideoUrl = _VODObject.url;
youtubeDL1.Options.VerbositySimulationOptions.DumpJson = true;
//Only can do one json even at a time
youtubeDL1.Download();
data = JsonConvert.DeserializeObject <VideoQualityFormat>(x);
});
return(data);
}
private static void SetInfoOptions(YoutubeDL ydl)
{
Options infoOptions = new Options
{
VerbositySimulationOptions =
{
DumpSingleJson = true,
Simulate = true
},
GeneralOptions =
{
FlatPlaylist = !ydl.RetrieveAllInfo,
IgnoreErrors = true
},
AuthenticationOptions =
{
Username = ydl.Options.AuthenticationOptions.Username,
Password = ydl.Options.AuthenticationOptions.Password,
NetRc = ydl.Options.AuthenticationOptions.NetRc,
VideoPassword = ydl.Options.AuthenticationOptions.VideoPassword,
TwoFactor = ydl.Options.AuthenticationOptions.TwoFactor
},
VideoSelectionOptions =
{
NoPlaylist = ydl.Options.VideoSelectionOptions.NoPlaylist
}
};
ydl.Options = infoOptions;
}
public static async Task <string> SearchChannel(string query, IServerApplicationPaths appPaths, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var ytd = new YoutubeDL();
var url = String.Format(Constants.SearchQuery, System.Web.HttpUtility.UrlEncode(query));
ytd.Options.VerbositySimulationOptions.Simulate = true;
ytd.Options.GeneralOptions.FlatPlaylist = true;
ytd.Options.VideoSelectionOptions.PlaylistItems = "1";
ytd.Options.VerbositySimulationOptions.PrintField = "url";
List <string> ytdl_errs = new();
List <string> ytdl_out = new();
ytd.StandardErrorEvent += (sender, error) => ytdl_errs.Add(error);
ytd.StandardOutputEvent += (sender, output) => ytdl_out.Add(output);
var cookie_file = Path.Join(appPaths.PluginsPath, "YoutubeMetadata", "cookies.txt");
if (File.Exists(cookie_file))
{
ytd.Options.FilesystemOptions.Cookies = cookie_file;
}
var task = ytd.DownloadAsync(url);
await task;
Uri uri = new Uri(ytdl_out[0]);
return(uri.Segments[uri.Segments.Length - 1]);
}
public static async Task YTDLMetadata(string id, IServerApplicationPaths appPaths, CancellationToken cancellationToken)
{
//var foo = await ValidCookie(appPaths, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
var ytd = new YoutubeDL();
ytd.Options.FilesystemOptions.WriteInfoJson = true;
ytd.Options.VerbositySimulationOptions.SkipDownload = true;
var cookie_file = Path.Join(appPaths.PluginsPath, "YoutubeMetadata", "cookies.txt");
if (File.Exists(cookie_file))
{
ytd.Options.FilesystemOptions.Cookies = cookie_file;
}
var dlstring = "https://www.youtube.com/watch?v=" + id;
var dataPath = Path.Combine(appPaths.CachePath, "youtubemetadata", id, "ytvideo");
ytd.Options.FilesystemOptions.Output = dataPath;
List <string> ytdl_errs = new();
ytd.StandardErrorEvent += (sender, error) => ytdl_errs.Add(error);
var task = ytd.DownloadAsync(dlstring);
await task;
}
public static async Task <bool> ValidCookie(IServerApplicationPaths appPaths, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var ytd = new YoutubeDL();
var task = ytd.DownloadAsync("https://www.youtube.com/playlist?list=WL");
List <string> ytdl_errs = new();
ytd.StandardErrorEvent += (sender, error) => ytdl_errs.Add(error);
ytd.Options.VideoSelectionOptions.PlaylistItems = "0";
ytd.Options.VerbositySimulationOptions.SkipDownload = true;
var cookie_file = Path.Join(appPaths.PluginsPath, "YoutubeMetadata", "cookies.txt");
if (File.Exists(cookie_file))
{
ytd.Options.FilesystemOptions.Cookies = cookie_file;
}
await task;
foreach (string err in ytdl_errs)
{
var match = Regex.Match(err, @".*The playlist does not exist\..*");
if (match.Success)
{
return(false);
}
}
return(true);
}
static string VideoDownload(string url)
{
var youtubeDl = new YoutubeDL();
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
youtubeDl.YoutubeDlPath = "./tools/youtube-dl.exe";
}
else
{
youtubeDl.YoutubeDlPath = "./tools/youtube-dl";
}
string filename = url.Split("/")[url.Split("/").Length - 2] + ".mp4";
youtubeDl.Options.FilesystemOptions.Output = filename;
youtubeDl.VideoUrl = "https://reddit.com" + url;
Console.WriteLine("https://reddit.com" + url);
youtubeDl.StandardOutputEvent += (sender, output) => Console.WriteLine(output);
youtubeDl.StandardErrorEvent += (sender, errorOutput) => Console.WriteLine(errorOutput);
string commandToRun = youtubeDl.PrepareDownload();
youtubeDl.Download();
youtubeDl = null;
return(filename);
}
private async void MusicSearchButton_Click(object sender, EventArgs e)
{
if (String.IsNullOrWhiteSpace(textBox1.Text))
{
MessageBox.Show("Поисковая строка пустая!");
}
else
{
try
{
if (announcer == true)
{
playVoiceLine(3);
}
await Task.Run(async() => yt.Start(textBox1.Text));
if (String.IsNullOrWhiteSpace(yt.videoKey))
{
MessageBox.Show("Nothing found!");
}
else
{
axWindowsMediaPlayer1.Visible = false;
axWindowsMediaPlayer1.close();
textBox1.Text = yt.videoTitile;
path = yt.videoTitile + "-" + yt.videoKey + ".mp4";
{
path = path.Replace("&", "&");
path = path.Replace("|", "_");
path = path.Replace("*", "_");
path = path.Replace("/", "_");
path = path.Replace(@"\", "_");
path = path.Replace(":", "_");
path = path.Replace("?", "_");
path = path.Replace(""", "'");
} // Fixing problems with path, cause video can contains symbols like /, or ?, which not exits in file names in Windows OC
var youtubeDl = new YoutubeDL();
youtubeDl.YoutubeDlPath = @"..\..\Videos\youtube-dl.exe";
youtubeDl.Options.PostProcessingOptions.ExtractAudio = true;
youtubeDl.Options.VideoFormatOptions.Format = NYoutubeDL.Helpers.Enums.VideoFormat.worst;
MessageBox.Show(path);
await youtubeDl.DownloadAsync($"https://www.youtube.com/watch?v={yt.videoKey}");
new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.DeleteOnClose);
axWindowsMediaPlayer1.Visible = true;
axWindowsMediaPlayer1.URL = path;
axWindowsMediaPlayer1.Ctlcontrols.play();
}
}
catch
{
MessageBox.Show("Ошибки случаются");
}
}
}
public void TestIsPlaylistDownload()
{
YoutubeDL ydlClient = new YoutubeDL();
var info = ydlClient.GetDownloadInfo(@"https://www.youtube.com/playlist?list=PLrEnWoR732-BHrPp_Pm8_VleD68f9s14-");
Assert.NotNull(info as PlaylistDownloadInfo);
}
public void TestIsVideoDownload()
{
YoutubeDL ydlClient = new YoutubeDL();
var info = ydlClient.GetDownloadInfo(@"https://www.youtube.com/watch?v=dQw4w9WgXcQ");
Assert.NotNull(info as VideoDownloadInfo);
}
