Exemplo n.º 1
0
        public void CanHandleGetMediaInformationExceptionalCases()
        {
            MockForGetMediaInformationFaultyTest mock = new MockForGetMediaInformationFaultyTest();
            YoutubeDl dl = new YoutubeDl(mock);

            dl.GetMediaInformation(new Uri("http://something.com"));
        }
Exemplo n.º 2
0
        private void PerformTest(IAudioDownloadOutputSample sample)
        {
            const string DownloadDirectory = "fakepath";

            MockForAudioDownloadTest processMock = this.CreateProcessFactory(sample, DownloadDirectory);

            YoutubeDl downloader = new YoutubeDl(processMock);

            Dictionary <double, bool>        ExpectedPercentsToBeReported = new Dictionary <double, bool>(sample.ExpectedPercents.Distinct().Select(x => new KeyValuePair <double, bool>(x, false)));
            Dictionary <DownloadState, bool> ExpectedStatusesToBeReported = new Dictionary <DownloadState, bool>(sample.ExpectedDownloadStatuses.Distinct().Select(x => new KeyValuePair <DownloadState, bool>(x, false)));

            using (IDownload progress = downloader.PrepareDownload(new Uri(sample.MediaUri), MediaFormat.MP3Audio, DownloadDirectory)) {
                RunDownload(processMock, ExpectedPercentsToBeReported, ExpectedStatusesToBeReported, progress);
            }

            foreach (var item in ExpectedStatusesToBeReported)
            {
                Assert.IsTrue(item.Value, $"Expected download status {item.Key} was not reported by event {nameof(IDownload.DownloadStatusChanged)}.");
            }

            foreach (var item in ExpectedPercentsToBeReported)
            {
                Assert.IsTrue(item.Value, $"Expected download percentage {item.Key} was not reported by event {nameof(IDownload.PercentageChanged)}.");
            }
        }
Exemplo n.º 3
0
            /// <summary>
            /// Initializes a new instance of the <see cref="PlaylistReader"/> class.
            /// </summary>
            /// <param name="url">The url<see cref="string"/></param>
            /// <param name="videos">The videos<see cref="int[]"/></param>
            /// <param name="reverse">The reverse<see cref="bool"/></param>
            public PlaylistReader(string url, int[] videos, bool reverse)
            {
                var json_dir = AppEnvironment.GetJsonDirectory();

                _playlist_id = YoutubeHelper.GetPlaylistId(url);
                var range = string.Empty;

                if (videos != null && videos.Length > 0)
                {
                    // Make sure the video indexes is sorted, otherwise reversing wont do anything
                    Array.Sort(videos);
                    range = string.Format(CmdPlaylistRange, string.Join(",", videos));
                }

                var reverseS = reverse ? CmdPlaylistReverse : string.Empty;

                _arguments = string.Format(CmdPlaylistInfo, json_dir, _playlist_id, range, reverseS, url);
                _url       = url;

                YoutubeDl.LogHeader(_arguments);

                _youtubeDl = ProcessHelper.StartProcess(YoutubeDl.YouTubeDlPath,
                                                        _arguments,
                                                        OutputReadLine,
                                                        ErrorReadLine,
                                                        null);
                _youtubeDl.Exited += delegate
                {
                    _processFinished = true;
                    YoutubeDl.LogFooter();
                };
            }
