cotugno/jellyfin
2
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2024-11-15 18:08:53 -07:00
Code Issues Packages Projects Releases Wiki Activity

Refactor and add scheduled task

Browse Source
This commit is contained in:
cvium 2022-01-11 23:30:30 +01:00
parent c658a883a2
commit 6ffa9539bb
24 changed files with 924 additions and 744 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Emby.Server.Implementations/ApplicationHost.cs
View File

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

6
Jellyfin.Api/Controllers/DynamicHlsController.cs
View File

@ -848,7 +848,7 @@ namespace Jellyfin.Api.Controllers
StreamOptions = streamOptions StreamOptions = streamOptions
}; };
return await GetVariantPlaylistInternal(streamingRequest, "main", cancellationTokenSource) return await GetVariantPlaylistInternal(streamingRequest, cancellationTokenSource)
.ConfigureAwait(false); .ConfigureAwait(false);
} }
@ -1013,7 +1013,7 @@ namespace Jellyfin.Api.Controllers
StreamOptions = streamOptions StreamOptions = streamOptions
}; };
return await GetVariantPlaylistInternal(streamingRequest, "main", cancellationTokenSource) return await GetVariantPlaylistInternal(streamingRequest, cancellationTokenSource)
.ConfigureAwait(false); .ConfigureAwait(false);
} }
@ -1371,7 +1371,7 @@ namespace Jellyfin.Api.Controllers
.ConfigureAwait(false); .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( using var state = await StreamingHelpers.GetStreamingState(
streamingRequest, streamingRequest,

4
MediaBrowser.Model/Configuration/EncodingOptions.cs
View File

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

87
src/Jellyfin.MediaEncoding.Hls/Cache/CacheDecorator.cs Normal file
View File

@ -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;
}
}

39
src/Jellyfin.MediaEncoding.Hls/Extensions/MediaEncodingHlsServiceCollectionExtensions.cs
View File

@ -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; 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> /// <summary>
/// Extensions for the <see cref="IServiceCollection"/> interface. /// Adds the hls playlist generators to the <see cref="IServiceCollection"/>.
/// </summary> /// </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)
{ {
/// <summary> serviceCollection.AddSingletonWithDecorator(typeof(FfProbeKeyframeExtractor));
/// Adds the hls playlist generators to the <see cref="IServiceCollection"/>. serviceCollection.AddSingletonWithDecorator(typeof(MatroskaKeyframeExtractor));
/// </summary> serviceCollection.AddSingleton<IDynamicHlsPlaylistGenerator, DynamicHlsPlaylistGenerator>();
/// <param name="serviceCollection">An instance of the <see cref="IServiceCollection"/> interface.</param> return serviceCollection;
/// <returns>The updated service collection.</returns> }
public static IServiceCollection AddHlsPlaylistGenerator(this IServiceCollection serviceCollection)
private static void AddSingletonWithDecorator(this IServiceCollection serviceCollection, Type type)
{
serviceCollection.AddSingleton<IKeyframeExtractor>(serviceProvider =>
{ {
return serviceCollection.AddSingleton<IDynamicHlsPlaylistGenerator, DynamicHlsPlaylistGenerator>(); var extractor = ActivatorUtilities.CreateInstance(serviceProvider, type);
} var decorator = ActivatorUtilities.CreateInstance<CacheDecorator>(serviceProvider, extractor);
return decorator;
});
} }
} }

58
src/Jellyfin.MediaEncoding.Hls/Extractors/FfProbeKeyframeExtractor.cs Normal file
View File

@ -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;
}
}

24
src/Jellyfin.MediaEncoding.Hls/Extractors/IKeyframeExtractor.cs Normal file
View File

@ -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);
}

48
src/Jellyfin.MediaEncoding.Hls/Extractors/MatroskaKeyframeExtractor.cs Normal file
View File

@ -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;
}
}

2
src/Jellyfin.MediaEncoding.Hls/Jellyfin.MediaEncoding.Hls.csproj
View File

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

101
src/Jellyfin.MediaEncoding.Hls/Playlist/CreateMainPlaylistRequest.cs
View File

