< Summary - Jellyfin

Information
Class: MediaBrowser.Model.Dlna.StreamBuilder
Assembly: MediaBrowser.Model
File(s): /srv/git/jellyfin/MediaBrowser.Model/Dlna/StreamBuilder.cs
Line coverage
69%
Covered lines: 759
Uncovered lines: 326
Coverable lines: 1085
Total lines: 2461
Line coverage: 69.9%
Branch coverage
59%
Covered branches: 583
Total branches: 982
Branch coverage: 59.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 3/5/2026 - 12:13:57 AM Line coverage: 68.6% (724/1055) Branch coverage: 58.7% (553/942) Total lines: 23994/12/2026 - 12:13:54 AM Line coverage: 69.1% (730/1055) Branch coverage: 61.2% (578/944) Total lines: 23995/11/2026 - 12:15:59 AM Line coverage: 68.5% (733/1069) Branch coverage: 60.8% (584/960) Total lines: 24365/20/2026 - 12:15:44 AM Line coverage: 69.6% (749/1075) Branch coverage: 59.7% (576/964) Total lines: 24496/1/2026 - 12:16:05 AM Line coverage: 69.9% (759/1085) Branch coverage: 59.3% (583/982) Total lines: 2461 3/5/2026 - 12:13:57 AM Line coverage: 68.6% (724/1055) Branch coverage: 58.7% (553/942) Total lines: 23994/12/2026 - 12:13:54 AM Line coverage: 69.1% (730/1055) Branch coverage: 61.2% (578/944) Total lines: 23995/11/2026 - 12:15:59 AM Line coverage: 68.5% (733/1069) Branch coverage: 60.8% (584/960) Total lines: 24365/20/2026 - 12:15:44 AM Line coverage: 69.6% (749/1075) Branch coverage: 59.7% (576/964) Total lines: 24496/1/2026 - 12:16:05 AM Line coverage: 69.9% (759/1085) Branch coverage: 59.3% (583/982) Total lines: 2461

Coverage delta

Coverage delta 3 -3

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
GetOptimalAudioStream(...)0%110100%
GetOptimalAudioStream(...)0%4692680%
GetOptimalVideoStream(...)80%1010100%
GetOptimalStream(...)100%11100%
SortMediaSources(...)100%11100%
GetTranscodeReasonForFailedCondition(...)32.14%2362835.71%
NormalizeMediaSourceFormatIntoSingleContainer(...)87.5%1616100%
GetAudioDirectPlayProfile(...)0%600240%
GetTranscodeReasonsFromDirectPlayProfile(...)0%420200%
GetDefaultSubtitleStreamIndex(...)82.35%353490.9%
SetStreamInfoOptionsFromTranscodingProfile(...)75%8895%
SetStreamInfoOptionsFromDirectPlayProfile(...)0%620%
BuildVideoItem(...)58.92%14011286.91%
GetVideoTranscodeProfile(...)70%101096.96%
BuildStreamVideoItem(...)88.28%12812897.27%
GetDefaultAudioBitrate(...)59.09%332271.42%
GetAudioBitrate(...)81.25%323295.83%
GetMaxAudioBitrateForTotalBitrate(...)68.75%231670.58%
GetVideoDirectPlayProfile(...)54.54%222296.11%
AggregateFailureConditions(...)100%11100%
LogConditionFailure(...)66.66%66100%
GetSubtitleProfile(...)78.94%473881.81%
IsSubtitleEmbedSupported(...)100%66100%
CanConsiderEmbedSubtitle(...)100%88100%
GetExternalSubtitleProfile(...)81.25%4848100%
IsBitrateLimitExceeded(...)66.66%6690.9%
ValidateMediaOptions(...)68.75%351658.33%
GetProfileConditionsForVideoAudio(...)100%11100%
GetProfileConditionsForAudio(...)0%620%
ApplyTranscodingConditions(...)61.63%927523244.82%
IsAudioContainerSupported(...)0%2040%
IsAudioDirectPlaySupported(...)0%4260%
IsAudioDirectStreamSupported(...)0%4260%
GetRank(...)100%44100%
CheckVideoConditions(...)50%3232100%
GetCompatibilityContainer(...)100%11100%
GetCompatibilityVideoCodec(...)100%11100%
GetCompatibilityAudioCodec(...)75%44100%
GetCompatibilityAudioCodecDirect(...)100%22100%

File(s)

