Refactor and add scheduled task

Emby.Server.Implementations/ApplicationHost.cs

@@ -47,6 +47,7 @@ using Emby.Server.Implementations.TV;
 using Emby.Server.Implementations.Udp;
 using Emby.Server.Implementations.Updates;
 using Jellyfin.Api.Helpers;
+using Jellyfin.MediaEncoding.Hls.Playlist;
 using Jellyfin.Networking.Configuration;
 using Jellyfin.Networking.Manager;
 using MediaBrowser.Common;
@@ -999,6 +1000,9 @@ namespace Emby.Server.Implementations
             // Network
             yield return typeof(NetworkManager).Assembly;
 
+            // Hls
+            yield return typeof(DynamicHlsPlaylistGenerator).Assembly;
+
             foreach (var i in GetAssembliesWithPartsInternal())
             {
                 yield return i;

Jellyfin.Api/Controllers/DynamicHlsController.cs

@@ -848,7 +848,7 @@ namespace Jellyfin.Api.Controllers
                 StreamOptions = streamOptions
             };
 
-            return await GetVariantPlaylistInternal(streamingRequest, "main", cancellationTokenSource)
+            return await GetVariantPlaylistInternal(streamingRequest, cancellationTokenSource)
                 .ConfigureAwait(false);
         }
 
@@ -1013,7 +1013,7 @@ namespace Jellyfin.Api.Controllers
                 StreamOptions = streamOptions
             };
 
-            return await GetVariantPlaylistInternal(streamingRequest, "main", cancellationTokenSource)
+            return await GetVariantPlaylistInternal(streamingRequest, cancellationTokenSource)
                 .ConfigureAwait(false);
         }
 
@@ -1371,7 +1371,7 @@ namespace Jellyfin.Api.Controllers
                 .ConfigureAwait(false);
         }
 
-        private async Task<ActionResult> GetVariantPlaylistInternal(StreamingRequestDto streamingRequest, string name, CancellationTokenSource cancellationTokenSource)
+        private async Task<ActionResult> GetVariantPlaylistInternal(StreamingRequestDto streamingRequest, CancellationTokenSource cancellationTokenSource)
         {
             using var state = await StreamingHelpers.GetStreamingState(
                     streamingRequest,

MediaBrowser.Model/Configuration/EncodingOptions.cs

@@ -39,7 +39,7 @@ namespace MediaBrowser.Model.Configuration
             EnableHardwareEncoding = true;
             AllowHevcEncoding = false;
             EnableSubtitleExtraction = true;
-            AllowAutomaticKeyframeExtractionForExtensions = Array.Empty<string>();
+            AllowOnDemandMetadataBasedKeyframeExtractionForExtensions = Array.Empty<string>();
             HardwareDecodingCodecs = new string[] { "h264", "vc1" };
         }
 
@@ -119,6 +119,6 @@ namespace MediaBrowser.Model.Configuration
 
         public string[] HardwareDecodingCodecs { get; set; }
 
-        public string[] AllowAutomaticKeyframeExtractionForExtensions { get; set; }
+        public string[] AllowOnDemandMetadataBasedKeyframeExtractionForExtensions { get; set; }
     }
 }

src/Jellyfin.MediaEncoding.Hls/Cache/CacheDecorator.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
+using System.Text.Json;
+using Jellyfin.Extensions.Json;
+using Jellyfin.MediaEncoding.Hls.Extractors;
+using Jellyfin.MediaEncoding.Keyframes;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Extensions;
+
+namespace Jellyfin.MediaEncoding.Hls.Cache;
+
+/// <inheritdoc />
+public class CacheDecorator : IKeyframeExtractor
+{
+    private readonly IKeyframeExtractor _keyframeExtractor;
+    private static readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+    private readonly string _keyframeCachePath;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CacheDecorator"/> class.
+    /// </summary>
+    /// <param name="applicationPaths">An instance of the <see cref="IApplicationPaths"/> interface.</param>
+    /// <param name="keyframeExtractor">An instance of the <see cref="IKeyframeExtractor"/> interface.</param>
+    public CacheDecorator(IApplicationPaths applicationPaths, IKeyframeExtractor keyframeExtractor)
+    {
+        _keyframeExtractor = keyframeExtractor;
+        ArgumentNullException.ThrowIfNull(applicationPaths);
+
+        // TODO make the dir configurable
+        _keyframeCachePath = Path.Combine(applicationPaths.DataPath, "keyframes");
+    }
+
+    /// <inheritdoc />
+    public bool IsMetadataBased => _keyframeExtractor.IsMetadataBased;
+
+    /// <inheritdoc />
+    public bool TryExtractKeyframes(string filePath, [NotNullWhen(true)] out KeyframeData? keyframeData)
+    {
+        keyframeData = null;
+        var cachePath = GetCachePath(_keyframeCachePath, filePath);
+        if (TryReadFromCache(cachePath, out var cachedResult))
+        {
+            keyframeData = cachedResult;
+            return true;
+        }
+
+        if (!_keyframeExtractor.TryExtractKeyframes(filePath, out var result))
+        {
+            return false;
+        }
+
+        keyframeData = result;
+        SaveToCache(cachePath, keyframeData);
+        return true;
+    }
+
+    private static void SaveToCache(string cachePath, KeyframeData keyframeData)
+    {
+        var json = JsonSerializer.Serialize(keyframeData, _jsonOptions);
+        Directory.CreateDirectory(Path.GetDirectoryName(cachePath) ?? throw new ArgumentException($"Provided path ({cachePath}) is not valid.", nameof(cachePath)));
+        File.WriteAllText(cachePath, json);
+    }
+
+    private static string GetCachePath(string keyframeCachePath, string filePath)
+    {
+        var lastWriteTimeUtc = File.GetLastWriteTimeUtc(filePath);
+        ReadOnlySpan<char> filename = (filePath + "_" + lastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture)).GetMD5() + ".json";
+        var prefix = filename[..1];
+
+        return Path.Join(keyframeCachePath, prefix, filename);
+    }
+
+    private static bool TryReadFromCache(string cachePath, [NotNullWhen(true)] out KeyframeData? cachedResult)
+    {
+        if (File.Exists(cachePath))
+        {
+            var bytes = File.ReadAllBytes(cachePath);
+            cachedResult = JsonSerializer.Deserialize<KeyframeData>(bytes, _jsonOptions);
+            return cachedResult != null;
+        }
+
+        cachedResult = null;
+        return false;
+    }
+}

src/Jellyfin.MediaEncoding.Hls/Extensions/MediaEncodingHlsServiceCollectionExtensions.cs

@@ -1,21 +1,36 @@
-using Jellyfin.MediaEncoding.Hls.Playlist;
+using System;
+using Jellyfin.MediaEncoding.Hls.Cache;
+using Jellyfin.MediaEncoding.Hls.Extractors;
+using Jellyfin.MediaEncoding.Hls.Playlist;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace Jellyfin.MediaEncoding.Hls.Extensions
+namespace Jellyfin.MediaEncoding.Hls.Extensions;
+
+/// <summary>
+/// Extensions for the <see cref="IServiceCollection"/> interface.
+/// </summary>
+public static class MediaEncodingHlsServiceCollectionExtensions
 {
     /// <summary>
-    /// Extensions for the <see cref="IServiceCollection"/> interface.
+    /// Adds the hls playlist generators to the <see cref="IServiceCollection"/>.
     /// </summary>
-    public static class MediaEncodingHlsServiceCollectionExtensions
+    /// <param name="serviceCollection">An instance of the <see cref="IServiceCollection"/> interface.</param>
+    /// <returns>The updated service collection.</returns>
+    public static IServiceCollection AddHlsPlaylistGenerator(this IServiceCollection serviceCollection)
+    {
+        serviceCollection.AddSingletonWithDecorator(typeof(FfProbeKeyframeExtractor));
+        serviceCollection.AddSingletonWithDecorator(typeof(MatroskaKeyframeExtractor));
+        serviceCollection.AddSingleton<IDynamicHlsPlaylistGenerator, DynamicHlsPlaylistGenerator>();
+        return serviceCollection;
+    }
+
+    private static void AddSingletonWithDecorator(this IServiceCollection serviceCollection, Type type)
     {
-        /// <summary>
-        /// Adds the hls playlist generators to the <see cref="IServiceCollection"/>.
-        /// </summary>
-        /// <param name="serviceCollection">An instance of the <see cref="IServiceCollection"/> interface.</param>
-        /// <returns>The updated service collection.</returns>
-        public static IServiceCollection AddHlsPlaylistGenerator(this IServiceCollection serviceCollection)
+        serviceCollection.AddSingleton<IKeyframeExtractor>(serviceProvider =>
         {
-            return serviceCollection.AddSingleton<IDynamicHlsPlaylistGenerator, DynamicHlsPlaylistGenerator>();
-        }
+            var extractor = ActivatorUtilities.CreateInstance(serviceProvider, type);
+            var decorator = ActivatorUtilities.CreateInstance<CacheDecorator>(serviceProvider, extractor);
+            return decorator;
+        });
     }
 }

