/// <summary>
/// Get youtube video depending of choosen quality settings
/// </summary>
/// <param name="videosToProcess">List of VideoInfo</param>
/// <param name="quality">The youtube quality settings</param>
/// <returns>The trailer's video info</returns>
private VideoInfo GetVideoByStreamingQuality(IEnumerable <VideoInfo> videosToProcess,
YoutubeStreamingQuality quality)
{
while (true)
{
var videos = videosToProcess.ToList(); // Prevent multiple enumeration
if (quality == YoutubeStreamingQuality.High)
{
// Choose high quality Youtube video
return(videos.OrderByDescending(x => x.Resolution).FirstOrDefault());
}
// Pick the video with the requested quality settings
var preferredResolutions = StreamingQualityMap[quality];
var preferredVideos =
videos.Where(info => preferredResolutions.Contains(info.Resolution))
.OrderByDescending(info => info.Resolution);
var video = preferredVideos.FirstOrDefault();
if (video != null)
{
return(video);
}
videosToProcess = videos;
quality = (YoutubeStreamingQuality)(((int)quality) - 1);
}
}
internal override async Task PrepareAsync(YoutubeStreamingQuality qualityHint)
{
VideoInfo video = null;
try
{
video = await GetVideoInfoForStreaming(this.OriginalPath, qualityHint);
if (video != null && video.RequiresDecryption)
{
await Task.Run(() => DownloadUrlResolver.DecryptDownloadUrl(video));
}
}
catch (Exception ex) if (ex is WebException || ex is VideoNotAvailableException || ex is YoutubeParseException)
{
throw new SongPreparationException(ex);
}
if (video == null)
{
throw new SongPreparationException("No suitable video found");
}
this.playbackPath = video.DownloadUrl;
}
internal override async Task PrepareAsync(YoutubeStreamingQuality qualityHint)
{
VideoInfo video = null;
try
{
video = await GetVideoInfoForStreaming(this.OriginalPath, qualityHint);
if (video != null && video.RequiresDecryption)
{
await Task.Run(() => DownloadUrlResolver.DecryptDownloadUrl(video));
}
}
catch (Exception ex)
{
if (ex is WebException || ex is VideoNotAvailableException || ex is YoutubeParseException)
{
throw new SongPreparationException(ex);
}
}
if (video == null)
{
throw new SongPreparationException("No suitable video found");
}
this.PlaybackPath = video.DownloadUrl;
}
/// <summary>
/// Get VideoInfo of a youtube video
/// </summary>
/// <param name="youtubeLink">The youtube link of a movie</param>
/// <param name="qualitySetting">The youtube quality settings</param>
/// <returns>The trailer's video info</returns>
private async Task <VideoInfo> GetVideoInfoForStreamingAsync(string youtubeLink,
YoutubeStreamingQuality qualitySetting)
{
IEnumerable <VideoInfo> videoInfos = new List <VideoInfo>();
// Get video infos of the requested video
await Task.Run(() => videoInfos = DownloadUrlResolver.GetDownloadUrls(youtubeLink, false));
// We only want video matching criterias : only mp4 and no adaptive
var filtered = videoInfos
.Where(info => info.VideoType == VideoType.Mp4 && !info.Is3D && info.AdaptiveType == AdaptiveType.None);
return(GetVideoByStreamingQuality(filtered, qualitySetting));
}
internal override Task PrepareAsync(YoutubeStreamingQuality qualityHint)
{
return this.dataGate.ToTask();
}
private static async Task<VideoInfo> GetVideoInfoForStreaming(string youtubeLink, YoutubeStreamingQuality qualitySetting)
{
IEnumerable<VideoInfo> videoInfos = await Task.Run(() => DownloadUrlResolver.GetDownloadUrls(youtubeLink, false));
IEnumerable<VideoInfo> filtered = videoInfos
.Where(info => info.VideoType == VideoType.Mp4 && !info.Is3D && info.AdaptiveType == AdaptiveType.None);
return GetVideoByStreamingQuality(filtered, qualitySetting);
}
private static VideoInfo GetVideoByStreamingQuality(IEnumerable<VideoInfo> videos, YoutubeStreamingQuality quality)
{
videos = videos.ToList(); // Prevent multiple enumeration
if (quality == YoutubeStreamingQuality.High)
{
return videos.OrderByDescending(x => x.Resolution)
.FirstOrDefault();
}
IEnumerable<int> preferredResolutions = StreamingQualityMap[quality];
IEnumerable<VideoInfo> preferredVideos = videos
.Where(info => preferredResolutions.Contains(info.Resolution))
.OrderByDescending(info => info.Resolution);
VideoInfo video = preferredVideos.FirstOrDefault();
if (video == null)
{
return GetVideoByStreamingQuality(videos, (YoutubeStreamingQuality)(((int)quality) - 1));
}
return video;
}
/// <summary>
/// Prepares the song for playback.
/// </summary>
internal virtual Task PrepareAsync(YoutubeStreamingQuality qualityHint)
{
return(Task.Delay(0));
}
private static async Task <VideoInfo> GetVideoInfoForStreaming(string youtubeLink, YoutubeStreamingQuality qualitySetting)
{
IEnumerable <VideoInfo> videoInfos = await Task.Run(() => DownloadUrlResolver.GetDownloadUrls(youtubeLink, false));
IEnumerable <VideoInfo> filtered = videoInfos
.Where(info => info.VideoType == VideoType.Mp4 && !info.Is3D && info.AdaptiveType == AdaptiveType.None);
return(GetVideoByStreamingQuality(filtered, qualitySetting));
}
private static VideoInfo GetVideoByStreamingQuality(IEnumerable <VideoInfo> videos, YoutubeStreamingQuality quality)
{
videos = videos.ToList(); // Prevent multiple enumeration
if (quality == YoutubeStreamingQuality.High)
{
return(videos.OrderByDescending(x => x.Resolution)
.FirstOrDefault());
}
IEnumerable <int> preferredResolutions = StreamingQualityMap[quality];
IEnumerable <VideoInfo> preferredVideos = videos
.Where(info => preferredResolutions.Contains(info.Resolution))
.OrderByDescending(info => info.Resolution);
VideoInfo video = preferredVideos.FirstOrDefault();
if (video == null)
{
return(GetVideoByStreamingQuality(videos, (YoutubeStreamingQuality)(((int)quality) - 1)));
}
return(video);
}
internal override Task PrepareAsync(YoutubeStreamingQuality qualityHint)
{
return(this.dataGate.ToTask());
}
/// <summary> /// Prepares the song for playback. /// </summary> internal virtual Task PrepareAsync(YoutubeStreamingQuality qualityHint) => Task.Delay(0);
