Merge pull request #900 from ploughpuff/validator

Implement proper FFmpeg version checking

MediaBrowser.MediaEncoding/Encoder/EncoderValidator.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text.RegularExpressions;
 using MediaBrowser.Model.Diagnostics;
@@ -58,18 +58,107 @@ namespace MediaBrowser.MediaEncoding.Encoder
                 return false;
             }
 
-            output = " " + output + " ";
+            // The min and max FFmpeg versions required to run jellyfin successfully
+            var minRequired = new Version(4, 0);
+            var maxRequired = new Version(4, 0);
 
-            for (var i = 2013; i <= 2015; i++)
+            // Work out what the version under test is
+            var underTest = GetFFmpegVersion(output);
+
+            if (logOutput)
             {
-                var yearString = i.ToString(CultureInfo.InvariantCulture);
-                if (output.IndexOf(" " + yearString + " ", StringComparison.OrdinalIgnoreCase) != -1)
+                _logger.LogInformation("FFmpeg validation: Found ffmpeg version {0}", underTest != null ? underTest.ToString() : "unknown");
+
+                if (underTest == null) // Version is unknown
+                {
+                    if (minRequired.Equals(maxRequired))
+                    {
+                        _logger.LogWarning("FFmpeg validation: We recommend ffmpeg version {0}", minRequired.ToString());
+                    }
+                    else
+                    {
+                        _logger.LogWarning("FFmpeg validation: We recommend a minimum of {0} and maximum of {1}", minRequired.ToString(), maxRequired.ToString());
+                    }
+                }
+                else if (underTest.CompareTo(minRequired) < 0) // Version is below what we recommend
                 {
-                    return false;
+                    _logger.LogWarning("FFmpeg validation: The minimum recommended ffmpeg version is {0}", minRequired.ToString());
                 }
+                else if (underTest.CompareTo(maxRequired) > 0) // Version is above what we recommend
+                {
+                    _logger.LogWarning("FFmpeg validation: The maximum recommended ffmpeg version is {0}", maxRequired.ToString());
+                }
+                else  // Version is ok
+                {
+                    _logger.LogInformation("FFmpeg validation: Found suitable ffmpeg version");
+                }
+            }
+
+            // underTest shall be null if versions is unknown
+            return (underTest == null) ? false : (underTest.CompareTo(minRequired) >= 0 && underTest.CompareTo(maxRequired) <= 0);
+        }
+
+        /// <summary>
+        /// Using the output from "ffmpeg -version" work out the FFmpeg version.
+        /// For pre-built binaries the first line should contain a string like "ffmpeg version x.y", which is easy
+        /// to parse.  If this is not available, then we try to match known library versions to FFmpeg versions.
+        /// If that fails then we use one of the main libraries to determine if it's new/older than the latest
+        /// we have stored.
+        /// </summary>
+        /// <param name="output"></param>
+        /// <returns></returns>
+        static private Version GetFFmpegVersion(string output)
+        {
+            // For pre-built binaries the FFmpeg version should be mentioned at the very start of the output
+            var match = Regex.Match(output, @"ffmpeg version (\d+\.\d+)");
+
+            if (match.Success)
+            {
+                return new Version(match.Groups[1].Value);
+            }
+            else
+            {
+                // Try and use the individual library versions to determine a FFmpeg version
+                // This lookup table is to be maintained with the following command line:
+                // $ ./ffmpeg.exe -version | perl -ne ' print "$1=$2.$3," if /^(lib\w+)\s+(\d+)\.\s*(\d+)/'
+                var lut = new ReadOnlyDictionary<Version, string>
+                    (new Dictionary<Version, string>
+                    {
+                        { new Version("4.1"), "libavutil=56.22,libavcodec=58.35,libavformat=58.20,libavdevice=58.5,libavfilter=7.40,libswscale=5.3,libswresample=3.3,libpostproc=55.3," },
+                        { new Version("4.0"), "libavutil=56.14,libavcodec=58.18,libavformat=58.12,libavdevice=58.3,libavfilter=7.16,libswscale=5.1,libswresample=3.1,libpostproc=55.1," },
+                        { new Version("3.4"), "libavutil=55.78,libavcodec=57.107,libavformat=57.83,libavdevice=57.10,libavfilter=6.107,libswscale=4.8,libswresample=2.9,libpostproc=54.7," },
+                        { new Version("3.3"), "libavutil=55.58,libavcodec=57.89,libavformat=57.71,libavdevice=57.6,libavfilter=6.82,libswscale=4.6,libswresample=2.7,libpostproc=54.5," },
+                        { new Version("3.2"), "libavutil=55.34,libavcodec=57.64,libavformat=57.56,libavdevice=57.1,libavfilter=6.65,libswscale=4.2,libswresample=2.3,libpostproc=54.1," },
+                        { new Version("2.8"), "libavutil=54.31,libavcodec=56.60,libavformat=56.40,libavdevice=56.4,libavfilter=5.40,libswscale=3.1,libswresample=1.2,libpostproc=53.3," }
+                    });
+
+                // Create a reduced version string and lookup key from dictionary
+                var reducedVersion = GetVersionString(output);
+
+                // Try to lookup the string and return Key, otherwise if not found returns null
+                return lut.FirstOrDefault(x => x.Value == reducedVersion).Key;
+            }
+        }
+
+        /// <summary>
+        /// Grabs the library names and major.minor version numbers from the 'ffmpeg -version' output
+        /// and condenses them on to one line.  Output format is "name1=major.minor,name2=major.minor,etc."
+        /// </summary>
+        /// <param name="output"></param>
+        /// <returns></returns>
+        static private string GetVersionString(string output)
+        {
+            string pattern = @"((?<name>lib\w+)\s+(?<major>\d+)\.\s*(?<minor>\d+))";
+            RegexOptions options = RegexOptions.Multiline;
+
+            string rc = null;
+
+            foreach (Match m in Regex.Matches(output, pattern, options))
+            {
+                rc += string.Concat(m.Groups["name"], '=', m.Groups["major"], '.', m.Groups["minor"], ',');
             }
 
-            return true;
+            return rc;
         }
 
         private static readonly string[] requiredDecoders = new[]