@ -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> /// <summary>
/// Request class for the <see cref="IDynamicHlsPlaylistGenerator.CreateMainPlaylist(CreateMainPlaylistRequest)"/> method. /// Initializes a new instance of the <see cref="CreateMainPlaylistRequest"/> class.
/// </summary> /// </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> FilePath = filePath;
/// Initializes a new instance of the <see cref="CreateMainPlaylistRequest"/> class. DesiredSegmentLengthMs = desiredSegmentLengthMs;
/// </summary> TotalRuntimeTicks = totalRuntimeTicks;
/// <param name="filePath">The absolute file path to the file.</param> SegmentContainer = segmentContainer;
/// <param name="desiredSegmentLengthMs">The desired segment length in milliseconds.</param> EndpointPrefix = endpointPrefix;
/// <param name="totalRuntimeTicks">The total duration of the file in ticks.</param> QueryString = queryString;
/// <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;
}
/// <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 total runtime in ticks.
/// </summary>
public long TotalRuntimeTicks { 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 query string.
/// </summary>
public string QueryString { 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 total runtime in ticks.
/// </summary>
public long TotalRuntimeTicks { 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 query string.
/// </summary>
public string QueryString { get; }
} }

373
src/Jellyfin.MediaEncoding.Hls/Playlist/DynamicHlsPlaylistGenerator.cs
View File

@ -5,269 +5,200 @@ using System.Globalization;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Text.Json; using Jellyfin.MediaEncoding.Hls.Extractors;
using Jellyfin.Extensions.Json;
using Jellyfin.MediaEncoding.Keyframes; using Jellyfin.MediaEncoding.Keyframes;
using MediaBrowser.Common.Configuration; using MediaBrowser.Common.Configuration;
using MediaBrowser.Common.Extensions;
using MediaBrowser.Controller.Configuration; using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.MediaEncoding; using MediaBrowser.Controller.MediaEncoding;
using Microsoft.Extensions.Logging;
namespace Jellyfin.MediaEncoding.Hls.Playlist namespace Jellyfin.MediaEncoding.Hls.Playlist;
/// <inheritdoc />
public class DynamicHlsPlaylistGenerator : IDynamicHlsPlaylistGenerator
{ {
/// <inheritdoc /> private readonly IServerConfigurationManager _serverConfigurationManager;
public class DynamicHlsPlaylistGenerator : IDynamicHlsPlaylistGenerator 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"; _serverConfigurationManager = serverConfigurationManager;
_extractors = extractors.Where(e => e.IsMetadataBased).ToArray();
}
private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options; /// <inheritdoc />
private readonly IServerConfigurationManager _serverConfigurationManager; public string CreateMainPlaylist(CreateMainPlaylistRequest request)
private readonly IMediaEncoder _mediaEncoder; {
private readonly IApplicationPaths _applicationPaths; IReadOnlyList<double> segments;
private readonly KeyframeExtractor _keyframeExtractor; if (TryExtractKeyframes(request.FilePath, out var keyframeData))
private readonly ILogger<DynamicHlsPlaylistGenerator> _logger;
/// <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)
{ {
_serverConfigurationManager = serverConfigurationManager; segments = ComputeSegments(keyframeData, request.DesiredSegmentLengthMs);
_mediaEncoder = mediaEncoder; }
_applicationPaths = applicationPaths; else
_keyframeExtractor = new KeyframeExtractor(loggerFactory.CreateLogger<KeyframeExtractor>()); {
_logger = loggerFactory.CreateLogger<DynamicHlsPlaylistGenerator>(); segments = ComputeEqualLengthSegments(request.DesiredSegmentLengthMs, request.TotalRuntimeTicks);
} }
private string KeyframeCachePath => Path.Combine(_applicationPaths.DataPath, "keyframes"); var segmentExtension = EncodingHelper.GetSegmentFileExtension(request.SegmentContainer);
/// <inheritdoc /> // http://ffmpeg.org/ffmpeg-all.html#toc-hls-2
public string CreateMainPlaylist(CreateMainPlaylistRequest request) 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)
{ {
IReadOnlyList<double> segments; builder.Append("#EXT-X-MAP:URI=\"")
if (TryExtractKeyframes(request.FilePath, out var keyframeData)) .Append(request.EndpointPrefix)
{ .Append("-1")
segments = ComputeSegments(keyframeData, request.DesiredSegmentLengthMs); .Append(segmentExtension)
} .Append(request.QueryString)
else .Append('"')
{ .AppendLine();
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;
if (isHlsInFmp4)
{
builder.Append("#EXT-X-MAP:URI=\"")
.Append(request.EndpointPrefix)
.Append("-1")
.Append(segmentExtension)
.Append(request.QueryString)
.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) long currentRuntimeInSeconds = 0;
foreach (var length in segments)
{ {
keyframeData = null; // Manually convert to ticks to avoid precision loss when converting double
if (!IsExtractionAllowedForFile(filePath, _serverConfigurationManager.GetEncodingOptions().AllowAutomaticKeyframeExtractionForExtensions)) var lengthTicks = Convert.ToInt64(length * TimeSpan.TicksPerSecond);
{ builder.Append("#EXTINF:")
return false; .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();
var succeeded = false; currentRuntimeInSeconds += lengthTicks;
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;
} }
private void CacheResult(string cachePath, KeyframeData keyframeData) 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))
{ {
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 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);
return Path.Join(KeyframeCachePath, prefix, filename);
}
private 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; 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); var extractor = _extractors[i];
if (extension.IsEmpty) if (!extractor.TryExtractKeyframes(filePath, out var result))
{ {
return false; continue;
} }
// Remove the leading dot keyframeData = result;
var extensionWithoutDot = extension[1..]; return true;
for (var i = 0; i < allowedExtensions.Length; i++) }
{
var allowedExtension = allowedExtensions[i];
if (extensionWithoutDot.Equals(allowedExtension, StringComparison.OrdinalIgnoreCase))
{
return true;
}
}
return false;
}
internal static bool IsExtractionAllowedForFile(ReadOnlySpan<char> filePath, string[] allowedExtensions)
{
var extension = Path.GetExtension(filePath);
if (extension.IsEmpty)
{
return false; 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;
}
}
result.Add(TimeSpan.FromTicks(keyframeData.TotalDuration - lastKeyframe).TotalSeconds);
return result;
} }
internal static double[] ComputeEqualLengthSegments(int desiredSegmentLengthMs, long totalRuntimeTicks) return false;
}
internal static IReadOnlyList<double> ComputeSegments(KeyframeData keyframeData, int desiredSegmentLengthMs)
{
if (keyframeData.KeyframeTicks.Count > 0 && keyframeData.TotalDuration < keyframeData.KeyframeTicks[^1])
{ {
if (desiredSegmentLengthMs == 0 || totalRuntimeTicks == 0) throw new ArgumentException("Invalid duration in keyframe data", nameof(keyframeData));
{
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;
} }
// TODO copied from DynamicHlsController long lastKeyframe = 0;
private static string GetSegmentFileExtension(string segmentContainer) 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 (!string.IsNullOrWhiteSpace(segmentContainer)) var keyframe = keyframeData.KeyframeTicks[j];
if (keyframe >= desiredCutTime)
{ {
return "." + segmentContainer; var currentSegmentLength = keyframe - lastKeyframe;
result.Add(TimeSpan.FromTicks(currentSegmentLength).TotalSeconds);
lastKeyframe = keyframe;
desiredCutTime += desiredSegmentLengthTicks;
} }
return DefaultContainerExtension;
} }
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;
} }
} }

