< Summary - Jellyfin

Information
Class: Jellyfin.Api.Helpers.DynamicHlsHelper
Assembly: Jellyfin.Api
File(s): /srv/git/jellyfin/Jellyfin.Api/Helpers/DynamicHlsHelper.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 259
Coverable lines: 259
Total lines: 858
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 176
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
AppendPlaylist(...)0%620%
AppendPlaylistVideoRangeField(...)0%156120%
AppendPlaylistCodecsField(...)0%156120%
AppendPlaylistSupplementalCodecsField(...)0%210140%
AppendPlaylistResolutionField(...)0%2040%
AppendPlaylistFramerateField(...)0%7280%
EnableAdaptiveBitrateStreaming(...)0%272160%
AddSubtitles(...)0%272160%
AddTrickplay(...)0%620%
GetOutputVideoCodecLevel(...)0%600240%
GetOutputVideoCodecProfile(...)0%420200%
GetPlaylistAudioCodecs(...)0%210140%
GetPlaylistVideoCodecs(...)0%342180%
GetBitrateVariation(...)0%210140%
ReplaceVideoBitrate(...)100%210%
ReplaceProfile(...)100%210%
ReplacePlaylistCodecsField(...)100%210%

File(s)

/srv/git/jellyfin/Jellyfin.Api/Helpers/DynamicHlsHelper.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Globalization;
 4using System.Linq;
 5using System.Net;
 6using System.Security.Claims;
 7using System.Text;
 8using System.Threading;
 9using System.Threading.Tasks;
 10using Jellyfin.Api.Extensions;
 11using Jellyfin.Data.Enums;
 12using Jellyfin.Database.Implementations.Entities;
 13using Jellyfin.Extensions;
 14using MediaBrowser.Common.Configuration;
 15using MediaBrowser.Common.Extensions;
 16using MediaBrowser.Common.Net;
 17using MediaBrowser.Controller.Configuration;
 18using MediaBrowser.Controller.Library;
 19using MediaBrowser.Controller.MediaEncoding;
 20using MediaBrowser.Controller.Streaming;
 21using MediaBrowser.Controller.Trickplay;
 22using MediaBrowser.Model.Dlna;
 23using MediaBrowser.Model.Entities;
 24using MediaBrowser.Model.Net;
 25using Microsoft.AspNetCore.Http;
 26using Microsoft.AspNetCore.Mvc;
 27using Microsoft.Extensions.Logging;
 28using Microsoft.Net.Http.Headers;
 29
 30namespace Jellyfin.Api.Helpers;
 31
 32/// <summary>
 33/// Dynamic hls helper.
 34/// </summary>
 35public class DynamicHlsHelper
 36{
 37    private readonly ILibraryManager _libraryManager;
 38    private readonly IUserManager _userManager;
 39    private readonly IMediaSourceManager _mediaSourceManager;
 40    private readonly IServerConfigurationManager _serverConfigurationManager;
 41    private readonly IMediaEncoder _mediaEncoder;
 42    private readonly ITranscodeManager _transcodeManager;
 43    private readonly INetworkManager _networkManager;
 44    private readonly ILogger<DynamicHlsHelper> _logger;
 45    private readonly IHttpContextAccessor _httpContextAccessor;
 46    private readonly EncodingHelper _encodingHelper;
 47    private readonly ITrickplayManager _trickplayManager;
 48
 49    /// <summary>
 50    /// Initializes a new instance of the <see cref="DynamicHlsHelper"/> class.
 51    /// </summary>
 52    /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
 53    /// <param name="userManager">Instance of the <see cref="IUserManager"/> interface.</param>
 54    /// <param name="mediaSourceManager">Instance of the <see cref="IMediaSourceManager"/> interface.</param>
 55    /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</p
 56    /// <param name="mediaEncoder">Instance of the <see cref="IMediaEncoder"/> interface.</param>
 57    /// <param name="transcodeManager">Instance of <see cref="ITranscodeManager"/>.</param>
 58    /// <param name="networkManager">Instance of the <see cref="INetworkManager"/> interface.</param>
 59    /// <param name="logger">Instance of the <see cref="ILogger{DynamicHlsHelper}"/> interface.</param>
 60    /// <param name="httpContextAccessor">Instance of the <see cref="IHttpContextAccessor"/> interface.</param>
 61    /// <param name="encodingHelper">Instance of <see cref="EncodingHelper"/>.</param>
 62    /// <param name="trickplayManager">Instance of <see cref="ITrickplayManager"/>.</param>
 63    public DynamicHlsHelper(
 64        ILibraryManager libraryManager,
 65        IUserManager userManager,
 66        IMediaSourceManager mediaSourceManager,
 67        IServerConfigurationManager serverConfigurationManager,
 68        IMediaEncoder mediaEncoder,
 69        ITranscodeManager transcodeManager,
 70        INetworkManager networkManager,
 71        ILogger<DynamicHlsHelper> logger,
 72        IHttpContextAccessor httpContextAccessor,
 73        EncodingHelper encodingHelper,
 74        ITrickplayManager trickplayManager)
 75    {
 076        _libraryManager = libraryManager;
 077        _userManager = userManager;
 078        _mediaSourceManager = mediaSourceManager;
 079        _serverConfigurationManager = serverConfigurationManager;
 080        _mediaEncoder = mediaEncoder;
 081        _transcodeManager = transcodeManager;
 082        _networkManager = networkManager;
 083        _logger = logger;
 084        _httpContextAccessor = httpContextAccessor;
 085        _encodingHelper = encodingHelper;
 086        _trickplayManager = trickplayManager;
 087    }
 88
 89    /// <summary>
 90    /// Get master hls playlist.
 91    /// </summary>
 92    /// <param name="transcodingJobType">Transcoding job type.</param>
 93    /// <param name="streamingRequest">Streaming request dto.</param>
 94    /// <param name="enableAdaptiveBitrateStreaming">Enable adaptive bitrate streaming.</param>
 95    /// <returns>A <see cref="Task"/> containing the resulting <see cref="ActionResult"/>.</returns>
 96    public async Task<ActionResult> GetMasterHlsPlaylist(
 97        TranscodingJobType transcodingJobType,
 98        StreamingRequestDto streamingRequest,
 99        bool enableAdaptiveBitrateStreaming)
 100    {
 101        var isHeadRequest = _httpContextAccessor.HttpContext?.Request.Method == WebRequestMethods.Http.Head;
 102        // CTS lifecycle is managed internally.
 103        var cancellationTokenSource = new CancellationTokenSource();
 104        return await GetMasterPlaylistInternal(
 105            streamingRequest,
 106            isHeadRequest,
 107            enableAdaptiveBitrateStreaming,
 108            transcodingJobType,
 109            cancellationTokenSource).ConfigureAwait(false);
 110    }
 111
 112    private async Task<ActionResult> GetMasterPlaylistInternal(
 113        StreamingRequestDto streamingRequest,
 114        bool isHeadRequest,
 115        bool enableAdaptiveBitrateStreaming,
 116        TranscodingJobType transcodingJobType,
 117        CancellationTokenSource cancellationTokenSource)
 118    {
 119        if (_httpContextAccessor.HttpContext is null)
 120        {
 121            throw new ResourceNotFoundException(nameof(_httpContextAccessor.HttpContext));
 122        }
 123
 124        using var state = await StreamingHelpers.GetStreamingState(
 125                streamingRequest,
 126                _httpContextAccessor.HttpContext,
 127                _mediaSourceManager,
 128                _userManager,
 129                _libraryManager,
 130                _serverConfigurationManager,
 131                _mediaEncoder,
 132                _encodingHelper,
 133                _transcodeManager,
 134                transcodingJobType,
 135                cancellationTokenSource.Token)
 136            .ConfigureAwait(false);
 137
 138        _httpContextAccessor.HttpContext.Response.Headers.Append(HeaderNames.Expires, "0");
 139        if (isHeadRequest)
 140        {
 141            return new FileContentResult(Array.Empty<byte>(), MimeTypes.GetMimeType("playlist.m3u8"));
 142        }
 143
 144        var totalBitrate = (state.OutputAudioBitrate ?? 0) + (state.OutputVideoBitrate ?? 0);
 145
 146        var builder = new StringBuilder();
 147
 148        builder.AppendLine("#EXTM3U");
 149
 150        var isLiveStream = state.IsSegmentedLiveStream;
 151
 152        var queryString = _httpContextAccessor.HttpContext.Request.QueryString.ToString();
 153
 154        // from universal audio service, need to override the AudioCodec when the actual request differs from original q
 155        if (!string.Equals(state.OutputAudioCodec, _httpContextAccessor.HttpContext.Request.Query["AudioCodec"].ToString
 156        {
 157            var newQuery = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(_httpContextAccessor.HttpContext.Re
 158            newQuery["AudioCodec"] = state.OutputAudioCodec;
 159            queryString = Microsoft.AspNetCore.WebUtilities.QueryHelpers.AddQueryString(string.Empty, newQuery);
 160        }
 161
 162        // from universal audio service
 163        if (!string.IsNullOrWhiteSpace(state.Request.SegmentContainer)
 164            && !queryString.Contains("SegmentContainer", StringComparison.OrdinalIgnoreCase))
 165        {
 166            queryString += "&SegmentContainer=" + state.Request.SegmentContainer;
 167        }
 168
 169        // from universal audio service
 170        if (!string.IsNullOrWhiteSpace(state.Request.TranscodeReasons)
 171            && !queryString.Contains("TranscodeReasons=", StringComparison.OrdinalIgnoreCase))
 172        {
 173            queryString += "&TranscodeReasons=" + state.Request.TranscodeReasons;
 174        }
 175
 176        // Main stream
 177        var playlistUrl = isLiveStream ? "live.m3u8" : "main.m3u8";
 178
 179        playlistUrl += queryString;
 180
 181        var subtitleStreams = state.MediaSource
 182            .MediaStreams
 183            .Where(i => i.IsTextSubtitleStream)
 184            .ToList();
 185
 186        var subtitleGroup = subtitleStreams.Count > 0 && (state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Hls || 
 187            ? "subs"
 188            : null;
 189
 190        // If we're burning in subtitles then don't add additional subs to the manifest
 191        if (state.SubtitleStream is not null && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
 192        {
 193            subtitleGroup = null;
 194        }
 195
 196        if (!string.IsNullOrWhiteSpace(subtitleGroup))
 197        {
 198            AddSubtitles(state, subtitleStreams, builder, _httpContextAccessor.HttpContext.User);
 199        }
 200
 201        // Video rotation metadata is only supported in fMP4 remuxing
 202        if (state.VideoStream is not null
 203            && state.VideoRequest is not null
 204            && (state.VideoStream?.Rotation ?? 0) != 0
 205            && EncodingHelper.IsCopyCodec(state.OutputVideoCodec)
 206            && !string.IsNullOrWhiteSpace(state.Request.SegmentContainer)
 207            && !string.Equals(state.Request.SegmentContainer, "mp4", StringComparison.OrdinalIgnoreCase))
 208        {
 209            playlistUrl += "&AllowVideoStreamCopy=false";
 210        }
 211
 212        var basicPlaylist = AppendPlaylist(builder, state, playlistUrl, totalBitrate, subtitleGroup);
 213
 214        if (state.VideoStream is not null && state.VideoRequest is not null)
 215        {
 216            var encodingOptions = _serverConfigurationManager.GetEncodingOptions();
 217
 218            // Provide SDR HEVC entrance for backward compatibility.
 219            if (encodingOptions.AllowHevcEncoding
 220                && !encodingOptions.AllowAv1Encoding
 221                && EncodingHelper.IsCopyCodec(state.OutputVideoCodec)
 222                && state.VideoStream.VideoRange == VideoRange.HDR
 223                && string.Equals(state.ActualOutputVideoCodec, "hevc", StringComparison.OrdinalIgnoreCase))
 224            {
 225                var requestedVideoProfiles = state.GetRequestedProfiles("hevc");
 226                if (requestedVideoProfiles is not null && requestedVideoProfiles.Length > 0)
 227                {
 228                    // Force HEVC Main Profile and disable video stream copy.
 229                    state.OutputVideoCodec = "hevc";
 230                    var sdrVideoUrl = ReplaceProfile(playlistUrl, "hevc", string.Join(',', requestedVideoProfiles), "mai
 231                    sdrVideoUrl += "&AllowVideoStreamCopy=false";
 232
 233                    // HACK: Use the same bitrate so that the client can choose by other attributes, such as color range
 234                    AppendPlaylist(builder, state, sdrVideoUrl, totalBitrate, subtitleGroup);
 235
 236                    // Restore the video codec
 237                    state.OutputVideoCodec = "copy";
 238                }
 239            }
 240
 241            // Provide Level 5.0 entrance for backward compatibility.
 242            // e.g. Apple A10 chips refuse the master playlist containing SDR HEVC Main Level 5.1 video,
 243            // but in fact it is capable of playing videos up to Level 6.1.
 244            if (encodingOptions.AllowHevcEncoding
 245                && !encodingOptions.AllowAv1Encoding
 246                && EncodingHelper.IsCopyCodec(state.OutputVideoCodec)
 247                && state.VideoStream.Level.HasValue
 248                && state.VideoStream.Level > 150
 249                && state.VideoStream.VideoRange == VideoRange.SDR
 250                && string.Equals(state.ActualOutputVideoCodec, "hevc", StringComparison.OrdinalIgnoreCase))
 251            {
 252                var playlistCodecsField = new StringBuilder();
 253                AppendPlaylistCodecsField(playlistCodecsField, state);
 254
 255                // Force the video level to 5.0.
 256                var originalLevel = state.VideoStream.Level;
 257                state.VideoStream.Level = 150;
 258                var newPlaylistCodecsField = new StringBuilder();
 259                AppendPlaylistCodecsField(newPlaylistCodecsField, state);
 260
 261                // Restore the video level.
 262                state.VideoStream.Level = originalLevel;
 263                var newPlaylist = ReplacePlaylistCodecsField(basicPlaylist, playlistCodecsField, newPlaylistCodecsField)
 264                builder.Append(newPlaylist);
 265            }
 266        }
 267
 268        if (EnableAdaptiveBitrateStreaming(state, isLiveStream, enableAdaptiveBitrateStreaming, _httpContextAccessor.Htt
 269        {
 270            var requestedVideoBitrate = state.VideoRequest?.VideoBitRate ?? 0;
 271
 272            // By default, vary by just 200k
 273            var variation = GetBitrateVariation(totalBitrate);
 274
 275            var newBitrate = totalBitrate - variation;
 276            var variantUrl = ReplaceVideoBitrate(playlistUrl, requestedVideoBitrate, requestedVideoBitrate - variation);
 277            AppendPlaylist(builder, state, variantUrl, newBitrate, subtitleGroup);
 278
 279            variation *= 2;
 280            newBitrate = totalBitrate - variation;
 281            variantUrl = ReplaceVideoBitrate(playlistUrl, requestedVideoBitrate, requestedVideoBitrate - variation);
 282            AppendPlaylist(builder, state, variantUrl, newBitrate, subtitleGroup);
 283        }
 284
 285        if (!isLiveStream && (state.VideoRequest?.EnableTrickplay ?? false))
 286        {
 287            var sourceId = Guid.Parse(state.Request.MediaSourceId);
 288            var trickplayResolutions = await _trickplayManager.GetTrickplayResolutions(sourceId).ConfigureAwait(false);
 289            AddTrickplay(state, trickplayResolutions, builder, _httpContextAccessor.HttpContext.User);
 290        }
 291
 292        return new FileContentResult(Encoding.UTF8.GetBytes(builder.ToString()), MimeTypes.GetMimeType("playlist.m3u8"))
 293    }
 294
 295    private StringBuilder AppendPlaylist(StringBuilder builder, StreamState state, string url, int bitrate, string? subt
 296    {
 0297        var playlistBuilder = new StringBuilder();
 0298        playlistBuilder.Append("#EXT-X-STREAM-INF:BANDWIDTH=")
 0299            .Append(bitrate.ToString(CultureInfo.InvariantCulture))
 0300            .Append(",AVERAGE-BANDWIDTH=")
 0301            .Append(bitrate.ToString(CultureInfo.InvariantCulture));
 302
 0303        AppendPlaylistVideoRangeField(playlistBuilder, state);
 304
 0305        AppendPlaylistCodecsField(playlistBuilder, state);
 306
 0307        AppendPlaylistSupplementalCodecsField(playlistBuilder, state);
 308
 0309        AppendPlaylistResolutionField(playlistBuilder, state);
 310
 0311        AppendPlaylistFramerateField(playlistBuilder, state);
 312
 0313        if (!string.IsNullOrWhiteSpace(subtitleGroup))
 314        {
 0315            playlistBuilder.Append(",SUBTITLES=\"")
 0316                .Append(subtitleGroup)
 0317                .Append('"');
 318        }
 319
 0320        playlistBuilder.Append(Environment.NewLine);
 0321        playlistBuilder.AppendLine(url);
 0322        builder.Append(playlistBuilder);
 323
 0324        return playlistBuilder;
 325    }
 326
 327    /// <summary>
 328    /// Appends a VIDEO-RANGE field containing the range of the output video stream.
 329    /// </summary>
 330    /// <seealso cref="AppendPlaylist(StringBuilder, StreamState, string, int, string)"/>
 331    /// <param name="builder">StringBuilder to append the field to.</param>
 332    /// <param name="state">StreamState of the current stream.</param>
 333    private void AppendPlaylistVideoRangeField(StringBuilder builder, StreamState state)
 334    {
 0335        if (state.VideoStream is not null && state.VideoStream.VideoRange != VideoRange.Unknown)
 336        {
 0337            var videoRange = state.VideoStream.VideoRange;
 0338            var videoRangeType = state.VideoStream.VideoRangeType;
 0339            if (EncodingHelper.IsCopyCodec(state.OutputVideoCodec))
 340            {
 0341                if (videoRange == VideoRange.SDR)
 342                {
 0343                    builder.Append(",VIDEO-RANGE=SDR");
 344                }
 345
 0346                if (videoRange == VideoRange.HDR)
 347                {
 0348                    if (videoRangeType == VideoRangeType.HLG)
 349                    {
 0350                        builder.Append(",VIDEO-RANGE=HLG");
 351                    }
 352                    else
 353                    {
 0354                        builder.Append(",VIDEO-RANGE=PQ");
 355                    }
 356                }
 357            }
 358            else
 359            {
 360                // Currently we only encode to SDR.
 0361                builder.Append(",VIDEO-RANGE=SDR");
 362            }
 363        }
 0364    }
 365
 366    /// <summary>
 367    /// Appends a CODECS field containing formatted strings of
 368    /// the active streams output video and audio codecs.
 369    /// </summary>
 370    /// <seealso cref="AppendPlaylist(StringBuilder, StreamState, string, int, string)"/>
 371    /// <seealso cref="GetPlaylistVideoCodecs(StreamState, string, int)"/>
 372    /// <seealso cref="GetPlaylistAudioCodecs(StreamState)"/>
 373    /// <param name="builder">StringBuilder to append the field to.</param>
 374    /// <param name="state">StreamState of the current stream.</param>
 375    private void AppendPlaylistCodecsField(StringBuilder builder, StreamState state)
 376    {
 377        // Video
 0378        string videoCodecs = string.Empty;
 0379        int? videoCodecLevel = GetOutputVideoCodecLevel(state);
 0380        if (!string.IsNullOrEmpty(state.ActualOutputVideoCodec) && videoCodecLevel.HasValue)
 381        {
 0382            videoCodecs = GetPlaylistVideoCodecs(state, state.ActualOutputVideoCodec, videoCodecLevel.Value);
 383        }
 384
 385        // Audio
 0386        string audioCodecs = string.Empty;
 0387        if (!string.IsNullOrEmpty(state.ActualOutputAudioCodec))
 388        {
 0389            audioCodecs = GetPlaylistAudioCodecs(state);
 390        }
 391
 0392        StringBuilder codecs = new StringBuilder();
 393
 0394        codecs.Append(videoCodecs);
 395
 0396        if (!string.IsNullOrEmpty(videoCodecs) && !string.IsNullOrEmpty(audioCodecs))
 397        {
 0398            codecs.Append(',');
 399        }
 400
 0401        codecs.Append(audioCodecs);
 402
 0403        if (codecs.Length > 1)
 404        {
 0405            builder.Append(",CODECS=\"")
 0406                .Append(codecs)
 0407                .Append('"');
 408        }
 0409    }
 410
 411    /// <summary>
 412    /// Appends a SUPPLEMENTAL-CODECS field containing formatted strings of
 413    /// the active streams output Dolby Vision Videos.
 414    /// </summary>
 415    /// <seealso cref="AppendPlaylist(StringBuilder, StreamState, string, int, string)"/>
 416    /// <seealso cref="GetPlaylistVideoCodecs(StreamState, string, int)"/>
 417    /// <param name="builder">StringBuilder to append the field to.</param>
 418    /// <param name="state">StreamState of the current stream.</param>
 419    private void AppendPlaylistSupplementalCodecsField(StringBuilder builder, StreamState state)
 420    {
 421        // Dolby Vision currently cannot exist when transcoding
 0422        if (!EncodingHelper.IsCopyCodec(state.OutputVideoCodec))
 423        {
 0424            return;
 425        }
 426
 0427        var dvProfile = state.VideoStream.DvProfile;
 0428        var dvLevel = state.VideoStream.DvLevel;
 0429        var dvRangeString = state.VideoStream.VideoRangeType switch
 0430        {
 0431            VideoRangeType.DOVIWithHDR10 => "db1p",
 0432            VideoRangeType.DOVIWithHLG => "db4h",
 0433            _ => string.Empty
 0434        };
 435
 0436        if (dvProfile is null || dvLevel is null || string.IsNullOrEmpty(dvRangeString))
 437        {
 0438            return;
 439        }
 440
 0441        var dvFourCc = string.Equals(state.ActualOutputVideoCodec, "av1", StringComparison.OrdinalIgnoreCase) ? "dav1" :
 0442        builder.Append(",SUPPLEMENTAL-CODECS=\"")
 0443            .Append(dvFourCc)
 0444            .Append('.')
 0445            .Append(dvProfile.Value.ToString("D2", CultureInfo.InvariantCulture))
 0446            .Append('.')
 0447            .Append(dvLevel.Value.ToString("D2", CultureInfo.InvariantCulture))
 0448            .Append('/')
 0449            .Append(dvRangeString)
 0450            .Append('"');
 0451    }
 452
 453    /// <summary>
 454    /// Appends a RESOLUTION field containing the resolution of the output stream.
 455    /// </summary>
 456    /// <seealso cref="AppendPlaylist(StringBuilder, StreamState, string, int, string)"/>
 457    /// <param name="builder">StringBuilder to append the field to.</param>
 458    /// <param name="state">StreamState of the current stream.</param>
 459    private void AppendPlaylistResolutionField(StringBuilder builder, StreamState state)
 460    {
 0461        if (state.OutputWidth.HasValue && state.OutputHeight.HasValue)
 462        {
 0463            builder.Append(",RESOLUTION=")
 0464                .Append(state.OutputWidth.GetValueOrDefault())
 0465                .Append('x')
 0466                .Append(state.OutputHeight.GetValueOrDefault());
 467        }
 0468    }
 469
 470    /// <summary>
 471    /// Appends a FRAME-RATE field containing the framerate of the output stream.
 472    /// </summary>
 473    /// <seealso cref="AppendPlaylist(StringBuilder, StreamState, string, int, string)"/>
 474    /// <param name="builder">StringBuilder to append the field to.</param>
 475    /// <param name="state">StreamState of the current stream.</param>
 476    private void AppendPlaylistFramerateField(StringBuilder builder, StreamState state)
 477    {
 0478        double? framerate = null;
 0479        if (state.TargetFramerate.HasValue)
 480        {
 0481            framerate = Math.Round(state.TargetFramerate.GetValueOrDefault(), 3);
 482        }
 0483        else if (state.VideoStream?.RealFrameRate is not null)
 484        {
 0485            framerate = Math.Round(state.VideoStream.RealFrameRate.GetValueOrDefault(), 3);
 486        }
 487
 0488        if (framerate.HasValue)
 489        {
 0490            builder.Append(",FRAME-RATE=")
 0491                .Append(framerate.Value.ToString(CultureInfo.InvariantCulture));
 492        }
 0493    }
 494
 495    private bool EnableAdaptiveBitrateStreaming(StreamState state, bool isLiveStream, bool enableAdaptiveBitrateStreamin
 496    {
 497        // Within the local network this will likely do more harm than good.
 0498        if (_networkManager.IsInLocalNetwork(ipAddress))
 499        {
 0500            return false;
 501        }
 502
 0503        if (!enableAdaptiveBitrateStreaming)
 504        {
 0505            return false;
 506        }
 507
 0508        if (isLiveStream || string.IsNullOrWhiteSpace(state.MediaPath))
 509        {
 510            // Opening live streams is so slow it's not even worth it
 0511            return false;
 512        }
 513
 0514        if (EncodingHelper.IsCopyCodec(state.OutputVideoCodec))
 515        {
 0516            return false;
 517        }
 518
 0519        if (EncodingHelper.IsCopyCodec(state.OutputAudioCodec))
 520        {
 0521            return false;
 522        }
 523
 0524        if (!state.IsOutputVideo)
 525        {
 0526            return false;
 527        }
 528
 0529        return state.VideoRequest?.VideoBitRate.HasValue ?? false;
 530    }
 531
 532    private void AddSubtitles(StreamState state, IEnumerable<MediaStream> subtitles, StringBuilder builder, ClaimsPrinci
 533    {
 0534        if (state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Drop)
 535        {
 0536            return;
 537        }
 538
 0539        var selectedIndex = state.SubtitleStream is null || state.SubtitleDeliveryMethod != SubtitleDeliveryMethod.Hls ?
 540        const string Format = "#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID=\"subs\",NAME=\"{0}\",DEFAULT={1},FORCED={2},AUTOSEL
 541
 0542        foreach (var stream in subtitles)
 543        {
 0544            var name = stream.DisplayTitle;
 545
 0546            var isDefault = selectedIndex.HasValue && selectedIndex.Value == stream.Index;
 0547            var isForced = stream.IsForced;
 548
 0549            var url = string.Format(
 0550                CultureInfo.InvariantCulture,
 0551                "{0}/Subtitles/{1}/subtitles.m3u8?SegmentLength={2}&ApiKey={3}",
 0552                state.Request.MediaSourceId,
 0553                stream.Index.ToString(CultureInfo.InvariantCulture),
 0554                30.ToString(CultureInfo.InvariantCulture),
 0555                user.GetToken());
 556
 0557            var line = string.Format(
 0558                CultureInfo.InvariantCulture,
 0559                Format,
 0560                name,
 0561                isDefault ? "YES" : "NO",
 0562                isForced ? "YES" : "NO",
 0563                url,
 0564                stream.Language ?? "Unknown");
 565
 0566            builder.AppendLine(line);
 567        }
 0568    }
 569
 570    /// <summary>
 571    /// Appends EXT-X-IMAGE-STREAM-INF playlists for each available trickplay resolution.
 572    /// </summary>
 573    /// <param name="state">StreamState of the current stream.</param>
 574    /// <param name="trickplayResolutions">Dictionary of widths to corresponding tiles info.</param>
 575    /// <param name="builder">StringBuilder to append the field to.</param>
 576    /// <param name="user">Http user context.</param>
 577    private void AddTrickplay(StreamState state, Dictionary<int, TrickplayInfo> trickplayResolutions, StringBuilder buil
 578    {
 579        const string playlistFormat = "#EXT-X-IMAGE-STREAM-INF:BANDWIDTH={0},RESOLUTION={1}x{2},CODECS=\"jpeg\",URI=\"{3
 580
 0581        foreach (var resolution in trickplayResolutions)
 582        {
 0583            var width = resolution.Key;
 0584            var trickplayInfo = resolution.Value;
 585
 0586            var url = string.Format(
 0587                CultureInfo.InvariantCulture,
 0588                "Trickplay/{0}/tiles.m3u8?MediaSourceId={1}&ApiKey={2}",
 0589                width.ToString(CultureInfo.InvariantCulture),
 0590                state.Request.MediaSourceId,
 0591                user.GetToken());
 592
 0593            builder.AppendFormat(
 0594                CultureInfo.InvariantCulture,
 0595                playlistFormat,
 0596                trickplayInfo.Bandwidth.ToString(CultureInfo.InvariantCulture),
 0597                trickplayInfo.Width.ToString(CultureInfo.InvariantCulture),
 0598                trickplayInfo.Height.ToString(CultureInfo.InvariantCulture),
 0599                url);
 600
 0601            builder.AppendLine();
 602        }
 0603    }
 604
 605    /// <summary>
 606    /// Get the H.26X level of the output video stream.
 607    /// </summary>
 608    /// <param name="state">StreamState of the current stream.</param>
 609    /// <returns>H.26X level of the output video stream.</returns>
 610    private int? GetOutputVideoCodecLevel(StreamState state)
 611    {
 0612        string levelString = string.Empty;
 0613        if (EncodingHelper.IsCopyCodec(state.OutputVideoCodec)
 0614            && state.VideoStream is not null
 0615            && state.VideoStream.Level.HasValue)
 616        {
 0617            levelString = state.VideoStream.Level.Value.ToString(CultureInfo.InvariantCulture);
 618        }
 619        else
 620        {
 0621            if (string.Equals(state.ActualOutputVideoCodec, "h264", StringComparison.OrdinalIgnoreCase))
 622            {
 0623                levelString = state.GetRequestedLevel(state.ActualOutputVideoCodec) ?? "41";
 0624                levelString = EncodingHelper.NormalizeTranscodingLevel(state, levelString);
 625            }
 626
 0627            if (string.Equals(state.ActualOutputVideoCodec, "h265", StringComparison.OrdinalIgnoreCase)
 0628                || string.Equals(state.ActualOutputVideoCodec, "hevc", StringComparison.OrdinalIgnoreCase))
 629            {
 0630                levelString = state.GetRequestedLevel("h265") ?? state.GetRequestedLevel("hevc") ?? "120";
 0631                levelString = EncodingHelper.NormalizeTranscodingLevel(state, levelString);
 632            }
 633
 0634            if (string.Equals(state.ActualOutputVideoCodec, "av1", StringComparison.OrdinalIgnoreCase))
 635            {
 0636                levelString = state.GetRequestedLevel("av1") ?? "19";
 0637                levelString = EncodingHelper.NormalizeTranscodingLevel(state, levelString);
 638            }
 639        }
 640
 0641        if (int.TryParse(levelString, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsedLevel))
 642        {
 0643            return parsedLevel;
 644        }
 645
 0646        return null;
 647    }
 648
 649    /// <summary>
 650    /// Get the profile of the output video stream.
 651    /// </summary>
 652    /// <param name="state">StreamState of the current stream.</param>
 653    /// <param name="codec">Video codec.</param>
 654    /// <returns>Profile of the output video stream.</returns>
 655    private string GetOutputVideoCodecProfile(StreamState state, string codec)
 656    {
 0657        string profileString = string.Empty;
 0658        if (EncodingHelper.IsCopyCodec(state.OutputVideoCodec)
 0659            && !string.IsNullOrEmpty(state.VideoStream.Profile))
 660        {
 0661            profileString = state.VideoStream.Profile;
 662        }
 0663        else if (!string.IsNullOrEmpty(codec))
 664        {
 0665            profileString = state.GetRequestedProfiles(codec).FirstOrDefault() ?? string.Empty;
 0666            if (string.Equals(state.ActualOutputVideoCodec, "h264", StringComparison.OrdinalIgnoreCase))
 667            {
 0668                profileString ??= "high";
 669            }
 670
 0671            if (string.Equals(state.ActualOutputVideoCodec, "h265", StringComparison.OrdinalIgnoreCase)
 0672                || string.Equals(state.ActualOutputVideoCodec, "hevc", StringComparison.OrdinalIgnoreCase)
 0673                || string.Equals(state.ActualOutputVideoCodec, "av1", StringComparison.OrdinalIgnoreCase))
 674            {
 0675                profileString ??= "main";
 676            }
 677        }
 678
 0679        return profileString;
 680    }
 681
 682    /// <summary>
 683    /// Gets a formatted string of the output audio codec, for use in the CODECS field.
 684    /// </summary>
 685    /// <seealso cref="AppendPlaylistCodecsField(StringBuilder, StreamState)"/>
 686    /// <seealso cref="GetPlaylistVideoCodecs(StreamState, string, int)"/>
 687    /// <param name="state">StreamState of the current stream.</param>
 688    /// <returns>Formatted audio codec string.</returns>
 689    private string GetPlaylistAudioCodecs(StreamState state)
 690    {
 0691        if (string.Equals(state.ActualOutputAudioCodec, "aac", StringComparison.OrdinalIgnoreCase))
 692        {
 0693            string? profile = state.GetRequestedProfiles("aac").FirstOrDefault();
 0694            return HlsCodecStringHelpers.GetAACString(profile);
 695        }
 696
 0697        if (string.Equals(state.ActualOutputAudioCodec, "mp3", StringComparison.OrdinalIgnoreCase))
 698        {
 0699            return HlsCodecStringHelpers.GetMP3String();
 700        }
 701
 0702        if (string.Equals(state.ActualOutputAudioCodec, "ac3", StringComparison.OrdinalIgnoreCase))
 703        {
 0704            return HlsCodecStringHelpers.GetAC3String();
 705        }
 706
 0707        if (string.Equals(state.ActualOutputAudioCodec, "eac3", StringComparison.OrdinalIgnoreCase))
 708        {
 0709            return HlsCodecStringHelpers.GetEAC3String();
 710        }
 711
 0712        if (string.Equals(state.ActualOutputAudioCodec, "flac", StringComparison.OrdinalIgnoreCase))
 713        {
 0714            return HlsCodecStringHelpers.GetFLACString();
 715        }
 716
 0717        if (string.Equals(state.ActualOutputAudioCodec, "alac", StringComparison.OrdinalIgnoreCase))
 718        {
 0719            return HlsCodecStringHelpers.GetALACString();
 720        }
 721
 0722        if (string.Equals(state.ActualOutputAudioCodec, "opus", StringComparison.OrdinalIgnoreCase))
 723        {
 0724            return HlsCodecStringHelpers.GetOPUSString();
 725        }
 726
 0727        return string.Empty;
 728    }
 729
 730    /// <summary>
 731    /// Gets a formatted string of the output video codec, for use in the CODECS field.
 732    /// </summary>
 733    /// <seealso cref="AppendPlaylistCodecsField(StringBuilder, StreamState)"/>
 734    /// <seealso cref="GetPlaylistAudioCodecs(StreamState)"/>
 735    /// <param name="state">StreamState of the current stream.</param>
 736    /// <param name="codec">Video codec.</param>
 737    /// <param name="level">Video level.</param>
 738    /// <returns>Formatted video codec string.</returns>
 739    private string GetPlaylistVideoCodecs(StreamState state, string codec, int level)
 740    {
 0741        if (level == 0)
 742        {
 743            // This is 0 when there's no requested level in the device profile
 744            // and the source is not encoded in H.26X or AV1
 0745            _logger.LogError("Got invalid level when building CODECS field for HLS master playlist");
 0746            return string.Empty;
 747        }
 748
 0749        if (string.Equals(codec, "h264", StringComparison.OrdinalIgnoreCase))
 750        {
 0751            string profile = GetOutputVideoCodecProfile(state, "h264");
 0752            return HlsCodecStringHelpers.GetH264String(profile, level);
 753        }
 754
 0755        if (string.Equals(codec, "h265", StringComparison.OrdinalIgnoreCase)
 0756            || string.Equals(codec, "hevc", StringComparison.OrdinalIgnoreCase))
 757        {
 0758            string profile = GetOutputVideoCodecProfile(state, "hevc");
 0759            return HlsCodecStringHelpers.GetH265String(profile, level);
 760        }
 761
 0762        if (string.Equals(codec, "av1", StringComparison.OrdinalIgnoreCase))
 763        {
 0764            string profile = GetOutputVideoCodecProfile(state, "av1");
 765
 766            // Currently we only transcode to 8 bits AV1
 0767            int bitDepth = 8;
 0768            if (EncodingHelper.IsCopyCodec(state.OutputVideoCodec)
 0769                && state.VideoStream is not null
 0770                && state.VideoStream.BitDepth.HasValue)
 771            {
 0772                bitDepth = state.VideoStream.BitDepth.Value;
 773            }
 774
 0775            return HlsCodecStringHelpers.GetAv1String(profile, level, false, bitDepth);
 776        }
 777
 778        // VP9 HLS is for video remuxing only, everything is probed from the original video
 0779        if (string.Equals(codec, "vp9", StringComparison.OrdinalIgnoreCase))
 780        {
 0781            var width = state.VideoStream.Width ?? 0;
 0782            var height = state.VideoStream.Height ?? 0;
 0783            var framerate = state.VideoStream.ReferenceFrameRate ?? 30;
 0784            var bitDepth = state.VideoStream.BitDepth ?? 8;
 0785            return HlsCodecStringHelpers.GetVp9String(
 0786                width,
 0787                height,
 0788                state.VideoStream.PixelFormat,
 0789                framerate,
 0790                bitDepth);
 791        }
 792
 0793        return string.Empty;
 794    }
 795
 796    private int GetBitrateVariation(int bitrate)
 797    {
 798        // By default, vary by just 50k
 0799        var variation = 50000;
 800
 0801        if (bitrate >= 10000000)
 802        {
 0803            variation = 2000000;
 804        }
 0805        else if (bitrate >= 5000000)
 806        {
 0807            variation = 1500000;
 808        }
 0809        else if (bitrate >= 3000000)
 810        {
 0811            variation = 1000000;
 812        }
 0813        else if (bitrate >= 2000000)
 814        {
 0815            variation = 500000;
 816        }
 0817        else if (bitrate >= 1000000)
 818        {
 0819            variation = 300000;
 820        }
 0821        else if (bitrate >= 600000)
 822        {
 0823            variation = 200000;
 824        }
 0825        else if (bitrate >= 400000)
 826        {
 0827            variation = 100000;
 828        }
 829
 0830        return variation;
 831    }
 832
 833    private string ReplaceVideoBitrate(string url, int oldValue, int newValue)
 834    {
 0835        return url.Replace(
 0836            "videobitrate=" + oldValue.ToString(CultureInfo.InvariantCulture),
 0837            "videobitrate=" + newValue.ToString(CultureInfo.InvariantCulture),
 0838            StringComparison.OrdinalIgnoreCase);
 839    }
 840
 841    private string ReplaceProfile(string url, string codec, string oldValue, string newValue)
 842    {
 0843        string profileStr = codec + "-profile=";
 0844        return url.Replace(
 0845            profileStr + oldValue,
 0846            profileStr + newValue,
 0847            StringComparison.OrdinalIgnoreCase);
 848    }
 849
 850    private string ReplacePlaylistCodecsField(StringBuilder playlist, StringBuilder oldValue, StringBuilder newValue)
 851    {
 0852        var oldPlaylist = playlist.ToString();
 0853        return oldPlaylist.Replace(
 0854            oldValue.ToString(),
 0855            newValue.ToString(),
 0856            StringComparison.Ordinal);
 857    }
 858}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:21 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Controller.Library.ILibraryManager,MediaBrowser.Controller.Library.IUserManager,MediaBrowser.Controller.Library.IMediaSourceManager,MediaBrowser.Controller.Configuration.IServerConfigurationManager,MediaBrowser.Controller.MediaEncoding.IMediaEncoder,MediaBrowser.Controller.MediaEncoding.ITranscodeManager,MediaBrowser.Common.Net.INetworkManager,Microsoft.Extensions.Logging.ILogger`1<Jellyfin.Api.Helpers.DynamicHlsHelper>,Microsoft.AspNetCore.Http.IHttpContextAccessor,MediaBrowser.Controller.MediaEncoding.EncodingHelper,MediaBrowser.Controller.Trickplay.ITrickplayManager)
AppendPlaylist(System.Text.StringBuilder,MediaBrowser.Controller.Streaming.StreamState,System.String,System.Int32,System.String)
AppendPlaylistVideoRangeField(System.Text.StringBuilder,MediaBrowser.Controller.Streaming.StreamState)
AppendPlaylistCodecsField(System.Text.StringBuilder,MediaBrowser.Controller.Streaming.StreamState)
AppendPlaylistSupplementalCodecsField(System.Text.StringBuilder,MediaBrowser.Controller.Streaming.StreamState)
AppendPlaylistResolutionField(System.Text.StringBuilder,MediaBrowser.Controller.Streaming.StreamState)
AppendPlaylistFramerateField(System.Text.StringBuilder,MediaBrowser.Controller.Streaming.StreamState)
EnableAdaptiveBitrateStreaming(MediaBrowser.Controller.Streaming.StreamState,System.Boolean,System.Boolean,System.Net.IPAddress)
AddSubtitles(MediaBrowser.Controller.Streaming.StreamState,System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.Entities.MediaStream>,System.Text.StringBuilder,System.Security.Claims.ClaimsPrincipal)
AddTrickplay(MediaBrowser.Controller.Streaming.StreamState,System.Collections.Generic.Dictionary`2<System.Int32,Jellyfin.Database.Implementations.Entities.TrickplayInfo>,System.Text.StringBuilder,System.Security.Claims.ClaimsPrincipal)
GetOutputVideoCodecLevel(MediaBrowser.Controller.Streaming.StreamState)
GetOutputVideoCodecProfile(MediaBrowser.Controller.Streaming.StreamState,System.String)
GetPlaylistAudioCodecs(MediaBrowser.Controller.Streaming.StreamState)
GetPlaylistVideoCodecs(MediaBrowser.Controller.Streaming.StreamState,System.String,System.Int32)
GetBitrateVariation(System.Int32)
ReplaceVideoBitrate(System.String,System.Int32,System.Int32)
ReplaceProfile(System.String,System.String,System.String,System.String)
ReplacePlaylistCodecsField(System.Text.StringBuilder,System.Text.StringBuilder,System.Text.StringBuilder)