src/Jellyfin.MediaEncoding.Hls/Extractors/FfProbeKeyframeExtractor.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using Emby.Naming.Common;
+using Jellyfin.Extensions;
+using Jellyfin.MediaEncoding.Keyframes;
+using MediaBrowser.Controller.MediaEncoding;
+using Microsoft.Extensions.Logging;
+using Extractor = Jellyfin.MediaEncoding.Keyframes.FfProbe.FfProbeKeyframeExtractor;
+
+namespace Jellyfin.MediaEncoding.Hls.Extractors;
+
+/// <inheritdoc />
+public class FfProbeKeyframeExtractor : IKeyframeExtractor
+{
+    private readonly IMediaEncoder _mediaEncoder;
+    private readonly NamingOptions _namingOptions;
+    private readonly ILogger<FfProbeKeyframeExtractor> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FfProbeKeyframeExtractor"/> class.
+    /// </summary>
+    /// <param name="mediaEncoder">An instance of the <see cref="IMediaEncoder"/> interface.</param>
+    /// <param name="namingOptions">An instance of <see cref="NamingOptions"/>.</param>
+    /// <param name="logger">An instance of the <see cref="ILogger{FfprobeKeyframeExtractor}"/> interface.</param>
+    public FfProbeKeyframeExtractor(IMediaEncoder mediaEncoder, NamingOptions namingOptions, ILogger<FfProbeKeyframeExtractor> logger)
+    {
+        _mediaEncoder = mediaEncoder;
+        _namingOptions = namingOptions;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public bool IsMetadataBased => false;
+
+    /// <inheritdoc />
+    public bool TryExtractKeyframes(string filePath, [NotNullWhen(true)] out KeyframeData? keyframeData)
+    {
+        if (!_namingOptions.VideoFileExtensions.Contains(Path.GetExtension(filePath.AsSpan()), StringComparison.OrdinalIgnoreCase))
+        {
+            keyframeData = null;
+            return false;
+        }
+
+        try
+        {
+            keyframeData = Extractor.GetKeyframeData(_mediaEncoder.ProbePath, filePath);
+            return keyframeData.KeyframeTicks.Count > 0;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Extracting keyframes from {FilePath} using ffprobe failed", filePath);
+        }
+
+        keyframeData = null;
+        return false;
+    }
+}

src/Jellyfin.MediaEncoding.Hls/Extractors/IKeyframeExtractor.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Jellyfin.MediaEncoding.Keyframes;
+
+namespace Jellyfin.MediaEncoding.Hls.Extractors;
+
+/// <summary>
+/// Keyframe extractor.
+/// </summary>
+public interface IKeyframeExtractor
+{
+    /// <summary>
+    /// Gets a value indicating whether the extractor is based on container metadata.
+    /// </summary>
+    bool IsMetadataBased { get; }
+
+    /// <summary>
+    /// Attempt to extract keyframes.
+    /// </summary>
+    /// <param name="filePath">The path to the file.</param>
+    /// <param name="keyframeData">The keyframes.</param>
+    /// <returns>A value indicating whether the keyframe extraction was successful.</returns>
+    bool TryExtractKeyframes(string filePath, [NotNullWhen(true)] out KeyframeData? keyframeData);
+}

src/Jellyfin.MediaEncoding.Hls/Extractors/MatroskaKeyframeExtractor.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Jellyfin.MediaEncoding.Keyframes;
+using Microsoft.Extensions.Logging;
+using Extractor = Jellyfin.MediaEncoding.Keyframes.Matroska.MatroskaKeyframeExtractor;
+
+namespace Jellyfin.MediaEncoding.Hls.Extractors;
+
+/// <inheritdoc />
+public class MatroskaKeyframeExtractor : IKeyframeExtractor
+{
+    private readonly ILogger<MatroskaKeyframeExtractor> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MatroskaKeyframeExtractor"/> class.
+    /// </summary>
+    /// <param name="logger">An instance of the <see cref="ILogger{MatroskaKeyframeExtractor}"/> interface.</param>
+    public MatroskaKeyframeExtractor(ILogger<MatroskaKeyframeExtractor> logger)
+    {
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public bool IsMetadataBased => true;
+
+    /// <inheritdoc />
+    public bool TryExtractKeyframes(string filePath, [NotNullWhen(true)] out KeyframeData? keyframeData)
+    {
+        if (filePath.AsSpan().EndsWith(".mkv", StringComparison.OrdinalIgnoreCase))
+        {
+            keyframeData = null;
+            return false;
+        }
+
+        try
+        {
+            keyframeData = Extractor.GetKeyframeData(filePath);
+            return keyframeData.KeyframeTicks.Count > 0;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Extracting keyframes from {FilePath} using matroska metadata failed", filePath);
+        }
+
+        keyframeData = null;
+        return false;
+    }
+}

src/Jellyfin.MediaEncoding.Hls/Jellyfin.MediaEncoding.Hls.csproj

@@ -19,7 +19,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="5.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Jellyfin.MediaEncoding.Hls/Playlist/CreateMainPlaylistRequest.cs

@@ -1,57 +1,56 @@
-namespace Jellyfin.MediaEncoding.Hls.Playlist
+namespace Jellyfin.MediaEncoding.Hls.Playlist;
+
+/// <summary>
+/// Request class for the <see cref="IDynamicHlsPlaylistGenerator.CreateMainPlaylist(CreateMainPlaylistRequest)"/> method.
+/// </summary>
+public class CreateMainPlaylistRequest
 {
     /// <summary>
-    /// Request class for the <see cref="IDynamicHlsPlaylistGenerator.CreateMainPlaylist(CreateMainPlaylistRequest)"/> method.
+    /// Initializes a new instance of the <see cref="CreateMainPlaylistRequest"/> class.
     /// </summary>
-    public class CreateMainPlaylistRequest
+    /// <param name="filePath">The absolute file path to the file.</param>
+    /// <param name="desiredSegmentLengthMs">The desired segment length in milliseconds.</param>
+    /// <param name="totalRuntimeTicks">The total duration of the file in ticks.</param>
+    /// <param name="segmentContainer">The desired segment container eg. "ts".</param>
+    /// <param name="endpointPrefix">The URI prefix for the relative URL in the playlist.</param>
+    /// <param name="queryString">The desired query string to append (must start with ?).</param>
+    public CreateMainPlaylistRequest(string filePath, int desiredSegmentLengthMs, long totalRuntimeTicks, string segmentContainer, string endpointPrefix, string queryString)
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="CreateMainPlaylistRequest"/> class.
-        /// </summary>
-        /// <param name="filePath">The absolute file path to the file.</param>
-        /// <param name="desiredSegmentLengthMs">The desired segment length in milliseconds.</param>
-        /// <param name="totalRuntimeTicks">The total duration of the file in ticks.</param>
-        /// <param name="segmentContainer">The desired segment container eg. "ts".</param>
-        /// <param name="endpointPrefix">The URI prefix for the relative URL in the playlist.</param>
-        /// <param name="queryString">The desired query string to append (must start with ?).</param>
-        public CreateMainPlaylistRequest(string filePath, int desiredSegmentLengthMs, long totalRuntimeTicks, string segmentContainer, string endpointPrefix, string queryString)
-        {
-            FilePath = filePath;
-            DesiredSegmentLengthMs = desiredSegmentLengthMs;
-            TotalRuntimeTicks = totalRuntimeTicks;
-            SegmentContainer = segmentContainer;
-            EndpointPrefix = endpointPrefix;
-            QueryString = queryString;
-        }
+        FilePath = filePath;
+        DesiredSegmentLengthMs = desiredSegmentLengthMs;
+        TotalRuntimeTicks = totalRuntimeTicks;
+        SegmentContainer = segmentContainer;
+        EndpointPrefix = endpointPrefix;
+        QueryString = queryString;
+    }
 
-        /// <summary>
-        /// Gets the file path.
-        /// </summary>
-        public string FilePath { get; }
+    /// <summary>
+    /// Gets the file path.
+    /// </summary>
+    public string FilePath { get; }
 
-        /// <summary>
-        /// Gets the desired segment length in milliseconds.
-        /// </summary>
-        public int DesiredSegmentLengthMs { get; }
+    /// <summary>
+    /// Gets the desired segment length in milliseconds.
+    /// </summary>
+    public int DesiredSegmentLengthMs { get; }
 
-        /// <summary>
-        /// Gets the total runtime in ticks.
-        /// </summary>
-        public long TotalRuntimeTicks { get; }
+    /// <summary>
+    /// Gets the total runtime in ticks.
+    /// </summary>
+    public long TotalRuntimeTicks { get; }
 
-        /// <summary>
-        /// Gets the segment container.
-        /// </summary>
-        public string SegmentContainer { get; }
+    /// <summary>
+    /// Gets the segment container.
+    /// </summary>
+    public string SegmentContainer { get; }
 
-        /// <summary>
-        /// Gets the endpoint prefix for the URL.
-        /// </summary>
-        public string EndpointPrefix { get; }
+    /// <summary>
+    /// Gets the endpoint prefix for the URL.
+    /// </summary>
+    public string EndpointPrefix { get; }
 
-        /// <summary>
-        /// Gets the query string.
-        /// </summary>
-        public string QueryString { get; }
-    }
+    /// <summary>
+    /// Gets the query string.
+    /// </summary>
+    public string QueryString { get; }
 }

src/Jellyfin.MediaEncoding.Hls/Playlist/DynamicHlsPlaylistGenerator.cs

@@ -5,269 +5,200 @@ using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text;
-using System.Text.Json;
-using Jellyfin.Extensions.Json;
+using Jellyfin.MediaEncoding.Hls.Extractors;
 using Jellyfin.MediaEncoding.Keyframes;
 using MediaBrowser.Common.Configuration;
-using MediaBrowser.Common.Extensions;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.MediaEncoding;
-using Microsoft.Extensions.Logging;
 