Exemplo n.º 4
0
        public async Task <Song> Download(string url)
        {
            using (var ytDownloader = new YoutubeDl())
            {
                var data = (await ytDownloader.GetDataAsync(url)).Split('\n');
                if (data.Length < 6)
                {
                    return(null);
                }

                if (!TimeSpan.TryParseExact(data[4], new[] { "ss", "m\\:ss", "mm\\:ss", "h\\:mm\\:ss", "hh\\:mm\\:ss", "hhh\\:mm\\:ss" }, CultureInfo.InvariantCulture, out var time))
                {
                    time = TimeSpan.FromHours(24);
                }

                if (time.TotalMinutes > 10)
                {
                    return(null);
                }

                return(new Song
                {
                    Title = data[0],
                    Duration = time,
                    Url = data[2],
                });
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Gets an instance asynchronously of the <see cref="YoutubeSongInfo"/> class.
        /// </summary>
        /// <param name="Source">The URL of the video</param>
        /// <returns>A <see cref="YoutubeSongInfo"/> instance.</returns>
        public static async Task <YoutubeSongInfo> GetVideoInfoAsync(string Source)
        {
            YoutubeDl d = new YoutubeDl("youtube-dl.exe", App.Path)
            {
                VideoID = YoutubeUri.GetVideoID(Source)
            };

            YoutubeMediaInfo r = await d.GetVideoInfo();

            var Result = new YoutubeSongInfo(
                Source: Source,
                Title: r.RecognizedMedia?.Title ?? r.Title,
                Artist: r.RecognizedMedia?.Artist,
                DurationInSeconds: r.Duration.TotalSeconds
                )
            {
                Formats = r.MediaFormats
            };

            if (App.Config.YoutubeDownloadThumbnail)
            {
                Result.AlbumImage = await r.Thumbnails.FirstOrDefault()?.DownloadAsImageAsync();
            }

            return(Result);
        }
Exemplo n.º 6
0
        public void CanGetYoutubeMediaInformation()
        {
            string ExpectedVideoTitle       = "sample-title";
            string ExpectedVideoID          = "hW9tIK5pcl8";
            string ExpectedUploaderID       = "sample-uploader";
            string ExpectedDescription      = "sample-description";
            int    ExpectedLikes            = 51;
            int    ExpectedDislikes         = 12;
            int    ExpectedViews            = 314;
            double ExpectedDuration         = 312.54;
            string ExpectedVideoUri         = $"https://www.youtube.com/watch?v={ExpectedVideoID}";
            string ExpectedIdentifiedArtist = "sample-artist";
            string ExpectedIdentifiedSong   = "sample-song";
            string ExpectedUploadDate       = "20181216";

            MockForGetMediaInformationWithYoutubeTest processMock = new MockForGetMediaInformationWithYoutubeTest(
                ExpectedVideoTitle,
                ExpectedVideoID,
                ExpectedUploaderID,
                ExpectedDescription,
                ExpectedLikes,
                ExpectedDislikes,
                ExpectedViews,
                ExpectedDuration,
                ExpectedVideoUri,
                ExpectedIdentifiedArtist,
                ExpectedIdentifiedSong,
                ExpectedUploadDate
                );

            YoutubeDl         downloader = new YoutubeDl(processMock);
            IMediaInformation actual     = downloader.GetMediaInformation(new Uri(ExpectedVideoUri));

            Assert.IsTrue(processMock.ProcessStarted, "Youtube-dl was not started.");
            Assert.IsTrue(processMock.ParametersPassedCorrectly, "Command-line arguments were passed incorrectly to youtube-dl.");

            Assert.IsNotNull(actual);
            Assert.IsInstanceOfType(actual, typeof(ILikeableMedia));
            Assert.IsInstanceOfType(actual, typeof(IIdentifiedSong));

            Assert.AreEqual(ExpectedVideoUri, actual.MediaUri);
            Assert.AreEqual(ExpectedDuration, actual.Duration);
            Assert.AreEqual(ExpectedVideoTitle, actual.Title);
            Assert.AreEqual(ExpectedDescription, actual.Description);
            Assert.AreEqual(ExpectedVideoID, actual.VideoId);

            ILikeableMedia actual2 = (ILikeableMedia)actual;

            Assert.AreEqual(ExpectedLikes, actual2.Likes);
            Assert.AreEqual(ExpectedDislikes, actual2.Dislikes);

            IIdentifiedSong actual3 = (IIdentifiedSong)actual;

            Assert.AreEqual(ExpectedIdentifiedArtist, actual3.Artist);
            Assert.AreEqual(ExpectedIdentifiedSong, actual3.TrackTitle);
        }
Exemplo n.º 7
0
        public void CanGetVersion()
        {
            string expectedVersion = "2018.12.11.";

            MockForGetVersionTest processMock = new MockForGetVersionTest(expectedVersion);

            YoutubeDl downloader = new YoutubeDl(processMock);
            string    actual     = downloader.GetVersion();

            Assert.IsTrue(processMock.ParametersPassedCorrectly);
            Assert.IsTrue(processMock.ExitedSuccessfully);
            Assert.AreEqual(expectedVersion, actual);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Downloads a video asynchronously with youtube-dl.
        /// </summary>
        /// <param name="SongInfo">A <see cref="ISongInfo"/> instance that holds the URI of the media to download</param>
        /// <returns>
        ///		A <see cref="Task"/> for an <see cref="IPlaybackManager"/> instance
        ///		that can play the YouTube media. Null is returned when the download
        ///		fails.
        /// </returns>
        /// <exception cref="ArgumentNullException">when <paramref name="SongInfo"/> is null</exception>
        /// <exception cref="ArgumentException">when <see cref="ISongInfo.Source"/> is not a valid YouTube URI</exception>
        public static async Task <IPlaybackManager> DownloadVideoAsync(ISongInfo SongInfo, IProgress <LongOperationProgress> Progress)
        {
            #region Error checking
            if (SongInfo == null)
            {
                throw new ArgumentNullException(nameof(SongInfo));
            }

            if (!YoutubeUri.IsValidYoutubeUri(SongInfo.Source))
            {
                throw new ArgumentException("Not a valid YouTube URI");
            }
            #endregion

            string MediaFilename = Path.ChangeExtension(Path.GetTempFileName(), "mp3");

            #region Cleanup
            if (File.Exists(MediaFilename))
            {
                File.Delete(MediaFilename);
            }
            #endregion

            MediaFormat Format = (SongInfo as YoutubeSongInfo)?.GetBestAudioFormat();

            try {
                YoutubeDl Downloader = new YoutubeDl("youtube-dl.exe", App.Path)
                {
                    AudioFileFormat = YoutubeDlAudioFormat.mp3,
                    Filename        = MediaFilename,
                    VideoID         = YoutubeUri.GetVideoID(SongInfo.Source)
                };

                Progress <YoutubeDownloadProgress> YTProgress = new Progress <YoutubeDownloadProgress>();
                YTProgress.ProgressChanged += (po, pe) => Progress?.Report(pe.ToLongOperationProgress());

                //When download fails and youtube-dl reports that an update is required, update it and retry.
                Downloader.UpdateRequired += async(o, e) => {
                    Progress.Report(
                        new YoutubeDownloadProgress(YoutubeDownloadStatus.Updating, 0).ToLongOperationProgress()
                        );
                    await Downloader.UpdateAsync();



                    await Downloader.DownloadAudioAsync(YTProgress);
                };

                await Downloader.DownloadAudioAsync(YTProgress, Format);
            }
            catch (Exception e) {
                Trace.WriteLine(e.Message);
                return(null);
            }

            if (File.Exists(MediaFilename))
            {
                using (Stream s = File.OpenRead(MediaFilename)) {
                    Progress <LongOperationProgress> OpenMediaProgress = new Progress <LongOperationProgress>();
                    OpenMediaProgress.ProgressChanged += (o, e) => Progress?.Report(e);

                    return(new YoutubePlayback(
                               SongInfo,
                               await UnmanagedStream.CreateFromStream(s, OpenMediaProgress),
                               MediaFilename
                               ));
                }
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 9
0
 private void HandleValidSubmit()
 {
     YoutubeDl.runYoutubeDl(basic);
     done = "Done!";
 }