1 files changed, 207 insertions, 0 deletions
diff --git a/src/Jellyfin.MediaEncoding.Hls/Playlist/DynamicHlsPlaylistGenerator.cs b/src/Jellyfin.MediaEncoding.Hls/Playlist/DynamicHlsPlaylistGenerator.cs
new file mode 100644
index 000000000..3382ba251
--- /dev/null
+++ b/src/Jellyfin.MediaEncoding.Hls/Playlist/DynamicHlsPlaylistGenerator.cs
@@ -0,0 +1,207 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Jellyfin.MediaEncoding.Hls.Extractors;
+using Jellyfin.MediaEncoding.Keyframes;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.MediaEncoding;
+
+namespace Jellyfin.MediaEncoding.Hls.Playlist;
+
+/// <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)
+    {
+        _serverConfigurationManager = serverConfigurationManager;
+        _extractors = extractors.Where(e => e.IsMetadataBased).ToArray();
+    }
+
+    /// <inheritdoc />
+    public string CreateMainPlaylist(CreateMainPlaylistRequest request)
+    {
+        IReadOnlyList<double> segments;
+        if (TryExtractKeyframes(request.FilePath, out var keyframeData))
+        {
+            segments = ComputeSegments(keyframeData, request.DesiredSegmentLengthMs);
+        }
+        else
+        {
+            segments = ComputeEqualLengthSegments(request.DesiredSegmentLengthMs, request.TotalRuntimeTicks);
+        }
+
+        var segmentExtension = EncodingHelper.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;
+
+        if (isHlsInFmp4)
+        {
+            // Init file that only includes fMP4 headers
+            builder.Append("#EXT-X-MAP:URI=\"")
+                .Append(request.EndpointPrefix)
+                .Append("-1")
+                .Append(segmentExtension)
+                .Append(request.QueryString)
+                .Append("&runtimeTicks=0")
+                .Append("&actualSegmentLengthTicks=0")
+                .Append('"')
+                .AppendLine();
+        }
+
+        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();
+
+            currentRuntimeInSeconds += lengthTicks;
+        }
+
+        builder.AppendLine("#EXT-X-ENDLIST");
+
+        return builder.ToString();
+    }
+
+    private bool TryExtractKeyframes(string filePath, [NotNullWhen(true)] out KeyframeData? keyframeData)
+    {
+        keyframeData = null;
+        if (!IsExtractionAllowedForFile(filePath, _serverConfigurationManager.GetEncodingOptions().AllowOnDemandMetadataBasedKeyframeExtractionForExtensions))
+        {
+            return false;
+        }
+
+        var len = _extractors.Length;
+        for (var i = 0; i < len; i++)
+        {
+            var extractor = _extractors[i];
+            if (!extractor.TryExtractKeyframes(filePath, out var result))
+            {
+                continue;
+            }
+
+            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;
+        }
+
+        // Remove the leading dot
+        var extensionWithoutDot = extension[1..];
+        for (var i = 0; i < allowedExtensions.Length; i++)
+        {
+            var allowedExtension = allowedExtensions[i].AsSpan().TrimStart('.');
+            if (extensionWithoutDot.Equals(allowedExtension, StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    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));
+        }
+
+        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;
+            }
+        }
+
+        result.Add(TimeSpan.FromTicks(keyframeData.TotalDuration - lastKeyframe).TotalSeconds);
+        return result;
+    }
+
+    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 desiredSegmentLength = TimeSpan.FromMilliseconds(desiredSegmentLengthMs);
+
+        var segmentLengthTicks = desiredSegmentLength.Ticks;
+        var wholeSegments = totalRuntimeTicks / segmentLengthTicks;
+        var remainingTicks = totalRuntimeTicks % segmentLengthTicks;
+
+        var segmentsLen = wholeSegments + (remainingTicks == 0 ? 0 : 1);
+        var segments = new double[segmentsLen];
+        for (int i = 0; i < wholeSegments; i++)
+        {
+            segments[i] = desiredSegmentLength.TotalSeconds;
+        }
+
+        if (remainingTicks != 0)
+        {
+            segments[^1] = TimeSpan.FromTicks(remainingTicks).TotalSeconds;
+        }
+
+        return segments;
+    }
+}