-namespace Jellyfin.MediaEncoding.Hls.Playlist
+namespace Jellyfin.MediaEncoding.Hls.Playlist;
+
+/// <inheritdoc />
+public class DynamicHlsPlaylistGenerator : IDynamicHlsPlaylistGenerator
 {
-    /// <inheritdoc />
-    public class DynamicHlsPlaylistGenerator : IDynamicHlsPlaylistGenerator
+    private readonly IServerConfigurationManager _serverConfigurationManager;
+    private readonly IKeyframeExtractor[] _extractors;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DynamicHlsPlaylistGenerator"/> class.
+    /// </summary>
+    /// <param name="serverConfigurationManager">An instance of the see <see cref="IServerConfigurationManager"/> interface.</param>
+    /// <param name="extractors">An instance of <see cref="IEnumerable{IKeyframeExtractor}"/>.</param>
+    public DynamicHlsPlaylistGenerator(IServerConfigurationManager serverConfigurationManager, IEnumerable<IKeyframeExtractor> extractors)
     {
-        private const string DefaultContainerExtension = ".ts";
-
-        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
-        private readonly IServerConfigurationManager _serverConfigurationManager;
-        private readonly IMediaEncoder _mediaEncoder;
-        private readonly IApplicationPaths _applicationPaths;
-        private readonly KeyframeExtractor _keyframeExtractor;
-        private readonly ILogger<DynamicHlsPlaylistGenerator> _logger;
+        _serverConfigurationManager = serverConfigurationManager;
+        _extractors = extractors.Where(e => e.IsMetadataBased).ToArray();
+    }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DynamicHlsPlaylistGenerator"/> class.
-        /// </summary>
-        /// <param name="serverConfigurationManager">An instance of the see <see cref="IServerConfigurationManager"/> interface.</param>
-        /// <param name="mediaEncoder">An instance of the see <see cref="IMediaEncoder"/> interface.</param>
-        /// <param name="applicationPaths">An instance of the <see cref="IApplicationPaths"/> interface.</param>
-        /// <param name="loggerFactory">An instance of the see <see cref="ILoggerFactory"/> interface.</param>
-        public DynamicHlsPlaylistGenerator(IServerConfigurationManager serverConfigurationManager, IMediaEncoder mediaEncoder, IApplicationPaths applicationPaths, ILoggerFactory loggerFactory)
+    /// <inheritdoc />
+    public string CreateMainPlaylist(CreateMainPlaylistRequest request)
+    {
+        IReadOnlyList<double> segments;
+        if (TryExtractKeyframes(request.FilePath, out var keyframeData))
         {
-            _serverConfigurationManager = serverConfigurationManager;
-            _mediaEncoder = mediaEncoder;
-            _applicationPaths = applicationPaths;
-            _keyframeExtractor = new KeyframeExtractor(loggerFactory.CreateLogger<KeyframeExtractor>());
-            _logger = loggerFactory.CreateLogger<DynamicHlsPlaylistGenerator>();
+            segments = ComputeSegments(keyframeData, request.DesiredSegmentLengthMs);
         }
-
-        private string KeyframeCachePath => Path.Combine(_applicationPaths.DataPath, "keyframes");
-
-        /// <inheritdoc />
-        public string CreateMainPlaylist(CreateMainPlaylistRequest request)
+        else
         {
-            IReadOnlyList<double> segments;
-            if (TryExtractKeyframes(request.FilePath, out var keyframeData))
-            {
-                segments = ComputeSegments(keyframeData, request.DesiredSegmentLengthMs);
-            }
-            else
-            {
-                segments = ComputeEqualLengthSegments(request.DesiredSegmentLengthMs, request.TotalRuntimeTicks);
-            }
-
-            var segmentExtension = GetSegmentFileExtension(request.SegmentContainer);
-
-            // http://ffmpeg.org/ffmpeg-all.html#toc-hls-2
-            var isHlsInFmp4 = string.Equals(segmentExtension, "mp4", StringComparison.OrdinalIgnoreCase);
-            var hlsVersion = isHlsInFmp4 ? "7" : "3";
-
-            var builder = new StringBuilder(128);
-
-            builder.AppendLine("#EXTM3U")
-                .AppendLine("#EXT-X-PLAYLIST-TYPE:VOD")
-                .Append("#EXT-X-VERSION:")
-                .Append(hlsVersion)
-                .AppendLine()
-                .Append("#EXT-X-TARGETDURATION:")
-                .Append(Math.Ceiling(segments.Count > 0 ? segments.Max() : request.DesiredSegmentLengthMs))
-                .AppendLine()
-                .AppendLine("#EXT-X-MEDIA-SEQUENCE:0");
-
-            var index = 0;
+            segments = ComputeEqualLengthSegments(request.DesiredSegmentLengthMs, request.TotalRuntimeTicks);
+        }
 
-            if (isHlsInFmp4)
-            {
-                builder.Append("#EXT-X-MAP:URI=\"")
-                    .Append(request.EndpointPrefix)
-                    .Append("-1")
-                    .Append(segmentExtension)
-                    .Append(request.QueryString)
-                    .Append('"')
-                    .AppendLine();
-            }
+        var segmentExtension = EncodingHelper.GetSegmentFileExtension(request.SegmentContainer);
 
-            long currentRuntimeInSeconds = 0;
-            foreach (var length in segments)
-            {
-                // Manually convert to ticks to avoid precision loss when converting double
-                var lengthTicks = Convert.ToInt64(length * TimeSpan.TicksPerSecond);
-                builder.Append("#EXTINF:")
-                    .Append(length.ToString("0.000000", CultureInfo.InvariantCulture))
-                    .AppendLine(", nodesc")
-                    .Append(request.EndpointPrefix)
-                    .Append(index++)
-                    .Append(segmentExtension)
-                    .Append(request.QueryString)
-                    .Append("&runtimeTicks=")
-                    .Append(currentRuntimeInSeconds)
-                    .Append("&actualSegmentLengthTicks=")
-                    .Append(lengthTicks)
-                    .AppendLine();
+        // http://ffmpeg.org/ffmpeg-all.html#toc-hls-2
+        var isHlsInFmp4 = string.Equals(segmentExtension, "mp4", StringComparison.OrdinalIgnoreCase);
+        var hlsVersion = isHlsInFmp4 ? "7" : "3";
 
-                currentRuntimeInSeconds += lengthTicks;
-            }
+        var builder = new StringBuilder(128);
 
-            builder.AppendLine("#EXT-X-ENDLIST");
+        builder.AppendLine("#EXTM3U")
+            .AppendLine("#EXT-X-PLAYLIST-TYPE:VOD")
+            .Append("#EXT-X-VERSION:")
+            .Append(hlsVersion)
+            .AppendLine()
+            .Append("#EXT-X-TARGETDURATION:")
+            .Append(Math.Ceiling(segments.Count > 0 ? segments.Max() : request.DesiredSegmentLengthMs))
+            .AppendLine()
+            .AppendLine("#EXT-X-MEDIA-SEQUENCE:0");
 
-            return builder.ToString();
-        }
+        var index = 0;
 
-        private bool TryExtractKeyframes(string filePath, [NotNullWhen(true)] out KeyframeData? keyframeData)
+        if (isHlsInFmp4)
         {
-            keyframeData = null;
-            if (!IsExtractionAllowedForFile(filePath, _serverConfigurationManager.GetEncodingOptions().AllowAutomaticKeyframeExtractionForExtensions))
-            {
-                return false;
-            }
-
-            var succeeded = false;
-            var cachePath = GetCachePath(filePath);
-            if (TryReadFromCache(cachePath, out var cachedResult))
-            {
-                keyframeData = cachedResult;
-            }
-            else
-            {
-                try
-                {
-                    keyframeData = _keyframeExtractor.GetKeyframeData(filePath, _mediaEncoder.ProbePath, string.Empty);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Keyframe extraction failed for path {FilePath}", filePath);
-                    return false;
-                }
-
-                succeeded = keyframeData.KeyframeTicks.Count > 0;
-                if (succeeded)
-                {
-                    CacheResult(cachePath, keyframeData);
-                }
-            }
-
-            return succeeded;
+            builder.Append("#EXT-X-MAP:URI=\"")
+                .Append(request.EndpointPrefix)
+                .Append("-1")
+                .Append(segmentExtension)
+                .Append(request.QueryString)
+                .Append('"')
+                .AppendLine();
         }
 
-        private void CacheResult(string cachePath, KeyframeData keyframeData)
+        long currentRuntimeInSeconds = 0;
+        foreach (var length in segments)
         {
-            var json = JsonSerializer.Serialize(keyframeData, _jsonOptions);
-            Directory.CreateDirectory(Path.GetDirectoryName(cachePath) ?? throw new ArgumentException($"Provided path ({cachePath}) is not valid.", nameof(cachePath)));
-            File.WriteAllText(cachePath, json);
+            // Manually convert to ticks to avoid precision loss when converting double
+            var lengthTicks = Convert.ToInt64(length * TimeSpan.TicksPerSecond);
+            builder.Append("#EXTINF:")
+                .Append(length.ToString("0.000000", CultureInfo.InvariantCulture))
+                .AppendLine(", nodesc")
+                .Append(request.EndpointPrefix)
+                .Append(index++)
+                .Append(segmentExtension)
+                .Append(request.QueryString)
+                .Append("&runtimeTicks=")
+                .Append(currentRuntimeInSeconds)
+                .Append("&actualSegmentLengthTicks=")
+                .Append(lengthTicks)
+                .AppendLine();
+
+            currentRuntimeInSeconds += lengthTicks;
         }
 
-        private string GetCachePath(string filePath)
-        {
-            var lastWriteTimeUtc = File.GetLastWriteTimeUtc(filePath);
-            ReadOnlySpan<char> filename = (filePath + "_" + lastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture)).GetMD5() + ".json";
-            var prefix = filename.Slice(0, 1);
+        builder.AppendLine("#EXT-X-ENDLIST");
 
-            return Path.Join(KeyframeCachePath, prefix, filename);
-        }
+        return builder.ToString();
+    }
 