21
src/Jellyfin.MediaEncoding.Hls/Playlist/IDynamicHlsPlaylistGenerator.cs
View File

@ -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> /// <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> /// </summary>
public interface IDynamicHlsPlaylistGenerator /// <param name="request">An instance of the <see cref="CreateMainPlaylistRequest"/> class.</param>
{ /// <returns>The playlist as a formatted string.</returns>
/// <summary> string CreateMainPlaylist(CreateMainPlaylistRequest request);
/// 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);
}
} }

92
src/Jellyfin.MediaEncoding.Hls/ScheduledTasks/KeyframeExtractionScheduledTask.cs Normal file
View File

@ -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>();
}

141
src/Jellyfin.MediaEncoding.Keyframes/FfProbe/FfProbeKeyframeExtractor.cs
View File

@ -4,92 +4,91 @@ using System.Diagnostics;
using System.Globalization; using System.Globalization;
using System.IO; 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> /// <summary>
/// FfProbe based keyframe extractor. /// Extracts the keyframes using the ffprobe executable at the specified path.
/// </summary> /// </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}\""; using var process = new Process
/// <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 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, CreateNoWindow = true,
UseShellExecute = false, UseShellExecute = false,
RedirectStandardOutput = true, RedirectStandardOutput = true,
WindowStyle = ProcessWindowStyle.Hidden, WindowStyle = ProcessWindowStyle.Hidden,
ErrorDialog = false, ErrorDialog = false,
}, },
EnableRaisingEvents = true EnableRaisingEvents = true
}; };
process.Start(); process.Start();
return ParseStream(process.StandardOutput); return ParseStream(process.StandardOutput);
} }
internal static KeyframeData ParseStream(StreamReader reader) internal static KeyframeData ParseStream(StreamReader reader)
{
var keyframes = new List<long>();
double streamDuration = 0;
double formatDuration = 0;
while (!reader.EndOfStream)
{ {
var keyframes = new List<long>(); var line = reader.ReadLine().AsSpan();
double streamDuration = 0; if (line.IsEmpty)
double formatDuration = 0;
while (!reader.EndOfStream)
{ {
var line = reader.ReadLine().AsSpan(); continue;
if (line.IsEmpty)
{
continue;
}
var firstComma = line.IndexOf(',');
var lineType = line[..firstComma];
var rest = line[(firstComma + 1)..];
if (lineType.Equals("packet", StringComparison.OrdinalIgnoreCase))
{
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));
}
}
else if (lineType.Equals("stream", StringComparison.OrdinalIgnoreCase))
{
if (double.TryParse(rest, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var streamDurationResult))
{
streamDuration = streamDurationResult;
}
}
else if (lineType.Equals("format", StringComparison.OrdinalIgnoreCase))
{
if (double.TryParse(rest, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var formatDurationResult))
{
formatDuration = formatDurationResult;
}
}
} }
// Prefer the stream duration as it should be more accurate var firstComma = line.IndexOf(',');
var duration = streamDuration > 0 ? streamDuration : formatDuration; var lineType = line[..firstComma];
var rest = line[(firstComma + 1)..];
return new KeyframeData(TimeSpan.FromSeconds(duration).Ticks, keyframes); if (lineType.Equals("packet", StringComparison.OrdinalIgnoreCase))
{
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));
}
}
else if (lineType.Equals("stream", StringComparison.OrdinalIgnoreCase))
{
if (double.TryParse(rest, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var streamDurationResult))
{
streamDuration = streamDurationResult;
}
}
else if (lineType.Equals("format", StringComparison.OrdinalIgnoreCase))
{
if (double.TryParse(rest, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var formatDurationResult))
{
formatDuration = formatDurationResult;
}
}
} }
// Prefer the stream duration as it should be more accurate
var duration = streamDuration > 0 ? streamDuration : formatDuration;
return new KeyframeData(TimeSpan.FromSeconds(duration).Ticks, keyframes);
} }
} }

