942 lines
36 KiB
C#
942 lines
36 KiB
C#
using System;
|
|
using YoutubeExplode;
|
|
using YoutubeExplode.Videos;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Net.Http;
|
|
using Newtonsoft.Json;
|
|
using System.IO;
|
|
|
|
using YoutubeExplode.Playlists;
|
|
using YoutubeExplode.Channels;
|
|
using YoutubeExplode.Search;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
|
|
namespace Tesses.YouTubeDownloader
|
|
{
|
|
|
|
public abstract class TYTDBase : ITYTDBase
|
|
{
|
|
public virtual async Task<bool> ThumbnailExistsAsync(VideoId videoId,string res)
|
|
{
|
|
return await FileExistsAsync($"Thumbnails/{videoId.Value}/{res}.jpg");
|
|
}
|
|
public virtual bool ThumbnailExists(VideoId videoId,string res)
|
|
{
|
|
return FileExists($"Thumbnails/{videoId.Value}/{res}.jpg");
|
|
}
|
|
public virtual async Task<byte[]> ReadThumbnailAsync(VideoId videoId,string res,CancellationToken token=default)
|
|
{
|
|
if(await ThumbnailExistsAsync(videoId,res))
|
|
{
|
|
return await ReadAllBytesAsync($"Thumbnails/{videoId.Value}/{res}.jpg",token);
|
|
}
|
|
return new byte[0];
|
|
}
|
|
public virtual bool PersonalPlaylistExists(string name)
|
|
{
|
|
return FileExists($"PersonalPlaylist/{name}.json");
|
|
}
|
|
public virtual async IAsyncEnumerable<ListContentItem> GetPersonalPlaylistContentsAsync(string playlist)
|
|
{
|
|
if(!PersonalPlaylistExists(playlist)) yield break;
|
|
var ls=JsonConvert.DeserializeObject<List<ListContentItem>>(await ReadAllTextAsync($"PersonalPlaylist/{playlist}.json"));
|
|
foreach(var item in ls)
|
|
{
|
|
yield return await Task.FromResult(item);
|
|
}
|
|
}
|
|
public virtual async IAsyncEnumerable<string> GetPersonalPlaylistsAsync()
|
|
{
|
|
await foreach(var item in EnumerateFilesAsync("PersonalPlaylist"))
|
|
{
|
|
if(Path.GetExtension(item) == ".json")
|
|
{
|
|
yield return await Task.FromResult(Path.GetFileNameWithoutExtension(item));
|
|
}
|
|
}
|
|
}
|
|
public virtual async Task<(String Path,bool Delete)> GetRealUrlOrPathAsync(string path)
|
|
{
|
|
string tmpFile = Path.GetTempFileName();
|
|
File.Delete(tmpFile);
|
|
tmpFile=tmpFile + Path.GetExtension(path);
|
|
using(var f = File.Create(tmpFile))
|
|
{
|
|
using(var src=await OpenReadAsync(path))
|
|
{
|
|
await TYTDManager.CopyStream(src,f);
|
|
}
|
|
}
|
|
|
|
return (tmpFile,true);
|
|
}
|
|
|
|
|
|
public bool FileExists(string path)
|
|
{
|
|
return Task.Run(()=>FileExistsAsync(path)).GetAwaiter().GetResult();
|
|
}
|
|
|
|
public virtual async IAsyncEnumerable<string> GetVideoIdsAsync()
|
|
{
|
|
await foreach(var item in EnumerateFilesAsync("Info"))
|
|
{
|
|
if(Path.GetExtension(item).Equals(".json",StringComparison.Ordinal))
|
|
{
|
|
yield return Path.GetFileNameWithoutExtension(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual async Task<SavedVideo> GetVideoInfoAsync(VideoId id)
|
|
{
|
|
|
|
return JsonConvert.DeserializeObject<SavedVideo>(await ReadAllTextAsync($"Info/{id}.json"));
|
|
}
|
|
|
|
public virtual async IAsyncEnumerable<SavedVideo> GetVideosAsync()
|
|
{
|
|
await foreach(var item in GetVideoIdsAsync())
|
|
{
|
|
var item0=await GetVideoInfoAsync(item);
|
|
if(item0 != null)
|
|
{
|
|
yield return item0;
|
|
}
|
|
}
|
|
}
|
|
public virtual async IAsyncEnumerable<SavedVideoLegacy> GetLegacyVideosAsync()
|
|
{
|
|
await foreach(var item in GetVideoIdsAsync())
|
|
{
|
|
var item0 =await GetLegacyVideoInfoAsync(item);
|
|
if(item0 != null)
|
|
{
|
|
yield return item0;
|
|
}
|
|
}
|
|
}
|
|
public virtual async Task<SavedVideoLegacy> GetLegacyVideoInfoAsync(VideoId id)
|
|
{
|
|
return JsonConvert.DeserializeObject<SavedVideoLegacy>(await ReadAllTextAsync($"Info/{id}.json"));
|
|
}
|
|
public virtual async IAsyncEnumerable<SavedPlaylist> GetPlaylistsAsync()
|
|
{
|
|
await foreach(var item in GetPlaylistIdsAsync())
|
|
{
|
|
var item0=await GetPlaylistInfoAsync(item);
|
|
if(item0 != null)
|
|
{
|
|
yield return item0;
|
|
}
|
|
}
|
|
}
|
|
|
|
public async Task<byte[]> ReadAllBytesAsync(string path,CancellationToken token=default(CancellationToken))
|
|
{using(var strm = await OpenReadAsync(path))
|
|
{
|
|
byte[] data=new byte[strm.Length];
|
|
|
|
await strm.ReadAsync(data,0,data.Length,token);
|
|
if(token.IsCancellationRequested)
|
|
{
|
|
return new byte[0];
|
|
}
|
|
return data;
|
|
}
|
|
|
|
}
|
|
public virtual async IAsyncEnumerable<string> GetPlaylistIdsAsync()
|
|
{
|
|
await foreach(var item in EnumerateFilesAsync("Playlist"))
|
|
{
|
|
if(Path.GetExtension(item).Equals(".json",StringComparison.Ordinal))
|
|
{
|
|
yield return Path.GetFileNameWithoutExtension(item);
|
|
}
|
|
}
|
|
}
|
|
public virtual async IAsyncEnumerable<string> GetChannelIdsAsync()
|
|
{
|
|
await foreach(var item in EnumerateFilesAsync("Channel"))
|
|
{
|
|
if(Path.GetExtension(item).Equals(".json",StringComparison.Ordinal))
|
|
{
|
|
yield return Path.GetFileNameWithoutExtension(item);
|
|
}
|
|
}
|
|
}
|
|
public virtual async IAsyncEnumerable<VideoId> GetYouTubeExplodeVideoIdsAsync()
|
|
{
|
|
await foreach(var item in GetVideoIdsAsync())
|
|
{
|
|
VideoId? id= VideoId.TryParse(item);
|
|
if(id.HasValue) yield return id.Value;
|
|
}
|
|
}
|
|
public virtual async Task<SavedChannel> GetChannelInfoAsync(ChannelId id)
|
|
{
|
|
return JsonConvert.DeserializeObject<SavedChannel>(await ReadAllTextAsync($"Channel/{id}.json"));
|
|
}
|
|
public virtual async IAsyncEnumerable<SavedChannel> GetChannelsAsync()
|
|
{
|
|
await foreach(var item in GetChannelIdsAsync())
|
|
{
|
|
var item0=await GetChannelInfoAsync(item);
|
|
if(item0 != null)
|
|
{
|
|
yield return item0;
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual async IAsyncEnumerable<SavedVideo> GetDownloadsAsync()
|
|
{
|
|
await foreach(var item in EnumerateFilesAsync("DownloadsInfo"))
|
|
{
|
|
if(Path.GetExtension(item).Equals(".json",StringComparison.Ordinal))
|
|
{
|
|
yield return JsonConvert.DeserializeObject<SavedVideo>(await ReadAllTextAsync(item));
|
|
|
|
}
|
|
}
|
|
}
|
|
public virtual async IAsyncEnumerable<string> GetDownloadUrlsAsync()
|
|
{
|
|
await foreach(var item in GetDownloadsAsync())
|
|
{
|
|
yield return item.Id;
|
|
}
|
|
}
|
|
|
|
public virtual async Task<BestStreamInfo.BestStreamsSerialized> GetBestStreamInfoAsync(VideoId id)
|
|
{
|
|
return JsonConvert.DeserializeObject<BestStreamInfo.BestStreamsSerialized>(await ReadAllTextAsync($"StreamInfo/{id.Value}.json"));
|
|
}
|
|
public virtual bool BestStreamInfoExists(VideoId id)
|
|
{
|
|
return FileExists($"StreamInfo/{id.Value}.json");
|
|
}
|
|
public virtual async Task<SavedVideo> GetDownloadInfoAsync(string url)
|
|
{
|
|
//string enc=$"FileInfo/{B64.Base64UrlEncodes(url)}.json";
|
|
string enc=$"DownloadsInfo/{HashDownloadUrl(url)}.json";
|
|
return JsonConvert.DeserializeObject<SavedVideo>(await ReadAllTextAsync(enc));
|
|
|
|
}
|
|
|
|
public static string HashDownloadUrl(string url)
|
|
{
|
|
using(var sha1=SHA1.Create()){
|
|
|
|
return B64.Base64UrlEncode(sha1.ComputeHash(Encoding.UTF8.GetBytes(url)));
|
|
}
|
|
}
|
|
|
|
public virtual bool DownloadExists(string url)
|
|
{
|
|
string enc=$"DownloadsInfo/{HashDownloadUrl(url)}.json";
|
|
|
|
return FileExists(enc);
|
|
}
|
|
public virtual bool PlaylistInfoExists(PlaylistId id)
|
|
{
|
|
return FileExists($"Playlist/{id}.json");
|
|
}
|
|
public virtual bool VideoInfoExists(VideoId id)
|
|
{
|
|
return FileExists($"Info/{id}.json");
|
|
}
|
|
public virtual bool ChannelInfoExists(ChannelId id)
|
|
{
|
|
return FileExists($"Channel/{id}.json");
|
|
}
|
|
public virtual async Task<SavedPlaylist> GetPlaylistInfoAsync(PlaylistId id)
|
|
{
|
|
return JsonConvert.DeserializeObject<SavedPlaylist>(await ReadAllTextAsync($"Playlist/{id}.json"));
|
|
}
|
|
|
|
public virtual async Task<string> ReadAllTextAsync(string file)
|
|
{
|
|
using(var s = await OpenReadAsync(file))
|
|
{
|
|
using(var sr = new StreamReader(s))
|
|
{
|
|
return await sr.ReadToEndAsync();
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool DirectoryExists(string path)
|
|
{
|
|
return Task.Run(()=>DirectoryExistsAsync(path)).GetAwaiter().GetResult();
|
|
}
|
|
|
|
public virtual IEnumerable<string> EnumerateFiles(string path)
|
|
{
|
|
var e = EnumerateFilesAsync(path).GetAsyncEnumerator();
|
|
while(e.MoveNextAsync().GetAwaiter().GetResult())
|
|
{
|
|
yield return e.Current;
|
|
}
|
|
}
|
|
public virtual IEnumerable<string> EnumerateDirectories(string path)
|
|
{
|
|
var e = EnumerateDirectoriesAsync(path).GetAsyncEnumerator();
|
|
while(e.MoveNextAsync().GetAwaiter().GetResult())
|
|
{
|
|
yield return e.Current;
|
|
}
|
|
}
|
|
|
|
public abstract Task<Stream> OpenReadAsync(string path);
|
|
|
|
public abstract Task<bool> FileExistsAsync(string path);
|
|
|
|
public abstract Task<bool> DirectoryExistsAsync(string path);
|
|
|
|
public abstract IAsyncEnumerable<string> EnumerateFilesAsync(string path);
|
|
|
|
public abstract IAsyncEnumerable<string> EnumerateDirectoriesAsync(string path);
|
|
|
|
public virtual ExtraData GetExtraData()
|
|
{
|
|
ExtraData data=new ExtraData();
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public class ListContentItem
|
|
{
|
|
public ListContentItem()
|
|
{
|
|
Id="";
|
|
Resolution=Resolution.PreMuxed;
|
|
}
|
|
public ListContentItem(VideoId id)
|
|
{
|
|
Id=id.Value;
|
|
Resolution=Resolution.PreMuxed;
|
|
}
|
|
public ListContentItem(string id)
|
|
{
|
|
Id=id;
|
|
Resolution =Resolution.PreMuxed;
|
|
}
|
|
public ListContentItem(string id,Resolution resolution)
|
|
{
|
|
Id=id;
|
|
Resolution=resolution;
|
|
}
|
|
public ListContentItem(VideoId id,Resolution resolution)
|
|
{
|
|
Id=id.Value;
|
|
Resolution=resolution;
|
|
}
|
|
public string Id {get;set;}
|
|
public Resolution Resolution {get;set;}
|
|
|
|
public static implicit operator ListContentItem(VideoId id)
|
|
{
|
|
return new ListContentItem(id.Value, Resolution.PreMuxed);
|
|
}
|
|
public static implicit operator VideoId?(ListContentItem item)
|
|
{
|
|
return VideoId.TryParse(item.Id);
|
|
}
|
|
|
|
public static implicit operator ListContentItem((VideoId Id,Resolution Resolution) item)
|
|
{
|
|
return new ListContentItem (item.Id,item.Resolution);
|
|
}
|
|
public static implicit operator (VideoId Id,Resolution Resolution)(ListContentItem item)
|
|
{
|
|
return (VideoId.Parse(item.Id),item.Resolution);
|
|
}
|
|
}
|
|
public enum MediaType
|
|
{
|
|
Video=0,
|
|
Playlist=1,
|
|
Channel=2,
|
|
|
|
|
|
}
|
|
public class SearchResult
|
|
{
|
|
|
|
public SearchResult()
|
|
{
|
|
Title="";
|
|
Id="";
|
|
Type=MediaType.Video;
|
|
}
|
|
public SearchResult(ISearchResult result)
|
|
{
|
|
var video = result as VideoSearchResult;
|
|
var playlist = result as PlaylistSearchResult;
|
|
var channel = result as ChannelSearchResult;
|
|
if(video != null)
|
|
{
|
|
Id=video.Id;
|
|
Title = video.Title;
|
|
Type=MediaType.Video;
|
|
}
|
|
if(playlist != null)
|
|
{
|
|
Id=playlist.Id;
|
|
Title=playlist.Title;
|
|
Type=MediaType.Playlist;
|
|
}
|
|
if(channel != null)
|
|
{
|
|
Id=channel.Id;
|
|
Title = channel.Title;
|
|
Type=MediaType.Channel;
|
|
}
|
|
}
|
|
|
|
public string Title {get;set;}
|
|
public string Id {get;set;}
|
|
|
|
public MediaType Type {get;set;}
|
|
|
|
public void AddToQueue(IStorage storage)
|
|
{
|
|
switch(Type)
|
|
{
|
|
case MediaType.Video:
|
|
storage.AddVideoAsync(Id,Resolution.NoDownload);
|
|
break;
|
|
case MediaType.Playlist:
|
|
storage.AddPlaylistAsync(Id,Resolution.NoDownload);
|
|
break;
|
|
case MediaType.Channel:
|
|
storage.AddChannelAsync(Id,Resolution.NoDownload);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
public static class TYTDManager
|
|
{
|
|
|
|
public static async Task<bool> VideoExistsAsync(this ITYTDBase baseCtl,VideoId id,Resolution resolution=Resolution.PreMuxed)
|
|
{
|
|
return (await GetVideoPathAsync(baseCtl,id,resolution)).Exists;
|
|
}
|
|
public static async Task<(bool Exists,string Path)> GetVideoPathAsync(this ITYTDBase baseCtl,VideoId id,Resolution resolution=Resolution.PreMuxed)
|
|
{
|
|
if(!baseCtl.VideoInfoExists(id) || !baseCtl.BestStreamInfoExists(id)) return (false,"");
|
|
var video=await baseCtl.GetVideoInfoAsync(id);
|
|
var name = await BestStreams.GetPathResolution(baseCtl,video,resolution);
|
|
if(string.IsNullOrWhiteSpace(name)) return (false,"");
|
|
|
|
return (await baseCtl.FileExistsAsync(name),name);
|
|
}
|
|
public static async IAsyncEnumerable<SearchResult> SearchYouTubeAsync(this IStorage storage, string query,bool getMediaInfo=true)
|
|
{
|
|
await foreach(var vid in storage.YoutubeClient.Search.GetResultsAsync(query))
|
|
{
|
|
var res=new SearchResult(vid);
|
|
if(getMediaInfo)
|
|
{
|
|
res.AddToQueue(storage);
|
|
}
|
|
yield return res;
|
|
}
|
|
}
|
|
public static bool DownloadFileExists(this ITYTDBase baseCtl,string url)
|
|
{
|
|
return baseCtl.FileExists(GetDownloadFile(url));
|
|
}
|
|
public static string GetDownloadFile(this ITYTDBase baseCtl,string url)
|
|
{
|
|
return GetDownloadFile(url);
|
|
}
|
|
public static string GetDownloadFile(string url)
|
|
{
|
|
string file_path = $"Downloads/{TYTDBase.HashDownloadUrl(url)}.bin";
|
|
return file_path;
|
|
}
|
|
/// <summary>
|
|
/// Add Video, Playlist, Channel Or Username
|
|
/// </summary>
|
|
/// <param name="url">Video, Playlist, Channel Or UserName Url Or Id</param>
|
|
/// <param name="resolution">Video Resolution</param>
|
|
public static async Task<List<(VideoId Id,Resolution Resolution)>> ToPersonalPlaylist(this IAsyncEnumerable<VideoId> list,Resolution res)
|
|
{
|
|
List<(VideoId Id,Resolution Resolution)> items=new List<(VideoId Id, Resolution Resolution)>();
|
|
await foreach(var item in list)
|
|
{
|
|
items.Add((item,res));
|
|
}
|
|
return items;
|
|
}
|
|
public static async Task AddItemAsync(this IDownloader downloader,string url,Resolution resolution=Resolution.PreMuxed)
|
|
{
|
|
|
|
VideoId? vid = VideoId.TryParse(url);
|
|
PlaylistId? pid = PlaylistId.TryParse(url);
|
|
ChannelId? cid = ChannelId.TryParse(url);
|
|
ChannelSlug? slug = ChannelSlug.TryParse(url);
|
|
ChannelHandle? handle = ChannelHandle.TryParse(url);
|
|
UserName? user = UserName.TryParse(url);
|
|
|
|
|
|
if (url.Length == 11)
|
|
{
|
|
if (vid.HasValue)
|
|
{
|
|
await downloader.AddVideoAsync(vid.Value, resolution); //shall we download video
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pid.HasValue)
|
|
{
|
|
await downloader.AddPlaylistAsync(pid.Value, resolution);
|
|
}
|
|
else if (vid.HasValue)
|
|
{
|
|
|
|
await downloader.AddVideoAsync(vid.Value, resolution);
|
|
}
|
|
else if (cid.HasValue)
|
|
{
|
|
await downloader.AddChannelAsync(cid.Value, resolution);
|
|
}
|
|
else if(handle.HasValue)
|
|
{
|
|
await downloader.AddHandleAsync(handle.Value, resolution);
|
|
}else if(slug.HasValue)
|
|
{
|
|
await downloader.AddSlugAsync(slug.Value,resolution);
|
|
}
|
|
else if (user.HasValue)
|
|
{
|
|
await downloader.AddUserAsync(user.Value, resolution);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
internal static void Print(this IProgress<string> prog,string text)
|
|
{
|
|
if(prog !=null)
|
|
{
|
|
prog.Report(text);
|
|
}
|
|
}
|
|
private static string[] resStr = new string[] {"Muxed","PreMuxed","AudioOnly","VideoOnly"};
|
|
|
|
/// <summary>
|
|
/// Convert DirectoryName to Resolution
|
|
/// </summary>
|
|
/// <param name="folder"></param>
|
|
/// <returns>Video Resolution</returns>
|
|
public static Resolution DirectoryToResolution(string folder)
|
|
{
|
|
int e= Array.IndexOf(resStr,folder);
|
|
if(e == -1) {return Resolution.NoDownload;}
|
|
|
|
return (Resolution)e;
|
|
}
|
|
public static string ResolutionToDirectory(Resolution res)
|
|
{
|
|
return resStr[(int)res];
|
|
}
|
|
public static async Task<bool> CopyVideoToFileAsync(VideoId id,ITYTDBase src,Stream destFile,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken))
|
|
{
|
|
string infoFile=$"Info/{id.Value}.json";
|
|
string path="";
|
|
if(await src.FileExistsAsync(infoFile)){
|
|
string f=await src.ReadAllTextAsync(infoFile);
|
|
SavedVideo video = JsonConvert.DeserializeObject<SavedVideo>(f);
|
|
path=await BestStreams.GetPathResolution(src,video,res);
|
|
}else{
|
|
return false;
|
|
}
|
|
if(string.IsNullOrWhiteSpace(path)) return false;
|
|
|
|
bool ret=false;
|
|
if(await src.FileExistsAsync(path))
|
|
{
|
|
using(var srcFile = await src.OpenReadAsync(path))
|
|
{
|
|
double len=srcFile.Length;
|
|
|
|
|
|
ret= await CopyStream(srcFile,destFile,new Progress<long>((e)=>{
|
|
if(progress !=null)
|
|
{
|
|
progress.Report(e/len);
|
|
}
|
|
}),token);
|
|
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
public static async Task CopyVideoToFileAsync(VideoId id,ITYTDBase src,string dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken))
|
|
{
|
|
bool delete=false;
|
|
using(var f = File.Create(dest))
|
|
{
|
|
delete=!await CopyVideoToFileAsync(id,src,f,res,progress,token);
|
|
}
|
|
if(delete)
|
|
{
|
|
File.Delete(dest);
|
|
}
|
|
}
|
|
|
|
public static async Task<bool> CopyStream(Stream src,Stream dest,IProgress<long> progress=null,CancellationToken token=default(CancellationToken))
|
|
{
|
|
|
|
try{
|
|
byte[] array=new byte[1024];
|
|
int read=0;
|
|
long totrd=0;
|
|
do{
|
|
read=await src.ReadAsync(array,0,array.Length,token);
|
|
if(token.IsCancellationRequested)
|
|
{
|
|
return false;
|
|
}
|
|
totrd += read;
|
|
await dest.WriteAsync(array,0,read,token);
|
|
if(token.IsCancellationRequested)
|
|
{
|
|
return false;
|
|
}
|
|
if(progress!=null)
|
|
{
|
|
progress.Report(totrd);
|
|
}
|
|
}while(read> 0);
|
|
|
|
|
|
}catch(Exception ex)
|
|
{
|
|
_=ex;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
public static async Task CopyThumbnailsAsync(string id,ITYTDBase src,IStorage dest,IProgress<double> progress=null,CancellationToken token=default(CancellationToken))
|
|
{
|
|
|
|
if(!src.DirectoryExists("Thumbnails") || !src.DirectoryExists($"Thumbnails/{id}")) return;
|
|
await dest.CopyDirectoryFrom(src,$"Thumbnails/{id}",$"Thumbnails/{id}",progress,token);
|
|
}
|
|
|
|
public static async Task CopyDirectoryFrom(this IStorage _dest,ITYTDBase _src,string src,string dest,IProgress<double> progress,CancellationToken token=default(CancellationToken))
|
|
{
|
|
|
|
List<string> dirs=new List<string>();
|
|
|
|
await foreach(var dir in _src.EnumerateDirectoriesAsync(src))
|
|
{
|
|
dirs.Add(dir);
|
|
_dest.CreateDirectoryIfNotExist($"{dest.TrimEnd('/')}/{dir.TrimStart('/')}");
|
|
}
|
|
List<string> files=new List<string>();
|
|
await foreach(var file in _src.EnumerateFilesAsync(src))
|
|
{
|
|
files.Add(file);
|
|
}
|
|
int total = dirs.Count + files.Count;
|
|
int i=0;
|
|
double segLen = 1.0 / total;
|
|
foreach(var item in dirs)
|
|
{
|
|
if(token.IsCancellationRequested) return;
|
|
await CopyDirectoryFrom(_dest,_src,$"{src.TrimEnd('/')}/{item.TrimStart('/')}",$"{dest.TrimEnd('/')}/{item.TrimStart('/')}",new Progress<double>(e=>{
|
|
double percent = e / total;
|
|
percent += segLen * i;
|
|
if(percent >= 1) percent=1;
|
|
if(percent <= 0) percent= 0;
|
|
progress?.Report(percent);
|
|
}),token);
|
|
i++;
|
|
}
|
|
if(token.IsCancellationRequested) return;
|
|
foreach(var item in files)
|
|
{
|
|
if(token.IsCancellationRequested) return;
|
|
await CopyFileFrom(_dest,_src,$"{src.TrimEnd('/')}/{item.TrimStart('/')}",$"{dest.TrimEnd('/')}/{item.TrimStart('/')}",new Progress<double>(e=>{
|
|
double percent = e / total;
|
|
percent += segLen * i;
|
|
if(percent >= 1) percent=1;
|
|
if(percent <= 0) percent= 0;
|
|
progress?.Report(percent);
|
|
}),token);
|
|
i++;
|
|
}
|
|
}
|
|
public static async Task CopyFileFrom(this IStorage _dest,ITYTDBase _src,string src,string dest,IProgress<double> progress=null,CancellationToken token=default(CancellationToken))
|
|
{
|
|
|
|
using(var srcFile = await _src.OpenReadAsync(src))
|
|
{double len=srcFile.Length;
|
|
bool deleteFile=false;
|
|
using(var destFile = await _dest.CreateAsync(dest))
|
|
{
|
|
deleteFile=!await CopyStream(srcFile,destFile,new Progress<long>((e)=>{
|
|
if(progress !=null)
|
|
{
|
|
progress.Report(e/len);
|
|
}
|
|
}),token);
|
|
}
|
|
//dest.DeleteFile(path);
|
|
}
|
|
}
|
|
|
|
|
|
public static async Task CopyVideoAsync(VideoId id,ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken))
|
|
{
|
|
await CopyVideoAsync(id,src,dest,res,progress,token,true);
|
|
}
|
|
public static async Task CopyChannelContentsAsync(ChannelId id,ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken),bool copyThumbnails=true)
|
|
{
|
|
List<(VideoId Id, Resolution Resolution)> items=new List<(VideoId Id, Resolution Resolution)>();
|
|
await foreach(var v in src.GetVideosAsync())
|
|
{
|
|
if(v.AuthorChannelId == id.Value)
|
|
{
|
|
VideoId? id2=VideoId.TryParse(v.Id);
|
|
if(id2.HasValue)
|
|
{
|
|
items.Add((id2.Value,res));
|
|
}
|
|
}
|
|
}
|
|
await CopyPersonalPlaylistContentsAsync(items,src,dest,progress,token,copyThumbnails);
|
|
}
|
|
public static async Task CopyChannelAsync(ChannelId id,ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken),bool copyThumbnails=true,bool copyContents=false)
|
|
{
|
|
if(!src.ChannelInfoExists(id)) return;
|
|
var channel = await src.GetChannelInfoAsync(id);
|
|
await dest.WriteChannelInfoAsync(channel);
|
|
if(copyThumbnails)
|
|
await CopyThumbnailsAsync(id,src,dest,progress,default(CancellationToken));
|
|
|
|
if(copyContents)
|
|
await CopyChannelContentsAsync(id,src,dest,res,progress,token,copyThumbnails);
|
|
}
|
|
public static async Task CopyEverythingAsync(ITYTDBase src,IStorage dest,Resolution res,IProgress<double> progress=null,CancellationToken token=default(CancellationToken),bool copyThumbnails=true)
|
|
{
|
|
await CopyAllPlaylistsAsync(src,dest,res,null,token,copyThumbnails,false);
|
|
if(token.IsCancellationRequested) return;
|
|
await CopyAllChannelsAsync(src,dest,res,null,token,true);
|
|
if(token.IsCancellationRequested) return;
|
|
await CopyAllVideosAsync(src,dest,res,progress,token,copyThumbnails);
|
|
}
|
|
public static async Task CopyEverythingAsync(ITYTDBase src,IStorage dest,IProgress<double> progress=null,CancellationToken token=default(CancellationToken),bool copyThumbnails=true)
|
|
{
|
|
await CopyEverythingAsync(src,dest,Resolution.Mux,new Progress<double>(e=>{
|
|
double percent=e / 4;
|
|
progress?.Report(percent);
|
|
}));
|
|
await CopyEverythingAsync(src,dest,Resolution.PreMuxed,new Progress<double>(e=>{
|
|
double percent=e / 4;
|
|
percent+=0.25;
|
|
progress?.Report(percent);
|
|
}));
|
|
await CopyEverythingAsync(src,dest,Resolution.AudioOnly,new Progress<double>(e=>{
|
|
double percent=e / 4;
|
|
percent+=0.50;
|
|
progress?.Report(percent);
|
|
}));
|
|
await CopyEverythingAsync(src,dest,Resolution.VideoOnly,new Progress<double>(e=>{
|
|
double percent=e / 4;
|
|
percent+=0.75;
|
|
progress?.Report(percent);
|
|
}));
|
|
}
|
|
public static async Task CopyAllVideosAsync(ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken),bool copyThumbnails=true)
|
|
{
|
|
await CopyPersonalPlaylistContentsAsync(await src.GetYouTubeExplodeVideoIdsAsync().ToPersonalPlaylist(res),src,dest,progress,token,copyThumbnails);
|
|
}
|
|
public static async Task CopyAllPlaylistsAsync(ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken),bool copyThumbnails=true,bool copyContents=true)
|
|
{
|
|
List<SavedPlaylist> pl=new List<SavedPlaylist>();
|
|
await foreach(var playlist in src.GetPlaylistsAsync())
|
|
{
|
|
pl.Add(playlist);
|
|
}
|
|
int total=pl.Count;
|
|
int i = 0;
|
|
double segLen = 1.0 / total;
|
|
foreach(var item in pl)
|
|
{
|
|
if(token.IsCancellationRequested) return;
|
|
await CopyPlaylistAsync(item.Id,src,dest,res,new Progress<double>(e=>{
|
|
double percent = e / total;
|
|
percent += segLen * i;
|
|
if(percent >= 1) percent=1;
|
|
if(percent <= 0) percent= 0;
|
|
progress?.Report(percent);
|
|
}),token,copyThumbnails,copyContents);
|
|
i++;
|
|
}
|
|
}
|
|
public static async Task CopyAllChannelsAsync(ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken),bool copyThumbnails=true,bool copyContents=false)
|
|
{
|
|
//copying all channels is equivalent to copying all videos except we copy all channels info also
|
|
await foreach(var item in src.GetChannelsAsync())
|
|
{
|
|
await dest.WriteChannelInfoAsync(item);
|
|
}
|
|
if(copyContents)
|
|
await CopyAllVideosAsync(src,dest,res,progress,token,copyThumbnails);
|
|
}
|
|
public static async Task CopyPersonalPlaylistContentsAsync(List<(VideoId Id,Resolution Resolution)> list,ITYTDBase src,IStorage dest,IProgress<double> progress=null,CancellationToken token=default(CancellationToken), bool copyThumbnails=true)
|
|
{
|
|
int total=list.Count;
|
|
int i = 0;
|
|
double segLen = 1.0 / total;
|
|
|
|
foreach(var item in list)
|
|
{
|
|
if(token.IsCancellationRequested) return;
|
|
await CopyVideoAsync(item.Id,src,dest,item.Resolution,new Progress<double>(e=>{
|
|
double percent = e / total;
|
|
percent += segLen * i;
|
|
if(percent >= 1) percent=1;
|
|
if(percent <= 0) percent= 0;
|
|
progress?.Report(percent);
|
|
}),token,copyThumbnails);
|
|
i++;
|
|
}
|
|
}
|
|
public static async Task CopyPlaylistContentsAsync(SavedPlaylist list,ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken), bool copyThumbnails=true)
|
|
{
|
|
|
|
await CopyPersonalPlaylistContentsAsync(list.ToPersonalPlaylist(res),src,dest,progress,token,copyThumbnails);
|
|
}
|
|
public static async Task CopyPlaylistAsync(PlaylistId id,ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token = default(CancellationToken),bool copyThumbnails=true,bool copyContents=true)
|
|
{
|
|
//copy playlist and videos
|
|
if(!src.PlaylistInfoExists(id)) return;
|
|
var playlist=await src.GetPlaylistInfoAsync(id);
|
|
await dest.WritePlaylistInfoAsync(playlist);
|
|
if(copyContents)
|
|
await CopyPlaylistContentsAsync(playlist,src,dest,res,progress,token,copyThumbnails);
|
|
}
|
|
public static async Task CopyVideoAsync(VideoId id,ITYTDBase src,IStorage dest,Resolution res=Resolution.PreMuxed,IProgress<double> progress=null,CancellationToken token=default(CancellationToken),bool copyThumbnails=true)
|
|
{
|
|
if(copyThumbnails)
|
|
{
|
|
await CopyThumbnailsAsync(id.Value,src,dest,progress,token);
|
|
}
|
|
string resDir = ResolutionToDirectory(res);
|
|
|
|
string infoFile = $"Info/{id}.json";
|
|
|
|
string streamInfo = $"StreamInfo/{id}.json";
|
|
string path="";
|
|
if(src.VideoInfoExists(id))
|
|
{
|
|
|
|
SavedVideo video = await src.GetVideoInfoAsync(id);
|
|
path=await BestStreams.GetPathResolution(src,video,res);
|
|
if(!dest.VideoInfoExists(id))
|
|
{
|
|
await dest.WriteVideoInfoAsync(video);
|
|
}
|
|
}else{
|
|
return;
|
|
}
|
|
if(string.IsNullOrWhiteSpace(path)) return;
|
|
if(await src.FileExistsAsync(streamInfo))
|
|
{
|
|
if(!await dest.FileExistsAsync(streamInfo))
|
|
{
|
|
string f = await src.ReadAllTextAsync(streamInfo);
|
|
await dest.WriteAllTextAsync(infoFile,f);
|
|
}
|
|
}
|
|
if(token.IsCancellationRequested)
|
|
{
|
|
return;
|
|
}
|
|
if(await src.FileExistsAsync(path))
|
|
{
|
|
if(!await dest.FileExistsAsync(path))
|
|
{
|
|
return;
|
|
}
|
|
|
|
dest.CreateDirectory(resDir);
|
|
using(var srcFile = await src.OpenReadAsync(path))
|
|
{
|
|
double len=srcFile.Length;
|
|
bool deleteFile=false;
|
|
using(var destFile = await dest.CreateAsync(path))
|
|
{
|
|
deleteFile=!await CopyStream(srcFile,destFile,new Progress<long>((e)=>{
|
|
if(progress !=null)
|
|
{
|
|
progress.Report(e/len);
|
|
}
|
|
}),token);
|
|
}
|
|
//dest.DeleteFile(path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public class Chapter
|
|
{
|
|
public Chapter(TimeSpan ts, string name)
|
|
{
|
|
Offset = ts;
|
|
ChapterName = name;
|
|
}
|
|
public TimeSpan Length {get;set;}
|
|
public TimeSpan Offset { get; set; }
|
|
public string ChapterName { get; set; }
|
|
|
|
public override string ToString()
|
|
{
|
|
|
|
return $"[{Offset}-{Offset.Add(Length)}] {ChapterName}";
|
|
}
|
|
}
|
|
public interface IPersonalPlaylistGet
|
|
{
|
|
ExtraData GetExtraData();
|
|
IAsyncEnumerable<ListContentItem> GetPersonalPlaylistContentsAsync(string name);
|
|
bool PersonalPlaylistExists(string name);
|
|
}
|
|
public interface IPersonalPlaylistSet : IPersonalPlaylistGet
|
|
{
|
|
Task AddToPersonalPlaylistAsync(string name, IEnumerable<ListContentItem> items);
|
|
|
|
Task ReplacePersonalPlaylistAsync(string name,IEnumerable<ListContentItem> items);
|
|
|
|
Task RemoveItemFromPersonalPlaylistAsync(string name,VideoId id);
|
|
|
|
Task SetResolutionForItemInPersonalPlaylistAsync(string name,VideoId id,Resolution resolution);
|
|
|
|
|
|
}
|
|
public interface IWritable : IPersonalPlaylistGet, IPersonalPlaylistSet
|
|
{
|
|
public Task WriteAllTextAsync(string path,string data);
|
|
}
|
|
|
|
|
|
} |