-        private bool TryReadFromCache(string cachePath, [NotNullWhen(true)] out KeyframeData? cachedResult)
+    private bool TryExtractKeyframes(string filePath, [NotNullWhen(true)] out KeyframeData? keyframeData)
+    {
+        keyframeData = null;
+        if (!IsExtractionAllowedForFile(filePath, _serverConfigurationManager.GetEncodingOptions().AllowOnDemandMetadataBasedKeyframeExtractionForExtensions))
         {
-            if (File.Exists(cachePath))
-            {
-                var bytes = File.ReadAllBytes(cachePath);
-                cachedResult = JsonSerializer.Deserialize<KeyframeData>(bytes, _jsonOptions);
-                return cachedResult != null;
-            }
-
-            cachedResult = null;
             return false;
         }
 
-        internal static bool IsExtractionAllowedForFile(ReadOnlySpan<char> filePath, string[] allowedExtensions)
+        var len = _extractors.Length;
+        for (var i = 0; i < len; i++)
         {
-            var extension = Path.GetExtension(filePath);
-            if (extension.IsEmpty)
+            var extractor = _extractors[i];
+            if (!extractor.TryExtractKeyframes(filePath, out var result))
             {
-                return false;
+                continue;
             }
 
-            // Remove the leading dot
-            var extensionWithoutDot = extension[1..];
-            for (var i = 0; i < allowedExtensions.Length; i++)
-            {
-                var allowedExtension = allowedExtensions[i];
-                if (extensionWithoutDot.Equals(allowedExtension, StringComparison.OrdinalIgnoreCase))
-                {
-                    return true;
-                }
-            }
+            keyframeData = result;
+            return true;
+        }
 
+        return false;
+    }
+
+    internal static bool IsExtractionAllowedForFile(ReadOnlySpan<char> filePath, string[] allowedExtensions)
+    {
+        var extension = Path.GetExtension(filePath);
+        if (extension.IsEmpty)
+        {
             return false;
         }
 
-        internal static IReadOnlyList<double> ComputeSegments(KeyframeData keyframeData, int desiredSegmentLengthMs)
+        // Remove the leading dot
+        var extensionWithoutDot = extension[1..];
+        for (var i = 0; i < allowedExtensions.Length; i++)
         {
-            if (keyframeData.KeyframeTicks.Count > 0 && keyframeData.TotalDuration < keyframeData.KeyframeTicks[^1])
+            var allowedExtension = allowedExtensions[i].AsSpan().TrimStart('.');
+            if (extensionWithoutDot.Equals(allowedExtension, StringComparison.OrdinalIgnoreCase))
             {
-                throw new ArgumentException("Invalid duration in keyframe data", nameof(keyframeData));
+                return true;
             }
+        }
 
-            long lastKeyframe = 0;
-            var result = new List<double>();
-            // Scale the segment length to ticks to match the keyframes
-            var desiredSegmentLengthTicks = TimeSpan.FromMilliseconds(desiredSegmentLengthMs).Ticks;
-            var desiredCutTime = desiredSegmentLengthTicks;
-            for (var j = 0; j < keyframeData.KeyframeTicks.Count; j++)
-            {
-                var keyframe = keyframeData.KeyframeTicks[j];
-                if (keyframe >= desiredCutTime)
-                {
-                    var currentSegmentLength = keyframe - lastKeyframe;
-                    result.Add(TimeSpan.FromTicks(currentSegmentLength).TotalSeconds);
-                    lastKeyframe = keyframe;
-                    desiredCutTime += desiredSegmentLengthTicks;
-                }
-            }
+        return false;
+    }
 
-            result.Add(TimeSpan.FromTicks(keyframeData.TotalDuration - lastKeyframe).TotalSeconds);
-            return result;
+    internal static IReadOnlyList<double> ComputeSegments(KeyframeData keyframeData, int desiredSegmentLengthMs)
+    {
+        if (keyframeData.KeyframeTicks.Count > 0 && keyframeData.TotalDuration < keyframeData.KeyframeTicks[^1])
+        {
+            throw new ArgumentException("Invalid duration in keyframe data", nameof(keyframeData));
         }
 
-        internal static double[] ComputeEqualLengthSegments(int desiredSegmentLengthMs, long totalRuntimeTicks)
+        long lastKeyframe = 0;
+        var result = new List<double>();
+        // Scale the segment length to ticks to match the keyframes
+        var desiredSegmentLengthTicks = TimeSpan.FromMilliseconds(desiredSegmentLengthMs).Ticks;
+        var desiredCutTime = desiredSegmentLengthTicks;
+        for (var j = 0; j < keyframeData.KeyframeTicks.Count; j++)
         {
-            if (desiredSegmentLengthMs == 0 || totalRuntimeTicks == 0)
+            var keyframe = keyframeData.KeyframeTicks[j];
+            if (keyframe >= desiredCutTime)
             {
-                throw new InvalidOperationException($"Invalid segment length ({desiredSegmentLengthMs}) or runtime ticks ({totalRuntimeTicks})");
+                var currentSegmentLength = keyframe - lastKeyframe;
+                result.Add(TimeSpan.FromTicks(currentSegmentLength).TotalSeconds);
+                lastKeyframe = keyframe;
+                desiredCutTime += desiredSegmentLengthTicks;
             }
+        }
 
-            var desiredSegmentLength = TimeSpan.FromMilliseconds(desiredSegmentLengthMs);
+        result.Add(TimeSpan.FromTicks(keyframeData.TotalDuration - lastKeyframe).TotalSeconds);
+        return result;
+    }
 
-            var segmentLengthTicks = desiredSegmentLength.Ticks;
-            var wholeSegments = totalRuntimeTicks / segmentLengthTicks;
-            var remainingTicks = totalRuntimeTicks % segmentLengthTicks;
+    internal static double[] ComputeEqualLengthSegments(int desiredSegmentLengthMs, long totalRuntimeTicks)
+    {
+        if (desiredSegmentLengthMs == 0 || totalRuntimeTicks == 0)
+        {
+            throw new InvalidOperationException($"Invalid segment length ({desiredSegmentLengthMs}) or runtime ticks ({totalRuntimeTicks})");
+        }
 
-            var segmentsLen = wholeSegments + (remainingTicks == 0 ? 0 : 1);
-            var segments = new double[segmentsLen];
-            for (int i = 0; i < wholeSegments; i++)
-            {
-                segments[i] = desiredSegmentLength.TotalSeconds;
-            }
+        var desiredSegmentLength = TimeSpan.FromMilliseconds(desiredSegmentLengthMs);
 
-            if (remainingTicks != 0)
-            {
-                segments[^1] = TimeSpan.FromTicks(remainingTicks).TotalSeconds;
-            }
+        var segmentLengthTicks = desiredSegmentLength.Ticks;
+        var wholeSegments = totalRuntimeTicks / segmentLengthTicks;
+        var remainingTicks = totalRuntimeTicks % segmentLengthTicks;
 
-            return segments;
+        var segmentsLen = wholeSegments + (remainingTicks == 0 ? 0 : 1);
+        var segments = new double[segmentsLen];
+        for (int i = 0; i < wholeSegments; i++)
+        {
+            segments[i] = desiredSegmentLength.TotalSeconds;
         }
 
-        // TODO copied from DynamicHlsController
-        private static string GetSegmentFileExtension(string segmentContainer)
+        if (remainingTicks != 0)
         {
-            if (!string.IsNullOrWhiteSpace(segmentContainer))
-            {
-                return "." + segmentContainer;
-            }
-
-            return DefaultContainerExtension;
+            segments[^1] = TimeSpan.FromTicks(remainingTicks).TotalSeconds;
         }
+
+        return segments;
     }
 }

src/Jellyfin.MediaEncoding.Hls/Playlist/IDynamicHlsPlaylistGenerator.cs

@@ -1,15 +1,14 @@
-namespace Jellyfin.MediaEncoding.Hls.Playlist
+namespace Jellyfin.MediaEncoding.Hls.Playlist;
+
+/// <summary>
+/// Generator for dynamic HLS playlists where the segment lengths aren't known in advance.
+/// </summary>
+public interface IDynamicHlsPlaylistGenerator
 {
     /// <summary>
-    /// Generator for dynamic HLS playlists where the segment lengths aren't known in advance.
+    /// Creates the main playlist containing the main video or audio stream.
     /// </summary>
-    public interface IDynamicHlsPlaylistGenerator
-    {
-        /// <summary>
-        /// Creates the main playlist containing the main video or audio stream.
-        /// </summary>
-        /// <param name="request">An instance of the <see cref="CreateMainPlaylistRequest"/> class.</param>
-        /// <returns>The playlist as a formatted string.</returns>
-        string CreateMainPlaylist(CreateMainPlaylistRequest request);
-    }
+    /// <param name="request">An instance of the <see cref="CreateMainPlaylistRequest"/> class.</param>
+    /// <returns>The playlist as a formatted string.</returns>
+    string CreateMainPlaylist(CreateMainPlaylistRequest request);
 }