23
src/Jellyfin.MediaEncoding.Keyframes/FfTool/FfToolKeyframeExtractor.cs
View File

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

45
src/Jellyfin.MediaEncoding.Keyframes/KeyframeData.cs
View File

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

69
src/Jellyfin.MediaEncoding.Keyframes/KeyframeExtractor.cs
View File

@ -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>());
}
}
}

267
src/Jellyfin.MediaEncoding.Keyframes/Matroska/Extensions/EbmlReaderExtensions.cs
View File

@ -3,176 +3,175 @@ using System.Buffers.Binary;
using Jellyfin.MediaEncoding.Keyframes.Matroska.Models; using Jellyfin.MediaEncoding.Keyframes.Matroska.Models;
using NEbml.Core; 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> /// <summary>
/// Extension methods for the <see cref="EbmlReader"/> class. /// Traverses the current container to find the element with <paramref name="identifier"/> identifier.
/// </summary> /// </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> while (reader.ReadNext())
/// 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()) if (reader.ElementId.EncodedValue == identifier)
{ {
if (reader.ElementId.EncodedValue == identifier) return true;
{
return true;
}
} }
return false;
} }
/// <summary> return false;
/// 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> /// <summary>
/// <returns>The unsigned integer.</returns> /// Reads the current position in the file as an unsigned integer converted from binary.
internal static uint ReadUIntFromBinary(this EbmlReader reader) /// </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]; throw new InvalidOperationException("File position must be at 0");
reader.ReadBinary(buffer, 0, 4);
return BinaryPrimitives.ReadUInt32BigEndian(buffer);
} }
/// <summary> // Skip the header
/// Reads from the start of the file to retrieve the SeekHead segment. if (!reader.FindElement(MatroskaConstants.SegmentContainer))
/// </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)); throw new InvalidOperationException("Expected a segment container");
}
if (reader.ElementPosition != 0) reader.EnterContainer();
{
throw new InvalidOperationException("File position must be at 0");
}
// Skip the header long? tracksPosition = null;
if (!reader.FindElement(MatroskaConstants.SegmentContainer)) long? cuesPosition = null;
{ long? infoPosition = null;
throw new InvalidOperationException("Expected a segment container"); // 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(); reader.EnterContainer();
reader.ReadNext();
long? tracksPosition = null; var type = (ulong)reader.ReadUIntFromBinary();
long? cuesPosition = null; switch (type)
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"); case MatroskaConstants.Tracks:
} reader.ReadNext();
tracksPosition = (long)reader.ReadUInt();
reader.EnterContainer(); break;
while (reader.FindElement(MatroskaConstants.Seek)) case MatroskaConstants.Cues:
{ reader.ReadNext();
reader.EnterContainer(); cuesPosition = (long)reader.ReadUInt();
reader.ReadNext(); break;
var type = (ulong)reader.ReadUIntFromBinary(); case MatroskaConstants.Info:
switch (type) reader.ReadNext();
{ infoPosition = (long)reader.ReadUInt();
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)
{
break; break;
}
} }
reader.LeaveContainer(); 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> reader.LeaveContainer();
/// 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);
double? duration = null; if (!tracksPosition.HasValue || !cuesPosition.HasValue || !infoPosition.HasValue)
{
throw new InvalidOperationException("SeekHead is missing or does not contain Info, Tracks and Cues positions");
}
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.ReadAt(position);
double? duration = null;
reader.EnterContainer();
// Mandatory element
reader.FindElement(MatroskaConstants.TimestampScale);
var timestampScale = reader.ReadUInt();
if (reader.FindElement(MatroskaConstants.Duration))
{
duration = reader.ReadFloat();
}
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(); reader.EnterContainer();
// Mandatory element // Mandatory element
reader.FindElement(MatroskaConstants.TimestampScale); reader.FindElement(MatroskaConstants.TrackNumber);
var timestampScale = reader.ReadUInt(); var trackNumber = reader.ReadUInt();
if (reader.FindElement(MatroskaConstants.Duration)) // Mandatory element
{ reader.FindElement(MatroskaConstants.TrackType);
duration = reader.ReadFloat(); var trackType = reader.ReadUInt();
}
reader.LeaveContainer(); reader.LeaveContainer();
if (trackType == MatroskaConstants.TrackTypeVideo)
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();
// Mandatory element
reader.FindElement(MatroskaConstants.TrackNumber);
var trackNumber = reader.ReadUInt();
// Mandatory element
reader.FindElement(MatroskaConstants.TrackType);
var trackType = reader.ReadUInt();
reader.LeaveContainer(); reader.LeaveContainer();
if (trackType == MatroskaConstants.TrackTypeVideo) return trackNumber;
{
reader.LeaveContainer();
return trackNumber;
}
} }
reader.LeaveContainer();
throw new InvalidOperationException($"No stream with type {type} found");
} }
reader.LeaveContainer();
throw new InvalidOperationException($"No stream with type {type} found");
} }
} }