/srv/git/jellyfin/MediaBrowser.Model/Dlna/StreamBuilder.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Globalization;
 4using System.Linq;
 5using Jellyfin.Data.Enums;
 6using Jellyfin.Extensions;
 7using MediaBrowser.Model.Dto;
 8using MediaBrowser.Model.Entities;
 9using MediaBrowser.Model.Extensions;
 10using MediaBrowser.Model.MediaInfo;
 11using MediaBrowser.Model.Session;
 12using Microsoft.Extensions.Logging;
 13
 14namespace MediaBrowser.Model.Dlna
 15{
 16    /// <summary>
 17    /// Class StreamBuilder.
 18    /// </summary>
 19    public class StreamBuilder
 20    {
 21        // Aliases
 22        internal const TranscodeReason ContainerReasons = TranscodeReason.ContainerNotSupported | TranscodeReason.Contai
 23        internal const TranscodeReason AudioCodecReasons = TranscodeReason.AudioBitrateNotSupported | TranscodeReason.Au
 24        internal const TranscodeReason AudioReasons = TranscodeReason.AudioCodecNotSupported | AudioCodecReasons;
 25        internal const TranscodeReason VideoCodecReasons = TranscodeReason.VideoResolutionNotSupported | TranscodeReason
 26        internal const TranscodeReason VideoReasons = TranscodeReason.VideoCodecNotSupported | VideoCodecReasons;
 27        internal const TranscodeReason DirectStreamReasons = AudioReasons | TranscodeReason.ContainerNotSupported | Tran
 28
 29        private readonly ILogger _logger;
 30        private readonly ITranscoderSupport _transcoderSupport;
 131        private static readonly string[] _supportedHlsVideoCodecs = ["h264", "hevc", "vp9", "av1"];
 132        private static readonly string[] _supportedHlsAudioCodecsTs = ["aac", "ac3", "eac3", "mp3"];
 133        private static readonly string[] _supportedHlsAudioCodecsMp4 = ["aac", "ac3", "eac3", "mp3", "alac", "flac", "op
 34
 35        /// <summary>
 36        /// Initializes a new instance of the <see cref="StreamBuilder"/> class.
 37        /// </summary>
 38        /// <param name="transcoderSupport">The <see cref="ITranscoderSupport"/> object.</param>
 39        /// <param name="logger">The <see cref="ILogger"/> object.</param>
 40        public StreamBuilder(ITranscoderSupport transcoderSupport, ILogger logger)
 41        {
 28042            _transcoderSupport = transcoderSupport;
 28043            _logger = logger;
 28044        }
 45
 46        /// <summary>
 47        /// Gets the optimal audio stream.
 48        /// </summary>
 49        /// <param name="options">The <see cref="MediaOptions"/> object to get the audio stream from.</param>
 50        /// <returns>The <see cref="StreamInfo"/> of the optimal audio stream.</returns>
 51        public StreamInfo? GetOptimalAudioStream(MediaOptions options)
 52        {
 053            ValidateMediaOptions(options, false);
 54
 055            List<StreamInfo> streams = [];
 056            foreach (var mediaSource in options.MediaSources)
 57            {
 058                if (!(string.IsNullOrEmpty(options.MediaSourceId)
 059                    || string.Equals(mediaSource.Id, options.MediaSourceId, StringComparison.OrdinalIgnoreCase)))
 60                {
 61                    continue;
 62                }
 63
 064                StreamInfo? streamInfo = GetOptimalAudioStream(mediaSource, options);
 065                if (streamInfo is not null)
 66                {
 067                    streamInfo.DeviceId = options.DeviceId;
 068                    streamInfo.DeviceProfileId = options.Profile.Id?.ToString("N", CultureInfo.InvariantCulture);
 069                    streams.Add(streamInfo);
 70                }
 71            }
 72
 073            return GetOptimalStream(streams, options.GetMaxBitrate(true) ?? 0);
 74        }
 75
 76        private StreamInfo? GetOptimalAudioStream(MediaSourceInfo item, MediaOptions options)
 77        {
 078            var playlistItem = new StreamInfo
 079            {
 080                ItemId = options.ItemId,
 081                MediaType = DlnaProfileType.Audio,
 082                MediaSource = item,
 083                RunTimeTicks = item.RunTimeTicks,
 084                Context = options.Context,
 085                DeviceProfile = options.Profile
 086            };
 87
 088            if (options.ForceDirectPlay)
 89            {
 090                playlistItem.PlayMethod = PlayMethod.DirectPlay;
 091                playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, 
 092                return playlistItem;
 93            }
 94
 095            if (options.ForceDirectStream)
 96            {
 097                playlistItem.PlayMethod = PlayMethod.DirectStream;
 098                playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, 
 099                return playlistItem;
 100            }
 101
 0102            MediaStream audioStream = item.GetDefaultAudioStream(null);
 103
 0104            ArgumentNullException.ThrowIfNull(audioStream);
 105
 0106            var directPlayInfo = GetAudioDirectPlayProfile(item, audioStream, options);
 107
 0108            var directPlayMethod = directPlayInfo.PlayMethod;
 0109            var transcodeReasons = directPlayInfo.TranscodeReasons;
 110
 0111            if (directPlayMethod is PlayMethod.DirectPlay)
 112            {
 0113                var audioFailureReasons = GetCompatibilityAudioCodec(options, item, item.Container, audioStream, null, f
 0114                transcodeReasons |= audioFailureReasons;
 115
 0116                if (audioFailureReasons == 0)
 117                {
 0118                    playlistItem.PlayMethod = directPlayMethod.Value;
 0119                    playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profi
 120
 0121                    return playlistItem;
 122                }
 123            }
 124
 0125            if (directPlayMethod is PlayMethod.DirectStream)
 126            {
 0127                var remuxContainer = item.TranscodingContainer ?? "ts";
 0128                string[] supportedHlsContainers = ["ts", "mp4"];
 129                // If the container specified for the profile is an HLS supported container, use that container instead,
 130                // The client should be responsible to ensure this container is compatible
 0131                remuxContainer = Array.Exists(supportedHlsContainers, element => string.Equals(element, directPlayInfo.P
 132                bool codeIsSupported;
 0133                if (item.TranscodingSubProtocol == MediaStreamProtocol.hls)
 134                {
 135                    // Enforce HLS audio codec restrictions
 0136                    if (string.Equals(remuxContainer, "mp4", StringComparison.OrdinalIgnoreCase))
 137                    {
 0138                        codeIsSupported = _supportedHlsAudioCodecsMp4.Contains(directPlayInfo.Profile?.AudioCodec ?? dir
 139                    }
 140                    else
 141                    {
 0142                        codeIsSupported = _supportedHlsAudioCodecsTs.Contains(directPlayInfo.Profile?.AudioCodec ?? dire
 143                    }
 144                }
 145                else
 146                {
 147                    // Let's assume the client has given a correct container for http
 0148                    codeIsSupported = true;
 149                }
 150
 0151                if (codeIsSupported)
 152                {
 0153                    playlistItem.PlayMethod = directPlayMethod.Value;
 0154                    playlistItem.Container = remuxContainer;
 0155                    playlistItem.TranscodeReasons = transcodeReasons;
 0156                    playlistItem.SubProtocol = item.TranscodingSubProtocol;
 0157                    item.TranscodingContainer = remuxContainer;
 0158                    return playlistItem;
 159                }
 160
 0161                transcodeReasons |= TranscodeReason.AudioCodecNotSupported;
 0162                playlistItem.TranscodeReasons = transcodeReasons;
 163            }
 164
 0165            TranscodingProfile? transcodingProfile = null;
 0166            foreach (var tcProfile in options.Profile.TranscodingProfiles)
 167            {
 0168                if (tcProfile.Type == playlistItem.MediaType
 0169                    && tcProfile.Context == options.Context
 0170                    && _transcoderSupport.CanEncodeToAudioCodec(tcProfile.AudioCodec ?? tcProfile.Container))
 171                {
 0172                    transcodingProfile = tcProfile;
 0173                    break;
 174                }
 175            }
 176
 0177            if (transcodingProfile is not null)
 178            {
 0179                if (!item.SupportsTranscoding)
 180                {
 0181                    return null;
 182                }
 183
 0184                SetStreamInfoOptionsFromTranscodingProfile(item, playlistItem, transcodingProfile);
 185
 0186                var inputAudioChannels = audioStream.Channels;
 0187                var inputAudioBitrate = audioStream.BitRate;
 0188                var inputAudioSampleRate = audioStream.SampleRate;
 0189                var inputAudioBitDepth = audioStream.BitDepth;
 190
 0191                var audioTranscodingConditions = GetProfileConditionsForAudio(options.Profile.CodecProfiles, transcoding
 0192                ApplyTranscodingConditions(playlistItem, audioTranscodingConditions, null, true, true);
 193
 194                // Honor requested max channels
 0195                playlistItem.GlobalMaxAudioChannels = options.MaxAudioChannels;
 196
 0197                var configuredBitrate = options.GetMaxBitrate(true);
 198
 0199                long transcodingBitrate = options.AudioTranscodingBitrate
 0200                    ?? (options.Context == EncodingContext.Streaming ? options.Profile.MusicStreamingTranscodingBitrate 
 0201                    ?? configuredBitrate
 0202                    ?? 128000;
 203
 0204                if (configuredBitrate.HasValue)
 205                {
 0206                    transcodingBitrate = Math.Min(configuredBitrate.Value, transcodingBitrate);
 207                }
 208
 0209                var longBitrate = Math.Min(transcodingBitrate, playlistItem.AudioBitrate ?? transcodingBitrate);
 0210                playlistItem.AudioBitrate = longBitrate > int.MaxValue ? int.MaxValue : Convert.ToInt32(longBitrate);
 211
 212                // Pure audio transcoding does not support comma separated list of transcoding codec at the moment.
 213                // So just use the AudioCodec as is would be safe enough as the _transcoderSupport.CanEncodeToAudioCodec
 214                // would fail so this profile will not even be picked up.
 0215                if (playlistItem.AudioCodecs.Count == 0 && !string.IsNullOrWhiteSpace(transcodingProfile.AudioCodec))
 216                {
 0217                    playlistItem.AudioCodecs = [transcodingProfile.AudioCodec];
 218                }
 219            }
 220
 0221            playlistItem.TranscodeReasons = transcodeReasons;
 0222            return playlistItem;
 223        }
 224
 225        /// <summary>
 226        /// Gets the optimal video stream.
 227        /// </summary>
 228        /// <param name="options">The <see cref="MediaOptions"/> object to get the video stream from.</param>
 229        /// <returns>The <see cref="StreamInfo"/> of the optimal video stream.</returns>
 230        public StreamInfo? GetOptimalVideoStream(MediaOptions options)
 231        {
 280232            ValidateMediaOptions(options, true);
 233
 280234            var mediaSources = string.IsNullOrEmpty(options.MediaSourceId)
 280235                ? options.MediaSources
 280236                : options.MediaSources.Where(x => string.Equals(x.Id, options.MediaSourceId, StringComparison.OrdinalIgn
 237
 280238            List<StreamInfo> streams = [];
 1120239            foreach (var mediaSourceInfo in mediaSources)
 240            {
 280241                var streamInfo = BuildVideoItem(mediaSourceInfo, options);
 280242                if (streamInfo is not null)
 243                {
 280244                    streams.Add(streamInfo);
 245                }
 246            }
 247
 1120248            foreach (var stream in streams)
 249            {
 280250                stream.DeviceId = options.DeviceId;
 280251                stream.DeviceProfileId = options.Profile.Id?.ToString("N", CultureInfo.InvariantCulture);
 252            }
 253
 280254            return GetOptimalStream(streams, options.GetMaxBitrate(false) ?? 0);
 255        }
 256
 257        private static StreamInfo? GetOptimalStream(List<StreamInfo> streams, long maxBitrate)
 280258            => SortMediaSources(streams, maxBitrate).FirstOrDefault();
 259
 260        private static IOrderedEnumerable<StreamInfo> SortMediaSources(List<StreamInfo> streams, long maxBitrate)
 261        {
 280262            return streams.OrderBy(i =>
 280263            {
 280264                // Nothing beats direct playing a file
 280265                if (i.PlayMethod == PlayMethod.DirectPlay && i.MediaSource?.Protocol == MediaProtocol.File)
 280266                {
 280267                    return 0;
 280268                }
 280269
 280270                return 1;
 280271            }).ThenBy(i =>
 280272            {
 280273                switch (i.PlayMethod)
 280274                {
 280275                    // Let's assume direct streaming a file is just as desirable as direct playing a remote url
 280276                    case PlayMethod.DirectStream:
 280277                    case PlayMethod.DirectPlay:
 280278                        return 0;
 280279                    default:
 280280                        return 1;
 280281                }
 280282            }).ThenBy(i =>
 280283            {
 280284                switch (i.MediaSource?.Protocol)
 280285                {
 280286                    case MediaProtocol.File:
 280287                        return 0;
 280288                    default:
 280289                        return 1;
 280290                }
 280291            }).ThenBy(i =>
 280292            {
 280293                if (maxBitrate > 0)
 280294                {
 280295                    if (i.MediaSource?.Bitrate is not null)
 280296                    {
 280297                        return Math.Abs(i.MediaSource.Bitrate.Value - maxBitrate);
 280298                    }
 280299                }
 280300
 280301                return 0;
 280302            }).ThenBy(streams.IndexOf);
 303        }
 304
 305        private static TranscodeReason GetTranscodeReasonForFailedCondition(ProfileCondition condition)
 306        {
 248307            switch (condition.Property)
 308            {
 309                case ProfileConditionValue.AudioBitrate:
 0310                    return TranscodeReason.AudioBitrateNotSupported;
 311
 312                case ProfileConditionValue.AudioChannels:
 122313                    return TranscodeReason.AudioChannelsNotSupported;
 314
 315                case ProfileConditionValue.AudioProfile:
 0316                    return TranscodeReason.AudioProfileNotSupported;
 317
 318                case ProfileConditionValue.AudioSampleRate:
 0319                    return TranscodeReason.AudioSampleRateNotSupported;
 320
 321                case ProfileConditionValue.Has64BitOffsets:
 322                    // TODO
 0323                    return 0;
 324
 325                case ProfileConditionValue.Height:
 0326                    return TranscodeReason.VideoResolutionNotSupported;
 327
 328                case ProfileConditionValue.IsAnamorphic:
 0329                    return TranscodeReason.AnamorphicVideoNotSupported;
 330
 331                case ProfileConditionValue.IsAvc:
 332                    // TODO
 0333                    return 0;
 334
 335                case ProfileConditionValue.IsInterlaced:
 0336                    return TranscodeReason.InterlacedVideoNotSupported;
 337
 338                case ProfileConditionValue.IsSecondaryAudio:
 35339                    return TranscodeReason.SecondaryAudioNotSupported;
 340
 341                case ProfileConditionValue.NumStreams:
 2342                    return TranscodeReason.StreamCountExceedsLimit;
 343
 344                case ProfileConditionValue.NumAudioStreams:
 345                    // TODO
 0346                    return 0;
 347
 348                case ProfileConditionValue.NumVideoStreams:
 349                    // TODO
 0350                    return 0;
 351
 352                case ProfileConditionValue.PacketLength:
 353                    // TODO
 0354                    return 0;
 355
 356                case ProfileConditionValue.RefFrames:
 0357                    return TranscodeReason.RefFramesNotSupported;
 358
 359                case ProfileConditionValue.VideoBitDepth:
 0360                    return TranscodeReason.VideoBitDepthNotSupported;
 361
 362                case ProfileConditionValue.AudioBitDepth:
 0363                    return TranscodeReason.AudioBitDepthNotSupported;
 364
 365                case ProfileConditionValue.VideoBitrate:
 4366                    return TranscodeReason.VideoBitrateNotSupported;
 367
 368                case ProfileConditionValue.VideoCodecTag:
 18369                    return TranscodeReason.VideoCodecTagNotSupported;
 370
 371                case ProfileConditionValue.VideoFramerate:
 0372                    return TranscodeReason.VideoFramerateNotSupported;
 373
 374                case ProfileConditionValue.VideoLevel:
 13375                    return TranscodeReason.VideoLevelNotSupported;
 376
 377                case ProfileConditionValue.VideoProfile:
 25378                    return TranscodeReason.VideoProfileNotSupported;
 379
 380                case ProfileConditionValue.VideoRangeType:
 28381                    return TranscodeReason.VideoRangeTypeNotSupported;
 382
 383                case ProfileConditionValue.VideoRotation:
 1384                    return TranscodeReason.VideoRotationNotSupported;
 385
 386                case ProfileConditionValue.VideoTimestamp:
 387                    // TODO
 0388                    return 0;
 389
 390                case ProfileConditionValue.Width:
 0391                    return TranscodeReason.VideoResolutionNotSupported;
 392
 393                default:
 0394                    return 0;
 395            }
 396        }
 397
 398        /// <summary>
 399        /// Normalizes input container.
 400        /// </summary>
 401        /// <param name="inputContainer">The input container.</param>
 402        /// <param name="profile">The <see cref="DeviceProfile"/>.</param>
 403        /// <param name="type">The <see cref="DlnaProfileType"/>.</param>
 404        /// <param name="playProfile">The <see cref="DirectPlayProfile"/> object to get the video stream from.</param>
 405        /// <returns>The normalized input container.</returns>
 406        public static string? NormalizeMediaSourceFormatIntoSingleContainer(string inputContainer, DeviceProfile? profil
 407        {
 408            // If the source is Live TV the inputContainer will be null until the mediasource is probed on first access
 405409            if (profile is null || string.IsNullOrEmpty(inputContainer) || !inputContainer.Contains(',', StringCompariso
 410            {
 94411                return inputContainer;
 412            }
 413
 311414            var formats = ContainerHelper.Split(inputContainer);
 311415            var playProfiles = playProfile is null ? profile.DirectPlayProfiles : [playProfile];
 1370416            foreach (var format in formats)
 417            {
 2602418                foreach (var directPlayProfile in playProfiles)
 419                {
 927420                    if (directPlayProfile.Type != type)
 421                    {
 422                        continue;
 423                    }
 424
 699425                    if (directPlayProfile.SupportsContainer(format))
 426                    {
 294427                        return format;
 428                    }
 429                }
 430            }
 431
 17432            return inputContainer;
 433        }
 434
 435        private (DirectPlayProfile? Profile, PlayMethod? PlayMethod, TranscodeReason TranscodeReasons) GetAudioDirectPla
 436        {
 0437            var directPlayProfile = options.Profile.DirectPlayProfiles
 0438                .FirstOrDefault(x => x.Type == DlnaProfileType.Audio && IsAudioDirectPlaySupported(x, item, audioStream)
 439
 0440            TranscodeReason transcodeReasons = 0;
 0441            if (directPlayProfile is null)
 442            {
 0443                _logger.LogDebug(
 0444                    "Profile: {0}, No audio direct play profiles found for {1} with codec {2}",
 0445                    options.Profile.Name ?? "Unknown Profile",
 0446                    item.Path ?? "Unknown path",
 0447                    audioStream.Codec ?? "Unknown codec");
 448
 0449                var directStreamProfile = options.Profile.DirectPlayProfiles
 0450                    .FirstOrDefault(x => x.Type == DlnaProfileType.Audio && IsAudioDirectStreamSupported(x, item, audioS
 451
 0452                if (directStreamProfile is not null)
 453                {
 0454                    directPlayProfile = directStreamProfile;
 0455                    transcodeReasons |= TranscodeReason.ContainerNotSupported;
 456                }
 457                else
 458                {
 0459                    return (null, null, GetTranscodeReasonsFromDirectPlayProfile(item, null, audioStream, options.Profil
 460                }
 461            }
 462
 463            // The profile describes what the device supports
 464            // If device requirements are satisfied then allow both direct stream and direct play
 465            // Note: As of 10.10 codebase, SupportsDirectPlay is always true because the MediaSourceInfo initializes thi
 466            // Need to check additionally for current transcode reasons
 0467            if (item.SupportsDirectPlay && transcodeReasons == 0)
 468            {
 0469                if (!IsBitrateLimitExceeded(item, options.GetMaxBitrate(true) ?? 0))
 470                {
 0471                    if (options.EnableDirectPlay)
 472                    {
 0473                        return (directPlayProfile, PlayMethod.DirectPlay, 0);
 474                    }
 475                }
 476                else
 477                {
 0478                    transcodeReasons |= TranscodeReason.ContainerBitrateExceedsLimit;
 479                }
 480            }
 481
 482            // While options takes the network and other factors into account. Only applies to direct stream
 0483            if (item.SupportsDirectStream)
 484            {
 0485                if (!IsBitrateLimitExceeded(item, options.GetMaxBitrate(true) ?? 0))
 486                {
 487                    // Note: as of 10.10 codebase, the options.EnableDirectStream is always false due to
 488                    // "direct-stream http streaming is currently broken"
 489                    // Don't check that option for audio as we always assume that is supported
 0490                    if (transcodeReasons == TranscodeReason.ContainerNotSupported)
 491                    {
 0492                        return (directPlayProfile, PlayMethod.DirectStream, transcodeReasons);
 493                    }
 494                }
 495                else
 496                {
 0497                    transcodeReasons |= TranscodeReason.ContainerBitrateExceedsLimit;
 498                }
 499            }
 500
 0501            return (directPlayProfile, null, transcodeReasons);
 502        }
 503
 504        private static TranscodeReason GetTranscodeReasonsFromDirectPlayProfile(MediaSourceInfo item, MediaStream? video
 505        {
 0506            var mediaType = videoStream is null ? DlnaProfileType.Audio : DlnaProfileType.Video;
 507
 0508            var containerSupported = false;
 0509            var audioSupported = false;
 0510            var videoSupported = false;
 511
 0512            foreach (var profile in directPlayProfiles)
 513            {
 514                // Check container type
 0515                if (profile.Type == mediaType && profile.SupportsContainer(item.Container))
 516                {
 0517                    containerSupported = true;
 518
 0519                    videoSupported = videoStream is null || profile.SupportsVideoCodec(videoStream.Codec);
 520
 0521                    audioSupported = audioStream is null || profile.SupportsAudioCodec(audioStream.Codec);
 522
 0523                    if (videoSupported && audioSupported)
 524                    {
 0525                        break;
 526                    }
 527                }
 528            }
 529
 0530            TranscodeReason reasons = 0;
 0531            if (!containerSupported)
 532            {
 0533                reasons |= TranscodeReason.ContainerNotSupported;
 534            }
 535
 0536            if (!videoSupported)
 537            {
 0538                reasons |= TranscodeReason.VideoCodecNotSupported;
 539            }
 540
 0541            if (!audioSupported)
 542            {
 0543                reasons |= TranscodeReason.AudioCodecNotSupported;
 544            }
 545
 0546            return reasons;
 547        }
 548
 549        private static int? GetDefaultSubtitleStreamIndex(MediaSourceInfo item, SubtitleProfile[] subtitleProfiles)
 550        {
 177551            int highestScore = -1;
 1800552            foreach (var stream in item.MediaStreams)
 553            {
 723554                if (stream.Type == MediaStreamType.Subtitle
 723555                    && stream.Score.HasValue
 723556                    && stream.Score.Value > highestScore)
 557                {
 144558                    highestScore = stream.Score.Value;
 559                }
 560            }
 561
 177562            List<MediaStream> topStreams = [];
 1800563            foreach (var stream in item.MediaStreams)
 564            {
 723565                if (stream.Type == MediaStreamType.Subtitle && stream.Score.HasValue && stream.Score.Value == highestSco
 566                {
 321567                    topStreams.Add(stream);
 568                }
 569            }
 570
 571            // If multiple streams have an equal score, try to pick the most efficient one
 177572            if (topStreams.Count > 1)
 573            {
 378574                foreach (var stream in topStreams)
 575                {
 1464576                    foreach (var profile in subtitleProfiles)
 577                    {
 549578                        if (profile.Method == SubtitleDeliveryMethod.External
 549579                            && (string.Equals(profile.Format, stream.Codec, StringComparison.OrdinalIgnoreCase)
 549580                                // FFmpeg cannot mux VobSub back into an .idx/.sub pair, so extracted VobSub streams are
 549581                                || (string.Equals(profile.Format, "mks", StringComparison.OrdinalIgnoreCase)
 549582                                    && stream.IsVobSubSubtitleStream
 549583                                    && (!stream.IsExternal || stream.Path.EndsWith(".mks", StringComparison.OrdinalIgnor
 584                        {
 0585                            return stream.Index;
 586                        }
 587                    }
 588                }
 589            }
 590
 591            // If no optimization panned out, just use the original default
 177592            return item.DefaultSubtitleStreamIndex;
 0593        }
 594
 595        private static void SetStreamInfoOptionsFromTranscodingProfile(MediaSourceInfo item, StreamInfo playlistItem, Tr
 596        {
 147597            var container = transcodingProfile.Container;
 147598            var protocol = transcodingProfile.Protocol;
 599
 147600            item.TranscodingContainer = container;
 147601            item.TranscodingSubProtocol = protocol;
 602
 147603            if (playlistItem.PlayMethod == PlayMethod.Transcode)
 604            {
 147605                playlistItem.Container = container;
 147606                playlistItem.SubProtocol = protocol;
 607            }
 608
 147609            playlistItem.TranscodeSeekInfo = transcodingProfile.TranscodeSeekInfo;
 147610            if (int.TryParse(transcodingProfile.MaxAudioChannels, CultureInfo.InvariantCulture, out int transcodingMaxAu
 611            {
 133612                playlistItem.TranscodingMaxAudioChannels = transcodingMaxAudioChannels;
 613            }
 614
 147615            playlistItem.EstimateContentLength = transcodingProfile.EstimateContentLength;
 616
 147617            playlistItem.CopyTimestamps = transcodingProfile.CopyTimestamps;
 147618            playlistItem.EnableSubtitlesInManifest = transcodingProfile.EnableSubtitlesInManifest;
 147619            playlistItem.EnableMpegtsM2TsMode = transcodingProfile.EnableMpegtsM2TsMode;
 620
 147621            playlistItem.EnableAudioVbrEncoding = transcodingProfile.EnableAudioVbrEncoding;
 622
 147623            if (transcodingProfile.MinSegments > 0)
 624            {
 102625                playlistItem.MinSegments = transcodingProfile.MinSegments;
 626            }
 627
 147628            if (transcodingProfile.SegmentLength > 0)
 629            {
 0630                playlistItem.SegmentLength = transcodingProfile.SegmentLength;
 631            }
 147632        }
 633
 634        private static void SetStreamInfoOptionsFromDirectPlayProfile(MediaOptions options, MediaSourceInfo item, Stream
 635        {
 0636            var container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, DlnaProfileTy
 0637            var protocol = MediaStreamProtocol.http;
 638
 0639            item.TranscodingContainer = container;
 0640            item.TranscodingSubProtocol = protocol;
 641
 0642            playlistItem.Container = container;
 0643            playlistItem.SubProtocol = protocol;
 644
 0645            playlistItem.VideoCodecs = [item.VideoStream.Codec];
 0646            playlistItem.AudioCodecs = ContainerHelper.Split(directPlayProfile?.AudioCodec);
 0647        }
 648
 649        private StreamInfo BuildVideoItem(MediaSourceInfo item, MediaOptions options)
 650        {
 280651            ArgumentNullException.ThrowIfNull(item);
 652
 280653            StreamInfo playlistItem = new StreamInfo
 280654            {
 280655                ItemId = options.ItemId,
 280656                MediaType = DlnaProfileType.Video,
 280657                MediaSource = item,
 280658                RunTimeTicks = item.RunTimeTicks,
 280659                Context = options.Context,
 280660                DeviceProfile = options.Profile,
 280661                SubtitleStreamIndex = options.SubtitleStreamIndex ?? GetDefaultSubtitleStreamIndex(item, options.Profile
 280662                AlwaysBurnInSubtitleWhenTranscoding = options.AlwaysBurnInSubtitleWhenTranscoding
 280663            };
 664
 280665            var subtitleStream = playlistItem.SubtitleStreamIndex.HasValue ? item.GetMediaStream(MediaStreamType.Subtitl
 666
 280667            var audioStream = item.GetDefaultAudioStream(options.AudioStreamIndex ?? item.DefaultAudioStreamIndex);
 280668            if (audioStream is not null)
 669            {
 279670                playlistItem.AudioStreamIndex = audioStream.Index;
 671            }
 672
 673            // Collect candidate audio streams
 280674            ICollection<MediaStream> candidateAudioStreams = audioStream is null ? [] : [audioStream];
 675            // When the index is explicitly required by client or the default is specified by user, don't do any stream 
 280676            if (!item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.User) && (options.AudioStreamIndex is null or < 0
 677            {
 678                // When user has no preferences allow stream selection on all streams.
 177679                if (item.DefaultAudioIndexSource == AudioIndexSource.None && audioStream is not null)
 680                {
 176681                    candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio).ToAr
 176682                    if (audioStream.IsDefault)
 683                    {
 684                        // If default is picked, only allow selection within default streams.
 176685                        candidateAudioStreams = candidateAudioStreams.Where(stream => stream.IsDefault).ToArray();
 686                    }
 687                }
 688
 177689                if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Language))
 690                {
 691                    // If user has language preference, only allow stream selection within the same language.
 0692                    candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && st
 0693                    if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Default))
 694                    {
 0695                        var defaultStreamsInPreferredLanguage = candidateAudioStreams.Where(stream => stream.IsDefault).
 696
 697                        // If the user also prefers default streams, try limit selection within default tracks in the sa
 698                        // If there is no default stream in the preferred language, allow selection on all default strea
 0699                        candidateAudioStreams = defaultStreamsInPreferredLanguage.Length > 0
 0700                            ? defaultStreamsInPreferredLanguage
 0701                            : item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && stream.IsDefault
 702                    }
 703                }
 177704                else if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Default))
 705                {
 706                    // If user prefers default streams, only allow stream selection on default streams.
 0707                    candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && st
 708                }
 709            }
 710
 280711            var videoStream = item.VideoStream;
 712
 280713            var bitrateLimitExceeded = IsBitrateLimitExceeded(item, options.GetMaxBitrate(false) ?? 0);
 280714            var isEligibleForDirectPlay = options.EnableDirectPlay && (options.ForceDirectPlay || !bitrateLimitExceeded)
 280715            var isEligibleForDirectStream = options.EnableDirectStream && (options.ForceDirectStream || !bitrateLimitExc
 280716            TranscodeReason transcodeReasons = 0;
 717
 718            // Force transcode or remux for BD/DVD folders
 280719            if (item.VideoType == VideoType.Dvd || item.VideoType == VideoType.BluRay)
 720            {
 0721                isEligibleForDirectPlay = false;
 722            }
 723
 280724            if (bitrateLimitExceeded)
 725            {
 24726                transcodeReasons = TranscodeReason.ContainerBitrateExceedsLimit;
 727            }
 728
 280729            _logger.LogDebug(
 280730                "Profile: {0}, Path: {1}, isEligibleForDirectPlay: {2}, isEligibleForDirectStream: {3}",
 280731                options.Profile.Name ?? "Unknown Profile",
 280732                item.Path ?? "Unknown path",
 280733                isEligibleForDirectPlay,
 280734                isEligibleForDirectStream);
 735
 280736            DirectPlayProfile? directPlayProfile = null;
 280737            if (isEligibleForDirectPlay || isEligibleForDirectStream)
 738            {
 739                // See if it can be direct played
 256740                var directPlayInfo = GetVideoDirectPlayProfile(options, item, videoStream, audioStream, candidateAudioSt
 256741                var directPlay = directPlayInfo.PlayMethod;
 256742                transcodeReasons |= directPlayInfo.TranscodeReasons;
 743
 256744                if (directPlay.HasValue)
 745                {
 125746                    directPlayProfile = directPlayInfo.Profile;
 125747                    playlistItem.PlayMethod = directPlay.Value;
 125748                    playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profi
 125749                    var videoCodec = videoStream?.Codec;
 125750                    playlistItem.VideoCodecs = videoCodec is null ? [] : [videoCodec];
 751
 125752                    if (directPlay == PlayMethod.DirectPlay)
 753                    {
 125754                        playlistItem.SubProtocol = MediaStreamProtocol.http;
 755
 125756                        var audioStreamIndex = directPlayInfo.AudioStreamIndex ?? audioStream?.Index;
 125757                        if (audioStreamIndex.HasValue)
 758                        {
 125759                            playlistItem.AudioStreamIndex = audioStreamIndex;
 125760                            var audioCodec = item.GetMediaStream(MediaStreamType.Audio, audioStreamIndex.Value)?.Codec;
 125761                            playlistItem.AudioCodecs = audioCodec is null ? [] : [audioCodec];
 762                        }
 763                    }
 0764                    else if (directPlay == PlayMethod.DirectStream)
 765                    {
 0766                        playlistItem.AudioStreamIndex = audioStream?.Index;
 0767                        if (audioStream is not null)
 768                        {
 0769                            playlistItem.AudioCodecs = ContainerHelper.Split(directPlayProfile?.AudioCodec);
 770                        }
 771
 0772                        SetStreamInfoOptionsFromDirectPlayProfile(options, item, playlistItem, directPlayProfile);
 0773                        BuildStreamVideoItem(playlistItem, options, item, videoStream, audioStream, candidateAudioStream
 774                    }
 775
 125776                    if (subtitleStream is not null)
 777                    {
 116778                        var subtitleProfile = GetSubtitleProfile(item, subtitleStream, options.Profile.SubtitleProfiles,
 779
 116780                        playlistItem.SubtitleDeliveryMethod = subtitleProfile.Method;
 116781                        playlistItem.SubtitleFormat = subtitleProfile.Format;
 782                    }
 783                }
 784
 256785                _logger.LogDebug(
 256786                    "DirectPlay Result for Profile: {0}, Path: {1}, PlayMethod: {2}, AudioStreamIndex: {3}, SubtitleStre
 256787                    options.Profile.Name ?? "Anonymous Profile",
 256788                    item.Path ?? "Unknown path",
 256789                    directPlayInfo.PlayMethod,
 256790                    directPlayInfo.AudioStreamIndex ?? audioStream?.Index,
 256791                    playlistItem.SubtitleStreamIndex,
 256792                    directPlayInfo.TranscodeReasons);
 793            }
 794
 280795            playlistItem.TranscodeReasons = transcodeReasons;
 796
 280797            if (playlistItem.PlayMethod != PlayMethod.DirectStream && playlistItem.PlayMethod != PlayMethod.DirectPlay)
 798            {
 799                // Can't direct play, find the transcoding profile
 800                // If we do this for direct-stream we will overwrite the info
 155801                var (transcodingProfile, playMethod) = GetVideoTranscodeProfile(item, options, videoStream, audioStream,
 802
 155803                if (transcodingProfile is not null && playMethod.HasValue)
 804                {
 147805                    SetStreamInfoOptionsFromTranscodingProfile(item, playlistItem, transcodingProfile);
 806
 147807                    BuildStreamVideoItem(playlistItem, options, item, videoStream, audioStream, candidateAudioStreams, t
 808
 147809                    playlistItem.PlayMethod = PlayMethod.Transcode;
 810
 147811                    if (subtitleStream is not null)
 812                    {
 123813                        var subtitleProfile = GetSubtitleProfile(item, subtitleStream, options.Profile.SubtitleProfiles,
 123814                        playlistItem.SubtitleDeliveryMethod = subtitleProfile.Method;
 123815                        playlistItem.SubtitleFormat = subtitleProfile.Format;
 123816                        playlistItem.SubtitleCodecs = [subtitleProfile.Format];
 817                    }
 818
 147819                    if ((playlistItem.TranscodeReasons & (VideoReasons | TranscodeReason.ContainerBitrateExceedsLimit)) 
 820                    {
 45821                        ApplyTranscodingConditions(playlistItem, transcodingProfile.Conditions, null, true, true);
 822                    }
 823                }
 824            }
 825
 280826            _logger.LogDebug(
 280827                "StreamBuilder.BuildVideoItem( Profile={0}, Path={1}, AudioStreamIndex={2}, SubtitleStreamIndex={3} ) =>
 280828                options.Profile.Name ?? "Anonymous Profile",
 280829                item.Path ?? "Unknown path",
 280830                options.AudioStreamIndex,
 280831                options.SubtitleStreamIndex,
 280832                playlistItem.PlayMethod,
 280833                playlistItem.TranscodeReasons,
 280834                playlistItem.ToUrl("media:", "<token>", null));
 835
 280836            item.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, DlnaProfileT
 280837            return playlistItem;
 838        }
 839
 840        private (TranscodingProfile? Profile, PlayMethod? PlayMethod) GetVideoTranscodeProfile(
 841            MediaSourceInfo item,
 842            MediaOptions options,
 843            MediaStream? videoStream,
 844            MediaStream? audioStream,
 845            StreamInfo playlistItem)
 846        {
 155847            var mediaSource = playlistItem.MediaSource;
 848
 155849            ArgumentNullException.ThrowIfNull(mediaSource);
 850
 155851            if (!(item.SupportsTranscoding || item.SupportsDirectStream))
 852            {
 0853                return (null, null);
 854            }
 855
 155856            var transcodingProfiles = options.Profile.TranscodingProfiles
 155857                .Where(i => i.Type == playlistItem.MediaType && i.Context == options.Context);
 858
 155859            if (item.UseMostCompatibleTranscodingProfile)
 860            {
 0861                transcodingProfiles = transcodingProfiles.Where(i => string.Equals(i.Container, "ts", StringComparison.O
 862            }
 863
 155864            var videoCodec = videoStream?.Codec;
 155865            var audioCodec = audioStream?.Codec;
 866
 155867            var analyzedProfiles = transcodingProfiles
 155868                .Select(transcodingProfile =>
 155869                {
 155870                    var rank = (Video: 3, Audio: 3);
 155871
 155872                    var container = transcodingProfile.Container;
 155873
 155874                    if (videoStream is not null
 155875                        && options.AllowVideoStreamCopy
 155876                        && ContainerHelper.ContainsContainer(transcodingProfile.VideoCodec, videoCodec))
 155877                    {
 155878                        var failures = GetCompatibilityVideoCodec(options, mediaSource, container, videoStream);
 155879                        rank.Video = failures == 0 ? 1 : 2;
 155880                    }
 155881
 155882                    if (audioStream is not null
 155883                        && options.AllowAudioStreamCopy)
 155884                    {
 155885                        // For Audio stream, we prefer the audio codec that can be directly copied, then the codec that 
 155886                        // the transcoding conditions, then the one does not satisfy the transcoding conditions.
 155887                        // For example: A client can support both aac and flac, but flac only supports 2 channels while 
 155888                        // When the source audio is 6 channel flac, we should transcode to 6 channel aac, instead of dow
 155889                        var transcodingAudioCodecs = ContainerHelper.Split(transcodingProfile.AudioCodec);
 155890
 155891                        foreach (var transcodingAudioCodec in transcodingAudioCodecs)
 155892                        {
 155893                            var failures = GetCompatibilityAudioCodec(options, mediaSource, container, audioStream, tran
 155894
 155895                            var rankAudio = 3;
 155896
 155897                            if (failures == 0)
 155898                            {
 155899                                rankAudio = string.Equals(transcodingAudioCodec, audioCodec, StringComparison.OrdinalIgn
 155900                            }
 155901
 155902                            rank.Audio = Math.Min(rank.Audio, rankAudio);
 155903
 155904                            if (rank.Audio == 1)
 155905                            {
 155906                                break;
 155907                            }
 155908                        }
 155909                    }
 155910
 155911                    PlayMethod playMethod = PlayMethod.Transcode;
 155912
 155913                    if (rank.Video == 1)
 155914                    {
 155915                        playMethod = PlayMethod.DirectStream;
 155916                    }
 155917
 155918                    return (Profile: transcodingProfile, PlayMethod: playMethod, Rank: rank);
 155919                })
 155920                .OrderBy(analysis => analysis.Rank);
 921
 155922            var profileMatch = analyzedProfiles.FirstOrDefault();
 923
 155924            return (profileMatch.Profile, profileMatch.PlayMethod);
 925        }
 926
 927        private void BuildStreamVideoItem(
 928            StreamInfo playlistItem,
 929            MediaOptions options,
 930            MediaSourceInfo item,
 931            MediaStream? videoStream,
 932            MediaStream? audioStream,
 933            IEnumerable<MediaStream> candidateAudioStreams,
 934            string? container,
 935            string? videoCodec,
 936            string? audioCodec)
 937        {
 938            // Prefer matching video codecs
 147939            var videoCodecs = ContainerHelper.Split(videoCodec).ToList();
 940
 147941            if (videoCodecs.Count == 0 && videoStream is not null)
 942            {
 943                // Add the original codec if no codec is specified
 0944                videoCodecs.Add(videoStream.Codec);
 945            }
 946
 947            // Enforce HLS video codec restrictions
 147948            if (playlistItem.SubProtocol == MediaStreamProtocol.hls)
 949            {
 133950                videoCodecs = videoCodecs.Where(codec => _supportedHlsVideoCodecs.Contains(codec)).ToList();
 951            }
 952
 147953            playlistItem.VideoCodecs = videoCodecs;
 954
 955            // Copy video codec options as a starting point, this applies to transcode and direct-stream
 147956            playlistItem.MaxFramerate = videoStream?.ReferenceFrameRate;
 147957            var qualifier = videoStream?.Codec;
 147958            if (videoStream?.Level is not null)
 959            {
 146960                playlistItem.SetOption(qualifier, "level", videoStream.Level.Value.ToString(CultureInfo.InvariantCulture
 961            }
 962
 147963            if (videoStream?.BitDepth is not null)
 964            {
 146965                playlistItem.SetOption(qualifier, "videobitdepth", videoStream.BitDepth.Value.ToString(CultureInfo.Invar
 966            }
 967
 147968            if (!string.IsNullOrEmpty(videoStream?.Profile))
 969            {
 146970                playlistItem.SetOption(qualifier, "profile", videoStream.Profile.ToLowerInvariant());
 971            }
 972
 973            // Prefer matching audio codecs, could do better here
 147974            var audioCodecs = ContainerHelper.Split(audioCodec).ToList();
 975
 147976            if (audioCodecs.Count == 0 && audioStream is not null)
 977            {
 978                // Add the original codec if no codec is specified
 0979                audioCodecs.Add(audioStream.Codec);
 980            }
 981
 982            // Enforce HLS audio codec restrictions
 147983            if (playlistItem.SubProtocol == MediaStreamProtocol.hls)
 984            {
 133985                if (string.Equals(playlistItem.Container, "mp4", StringComparison.OrdinalIgnoreCase))
 986                {
 72987                    audioCodecs = audioCodecs.Where(codec => _supportedHlsAudioCodecsMp4.Contains(codec)).ToList();
 988                }
 989                else
 990                {
 61991                    audioCodecs = audioCodecs.Where(codec => _supportedHlsAudioCodecsTs.Contains(codec)).ToList();
 992                }
 993            }
 994
 147995            var audioStreamWithSupportedCodec = candidateAudioStreams.Where(stream => ContainerHelper.ContainsContainer(
 996
 147997            var channelsExceedsLimit = audioStreamWithSupportedCodec is not null && audioStreamWithSupportedCodec.Channe
 998
 147999            var directAudioFailures = audioStreamWithSupportedCodec is null ? default : GetCompatibilityAudioCodec(optio
 1000
 1471001            playlistItem.TranscodeReasons |= directAudioFailures;
 1002
 1471003            var directAudioStreamSatisfied = audioStreamWithSupportedCodec is not null && !channelsExceedsLimit
 1471004                && directAudioFailures == 0;
 1005
 1471006            directAudioStreamSatisfied = directAudioStreamSatisfied && !playlistItem.TranscodeReasons.HasFlag(TranscodeR
 1007
 1471008            var directAudioStream = directAudioStreamSatisfied ? audioStreamWithSupportedCodec : null;
 1009
 1471010            if (channelsExceedsLimit && playlistItem.TargetAudioStream is not null)
 1011            {
 101012                playlistItem.TranscodeReasons |= TranscodeReason.AudioChannelsNotSupported;
 101013                playlistItem.TargetAudioStream.Channels = playlistItem.TranscodingMaxAudioChannels;
 1014            }
 1015
 1471016            playlistItem.AudioCodecs = audioCodecs;
 1471017            if (directAudioStream is not null)
 1018            {
 561019                audioStream = directAudioStream;
 561020                playlistItem.AudioStreamIndex = audioStream.Index;
 561021                audioCodecs = [audioStream.Codec];
 561022                playlistItem.AudioCodecs = audioCodecs;
 1023
 1024                // Copy matching audio codec options
 561025                playlistItem.AudioSampleRate = audioStream.SampleRate;
 561026                playlistItem.SetOption(qualifier, "audiochannels", audioStream.Channels?.ToString(CultureInfo.InvariantC
 1027
 561028                if (!string.IsNullOrEmpty(audioStream.Profile))
 1029                {
 541030                    playlistItem.SetOption(audioStream.Codec, "profile", audioStream.Profile.ToLowerInvariant());
 1031                }
 1032
 561033                if (audioStream.Level.HasValue && audioStream.Level.Value != 0)
 1034                {
 01035                    playlistItem.SetOption(audioStream.Codec, "level", audioStream.Level.Value.ToString(CultureInfo.Inva
 1036                }
 1037            }
 1038
 1471039            int? width = videoStream?.Width;
 1471040            int? height = videoStream?.Height;
 1471041            int? bitDepth = videoStream?.BitDepth;
 1471042            int? videoBitrate = videoStream?.BitRate;
 1471043            double? videoLevel = videoStream?.Level;
 1471044            string? videoProfile = videoStream?.Profile;
 1471045            VideoRangeType? videoRangeType = videoStream?.VideoRangeType;
 1471046            float videoFramerate = videoStream is null ? 0 : videoStream.ReferenceFrameRate ?? 0;
 1471047            bool? isAnamorphic = videoStream?.IsAnamorphic;
 1471048            bool? isInterlaced = videoStream?.IsInterlaced;
 1471049            string? videoCodecTag = videoStream?.CodecTag;
 1471050            bool? isAvc = videoStream?.IsAVC;
 1471051            int? videoRotation = videoStream?.Rotation;
 1052
 1471053            TransportStreamTimestamp? timestamp = videoStream is null ? TransportStreamTimestamp.None : item.Timestamp;
 1471054            int? packetLength = videoStream?.PacketLength;
 1471055            int? refFrames = videoStream?.RefFrames;
 1056
 1471057            int numStreams = item.MediaStreams.Count;
 1471058            int? numAudioStreams = item.GetStreamCount(MediaStreamType.Audio);
 1471059            int? numVideoStreams = item.GetStreamCount(MediaStreamType.Video);
 1060
 1471061            var useSubContainer = playlistItem.SubProtocol == MediaStreamProtocol.hls;
 1062
 1471063            var appliedVideoConditions = options.Profile.CodecProfiles
 1471064                .Where(i => i.Type == CodecType.Video &&
 1471065                    i.ContainsAnyCodec(playlistItem.VideoCodecs, container, useSubContainer) &&
 1471066                    i.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoConditionSatisfied(applyCondition,
 1471067                // Reverse codec profiles for backward compatibility - first codec profile has higher priority
 1471068                .Reverse();
 8901069            foreach (var condition in appliedVideoConditions)
 1070            {
 24161071                foreach (var transcodingVideoCodec in playlistItem.VideoCodecs)
 1072                {
 9101073                    if (condition.ContainsAnyCodec(transcodingVideoCodec, container, useSubContainer))
 1074                    {
 3061075                        ApplyTranscodingConditions(playlistItem, condition.Conditions, transcodingVideoCodec, true, true
 1076                        continue;
 1077                    }
 1078                }
 1079            }
 1080
 1081            // Honor requested max channels
 1471082            playlistItem.GlobalMaxAudioChannels = channelsExceedsLimit ? playlistItem.TranscodingMaxAudioChannels : opti
 1083
 1471084            int audioBitrate = GetAudioBitrate(options.GetMaxBitrate(true) ?? 0, playlistItem.TargetAudioCodec, audioStr
 1471085            playlistItem.AudioBitrate = Math.Min(playlistItem.AudioBitrate ?? audioBitrate, audioBitrate);
 1086
 1471087            bool? isSecondaryAudio = audioStream is null ? null : item.IsSecondaryAudio(audioStream);
 1471088            int? inputAudioBitrate = audioStream?.BitRate;
 1471089            int? audioChannels = audioStream?.Channels;
 1471090            string? audioProfile = audioStream?.Profile;
 1471091            int? inputAudioSampleRate = audioStream?.SampleRate;
 1471092            int? inputAudioBitDepth = audioStream?.BitDepth;
 1093
 1471094            var appliedAudioConditions = options.Profile.CodecProfiles
 1471095                .Where(i => i.Type == CodecType.VideoAudio &&
 1471096                    i.ContainsAnyCodec(playlistItem.AudioCodecs, container) &&
 1471097                    i.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoAudioConditionSatisfied(applyCondi
 1471098                // Reverse codec profiles for backward compatibility - first codec profile has higher priority
 1471099                .Reverse();
 1100
 5981101            foreach (var codecProfile in appliedAudioConditions)
 1102            {
 4561103                foreach (var transcodingAudioCodec in playlistItem.AudioCodecs)
 1104                {
 1521105                    if (codecProfile.ContainsAnyCodec(transcodingAudioCodec, container))
 1106                    {
 1521107                        ApplyTranscodingConditions(playlistItem, codecProfile.Conditions, transcodingAudioCodec, true, t
 1521108                        break;
 1109                    }
 1110                }
 1111            }
 1112
 1471113            var maxBitrateSetting = options.GetMaxBitrate(false);
 1114            // Honor max rate
 1471115            if (maxBitrateSetting.HasValue)
 1116            {
 1471117                var availableBitrateForVideo = maxBitrateSetting.Value;
 1118
 1471119                if (playlistItem.AudioBitrate.HasValue)
 1120                {
 1471121                    availableBitrateForVideo -= playlistItem.AudioBitrate.Value;
 1122                }
 1123
 1124                // Make sure the video bitrate is lower than bitrate settings but at least 64k
 1125                // Don't use Math.Clamp as availableBitrateForVideo can be lower then 64k.
 1471126                var currentValue = playlistItem.VideoBitrate ?? availableBitrateForVideo;
 1471127                playlistItem.VideoBitrate = Math.Max(Math.Min(availableBitrateForVideo, currentValue), 64_000);
 1128            }
 1129
 1471130            _logger.LogDebug(
 1471131                "Transcode Result for Profile: {Profile}, Path: {Path}, PlayMethod: {PlayMethod}, AudioStreamIndex: {Aud
 1471132                options.Profile.Name ?? "Anonymous Profile",
 1471133                item.Path ?? "Unknown path",
 1471134                playlistItem.PlayMethod,
 1471135                audioStream?.Index,
 1471136                playlistItem.SubtitleStreamIndex,
 1471137                playlistItem.TranscodeReasons);
 1471138        }
 1139
 1140        private static int GetDefaultAudioBitrate(string? audioCodec, int? audioChannels)
 1141        {
 601142            if (!string.IsNullOrEmpty(audioCodec))
 1143            {
 1144                // Default to a higher bitrate for stream copy
 601145                if (string.Equals(audioCodec, "aac", StringComparison.OrdinalIgnoreCase)
 601146                    || string.Equals(audioCodec, "mp3", StringComparison.OrdinalIgnoreCase)
 601147                    || string.Equals(audioCodec, "ac3", StringComparison.OrdinalIgnoreCase)
 601148                    || string.Equals(audioCodec, "eac3", StringComparison.OrdinalIgnoreCase))
 1149                {
 551150                    if ((audioChannels ?? 0) < 2)
 1151                    {
 01152                        return 128000;
 1153                    }
 1154
 551155                    return (audioChannels ?? 0) >= 6 ? 640000 : 384000;
 1156                }
 1157
 51158                if (string.Equals(audioCodec, "flac", StringComparison.OrdinalIgnoreCase)
 51159                    || string.Equals(audioCodec, "alac", StringComparison.OrdinalIgnoreCase))
 1160                {
 01161                    if ((audioChannels ?? 0) < 2)
 1162                    {
 01163                        return 768000;
 1164                    }
 1165
 01166                    return (audioChannels ?? 0) >= 6 ? 3584000 : 1536000;
 1167                }
 1168            }
 1169
 51170            return 192000;
 1171        }
 1172
 1173        private static int GetAudioBitrate(long maxTotalBitrate, IReadOnlyList<string> targetAudioCodecs, MediaStream? a
 1174        {
 1471175            string? targetAudioCodec = targetAudioCodecs.Count == 0 ? null : targetAudioCodecs[0];
 1176
 1471177            int? targetAudioChannels = item.GetTargetAudioChannels(targetAudioCodec);
 1178
 1179            int defaultBitrate;
 1471180            int encoderAudioBitrateLimit = int.MaxValue;
 1181
 1471182            if (audioStream is null)
 1183            {
 11184                defaultBitrate = 192000;
 1185            }
 1186            else
 1187            {
 1461188                if (targetAudioChannels.HasValue
 1461189                    && audioStream.Channels.HasValue
 1461190                    && audioStream.Channels.Value > targetAudioChannels.Value)
 1191                {
 1192                    // Reduce the bitrate if we're down mixing.
 461193                    defaultBitrate = GetDefaultAudioBitrate(targetAudioCodec, targetAudioChannels);
 1194                }
 1001195                else if (targetAudioChannels.HasValue
 1001196                         && audioStream.Channels.HasValue
 1001197                         && audioStream.Channels.Value <= targetAudioChannels.Value
 1001198                         && !string.IsNullOrEmpty(audioStream.Codec)
 1001199                         && targetAudioCodecs is not null
 1001200                         && targetAudioCodecs.Count > 0
 1001201                         && !targetAudioCodecs.Any(elem => string.Equals(audioStream.Codec, elem, StringComparison.Ordin
 1202                {
 1203                    // Shift the bitrate if we're transcoding to a different audio codec.
 141204                    defaultBitrate = GetDefaultAudioBitrate(targetAudioCodec, audioStream.Channels.Value);
 1205                }
 1206                else
 1207                {
 861208                    defaultBitrate = audioStream.BitRate ?? GetDefaultAudioBitrate(targetAudioCodec, targetAudioChannels
 1209                }
 1210
 1211                // Seeing webm encoding failures when source has 1 audio channel and 22k bitrate.
 1212                // Any attempts to transcode over 64k will fail
 1461213                if (audioStream.Channels == 1
 1461214                    && (audioStream.BitRate ?? 0) < 64000)
 1215                {
 01216                    encoderAudioBitrateLimit = 64000;
 1217                }
 1218            }
 1219
 1471220            if (maxTotalBitrate > 0)
 1221            {
 1471222                defaultBitrate = Math.Min(GetMaxAudioBitrateForTotalBitrate(maxTotalBitrate), defaultBitrate);
 1223            }
 1224
 1471225            return Math.Min(defaultBitrate, encoderAudioBitrateLimit);
 1226        }
 1227
 1228        private static int GetMaxAudioBitrateForTotalBitrate(long totalBitrate)
 1229        {
 1471230            if (totalBitrate <= 640000)
 1231            {
 81232                return 128000;
 1233            }
 1234
 1391235            if (totalBitrate <= 2000000)
 1236            {
 01237                return 384000;
 1238            }
 1239
 1391240            if (totalBitrate <= 3000000)
 1241            {
 01242                return 448000;
 1243            }
 1244
 1391245            if (totalBitrate <= 4000000)
 1246            {
 01247                return 640000;
 1248            }
 1249
 1391250            if (totalBitrate <= 5000000)
 1251            {
 01252                return 768000;
 1253            }
 1254
 1391255            if (totalBitrate <= 10000000)
 1256            {
 81257                return 1536000;
 1258            }
 1259
 1311260            if (totalBitrate <= 15000000)
 1261            {
 01262                return 2304000;
 1263            }
 1264
 1311265            if (totalBitrate <= 20000000)
 1266            {
 141267                return 3584000;
 1268            }
 1269
 1171270            return 7168000;
 1271        }
 1272
 1273        private (DirectPlayProfile? Profile, PlayMethod? PlayMethod, int? AudioStreamIndex, TranscodeReason TranscodeRea
 1274            MediaOptions options,
 1275            MediaSourceInfo mediaSource,
 1276            MediaStream? videoStream,
 1277            MediaStream? audioStream,
 1278            ICollection<MediaStream> candidateAudioStreams,
 1279            MediaStream? subtitleStream,
 1280            bool isEligibleForDirectPlay,
 1281            bool isEligibleForDirectStream)
 1282        {
 2561283            if (options.ForceDirectPlay)
 1284            {
 01285                return (null, PlayMethod.DirectPlay, audioStream?.Index, 0);
 1286            }
 1287
 2561288            if (options.ForceDirectStream)
 1289            {
 01290                return (null, PlayMethod.DirectStream, audioStream?.Index, 0);
 1291            }
 1292
 2561293            DeviceProfile profile = options.Profile;
 2561294            string container = mediaSource.Container;
 1295
 1296            // Check container conditions
 2561297            var containerProfileReasons = GetCompatibilityContainer(options, mediaSource, container, videoStream);
 1298
 1299            // Check video conditions
 2561300            var videoCodecProfileReasons = videoStream is null ? default : GetCompatibilityVideoCodec(options, mediaSour
 1301
 1302            // Check audio candidates profile conditions
 2561303            var audioStreamMatches = candidateAudioStreams.ToDictionary(s => s, audioStream => GetCompatibilityAudioCode
 1304
 2561305            TranscodeReason subtitleProfileReasons = 0;
 2561306            if (subtitleStream is not null)
 1307            {
 2231308                var subtitleProfile = GetSubtitleProfile(mediaSource, subtitleStream, options.Profile.SubtitleProfiles, 
 1309
 2231310                if (subtitleProfile.Method != SubtitleDeliveryMethod.Drop
 2231311                    && subtitleProfile.Method != SubtitleDeliveryMethod.External
 2231312                    && subtitleProfile.Method != SubtitleDeliveryMethod.Embed)
 1313                {
 01314                    _logger.LogDebug("Not eligible for {0} due to unsupported subtitles", PlayMethod.DirectPlay);
 01315                    subtitleProfileReasons |= TranscodeReason.SubtitleCodecNotSupported;
 1316                }
 1317            }
 1318
 2561319            var containerSupported = false;
 2561320            TranscodeReason[] rankings = [TranscodeReason.VideoCodecNotSupported, VideoCodecReasons, TranscodeReason.Aud
 1321
 1322            // Check DirectPlay profiles to see if it can be direct played
 2561323            var analyzedProfiles = profile.DirectPlayProfiles
 2561324                .Where(directPlayProfile => directPlayProfile.Type == DlnaProfileType.Video)
 2561325                .Select((directPlayProfile, order) =>
 2561326                {
 2561327                    TranscodeReason directPlayProfileReasons = 0;
 2561328                    TranscodeReason audioCodecProfileReasons = 0;
 2561329
 2561330                    // Check container type
 2561331                    if (!directPlayProfile.SupportsContainer(container))
 2561332                    {
 2561333                        directPlayProfileReasons |= TranscodeReason.ContainerNotSupported;
 2561334                    }
 2561335                    else
 2561336                    {
 2561337                        containerSupported = true;
 2561338                    }
 2561339
 2561340                    // Check video codec
 2561341                    string? videoCodec = videoStream?.Codec;
 2561342                    if (!directPlayProfile.SupportsVideoCodec(videoCodec))
 2561343                    {
 2561344                        directPlayProfileReasons |= TranscodeReason.VideoCodecNotSupported;
 2561345                    }
 2561346
 2561347                    // Check audio codec
 2561348                    MediaStream? selectedAudioStream = null;
 2561349                    if (candidateAudioStreams.Count != 0)
 2561350                    {
 2561351                        selectedAudioStream = candidateAudioStreams.FirstOrDefault(audioStream => directPlayProfile.Supp
 2561352                        if (selectedAudioStream is null)
 2561353                        {
 2561354                            directPlayProfileReasons |= TranscodeReason.AudioCodecNotSupported;
 2561355                        }
 2561356                        else
 2561357                        {
 2561358                            audioCodecProfileReasons = audioStreamMatches.GetValueOrDefault(selectedAudioStream);
 2561359                        }
 2561360                    }
 2561361
 2561362                    var failureReasons = directPlayProfileReasons | containerProfileReasons | subtitleProfileReasons;
 2561363
 2561364                    if ((failureReasons & TranscodeReason.VideoCodecNotSupported) == 0)
 2561365                    {
 2561366                        failureReasons |= videoCodecProfileReasons;
 2561367                    }
 2561368
 2561369                    if ((failureReasons & TranscodeReason.AudioCodecNotSupported) == 0)
 2561370                    {
 2561371                        failureReasons |= audioCodecProfileReasons;
 2561372                    }
 2561373
 2561374                    var directStreamFailureReasons = failureReasons & (~DirectStreamReasons);
 2561375
 2561376                    PlayMethod? playMethod = null;
 2561377                    if (failureReasons == 0 && isEligibleForDirectPlay && mediaSource.SupportsDirectPlay)
 2561378                    {
 2561379                        playMethod = PlayMethod.DirectPlay;
 2561380                    }
 2561381                    else if (directStreamFailureReasons == 0 && isEligibleForDirectStream && mediaSource.SupportsDirectS
 2561382                    {
 2561383                        playMethod = PlayMethod.DirectStream;
 2561384                    }
 2561385
 2561386                    var ranked = GetRank(ref failureReasons, rankings);
 2561387
 2561388                    return (Result: (Profile: directPlayProfile, PlayMethod: playMethod, AudioStreamIndex: selectedAudio
 2561389                })
 2561390                .OrderByDescending(analysis => analysis.Result.PlayMethod)
 2561391                .ThenByDescending(analysis => analysis.Rank)
 2561392                .ThenBy(analysis => analysis.Order)
 2561393                .ToArray()
 2561394                .ToLookup(analysis => analysis.Result.PlayMethod is not null);
 1395
 2561396            var profileMatch = analyzedProfiles[true]
 2561397                .Select(analysis => analysis.Result)
 2561398                .FirstOrDefault();
 2561399            if (profileMatch.Profile is not null)
 1400            {
 1251401                return profileMatch;
 1402            }
 1403
 1311404            var failureReasons = analyzedProfiles[false]
 1311405                .Select(analysis => analysis.Result)
 1311406                .Where(result => !containerSupported || !result.TranscodeReason.HasFlag(TranscodeReason.ContainerNotSupp
 1311407                .FirstOrDefault().TranscodeReason;
 1311408            if (failureReasons == 0)
 1409            {
 141410                failureReasons = TranscodeReason.DirectPlayError;
 1411            }
 1412
 1311413            return (Profile: null, PlayMethod: null, AudioStreamIndex: null, TranscodeReasons: failureReasons);
 1414        }
 1415
 1416        private TranscodeReason AggregateFailureConditions(MediaSourceInfo mediaSource, DeviceProfile profile, string ty
 1417        {
 16691418            return conditions.Aggregate<ProfileCondition, TranscodeReason>(0, (reasons, i) =>
 16691419            {
 16691420                LogConditionFailure(profile, type, i, mediaSource);
 16691421                var transcodeReasons = GetTranscodeReasonForFailedCondition(i);
 16691422                return reasons | transcodeReasons;
 16691423            });
 1424        }
 1425
 1426        private void LogConditionFailure(DeviceProfile profile, string type, ProfileCondition condition, MediaSourceInfo
 1427        {
 2481428            _logger.LogDebug(
 2481429                "Profile: {0}, DirectPlay=false. Reason={1}.{2} Condition: {3}. ConditionValue: {4}. IsRequired: {5}. Pa
 2481430                type,
 2481431                profile.Name ?? "Unknown Profile",
 2481432                condition.Property,
 2481433                condition.Condition,
 2481434                condition.Value ?? string.Empty,
 2481435                condition.IsRequired,
 2481436                mediaSource.Path ?? "Unknown path");
 2481437        }
 1438
 1439        /// <summary>
 1440        /// Normalizes input container.
 1441        /// </summary>
 1442        /// <param name="mediaSource">The <see cref="MediaSourceInfo"/>.</param>
 1443        /// <param name="subtitleStream">The <see cref="MediaStream"/> of the subtitle stream.</param>
 1444        /// <param name="subtitleProfiles">The list of supported <see cref="SubtitleProfile"/>s.</param>
 1445        /// <param name="playMethod">The <see cref="PlayMethod"/>.</param>
 1446        /// <param name="transcoderSupport">The <see cref="ITranscoderSupport"/>.</param>
 1447        /// <param name="outputContainer">The output container.</param>
 1448        /// <param name="transcodingSubProtocol">The subtitle transcoding protocol.</param>
 1449        /// <returns>The normalized input container.</returns>
 1450        public static SubtitleProfile GetSubtitleProfile(
 1451            MediaSourceInfo mediaSource,
 1452            MediaStream subtitleStream,
 1453            SubtitleProfile[] subtitleProfiles,
 1454            PlayMethod playMethod,
 1455            ITranscoderSupport transcoderSupport,
 1456            string? outputContainer,
 1457            MediaStreamProtocol? transcodingSubProtocol)
 1458        {
 4821459            if (CanConsiderEmbedSubtitle(subtitleStream, playMethod, transcodingSubProtocol, outputContainer))
 1460            {
 1461                // Look for supported embedded subs of the same format
 541462                foreach (var profile in subtitleProfiles)
 1463                {
 151464                    if (!profile.SupportsLanguage(subtitleStream.Language))
 1465                    {
 1466                        continue;
 1467                    }
 1468
 151469                    if (profile.Method != SubtitleDeliveryMethod.Embed)
 1470                    {
 1471                        continue;
 1472                    }
 1473
 61474                    if (!ContainerHelper.ContainsContainer(profile.Container, outputContainer))
 1475                    {
 1476                        continue;
 1477                    }
 1478
 61479                    if (playMethod == PlayMethod.Transcode && !IsSubtitleEmbedSupported(outputContainer))
 1480                    {
 1481                        continue;
 1482                    }
 1483
 61484                    if (subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format) && string.Equals
 1485                    {
 61486                        return profile;
 1487                    }
 1488                }
 1489
 1490                // Look for supported embedded subs of a convertible format
 361491                foreach (var profile in subtitleProfiles)
 1492                {
 91493                    if (!profile.SupportsLanguage(subtitleStream.Language))
 1494                    {
 1495                        continue;
 1496                    }
 1497
 91498                    if (profile.Method != SubtitleDeliveryMethod.Embed)
 1499                    {
 1500                        continue;
 1501                    }
 1502
 01503                    if (!ContainerHelper.ContainsContainer(profile.Container, outputContainer))
 1504                    {
 1505                        continue;
 1506                    }
 1507
 01508                    if (playMethod == PlayMethod.Transcode && !IsSubtitleEmbedSupported(outputContainer))
 1509                    {
 1510                        continue;
 1511                    }
 1512
 01513                    if (subtitleStream.IsTextSubtitleStream && subtitleStream.SupportsSubtitleConversionTo(profile.Forma
 1514                    {
 01515                        return profile;
 1516                    }
 1517                }
 1518            }
 1519
 1520            // Look for an external or hls profile that matches the stream type (text/graphical) and doesn't require con
 4761521            return GetExternalSubtitleProfile(mediaSource, subtitleStream, subtitleProfiles, playMethod, transcoderSuppo
 4761522                GetExternalSubtitleProfile(mediaSource, subtitleStream, subtitleProfiles, playMethod, transcoderSupport,
 4761523                new SubtitleProfile
 4761524                {
 4761525                    Method = SubtitleDeliveryMethod.Encode,
 4761526                    Format = subtitleStream.Codec
 4761527                };
 1528        }
 1529
 1530        private static bool IsSubtitleEmbedSupported(string? transcodingContainer)
 1531        {
 261532            if (!string.IsNullOrEmpty(transcodingContainer))
 1533            {
 241534                if (ContainerHelper.ContainsContainer(transcodingContainer, "ts,mpegts,mp4"))
 1535                {
 71536                    return false;
 1537                }
 1538
 171539                if (ContainerHelper.ContainsContainer(transcodingContainer, "mkv,matroska"))
 1540                {
 101541                    return true;
 1542                }
 1543            }
 1544
 91545            return false;
 1546        }
 1547
 1548        private static bool CanConsiderEmbedSubtitle(MediaStream subtitleStream, PlayMethod playMethod, MediaStreamProto
 1549        {
 4821550            if (subtitleStream.IsExternal)
 1551            {
 4711552                return playMethod == PlayMethod.Transcode
 4711553                    && transcodingSubProtocol != MediaStreamProtocol.hls
 4711554                    && IsSubtitleEmbedSupported(outputContainer);
 1555            }
 1556
 111557            return playMethod != PlayMethod.Transcode
 111558                || transcodingSubProtocol != MediaStreamProtocol.hls;
 1559        }
 1560
 1561        private static SubtitleProfile? GetExternalSubtitleProfile(MediaSourceInfo mediaSource, MediaStream subtitleStre
 1562        {
 51341563            foreach (var profile in subtitleProfiles)
 1564            {
 20371565                if (profile.Method != SubtitleDeliveryMethod.External && profile.Method != SubtitleDeliveryMethod.Hls)
 1566                {
 1567                    continue;
 1568                }
 1569
 14001570                if (profile.Method == SubtitleDeliveryMethod.Hls && playMethod != PlayMethod.Transcode)
 1571                {
 1572                    continue;
 1573                }
 1574
 14001575                if (!profile.SupportsLanguage(subtitleStream.Language))
 1576                {
 1577                    continue;
 1578                }
 1579
 14001580                if (!subtitleStream.IsExternal && playMethod == PlayMethod.Transcode && !transcoderSupport.CanExtractSub
 1581                {
 1582                    continue;
 1583                }
 1584
 1585                // FFmpeg cannot mux VobSub back into an .idx/.sub pair, so extracted VobSub streams are matched against
 13941586                bool isVobSubMksProfile = string.Equals(profile.Format, "mks", StringComparison.OrdinalIgnoreCase)
 13941587                    && subtitleStream.IsVobSubSubtitleStream
 13941588                    && (!subtitleStream.IsExternal || subtitleStream.Path.EndsWith(".mks", StringComparison.OrdinalIgnor
 1589
 13941590                if ((profile.Method == SubtitleDeliveryMethod.External
 13941591                        && (isVobSubMksProfile || subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profil
 13941592                    (profile.Method == SubtitleDeliveryMethod.Hls && subtitleStream.IsTextSubtitleStream))
 1593                {
 13741594                    bool requiresConversion = !isVobSubMksProfile
 13741595                        && !string.Equals(subtitleStream.Codec, profile.Format, StringComparison.OrdinalIgnoreCase);
 1596
 13741597                    if (!requiresConversion)
 1598                    {
 1861599                        return profile;
 1600                    }
 1601
 11881602                    if (!allowConversion)
 1603                    {
 1604                        continue;
 1605                    }
 1606
 1607                    // TODO: Build this into subtitleStream.SupportsExternalStream
 2861608                    if (mediaSource.IsInfiniteStream)
 1609                    {
 1610                        continue;
 1611                    }
 1612
 2861613                    if (subtitleStream.IsTextSubtitleStream && subtitleStream.SupportsExternalStream && subtitleStream.S
 1614                    {
 2861615                        return profile;
 1616                    }
 1617                }
 1618            }
 1619
 2941620            return null;
 1621        }
 1622
 1623        private bool IsBitrateLimitExceeded(MediaSourceInfo item, long maxBitrate)
 1624        {
 1625            // Don't restrict bitrate if item is remote.
 2801626            if (item.IsRemote)
 1627            {
 01628                return false;
 1629            }
 1630
 1631            // If no maximum bitrate is set, default to no maximum bitrate.
 2801632            long requestedMaxBitrate = maxBitrate > 0 ? maxBitrate : int.MaxValue;
 1633
 1634            // If we don't know the item bitrate, then force a transcode if requested max bitrate is under 40 mbps
 2801635            int itemBitrate = item.Bitrate ?? 40000000;
 1636
 2801637            if (itemBitrate > requestedMaxBitrate)
 1638            {
 241639                _logger.LogDebug(
 241640                    "Bitrate exceeds limit: media bitrate: {MediaBitrate}, max bitrate: {MaxBitrate}",
 241641                    itemBitrate,
 241642                    requestedMaxBitrate);
 241643                return true;
 1644            }
 1645
 2561646            return false;
 1647        }
 1648
 1649        private static void ValidateMediaOptions(MediaOptions options, bool isMediaSource)
 1650        {
 2801651            if (options.ItemId.IsEmpty())
 1652            {
 01653                ArgumentException.ThrowIfNullOrEmpty(options.DeviceId);
 1654            }
 1655
 2801656            if (options.Profile is null)
 1657            {
 01658                throw new ArgumentException("Profile is required");
 1659            }
 1660
 2801661            if (options.MediaSources is null)
 1662            {
 01663                throw new ArgumentException("MediaSources is required");
 1664            }
 1665
 2801666            if (isMediaSource)
 1667            {
 2801668                if (options.AudioStreamIndex.HasValue && string.IsNullOrEmpty(options.MediaSourceId))
 1669                {
 01670                    throw new ArgumentException("MediaSourceId is required when a specific audio stream is requested");
 1671                }
 1672
 2801673                if (options.SubtitleStreamIndex.HasValue && string.IsNullOrEmpty(options.MediaSourceId))
 1674                {
 01675                    throw new ArgumentException("MediaSourceId is required when a specific subtitle stream is requested"
 1676                }
 1677            }
 2801678        }
 1679
 1680        private static IEnumerable<ProfileCondition> GetProfileConditionsForVideoAudio(
 1681            IEnumerable<CodecProfile> codecProfiles,
 1682            string container,
 1683            string codec,
 1684            int? audioChannels,
 1685            int? audioBitrate,
 1686            int? audioSampleRate,
 1687            int? audioBitDepth,
 1688            string audioProfile,
 1689            bool? isSecondaryAudio)
 1690        {
 10091691            return codecProfiles
 10091692                .Where(profile => profile.Type == CodecType.VideoAudio &&
 10091693                    profile.ContainsAnyCodec(codec, container) &&
 10091694                    profile.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoAudioConditionSatisfied(appl
 10091695                .SelectMany(profile => profile.Conditions)
 10091696                .Where(condition => !ConditionProcessor.IsVideoAudioConditionSatisfied(condition, audioChannels, audioBi
 1697        }
 1698
 1699        private static IEnumerable<ProfileCondition> GetProfileConditionsForAudio(
 1700            IEnumerable<CodecProfile> codecProfiles,
 1701            string container,
 1702            string? codec,
 1703            int? audioChannels,
 1704            int? audioBitrate,
 1705            int? audioSampleRate,
 1706            int? audioBitDepth,
 1707            bool checkConditions)
 1708        {
 01709            var conditions = codecProfiles
 01710                .Where(profile => profile.Type == CodecType.Audio &&
 01711                    profile.ContainsAnyCodec(codec, container) &&
 01712                    profile.ApplyConditions.All(applyCondition => ConditionProcessor.IsAudioConditionSatisfied(applyCond
 01713                .SelectMany(profile => profile.Conditions);
 1714
 01715            if (!checkConditions)
 1716            {
 01717                return conditions;
 1718            }
 1719
 01720            return conditions.Where(condition => !ConditionProcessor.IsAudioConditionSatisfied(condition, audioChannels,
 1721        }
 1722
 1723        private void ApplyTranscodingConditions(StreamInfo item, IEnumerable<ProfileCondition> conditions, string? quali
 1724        {
 34941725            foreach (ProfileCondition condition in conditions)
 1726            {
 12441727                string value = condition.Value;
 1728
 12441729                if (string.IsNullOrEmpty(value))
 1730                {
 1731                    continue;
 1732                }
 1733
 1734                // No way to express this
 12441735                if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1736                {
 1737                    continue;
 1738                }
 1739
 12441740                switch (condition.Property)
 1741                {
 1742                    case ProfileConditionValue.AudioBitrate:
 1743                        {
 01744                            if (!enableNonQualifiedConditions)
 1745                            {
 1746                                continue;
 1747                            }
 1748
 01749                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1750                            {
 01751                                if (condition.Condition == ProfileConditionType.Equals)
 1752                                {
 01753                                    item.AudioBitrate = num;
 1754                                }
 01755                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1756                                {
 01757                                    item.AudioBitrate = Math.Min(num, item.AudioBitrate ?? num);
 1758                                }
 01759                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1760                                {
 01761                                    item.AudioBitrate = Math.Max(num, item.AudioBitrate ?? num);
 1762                                }
 1763                            }
 1764
 01765                            break;
 1766                        }
 1767
 1768                    case ProfileConditionValue.AudioSampleRate:
 1769                        {
 01770                            if (!enableNonQualifiedConditions)
 1771                            {
 1772                                continue;
 1773                            }
 1774
 01775                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1776                            {
 01777                                if (condition.Condition == ProfileConditionType.Equals)
 1778                                {
 01779                                    item.AudioSampleRate = num;
 1780                                }
 01781                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1782                                {
 01783                                    item.AudioSampleRate = Math.Min(num, item.AudioSampleRate ?? num);
 1784                                }
 01785                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1786                                {
 01787                                    item.AudioSampleRate = Math.Max(num, item.AudioSampleRate ?? num);
 1788                                }
 1789                            }
 1790
 01791                            break;
 1792                        }
 1793
 1794                    case ProfileConditionValue.AudioChannels:
 1795                        {
 281796                            if (string.IsNullOrEmpty(qualifier))
 1797                            {
 01798                                if (!enableNonQualifiedConditions)
 1799                                {
 01800                                    continue;
 1801                                }
 1802                            }
 1803                            else
 1804                            {
 281805                                if (!enableQualifiedConditions)
 1806                                {
 1807                                    continue;
 1808                                }
 1809                            }
 1810
 281811                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1812                            {
 281813                                if (condition.Condition == ProfileConditionType.Equals)
 1814                                {
 01815                                    item.SetOption(qualifier, "audiochannels", num.ToString(CultureInfo.InvariantCulture
 1816                                }
 281817                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1818                                {
 281819                                    item.SetOption(qualifier, "audiochannels", Math.Min(num, item.GetTargetAudioChannels
 1820                                }
 01821                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1822                                {
 01823                                    item.SetOption(qualifier, "audiochannels", Math.Max(num, item.GetTargetAudioChannels
 1824                                }
 1825                            }
 1826
 01827                            break;
 1828                        }
 1829
 1830                    case ProfileConditionValue.IsAvc:
 1831                        {
 01832                            if (!enableNonQualifiedConditions)
 1833                            {
 1834                                continue;
 1835                            }
 1836
 01837                            if (bool.TryParse(value, out var isAvc))
 1838                            {
 01839                                if (isAvc && condition.Condition == ProfileConditionType.Equals)
 1840                                {
 01841                                    item.RequireAvc = true;
 1842                                }
 01843                                else if (!isAvc && condition.Condition == ProfileConditionType.NotEquals)
 1844                                {
 01845                                    item.RequireAvc = true;
 1846                                }
 1847                            }
 1848
 01849                            break;
 1850                        }
 1851
 1852                    case ProfileConditionValue.IsAnamorphic:
 1853                        {
 2011854                            if (!enableNonQualifiedConditions)
 1855                            {
 1856                                continue;
 1857                            }
 1858
 2011859                            if (bool.TryParse(value, out var isAnamorphic))
 1860                            {
 2011861                                if (isAnamorphic && condition.Condition == ProfileConditionType.Equals)
 1862                                {
 01863                                    item.RequireNonAnamorphic = true;
 1864                                }
 2011865                                else if (!isAnamorphic && condition.Condition == ProfileConditionType.NotEquals)
 1866                                {
 01867                                    item.RequireNonAnamorphic = true;
 1868                                }
 1869                            }
 1870
 01871                            break;
 1872                        }
 1873
 1874                    case ProfileConditionValue.IsInterlaced:
 1875                        {
 1091876                            if (string.IsNullOrEmpty(qualifier))
 1877                            {
 01878                                if (!enableNonQualifiedConditions)
 1879                                {
 01880                                    continue;
 1881                                }
 1882                            }
 1883                            else
 1884                            {
 1091885                                if (!enableQualifiedConditions)
 1886                                {
 1887                                    continue;
 1888                                }
 1889                            }
 1890
 1091891                            if (bool.TryParse(value, out var isInterlaced))
 1892                            {
 1091893                                if (!isInterlaced && condition.Condition == ProfileConditionType.Equals)
 1894                                {
 01895                                    item.SetOption(qualifier, "deinterlace", "true");
 1896                                }
 1091897                                else if (isInterlaced && condition.Condition == ProfileConditionType.NotEquals)
 1898                                {
 1091899                                    item.SetOption(qualifier, "deinterlace", "true");
 1900                                }
 1901                            }
 1902
 1091903                            break;
 1904                        }
 1905
 1906                    case ProfileConditionValue.AudioProfile:
 1907                    case ProfileConditionValue.Has64BitOffsets:
 1908                    case ProfileConditionValue.PacketLength:
 1909                    case ProfileConditionValue.NumStreams:
 1910                    case ProfileConditionValue.NumAudioStreams:
 1911                    case ProfileConditionValue.NumVideoStreams:
 1912                    case ProfileConditionValue.IsSecondaryAudio:
 1913                    case ProfileConditionValue.VideoTimestamp:
 1914                        {
 1915                            // Not supported yet
 1916                            break;
 1917                        }
 1918
 1919                    case ProfileConditionValue.RefFrames:
 1920                        {
 21921                            if (string.IsNullOrEmpty(qualifier))
 1922                            {
 01923                                if (!enableNonQualifiedConditions)
 1924                                {
 01925                                    continue;
 1926                                }
 1927                            }
 1928                            else
 1929                            {
 21930                                if (!enableQualifiedConditions)
 1931                                {
 1932                                    continue;
 1933                                }
 1934                            }
 1935
 21936                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1937                            {
 21938                                if (condition.Condition == ProfileConditionType.Equals)
 1939                                {
 01940                                    item.SetOption(qualifier, "maxrefframes", num.ToString(CultureInfo.InvariantCulture)
 1941                                }
 21942                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1943                                {
 21944                                    item.SetOption(qualifier, "maxrefframes", Math.Min(num, item.GetTargetRefFrames(qual
 1945                                }
 01946                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1947                                {
 01948                                    item.SetOption(qualifier, "maxrefframes", Math.Max(num, item.GetTargetRefFrames(qual
 1949                                }
 1950                            }
 1951
 01952                            break;
 1953                        }
 1954
 1955                    case ProfileConditionValue.VideoBitDepth:
 1956                        {
 01957                            if (string.IsNullOrEmpty(qualifier))
 1958                            {
 01959                                if (!enableNonQualifiedConditions)
 1960                                {
 01961                                    continue;
 1962                                }
 1963                            }
 1964                            else
 1965                            {
 01966                                if (!enableQualifiedConditions)
 1967                                {
 1968                                    continue;
 1969                                }
 1970                            }
 1971
 01972                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1973                            {
 01974                                if (condition.Condition == ProfileConditionType.Equals)
 1975                                {
 01976                                    item.SetOption(qualifier, "videobitdepth", num.ToString(CultureInfo.InvariantCulture
 1977                                }
 01978                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1979                                {
 01980                                    item.SetOption(qualifier, "videobitdepth", Math.Min(num, item.GetTargetVideoBitDepth
 1981                                }
 01982                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1983                                {
 01984                                    item.SetOption(qualifier, "videobitdepth", Math.Max(num, item.GetTargetVideoBitDepth
 1985                                }
 1986                            }
 1987
 01988                            break;
 1989                        }
 1990
 1991                    case ProfileConditionValue.VideoProfile:
 1992                        {
 2241993                            if (string.IsNullOrEmpty(qualifier))
 1994                            {
 1995                                continue;
 1996                            }
 1997
 1998                            // Change from split by | to comma
 1999                            // Strip spaces to avoid having to encode
 2242000                            var values = value
 2242001                                .Split('|', StringSplitOptions.RemoveEmptyEntries);
 2002
 2242003                            if (condition.Condition == ProfileConditionType.Equals)
 2004                            {
 02005                                item.SetOption(qualifier, "profile", string.Join(',', values));
 2006                            }
 2242007                            else if (condition.Condition == ProfileConditionType.EqualsAny)
 2008                            {
 2242009                                var currentValue = item.GetOption(qualifier, "profile");
 2242010                                if (!string.IsNullOrEmpty(currentValue) && values.Any(value => value == currentValue))
 2011                                {
 712012                                    item.SetOption(qualifier, "profile", currentValue);
 2013                                }
 2014                                else
 2015                                {
 1532016                                    item.SetOption(qualifier, "profile", string.Join(',', values));
 2017                                }
 2018                            }
 2019
 1532020                            break;
 2021                        }
 2022
 2023                    case ProfileConditionValue.VideoRangeType:
 2024                        {
 2582025                            if (string.IsNullOrEmpty(qualifier))
 2026                            {
 2027                                continue;
 2028                            }
 2029
 2030                            // change from split by | to comma
 2031                            // strip spaces to avoid having to encode
 2582032                            var values = value
 2582033                                .Split('|', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 2034
 2582035                            if (condition.Condition == ProfileConditionType.Equals)
 2036                            {
 02037                                item.SetOption(qualifier, "rangetype", string.Join(',', values));
 2038                            }
 2582039                            else if (condition.Condition == ProfileConditionType.NotEquals)
 2040                            {
 02041                                item.SetOption(qualifier, "rangetype", string.Join(',', Enum.GetNames<VideoRangeType>().
 2042                            }
 2582043                            else if (condition.Condition == ProfileConditionType.EqualsAny)
 2044                            {
 2582045                                var currentValue = item.GetOption(qualifier, "rangetype");
 2582046                                if (!string.IsNullOrEmpty(currentValue) && values.Any(v => string.Equals(v, currentValue
 2047                                {
 02048                                    item.SetOption(qualifier, "rangetype", currentValue);
 2049                                }
 2050                                else
 2051                                {
 2582052                                    item.SetOption(qualifier, "rangetype", string.Join(',', values));
 2053                                }
 2054                            }
 2055
 2582056                            break;
 2057                        }
 2058
 2059                    case ProfileConditionValue.VideoCodecTag:
 2060                        {
 122061                            if (string.IsNullOrEmpty(qualifier))
 2062                            {
 2063                                continue;
 2064                            }
 2065
 2066                            // change from split by | to comma
 2067                            // strip spaces to avoid having to encode
 122068                            var values = value
 122069                                .Split('|', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 2070
 122071                            if (condition.Condition == ProfileConditionType.Equals)
 2072                            {
 02073                                item.SetOption(qualifier, "codectag", string.Join(',', values));
 2074                            }
 122075                            else if (condition.Condition == ProfileConditionType.EqualsAny)
 2076                            {
 122077                                var currentValue = item.GetOption(qualifier, "codectag");
 122078                                if (!string.IsNullOrEmpty(currentValue) && values.Any(v => string.Equals(v, currentValue
 2079                                {
 02080                                    item.SetOption(qualifier, "codectag", currentValue);
 2081                                }
 2082                                else
 2083                                {
 122084                                    item.SetOption(qualifier, "codectag", string.Join(',', values));
 2085                                }
 2086                            }
 2087
 122088                            break;
 2089                        }
 2090
 2091                    case ProfileConditionValue.VideoRotation:
 2092                        {
 02093                            if (string.IsNullOrEmpty(qualifier))
 2094                            {
 2095                                continue;
 2096                            }
 2097
 2098                            // change from split by | to comma
 2099                            // strip spaces to avoid having to encode
 02100                            var values = value
 02101                                .Split('|', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 2102
 02103                            if (condition.Condition == ProfileConditionType.Equals)
 2104                            {
 02105                                item.SetOption(qualifier, "rotation", string.Join(',', values));
 2106                            }
 02107                            else if (condition.Condition == ProfileConditionType.EqualsAny)
 2108                            {
 02109                                var currentValue = item.GetOption(qualifier, "rotation");
 02110                                if (!string.IsNullOrEmpty(currentValue) && values.Any(v => string.Equals(v, currentValue
 2111                                {
 02112                                    item.SetOption(qualifier, "rotation", currentValue);
 2113                                }
 2114                                else
 2115                                {
 02116                                    item.SetOption(qualifier, "rotation", string.Join(',', values));
 2117                                }
 2118                            }
 2119
 02120                            break;
 2121                        }
 2122
 2123                    case ProfileConditionValue.Height:
 2124                        {
 02125                            if (!enableNonQualifiedConditions)
 2126                            {
 2127                                continue;
 2128                            }
 2129
 02130                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2131                            {
 02132                                if (condition.Condition == ProfileConditionType.Equals)
 2133                                {
 02134                                    item.MaxHeight = num;
 2135                                }
 02136                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2137                                {
 02138                                    item.MaxHeight = Math.Min(num, item.MaxHeight ?? num);
 2139                                }
 02140                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2141                                {
 02142                                    item.MaxHeight = Math.Max(num, item.MaxHeight ?? num);
 2143                                }
 2144                            }
 2145
 02146                            break;
 2147                        }
 2148
 2149                    case ProfileConditionValue.VideoBitrate:
 2150                        {
 322151                            if (!enableNonQualifiedConditions)
 2152                            {
 2153                                continue;
 2154                            }
 2155
 322156                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2157                            {
 322158                                if (condition.Condition == ProfileConditionType.Equals)
 2159                                {
 02160                                    item.VideoBitrate = num;
 2161                                }
 322162                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2163                                {
 322164                                    item.VideoBitrate = Math.Min(num, item.VideoBitrate ?? num);
 2165                                }
 02166                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2167                                {
 02168                                    item.VideoBitrate = Math.Max(num, item.VideoBitrate ?? num);
 2169                                }
 2170                            }
 2171
 02172                            break;
 2173                        }
 2174
 2175                    case ProfileConditionValue.VideoFramerate:
 2176                        {
 122177                            if (!enableNonQualifiedConditions)
 2178                            {
 2179                                continue;
 2180                            }
 2181
 122182                            if (float.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2183                            {
 122184                                if (condition.Condition == ProfileConditionType.Equals)
 2185                                {
 02186                                    item.MaxFramerate = num;
 2187                                }
 122188                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2189                                {
 122190                                    item.MaxFramerate = Math.Min(num, item.MaxFramerate ?? num);
 2191                                }
 02192                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2193                                {
 02194                                    item.MaxFramerate = Math.Max(num, item.MaxFramerate ?? num);
 2195                                }
 2196                            }
 2197
 02198                            break;
 2199                        }
 2200
 2201                    case ProfileConditionValue.VideoLevel:
 2202                        {
 2122203                            if (string.IsNullOrEmpty(qualifier))
 2204                            {
 2205                                continue;
 2206                            }
 2207
 2122208                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2209                            {
 2122210                                if (condition.Condition == ProfileConditionType.Equals)
 2211                                {
 02212                                    item.SetOption(qualifier, "level", num.ToString(CultureInfo.InvariantCulture));
 2213                                }
 2122214                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2215                                {
 2122216                                    item.SetOption(qualifier, "level", Math.Min(num, item.GetTargetVideoLevel(qualifier)
 2217                                }
 02218                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2219                                {
 02220                                    item.SetOption(qualifier, "level", Math.Max(num, item.GetTargetVideoLevel(qualifier)
 2221                                }
 2222                            }
 2223
 02224                            break;
 2225                        }
 2226
 2227                    case ProfileConditionValue.Width:
 2228                        {
 42229                            if (!enableNonQualifiedConditions)
 2230                            {
 2231                                continue;
 2232                            }
 2233
 42234                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2235                            {
 42236                                if (condition.Condition == ProfileConditionType.Equals)
 2237                                {
 02238                                    item.MaxWidth = num;
 2239                                }
 42240                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2241                                {
 42242                                    item.MaxWidth = Math.Min(num, item.MaxWidth ?? num);
 2243                                }
 02244                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2245                                {
 02246                                    item.MaxWidth = Math.Max(num, item.MaxWidth ?? num);
 2247                                }
 2248                            }
 2249
 2250                            break;
 2251                        }
 2252
 2253                    default:
 2254                        break;
 2255                }
 2256            }
 5032257        }
 2258
 2259        private static bool IsAudioContainerSupported(DirectPlayProfile profile, MediaSourceInfo item)
 2260        {
 2261            // Check container type
 02262            if (!profile.SupportsContainer(item.Container))
 2263            {
 02264                return false;
 2265            }
 2266
 2267            // Never direct play audio in matroska when the device only declare support for webm.
 2268            // The first check is not enough because mkv is assumed can be webm.
 2269            // See https://github.com/jellyfin/jellyfin/issues/13344
 02270            return !ContainerHelper.ContainsContainer("mkv", item.Container)
 02271                   || profile.SupportsContainer("mkv");
 2272        }
 2273
 2274        private static bool IsAudioDirectPlaySupported(DirectPlayProfile profile, MediaSourceInfo item, MediaStream audi
 2275        {
 02276            if (!IsAudioContainerSupported(profile, item))
 2277            {
 02278                return false;
 2279            }
 2280
 2281            // Check audio codec
 02282            string? audioCodec = audioStream?.Codec;
 02283            if (!profile.SupportsAudioCodec(audioCodec))
 2284            {
 02285                return false;
 2286            }
 2287
 02288            return true;
 2289        }
 2290
 2291        private static bool IsAudioDirectStreamSupported(DirectPlayProfile profile, MediaSourceInfo item, MediaStream au
 2292        {
 2293            // Check container type, this should NOT be supported
 2294            // If the container is supported, the file should be directly played
 02295            if (IsAudioContainerSupported(profile, item))
 2296            {
 02297                return false;
 2298            }
 2299
 2300            // Check audio codec, we cannot use the SupportsAudioCodec here
 2301            // Because that one assumes empty container supports all codec, which is just useless
 02302            string? audioCodec = audioStream?.Codec;
 02303            return string.Equals(profile.AudioCodec, audioCodec, StringComparison.OrdinalIgnoreCase)
 02304                   || string.Equals(profile.Container, audioCodec, StringComparison.OrdinalIgnoreCase);
 2305        }
 2306
 2307        private int GetRank(ref TranscodeReason a, TranscodeReason[] rankings)
 2308        {
 12112309            var index = 1;
 87572310            foreach (var flag in rankings)
 2311            {
 36732312                var reason = a & flag;
 36732313                if (reason != 0)
 2314                {
 10112315                    return index;
 2316                }
 2317
 26622318                index++;
 2319            }
 2320
 2002321            return index;
 2322        }
 2323
 2324        /// <summary>
 2325        /// Check the profile conditions.
 2326        /// </summary>
 2327        /// <param name="conditions">Profile conditions.</param>
 2328        /// <param name="mediaSource">Media source.</param>
 2329        /// <param name="videoStream">Video stream.</param>
 2330        /// <returns>Failed profile conditions.</returns>
 2331        private IEnumerable<ProfileCondition> CheckVideoConditions(ProfileCondition[] conditions, MediaSourceInfo mediaS
 2332        {
 7312333            int? width = videoStream?.Width;
 7312334            int? height = videoStream?.Height;
 7312335            int? bitDepth = videoStream?.BitDepth;
 7312336            int? videoBitrate = videoStream?.BitRate;
 7312337            double? videoLevel = videoStream?.Level;
 7312338            string? videoProfile = videoStream?.Profile;
 7312339            VideoRangeType? videoRangeType = videoStream?.VideoRangeType;
 7312340            float videoFramerate = videoStream is null ? 0 : videoStream.ReferenceFrameRate ?? 0;
 7312341            bool? isAnamorphic = videoStream?.IsAnamorphic;
 7312342            bool? isInterlaced = videoStream?.IsInterlaced;
 7312343            string? videoCodecTag = videoStream?.CodecTag;
 7312344            bool? isAvc = videoStream?.IsAVC;
 7312345            int? videoRotation = videoStream?.Rotation;
 2346
 7312347            TransportStreamTimestamp? timestamp = videoStream is null ? TransportStreamTimestamp.None : mediaSource.Time
 7312348            int? packetLength = videoStream?.PacketLength;
 7312349            int? refFrames = videoStream?.RefFrames;
 2350
 7312351            int numStreams = mediaSource.MediaStreams.Count;
 7312352            int? numAudioStreams = mediaSource.GetStreamCount(MediaStreamType.Audio);
 7312353            int? numVideoStreams = mediaSource.GetStreamCount(MediaStreamType.Video);
 2354
 7312355            return conditions.Where(applyCondition => !ConditionProcessor.IsVideoConditionSatisfied(applyCondition, widt
 2356        }
 2357
 2358        /// <summary>
 2359        /// Check the compatibility of the container.
 2360        /// </summary>
 2361        /// <param name="options">Media options.</param>
 2362        /// <param name="mediaSource">Media source.</param>
 2363        /// <param name="container">Container.</param>
 2364        /// <param name="videoStream">Video stream.</param>
 2365        /// <returns>Transcode reasons if the container is not fully compatible.</returns>
 2366        private TranscodeReason GetCompatibilityContainer(MediaOptions options, MediaSourceInfo mediaSource, string cont
 2367        {
 2562368            var profile = options.Profile;
 2369
 2562370            var failures = AggregateFailureConditions(
 2562371                mediaSource,
 2562372                profile,
 2562373                "VideoCodecProfile",
 2562374                profile.ContainerProfiles
 2562375                    .Where(containerProfile => containerProfile.Type == DlnaProfileType.Video && containerProfile.Contai
 2562376                    .SelectMany(containerProfile => CheckVideoConditions(containerProfile.Conditions, mediaSource, video
 2377
 2562378            return failures;
 2379        }
 2380
 2381        /// <summary>
 2382        /// Check the compatibility of the video codec.
 2383        /// </summary>
 2384        /// <param name="options">Media options.</param>
 2385        /// <param name="mediaSource">Media source.</param>
 2386        /// <param name="container">Container.</param>
 2387        /// <param name="videoStream">Video stream.</param>
 2388        /// <returns>Transcode reasons if the video stream is not fully compatible.</returns>
 2389        private TranscodeReason GetCompatibilityVideoCodec(MediaOptions options, MediaSourceInfo mediaSource, string con
 2390        {
 4042391            var profile = options.Profile;
 2392
 4042393            string videoCodec = videoStream.Codec;
 2394
 4042395            var failures = AggregateFailureConditions(
 4042396                mediaSource,
 4042397                profile,
 4042398                "VideoCodecProfile",
 4042399                profile.CodecProfiles
 4042400                    .Where(codecProfile => codecProfile.Type == CodecType.Video &&
 4042401                        codecProfile.ContainsAnyCodec(videoCodec, container) &&
 4042402                        !CheckVideoConditions(codecProfile.ApplyConditions, mediaSource, videoStream).Any())
 4042403                    .SelectMany(codecProfile => CheckVideoConditions(codecProfile.Conditions, mediaSource, videoStream))
 2404
 4042405            return failures;
 2406        }
 2407
 2408        /// <summary>
 2409        /// Check the compatibility of the audio codec.
 2410        /// </summary>
 2411        /// <param name="options">Media options.</param>
 2412        /// <param name="mediaSource">Media source.</param>
 2413        /// <param name="container">Container.</param>
 2414        /// <param name="audioStream">Audio stream.</param>
 2415        /// <param name="transcodingAudioCodec">Override audio codec.</param>
 2416        /// <param name="isVideo">The media source is video.</param>
 2417        /// <param name="isSecondaryAudio">The audio stream is secondary.</param>
 2418        /// <returns>Transcode reasons if the audio stream is not fully compatible.</returns>
 2419        private TranscodeReason GetCompatibilityAudioCodec(MediaOptions options, MediaSourceInfo mediaSource, string con
 2420        {
 10092421            var profile = options.Profile;
 2422
 10092423            var audioCodec = transcodingAudioCodec ?? audioStream.Codec;
 10092424            var audioProfile = audioStream.Profile;
 10092425            var audioChannels = audioStream.Channels;
 10092426            var audioBitrate = audioStream.BitRate;
 10092427            var audioSampleRate = audioStream.SampleRate;
 10092428            var audioBitDepth = audioStream.BitDepth;
 2429
 10092430            var audioFailureConditions = isVideo
 10092431                ? GetProfileConditionsForVideoAudio(profile.CodecProfiles, container, audioCodec, audioChannels, audioBi
 10092432                : GetProfileConditionsForAudio(profile.CodecProfiles, container, audioCodec, audioChannels, audioBitrate
 2433
 10092434            var failures = AggregateFailureConditions(mediaSource, profile, "AudioCodecProfile", audioFailureConditions)
 2435
 10092436            return failures;
 2437        }
 2438
 2439        /// <summary>
 2440        /// Check the compatibility of the audio codec for direct playback.
 2441        /// </summary>
 2442        /// <param name="options">Media options.</param>
 2443        /// <param name="mediaSource">Media source.</param>
 2444        /// <param name="container">Container.</param>
 2445        /// <param name="audioStream">Audio stream.</param>
 2446        /// <param name="isVideo">The media source is video.</param>
 2447        /// <param name="isSecondaryAudio">The audio stream is secondary.</param>
 2448        /// <returns>Transcode reasons if the audio stream is not fully compatible for direct playback.</returns>
 2449        private TranscodeReason GetCompatibilityAudioCodecDirect(MediaOptions options, MediaSourceInfo mediaSource, stri
 2450        {
 2752451            var failures = GetCompatibilityAudioCodec(options, mediaSource, container, audioStream, null, isVideo, isSec
 2452
 2752453            if (audioStream.IsExternal)
 2454            {
 62455                failures |= TranscodeReason.AudioIsExternal;
 2456            }
 2457
 2752458            return failures;
 2459        }
 2460    }
 2461}
Generated by: ReportGenerator 5.5.10.0
6/15/2026 - 12:16:13 AM
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(MediaBrowser.Model.Dlna.ITranscoderSupport,Microsoft.Extensions.Logging.ILogger)
GetOptimalAudioStream(MediaBrowser.Model.Dlna.MediaOptions)
GetOptimalAudioStream(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Dlna.MediaOptions)
GetOptimalVideoStream(MediaBrowser.Model.Dlna.MediaOptions)
GetOptimalStream(System.Collections.Generic.List`1<MediaBrowser.Model.Dlna.StreamInfo>,System.Int64)
SortMediaSources(System.Collections.Generic.List`1<MediaBrowser.Model.Dlna.StreamInfo>,System.Int64)
GetTranscodeReasonForFailedCondition(MediaBrowser.Model.Dlna.ProfileCondition)
NormalizeMediaSourceFormatIntoSingleContainer(System.String,MediaBrowser.Model.Dlna.DeviceProfile,MediaBrowser.Model.Dlna.DlnaProfileType,MediaBrowser.Model.Dlna.DirectPlayProfile)
GetAudioDirectPlayProfile(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Dlna.MediaOptions)
GetTranscodeReasonsFromDirectPlayProfile(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Entities.MediaStream,System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.Dlna.DirectPlayProfile>)
GetDefaultSubtitleStreamIndex(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Dlna.SubtitleProfile[])
SetStreamInfoOptionsFromTranscodingProfile(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Dlna.StreamInfo,MediaBrowser.Model.Dlna.TranscodingProfile)
SetStreamInfoOptionsFromDirectPlayProfile(MediaBrowser.Model.Dlna.MediaOptions,MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Dlna.StreamInfo,MediaBrowser.Model.Dlna.DirectPlayProfile)
BuildVideoItem(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Dlna.MediaOptions)
GetVideoTranscodeProfile(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Dlna.MediaOptions,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Dlna.StreamInfo)
BuildStreamVideoItem(MediaBrowser.Model.Dlna.StreamInfo,MediaBrowser.Model.Dlna.MediaOptions,MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Entities.MediaStream,System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.Entities.MediaStream>,System.String,System.String,System.String)
GetDefaultAudioBitrate(System.String,System.Nullable`1<System.Int32>)
GetAudioBitrate(System.Int64,System.Collections.Generic.IReadOnlyList`1<System.String>,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Dlna.StreamInfo)
GetMaxAudioBitrateForTotalBitrate(System.Int64)
GetVideoDirectPlayProfile(MediaBrowser.Model.Dlna.MediaOptions,MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Entities.MediaStream,System.Collections.Generic.ICollection`1<MediaBrowser.Model.Entities.MediaStream>,MediaBrowser.Model.Entities.MediaStream,System.Boolean,System.Boolean)
AggregateFailureConditions(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Dlna.DeviceProfile,System.String,System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.Dlna.ProfileCondition>)
LogConditionFailure(MediaBrowser.Model.Dlna.DeviceProfile,System.String,MediaBrowser.Model.Dlna.ProfileCondition,MediaBrowser.Model.Dto.MediaSourceInfo)
GetSubtitleProfile(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Dlna.SubtitleProfile[],MediaBrowser.Model.Session.PlayMethod,MediaBrowser.Model.Dlna.ITranscoderSupport,System.String,System.Nullable`1<Jellyfin.Data.Enums.MediaStreamProtocol>)
IsSubtitleEmbedSupported(System.String)
CanConsiderEmbedSubtitle(MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Session.PlayMethod,System.Nullable`1<Jellyfin.Data.Enums.MediaStreamProtocol>,System.String)
GetExternalSubtitleProfile(MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream,MediaBrowser.Model.Dlna.SubtitleProfile[],MediaBrowser.Model.Session.PlayMethod,MediaBrowser.Model.Dlna.ITranscoderSupport,System.Boolean)
IsBitrateLimitExceeded(MediaBrowser.Model.Dto.MediaSourceInfo,System.Int64)
ValidateMediaOptions(MediaBrowser.Model.Dlna.MediaOptions,System.Boolean)
GetProfileConditionsForVideoAudio(System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.Dlna.CodecProfile>,System.String,System.String,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.String,System.Nullable`1<System.Boolean>)
GetProfileConditionsForAudio(System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.Dlna.CodecProfile>,System.String,System.String,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Nullable`1<System.Int32>,System.Boolean)
ApplyTranscodingConditions(MediaBrowser.Model.Dlna.StreamInfo,System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.Dlna.ProfileCondition>,System.String,System.Boolean,System.Boolean)
IsAudioContainerSupported(MediaBrowser.Model.Dlna.DirectPlayProfile,MediaBrowser.Model.Dto.MediaSourceInfo)
IsAudioDirectPlaySupported(MediaBrowser.Model.Dlna.DirectPlayProfile,MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream)
IsAudioDirectStreamSupported(MediaBrowser.Model.Dlna.DirectPlayProfile,MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream)
GetRank(MediaBrowser.Model.Session.TranscodeReason&,MediaBrowser.Model.Session.TranscodeReason[])
CheckVideoConditions(MediaBrowser.Model.Dlna.ProfileCondition[],MediaBrowser.Model.Dto.MediaSourceInfo,MediaBrowser.Model.Entities.MediaStream)
GetCompatibilityContainer(MediaBrowser.Model.Dlna.MediaOptions,MediaBrowser.Model.Dto.MediaSourceInfo,System.String,MediaBrowser.Model.Entities.MediaStream)
GetCompatibilityVideoCodec(MediaBrowser.Model.Dlna.MediaOptions,MediaBrowser.Model.Dto.MediaSourceInfo,System.String,MediaBrowser.Model.Entities.MediaStream)
GetCompatibilityAudioCodec(MediaBrowser.Model.Dlna.MediaOptions,MediaBrowser.Model.Dto.MediaSourceInfo,System.String,MediaBrowser.Model.Entities.MediaStream,System.String,System.Boolean,System.Boolean)
GetCompatibilityAudioCodecDirect(MediaBrowser.Model.Dlna.MediaOptions,MediaBrowser.Model.Dto.MediaSourceInfo,System.String,MediaBrowser.Model.Entities.MediaStream,System.Boolean,System.Boolean)