src/Jellyfin.MediaEncoding.Hls/ScheduledTasks/KeyframeExtractionScheduledTask.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.MediaEncoding.Hls.Extractors;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.Tasks;
+
+namespace Jellyfin.MediaEncoding.Hls.ScheduledTasks;
+
+/// <inheritdoc />
+public class KeyframeExtractionScheduledTask : IScheduledTask
+{
+    private readonly ILocalizationManager _localizationManager;
+    private readonly ILibraryManager _libraryManager;
+    private readonly IKeyframeExtractor[] _keyframeExtractors;
+    private static readonly BaseItemKind[] _itemTypes = { BaseItemKind.Episode, BaseItemKind.Movie };
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="KeyframeExtractionScheduledTask"/> class.
+    /// </summary>
+    /// <param name="localizationManager">An instance of the <see cref="ILocalizationManager"/> interface.</param>
+    /// <param name="libraryManager">An instance of the <see cref="ILibraryManager"/> interface.</param>
+    /// <param name="keyframeExtractors">The keyframe extractors.</param>
+    public KeyframeExtractionScheduledTask(ILocalizationManager localizationManager, ILibraryManager libraryManager, IEnumerable<IKeyframeExtractor> keyframeExtractors)
+    {
+        _localizationManager = localizationManager;
+        _libraryManager = libraryManager;
+        _keyframeExtractors = keyframeExtractors.ToArray();
+    }
+
+    /// <inheritdoc />
+    public string Name => "Keyframe Extractor";
+
+    /// <inheritdoc />
+    public string Key => "KeyframeExtraction";
+
+    /// <inheritdoc />
+    public string Description => "Extracts keyframes from video files to create more precise HLS playlists";
+
+    /// <inheritdoc />
+    public string Category => _localizationManager.GetLocalizedString("TasksLibraryCategory");
+
+    /// <inheritdoc />
+    public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+    {
+        var query = new InternalItemsQuery
+        {
+            MediaTypes = new[] { MediaType.Video },
+            IsVirtualItem = false,
+            IncludeItemTypes = _itemTypes,
+            DtoOptions = new DtoOptions(true),
+            SourceTypes = new[] { SourceType.Library },
+            Recursive = true
+        };
+
+        var videos = _libraryManager.GetItemList(query);
+
+        // TODO parallelize with Parallel.ForEach?
+        for (var i = 0; i < videos.Count; i++)
+        {
+            var video = videos[i];
+            // Only local files supported
+            if (!video.IsFileProtocol || !File.Exists(video.Path))
+            {
+                continue;
+            }
+
+            for (var j = 0; j < _keyframeExtractors.Length; j++)
+            {
+                var extractor = _keyframeExtractors[j];
+                // The cache decorator will make sure to save them in the data dir
+                if (extractor.TryExtractKeyframes(video.Path, out _))
+                {
+                    break;
+                }
+            }
+        }
+
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers() => Enumerable.Empty<TaskTriggerInfo>();
+}

src/Jellyfin.MediaEncoding.Keyframes/FfProbe/FfProbeKeyframeExtractor.cs

@@ -4,92 +4,91 @@ using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 
-namespace Jellyfin.MediaEncoding.Keyframes.FfProbe
+namespace Jellyfin.MediaEncoding.Keyframes.FfProbe;
+
+/// <summary>
+/// FfProbe based keyframe extractor.
+/// </summary>
+public static class FfProbeKeyframeExtractor
 {
+    private const string DefaultArguments = "-v error -skip_frame nokey -show_entries format=duration -show_entries stream=duration -show_entries packet=pts_time,flags -select_streams v -of csv \"{0}\"";
+
     /// <summary>
-    /// FfProbe based keyframe extractor.
+    /// Extracts the keyframes using the ffprobe executable at the specified path.
     /// </summary>
-    public static class FfProbeKeyframeExtractor
+    /// <param name="ffProbePath">The path to the ffprobe executable.</param>
+    /// <param name="filePath">The file path.</param>
+    /// <returns>An instance of <see cref="KeyframeData"/>.</returns>
+    public static KeyframeData GetKeyframeData(string ffProbePath, string filePath)
     {
-        private const string DefaultArguments = "-v error -skip_frame nokey -show_entries format=duration -show_entries stream=duration -show_entries packet=pts_time,flags -select_streams v -of csv \"{0}\"";
-
-        /// <summary>
-        /// Extracts the keyframes using the ffprobe executable at the specified path.
-        /// </summary>
-        /// <param name="ffProbePath">The path to the ffprobe executable.</param>
-        /// <param name="filePath">The file path.</param>
-        /// <returns>An instance of <see cref="KeyframeData"/>.</returns>
-        public static KeyframeData GetKeyframeData(string ffProbePath, string filePath)
+        using var process = new Process
         {
-            using var process = new Process
+            StartInfo = new ProcessStartInfo
             {
-                StartInfo = new ProcessStartInfo
-                {
-                    FileName = ffProbePath,
-                    Arguments = string.Format(CultureInfo.InvariantCulture, DefaultArguments, filePath),
+                FileName = ffProbePath,
+                Arguments = string.Format(CultureInfo.InvariantCulture, DefaultArguments, filePath),
 
-                    CreateNoWindow = true,
-                    UseShellExecute = false,
-                    RedirectStandardOutput = true,
+                CreateNoWindow = true,
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
 
-                    WindowStyle = ProcessWindowStyle.Hidden,
-                    ErrorDialog = false,
-                },
-                EnableRaisingEvents = true
-            };
+                WindowStyle = ProcessWindowStyle.Hidden,
+                ErrorDialog = false,
+            },
+            EnableRaisingEvents = true
+        };
 
-            process.Start();
+        process.Start();
 
-            return ParseStream(process.StandardOutput);
-        }
+        return ParseStream(process.StandardOutput);
+    }
 
-        internal static KeyframeData ParseStream(StreamReader reader)
-        {
-            var keyframes = new List<long>();
-            double streamDuration = 0;
-            double formatDuration = 0;
+    internal static KeyframeData ParseStream(StreamReader reader)
+    {
+        var keyframes = new List<long>();
+        double streamDuration = 0;
+        double formatDuration = 0;
 
-            while (!reader.EndOfStream)
+        while (!reader.EndOfStream)
+        {
+            var line = reader.ReadLine().AsSpan();
+            if (line.IsEmpty)
             {
-                var line = reader.ReadLine().AsSpan();
-                if (line.IsEmpty)
-                {
-                    continue;
-                }
+                continue;
+            }
 
-                var firstComma = line.IndexOf(',');
-                var lineType = line[..firstComma];
-                var rest = line[(firstComma + 1)..];
-                if (lineType.Equals("packet", StringComparison.OrdinalIgnoreCase))
+            var firstComma = line.IndexOf(',');
+            var lineType = line[..firstComma];
+            var rest = line[(firstComma + 1)..];
+            if (lineType.Equals("packet", StringComparison.OrdinalIgnoreCase))
+            {
+                if (rest.EndsWith(",K_"))
                 {
-                    if (rest.EndsWith(",K_"))
-                    {
-                        // Trim the flags from the packet line. Example line: packet,7169.079000,K_
-                        var keyframe = double.Parse(rest[..^3], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
-                        // Have to manually convert to ticks to avoid rounding errors as TimeSpan is only precise down to 1 ms when converting double.
-                        keyframes.Add(Convert.ToInt64(keyframe * TimeSpan.TicksPerSecond));
-                    }
+                    // Trim the flags from the packet line. Example line: packet,7169.079000,K_
+                    var keyframe = double.Parse(rest[..^3], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
+                    // Have to manually convert to ticks to avoid rounding errors as TimeSpan is only precise down to 1 ms when converting double.
+                    keyframes.Add(Convert.ToInt64(keyframe * TimeSpan.TicksPerSecond));
                 }
-                else if (lineType.Equals("stream", StringComparison.OrdinalIgnoreCase))
+            }
+            else if (lineType.Equals("stream", StringComparison.OrdinalIgnoreCase))
+            {
+                if (double.TryParse(rest, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var streamDurationResult))
                 {
-                    if (double.TryParse(rest, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var streamDurationResult))
-                    {
-                        streamDuration = streamDurationResult;
-                    }
+                    streamDuration = streamDurationResult;
                 }
-                else if (lineType.Equals("format", StringComparison.OrdinalIgnoreCase))
+            }
+            else if (lineType.Equals("format", StringComparison.OrdinalIgnoreCase))
+            {
+                if (double.TryParse(rest, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var formatDurationResult))
                 {
-                    if (double.TryParse(rest, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var formatDurationResult))
-                    {
-                        formatDuration = formatDurationResult;
-                    }
+                    formatDuration = formatDurationResult;
                 }
             }
+        }
 
-            // Prefer the stream duration as it should be more accurate
-            var duration = streamDuration > 0 ? streamDuration : formatDuration;
+        // Prefer the stream duration as it should be more accurate
+        var duration = streamDuration > 0 ? streamDuration : formatDuration;
 
-            return new KeyframeData(TimeSpan.FromSeconds(duration).Ticks, keyframes);
-        }
+        return new KeyframeData(TimeSpan.FromSeconds(duration).Ticks, keyframes);
     }
 }

src/Jellyfin.MediaEncoding.Keyframes/FfTool/FfToolKeyframeExtractor.cs

@@ -1,18 +1,17 @@
 using System;
 
-namespace Jellyfin.MediaEncoding.Keyframes.FfTool
+namespace Jellyfin.MediaEncoding.Keyframes.FfTool;
+
+/// <summary>
+/// FfTool based keyframe extractor.
+/// </summary>
+public static class FfToolKeyframeExtractor
 {
     /// <summary>
-    /// FfTool based keyframe extractor.
+    /// Extracts the keyframes using the fftool executable at the specified path.
     /// </summary>
-    public static class FfToolKeyframeExtractor
-    {
-        /// <summary>
-        /// Extracts the keyframes using the fftool executable at the specified path.
-        /// </summary>
-        /// <param name="ffToolPath">The path to the fftool executable.</param>
-        /// <param name="filePath">The file path.</param>
-        /// <returns>An instance of <see cref="KeyframeData"/>.</returns>
-        public static KeyframeData GetKeyframeData(string ffToolPath, string filePath) => throw new NotImplementedException();
-    }
+    /// <param name="ffToolPath">The path to the fftool executable.</param>
+    /// <param name="filePath">The file path.</param>
+    /// <returns>An instance of <see cref="KeyframeData"/>.</returns>
+    public static KeyframeData GetKeyframeData(string ffToolPath, string filePath) => throw new NotImplementedException();
 }

src/Jellyfin.MediaEncoding.Keyframes/KeyframeData.cs

@@ -1,31 +1,30 @@
 using System.Collections.Generic;
 
-namespace Jellyfin.MediaEncoding.Keyframes
+namespace Jellyfin.MediaEncoding.Keyframes;
+
+/// <summary>
+/// Keyframe information for a specific file.
+/// </summary>
+public class KeyframeData
 {
     /// <summary>
-    /// Keyframe information for a specific file.
+    /// Initializes a new instance of the <see cref="KeyframeData"/> class.
     /// </summary>
-    public class KeyframeData
+    /// <param name="totalDuration">The total duration of the video stream in ticks.</param>
+    /// <param name="keyframeTicks">The video keyframes in ticks.</param>
+    public KeyframeData(long totalDuration, IReadOnlyList<long> keyframeTicks)
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="KeyframeData"/> class.
-        /// </summary>
-        /// <param name="totalDuration">The total duration of the video stream in ticks.</param>
-        /// <param name="keyframeTicks">The video keyframes in ticks.</param>
-        public KeyframeData(long totalDuration, IReadOnlyList<long> keyframeTicks)
-        {
-            TotalDuration = totalDuration;
-            KeyframeTicks = keyframeTicks;
-        }
+        TotalDuration = totalDuration;
+        KeyframeTicks = keyframeTicks;
+    }
 
-        /// <summary>
-        /// Gets the total duration of the stream in ticks.
-        /// </summary>
-        public long TotalDuration { get; }
+    /// <summary>
+    /// Gets the total duration of the stream in ticks.
+    /// </summary>
+    public long TotalDuration { get; }
 
-        /// <summary>
-        /// Gets the keyframes in ticks.
-        /// </summary>
-        public IReadOnlyList<long> KeyframeTicks { get; }
-    }
+    /// <summary>
+    /// Gets the keyframes in ticks.
+    /// </summary>
+    public IReadOnlyList<long> KeyframeTicks { get; }
 }

