You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
209 lines
7.6 KiB
209 lines
7.6 KiB
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;
|
|
// For video transcodes it is sufficient with equal length segments as ffmpeg will create new keyframes
|
|
if (request.IsRemuxingVideo && 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;
|
|
}
|
|
}
|