Added TimeLeftCalculator, renamed FFmpegProgress as FFmpegStatus

mysteryx93 · mysteryx93 · commit 923c58f0efe3 · 2017-03-18T22:46:14.000-05:00
diff --git a/ExampleApplication/FFmpegWindow.xaml.cs b/ExampleApplication/FFmpegWindow.xaml.cs
@@ -21,6 +21,7 @@ public static FFmpegWindow Instance(Window parent, string title, bool autoClose)
         private FFmpegProcess task;
         private bool autoClose;
         private string title { get; set; }
+        private TimeLeftCalculator timeCalc;
 
         public void Stop() {
             Dispatcher.Invoke(() => this.Close());
@@ -39,7 +40,7 @@ public void DisplayTask(FFmpegProcess taskArg) {
                 if (taskArg.Options.IsMainTask) {
                     host = taskArg;
                     host.InfoUpdated += FFmpeg_InfoUpdated;
-                    host.ProgressUpdated += FFmpeg_ProgressUpdated;
+                    host.StatusUpdated += FFmpeg_StatusUpdated;
                     host.Completed += FFmpeg_Completed;
                     PercentText.Text = 0.ToString("p1");
                     SetPageTitle(PercentText.Text);
@@ -66,21 +67,27 @@ private void SetPageTitle(string status) {
         }
 
         private void FFmpeg_InfoUpdated(object sender, EventArgs e) {
-            Dispatcher.Invoke(() => WorkProgressBar.Maximum = host.FrameCount + host.Options.ResumePos);
+            Dispatcher.Invoke(() => {
+                WorkProgressBar.Maximum = host.FrameCount + host.Options.ResumePos;
+                timeCalc = new TimeLeftCalculator(host.FrameCount + host.Options.ResumePos);
+            });
         }
 
         private bool EstimatedTimeLeftToggle = false;
-        private void FFmpeg_ProgressUpdated(object sender, FFmpeg.ProgressUpdatedEventArgs e) {
+        private void FFmpeg_StatusUpdated(object sender, FFmpeg.StatusUpdatedEventArgs e) {
             Dispatcher.Invoke(() => {
-                WorkProgressBar.Value = e.Progress.Frame + host.Options.ResumePos;
+                WorkProgressBar.Value = e.Status.Frame + host.Options.ResumePos;
                 PercentText.Text = (WorkProgressBar.Value / WorkProgressBar.Maximum).ToString("p1");
                 SetPageTitle(PercentText.Text);
-                FpsText.Text = e.Progress.Fps.ToString();
+                FpsText.Text = e.Status.Fps.ToString();
 
                 // Time left will be updated only 1 out of 2 to prevent changing too quick.
                 EstimatedTimeLeftToggle = !EstimatedTimeLeftToggle;
-                if (e.Progress.EstimatedTimeLeft != TimeSpan.Zero && EstimatedTimeLeftToggle)
-                    TimeLeftText.Text = e.Progress.EstimatedTimeLeft.ToString(e.Progress.EstimatedTimeLeft.TotalHours < 1 ? "m\\:ss" : "h\\:mm\\:ss");
+                if (EstimatedTimeLeftToggle) {
+                    TimeSpan TimeLeft = timeCalc?.Calculate(e.Status.Frame + host.Options.ResumePos) ?? TimeSpan.Zero;
+                    if (TimeLeft > TimeSpan.Zero)
+                        TimeLeftText.Text = TimeLeft.ToString(TimeLeft.TotalHours < 1 ? "m\\:ss" : "h\\:mm\\:ss");
+                }
             });
         }
 
diff --git a/ExampleApplication/Properties/AssemblyInfo.cs b/ExampleApplication/Properties/AssemblyInfo.cs
@@ -51,5 +51,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.0.1.0")]
+[assembly: AssemblyFileVersion("1.0.1.0")]
diff --git a/FFmpeg/EventHandlers.cs b/FFmpeg/EventHandlers.cs
@@ -3,21 +3,21 @@
 
 namespace EmergenceGuardian.FFmpeg {
     /// <summary>
-    /// Represents the method that will handle the ProgressUpdated event.
+    /// Represents the method that will handle the StatusUpdated event.
     /// </summary>
-    public delegate void ProgressUpdatedEventHandler(object sender, ProgressUpdatedEventArgs e);
+    public delegate void StatusUpdatedEventHandler(object sender, StatusUpdatedEventArgs e);
 
     /// <summary>
-    /// Provides progress information for the ProgressUpdated event.
+    /// Provides progress information for the StatusUpdated event.
     /// </summary>
-    public class ProgressUpdatedEventArgs : EventArgs {
-        public FFmpegProgress Progress { get; set; }
+    public class StatusUpdatedEventArgs : EventArgs {
+        public FFmpegStatus Status { get; set; }
 
-        public ProgressUpdatedEventArgs() {
+        public StatusUpdatedEventArgs() {
         }
 
-        public ProgressUpdatedEventArgs(FFmpegProgress progress) {
-            Progress = progress;
+        public StatusUpdatedEventArgs(FFmpegStatus progress) {
+            Status = progress;
         }
     }
 
diff --git a/FFmpeg/FFmpeg.csproj b/FFmpeg/FFmpeg.csproj
@@ -51,11 +51,13 @@
     <Compile Include="FFmpegConfig.cs" />
     <Compile Include="FFmpegDisplayMode.cs" />
     <Compile Include="FFmpegParser.cs" />
+    <Compile Include="FFmpegStatus.cs" />
     <Compile Include="FFmpegStream.cs" />
     <Compile Include="FFmpegStreamInfo.cs" />
     <Compile Include="FFmpegProcess.cs" />
     <Compile Include="FFmpegStreamType.cs" />
     <Compile Include="MediaProcesses.cs" />
+    <Compile Include="TimeLeftCalculator.cs" />
     <Compile Include="UserInterfaceManagerBase.cs" />
     <Compile Include="MediaInfo.cs" />
     <Compile Include="MediaEncoder.cs" />
diff --git a/FFmpeg/FFmpeg.nuspec b/FFmpeg/FFmpeg.nuspec
@@ -2,15 +2,15 @@
 <package >
   <metadata>
     <id>EmergenceGuardian.FFmpeg</id>
-    <version>1.0.0.0</version>
+    <version>1.0.1.0</version>
     <title>FFmpeg.NET</title>
     <authors>Etienne Charland</authors>
     <owners>Etienne Charland</owners>
     <licenseUrl>https://github.com/mysteryx93/FFmpeg.NET/blob/master/LICENSE</licenseUrl>
     <projectUrl>https://github.com/mysteryx93/FFmpeg.NET</projectUrl>
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>.NET Wrapper for FFmpeg</description>
-    <releaseNotes>Initial release.</releaseNotes>
+    <releaseNotes>Sample and usage info available here https://github.com/mysteryx93/FFmpeg.NET</releaseNotes>
     <copyright>Copyright 2017, Emergence Guardian</copyright>
     <tags>ffmpeg ffmpeg-wrapper video-encoding video library .net</tags>
   </metadata>
diff --git a/FFmpeg/FFmpegParser.cs b/FFmpeg/FFmpegParser.cs
@@ -159,8 +159,8 @@ internal static FFmpegStreamInfo ParseStreamInfo(string item) {
         /// </summary>
         /// <param name="text">The raw output line from FFmpeg.</param>
         /// <returns>A FFmpegProgress object.</returns>
-        internal static FFmpegProgress ParseProgress(string text) {
-            FFmpegProgress Result = new FFmpegProgress();
+        internal static FFmpegStatus ParseProgress(string text) {
+            FFmpegStatus Result = new FFmpegStatus();
             // frame=  929 fps=0.0 q=-0.0 size=   68483kB time=00:00:37.00 bitrate=15162.6kbits/s speed=  74x    
             string[] Values = text.Split('=');
             try {
diff --git a/FFmpeg/FFmpegProcess.cs b/FFmpeg/FFmpegProcess.cs
@@ -31,9 +31,9 @@ public class FFmpegProcess {
         /// </summary>
         public event EventHandler InfoUpdated;
         /// <summary>
-        /// Occurs when progress update is received through FFmpeg's output stream.
+        /// Occurs when status update is received through FFmpeg's output stream.
         /// </summary>
-        public event ProgressUpdatedEventHandler ProgressUpdated;
+        public event StatusUpdatedEventHandler StatusUpdated;
         /// <summary>
         /// Occurs when the process has terminated its work.
         /// </summary>
@@ -65,8 +65,6 @@ public string Output {
         private bool isFFmpeg;
         private bool isStarted;
         private CancellationTokenSource cancelWork;
-        private List<KeyValuePair<DateTime, long>> progressHistory;
-        private bool nestedProcess;
 
         /// <summary>
         /// Initializes a new instances of the FFmpegProcess class.
@@ -151,14 +149,12 @@ public CompletionStatus Run(string fileName, string arguments, bool isFFmpeg, bo
             Process P = new Process();
             this.isFFmpeg = isFFmpeg;
             WorkProcess = P;
-            this.nestedProcess = nestedProcess;
             output = new StringBuilder();
             isStarted = false;
             FileStreams = null;
             FrameCount = 0;
             FileDuration = TimeSpan.Zero;
             cancelWork = new CancellationTokenSource();
-            progressHistory = new List<KeyValuePair<DateTime, long>>();
             if (Options == null)
                 Options = new ProcessStartOptions();
 
@@ -193,7 +189,6 @@ public CompletionStatus Run(string fileName, string arguments, bool isFFmpeg, bo
 
             isStarted = false;
             cancelWork = null;
-            progressHistory = null;
             LastCompletionStatus = Result;
             Completed?.Invoke(this, new CompletedEventArgs(Result));
             if ((Result == CompletionStatus.Error || Result == CompletionStatus.Timeout) && Options.DisplayMode == FFmpegDisplayMode.ErrorOnly)
@@ -264,9 +259,8 @@ private void FFmpeg_DataReceived(object sender, DataReceivedEventArgs e) {
                     isStarted = true;
 
                 if (isStarted && e.Data.StartsWith("frame=")) {
-                    FFmpegProgress ProgressInfo = FFmpegParser.ParseProgress(e.Data);
-                    CalculateTimeLeft(ProgressInfo);
-                    ProgressUpdated?.Invoke(this, new ProgressUpdatedEventArgs(ProgressInfo));
+                    FFmpegStatus ProgressInfo = FFmpegParser.ParseProgress(e.Data);
+                    StatusUpdated?.Invoke(this, new StatusUpdatedEventArgs(ProgressInfo));
                 }
             }
         }
@@ -282,25 +276,6 @@ private void ParseFileInfo() {
             InfoUpdated?.Invoke(this, new EventArgs());
         }
 
-        /// <summary>
-        /// Calculates the time left.
-        /// </summary>
-        /// <param name="progress">An object containing the latest progress info.</param>
-        private void CalculateTimeLeft(FFmpegProgress progress) {
-            // progressHistory contains the last 10 progress values.
-            progressHistory.Add(new KeyValuePair<DateTime, long>(DateTime.Now, progress.Frame));
-            if (progressHistory.Count > 10)
-                progressHistory.RemoveAt(0);
-            if (progressHistory.Count > 1) {
-                TimeSpan SampleWorkTime = progressHistory.Last().Key - progressHistory.First().Key;
-                long SampleWorkFrame = progressHistory.Last().Value - progressHistory.First().Value;
-                double ProcessingFps = SampleWorkFrame / SampleWorkTime.TotalSeconds;
-                long WorkLeft = FrameCount - progress.Frame;
-                if (WorkLeft > 0)
-                    progress.EstimatedTimeLeft = TimeSpan.FromSeconds(WorkLeft / ProcessingFps);
-            }
-        }
-
         /// <summary>
         /// Gets the first video stream from FileStreams.
         /// </summary>
diff --git a/FFmpeg/FFmpegStatus.cs b/FFmpeg/FFmpegStatus.cs
@@ -0,0 +1,19 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace EmergenceGuardian.FFmpeg {
+    /// <summary>
+    /// Contains progress information returned from FFmpeg's output.
+    /// </summary>
+    public class FFmpegStatus {
+        public long Frame { get; set; }
+        public float Fps { get; set; }
+        public float Quantizer { get; set; }
+        public string Size { get; set; }
+        public TimeSpan Time { get; set; }
+        public string Bitrate { get; set; }
+        public float Speed { get; set; }
+    }
+}
diff --git a/FFmpeg/FFmpegStreamInfo.cs b/FFmpeg/FFmpegStreamInfo.cs
@@ -51,17 +51,4 @@ public class FFmpegAudioStreamInfo : FFmpegStreamInfo {
         public int Bitrate { get; set; }
     }
 
-    /// <summary>
-    /// Contains progress information returned from FFmpeg's output.
-    /// </summary>
-    public class FFmpegProgress {
-        public long Frame { get; set; }
-        public float Fps { get; set; }
-        public float Quantizer { get; set; }
-        public string Size { get; set; }
-        public TimeSpan Time { get; set; }
-        public string Bitrate { get; set; }
-        public float Speed { get; set; }
-        public TimeSpan EstimatedTimeLeft { get; set; }
-    }
 }
diff --git a/FFmpeg/MediaInfo.cs b/FFmpeg/MediaInfo.cs
@@ -49,8 +49,8 @@ public static long GetFrameCount(string source) {
         public static long GetFrameCount(string source, ProcessStartOptions options) {
             long Result = 0;
             FFmpegProcess Worker = new FFmpeg.FFmpegProcess(options);
-            Worker.ProgressUpdated += (sender, e) => {
-                Result = e.Progress.Frame;
+            Worker.StatusUpdated += (sender, e) => {
+                Result = e.Status.Frame;
             };
             Worker.RunFFmpeg(string.Format(@"-i ""{0}"" -f null /dev/null", source));
             return Result;
diff --git a/FFmpeg/Properties/AssemblyInfo.cs b/FFmpeg/Properties/AssemblyInfo.cs
@@ -32,5 +32,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.0.1.0")]
+[assembly: AssemblyFileVersion("1.0.1.0")]
diff --git a/FFmpeg/TimeLeftCalculator.cs b/FFmpeg/TimeLeftCalculator.cs
@@ -0,0 +1,72 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace EmergenceGuardian.FFmpeg {
+    /// <summary>
+    /// Allows calculating the time left for a FFmpeg process.
+    /// </summary>
+    public class TimeLeftCalculator {
+        private KeyValuePair<DateTime, long>[] progressHistory;
+        private int iterator = 0;
+        private bool fullCycle = false;
+        /// <summary>
+        /// Gets or sets the total number of frames to encode.
+        /// </summary>
+        public long FrameCount { get; private set; }
+        /// <summary>
+        /// Gets or sets the number of status entries to store. The larger the number, the slower the time left will change.
+        /// </summary>
+        public int HistoryLength { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the TimeLeftCalculator class.
+        /// </summary>
+        /// <param name="frameCount">The total number of frames to encode.</param>
+        public TimeLeftCalculator(long frameCount) : this(frameCount, 20) {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the TimeLeftCalculator class.
+        /// </summary>
+        /// <param name="frameCount">The total number of frames to encode.</param>
+        /// <param name="historyLength">The number of status entries to store. The larger the number, the slower the time left will change.</param>
+        public TimeLeftCalculator(long frameCount, int historyLength) {
+            this.FrameCount = frameCount;
+            this.HistoryLength = historyLength;
+            progressHistory = new KeyValuePair<DateTime, long>[historyLength];
+        }
+
+        /// <summary>
+        /// Calculates the time left.
+        /// </summary>
+        /// <param name="pos">The current frame position.</param>
+        /// <returns>The estimated time left.</returns>
+        public TimeSpan Calculate(long pos) {
+            TimeSpan Result = TimeSpan.Zero;
+            progressHistory[iterator] = new KeyValuePair<DateTime, long>(DateTime.Now, pos);
+
+            int PosFirst = -1;
+            if (fullCycle) {
+                PosFirst = (iterator + 1) % HistoryLength;
+            } else if (iterator > 0)
+                PosFirst = 0;
+
+            if (PosFirst > -1) {
+                TimeSpan SampleWorkTime = progressHistory[iterator].Key - progressHistory[PosFirst].Key;
+                long SampleWorkFrame = progressHistory[iterator].Value - progressHistory[PosFirst].Value;
+                double ProcessingFps = SampleWorkFrame / SampleWorkTime.TotalSeconds;
+                long WorkLeft = FrameCount - pos;
+                if (WorkLeft > 0)
+                    Result = TimeSpan.FromSeconds(WorkLeft / ProcessingFps);
+            }
+
+            iterator = (iterator + 1) % HistoryLength;
+            if (iterator == 0)
+                fullCycle = true;
+
+            return Result;
+        }
+    }
+}
