You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
jellyfin/MediaBrowser.MediaEncoding/Encoder/EncoderValidator.cs

350 lines
12 KiB

#pragma warning disable CS1591
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.Extensions.Logging;
namespace MediaBrowser.MediaEncoding.Encoder
{
public class EncoderValidator
{
private const string DefaultEncoderPath = "ffmpeg";
private static readonly string[] _requiredDecoders = new[]
{
"h264",
"hevc",
"mpeg2video",
"mpeg4",
"msmpeg4",
"dts",
"ac3",
"aac",
"mp3",
"h264_qsv",
"hevc_qsv",
"mpeg2_qsv",
"vc1_qsv",
"vp8_qsv",
"vp9_qsv",
"h264_cuvid",
"hevc_cuvid",
"mpeg2_cuvid",
"vc1_cuvid",
"mpeg4_cuvid",
"vp8_cuvid",
"vp9_cuvid",
"h264_mmal",
"mpeg2_mmal",
"mpeg4_mmal",
"vc1_mmal",
"h264_mediacodec",
"hevc_mediacodec",
"mpeg2_mediacodec",
"mpeg4_mediacodec",
"vp8_mediacodec",
"vp9_mediacodec",
"h264_opencl",
"hevc_opencl",
"mpeg2_opencl",
"mpeg4_opencl",
"vp8_opencl",
"vp9_opencl",
"vc1_opencl"
};
private static readonly string[] _requiredEncoders = new[]
{
"libx264",
"libx265",
"mpeg4",
"msmpeg4",
"libvpx",
"libvpx-vp9",
"aac",
"libfdk_aac",
"ac3",
"libmp3lame",
"libopus",
"libvorbis",
"srt",
"h264_amf",
"hevc_amf",
"h264_qsv",
"hevc_qsv",
"h264_nvenc",
"hevc_nvenc",
"h264_vaapi",
"hevc_vaapi",
"h264_omx",
"hevc_omx",
"h264_v4l2m2m",
"h264_videotoolbox",
"hevc_videotoolbox"
};
// These are the library versions that corresponds to our minimum ffmpeg version 4.x according to the version table below
private static readonly IReadOnlyDictionary<string, Version> _ffmpegMinimumLibraryVersions = new Dictionary<string, Version>
{
{ "libavutil", new Version(56, 14) },
{ "libavcodec", new Version(58, 18) },
{ "libavformat", new Version(58, 12) },
{ "libavdevice", new Version(58, 3) },
{ "libavfilter", new Version(7, 16) },
{ "libswscale", new Version(5, 1) },
{ "libswresample", new Version(3, 1) },
{ "libpostproc", new Version(55, 1) }
};
private readonly ILogger _logger;
private readonly string _encoderPath;
public EncoderValidator(ILogger logger, string encoderPath = DefaultEncoderPath)
{
_logger = logger;
_encoderPath = encoderPath;
}
private enum Codec
{
Encoder,
Decoder
}
// When changing this, also change the minimum library versions in _ffmpegMinimumLibraryVersions
public static Version MinVersion { get; } = new Version(4, 0);
public static Version MaxVersion { get; } = null;
public bool ValidateVersion()
{
string output = null;
try
{
output = GetProcessOutput(_encoderPath, "-version");
}
catch (Exception ex)
{
_logger.LogError(ex, "Error validating encoder");
}
if (string.IsNullOrWhiteSpace(output))
{
_logger.LogError("FFmpeg validation: The process returned no result");
return false;
}
_logger.LogDebug("ffmpeg output: {Output}", output);
return ValidateVersionInternal(output);
}
internal bool ValidateVersionInternal(string versionOutput)
{
if (versionOutput.IndexOf("Libav developers", StringComparison.OrdinalIgnoreCase) != -1)
{
_logger.LogError("FFmpeg validation: avconv instead of ffmpeg is not supported");
return false;
}
// Work out what the version under test is
var version = GetFFmpegVersion(versionOutput);
_logger.LogInformation("Found ffmpeg version {Version}", version != null ? version.ToString() : "unknown");
if (version == null)
{
if (MaxVersion != null) // Version is unknown
{
if (MinVersion == MaxVersion)
{
_logger.LogWarning("FFmpeg validation: We recommend version {MinVersion}", MinVersion);
}
else
{
_logger.LogWarning("FFmpeg validation: We recommend a minimum of {MinVersion} and maximum of {MaxVersion}", MinVersion, MaxVersion);
}
}
else
{
_logger.LogWarning("FFmpeg validation: We recommend minimum version {MinVersion}", MinVersion);
}
return false;
}
else if (version < MinVersion) // Version is below what we recommend
{
_logger.LogWarning("FFmpeg validation: The minimum recommended version is {MinVersion}", MinVersion);
return false;
}
else if (MaxVersion != null && version > MaxVersion) // Version is above what we recommend
{
_logger.LogWarning("FFmpeg validation: The maximum recommended version is {MaxVersion}", MaxVersion);
return false;
}
return true;
}
public IEnumerable<string> GetDecoders() => GetCodecs(Codec.Decoder);
public IEnumerable<string> GetEncoders() => GetCodecs(Codec.Encoder);
public IEnumerable<string> GetHwaccels() => GetHwaccelTypes();
/// <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 test the libraries to determine if they're newer than our minimum versions.
/// </summary>
/// <param name="output">The output from "ffmpeg -version".</param>
/// <returns>The FFmpeg version.</returns>
internal 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 n?((?:[0-9]+\.?)+)");
if (match.Success)
{
return new Version(match.Groups[1].Value);
}
var versionMap = GetFFmpegLibraryVersions(output);
var allVersionsValidated = true;
foreach (var minimumVersion in _ffmpegMinimumLibraryVersions)
{
if (versionMap.TryGetValue(minimumVersion.Key, out var foundVersion))
{
if (foundVersion >= minimumVersion.Value)
{
_logger.LogInformation("Found {Library} version {FoundVersion} ({MinimumVersion})", minimumVersion.Key, foundVersion, minimumVersion.Value);
}
else
{
_logger.LogWarning("Found {Library} version {FoundVersion} lower than recommended version {MinimumVersion}", minimumVersion.Key, foundVersion, minimumVersion.Value);
allVersionsValidated = false;
}
}
else
{
_logger.LogError("{Library} version not found", minimumVersion.Key);
allVersionsValidated = false;
}
}
return allVersionsValidated ? MinVersion : null;
}
/// <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">The 'ffmpeg -version' output.</param>
/// <returns>The library names and major.minor version numbers.</returns>
private static IReadOnlyDictionary<string, Version> GetFFmpegLibraryVersions(string output)
{
var map = new Dictionary<string, Version>();
foreach (Match match in Regex.Matches(
output,
@"((?<name>lib\w+)\s+(?<major>[0-9]+)\.\s*(?<minor>[0-9]+))",
RegexOptions.Multiline))
{
var version = new Version(
int.Parse(match.Groups["major"].Value, CultureInfo.InvariantCulture),
int.Parse(match.Groups["minor"].Value, CultureInfo.InvariantCulture));
map.Add(match.Groups["name"].Value, version);
}
return map;
}
private IEnumerable<string> GetHwaccelTypes()
{
string output = null;
try
{
output = GetProcessOutput(_encoderPath, "-hwaccels");
}
catch (Exception ex)
{
_logger.LogError(ex, "Error detecting available hwaccel types");
}
if (string.IsNullOrWhiteSpace(output))
{
return Enumerable.Empty<string>();
}
var found = output.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Skip(1).Distinct().ToList();
_logger.LogInformation("Available hwaccel types: {Types}", found);
return found;
}
private IEnumerable<string> GetCodecs(Codec codec)
{
string codecstr = codec == Codec.Encoder ? "encoders" : "decoders";
string output = null;
try
{
output = GetProcessOutput(_encoderPath, "-" + codecstr);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error detecting available {Codec}", codecstr);
}
if (string.IsNullOrWhiteSpace(output))
{
return Enumerable.Empty<string>();
}
var required = codec == Codec.Encoder ? _requiredEncoders : _requiredDecoders;
var found = Regex
.Matches(output, @"^\s\S{6}\s(?<codec>[\w|-]+)\s+.+$", RegexOptions.Multiline)
.Cast<Match>()
.Select(x => x.Groups["codec"].Value)
.Where(x => required.Contains(x));
_logger.LogInformation("Available {Codec}: {Codecs}", codecstr, found);
return found;
}
private string GetProcessOutput(string path, string arguments)
{
using (var process = new Process()
{
StartInfo = new ProcessStartInfo(path, arguments)
{
CreateNoWindow = true,
UseShellExecute = false,
WindowStyle = ProcessWindowStyle.Hidden,
ErrorDialog = false,
RedirectStandardOutput = true,
// ffmpeg uses stderr to log info, don't show this
RedirectStandardError = true
}
})
{
_logger.LogDebug("Running {Path} {Arguments}", path, arguments);
process.Start();
return process.StandardOutput.ReadToEnd();
}
}
}
}