src/Jellyfin.MediaEncoding.Keyframes/KeyframeExtractor.cs

@@ -1,69 +0,0 @@
-using System;
-using System.IO;
-using Jellyfin.MediaEncoding.Keyframes.FfProbe;
-using Jellyfin.MediaEncoding.Keyframes.FfTool;
-using Jellyfin.MediaEncoding.Keyframes.Matroska;
-using Microsoft.Extensions.Logging;
-
-namespace Jellyfin.MediaEncoding.Keyframes
-{
-    /// <summary>
-    /// Manager class for the set of keyframe extractors.
-    /// </summary>
-    public class KeyframeExtractor
-    {
-        private readonly ILogger<KeyframeExtractor> _logger;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="KeyframeExtractor"/> class.
-        /// </summary>
-        /// <param name="logger">An instance of the <see cref="ILogger{KeyframeExtractor}"/> interface.</param>
-        public KeyframeExtractor(ILogger<KeyframeExtractor> logger)
-        {
-            _logger = logger;
-        }
-
-        /// <summary>
-        /// Extracts the keyframe positions from a video file.
-        /// </summary>
-        /// <param name="filePath">Absolute file path to the media file.</param>
-        /// <param name="ffProbePath">Absolute file path to the ffprobe executable.</param>
-        /// <param name="ffToolPath">Absolute file path to the fftool executable.</param>
-        /// <returns>An instance of <see cref="KeyframeData"/>.</returns>
-        public KeyframeData GetKeyframeData(string filePath, string ffProbePath, string ffToolPath)
-        {
-            var extension = Path.GetExtension(filePath.AsSpan());
-            if (extension.Equals(".mkv", StringComparison.OrdinalIgnoreCase))
-            {
-                try
-                {
-                    return MatroskaKeyframeExtractor.GetKeyframeData(filePath);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "{ExtractorType} failed to extract keyframes", nameof(MatroskaKeyframeExtractor));
-                }
-            }
-
-            try
-            {
-                return FfToolKeyframeExtractor.GetKeyframeData(ffToolPath, filePath);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "{ExtractorType} failed to extract keyframes", nameof(FfToolKeyframeExtractor));
-            }
-
-            try
-            {
-                return FfProbeKeyframeExtractor.GetKeyframeData(ffProbePath, filePath);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "{ExtractorType} failed to extract keyframes", nameof(FfProbeKeyframeExtractor));
-            }
-
-            return new KeyframeData(0, Array.Empty<long>());
-        }
-    }
-}

src/Jellyfin.MediaEncoding.Keyframes/Matroska/Extensions/EbmlReaderExtensions.cs

@@ -3,176 +3,175 @@ using System.Buffers.Binary;
 using Jellyfin.MediaEncoding.Keyframes.Matroska.Models;
 using NEbml.Core;
 
