< Summary - Jellyfin

Information
Class: MediaBrowser.MediaEncoding.Encoder.MediaEncoder
Assembly: MediaBrowser.MediaEncoding
File(s): /srv/git/jellyfin/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
Line coverage
14%
Covered lines: 52
Uncovered lines: 307
Coverable lines: 359
Total lines: 1352
Line coverage: 14.4%
Branch coverage
12%
Covered branches: 21
Total branches: 163
Branch coverage: 12.8%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)83.33%66100%
.cctor()100%210%
get_EncoderPath()100%210%
get_ProbePath()100%210%
get_EncoderVersion()100%210%
get_IsPkeyPauseSupported()100%210%
get_IsVaapiDeviceAmd()100%210%
get_IsVaapiDeviceInteliHD()100%210%
get_IsVaapiDeviceInteli965()100%210%
get_IsVaapiDeviceSupportVulkanDrmModifier()100%210%
get_IsVaapiDeviceSupportVulkanDrmInterop()100%210%
get_IsVideoToolboxAv1DecodeAvailable()100%210%
SetFFmpegPath()2.77%1065367.4%
ValidatePath(...)0%2040%
GetEncoderPathFromDirectory(...)100%210%
SetAvailableEncoders(...)100%210%
SetAvailableDecoders(...)100%210%
SetAvailableHwaccels(...)100%210%
SetAvailableFilters(...)100%210%
SetAvailableFiltersWithOption(...)100%210%
SetMediaEncoderVersion(...)100%210%
SupportsEncoder(...)100%210%
SupportsDecoder(...)100%210%
SupportsHwaccel(...)100%210%
SupportsFilter(...)100%210%
SupportsFilterWithOption(...)0%620%
CanEncodeToAudioCodec(...)0%2040%
CanEncodeToSubtitleCodec(...)100%210%
GetMediaInfo(...)0%620%
GetExtraArguments(...)61.11%261870.58%
GetInputArgument(...)100%210%
GetInputArgument(...)0%620%
GetExternalSubtitleInputArgument(...)100%210%
ExtractAudioImage(...)100%210%
ExtractVideoImage(...)100%210%
ExtractVideoImage(...)100%210%
GetImageResolutionParameter()0%132110%
ExtractVideoImagesOnIntervalAccelerated(...)0%2352480%
GetTimeParameter(...)100%210%
GetTimeParameter(...)100%210%
StartProcess(...)100%210%
StopProcess(...)0%620%
StopProcesses()50%4475%
EscapeSubtitleFilterPath(...)100%210%
Dispose()100%11100%
Dispose(...)100%22100%
ConvertImage(...)100%210%
GetPrimaryPlaylistVobFiles(...)0%4260%
GetPrimaryPlaylistM2tsFiles(...)100%210%
GetInputPathArgument(...)100%210%
GetInputPathArgument(...)0%4260%
GenerateConcatConfig(...)0%4260%
CanExtractSubtitles(...)100%210%
.ctor(...)100%210%
OnProcessExited(...)100%210%
DisposeProcess(...)100%210%
Dispose()0%2040%

File(s)

/srv/git/jellyfin/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs

#LineLine coverage
 1#nullable disable
 2#pragma warning disable CS1591
 3
 4using System;
 5using System.Collections.Generic;
 6using System.Diagnostics;
 7using System.Globalization;
 8using System.IO;
 9using System.Linq;
 10using System.Text.Json;
 11using System.Text.RegularExpressions;
 12using System.Threading;
 13using System.Threading.Tasks;
 14using AsyncKeyedLock;
 15using Jellyfin.Data.Enums;
 16using Jellyfin.Extensions;
 17using Jellyfin.Extensions.Json;
 18using Jellyfin.Extensions.Json.Converters;
 19using MediaBrowser.Common;
 20using MediaBrowser.Common.Configuration;
 21using MediaBrowser.Common.Extensions;
 22using MediaBrowser.Controller.Configuration;
 23using MediaBrowser.Controller.Extensions;
 24using MediaBrowser.Controller.MediaEncoding;
 25using MediaBrowser.MediaEncoding.Probing;
 26using MediaBrowser.Model.Configuration;
 27using MediaBrowser.Model.Dlna;
 28using MediaBrowser.Model.Drawing;
 29using MediaBrowser.Model.Dto;
 30using MediaBrowser.Model.Entities;
 31using MediaBrowser.Model.Globalization;
 32using MediaBrowser.Model.IO;
 33using MediaBrowser.Model.MediaInfo;
 34using Microsoft.Extensions.Configuration;
 35using Microsoft.Extensions.Logging;
 36
 37namespace MediaBrowser.MediaEncoding.Encoder
 38{
 39    /// <summary>
 40    /// Class MediaEncoder.
 41    /// </summary>
 42    public partial class MediaEncoder : IMediaEncoder, IDisposable
 43    {
 44        /// <summary>
 45        /// The default SDR image extraction timeout in milliseconds.
 46        /// </summary>
 47        internal const int DefaultSdrImageExtractionTimeout = 10000;
 48
 49        /// <summary>
 50        /// The default HDR image extraction timeout in milliseconds.
 51        /// </summary>
 52        internal const int DefaultHdrImageExtractionTimeout = 20000;
 53
 54        private readonly ILogger<MediaEncoder> _logger;
 55        private readonly IServerConfigurationManager _configurationManager;
 56        private readonly IFileSystem _fileSystem;
 57        private readonly ILocalizationManager _localization;
 58        private readonly IBlurayExaminer _blurayExaminer;
 59        private readonly IConfiguration _config;
 60        private readonly IServerConfigurationManager _serverConfig;
 61        private readonly string _startupOptionFFmpegPath;
 62
 63        private readonly AsyncNonKeyedLocker _thumbnailResourcePool;
 64
 2265        private readonly Lock _runningProcessesLock = new();
 2266        private readonly List<ProcessWrapper> _runningProcesses = new List<ProcessWrapper>();
 67
 68        // MediaEncoder is registered as a Singleton
 69        private readonly JsonSerializerOptions _jsonSerializerOptions;
 70
 2271        private List<string> _encoders = new List<string>();
 2272        private List<string> _decoders = new List<string>();
 2273        private List<string> _hwaccels = new List<string>();
 2274        private List<string> _filters = new List<string>();
 2275        private IDictionary<int, bool> _filtersWithOption = new Dictionary<int, bool>();
 76
 77        private bool _isPkeyPauseSupported = false;
 78        private bool _isLowPriorityHwDecodeSupported = false;
 79
 80        private bool _isVaapiDeviceAmd = false;
 81        private bool _isVaapiDeviceInteliHD = false;
 82        private bool _isVaapiDeviceInteli965 = false;
 83        private bool _isVaapiDeviceSupportVulkanDrmModifier = false;
 84        private bool _isVaapiDeviceSupportVulkanDrmInterop = false;
 85
 86        private bool _isVideoToolboxAv1DecodeAvailable = false;
 87
 088        private static string[] _vulkanImageDrmFmtModifierExts =
 089        {
 090            "VK_EXT_image_drm_format_modifier",
 091        };
 92
 093        private static string[] _vulkanExternalMemoryDmaBufExts =
 094        {
 095            "VK_KHR_external_memory_fd",
 096            "VK_EXT_external_memory_dma_buf",
 097            "VK_KHR_external_semaphore_fd",
 098            "VK_EXT_external_memory_host"
 099        };
 100
 101        private Version _ffmpegVersion = null;
 22102        private string _ffmpegPath = string.Empty;
 103        private string _ffprobePath;
 104        private int _threads;
 105
 106        public MediaEncoder(
 107            ILogger<MediaEncoder> logger,
 108            IServerConfigurationManager configurationManager,
 109            IFileSystem fileSystem,
 110            IBlurayExaminer blurayExaminer,
 111            ILocalizationManager localization,
 112            IConfiguration config,
 113            IServerConfigurationManager serverConfig)
 114        {
 22115            _logger = logger;
 22116            _configurationManager = configurationManager;
 22117            _fileSystem = fileSystem;
 22118            _blurayExaminer = blurayExaminer;
 22119            _localization = localization;
 22120            _config = config;
 22121            _serverConfig = serverConfig;
 22122            _startupOptionFFmpegPath = config.GetValue<string>(Controller.Extensions.ConfigurationExtensions.FfmpegPathK
 123
 22124            _jsonSerializerOptions = new JsonSerializerOptions(JsonDefaults.Options);
 22125            _jsonSerializerOptions.Converters.Add(new JsonBoolStringConverter());
 126
 127            // Although the type is not nullable, this might still be null during unit tests
 22128            var semaphoreCount = serverConfig.Configuration?.ParallelImageEncodingLimit ?? 0;
 22129            if (semaphoreCount < 1)
 130            {
 22131                semaphoreCount = Environment.ProcessorCount;
 132            }
 133
 22134            _thumbnailResourcePool = new(semaphoreCount);
 22135        }
 136
 137        /// <inheritdoc />
 0138        public string EncoderPath => _ffmpegPath;
 139
 140        /// <inheritdoc />
 0141        public string ProbePath => _ffprobePath;
 142
 143        /// <inheritdoc />
 0144        public Version EncoderVersion => _ffmpegVersion;
 145
 146        /// <inheritdoc />
 0147        public bool IsPkeyPauseSupported => _isPkeyPauseSupported;
 148
 149        /// <inheritdoc />
 0150        public bool IsVaapiDeviceAmd => _isVaapiDeviceAmd;
 151
 152        /// <inheritdoc />
 0153        public bool IsVaapiDeviceInteliHD => _isVaapiDeviceInteliHD;
 154
 155        /// <inheritdoc />
 0156        public bool IsVaapiDeviceInteli965 => _isVaapiDeviceInteli965;
 157
 158        /// <inheritdoc />
 0159        public bool IsVaapiDeviceSupportVulkanDrmModifier => _isVaapiDeviceSupportVulkanDrmModifier;
 160
 161        /// <inheritdoc />
 0162        public bool IsVaapiDeviceSupportVulkanDrmInterop => _isVaapiDeviceSupportVulkanDrmInterop;
 163
 0164        public bool IsVideoToolboxAv1DecodeAvailable => _isVideoToolboxAv1DecodeAvailable;
 165
 166        [GeneratedRegex(@"[^\/\\]+?(\.[^\/\\\n.]+)?$")]
 167        private static partial Regex FfprobePathRegex();
 168
 169        /// <summary>
 170        /// Run at startup to validate ffmpeg.
 171        /// Sets global variables FFmpegPath.
 172        /// Precedence is: CLI/Env var > Config > $PATH.
 173        /// </summary>
 174        /// <returns>bool indicates whether a valid ffmpeg is found.</returns>
 175        public bool SetFFmpegPath()
 176        {
 21177            var skipValidation = _config.GetFFmpegSkipValidation();
 21178            if (skipValidation)
 179            {
 21180                _logger.LogWarning("FFmpeg: Skipping FFmpeg Validation due to FFmpeg:novalidation set to true");
 21181                return true;
 182            }
 183
 184            // 1) Check if the --ffmpeg CLI switch has been given
 0185            var ffmpegPath = _startupOptionFFmpegPath;
 0186            string ffmpegPathSetMethodText = "command line or environment variable";
 0187            if (string.IsNullOrEmpty(ffmpegPath))
 188            {
 189                // 2) Custom path stored in config/encoding xml file under tag <EncoderAppPath> should be used as a fall
 0190                ffmpegPath = _configurationManager.GetEncodingOptions().EncoderAppPath;
 0191                ffmpegPathSetMethodText = "encoding.xml config file";
 0192                if (string.IsNullOrEmpty(ffmpegPath))
 193                {
 194                    // 3) Check "ffmpeg"
 0195                    ffmpegPath = "ffmpeg";
 0196                    ffmpegPathSetMethodText = "system $PATH";
 197                }
 198            }
 199
 0200            if (!ValidatePath(ffmpegPath))
 201            {
 0202                _ffmpegPath = null;
 0203                _logger.LogError("FFmpeg: Path set by {FfmpegPathSetMethodText} is invalid", ffmpegPathSetMethodText);
 0204                return false;
 205            }
 206
 207            // Write the FFmpeg path to the config/encoding.xml file as <EncoderAppPathDisplay> so it appears in UI
 0208            var options = _configurationManager.GetEncodingOptions();
 0209            options.EncoderAppPathDisplay = _ffmpegPath ?? string.Empty;
 0210            _configurationManager.SaveConfiguration("encoding", options);
 211
 212            // Only if mpeg path is set, try and set path to probe
 0213            if (_ffmpegPath is not null)
 214            {
 215                // Determine a probe path from the mpeg path
 0216                _ffprobePath = FfprobePathRegex().Replace(_ffmpegPath, "ffprobe$1");
 217
 218                // Interrogate to understand what coders are supported
 0219                var validator = new EncoderValidator(_logger, _ffmpegPath);
 220
 0221                SetAvailableDecoders(validator.GetDecoders());
 0222                SetAvailableEncoders(validator.GetEncoders());
 0223                SetAvailableFilters(validator.GetFilters());
 0224                SetAvailableFiltersWithOption(validator.GetFiltersWithOption());
 0225                SetAvailableHwaccels(validator.GetHwaccels());
 0226                SetMediaEncoderVersion(validator);
 227
 0228                _threads = EncodingHelper.GetNumberOfThreads(null, options, null);
 229
 0230                _isPkeyPauseSupported = validator.CheckSupportedRuntimeKey("p      pause transcoding", _ffmpegVersion);
 0231                _isLowPriorityHwDecodeSupported = validator.CheckSupportedHwaccelFlag("low_priority");
 232
 233                // Check the Vaapi device vendor
 0234                if (OperatingSystem.IsLinux()
 0235                    && SupportsHwaccel("vaapi")
 0236                    && !string.IsNullOrEmpty(options.VaapiDevice)
 0237                    && options.HardwareAccelerationType == HardwareAccelerationType.vaapi)
 238                {
 0239                    _isVaapiDeviceAmd = validator.CheckVaapiDeviceByDriverName("Mesa Gallium driver", options.VaapiDevic
 0240                    _isVaapiDeviceInteliHD = validator.CheckVaapiDeviceByDriverName("Intel iHD driver", options.VaapiDev
 0241                    _isVaapiDeviceInteli965 = validator.CheckVaapiDeviceByDriverName("Intel i965 driver", options.VaapiD
 0242                    _isVaapiDeviceSupportVulkanDrmModifier = validator.CheckVulkanDrmDeviceByExtensionName(options.Vaapi
 0243                    _isVaapiDeviceSupportVulkanDrmInterop = validator.CheckVulkanDrmDeviceByExtensionName(options.VaapiD
 244
 0245                    if (_isVaapiDeviceAmd)
 246                    {
 0247                        _logger.LogInformation("VAAPI device {RenderNodePath} is AMD GPU", options.VaapiDevice);
 248                    }
 0249                    else if (_isVaapiDeviceInteliHD)
 250                    {
 0251                        _logger.LogInformation("VAAPI device {RenderNodePath} is Intel GPU (iHD)", options.VaapiDevice);
 252                    }
 0253                    else if (_isVaapiDeviceInteli965)
 254                    {
 0255                        _logger.LogInformation("VAAPI device {RenderNodePath} is Intel GPU (i965)", options.VaapiDevice)
 256                    }
 257
 0258                    if (_isVaapiDeviceSupportVulkanDrmModifier)
 259                    {
 0260                        _logger.LogInformation("VAAPI device {RenderNodePath} supports Vulkan DRM modifier", options.Vaa
 261                    }
 262
 0263                    if (_isVaapiDeviceSupportVulkanDrmInterop)
 264                    {
 0265                        _logger.LogInformation("VAAPI device {RenderNodePath} supports Vulkan DRM interop", options.Vaap
 266                    }
 267                }
 268
 269                // Check if VideoToolbox supports AV1 decode
 0270                if (OperatingSystem.IsMacOS() && SupportsHwaccel("videotoolbox"))
 271                {
 0272                    _isVideoToolboxAv1DecodeAvailable = validator.CheckIsVideoToolboxAv1DecodeAvailable();
 273                }
 274            }
 275
 0276            _logger.LogInformation("FFmpeg: {FfmpegPath}", _ffmpegPath ?? string.Empty);
 0277            return !string.IsNullOrWhiteSpace(ffmpegPath);
 278        }
 279
 280        /// <summary>
 281        /// Validates the supplied FQPN to ensure it is a ffmpeg utility.
 282        /// If checks pass, global variable FFmpegPath is updated.
 283        /// </summary>
 284        /// <param name="path">FQPN to test.</param>
 285        /// <returns><c>true</c> if the version validation succeeded; otherwise, <c>false</c>.</returns>
 286        private bool ValidatePath(string path)
 287        {
 0288            if (string.IsNullOrEmpty(path))
 289            {
 0290                return false;
 291            }
 292
 0293            bool rc = new EncoderValidator(_logger, path).ValidateVersion();
 0294            if (!rc)
 295            {
 0296                _logger.LogError("FFmpeg: Failed version check: {Path}", path);
 0297                return false;
 298            }
 299
 0300            _ffmpegPath = path;
 0301            return true;
 302        }
 303
 304        private string GetEncoderPathFromDirectory(string path, string filename, bool recursive = false)
 305        {
 306            try
 307            {
 0308                var files = _fileSystem.GetFilePaths(path, recursive);
 309
 0310                return files.FirstOrDefault(i => Path.GetFileNameWithoutExtension(i.AsSpan()).Equals(filename, StringCom
 0311                                                    && !Path.GetExtension(i.AsSpan()).Equals(".c", StringComparison.Ordi
 312            }
 0313            catch (Exception)
 314            {
 315                // Trap all exceptions, like DirNotExists, and return null
 0316                return null;
 317            }
 0318        }
 319
 320        public void SetAvailableEncoders(IEnumerable<string> list)
 321        {
 0322            _encoders = list.ToList();
 0323        }
 324
 325        public void SetAvailableDecoders(IEnumerable<string> list)
 326        {
 0327            _decoders = list.ToList();
 0328        }
 329
 330        public void SetAvailableHwaccels(IEnumerable<string> list)
 331        {
 0332            _hwaccels = list.ToList();
 0333        }
 334
 335        public void SetAvailableFilters(IEnumerable<string> list)
 336        {
 0337            _filters = list.ToList();
 0338        }
 339
 340        public void SetAvailableFiltersWithOption(IDictionary<int, bool> dict)
 341        {
 0342            _filtersWithOption = dict;
 0343        }
 344
 345        public void SetMediaEncoderVersion(EncoderValidator validator)
 346        {
 0347            _ffmpegVersion = validator.GetFFmpegVersion();
 0348        }
 349
 350        /// <inheritdoc />
 351        public bool SupportsEncoder(string encoder)
 352        {
 0353            return _encoders.Contains(encoder, StringComparer.OrdinalIgnoreCase);
 354        }
 355
 356        /// <inheritdoc />
 357        public bool SupportsDecoder(string decoder)
 358        {
 0359            return _decoders.Contains(decoder, StringComparer.OrdinalIgnoreCase);
 360        }
 361
 362        /// <inheritdoc />
 363        public bool SupportsHwaccel(string hwaccel)
 364        {
 0365            return _hwaccels.Contains(hwaccel, StringComparer.OrdinalIgnoreCase);
 366        }
 367
 368        /// <inheritdoc />
 369        public bool SupportsFilter(string filter)
 370        {
 0371            return _filters.Contains(filter, StringComparer.OrdinalIgnoreCase);
 372        }
 373
 374        /// <inheritdoc />
 375        public bool SupportsFilterWithOption(FilterOptionType option)
 376        {
 0377            if (_filtersWithOption.TryGetValue((int)option, out var val))
 378            {
 0379                return val;
 380            }
 381
 0382            return false;
 383        }
 384
 385        public bool CanEncodeToAudioCodec(string codec)
 386        {
 0387            if (string.Equals(codec, "opus", StringComparison.OrdinalIgnoreCase))
 388            {
 0389                codec = "libopus";
 390            }
 0391            else if (string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))
 392            {
 0393                codec = "libmp3lame";
 394            }
 395
 0396            return SupportsEncoder(codec);
 397        }
 398
 399        public bool CanEncodeToSubtitleCodec(string codec)
 400        {
 401            // TODO
 0402            return true;
 403        }
 404
 405        /// <inheritdoc />
 406        public Task<MediaInfo> GetMediaInfo(MediaInfoRequest request, CancellationToken cancellationToken)
 407        {
 0408            var extractChapters = request.MediaType == DlnaProfileType.Video && request.ExtractChapters;
 0409            var extraArgs = GetExtraArguments(request);
 410
 0411            return GetMediaInfoInternal(
 0412                GetInputArgument(request.MediaSource.Path, request.MediaSource),
 0413                request.MediaSource.Path,
 0414                request.MediaSource.Protocol,
 0415                extractChapters,
 0416                extraArgs,
 0417                request.MediaType == DlnaProfileType.Audio,
 0418                request.MediaSource.VideoType,
 0419                cancellationToken);
 420        }
 421
 422        internal string GetExtraArguments(MediaInfoRequest request)
 423        {
 1424            var ffmpegAnalyzeDuration = _config.GetFFmpegAnalyzeDuration() ?? string.Empty;
 1425            var ffmpegProbeSize = _config.GetFFmpegProbeSize() ?? string.Empty;
 1426            var analyzeDuration = string.Empty;
 1427            var extraArgs = string.Empty;
 428
 1429            if (request.MediaSource.AnalyzeDurationMs > 0)
 430            {
 0431                analyzeDuration = "-analyzeduration " + (request.MediaSource.AnalyzeDurationMs * 1000);
 432            }
 1433            else if (!string.IsNullOrEmpty(ffmpegAnalyzeDuration))
 434            {
 0435                analyzeDuration = "-analyzeduration " + ffmpegAnalyzeDuration;
 436            }
 437
 1438            if (!string.IsNullOrEmpty(analyzeDuration))
 439            {
 0440                extraArgs = analyzeDuration;
 441            }
 442
 1443            if (!string.IsNullOrEmpty(ffmpegProbeSize))
 444            {
 0445                extraArgs += " -probesize " + ffmpegProbeSize;
 446            }
 447
 1448            if (request.MediaSource.RequiredHttpHeaders.TryGetValue("User-Agent", out var userAgent))
 449            {
 1450                extraArgs += $" -user_agent \"{userAgent}\"";
 451            }
 452
 1453            if (request.MediaSource.Protocol == MediaProtocol.Rtsp)
 454            {
 0455                extraArgs += " -rtsp_transport tcp+udp -rtsp_flags prefer_tcp";
 456            }
 457
 1458            return extraArgs;
 459        }
 460
 461        /// <inheritdoc />
 462        public string GetInputArgument(IReadOnlyList<string> inputFiles, MediaSourceInfo mediaSource)
 463        {
 0464            return EncodingUtils.GetInputArgument("file", inputFiles, mediaSource.Protocol);
 465        }
 466
 467        /// <inheritdoc />
 468        public string GetInputArgument(string inputFile, MediaSourceInfo mediaSource)
 469        {
 0470            var prefix = "file";
 0471            if (mediaSource.IsoType == IsoType.BluRay)
 472            {
 0473                prefix = "bluray";
 474            }
 475
 0476            return EncodingUtils.GetInputArgument(prefix, new[] { inputFile }, mediaSource.Protocol);
 477        }
 478
 479        /// <inheritdoc />
 480        public string GetExternalSubtitleInputArgument(string inputFile)
 481        {
 482            const string Prefix = "file";
 483
 0484            return EncodingUtils.GetInputArgument(Prefix, new[] { inputFile }, MediaProtocol.File);
 485        }
 486
 487        /// <summary>
 488        /// Gets the media info internal.
 489        /// </summary>
 490        /// <returns>Task{MediaInfoResult}.</returns>
 491        private async Task<MediaInfo> GetMediaInfoInternal(
 492            string inputPath,
 493            string primaryPath,
 494            MediaProtocol protocol,
 495            bool extractChapters,
 496            string probeSizeArgument,
 497            bool isAudio,
 498            VideoType? videoType,
 499            CancellationToken cancellationToken)
 500        {
 501            var args = extractChapters
 502                ? "{0} -i {1} -threads {2} -v warning -print_format json -show_streams -show_chapters -show_format"
 503                : "{0} -i {1} -threads {2} -v warning -print_format json -show_streams -show_format";
 504            args = string.Format(CultureInfo.InvariantCulture, args, probeSizeArgument, inputPath, _threads).Trim();
 505
 506            var process = new Process
 507            {
 508                StartInfo = new ProcessStartInfo
 509                {
 510                    CreateNoWindow = true,
 511                    UseShellExecute = false,
 512
 513                    // Must consume both or ffmpeg may hang due to deadlocks.
 514                    RedirectStandardOutput = true,
 515
 516                    FileName = _ffprobePath,
 517                    Arguments = args,
 518
 519                    WindowStyle = ProcessWindowStyle.Hidden,
 520                    ErrorDialog = false,
 521                },
 522                EnableRaisingEvents = true
 523            };
 524
 525            _logger.LogInformation("Starting {ProcessFileName} with args {ProcessArgs}", _ffprobePath, args);
 526
 527            var memoryStream = new MemoryStream();
 528            await using (memoryStream.ConfigureAwait(false))
 529            using (var processWrapper = new ProcessWrapper(process, this))
 530            {
 531                StartProcess(processWrapper);
 532                using var reader = process.StandardOutput;
 533                await reader.BaseStream.CopyToAsync(memoryStream, cancellationToken).ConfigureAwait(false);
 534                memoryStream.Seek(0, SeekOrigin.Begin);
 535                InternalMediaInfoResult result;
 536                try
 537                {
 538                    result = await JsonSerializer.DeserializeAsync<InternalMediaInfoResult>(
 539                                        memoryStream,
 540                                        _jsonSerializerOptions,
 541                                        cancellationToken).ConfigureAwait(false);
 542                }
 543                catch
 544                {
 545                    StopProcess(processWrapper, 100);
 546
 547                    throw;
 548                }
 549
 550                if (result is null || (result.Streams is null && result.Format is null))
 551                {
 552                    throw new FfmpegException("ffprobe failed - streams and format are both null.");
 553                }
 554
 555                if (result.Streams is not null)
 556                {
 557                    // Normalize aspect ratio if invalid
 558                    foreach (var stream in result.Streams)
 559                    {
 560                        if (string.Equals(stream.DisplayAspectRatio, "0:1", StringComparison.OrdinalIgnoreCase))
 561                        {
 562                            stream.DisplayAspectRatio = string.Empty;
 563                        }
 564
 565                        if (string.Equals(stream.SampleAspectRatio, "0:1", StringComparison.OrdinalIgnoreCase))
 566                        {
 567                            stream.SampleAspectRatio = string.Empty;
 568                        }
 569                    }
 570                }
 571
 572                return new ProbeResultNormalizer(_logger, _localization).GetMediaInfo(result, videoType, isAudio, primar
 573            }
 574        }
 575
 576        /// <inheritdoc />
 577        public Task<string> ExtractAudioImage(string path, int? imageStreamIndex, CancellationToken cancellationToken)
 578        {
 0579            var mediaSource = new MediaSourceInfo
 0580            {
 0581                Protocol = MediaProtocol.File
 0582            };
 583
 0584            return ExtractImage(path, null, null, imageStreamIndex, mediaSource, true, null, null, ImageFormat.Jpg, canc
 585        }
 586
 587        /// <inheritdoc />
 588        public Task<string> ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStre
 589        {
 0590            return ExtractImage(inputFile, container, videoStream, null, mediaSource, false, threedFormat, offset, Image
 591        }
 592
 593        /// <inheritdoc />
 594        public Task<string> ExtractVideoImage(string inputFile, string container, MediaSourceInfo mediaSource, MediaStre
 595        {
 0596            return ExtractImage(inputFile, container, imageStream, imageStreamIndex, mediaSource, false, null, null, tar
 597        }
 598
 599        private async Task<string> ExtractImage(
 600            string inputFile,
 601            string container,
 602            MediaStream videoStream,
 603            int? imageStreamIndex,
 604            MediaSourceInfo mediaSource,
 605            bool isAudio,
 606            Video3DFormat? threedFormat,
 607            TimeSpan? offset,
 608            ImageFormat? targetFormat,
 609            CancellationToken cancellationToken)
 610        {
 611            var inputArgument = GetInputPathArgument(inputFile, mediaSource);
 612
 613            if (!isAudio)
 614            {
 615                try
 616                {
 617                    return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFor
 618                }
 619                catch (ArgumentException)
 620                {
 621                    throw;
 622                }
 623                catch (Exception ex)
 624                {
 625                    _logger.LogError(ex, "I-frame image extraction failed, will attempt standard way. Input: {Arguments}
 626                }
 627            }
 628
 629            return await ExtractImageInternal(inputArgument, container, videoStream, imageStreamIndex, threedFormat, off
 630        }
 631
 632        private string GetImageResolutionParameter()
 633        {
 0634            var imageResolutionParameter = _serverConfig.Configuration.ChapterImageResolution switch
 0635            {
 0636                ImageResolution.P144 => "256x144",
 0637                ImageResolution.P240 => "426x240",
 0638                ImageResolution.P360 => "640x360",
 0639                ImageResolution.P480 => "854x480",
 0640                ImageResolution.P720 => "1280x720",
 0641                ImageResolution.P1080 => "1920x1080",
 0642                ImageResolution.P1440 => "2560x1440",
 0643                ImageResolution.P2160 => "3840x2160",
 0644                _ => string.Empty
 0645            };
 646
 0647            if (!string.IsNullOrEmpty(imageResolutionParameter))
 648            {
 0649                imageResolutionParameter = " -s " + imageResolutionParameter;
 650            }
 651
 0652            return imageResolutionParameter;
 653        }
 654
 655        private async Task<string> ExtractImageInternal(
 656            string inputPath,
 657            string container,
 658            MediaStream videoStream,
 659            int? imageStreamIndex,
 660            Video3DFormat? threedFormat,
 661            TimeSpan? offset,
 662            bool useIFrame,
 663            ImageFormat? targetFormat,
 664            bool isAudio,
 665            CancellationToken cancellationToken)
 666        {
 667            ArgumentException.ThrowIfNullOrEmpty(inputPath);
 668
 669            var useTradeoff = _config.GetFFmpegImgExtractPerfTradeoff();
 670
 671            var outputExtension = targetFormat?.GetExtension() ?? ".jpg";
 672
 673            var tempExtractPath = Path.Combine(_configurationManager.ApplicationPaths.TempDirectory, Guid.NewGuid() + ou
 674            Directory.CreateDirectory(Path.GetDirectoryName(tempExtractPath));
 675
 676            // deint -> scale -> thumbnail -> tonemap.
 677            // put the SW tonemap right after the thumbnail to do it only once to reduce cpu usage.
 678            var filters = new List<string>();
 679
 680            // deinterlace using bwdif algorithm for video stream.
 681            if (videoStream is not null && videoStream.IsInterlaced)
 682            {
 683                filters.Add("bwdif=0:-1:0");
 684            }
 685
 686            // apply some filters to thumbnail extracted below (below) crop any black lines that we made and get the cor
 687            // This filter chain may have adverse effects on recorded tv thumbnails if ar changes during presentation ex
 688            var scaler = threedFormat switch
 689            {
 690                // hsbs crop width in half,scale to correct size, set the display aspect,crop out any black bars we may 
 691                Video3DFormat.HalfSideBySide => @"crop=iw/2:ih:0:0,scale=(iw*2):ih,setdar=dar=a,crop=min(iw\,ih*dar):min
 692                // fsbs crop width in half,set the display aspect,crop out any black bars we may have made
 693                Video3DFormat.FullSideBySide => @"crop=iw/2:ih:0:0,setdar=dar=a,crop=min(iw\,ih*dar):min(ih\,iw/dar):(iw
 694                // htab crop height in half,scale to correct size, set the display aspect,crop out any black bars we may
 695                Video3DFormat.HalfTopAndBottom => @"crop=iw:ih/2:0:0,scale=(iw*2):ih),setdar=dar=a,crop=min(iw\,ih*dar):
 696                // ftab crop height in half, set the display aspect,crop out any black bars we may have made
 697                Video3DFormat.FullTopAndBottom => @"crop=iw:ih/2:0:0,setdar=dar=a,crop=min(iw\,ih*dar):min(ih\,iw/dar):(
 698                _ => "scale=round(iw*sar/2)*2:round(ih/2)*2"
 699            };
 700
 701            filters.Add(scaler);
 702
 703            // Use ffmpeg to sample 100 (we can drop this if required using thumbnail=50 for 50 frames) frames and pick 
 704            // mpegts need larger batch size otherwise the corrupted thumbnail will be created. Larger batch size will l
 705            var enableThumbnail = !useTradeoff && useIFrame && !string.Equals("wtv", container, StringComparison.Ordinal
 706            if (enableThumbnail)
 707            {
 708                var useLargerBatchSize = string.Equals("mpegts", container, StringComparison.OrdinalIgnoreCase);
 709                filters.Add("thumbnail=n=" + (useLargerBatchSize ? "50" : "24"));
 710            }
 711
 712            // Use SW tonemap on HDR video stream only when the zscale or tonemapx filter is available.
 713            // Only enable Dolby Vision tonemap when tonemapx is available
 714            var enableHdrExtraction = false;
 715
 716            if (videoStream?.VideoRange == VideoRange.HDR)
 717            {
 718                if (SupportsFilter("tonemapx"))
 719                {
 720                    var peak = videoStream.VideoRangeType == VideoRangeType.DOVI ? "400" : "100";
 721                    enableHdrExtraction = true;
 722                    filters.Add($"tonemapx=tonemap=bt2390:desat=0:peak={peak}:t=bt709:m=bt709:p=bt709:format=yuv420p");
 723                }
 724                else if (SupportsFilter("zscale") && videoStream.VideoRangeType != VideoRangeType.DOVI)
 725                {
 726                    enableHdrExtraction = true;
 727                    filters.Add("zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap=hable:desat=0:p
 728                }
 729            }
 730
 731            var vf = string.Join(',', filters);
 732            var mapArg = imageStreamIndex.HasValue ? (" -map 0:" + imageStreamIndex.Value.ToString(CultureInfo.Invariant
 733            var args = string.Format(CultureInfo.InvariantCulture, "-i {0}{3} -threads {4} -v quiet -vframes 1 -vf {2}{5
 734
 735            if (offset.HasValue)
 736            {
 737                args = string.Format(CultureInfo.InvariantCulture, "-ss {0} ", GetTimeParameter(offset.Value)) + args;
 738            }
 739
 740            if (useIFrame && useTradeoff)
 741            {
 742                args = "-skip_frame nokey " + args;
 743            }
 744
 745            if (!string.IsNullOrWhiteSpace(container))
 746            {
 747                var inputFormat = EncodingHelper.GetInputFormat(container);
 748                if (!string.IsNullOrWhiteSpace(inputFormat))
 749                {
 750                    args = "-f " + inputFormat + " " + args;
 751                }
 752            }
 753
 754            var process = new Process
 755            {
 756                StartInfo = new ProcessStartInfo
 757                {
 758                    CreateNoWindow = true,
 759                    UseShellExecute = false,
 760                    FileName = _ffmpegPath,
 761                    Arguments = args,
 762                    WindowStyle = ProcessWindowStyle.Hidden,
 763                    ErrorDialog = false,
 764                },
 765                EnableRaisingEvents = true
 766            };
 767
 768            _logger.LogDebug("{ProcessFileName} {ProcessArguments}", process.StartInfo.FileName, process.StartInfo.Argum
 769
 770            using (var processWrapper = new ProcessWrapper(process, this))
 771            {
 772                using (await _thumbnailResourcePool.LockAsync(cancellationToken).ConfigureAwait(false))
 773                {
 774                    StartProcess(processWrapper);
 775
 776                    var timeoutMs = _configurationManager.Configuration.ImageExtractionTimeoutMs;
 777                    if (timeoutMs <= 0)
 778                    {
 779                        timeoutMs = enableHdrExtraction ? DefaultHdrImageExtractionTimeout : DefaultSdrImageExtractionTi
 780                    }
 781
 782                    try
 783                    {
 784                        await process.WaitForExitAsync(TimeSpan.FromMilliseconds(timeoutMs)).ConfigureAwait(false);
 785                    }
 786                    catch (OperationCanceledException ex)
 787                    {
 788                        process.Kill(true);
 789                        throw new FfmpegException(string.Format(CultureInfo.InvariantCulture, "ffmpeg image extraction t
 790                    }
 791                }
 792
 793                var file = _fileSystem.GetFileInfo(tempExtractPath);
 794
 795                if (processWrapper.ExitCode > 0 || !file.Exists || file.Length == 0)
 796                {
 797                    throw new FfmpegException(string.Format(CultureInfo.InvariantCulture, "ffmpeg image extraction faile
 798                }
 799
 800                return tempExtractPath;
 801            }
 802        }
 803
 804        /// <inheritdoc />
 805        public Task<string> ExtractVideoImagesOnIntervalAccelerated(
 806            string inputFile,
 807            string container,
 808            MediaSourceInfo mediaSource,
 809            MediaStream imageStream,
 810            int maxWidth,
 811            TimeSpan interval,
 812            bool allowHwAccel,
 813            bool enableHwEncoding,
 814            int? threads,
 815            int? qualityScale,
 816            ProcessPriorityClass? priority,
 817            bool enableKeyFrameOnlyExtraction,
 818            EncodingHelper encodingHelper,
 819            CancellationToken cancellationToken)
 820        {
 0821            var options = allowHwAccel ? _configurationManager.GetEncodingOptions() : new EncodingOptions();
 0822            threads ??= _threads;
 823
 0824            if (allowHwAccel && enableKeyFrameOnlyExtraction)
 825            {
 0826                var hardwareAccelerationType = options.HardwareAccelerationType;
 0827                var supportsKeyFrameOnly = (hardwareAccelerationType == HardwareAccelerationType.nvenc && options.Enable
 0828                                           || (hardwareAccelerationType == HardwareAccelerationType.amf && OperatingSyst
 0829                                           || (hardwareAccelerationType == HardwareAccelerationType.qsv && options.Prefe
 0830                                           || hardwareAccelerationType == HardwareAccelerationType.vaapi
 0831                                           || hardwareAccelerationType == HardwareAccelerationType.videotoolbox
 0832                                           || hardwareAccelerationType == HardwareAccelerationType.rkmpp;
 0833                if (!supportsKeyFrameOnly)
 834                {
 835                    // Disable hardware acceleration when the hardware decoder does not support keyframe only mode.
 0836                    allowHwAccel = false;
 0837                    options = new EncodingOptions();
 838                }
 839            }
 840
 841            // A new EncodingOptions instance must be used as to not disable HW acceleration for all of Jellyfin.
 842            // Additionally, we must set a few fields without defaults to prevent null pointer exceptions.
 0843            if (!allowHwAccel)
 844            {
 0845                options.EnableHardwareEncoding = false;
 0846                options.HardwareAccelerationType = HardwareAccelerationType.none;
 0847                options.EnableTonemapping = false;
 848            }
 849
 0850            if (imageStream.Width is not null && imageStream.Height is not null && !string.IsNullOrEmpty(imageStream.Asp
 851            {
 852                // For hardware trickplay encoders, we need to re-calculate the size because they used fixed scale dimen
 0853                var darParts = imageStream.AspectRatio.Split(':');
 0854                var (wa, ha) = (double.Parse(darParts[0], CultureInfo.InvariantCulture), double.Parse(darParts[1], Cultu
 855                // When dimension / DAR does not equal to 1:1, then the frames are most likely stored stretched.
 856                // Note: this might be incorrect for 3D videos as the SAR stored might be per eye instead of per video, 
 0857                var shouldResetHeight = Math.Abs((imageStream.Width.Value * ha) - (imageStream.Height.Value * wa)) > .05
 0858                if (shouldResetHeight)
 859                {
 860                    // SAR = DAR * Height / Width
 861                    // RealHeight = Height / SAR = Height / (DAR * Height / Width) = Width / DAR
 0862                    imageStream.Height = Convert.ToInt32(imageStream.Width.Value * ha / wa);
 863                }
 864            }
 865
 0866            var baseRequest = new BaseEncodingJobOptions { MaxWidth = maxWidth, MaxFramerate = (float)(1.0 / interval.To
 0867            var jobState = new EncodingJobInfo(TranscodingJobType.Progressive)
 0868            {
 0869                IsVideoRequest = true,  // must be true for InputVideoHwaccelArgs to return non-empty value
 0870                MediaSource = mediaSource,
 0871                VideoStream = imageStream,
 0872                BaseRequest = baseRequest,  // GetVideoProcessingFilterParam errors if null
 0873                MediaPath = inputFile,
 0874                OutputVideoCodec = "mjpeg"
 0875            };
 0876            var vidEncoder = enableHwEncoding ? encodingHelper.GetVideoEncoder(jobState, options) : jobState.OutputVideo
 877
 878            // Get input and filter arguments
 0879            var inputArg = encodingHelper.GetInputArgument(jobState, options, container).Trim();
 0880            if (string.IsNullOrWhiteSpace(inputArg))
 881            {
 0882                throw new InvalidOperationException("EncodingHelper returned empty input arguments.");
 883            }
 884
 0885            if (!allowHwAccel)
 886            {
 0887                inputArg = "-threads " + threads + " " + inputArg; // HW accel args set a different input thread count, 
 888            }
 889
 0890            if (options.HardwareAccelerationType == HardwareAccelerationType.videotoolbox && _isLowPriorityHwDecodeSuppo
 891            {
 892                // VideoToolbox supports low priority decoding, which is useful for trickplay
 0893                inputArg = "-hwaccel_flags +low_priority " + inputArg;
 894            }
 895
 0896            if (enableKeyFrameOnlyExtraction)
 897            {
 0898                inputArg = "-skip_frame nokey " + inputArg;
 899            }
 900
 0901            var filterParam = encodingHelper.GetVideoProcessingFilterParam(jobState, options, vidEncoder).Trim();
 0902            if (string.IsNullOrWhiteSpace(filterParam))
 903            {
 0904                throw new InvalidOperationException("EncodingHelper returned empty or invalid filter parameters.");
 905            }
 906
 0907            return ExtractVideoImagesOnIntervalInternal(inputArg, filterParam, vidEncoder, threads, qualityScale, priori
 908        }
 909
 910        private async Task<string> ExtractVideoImagesOnIntervalInternal(
 911            string inputArg,
 912            string filterParam,
 913            string vidEncoder,
 914            int? outputThreads,
 915            int? qualityScale,
 916            ProcessPriorityClass? priority,
 917            CancellationToken cancellationToken)
 918        {
 919            if (string.IsNullOrWhiteSpace(inputArg))
 920            {
 921                throw new InvalidOperationException("Empty or invalid input argument.");
 922            }
 923
 924            // ffmpeg qscale is a value from 1-31, with 1 being best quality and 31 being worst
 925            // jpeg quality is a value from 0-100, with 0 being worst quality and 100 being best
 926            var encoderQuality = Math.Clamp(qualityScale ?? 4, 1, 31);
 927            var encoderQualityOption = "-qscale:v ";
 928
 929            if (vidEncoder.Contains("vaapi", StringComparison.OrdinalIgnoreCase)
 930                || vidEncoder.Contains("qsv", StringComparison.OrdinalIgnoreCase))
 931            {
 932                // vaapi and qsv's mjpeg encoder use jpeg quality as input, instead of ffmpeg defined qscale
 933                encoderQuality = 100 - ((encoderQuality - 1) * (100 / 30));
 934                encoderQualityOption = "-global_quality:v ";
 935            }
 936
 937            if (vidEncoder.Contains("videotoolbox", StringComparison.OrdinalIgnoreCase))
 938            {
 939                // videotoolbox's mjpeg encoder uses jpeg quality scaled to QP2LAMBDA (118) instead of ffmpeg defined qs
 940                encoderQuality = 118 - ((encoderQuality - 1) * (118 / 30));
 941            }
 942
 943            if (vidEncoder.Contains("rkmpp", StringComparison.OrdinalIgnoreCase))
 944            {
 945                // rkmpp's mjpeg encoder uses jpeg quality as input (max is 99, not 100), instead of ffmpeg defined qsca
 946                encoderQuality = 99 - ((encoderQuality - 1) * (99 / 30));
 947                encoderQualityOption = "-qp_init:v ";
 948            }
 949
 950            // Output arguments
 951            var targetDirectory = Path.Combine(_configurationManager.ApplicationPaths.TempDirectory, Guid.NewGuid().ToSt
 952            Directory.CreateDirectory(targetDirectory);
 953            var outputPath = Path.Combine(targetDirectory, "%08d.jpg");
 954
 955            // Final command arguments
 956            var args = string.Format(
 957                CultureInfo.InvariantCulture,
 958                "-loglevel error {0} -an -sn {1} -threads {2} -c:v {3} {4}{5}{6}-f {7} \"{8}\"",
 959                inputArg,
 960                filterParam,
 961                outputThreads.GetValueOrDefault(_threads),
 962                vidEncoder,
 963                encoderQualityOption + encoderQuality + " ",
 964                vidEncoder.Contains("videotoolbox", StringComparison.InvariantCultureIgnoreCase) ? "-allow_sw 1 " : stri
 965                EncodingHelper.GetVideoSyncOption("0", EncoderVersion).Trim() + " ", // passthrough timestamp
 966                "image2",
 967                outputPath);
 968
 969            // Start ffmpeg process
 970            var process = new Process
 971            {
 972                StartInfo = new ProcessStartInfo
 973                {
 974                    CreateNoWindow = true,
 975                    UseShellExecute = false,
 976                    FileName = _ffmpegPath,
 977                    Arguments = args,
 978                    WindowStyle = ProcessWindowStyle.Hidden,
 979                    ErrorDialog = false,
 980                },
 981                EnableRaisingEvents = true
 982            };
 983
 984            var processDescription = string.Format(CultureInfo.InvariantCulture, "{0} {1}", process.StartInfo.FileName, 
 985            _logger.LogInformation("Trickplay generation: {ProcessDescription}", processDescription);
 986
 987            using (var processWrapper = new ProcessWrapper(process, this))
 988            {
 989                bool ranToCompletion = false;
 990
 991                using (await _thumbnailResourcePool.LockAsync(cancellationToken).ConfigureAwait(false))
 992                {
 993                    StartProcess(processWrapper);
 994
 995                    // Set process priority
 996                    if (priority.HasValue)
 997                    {
 998                        try
 999                        {
 1000                            processWrapper.Process.PriorityClass = priority.Value;
 1001                        }
 1002                        catch (Exception ex)
 1003                        {
 1004                            _logger.LogDebug(ex, "Unable to set process priority to {Priority} for {Description}", prior
 1005                        }
 1006                    }
 1007
 1008                    // Need to give ffmpeg enough time to make all the thumbnails, which could be a while,
 1009                    // but we still need to detect if the process hangs.
 1010                    // Making the assumption that as long as new jpegs are showing up, everything is good.
 1011
 1012                    bool isResponsive = true;
 1013                    int lastCount = 0;
 1014                    var timeoutMs = _configurationManager.Configuration.ImageExtractionTimeoutMs;
 1015                    timeoutMs = timeoutMs <= 0 ? DefaultHdrImageExtractionTimeout : timeoutMs;
 1016
 1017                    while (isResponsive && !cancellationToken.IsCancellationRequested)
 1018                    {
 1019                        try
 1020                        {
 1021                            await process.WaitForExitAsync(TimeSpan.FromMilliseconds(timeoutMs)).ConfigureAwait(false);
 1022
 1023                            ranToCompletion = true;
 1024                            break;
 1025                        }
 1026                        catch (OperationCanceledException)
 1027                        {
 1028                            // We don't actually expect the process to be finished in one timeout span, just that one im
 1029                        }
 1030
 1031                        var jpegCount = _fileSystem.GetFilePaths(targetDirectory).Count();
 1032
 1033                        isResponsive = jpegCount > lastCount;
 1034                        lastCount = jpegCount;
 1035                    }
 1036
 1037                    if (!ranToCompletion)
 1038                    {
 1039                        if (!isResponsive)
 1040                        {
 1041                            _logger.LogInformation("Trickplay process unresponsive.");
 1042                        }
 1043
 1044                        _logger.LogInformation("Stopping trickplay extraction.");
 1045                        StopProcess(processWrapper, 1000);
 1046                    }
 1047                }
 1048
 1049                var exitCode = ranToCompletion ? processWrapper.ExitCode ?? 0 : -1;
 1050
 1051                if (exitCode == -1)
 1052                {
 1053                    _logger.LogError("ffmpeg image extraction failed for {ProcessDescription}", processDescription);
 1054                    // Cleanup temp folder here, because the targetDirectory is not returned and the cleanup for failed 
 1055                    // Ideally the ffmpeg should not write any files if it fails, but it seems like it is not guaranteed
 1056                    try
 1057                    {
 1058                        Directory.Delete(targetDirectory, true);
 1059                    }
 1060                    catch (Exception e)
 1061                    {
 1062                        _logger.LogError(e, "Failed to delete ffmpeg temp directory {TargetDirectory}", targetDirectory)
 1063                    }
 1064
 1065                    throw new FfmpegException(string.Format(CultureInfo.InvariantCulture, "ffmpeg image extraction faile
 1066                }
 1067
 1068                return targetDirectory;
 1069            }
 1070        }
 1071
 1072        public string GetTimeParameter(long ticks)
 1073        {
 01074            var time = TimeSpan.FromTicks(ticks);
 1075
 01076            return GetTimeParameter(time);
 1077        }
 1078
 1079        public string GetTimeParameter(TimeSpan time)
 1080        {
 01081            return time.ToString(@"hh\:mm\:ss\.fff", CultureInfo.InvariantCulture);
 1082        }
 1083
 1084        private void StartProcess(ProcessWrapper process)
 1085        {
 01086            process.Process.Start();
 1087
 1088            lock (_runningProcessesLock)
 1089            {
 01090                _runningProcesses.Add(process);
 01091            }
 01092        }
 1093
 1094        private void StopProcess(ProcessWrapper process, int waitTimeMs)
 1095        {
 1096            try
 1097            {
 01098                if (process.Process.WaitForExit(waitTimeMs))
 1099                {
 01100                    return;
 1101                }
 1102
 01103                _logger.LogInformation("Killing ffmpeg process");
 1104
 01105                process.Process.Kill();
 01106            }
 01107            catch (InvalidOperationException)
 1108            {
 1109                // The process has already exited or
 1110                // there is no process associated with this Process object.
 01111            }
 01112            catch (Exception ex)
 1113            {
 01114                _logger.LogError(ex, "Error killing process");
 01115            }
 01116        }
 1117
 1118        private void StopProcesses()
 211119        {
 1120            List<ProcessWrapper> processes;
 1121            lock (_runningProcessesLock)
 1122            {
 211123                processes = _runningProcesses.ToList();
 211124                _runningProcesses.Clear();
 211125            }
 1126
 421127            foreach (var process in processes)
 1128            {
 01129                if (!process.HasExited)
 1130                {
 01131                    StopProcess(process, 500);
 1132                }
 1133            }
 211134        }
 1135
 1136        public string EscapeSubtitleFilterPath(string path)
 1137        {
 1138            // https://ffmpeg.org/ffmpeg-filters.html#Notes-on-filtergraph-escaping
 1139            // We need to double escape
 1140
 01141            return path
 01142                .Replace('\\', '/')
 01143                .Replace(":", "\\:", StringComparison.Ordinal)
 01144                .Replace("'", @"'\\\''", StringComparison.Ordinal)
 01145                .Replace("\"", "\\\"", StringComparison.Ordinal);
 1146        }
 1147
 1148        /// <inheritdoc />
 1149        public void Dispose()
 1150        {
 211151            Dispose(true);
 211152            GC.SuppressFinalize(this);
 211153        }
 1154
 1155        /// <summary>
 1156        /// Releases unmanaged and - optionally - managed resources.
 1157        /// </summary>
 1158        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release o
 1159        protected virtual void Dispose(bool dispose)
 1160        {
 211161            if (dispose)
 1162            {
 211163                StopProcesses();
 211164                _thumbnailResourcePool.Dispose();
 1165            }
 211166        }
 1167
 1168        /// <inheritdoc />
 1169        public Task ConvertImage(string inputPath, string outputPath)
 1170        {
 01171            throw new NotImplementedException();
 1172        }
 1173
 1174        /// <inheritdoc />
 1175        public IReadOnlyList<string> GetPrimaryPlaylistVobFiles(string path, uint? titleNumber)
 1176        {
 1177            // Eliminate menus and intros by omitting VIDEO_TS.VOB and all subsequent title .vob files ending with _0.VO
 01178            var allVobs = _fileSystem.GetFiles(path, true)
 01179                .Where(file => string.Equals(file.Extension, ".VOB", StringComparison.OrdinalIgnoreCase))
 01180                .Where(file => !string.Equals(file.Name, "VIDEO_TS.VOB", StringComparison.OrdinalIgnoreCase))
 01181                .Where(file => !file.Name.EndsWith("_0.VOB", StringComparison.OrdinalIgnoreCase))
 01182                .OrderBy(i => i.FullName)
 01183                .ToList();
 1184
 01185            if (titleNumber.HasValue)
 1186            {
 01187                var prefix = string.Format(CultureInfo.InvariantCulture, "VTS_{0:D2}_", titleNumber.Value);
 01188                var vobs = allVobs.Where(i => i.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)).ToList();
 1189
 01190                if (vobs.Count > 0)
 1191                {
 01192                    return vobs.Select(i => i.FullName).ToList();
 1193                }
 1194
 01195                _logger.LogWarning("Could not determine .vob files for title {Title} of {Path}.", titleNumber, path);
 1196            }
 1197
 1198            // Check for multiple big titles (> 900 MB)
 01199            var titles = allVobs
 01200                .Where(vob => vob.Length >= 900 * 1024 * 1024)
 01201                .Select(vob => _fileSystem.GetFileNameWithoutExtension(vob).AsSpan().RightPart('_').ToString())
 01202                .Distinct()
 01203                .ToList();
 1204
 1205            // Fall back to first title if no big title is found
 01206            if (titles.Count == 0)
 1207            {
 01208                titles.Add(_fileSystem.GetFileNameWithoutExtension(allVobs[0]).AsSpan().RightPart('_').ToString());
 1209            }
 1210
 1211            // Aggregate all .vob files of the titles
 01212            return allVobs
 01213                .Where(vob => titles.Contains(_fileSystem.GetFileNameWithoutExtension(vob).AsSpan().RightPart('_').ToStr
 01214                .Select(i => i.FullName)
 01215                .Order()
 01216                .ToList();
 1217        }
 1218
 1219        /// <inheritdoc />
 1220        public IReadOnlyList<string> GetPrimaryPlaylistM2tsFiles(string path)
 01221            => _blurayExaminer.GetDiscInfo(path).Files;
 1222
 1223        /// <inheritdoc />
 1224        public string GetInputPathArgument(EncodingJobInfo state)
 01225            => GetInputPathArgument(state.MediaPath, state.MediaSource);
 1226
 1227        /// <inheritdoc />
 1228        public string GetInputPathArgument(string path, MediaSourceInfo mediaSource)
 1229        {
 01230            return mediaSource.VideoType switch
 01231            {
 01232                VideoType.Dvd => GetInputArgument(GetPrimaryPlaylistVobFiles(path, null), mediaSource),
 01233                VideoType.BluRay => GetInputArgument(GetPrimaryPlaylistM2tsFiles(path), mediaSource),
 01234                _ => GetInputArgument(path, mediaSource)
 01235            };
 1236        }
 1237
 1238        /// <inheritdoc />
 1239        public void GenerateConcatConfig(MediaSourceInfo source, string concatFilePath)
 1240        {
 1241            // Get all playable files
 1242            IReadOnlyList<string> files;
 01243            var videoType = source.VideoType;
 01244            if (videoType == VideoType.Dvd)
 1245            {
 01246                files = GetPrimaryPlaylistVobFiles(source.Path, null);
 1247            }
 01248            else if (videoType == VideoType.BluRay)
 1249            {
 01250                files = GetPrimaryPlaylistM2tsFiles(source.Path);
 1251            }
 1252            else
 1253            {
 01254                return;
 1255            }
 1256
 1257            // Generate concat configuration entries for each file and write to file
 01258            Directory.CreateDirectory(Path.GetDirectoryName(concatFilePath));
 01259            using var sw = new FormattingStreamWriter(concatFilePath, CultureInfo.InvariantCulture);
 01260            foreach (var path in files)
 1261            {
 01262                var mediaInfoResult = GetMediaInfo(
 01263                    new MediaInfoRequest
 01264                    {
 01265                        MediaType = DlnaProfileType.Video,
 01266                        MediaSource = new MediaSourceInfo
 01267                        {
 01268                            Path = path,
 01269                            Protocol = MediaProtocol.File,
 01270                            VideoType = videoType
 01271                        }
 01272                    },
 01273                    CancellationToken.None).GetAwaiter().GetResult();
 1274
 01275                var duration = TimeSpan.FromTicks(mediaInfoResult.RunTimeTicks.Value).TotalSeconds;
 1276
 1277                // Add file path stanza to concat configuration
 01278                sw.WriteLine("file '{0}'", path.Replace("'", @"'\''", StringComparison.Ordinal));
 1279
 1280                // Add duration stanza to concat configuration
 01281                sw.WriteLine("duration {0}", duration);
 1282            }
 01283        }
 1284
 1285        public bool CanExtractSubtitles(string codec)
 1286        {
 1287            // TODO is there ever a case when a subtitle can't be extracted??
 01288            return true;
 1289        }
 1290
 1291        private sealed class ProcessWrapper : IDisposable
 1292        {
 1293            private readonly MediaEncoder _mediaEncoder;
 1294
 1295            private bool _disposed = false;
 1296
 1297            public ProcessWrapper(Process process, MediaEncoder mediaEncoder)
 1298            {
 1299                Process = process;
 01300                _mediaEncoder = mediaEncoder;
 01301                Process.Exited += OnProcessExited;
 01302            }
 1303
 1304            public Process Process { get; }
 1305
 1306            public bool HasExited { get; private set; }
 1307
 1308            public int? ExitCode { get; private set; }
 1309
 1310            private void OnProcessExited(object sender, EventArgs e)
 1311            {
 01312                var process = (Process)sender;
 1313
 01314                HasExited = true;
 1315
 1316                try
 1317                {
 01318                    ExitCode = process.ExitCode;
 01319                }
 01320                catch
 1321                {
 01322                }
 1323
 01324                DisposeProcess(process);
 01325            }
 1326
 1327            private void DisposeProcess(Process process)
 01328            {
 1329                lock (_mediaEncoder._runningProcessesLock)
 1330                {
 01331                    _mediaEncoder._runningProcesses.Remove(this);
 01332                }
 1333
 01334                process.Dispose();
 01335            }
 1336
 1337            public void Dispose()
 1338            {
 01339                if (!_disposed)
 1340                {
 01341                    if (Process is not null)
 1342                    {
 01343                        Process.Exited -= OnProcessExited;
 01344                        DisposeProcess(Process);
 1345                    }
 1346                }
 1347
 01348                _disposed = true;
 01349            }
 1350        }
 1351    }
 1352}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:22 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.Extensions.Logging.ILogger`1<MediaBrowser.MediaEncoding.Encoder.MediaEncoder>,MediaBrowser.Controller.Configuration.IServerConfigurationManager,MediaBrowser.Model.IO.IFileSystem,MediaBrowser.Model.MediaInfo.IBlurayExaminer,MediaBrowser.Model.Globalization.ILocalizationManager,Microsoft.Extensions.Configuration.IConfiguration,MediaBrowser.Controller.Configuration.IServerConfigurationManager)
.cctor()
get_EncoderPath()
get_ProbePath()
get_EncoderVersion()
get_IsPkeyPauseSupported()
get_IsVaapiDeviceAmd()
get_IsVaapiDeviceInteliHD()
get_IsVaapiDeviceInteli965()
get_IsVaapiDeviceSupportVulkanDrmModifier()
get_IsVaapiDeviceSupportVulkanDrmInterop()
get_IsVideoToolboxAv1DecodeAvailable()
SetFFmpegPath()
ValidatePath(System.String)
GetEncoderPathFromDirectory(System.String,System.String,System.Boolean)
SetAvailableEncoders(System.Collections.Generic.IEnumerable`1<System.String>)
SetAvailableDecoders(System.Collections.Generic.IEnumerable`1<System.String>)
SetAvailableHwaccels(System.Collections.Generic.IEnumerable`1<System.String>)
SetAvailableFilters(System.Collections.Generic.IEnumerable`1<System.String>)
SetAvailableFiltersWithOption(System.Collections.Generic.IDictionary`2<System.Int32,System.Boolean>)
SetMediaEncoderVersion(MediaBrowser.MediaEncoding.Encoder.EncoderValidator)
SupportsEncoder(System.String)
SupportsDecoder(System.String)
SupportsHwaccel(System.String)
SupportsFilter(System.String)
SupportsFilterWithOption(MediaBrowser.Controller.MediaEncoding.FilterOptionType)
CanEncodeToAudioCodec(System.String)
CanEncodeToSubtitleCodec(System.String)
GetMediaInfo(MediaBrowser.Controller.MediaEncoding.MediaInfoRequest,System.Threading.CancellationToken)
GetExtraArguments(MediaBrowser.Controller.MediaEncoding.MediaInfoRequest)
GetInputArgument(System.Collections.Generic.IReadOnlyList`1<System.String>,MediaBrowser.Model.Dto.MediaSourceInfo)
GetInputArgument(System.String,MediaBrowser.Model.Dto.MediaSourceInfo)
GetExternalSubtitleInputArgument(System.String)
ExtractAudioImage(System.String,System.Nullable`1<System.Int32>,System.Threading.CancellationToken)
ExtractVideoImage(System.String,System.String,MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,System.Nullable`1<MediaBrowser.Model.Entities.Video3DFormat>,System.Nullable`1<System.TimeSpan>,System.Threading.CancellationToken)
ExtractVideoImage(System.String,System.String,MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,System.Nullable`1<System.Int32>,System.Nullable`1<MediaBrowser.Model.Drawing.ImageFormat>,System.Threading.CancellationToken)
GetImageResolutionParameter()
ExtractVideoImagesOnIntervalAccelerated(System.String,System.String,MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,System.Int32,System.TimeSpan,System.Boolean,System.Boolean,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Diagnostics.ProcessPriorityClass>,System.Boolean,MediaBrowser.Controller.MediaEncoding.EncodingHelper,System.Threading.CancellationToken)
GetTimeParameter(System.Int64)
GetTimeParameter(System.TimeSpan)
StartProcess(MediaBrowser.MediaEncoding.Encoder.MediaEncoder/ProcessWrapper)
StopProcess(MediaBrowser.MediaEncoding.Encoder.MediaEncoder/ProcessWrapper,System.Int32)
StopProcesses()
EscapeSubtitleFilterPath(System.String)
Dispose()
Dispose(System.Boolean)
ConvertImage(System.String,System.String)
GetPrimaryPlaylistVobFiles(System.String,System.Nullable`1<System.UInt32>)
GetPrimaryPlaylistM2tsFiles(System.String)
GetInputPathArgument(MediaBrowser.Controller.MediaEncoding.EncodingJobInfo)
GetInputPathArgument(System.String,MediaBrowser.Model.Dto.MediaSourceInfo)
GenerateConcatConfig(MediaBrowser.Model.Dto.MediaSourceInfo,System.String)
CanExtractSubtitles(System.String)
.ctor(System.Diagnostics.Process,MediaBrowser.MediaEncoding.Encoder.MediaEncoder)
OnProcessExited(System.Object,System.EventArgs)
DisposeProcess(System.Diagnostics.Process)
Dispose()