private async void btn_analyze_Click(object sender, EventArgs e) { Settings.Default.LastFolder = tb_dir.Text; Settings.Default.Save(); btn_extract.Enabled = false; await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full); var extenssions = new List <string> { ".mov", "mp4" }; var files = Directory.EnumerateFiles(tb_dir.Text) .Where(v => extenssions.Any(x => v.ToLower().EndsWith(x))); foreach (var file in files) { var audioStream = (await FFmpeg.GetMediaInfo(file)) .AudioStreams.FirstOrDefault(); var codec = "Unknown"; if (audioStream != null) { codec = audioStream.Codec; } var lvi = new ListViewItem(new string[] { file, codec }); lv.Items.Add(lvi); } btn_extract.Enabled = true; }
private async Task Convert() { DialogResult result = dialogSaveOutput.ShowDialog(); string outputPath = ""; if (result == DialogResult.OK) { outputPath = dialogSaveOutput.FileName; } else { return; } txtOutput.Text = ""; prgProgressBar.Value = 0; string audio = dialogOpenAudioFile.FileName; string image = dialogOpenCoverArt.FileName; await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); // FFMpeg arguments based on this answer // https://superuser.com/a/1041818 IConversion conversion = FFmpeg.Conversions.New(); conversion .SetOutput(outputPath) .SetOverwriteOutput(true) .AddParameter("-loop 1") .AddParameter("-y") .AddParameter($"-i {image}") .AddParameter($"-i {audio}") .AddParameter("-shortest") .AddParameter("-framerate 2") .AddParameter("-acodec copy") .AddParameter("-vcodec mjpeg") .AddParameter("-preset ultrafast"); string ffmpegParams = conversion.Build(); txtOutput.AppendText($"ffmpeg {ffmpegParams}{Environment.NewLine}"); conversion.OnDataReceived += Conversion_OnDataReceived; conversion.OnProgress += Conversion_OnProgress; try { _state = State.Converting; btnCreate.Text = Language.Stop; IConversionResult conversionResult = await conversion.Start(_cts.Token); } catch (OperationCanceledException) { } catch (Exception ex) { _state = State.Ready; btnCreate.Text = Language.Convert; txtOutput.AppendText(Environment.NewLine + Environment.NewLine + ex.Message); } }
private async void Window_Loaded(object sender, RoutedEventArgs e) { Main.Content = pageVodDownload; if (!File.Exists("ffmpeg.exe")) { await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full); } }
// Points the FFmpeg library to the right executables public static void SetFFMpegPath() { FFmpeg.SetExecutablesPath(FFMPEG_PATH); #if DEBUG // Automatically downloads FFmpeg useful for development FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official, FFmpeg.ExecutablesPath); #endif }
static void Main(string[] args) { if (args.Any(x => x.Equals("--download-ffmpeg"))) { Console.WriteLine("[INFO] - Downloading ffmpeg and exiting"); if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official).Wait(); try { var filePermissions = new Mono.Unix.UnixFileInfo("ffmpeg"); filePermissions.FileAccessPermissions = FileAccessPermissions.UserRead | FileAccessPermissions.UserWrite | FileAccessPermissions.GroupRead | FileAccessPermissions.OtherRead | FileAccessPermissions.UserExecute | FileAccessPermissions.GroupExecute | FileAccessPermissions.OtherExecute; filePermissions.Refresh(); } catch { } } else { FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full).Wait(); } Environment.Exit(1); } Options inputOptions = new Options(); var optionsResult = Parser.Default.ParseArguments <Options>(args).WithParsed(r => { inputOptions = r; }); if (optionsResult.Tag == ParserResultType.NotParsed) { Environment.Exit(1); } if (!File.Exists(ffmpegPath) && (inputOptions.FfmpegPath == null || !File.Exists(inputOptions.FfmpegPath)) && !ExistsOnPath(ffmpegPath)) { Console.WriteLine("[ERROR] - Unable to find ffmpeg, exiting. You can download ffmpeg automatically with the argument --download-ffmpeg"); Environment.Exit(1); } switch (inputOptions.RunMode) { case RunMode.VideoDownload: DownloadVideo(inputOptions); break; case RunMode.ClipDownload: DownloadClip(inputOptions); break; case RunMode.ChatDownload: DownloadChat(inputOptions); break; case RunMode.ChatRender: RenderChat(inputOptions); break; } }
static void Main() { FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official).Wait(); //TODO: wrap this into a splash or so Application.SetHighDpiMode(HighDpiMode.SystemAware); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new FrmStart()); }
private async void Window_Loaded(object sender, RoutedEventArgs e) { Main.Content = pageChatRender; Settings.Default.Upgrade(); Settings.Default.Save(); if (!File.Exists("ffmpeg.exe")) { await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full); } }
public static void GetPrerequisite() { // Downloads FFMPEG if it's not already there. if (!File.Exists(ffmpegLocation)) { FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official, $@"{Directory.GetCurrentDirectory()}\ressources\"); } // Creates temp folder just in case. Directory.CreateDirectory(Path.GetDirectoryName(concatFileLocation)); }
public MusicManager() { _ytClient = new YoutubeClient(); FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official).Wait(); if (Directory.Exists(_tmpDir)) { Directory.Delete(_tmpDir, true); } }
private async void Window_Loaded(object sender, RoutedEventArgs e) { Main.Content = pageVodDownload; Settings.Default.Upgrade(); Settings.Default.Save(); if (!File.Exists("ffmpeg.exe")) { await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full); } AutoUpdater.Start("https://downloader-update.twitcharchives.workers.dev"); }
private async void CheckFFmpeg() { if (!File.Exists("ffmpeg.exe") || !File.Exists("ffprobe.exe")) { buttonOpenFile.Enabled = false; LogToConsole("FFmpeg doesn't exist."); LogToConsole("Downloading FFmpeg..."); await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); LogToConsole("FFmpeg downloaded."); buttonOpenFile.Enabled = true; } }
private static async Task <int> Main(string[] args) { Flags = CommandLineFlags.ParseFlags <SubSplitFlags>(args); if (Flags == null) { return(1); } if (!File.Exists(Flags.InputFile)) { Logger.Error("Program", "Input file does not exist"); return(4); } Logger.Info("Program", "Downloading ffmpeg"); await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); var probe = await FFmpeg.GetMediaInfo(Flags.InputFile); if (probe == null) { Logger.Error("FFmpeg", "Can't probe media file"); return(2); } if (!File.Exists(Flags.PrimarySubtitleFile)) { Logger.Error("Program", "Subtitle file missing"); return(5); } var subtitles = SubtitleFile.GetSubtitles(await File.ReadAllLinesAsync(Flags.PrimarySubtitleFile), out var subtitleLeadIn); if (!File.Exists(Flags.OverrideSubtitleFile)) { if (!string.IsNullOrEmpty(Flags.OverrideSubtitleFile)) { Logger.Warn("Program", "Override Subtitle File does not exist"); } } else { subtitles = SubtitleFile.GetSubtitles(await File.ReadAllLinesAsync(Flags.OverrideSubtitleFile), out subtitleLeadIn).Select((t, index) => subtitles.ElementAt(index) with { Text = t.Text, OriginalText = t.OriginalText }).ToList();
internal static async Task Run() { Console.Out.WriteLine("[Start] Basic Conversion"); FileInfo fileToConvert = GetFilesToConvert(".").First(); //Set directory where app should look for FFmpeg executables. FFmpeg.SetExecutablesPath(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "FFmpeg")); //Get latest version of FFmpeg. It's great idea if you don't know if you had installed FFmpe1g. await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); //Run conversion await RunConversion(fileToConvert); Console.Out.WriteLine("[End] Basic Conversion"); }
public async Task Intitialize() { var location = GetDirectory(); Log.Information("Initialize FFmpeg with location: {Location}", location); if (_options.AutoDownload) { Log.Information("FFmpeg GetLatestVersion"); await FFmpegDownloader.GetLatestVersion( FFmpegVersion.Official, location); } FFmpeg.SetExecutablesPath(location); }
public override async Task Initialize() { //download ffmpeg here string tempFFmpegFolder = Path.Combine(Path.GetTempPath(), "ffmpeg"); if (!Directory.Exists(tempFFmpegFolder)) { Directory.CreateDirectory(tempFFmpegFolder); Console.WriteLine($"Created directory {tempFFmpegFolder}"); } FFmpeg.SetExecutablesPath(tempFFmpegFolder); await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official, FFmpeg.ExecutablesPath, this); }
internal static async Task Run() { Console.Out.WriteLine("[Start] Basic Conversion"); FileInfo fileToConvert = GetFilesToConvert(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)).First(); //Set directory where app should look for FFmpeg executables. FFmpeg.SetExecutablesPath(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)); //Get latest version of FFmpeg. It's great idea if you don't know if you had installed FFmpeg. await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); //Run conversion await RunConversion(fileToConvert); Console.Out.WriteLine("[End] Basic Conversion"); }
public VideoHelper() { InitializeComponent(); info = new Info(pictureBox1.Width, pictureBox1.Height); this.labelBgmVolume.DataBindings.Add("Text", trackBarBgm, "Value"); this.labelPersonVolume.DataBindings.Add("Text", trackBarPerson, "Value"); this.labelEndTime.DataBindings.Add("Text", trackBarEndTime, "Value"); this.labelBeginTime.DataBindings.Add("Text", trackBarBeginTime, "Value"); this.trackBarEndTime.DataBindings.Add("Minimum", trackBarBeginTime, "Value"); this.trackBarEndTime.DataBindings.Add("Maximum", trackBarBeginTime, "Maximum"); this.textBoxThickness.DataBindings.Add("Text", info, "thickness"); this.textBoxScale.DataBindings.Add("Text", info, "scale"); this.trackBarBeginTime.DataBindings.Add("Value", info, "BeginTime"); this.trackBarEndTime.DataBindings.Add("Value", info, "EndTime"); this.textBoxSubtitlePositionX.DataBindings.Add("Text", info, "X"); this.textBoxSubtitlePositionY.DataBindings.Add("Text", info, "Y"); this.pictureBox1.BackColor = Color.Black; this.labelSub.MouseDown += new MouseEventHandler(labelSub_MouseDown); this.labelSub.MouseMove += new MouseEventHandler(labelSub_MouseMove); this.labelSub.MouseUp += new MouseEventHandler(labelSub_MouseUp); //this.labelSub.Parent = pictureBox1; pictureBox1.Image = info.bmp; pictureBox1.Controls.Add(labelSub); this.labelSub.BackColor = Color.White; modeVideoToolStripMenuItem.Checked = true; importAudioFileToolStripMenuItem.Enabled = false; this.labelSub.Location = new Point(0, 0); if (File.Exists(info.mixed)) { System.IO.File.Delete(info.mixed); } if (File.Exists(info.bgmTemp)) { System.IO.File.Delete(info.bgmTemp); } if (File.Exists(info.speechTemp)) { System.IO.File.Delete(info.speechTemp); } if (!File.Exists("ffmpeg.exe")) { FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full); } }
public async Task GenerateVideosAsync(CancellationToken cancellationToken) { await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); List <Store.Media> videos = await _storeContext.Medias.AsQueryable() .Where(x => x.MediaType == Store.MediaType.Video) .ToListAsync(cancellationToken); var todo = videos.Count; var videoPreview = @"H:\Drive\Moments\System\VideoPreview"; foreach (Store.Media video in videos) { todo--; var filename = _mediaBlobStore.GetFilename(new MediaBlobData { Directory = video.Folder, Filename = video.Filename, Type = MediaBlobType.Media }); try { var outfile = Path.Combine(videoPreview, $"720P_{video.Id}.mp4"); if (!File.Exists(outfile)) { var inputLength = new FileInfo(filename).Length / 1024 / 1024; await _videoProcessing.ConvertTo720Async(filename, outfile, cancellationToken); Console.WriteLine($"{todo} - Video created: {Path.GetFileName(outfile)}"); var outLength = new FileInfo(outfile).Length / 1024 / 1024; Console.WriteLine($"{inputLength} --> {outLength} (-{100.0 / inputLength * outLength}%)"); } } catch (Exception ex) { Console.WriteLine($"Error in Media: {video.Id}. --> {ex.Message}"); } } }
public static async Task Run() { Console.Out.WriteLine("[Start] Modify streams"); Queue <FileInfo> filesToConvert = new Queue <FileInfo>(GetFilesToConvert(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location))); await Console.Out.WriteLineAsync($"Find {filesToConvert.Count()} files to convert."); //Set directory where app should look for FFmpeg executables. FFmpeg.SetExecutablesPath(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "FFmpeg")); //Get latest version of FFmpeg. It's great idea if you don't know if you had installed FFmpe1g. await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); //Run conversion await RunConversion(filesToConvert); Console.Out.WriteLine("[End] Modify streams"); }
static void Main() { Display.title = "Ascier"; Display.dynamicRefresh = true; Display.start(); string[] directories = { "input", "output", "ffmpeg" }; for (int i = 0; i < directories.Length; i++) { if (!Directory.Exists($"{Directory.GetCurrentDirectory()}/{directories[i]}")) { Program.Logger.info($"The following directory has not been found."); Program.Logger.info($"{Directory.GetCurrentDirectory()}/{directories[i]}"); Directory.CreateDirectory(directories[i]); Program.Logger.info($"{directories[i]} directory has been created."); } else { Program.Logger.info($"{directories[i]} directory has been found."); } } Display.forceRedraw(); var status = FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official, $"{Directory.GetCurrentDirectory()}/ffmpeg"); if (!status.IsCompleted) { Program.Logger.info("Downloading FFMPEG library for video conversion."); while (!status.IsCompleted) { ; } Program.Logger.info("Done."); } else { Program.Logger.info("ffmpeg has been found."); } }
internal async Task FullProcessPassed() { var operatingSystemProvider = Substitute.For <IOperatingSystemProvider>(); operatingSystemProvider.GetOperatingSystem().Returns(x => OperatingSystem.Linux64); FFmpegDownloader._linkProvider = new LinkProvider(operatingSystemProvider); var ffmpegExecutablesPath = FFmpeg.ExecutablesPath; try { FFmpeg.ExecutablesPath = Path.Combine(Path.GetTempPath(), System.Guid.NewGuid().ToString("N")); await FFmpegDownloader.GetLatestVersion(); Assert.True(File.Exists(Path.Combine(FFmpeg.ExecutablesPath, "ffmpeg"))); Assert.True(File.Exists(Path.Combine(FFmpeg.ExecutablesPath, "ffprobe"))); } finally { FFmpeg.ExecutablesPath = ffmpegExecutablesPath; } }
private static async Task ExtractAudio(string path, MediaType.MediaCodec codec) { var currentFolder = Directory.GetCurrentDirectory(); var ffmpegPath = $"{currentFolder}/FFmpeg"; FFmpeg.SetExecutablesPath(ffmpegPath, "FFmpeg"); await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official, ffmpegPath); FileInfo fi = new FileInfo(path); string inputPath = fi.FullName; string outputPath = Path.ChangeExtension(inputPath, codec.ToString()); if (File.Exists(outputPath)) { File.Delete(outputPath); } var conversion = await FFmpeg.Conversions.FromSnippet.ExtractAudio(inputPath, outputPath); await conversion.Start(); await Task.Delay(500); }
private static async Task GenerateThumbnailDuration(long vodId) { Logger _logger = new NLog.LogFactory().GetCurrentClassLogger(); try { await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); } catch (NotImplementedException) { _logger.Warn("OS not supported. Skipping thumbnail generation."); return; } Stream stream; using (var context = new MainDataContext()) { stream = context.Streams.FirstOrDefault(item => item.streamId == vodId); if (stream != null) { stream.duration = FFmpeg.GetMediaInfo(GlobalConfig.GetGlobalConfig("contentRootPath") + stream.location + stream.fileName).Result .Duration .Seconds; } context.SaveChanges(); } if (stream != null) { Task <IMediaInfo> streamFile = FFmpeg.GetMediaInfo(Path.Combine(GlobalConfig.GetGlobalConfig("contentRootPath"), stream.location, stream.fileName)); var conversion = await FFmpeg.Conversions.New() .AddStream(streamFile.Result.Streams.FirstOrDefault()) .AddParameter("-vframes 1 -s 320x180") .SetOutput(Path.Combine(GlobalConfig.GetGlobalConfig("contentRootPath"), stream.location, "thumbnail.jpg")) .Start(); } }
public async Task <string> ConvertMp4ToMp3AndGetMp3Path(string mp4Path) { if (!File.Exists(mp4Path)) { throw new FileNotFoundException($"MP4 was not found at the specified path {mp4Path}. Audio conversion failed."); } var executablePath = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName); await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official, executablePath); FFmpeg.SetExecutablesPath(executablePath); var mp3Path = mp4Path.Replace(".mp4", ".mp3"); await(await FFmpeg.Conversions.FromSnippet.Convert(mp4Path, mp3Path)) .SetOutputFormat(Format.mp3) .SetOverwriteOutput(true) .AddParameter("-qscale:a 0") .Start(); File.Delete(mp4Path); return(mp3Path); }
private async static Task DownloadFFmpegExecutables(string destinationPath) { await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full, destinationPath); }
async void backgroundWorker2_DoWork(object sender, DoWorkEventArgs e) { totalbytes = 0; collectedbytes = 0; string audiomp4 = "Audio.mp4"; string Audiomp3 = "Audio.mp3"; string VideoFile = "Video.mp4"; Status.Text = "Checking tools"; async Task SourceDownloader(string name, YouTubeVideo vid) { var client = new HttpClient(); long?totalByte = 0; using (Stream output = File.OpenWrite(name)) { using (var request = new HttpRequestMessage(HttpMethod.Head, vid.Uri)) { totalByte = client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead).Result.Content.Headers.ContentLength; } totalbytes += (long)totalByte; using (var input = await client.GetStreamAsync(vid.Uri)) { byte[] buffer = new byte[16 * 1024]; int read; int totalRead = 0; while ((read = input.Read(buffer, 0, buffer.Length)) > 0) { output.Write(buffer, 0, read); totalRead += read; collectedbytes += read; long x = collectedbytes * 100 / totalbytes; Dataprogress.Text = bytetobigger(collectedbytes) + "/" + bytetobigger(totalbytes); progressBar1.Invoke((MethodInvoker)(() => progressBar1.Value = (int)x)); } } } client.Dispose(); } await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full); async Task DownloadWork(string link, int playlist = -1) { if (playlist < 0) { Status.Text = "Downloading .."; } else { Status.Text = (playlist + 1).ToString() + "/" + listVidsIds.Count.ToString(); } var video = youTube.GetAllVideos(link); var Targetaudio = video.Where(j => j.AdaptiveKind == AdaptiveKind.Audio && j.AudioBitrate.ToString() == selectedAudioQuality).Select(j => j); var TargetVideo = video.Where(j => j.AdaptiveKind == AdaptiveKind.Video && j.Format == VideoFormat.Mp4 && j.Resolution.ToString() == selectedVideoQality).Select(j => j); VidTitle.Invoke((MethodInvoker)(() => VidTitle.Text = video.ToList()[0].Title)); Task au = SourceDownloader(audiomp4, Targetaudio.ToList()[0]); if (SoundOnly.Checked != true) { Task vide = SourceDownloader(VideoFile, TargetVideo.ToList()[0]); await au; FFMpeg.ExtractAudio(audiomp4, Audiomp3); fileDelete(audiomp4); await vide; FFMpeg.ReplaceAudio(VideoFile, Audiomp3, FilePath.Text + TargetVideo.ToList()[0].FullName); fileDelete(VideoFile); fileDelete(Audiomp3); } else { await au; FFMpeg.ExtractAudio(audiomp4, FilePath.Text + TargetVideo.ToList()[0].Title + ".mp3"); fileDelete(audiomp4); } if (playlist < 0) { Status.Text = "Done. "; } else { Status.Text = "Done (" + (playlist + 1).ToString() + "/" + listVidsIds.Count.ToString() + ")"; } Dataprogress.Text = ""; } if (listVidsIds.Count > 0) { for (int i = 0; i < listVidsIds.Count; i++) { await DownloadWork(watchLink + listVidsIds.ElementAt(i), i); } } else { await DownloadWork(videoLink.Text); } }
static async void RunConversion(string inPath, string outPath) { //Set directory where app should look for FFmpeg //FFmpeg.SetExecutablesPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "FFmpeg"); FFmpeg.SetExecutablesPath(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "FFmpeg")); //Get latest version of FFmpeg. It's great idea if you don't know if you had installed FFmpeg. FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official); Queue filesToConvert = new Queue(); DirectoryInfo di = new DirectoryInfo(inPath); foreach (FileInfo file in di.GetFiles()) { if (file.Extension == ".mp3") { filesToConvert.Enqueue(file); } } await Console.Out.WriteLineAsync($"Find {filesToConvert.Count} files to convert."); //string filePath = Path.Combine("C:", "samples", "SampleVideo.mp4"); //string inputMp3Path = Path.Combine("E:", "bai1.mp3"); //IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(inputMp3Path); //while (filesToConvert.(out FileInfo fileToConvert)) foreach (FileInfo fileToConvert in filesToConvert) { Console.WriteLine("1"); //Save file to the same location with changed extension //string outputFileName = Path.ChangeExtension(fileToConvert.FullName, ".mp4"); IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(fileToConvert.DirectoryName); //var mediaInfo = await MediaInfo.Get(fileToConvert); //var videoStream = mediaInfo.VideoStreams.First(); var audioStream = mediaInfo.AudioStreams.First(); audioStream.SetBitrate(8000) .SetChannels(1) .SetSampleRate(24000) .SetCodec(AudioCodec.mp3); ////Change some parameters of video stream ////videoStream //// Rotate video counter clockwise //// .Rotate(RotateDegrees.CounterClockwise) //// Set size to 480p //// .SetSize(VideoSize.Hd480) //// Set codec which will be used to encode file.If not set it's set automatically according to output file extension //// .SetCodec(VideoCodec.H264); //Create new conversion object var conversion = FFmpeg.Conversions.New() //Add audio stream to output file .AddStream(audioStream) //Set output file path .SetOutput(outPath) //SetOverwriteOutput to overwrite files. It's useful when we already run application before .SetOverwriteOutput(true) //Disable multithreading .UseMultiThread(false) //Set conversion preset. You have to chose between file size and quality of video and duration of conversion .SetPreset(ConversionPreset.UltraFast); //Add log to OnProgress //conversion.OnProgress += async (sender, args) => //{ // //Show all output from FFmpeg to console // await Console.Out.WriteLineAsync($"[{args.Duration}/{args.TotalLength}][{args.Percent}%] {fileToConvert.Name}"); //}; //Start conversion conversion.Start(); Console.WriteLine($"Finished converion file [{fileToConvert.Name}]"); } }
public PresentationService(IVideoService videoService) { _videoService = videoService; FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full).GetAwaiter().GetResult(); }
internal async Task FullProcessPassed() { const OperatingSystem os = OperatingSystem.Linux64; var operatingSystemProvider = Substitute.For <IOperatingSystemProvider>(); operatingSystemProvider.GetOperatingSystem().Returns(x => os); FFmpegDownloader._linkProvider = new LinkProvider(operatingSystemProvider); var ffmpegExecutablesPath = FFmpeg.ExecutablesPath; try { FFmpeg.ExecutablesPath = Path.Combine(Path.GetTempPath(), System.Guid.NewGuid().ToString("N")); string ffmpegPath = FFmpegDownloader.ComputeFileDestinationPath("ffmpeg", os); string ffprobePath = FFmpegDownloader.ComputeFileDestinationPath("ffprobe", os); // 1- First download await FFmpegDownloader.GetLatestVersion().ConfigureAwait(false); Assert.True(File.Exists(ffmpegPath)); Assert.True(File.Exists(ffprobePath)); // 2- Check updates (same version) await FFmpegDownloader.GetLatestVersion().ConfigureAwait(false); Assert.True(File.Exists(ffmpegPath)); Assert.True(File.Exists(ffprobePath)); // 3- Check updates (outdated version) var fFbinariesVersionInfo = new FFbinariesVersionInfo { Version = new Version().ToString() // "0.0" }; FFmpegDownloader.SaveVersion(fFbinariesVersionInfo); await FFmpegDownloader.GetLatestVersion().ConfigureAwait(false); Assert.True(File.Exists(ffmpegPath)); Assert.True(File.Exists(ffprobePath)); // 4- Missing ffmpeg File.Delete(ffmpegPath); await FFmpegDownloader.GetLatestVersion().ConfigureAwait(false); Assert.True(File.Exists(ffmpegPath)); Assert.True(File.Exists(ffprobePath)); // 5- Missing ffprobe File.Delete(ffprobePath); await FFmpegDownloader.GetLatestVersion().ConfigureAwait(false); Assert.True(File.Exists(ffmpegPath)); Assert.True(File.Exists(ffprobePath)); } finally { FFmpeg.ExecutablesPath = ffmpegExecutablesPath; } }
private async void bGo_Click(object sender, RoutedEventArgs e) { textStatus.Text = "Preparing"; gridMain.Dispatcher.Invoke(new Action(() => { }), DispatcherPriority.Render); var downloader = new YoutubeDL(); string fileName = ""; downloader.VideoUrl = tbLink.Text; downloader.Options.FilesystemOptions.NoMtime = true; //downloader.Options.VideoFormatOptions.Format = NYoutubeDL.Helpers.Enums.VideoFormat.best; downloader.Options.VerbositySimulationOptions.CallHome = false; downloader.Options.GeneralOptions.Update = true; //downloader.Options.VideoFormatOptions.FormatAdvanced = string videoTitleNoFilter = downloader.GetDownloadInfo().Title; string videoTitle = Regex.Replace(videoTitleNoFilter, @"[^a-z,0-9, ,-]", "", RegexOptions.IgnoreCase); Random random = new Random(); int randomInt = random.Next(1, 1000); downloader.Options.FilesystemOptions.Output = filePath + $"\\video{randomInt}"; if (cboxCut.IsChecked == false && cboxConvert.IsChecked == false) { downloader.Options.FilesystemOptions.Output = filePath + $"\\{videoTitle}"; } downloader.YoutubeDlPath = runningPath + "\\youtube-dl.exe"; if (rbBest.IsChecked == true) { downloader.Options.VideoFormatOptions.FormatAdvanced = "best"; } else { downloader.Options.VideoFormatOptions.FormatAdvanced = "worst"; } if (cboxResolution.Text != "Auto") { downloader.Options.VideoFormatOptions.FormatAdvanced += $"[height <=? {Int32.Parse(cboxResolution.Text.TrimEnd('p'))}]"; } textStatus.Text = "Downloading"; downloader.DownloadAsync(); while (downloader.IsDownloading) { pbProgress.Value = downloader.Info.VideoProgress; textETA.Text = "ETA: " + downloader.Info.Eta; textSpeed.Text = "Speed: " + downloader.Info.DownloadRate; gridMain.Dispatcher.Invoke(new Action(() => { }), DispatcherPriority.Render); } pbProgress.Value = 0; textETA.Text = "ETA: ?"; textSpeed.Text = "Speed: ?"; gridMain.Dispatcher.Invoke(new Action(() => { }), DispatcherPriority.Render); foreach (string file in Directory.GetFiles(filePath)) { if (Path.GetFileName(file).StartsWith($"video{randomInt}")) { fileName = file; } } if (cboxCut.IsChecked == true || cboxConvert.IsChecked == true) { pbProgress.IsIndeterminate = true; textStatus.Text = "Getting FFmpeg"; gridMain.Dispatcher.Invoke(new Action(() => { }), DispatcherPriority.Render); if (!File.Exists(runningPath + "\\ffmpeg.exe")) { await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Full, runningPath); } textStatus.Text = "Processing"; gridMain.Dispatcher.Invoke(new Action(() => { }), DispatcherPriority.Render); var conversions = FFmpeg.Conversions.New(); if (cboxCut.IsChecked == true) { conversions.AddParameter($"-ss {TimeSpan.FromSeconds(Int32.Parse(tbFrom.Text))}"); } conversions.AddParameter($"-i \"{fileName}\""); if (cboxConvert.IsChecked == true) { conversions.SetOutput($"{filePath}\\{videoTitle}{cbConvertType.Text}"); } else { conversions.SetOutput($"{filePath}\\{videoTitle}{Path.GetExtension(fileName)}"); } if (cboxCut.IsChecked == true) { conversions.AddParameter($"-to {TimeSpan.FromSeconds(Int32.Parse(tbTo.Text) - Int32.Parse(tbFrom.Text))}"); } /* * if (cboxConvert.IsChecked == true && cboxCut.IsChecked == false) * await conversions.AddParameter($"-i \"{fileName}\" \"{filePath}\\{videoTitle}{cbConvertType.Text}\"").Start(); * if (cboxConvert.IsChecked == true && cboxCut.IsChecked == true) * await conversions.AddParameter($"-ss {TimeSpan.FromSeconds(Int32.Parse(tbFrom.Text))} -i \"{fileName}\" -to {TimeSpan.FromSeconds(Int32.Parse(tbTo.Text) - Int32.Parse(tbFrom.Text))} -c copy \"{filePath + $"\\{videoTitle}{cbConvertType.Text}"}\"").Start(); * if (cboxConvert.IsChecked == false && cboxCut.IsChecked == true) * await conversions.AddParameter($"-ss {TimeSpan.FromSeconds(Int32.Parse(tbFrom.Text))} -i \"{fileName}\" -to {TimeSpan.FromSeconds(Int32.Parse(tbTo.Text) - Int32.Parse(tbFrom.Text))} -c copy \"{filePath + $"\\{videoTitle}{Path.GetExtension(fileName)}"}\"").Start();*/ await conversions.Start(); File.Delete(fileName); pbProgress.IsIndeterminate = false; } textStatus.Text = "Idle"; }