-namespace Jellyfin.MediaEncoding.Keyframes.Matroska.Extensions
+namespace Jellyfin.MediaEncoding.Keyframes.Matroska.Extensions;
+
+/// <summary>
+/// Extension methods for the <see cref="EbmlReader"/> class.
+/// </summary>
+internal static class EbmlReaderExtensions
 {
     /// <summary>
-    /// Extension methods for the <see cref="EbmlReader"/> class.
+    /// Traverses the current container to find the element with <paramref name="identifier"/> identifier.
     /// </summary>
-    internal static class EbmlReaderExtensions
+    /// <param name="reader">An instance of <see cref="EbmlReader"/>.</param>
+    /// <param name="identifier">The element identifier.</param>
+    /// <returns>A value indicating whether the element was found.</returns>
+    internal static bool FindElement(this EbmlReader reader, ulong identifier)
     {
-        /// <summary>
-        /// Traverses the current container to find the element with <paramref name="identifier"/> identifier.
-        /// </summary>
-        /// <param name="reader">An instance of <see cref="EbmlReader"/>.</param>
-        /// <param name="identifier">The element identifier.</param>
-        /// <returns>A value indicating whether the element was found.</returns>
-        internal static bool FindElement(this EbmlReader reader, ulong identifier)
+        while (reader.ReadNext())
         {
-            while (reader.ReadNext())
+            if (reader.ElementId.EncodedValue == identifier)
             {
-                if (reader.ElementId.EncodedValue == identifier)
-                {
-                    return true;
-                }
+                return true;
             }
-
-            return false;
         }
 
-        /// <summary>
-        /// Reads the current position in the file as an unsigned integer converted from binary.
-        /// </summary>
-        /// <param name="reader">An instance of <see cref="EbmlReader"/>.</param>
-        /// <returns>The unsigned integer.</returns>
-        internal static uint ReadUIntFromBinary(this EbmlReader reader)
+        return false;
+    }
+
+    /// <summary>
+    /// Reads the current position in the file as an unsigned integer converted from binary.
+    /// </summary>
+    /// <param name="reader">An instance of <see cref="EbmlReader"/>.</param>
+    /// <returns>The unsigned integer.</returns>
+    internal static uint ReadUIntFromBinary(this EbmlReader reader)
+    {
+        var buffer = new byte[4];
+        reader.ReadBinary(buffer, 0, 4);
+        return BinaryPrimitives.ReadUInt32BigEndian(buffer);
+    }
+
+    /// <summary>
+    /// Reads from the start of the file to retrieve the SeekHead segment.
+    /// </summary>
+    /// <param name="reader">An instance of <see cref="EbmlReader"/>.</param>
+    /// <returns>Instance of <see cref="SeekHead"/>.</returns>
+    internal static SeekHead ReadSeekHead(this EbmlReader reader)
+    {
+        reader = reader ?? throw new ArgumentNullException(nameof(reader));
+
+        if (reader.ElementPosition != 0)
         {
-            var buffer = new byte[4];
-            reader.ReadBinary(buffer, 0, 4);
-            return BinaryPrimitives.ReadUInt32BigEndian(buffer);
+            throw new InvalidOperationException("File position must be at 0");
         }
 
-        /// <summary>
-        /// Reads from the start of the file to retrieve the SeekHead segment.
-        /// </summary>
-        /// <param name="reader">An instance of <see cref="EbmlReader"/>.</param>
-        /// <returns>Instance of <see cref="SeekHead"/>.</returns>
-        internal static SeekHead ReadSeekHead(this EbmlReader reader)
+        // Skip the header
+        if (!reader.FindElement(MatroskaConstants.SegmentContainer))
         {
-            reader = reader ?? throw new ArgumentNullException(nameof(reader));
-
-            if (reader.ElementPosition != 0)
-            {
-                throw new InvalidOperationException("File position must be at 0");
-            }
-
-            // Skip the header
-            if (!reader.FindElement(MatroskaConstants.SegmentContainer))
-            {
-                throw new InvalidOperationException("Expected a segment container");
-            }
+            throw new InvalidOperationException("Expected a segment container");
+        }
 
-            reader.EnterContainer();
+        reader.EnterContainer();
 
-            long? tracksPosition = null;
-            long? cuesPosition = null;
-            long? infoPosition = null;
-            // The first element should be a SeekHead otherwise we'll have to search manually
-            if (!reader.FindElement(MatroskaConstants.SeekHead))
-            {
-                throw new InvalidOperationException("Expected a SeekHead");
-            }
+        long? tracksPosition = null;
+        long? cuesPosition = null;
+        long? infoPosition = null;
+        // The first element should be a SeekHead otherwise we'll have to search manually
+        if (!reader.FindElement(MatroskaConstants.SeekHead))
+        {
+            throw new InvalidOperationException("Expected a SeekHead");
+        }
 
+        reader.EnterContainer();
+        while (reader.FindElement(MatroskaConstants.Seek))
+        {
             reader.EnterContainer();
-            while (reader.FindElement(MatroskaConstants.Seek))
+            reader.ReadNext();
+            var type = (ulong)reader.ReadUIntFromBinary();
+            switch (type)
             {
-                reader.EnterContainer();
-                reader.ReadNext();
-                var type = (ulong)reader.ReadUIntFromBinary();
-                switch (type)
-                {
-                    case MatroskaConstants.Tracks:
-                        reader.ReadNext();
-                        tracksPosition = (long)reader.ReadUInt();
-                        break;
-                    case MatroskaConstants.Cues:
-                        reader.ReadNext();
-                        cuesPosition = (long)reader.ReadUInt();
-                        break;
-                    case MatroskaConstants.Info:
-                        reader.ReadNext();
-                        infoPosition = (long)reader.ReadUInt();
-                        break;
-                }
-
-                reader.LeaveContainer();
-
-                if (tracksPosition.HasValue && cuesPosition.HasValue && infoPosition.HasValue)
-                {
+                case MatroskaConstants.Tracks:
+                    reader.ReadNext();
+                    tracksPosition = (long)reader.ReadUInt();
+                    break;
+                case MatroskaConstants.Cues:
+                    reader.ReadNext();
+                    cuesPosition = (long)reader.ReadUInt();
+                    break;
+                case MatroskaConstants.Info:
+                    reader.ReadNext();
+                    infoPosition = (long)reader.ReadUInt();
                     break;
-                }
             }
 
             reader.LeaveContainer();
 
-            if (!tracksPosition.HasValue || !cuesPosition.HasValue || !infoPosition.HasValue)
+            if (tracksPosition.HasValue && cuesPosition.HasValue && infoPosition.HasValue)
             {
-                throw new InvalidOperationException("SeekHead is missing or does not contain Info, Tracks and Cues positions");
+                break;
             }
-
-            return new SeekHead(infoPosition.Value, tracksPosition.Value, cuesPosition.Value);
         }
 
-        /// <summary>
-        /// Reads from SegmentContainer to retrieve the Info segment.
-        /// </summary>
-        /// <param name="reader">An instance of <see cref="EbmlReader"/>.</param>
-        /// <param name="position">The position of the info segment relative to the Segment container.</param>
-        /// <returns>Instance of <see cref="Info"/>.</returns>
-        internal static Info ReadInfo(this EbmlReader reader, long position)
+        reader.LeaveContainer();
+
+        if (!tracksPosition.HasValue || !cuesPosition.HasValue || !infoPosition.HasValue)
         {
-            reader.ReadAt(position);
+            throw new InvalidOperationException("SeekHead is missing or does not contain Info, Tracks and Cues positions");
+        }
 
-            double? duration = null;
-            reader.EnterContainer();
-            // Mandatory element
-            reader.FindElement(MatroskaConstants.TimestampScale);
-            var timestampScale = reader.ReadUInt();
+        return new SeekHead(infoPosition.Value, tracksPosition.Value, cuesPosition.Value);
+    }
 
-            if (reader.FindElement(MatroskaConstants.Duration))
-            {
-                duration = reader.ReadFloat();
-            }
+    /// <summary>
+    /// Reads from SegmentContainer to retrieve the Info segment.
+    /// </summary>
+    /// <param name="reader">An instance of <see cref="EbmlReader"/>.</param>
+    /// <param name="position">The position of the info segment relative to the Segment container.</param>
+    /// <returns>Instance of <see cref="Info"/>.</returns>
+    internal static Info ReadInfo(this EbmlReader reader, long position)
+    {
+        reader.ReadAt(position);
 
-            reader.LeaveContainer();
+        double? duration = null;
+        reader.EnterContainer();
+        // Mandatory element
+        reader.FindElement(MatroskaConstants.TimestampScale);
+        var timestampScale = reader.ReadUInt();
 
-            return new Info((long)timestampScale, duration);
+        if (reader.FindElement(MatroskaConstants.Duration))
+        {
+            duration = reader.ReadFloat();
         }
 
-        /// <summary>
-        /// Enters the Tracks segment and reads all tracks to find the specified type.
-        /// </summary>
-        /// <param name="reader">Instance of <see cref="EbmlReader"/>.</param>
-        /// <param name="tracksPosition">The relative position of the tracks segment.</param>
-        /// <param name="type">The track type identifier.</param>
-        /// <returns>The first track number with the specified type.</returns>
-        /// <exception cref="InvalidOperationException">Stream type is not found.</exception>
-        internal static ulong FindFirstTrackNumberByType(this EbmlReader reader, long tracksPosition, ulong type)
-        {
-            reader.ReadAt(tracksPosition);
+        reader.LeaveContainer();
 
+        return new Info((long)timestampScale, duration);
+    }
+
+    /// <summary>
+    /// Enters the Tracks segment and reads all tracks to find the specified type.
+    /// </summary>
+    /// <param name="reader">Instance of <see cref="EbmlReader"/>.</param>
+    /// <param name="tracksPosition">The relative position of the tracks segment.</param>
+    /// <param name="type">The track type identifier.</param>
+    /// <returns>The first track number with the specified type.</returns>
+    /// <exception cref="InvalidOperationException">Stream type is not found.</exception>
+    internal static ulong FindFirstTrackNumberByType(this EbmlReader reader, long tracksPosition, ulong type)
+    {
+        reader.ReadAt(tracksPosition);
+
+        reader.EnterContainer();
+        while (reader.FindElement(MatroskaConstants.TrackEntry))
+        {
             reader.EnterContainer();
-            while (reader.FindElement(MatroskaConstants.TrackEntry))
-            {
-                reader.EnterContainer();
-                // Mandatory element
-                reader.FindElement(MatroskaConstants.TrackNumber);
-                var trackNumber = reader.ReadUInt();
+            // Mandatory element
+            reader.FindElement(MatroskaConstants.TrackNumber);
+            var trackNumber = reader.ReadUInt();
 
-                // Mandatory element
-                reader.FindElement(MatroskaConstants.TrackType);
-                var trackType = reader.ReadUInt();
+            // Mandatory element
+            reader.FindElement(MatroskaConstants.TrackType);
+            var trackType = reader.ReadUInt();
 
+            reader.LeaveContainer();
+            if (trackType == MatroskaConstants.TrackTypeVideo)
+            {
                 reader.LeaveContainer();
-                if (trackType == MatroskaConstants.TrackTypeVideo)
-                {
-                    reader.LeaveContainer();
-                    return trackNumber;
-                }
+                return trackNumber;
             }
+        }
 
-            reader.LeaveContainer();
+        reader.LeaveContainer();
 
-            throw new InvalidOperationException($"No stream with type {type} found");
-        }
+        throw new InvalidOperationException($"No stream with type {type} found");
     }
 }

src/Jellyfin.MediaEncoding.Keyframes/Matroska/MatroskaConstants.cs

@@ -1,31 +1,30 @@
-namespace Jellyfin.MediaEncoding.Keyframes.Matroska
+namespace Jellyfin.MediaEncoding.Keyframes.Matroska;
+
+/// <summary>
+/// Constants for the Matroska identifiers.
+/// </summary>
+public static class MatroskaConstants
 {
-    /// <summary>
-    /// Constants for the Matroska identifiers.
-    /// </summary>
-    public static class MatroskaConstants
-    {
-        internal const ulong SegmentContainer = 0x18538067;
+    internal const ulong SegmentContainer = 0x18538067;
 
-        internal const ulong SeekHead = 0x114D9B74;
-        internal const ulong Seek = 0x4DBB;
+    internal const ulong SeekHead = 0x114D9B74;
+    internal const ulong Seek = 0x4DBB;
 
-        internal const ulong Info = 0x1549A966;
-        internal const ulong TimestampScale = 0x2AD7B1;
-        internal const ulong Duration = 0x4489;
+    internal const ulong Info = 0x1549A966;
+    internal const ulong TimestampScale = 0x2AD7B1;
+    internal const ulong Duration = 0x4489;
 
-        internal const ulong Tracks = 0x1654AE6B;
-        internal const ulong TrackEntry = 0xAE;
-        internal const ulong TrackNumber = 0xD7;
-        internal const ulong TrackType = 0x83;
+    internal const ulong Tracks = 0x1654AE6B;
+    internal const ulong TrackEntry = 0xAE;
+    internal const ulong TrackNumber = 0xD7;
+    internal const ulong TrackType = 0x83;
 
-        internal const ulong TrackTypeVideo = 0x1;
-        internal const ulong TrackTypeSubtitle = 0x11;
+    internal const ulong TrackTypeVideo = 0x1;
+    internal const ulong TrackTypeSubtitle = 0x11;
 
-        internal const ulong Cues = 0x1C53BB6B;
-        internal const ulong CueTime = 0xB3;
-        internal const ulong CuePoint = 0xBB;
-        internal const ulong CueTrackPositions = 0xB7;
-        internal const ulong CuePointTrackNumber = 0xF7;
-    }
+    internal const ulong Cues = 0x1C53BB6B;
+    internal const ulong CueTime = 0xB3;
+    internal const ulong CuePoint = 0xBB;
+    internal const ulong CueTrackPositions = 0xB7;
+    internal const ulong CuePointTrackNumber = 0xF7;
 }

src/Jellyfin.MediaEncoding.Keyframes/Matroska/MatroskaKeyframeExtractor.cs

@@ -4,73 +4,72 @@ using System.IO;
 using Jellyfin.MediaEncoding.Keyframes.Matroska.Extensions;
 using NEbml.Core;
 
-namespace Jellyfin.MediaEncoding.Keyframes.Matroska
+namespace Jellyfin.MediaEncoding.Keyframes.Matroska;
+
+/// <summary>
+/// The keyframe extractor for the matroska container.
+/// </summary>
+public static class MatroskaKeyframeExtractor
 {
     /// <summary>
-    /// The keyframe extractor for the matroska container.
+    /// Extracts the keyframes in ticks (scaled using the container timestamp scale) from the matroska container.
     /// </summary>
-    public static class MatroskaKeyframeExtractor
+    /// <param name="filePath">The file path.</param>
+    /// <returns>An instance of <see cref="KeyframeData"/>.</returns>
+    public static KeyframeData GetKeyframeData(string filePath)
     {
-        /// <summary>
-        /// Extracts the keyframes in ticks (scaled using the container timestamp scale) from the matroska container.
-        /// </summary>
-        /// <param name="filePath">The file path.</param>
-        /// <returns>An instance of <see cref="KeyframeData"/>.</returns>
-        public static KeyframeData GetKeyframeData(string filePath)
-        {
-            using var stream = File.OpenRead(filePath);
-            using var reader = new EbmlReader(stream);
+        using var stream = File.OpenRead(filePath);
+        using var reader = new EbmlReader(stream);
+
+        var seekHead = reader.ReadSeekHead();
+        var info = reader.ReadInfo(seekHead.InfoPosition);
+        var videoTrackNumber = reader.FindFirstTrackNumberByType(seekHead.TracksPosition, MatroskaConstants.TrackTypeVideo);
 
-            var seekHead = reader.ReadSeekHead();
-            var info = reader.ReadInfo(seekHead.InfoPosition);
-            var videoTrackNumber = reader.FindFirstTrackNumberByType(seekHead.TracksPosition, MatroskaConstants.TrackTypeVideo);
+        var keyframes = new List<long>();
+        reader.ReadAt(seekHead.CuesPosition);
+        reader.EnterContainer();
 
-            var keyframes = new List<long>();
-            reader.ReadAt(seekHead.CuesPosition);
+        while (reader.FindElement(MatroskaConstants.CuePoint))
+        {
             reader.EnterContainer();
+            ulong? trackNumber = null;
+            // Mandatory element
+            reader.FindElement(MatroskaConstants.CueTime);
+            var cueTime = reader.ReadUInt();
 
-            while (reader.FindElement(MatroskaConstants.CuePoint))
+            // Mandatory element
+            reader.FindElement(MatroskaConstants.CueTrackPositions);
+            reader.EnterContainer();
+            if (reader.FindElement(MatroskaConstants.CuePointTrackNumber))
             {
-                reader.EnterContainer();
-                ulong? trackNumber = null;
-                // Mandatory element
-                reader.FindElement(MatroskaConstants.CueTime);
-                var cueTime = reader.ReadUInt();
-
-                // Mandatory element
-                reader.FindElement(MatroskaConstants.CueTrackPositions);
-                reader.EnterContainer();
-                if (reader.FindElement(MatroskaConstants.CuePointTrackNumber))
-                {
-                    trackNumber = reader.ReadUInt();
-                }
-
-                reader.LeaveContainer();
+                trackNumber = reader.ReadUInt();
+            }
 
-                if (trackNumber == videoTrackNumber)
-                {
-                    keyframes.Add(ScaleToTicks(cueTime, info.TimestampScale));
-                }
+            reader.LeaveContainer();
 
-                reader.LeaveContainer();
+            if (trackNumber == videoTrackNumber)
+            {
+                keyframes.Add(ScaleToTicks(cueTime, info.TimestampScale));
             }
 
             reader.LeaveContainer();
-
-            var result = new KeyframeData(ScaleToTicks(info.Duration ?? 0, info.TimestampScale), keyframes);
-            return result;
         }
 
-        private static long ScaleToTicks(ulong unscaledValue, long timestampScale)
-        {
-            // TimestampScale is in nanoseconds, scale it to get the value in ticks, 1 tick == 100 ns
-            return (long)unscaledValue * timestampScale / 100;
-        }
+        reader.LeaveContainer();
 
-        private static long ScaleToTicks(double unscaledValue, long timestampScale)
-        {
-            // TimestampScale is in nanoseconds, scale it to get the value in ticks, 1 tick == 100 ns
-            return Convert.ToInt64(unscaledValue * timestampScale / 100);
-        }
+        var result = new KeyframeData(ScaleToTicks(info.Duration ?? 0, info.TimestampScale), keyframes);
+        return result;
+    }
+
+    private static long ScaleToTicks(ulong unscaledValue, long timestampScale)
+    {
+        // TimestampScale is in nanoseconds, scale it to get the value in ticks, 1 tick == 100 ns
+        return (long)unscaledValue * timestampScale / 100;
+    }
+
+    private static long ScaleToTicks(double unscaledValue, long timestampScale)
+    {
+        // TimestampScale is in nanoseconds, scale it to get the value in ticks, 1 tick == 100 ns
+        return Convert.ToInt64(unscaledValue * timestampScale / 100);
     }
 }

src/Jellyfin.MediaEncoding.Keyframes/Matroska/Models/Info.cs

@@ -1,29 +1,28 @@
-namespace Jellyfin.MediaEncoding.Keyframes.Matroska.Models
+namespace Jellyfin.MediaEncoding.Keyframes.Matroska.Models;
+
+/// <summary>
+/// The matroska Info segment.
+/// </summary>
+internal class Info
 {
     /// <summary>
-    /// The matroska Info segment.
+    /// Initializes a new instance of the <see cref="Info"/> class.
     /// </summary>
-    internal class Info
+    /// <param name="timestampScale">The timestamp scale in nanoseconds.</param>
+    /// <param name="duration">The duration of the entire file.</param>
+    public Info(long timestampScale, double? duration)
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="Info"/> class.
-        /// </summary>
-        /// <param name="timestampScale">The timestamp scale in nanoseconds.</param>
-        /// <param name="duration">The duration of the entire file.</param>
-        public Info(long timestampScale, double? duration)
-        {
-            TimestampScale = timestampScale;
-            Duration = duration;
-        }
+        TimestampScale = timestampScale;
+        Duration = duration;
+    }
 
-        /// <summary>
-        /// Gets the timestamp scale in nanoseconds.
-        /// </summary>
-        public long TimestampScale { get; }
+    /// <summary>
+    /// Gets the timestamp scale in nanoseconds.
+    /// </summary>
+    public long TimestampScale { get; }
 
-        /// <summary>
-        /// Gets the total duration of the file.
-        /// </summary>
-        public double? Duration { get; }
-    }
+    /// <summary>
+    /// Gets the total duration of the file.
+    /// </summary>
+    public double? Duration { get; }
 }