47
src/Jellyfin.MediaEncoding.Keyframes/Matroska/MatroskaConstants.cs
View File

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

105
src/Jellyfin.MediaEncoding.Keyframes/Matroska/MatroskaKeyframeExtractor.cs
View File

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

45
src/Jellyfin.MediaEncoding.Keyframes/Matroska/Models/Info.cs
View File

@ -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> /// <summary>
/// The matroska Info segment. /// Initializes a new instance of the <see cref="Info"/> class.
/// </summary> /// </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> TimestampScale = timestampScale;
/// Initializes a new instance of the <see cref="Info"/> class. Duration = duration;
/// </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;
}
/// <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 timestamp scale in nanoseconds.
/// </summary>
public long TimestampScale { get; }
/// <summary>
/// Gets the total duration of the file.
/// </summary>
public double? Duration { get; }
} }

59
src/Jellyfin.MediaEncoding.Keyframes/Matroska/Models/SeekHead.cs
View File

@ -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> /// <summary>
/// The matroska SeekHead segment. All positions are relative to the Segment container. /// Initializes a new instance of the <see cref="SeekHead"/> class.
/// </summary> /// </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> InfoPosition = infoPosition;
/// Initializes a new instance of the <see cref="SeekHead"/> class. TracksPosition = tracksPosition;
/// </summary> CuesPosition = cuesPosition;
/// <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;
}
/// <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 cues segment.
/// </summary>
public long CuesPosition { 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 cues segment.
/// </summary>
public long CuesPosition { get; }
} }

6
tests/Jellyfin.MediaEncoding.Hls.Tests/Playlist/DynamicHlsPlaylistGeneratorTests.cs
View File

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

2
tests/Jellyfin.MediaEncoding.Keyframes.Tests/FfProbe/FfProbeKeyframeExtractorTests.cs
View File

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