src/Jellyfin.MediaEncoding.Keyframes/Matroska/Models/SeekHead.cs

@@ -1,36 +1,35 @@
-namespace Jellyfin.MediaEncoding.Keyframes.Matroska.Models
+namespace Jellyfin.MediaEncoding.Keyframes.Matroska.Models;
+
+/// <summary>
+/// The matroska SeekHead segment. All positions are relative to the Segment container.
+/// </summary>
+internal class SeekHead
 {
     /// <summary>
-    /// The matroska SeekHead segment. All positions are relative to the Segment container.
+    /// Initializes a new instance of the <see cref="SeekHead"/> class.
     /// </summary>
-    internal class SeekHead
+    /// <param name="infoPosition">The relative file position of the info segment.</param>
+    /// <param name="tracksPosition">The relative file position of the tracks segment.</param>
+    /// <param name="cuesPosition">The relative file position of the cues segment.</param>
+    public SeekHead(long infoPosition, long tracksPosition, long cuesPosition)
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="SeekHead"/> class.
-        /// </summary>
-        /// <param name="infoPosition">The relative file position of the info segment.</param>
-        /// <param name="tracksPosition">The relative file position of the tracks segment.</param>
-        /// <param name="cuesPosition">The relative file position of the cues segment.</param>
-        public SeekHead(long infoPosition, long tracksPosition, long cuesPosition)
-        {
-            InfoPosition = infoPosition;
-            TracksPosition = tracksPosition;
-            CuesPosition = cuesPosition;
-        }
+        InfoPosition = infoPosition;
+        TracksPosition = tracksPosition;
+        CuesPosition = cuesPosition;
+    }
 
-        /// <summary>
-        /// Gets relative file position of the info segment.
-        /// </summary>
-        public long InfoPosition { get; }
+    /// <summary>
+    /// Gets relative file position of the info segment.
+    /// </summary>
+    public long InfoPosition { get; }
 
-        /// <summary>
-        /// Gets the relative file position of the tracks segment.
-        /// </summary>
-        public long TracksPosition { get; }
+    /// <summary>
+    /// Gets the relative file position of the tracks segment.
+    /// </summary>
+    public long TracksPosition { get; }
 
-        /// <summary>
-        /// Gets the relative file position of the cues segment.
-        /// </summary>
-        public long CuesPosition { get; }
-    }
+    /// <summary>
+    /// Gets the relative file position of the cues segment.
+    /// </summary>
+    public long CuesPosition { get; }
 }

tests/Jellyfin.MediaEncoding.Hls.Tests/Playlist/DynamicHlsPlaylistGeneratorTests.cs

@@ -38,8 +38,8 @@ namespace Jellyfin.MediaEncoding.Hls.Tests.Playlist
 
         [Theory]
         [InlineData("testfile.mkv", new string[0], false)]
-        [InlineData("testfile.flv", new[] { "mp4", "mkv", "ts" }, false)]
-        [InlineData("testfile.flv", new[] { "mp4", "mkv", "ts", "flv" }, true)]
+        [InlineData("testfile.flv", new[] { ".mp4", ".mkv", ".ts" }, false)]
+        [InlineData("testfile.flv", new[] { ".mp4", ".mkv", ".ts", ".flv" }, true)]
         [InlineData("/some/arbitrarily/long/path/testfile.mkv", new[] { "mkv" }, true)]
         public void IsExtractionAllowedForFile_Valid_Success(string filePath, string[] allowedExtensions, bool isAllowed)
         {
@@ -47,7 +47,7 @@ namespace Jellyfin.MediaEncoding.Hls.Tests.Playlist
         }
 
         [Theory]
-        [InlineData("testfile", new[] { "mp4" })]
+        [InlineData("testfile", new[] { ".mp4" })]
         public void IsExtractionAllowedForFile_Invalid_ReturnsFalse(string filePath, string[] allowedExtensions)
         {
             Assert.False(DynamicHlsPlaylistGenerator.IsExtractionAllowedForFile(filePath, allowedExtensions));

tests/Jellyfin.MediaEncoding.Keyframes.Tests/FfProbe/FfProbeKeyframeExtractorTests.cs

@@ -13,7 +13,7 @@ namespace Jellyfin.MediaEncoding.Keyframes.FfProbe
         {
             var testDataPath = Path.Combine("FfProbe/Test Data", testDataFileName);
             var resultPath = Path.Combine("FfProbe/Test Data", resultFileName);
-            var resultFileStream = File.OpenRead(resultPath);
+            using var resultFileStream = File.OpenRead(resultPath);
             var expectedResult = JsonSerializer.Deserialize<KeyframeData>(resultFileStream)!;
 
             using var fileStream = File.OpenRead(testDataPath);