< Summary - Jellyfin

Information
Class: MediaBrowser.Model.Dlna.StreamBuilder
Assembly: MediaBrowser.Model
File(s): /srv/git/jellyfin/MediaBrowser.Model/Dlna/StreamBuilder.cs
Line coverage
68%
Covered lines: 725
Uncovered lines: 331
Coverable lines: 1056
Total lines: 2400
Line coverage: 68.6%
Branch coverage
58%
Covered branches: 553
Total branches: 942
Branch coverage: 58.7%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

0255075100

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(...)29.62%2432733.33%
NormalizeMediaSourceFormatIntoSingleContainer(...)100%1616100%
GetAudioDirectPlayProfile(...)0%600240%
GetTranscodeReasonsFromDirectPlayProfile(...)0%420200%
GetDefaultSubtitleStreamIndex(...)96.15%272688.23%
SetStreamInfoOptionsFromTranscodingProfile(...)87.5%8895.23%
SetStreamInfoOptionsFromDirectPlayProfile(...)0%620%
BuildVideoItem(...)66.96%14011286.91%
GetVideoTranscodeProfile(...)70%101096.96%
BuildStreamVideoItem(...)92.06%12612697.24%
GetDefaultAudioBitrate(...)68.18%332271.42%
GetAudioBitrate(...)87.5%323295.83%
GetMaxAudioBitrateForTotalBitrate(...)68.75%231670.58%
GetVideoDirectPlayProfile(...)63.63%222296.11%
AggregateFailureConditions(...)100%11100%
LogConditionFailure(...)66.66%66100%
GetSubtitleProfile(...)14.28%4974236.36%
IsSubtitleEmbedSupported(...)0%4260%
GetExternalSubtitleProfile(...)91.66%3636100%
IsBitrateLimitExceeded(...)66.66%6690.9%
ValidateMediaOptions(...)68.75%351658.33%
GetProfileConditionsForVideoAudio(...)100%11100%
GetProfileConditionsForAudio(...)0%620%
ApplyTranscodingConditions(...)63.8%714822147.85%
IsAudioContainerSupported(...)0%2040%
IsAudioDirectPlaySupported(...)0%4260%
IsAudioDirectStreamSupported(...)0%4260%
GetRank(...)100%44100%
CheckVideoConditions(...)50%3030100%
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        {
 27842            _transcoderSupport = transcoderSupport;
 27843            _logger = logger;
 27844        }
 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        {
 278232            ValidateMediaOptions(options, true);
 233
 278234            var mediaSources = string.IsNullOrEmpty(options.MediaSourceId)
 278235                ? options.MediaSources
 278236                : options.MediaSources.Where(x => string.Equals(x.Id, options.MediaSourceId, StringComparison.OrdinalIgn
 237
 278238            List<StreamInfo> streams = [];
 1112239            foreach (var mediaSourceInfo in mediaSources)
 240            {
 278241                var streamInfo = BuildVideoItem(mediaSourceInfo, options);
 278242                if (streamInfo is not null)
 243                {
 278244                    streams.Add(streamInfo);
 245                }
 246            }
 247
 1112248            foreach (var stream in streams)
 249            {
 278250                stream.DeviceId = options.DeviceId;
 278251                stream.DeviceProfileId = options.Profile.Id?.ToString("N", CultureInfo.InvariantCulture);
 252            }
 253
 278254            return GetOptimalStream(streams, options.GetMaxBitrate(false) ?? 0);
 255        }
 256
 257        private static StreamInfo? GetOptimalStream(List<StreamInfo> streams, long maxBitrate)
 278258            => SortMediaSources(streams, maxBitrate).FirstOrDefault();
 259
 260        private static IOrderedEnumerable<StreamInfo> SortMediaSources(List<StreamInfo> streams, long maxBitrate)
 261        {
 278262            return streams.OrderBy(i =>
 278263            {
 278264                // Nothing beats direct playing a file
 278265                if (i.PlayMethod == PlayMethod.DirectPlay && i.MediaSource?.Protocol == MediaProtocol.File)
 278266                {
 278267                    return 0;
 278268                }
 278269
 278270                return 1;
 278271            }).ThenBy(i =>
 278272            {
 278273                switch (i.PlayMethod)
 278274                {
 278275                    // Let's assume direct streaming a file is just as desirable as direct playing a remote url
 278276                    case PlayMethod.DirectStream:
 278277                    case PlayMethod.DirectPlay:
 278278                        return 0;
 278279                    default:
 278280                        return 1;
 278281                }
 278282            }).ThenBy(i =>
 278283            {
 278284                switch (i.MediaSource?.Protocol)
 278285                {
 278286                    case MediaProtocol.File:
 278287                        return 0;
 278288                    default:
 278289                        return 1;
 278290                }
 278291            }).ThenBy(i =>
 278292            {
 278293                if (maxBitrate > 0)
 278294                {
 278295                    if (i.MediaSource?.Bitrate is not null)
 278296                    {
 278297                        return Math.Abs(i.MediaSource.Bitrate.Value - maxBitrate);
 278298                    }
 278299                }
 278300
 278301                return 0;
 278302            }).ThenBy(streams.IndexOf);
 303        }
 304
 305        private static TranscodeReason GetTranscodeReasonForFailedCondition(ProfileCondition condition)
 306        {
 247307            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.VideoTimestamp:
 384                    // TODO
 0385                    return 0;
 386
 387                case ProfileConditionValue.Width:
 0388                    return TranscodeReason.VideoResolutionNotSupported;
 389
 390                default:
 0391                    return 0;
 392            }
 393        }
 394
 395        /// <summary>
 396        /// Normalizes input container.
 397        /// </summary>
 398        /// <param name="inputContainer">The input container.</param>
 399        /// <param name="profile">The <see cref="DeviceProfile"/>.</param>
 400        /// <param name="type">The <see cref="DlnaProfileType"/>.</param>
 401        /// <param name="playProfile">The <see cref="DirectPlayProfile"/> object to get the video stream from.</param>
 402        /// <returns>The normalized input container.</returns>
 403        public static string? NormalizeMediaSourceFormatIntoSingleContainer(string inputContainer, DeviceProfile? profil
 404        {
 405            // If the source is Live TV the inputContainer will be null until the mediasource is probed on first access
 402406            if (profile is null || string.IsNullOrEmpty(inputContainer) || !inputContainer.Contains(',', StringCompariso
 407            {
 94408                return inputContainer;
 409            }
 410
 308411            var formats = ContainerHelper.Split(inputContainer);
 308412            var playProfiles = playProfile is null ? profile.DirectPlayProfiles : [playProfile];
 1361413            foreach (var format in formats)
 414            {
 2593415                foreach (var directPlayProfile in playProfiles)
 416                {
 924417                    if (directPlayProfile.Type != type)
 418                    {
 419                        continue;
 420                    }
 421
 696422                    if (directPlayProfile.SupportsContainer(format))
 423                    {
 291424                        return format;
 425                    }
 426                }
 427            }
 428
 17429            return inputContainer;
 430        }
 431
 432        private (DirectPlayProfile? Profile, PlayMethod? PlayMethod, TranscodeReason TranscodeReasons) GetAudioDirectPla
 433        {
 0434            var directPlayProfile = options.Profile.DirectPlayProfiles
 0435                .FirstOrDefault(x => x.Type == DlnaProfileType.Audio && IsAudioDirectPlaySupported(x, item, audioStream)
 436
 0437            TranscodeReason transcodeReasons = 0;
 0438            if (directPlayProfile is null)
 439            {
 0440                _logger.LogDebug(
 0441                    "Profile: {0}, No audio direct play profiles found for {1} with codec {2}",
 0442                    options.Profile.Name ?? "Unknown Profile",
 0443                    item.Path ?? "Unknown path",
 0444                    audioStream.Codec ?? "Unknown codec");
 445
 0446                var directStreamProfile = options.Profile.DirectPlayProfiles
 0447                    .FirstOrDefault(x => x.Type == DlnaProfileType.Audio && IsAudioDirectStreamSupported(x, item, audioS
 448
 0449                if (directStreamProfile is not null)
 450                {
 0451                    directPlayProfile = directStreamProfile;
 0452                    transcodeReasons |= TranscodeReason.ContainerNotSupported;
 453                }
 454                else
 455                {
 0456                    return (null, null, GetTranscodeReasonsFromDirectPlayProfile(item, null, audioStream, options.Profil
 457                }
 458            }
 459
 460            // The profile describes what the device supports
 461            // If device requirements are satisfied then allow both direct stream and direct play
 462            // Note: As of 10.10 codebase, SupportsDirectPlay is always true because the MediaSourceInfo initializes thi
 463            // Need to check additionally for current transcode reasons
 0464            if (item.SupportsDirectPlay && transcodeReasons == 0)
 465            {
 0466                if (!IsBitrateLimitExceeded(item, options.GetMaxBitrate(true) ?? 0))
 467                {
 0468                    if (options.EnableDirectPlay)
 469                    {
 0470                        return (directPlayProfile, PlayMethod.DirectPlay, 0);
 471                    }
 472                }
 473                else
 474                {
 0475                    transcodeReasons |= TranscodeReason.ContainerBitrateExceedsLimit;
 476                }
 477            }
 478
 479            // While options takes the network and other factors into account. Only applies to direct stream
 0480            if (item.SupportsDirectStream)
 481            {
 0482                if (!IsBitrateLimitExceeded(item, options.GetMaxBitrate(true) ?? 0))
 483                {
 484                    // Note: as of 10.10 codebase, the options.EnableDirectStream is always false due to
 485                    // "direct-stream http streaming is currently broken"
 486                    // Don't check that option for audio as we always assume that is supported
 0487                    if (transcodeReasons == TranscodeReason.ContainerNotSupported)
 488                    {
 0489                        return (directPlayProfile, PlayMethod.DirectStream, transcodeReasons);
 490                    }
 491                }
 492                else
 493                {
 0494                    transcodeReasons |= TranscodeReason.ContainerBitrateExceedsLimit;
 495                }
 496            }
 497
 0498            return (directPlayProfile, null, transcodeReasons);
 499        }
 500
 501        private static TranscodeReason GetTranscodeReasonsFromDirectPlayProfile(MediaSourceInfo item, MediaStream? video
 502        {
 0503            var mediaType = videoStream is null ? DlnaProfileType.Audio : DlnaProfileType.Video;
 504
 0505            var containerSupported = false;
 0506            var audioSupported = false;
 0507            var videoSupported = false;
 508
 0509            foreach (var profile in directPlayProfiles)
 510            {
 511                // Check container type
 0512                if (profile.Type == mediaType && profile.SupportsContainer(item.Container))
 513                {
 0514                    containerSupported = true;
 515
 0516                    videoSupported = videoStream is null || profile.SupportsVideoCodec(videoStream.Codec);
 517
 0518                    audioSupported = audioStream is null || profile.SupportsAudioCodec(audioStream.Codec);
 519
 0520                    if (videoSupported && audioSupported)
 521                    {
 0522                        break;
 523                    }
 524                }
 525            }
 526
 0527            TranscodeReason reasons = 0;
 0528            if (!containerSupported)
 529            {
 0530                reasons |= TranscodeReason.ContainerNotSupported;
 531            }
 532
 0533            if (!videoSupported)
 534            {
 0535                reasons |= TranscodeReason.VideoCodecNotSupported;
 536            }
 537
 0538            if (!audioSupported)
 539            {
 0540                reasons |= TranscodeReason.AudioCodecNotSupported;
 541            }
 542
 0543            return reasons;
 544        }
 545
 546        private static int? GetDefaultSubtitleStreamIndex(MediaSourceInfo item, SubtitleProfile[] subtitleProfiles)
 547        {
 175548            int highestScore = -1;
 1788549            foreach (var stream in item.MediaStreams)
 550            {
 719551                if (stream.Type == MediaStreamType.Subtitle
 719552                    && stream.Score.HasValue
 719553                    && stream.Score.Value > highestScore)
 554                {
 144555                    highestScore = stream.Score.Value;
 556                }
 557            }
 558
 175559            List<MediaStream> topStreams = [];
 1788560            foreach (var stream in item.MediaStreams)
 561            {
 719562                if (stream.Type == MediaStreamType.Subtitle && stream.Score.HasValue && stream.Score.Value == highestSco
 563                {
 321564                    topStreams.Add(stream);
 565                }
 566            }
 567
 568            // If multiple streams have an equal score, try to pick the most efficient one
 175569            if (topStreams.Count > 1)
 570            {
 378571                foreach (var stream in topStreams)
 572                {
 1464573                    foreach (var profile in subtitleProfiles)
 574                    {
 549575                        if (profile.Method == SubtitleDeliveryMethod.External && string.Equals(profile.Format, stream.Co
 576                        {
 0577                            return stream.Index;
 578                        }
 579                    }
 580                }
 581            }
 582
 583            // If no optimization panned out, just use the original default
 175584            return item.DefaultSubtitleStreamIndex;
 0585        }
 586
 587        private static void SetStreamInfoOptionsFromTranscodingProfile(MediaSourceInfo item, StreamInfo playlistItem, Tr
 588        {
 146589            var container = transcodingProfile.Container;
 146590            var protocol = transcodingProfile.Protocol;
 591
 146592            item.TranscodingContainer = container;
 146593            item.TranscodingSubProtocol = protocol;
 594
 146595            if (playlistItem.PlayMethod == PlayMethod.Transcode)
 596            {
 146597                playlistItem.Container = container;
 146598                playlistItem.SubProtocol = protocol;
 599            }
 600
 146601            playlistItem.TranscodeSeekInfo = transcodingProfile.TranscodeSeekInfo;
 146602            if (int.TryParse(transcodingProfile.MaxAudioChannels, CultureInfo.InvariantCulture, out int transcodingMaxAu
 603            {
 133604                playlistItem.TranscodingMaxAudioChannels = transcodingMaxAudioChannels;
 605            }
 606
 146607            playlistItem.EstimateContentLength = transcodingProfile.EstimateContentLength;
 608
 146609            playlistItem.CopyTimestamps = transcodingProfile.CopyTimestamps;
 146610            playlistItem.EnableSubtitlesInManifest = transcodingProfile.EnableSubtitlesInManifest;
 146611            playlistItem.EnableMpegtsM2TsMode = transcodingProfile.EnableMpegtsM2TsMode;
 612
 146613            playlistItem.BreakOnNonKeyFrames = transcodingProfile.BreakOnNonKeyFrames;
 146614            playlistItem.EnableAudioVbrEncoding = transcodingProfile.EnableAudioVbrEncoding;
 615
 146616            if (transcodingProfile.MinSegments > 0)
 617            {
 102618                playlistItem.MinSegments = transcodingProfile.MinSegments;
 619            }
 620
 146621            if (transcodingProfile.SegmentLength > 0)
 622            {
 0623                playlistItem.SegmentLength = transcodingProfile.SegmentLength;
 624            }
 146625        }
 626
 627        private static void SetStreamInfoOptionsFromDirectPlayProfile(MediaOptions options, MediaSourceInfo item, Stream
 628        {
 0629            var container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, DlnaProfileTy
 0630            var protocol = MediaStreamProtocol.http;
 631
 0632            item.TranscodingContainer = container;
 0633            item.TranscodingSubProtocol = protocol;
 634
 0635            playlistItem.Container = container;
 0636            playlistItem.SubProtocol = protocol;
 637
 0638            playlistItem.VideoCodecs = [item.VideoStream.Codec];
 0639            playlistItem.AudioCodecs = ContainerHelper.Split(directPlayProfile?.AudioCodec);
 0640        }
 641
 642        private StreamInfo BuildVideoItem(MediaSourceInfo item, MediaOptions options)
 643        {
 278644            ArgumentNullException.ThrowIfNull(item);
 645
 278646            StreamInfo playlistItem = new StreamInfo
 278647            {
 278648                ItemId = options.ItemId,
 278649                MediaType = DlnaProfileType.Video,
 278650                MediaSource = item,
 278651                RunTimeTicks = item.RunTimeTicks,
 278652                Context = options.Context,
 278653                DeviceProfile = options.Profile,
 278654                SubtitleStreamIndex = options.SubtitleStreamIndex ?? GetDefaultSubtitleStreamIndex(item, options.Profile
 278655                AlwaysBurnInSubtitleWhenTranscoding = options.AlwaysBurnInSubtitleWhenTranscoding
 278656            };
 657
 278658            var subtitleStream = playlistItem.SubtitleStreamIndex.HasValue ? item.GetMediaStream(MediaStreamType.Subtitl
 659
 278660            var audioStream = item.GetDefaultAudioStream(options.AudioStreamIndex ?? item.DefaultAudioStreamIndex);
 278661            if (audioStream is not null)
 662            {
 277663                playlistItem.AudioStreamIndex = audioStream.Index;
 664            }
 665
 666            // Collect candidate audio streams
 278667            ICollection<MediaStream> candidateAudioStreams = audioStream is null ? [] : [audioStream];
 668            // When the index is explicitly required by client or the default is specified by user, don't do any stream 
 278669            if (!item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.User) && (options.AudioStreamIndex is null or < 0
 670            {
 671                // When user has no preferences allow stream selection on all streams.
 175672                if (item.DefaultAudioIndexSource == AudioIndexSource.None && audioStream is not null)
 673                {
 174674                    candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio).ToAr
 174675                    if (audioStream.IsDefault)
 676                    {
 677                        // If default is picked, only allow selection within default streams.
 174678                        candidateAudioStreams = candidateAudioStreams.Where(stream => stream.IsDefault).ToArray();
 679                    }
 680                }
 681
 175682                if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Language))
 683                {
 684                    // If user has language preference, only allow stream selection within the same language.
 0685                    candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && st
 0686                    if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Default))
 687                    {
 0688                        var defaultStreamsInPreferredLanguage = candidateAudioStreams.Where(stream => stream.IsDefault).
 689
 690                        // If the user also prefers default streams, try limit selection within default tracks in the sa
 691                        // If there is no default stream in the preferred language, allow selection on all default strea
 0692                        candidateAudioStreams = defaultStreamsInPreferredLanguage.Length > 0
 0693                            ? defaultStreamsInPreferredLanguage
 0694                            : item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && stream.IsDefault
 695                    }
 696                }
 175697                else if (item.DefaultAudioIndexSource.HasFlag(AudioIndexSource.Default))
 698                {
 699                    // If user prefers default streams, only allow stream selection on default streams.
 0700                    candidateAudioStreams = item.MediaStreams.Where(stream => stream.Type == MediaStreamType.Audio && st
 701                }
 702            }
 703
 278704            var videoStream = item.VideoStream;
 705
 278706            var bitrateLimitExceeded = IsBitrateLimitExceeded(item, options.GetMaxBitrate(false) ?? 0);
 278707            var isEligibleForDirectPlay = options.EnableDirectPlay && (options.ForceDirectPlay || !bitrateLimitExceeded)
 278708            var isEligibleForDirectStream = options.EnableDirectStream && (options.ForceDirectStream || !bitrateLimitExc
 278709            TranscodeReason transcodeReasons = 0;
 710
 711            // Force transcode or remux for BD/DVD folders
 278712            if (item.VideoType == VideoType.Dvd || item.VideoType == VideoType.BluRay)
 713            {
 0714                isEligibleForDirectPlay = false;
 715            }
 716
 278717            if (bitrateLimitExceeded)
 718            {
 24719                transcodeReasons = TranscodeReason.ContainerBitrateExceedsLimit;
 720            }
 721
 278722            _logger.LogDebug(
 278723                "Profile: {0}, Path: {1}, isEligibleForDirectPlay: {2}, isEligibleForDirectStream: {3}",
 278724                options.Profile.Name ?? "Unknown Profile",
 278725                item.Path ?? "Unknown path",
 278726                isEligibleForDirectPlay,
 278727                isEligibleForDirectStream);
 728
 278729            DirectPlayProfile? directPlayProfile = null;
 278730            if (isEligibleForDirectPlay || isEligibleForDirectStream)
 731            {
 732                // See if it can be direct played
 254733                var directPlayInfo = GetVideoDirectPlayProfile(options, item, videoStream, audioStream, candidateAudioSt
 254734                var directPlay = directPlayInfo.PlayMethod;
 254735                transcodeReasons |= directPlayInfo.TranscodeReasons;
 736
 254737                if (directPlay.HasValue)
 738                {
 124739                    directPlayProfile = directPlayInfo.Profile;
 124740                    playlistItem.PlayMethod = directPlay.Value;
 124741                    playlistItem.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profi
 124742                    var videoCodec = videoStream?.Codec;
 124743                    playlistItem.VideoCodecs = videoCodec is null ? [] : [videoCodec];
 744
 124745                    if (directPlay == PlayMethod.DirectPlay)
 746                    {
 124747                        playlistItem.SubProtocol = MediaStreamProtocol.http;
 748
 124749                        var audioStreamIndex = directPlayInfo.AudioStreamIndex ?? audioStream?.Index;
 124750                        if (audioStreamIndex.HasValue)
 751                        {
 124752                            playlistItem.AudioStreamIndex = audioStreamIndex;
 124753                            var audioCodec = item.GetMediaStream(MediaStreamType.Audio, audioStreamIndex.Value)?.Codec;
 124754                            playlistItem.AudioCodecs = audioCodec is null ? [] : [audioCodec];
 755                        }
 756                    }
 0757                    else if (directPlay == PlayMethod.DirectStream)
 758                    {
 0759                        playlistItem.AudioStreamIndex = audioStream?.Index;
 0760                        if (audioStream is not null)
 761                        {
 0762                            playlistItem.AudioCodecs = ContainerHelper.Split(directPlayProfile?.AudioCodec);
 763                        }
 764
 0765                        SetStreamInfoOptionsFromDirectPlayProfile(options, item, playlistItem, directPlayProfile);
 0766                        BuildStreamVideoItem(playlistItem, options, item, videoStream, audioStream, candidateAudioStream
 767                    }
 768
 124769                    if (subtitleStream is not null)
 770                    {
 116771                        var subtitleProfile = GetSubtitleProfile(item, subtitleStream, options.Profile.SubtitleProfiles,
 772
 116773                        playlistItem.SubtitleDeliveryMethod = subtitleProfile.Method;
 116774                        playlistItem.SubtitleFormat = subtitleProfile.Format;
 775                    }
 776                }
 777
 254778                _logger.LogDebug(
 254779                    "DirectPlay Result for Profile: {0}, Path: {1}, PlayMethod: {2}, AudioStreamIndex: {3}, SubtitleStre
 254780                    options.Profile.Name ?? "Anonymous Profile",
 254781                    item.Path ?? "Unknown path",
 254782                    directPlayInfo.PlayMethod,
 254783                    directPlayInfo.AudioStreamIndex ?? audioStream?.Index,
 254784                    playlistItem.SubtitleStreamIndex,
 254785                    directPlayInfo.TranscodeReasons);
 786            }
 787
 278788            playlistItem.TranscodeReasons = transcodeReasons;
 789
 278790            if (playlistItem.PlayMethod != PlayMethod.DirectStream && playlistItem.PlayMethod != PlayMethod.DirectPlay)
 791            {
 792                // Can't direct play, find the transcoding profile
 793                // If we do this for direct-stream we will overwrite the info
 154794                var (transcodingProfile, playMethod) = GetVideoTranscodeProfile(item, options, videoStream, audioStream,
 795
 154796                if (transcodingProfile is not null && playMethod.HasValue)
 797                {
 146798                    SetStreamInfoOptionsFromTranscodingProfile(item, playlistItem, transcodingProfile);
 799
 146800                    BuildStreamVideoItem(playlistItem, options, item, videoStream, audioStream, candidateAudioStreams, t
 801
 146802                    playlistItem.PlayMethod = PlayMethod.Transcode;
 803
 146804                    if (subtitleStream is not null)
 805                    {
 123806                        var subtitleProfile = GetSubtitleProfile(item, subtitleStream, options.Profile.SubtitleProfiles,
 123807                        playlistItem.SubtitleDeliveryMethod = subtitleProfile.Method;
 123808                        playlistItem.SubtitleFormat = subtitleProfile.Format;
 123809                        playlistItem.SubtitleCodecs = [subtitleProfile.Format];
 810                    }
 811
 146812                    if ((playlistItem.TranscodeReasons & (VideoReasons | TranscodeReason.ContainerBitrateExceedsLimit)) 
 813                    {
 44814                        ApplyTranscodingConditions(playlistItem, transcodingProfile.Conditions, null, true, true);
 815                    }
 816                }
 817            }
 818
 278819            _logger.LogDebug(
 278820                "StreamBuilder.BuildVideoItem( Profile={0}, Path={1}, AudioStreamIndex={2}, SubtitleStreamIndex={3} ) =>
 278821                options.Profile.Name ?? "Anonymous Profile",
 278822                item.Path ?? "Unknown path",
 278823                options.AudioStreamIndex,
 278824                options.SubtitleStreamIndex,
 278825                playlistItem.PlayMethod,
 278826                playlistItem.TranscodeReasons,
 278827                playlistItem.ToUrl("media:", "<token>", null));
 828
 278829            item.Container = NormalizeMediaSourceFormatIntoSingleContainer(item.Container, options.Profile, DlnaProfileT
 278830            return playlistItem;
 831        }
 832
 833        private (TranscodingProfile? Profile, PlayMethod? PlayMethod) GetVideoTranscodeProfile(
 834            MediaSourceInfo item,
 835            MediaOptions options,
 836            MediaStream? videoStream,
 837            MediaStream? audioStream,
 838            StreamInfo playlistItem)
 839        {
 154840            var mediaSource = playlistItem.MediaSource;
 841
 154842            ArgumentNullException.ThrowIfNull(mediaSource);
 843
 154844            if (!(item.SupportsTranscoding || item.SupportsDirectStream))
 845            {
 0846                return (null, null);
 847            }
 848
 154849            var transcodingProfiles = options.Profile.TranscodingProfiles
 154850                .Where(i => i.Type == playlistItem.MediaType && i.Context == options.Context);
 851
 154852            if (item.UseMostCompatibleTranscodingProfile)
 853            {
 0854                transcodingProfiles = transcodingProfiles.Where(i => string.Equals(i.Container, "ts", StringComparison.O
 855            }
 856
 154857            var videoCodec = videoStream?.Codec;
 154858            var audioCodec = audioStream?.Codec;
 859
 154860            var analyzedProfiles = transcodingProfiles
 154861                .Select(transcodingProfile =>
 154862                {
 154863                    var rank = (Video: 3, Audio: 3);
 154864
 154865                    var container = transcodingProfile.Container;
 154866
 154867                    if (videoStream is not null
 154868                        && options.AllowVideoStreamCopy
 154869                        && ContainerHelper.ContainsContainer(transcodingProfile.VideoCodec, videoCodec))
 154870                    {
 154871                        var failures = GetCompatibilityVideoCodec(options, mediaSource, container, videoStream);
 154872                        rank.Video = failures == 0 ? 1 : 2;
 154873                    }
 154874
 154875                    if (audioStream is not null
 154876                        && options.AllowAudioStreamCopy)
 154877                    {
 154878                        // For Audio stream, we prefer the audio codec that can be directly copied, then the codec that 
 154879                        // the transcoding conditions, then the one does not satisfy the transcoding conditions.
 154880                        // For example: A client can support both aac and flac, but flac only supports 2 channels while 
 154881                        // When the source audio is 6 channel flac, we should transcode to 6 channel aac, instead of dow
 154882                        var transcodingAudioCodecs = ContainerHelper.Split(transcodingProfile.AudioCodec);
 154883
 154884                        foreach (var transcodingAudioCodec in transcodingAudioCodecs)
 154885                        {
 154886                            var failures = GetCompatibilityAudioCodec(options, mediaSource, container, audioStream, tran
 154887
 154888                            var rankAudio = 3;
 154889
 154890                            if (failures == 0)
 154891                            {
 154892                                rankAudio = string.Equals(transcodingAudioCodec, audioCodec, StringComparison.OrdinalIgn
 154893                            }
 154894
 154895                            rank.Audio = Math.Min(rank.Audio, rankAudio);
 154896
 154897                            if (rank.Audio == 1)
 154898                            {
 154899                                break;
 154900                            }
 154901                        }
 154902                    }
 154903
 154904                    PlayMethod playMethod = PlayMethod.Transcode;
 154905
 154906                    if (rank.Video == 1)
 154907                    {
 154908                        playMethod = PlayMethod.DirectStream;
 154909                    }
 154910
 154911                    return (Profile: transcodingProfile, PlayMethod: playMethod, Rank: rank);
 154912                })
 154913                .OrderBy(analysis => analysis.Rank);
 914
 154915            var profileMatch = analyzedProfiles.FirstOrDefault();
 916
 154917            return (profileMatch.Profile, profileMatch.PlayMethod);
 918        }
 919
 920        private void BuildStreamVideoItem(
 921            StreamInfo playlistItem,
 922            MediaOptions options,
 923            MediaSourceInfo item,
 924            MediaStream? videoStream,
 925            MediaStream? audioStream,
 926            IEnumerable<MediaStream> candidateAudioStreams,
 927            string? container,
 928            string? videoCodec,
 929            string? audioCodec)
 930        {
 931            // Prefer matching video codecs
 146932            var videoCodecs = ContainerHelper.Split(videoCodec).ToList();
 933
 146934            if (videoCodecs.Count == 0 && videoStream is not null)
 935            {
 936                // Add the original codec if no codec is specified
 0937                videoCodecs.Add(videoStream.Codec);
 938            }
 939
 940            // Enforce HLS video codec restrictions
 146941            if (playlistItem.SubProtocol == MediaStreamProtocol.hls)
 942            {
 132943                videoCodecs = videoCodecs.Where(codec => _supportedHlsVideoCodecs.Contains(codec)).ToList();
 944            }
 945
 146946            playlistItem.VideoCodecs = videoCodecs;
 947
 948            // Copy video codec options as a starting point, this applies to transcode and direct-stream
 146949            playlistItem.MaxFramerate = videoStream?.ReferenceFrameRate;
 146950            var qualifier = videoStream?.Codec;
 146951            if (videoStream?.Level is not null)
 952            {
 145953                playlistItem.SetOption(qualifier, "level", videoStream.Level.Value.ToString(CultureInfo.InvariantCulture
 954            }
 955
 146956            if (videoStream?.BitDepth is not null)
 957            {
 145958                playlistItem.SetOption(qualifier, "videobitdepth", videoStream.BitDepth.Value.ToString(CultureInfo.Invar
 959            }
 960
 146961            if (!string.IsNullOrEmpty(videoStream?.Profile))
 962            {
 145963                playlistItem.SetOption(qualifier, "profile", videoStream.Profile.ToLowerInvariant());
 964            }
 965
 966            // Prefer matching audio codecs, could do better here
 146967            var audioCodecs = ContainerHelper.Split(audioCodec).ToList();
 968
 146969            if (audioCodecs.Count == 0 && audioStream is not null)
 970            {
 971                // Add the original codec if no codec is specified
 0972                audioCodecs.Add(audioStream.Codec);
 973            }
 974
 975            // Enforce HLS audio codec restrictions
 146976            if (playlistItem.SubProtocol == MediaStreamProtocol.hls)
 977            {
 132978                if (string.Equals(playlistItem.Container, "mp4", StringComparison.OrdinalIgnoreCase))
 979                {
 72980                    audioCodecs = audioCodecs.Where(codec => _supportedHlsAudioCodecsMp4.Contains(codec)).ToList();
 981                }
 982                else
 983                {
 60984                    audioCodecs = audioCodecs.Where(codec => _supportedHlsAudioCodecsTs.Contains(codec)).ToList();
 985                }
 986            }
 987
 146988            var audioStreamWithSupportedCodec = candidateAudioStreams.Where(stream => ContainerHelper.ContainsContainer(
 989
 146990            var channelsExceedsLimit = audioStreamWithSupportedCodec is not null && audioStreamWithSupportedCodec.Channe
 991
 146992            var directAudioFailures = audioStreamWithSupportedCodec is null ? default : GetCompatibilityAudioCodec(optio
 993
 146994            playlistItem.TranscodeReasons |= directAudioFailures;
 995
 146996            var directAudioStreamSatisfied = audioStreamWithSupportedCodec is not null && !channelsExceedsLimit
 146997                && directAudioFailures == 0;
 998
 146999            directAudioStreamSatisfied = directAudioStreamSatisfied && !playlistItem.TranscodeReasons.HasFlag(TranscodeR
 1000
 1461001            var directAudioStream = directAudioStreamSatisfied ? audioStreamWithSupportedCodec : null;
 1002
 1461003            if (channelsExceedsLimit && playlistItem.TargetAudioStream is not null)
 1004            {
 101005                playlistItem.TranscodeReasons |= TranscodeReason.AudioChannelsNotSupported;
 101006                playlistItem.TargetAudioStream.Channels = playlistItem.TranscodingMaxAudioChannels;
 1007            }
 1008
 1461009            playlistItem.AudioCodecs = audioCodecs;
 1461010            if (directAudioStream is not null)
 1011            {
 551012                audioStream = directAudioStream;
 551013                playlistItem.AudioStreamIndex = audioStream.Index;
 551014                audioCodecs = [audioStream.Codec];
 551015                playlistItem.AudioCodecs = audioCodecs;
 1016
 1017                // Copy matching audio codec options
 551018                playlistItem.AudioSampleRate = audioStream.SampleRate;
 551019                playlistItem.SetOption(qualifier, "audiochannels", audioStream.Channels?.ToString(CultureInfo.InvariantC
 1020
 551021                if (!string.IsNullOrEmpty(audioStream.Profile))
 1022                {
 531023                    playlistItem.SetOption(audioStream.Codec, "profile", audioStream.Profile.ToLowerInvariant());
 1024                }
 1025
 551026                if (audioStream.Level.HasValue && audioStream.Level.Value != 0)
 1027                {
 01028                    playlistItem.SetOption(audioStream.Codec, "level", audioStream.Level.Value.ToString(CultureInfo.Inva
 1029                }
 1030            }
 1031
 1461032            int? width = videoStream?.Width;
 1461033            int? height = videoStream?.Height;
 1461034            int? bitDepth = videoStream?.BitDepth;
 1461035            int? videoBitrate = videoStream?.BitRate;
 1461036            double? videoLevel = videoStream?.Level;
 1461037            string? videoProfile = videoStream?.Profile;
 1461038            VideoRangeType? videoRangeType = videoStream?.VideoRangeType;
 1461039            float videoFramerate = videoStream is null ? 0 : videoStream.ReferenceFrameRate ?? 0;
 1461040            bool? isAnamorphic = videoStream?.IsAnamorphic;
 1461041            bool? isInterlaced = videoStream?.IsInterlaced;
 1461042            string? videoCodecTag = videoStream?.CodecTag;
 1461043            bool? isAvc = videoStream?.IsAVC;
 1044
 1461045            TransportStreamTimestamp? timestamp = videoStream is null ? TransportStreamTimestamp.None : item.Timestamp;
 1461046            int? packetLength = videoStream?.PacketLength;
 1461047            int? refFrames = videoStream?.RefFrames;
 1048
 1461049            int numStreams = item.MediaStreams.Count;
 1461050            int? numAudioStreams = item.GetStreamCount(MediaStreamType.Audio);
 1461051            int? numVideoStreams = item.GetStreamCount(MediaStreamType.Video);
 1052
 1461053            var useSubContainer = playlistItem.SubProtocol == MediaStreamProtocol.hls;
 1054
 1461055            var appliedVideoConditions = options.Profile.CodecProfiles
 1461056                .Where(i => i.Type == CodecType.Video &&
 1461057                    i.ContainsAnyCodec(playlistItem.VideoCodecs, container, useSubContainer) &&
 1461058                    i.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoConditionSatisfied(applyCondition,
 1461059                // Reverse codec profiles for backward compatibility - first codec profile has higher priority
 1461060                .Reverse();
 8881061            foreach (var condition in appliedVideoConditions)
 1062            {
 24161063                foreach (var transcodingVideoCodec in playlistItem.VideoCodecs)
 1064                {
 9101065                    if (condition.ContainsAnyCodec(transcodingVideoCodec, container, useSubContainer))
 1066                    {
 3061067                        ApplyTranscodingConditions(playlistItem, condition.Conditions, transcodingVideoCodec, true, true
 1068                        continue;
 1069                    }
 1070                }
 1071            }
 1072
 1073            // Honor requested max channels
 1461074            playlistItem.GlobalMaxAudioChannels = channelsExceedsLimit ? playlistItem.TranscodingMaxAudioChannels : opti
 1075
 1461076            int audioBitrate = GetAudioBitrate(options.GetMaxBitrate(true) ?? 0, playlistItem.TargetAudioCodec, audioStr
 1461077            playlistItem.AudioBitrate = Math.Min(playlistItem.AudioBitrate ?? audioBitrate, audioBitrate);
 1078
 1461079            bool? isSecondaryAudio = audioStream is null ? null : item.IsSecondaryAudio(audioStream);
 1461080            int? inputAudioBitrate = audioStream?.BitRate;
 1461081            int? audioChannels = audioStream?.Channels;
 1461082            string? audioProfile = audioStream?.Profile;
 1461083            int? inputAudioSampleRate = audioStream?.SampleRate;
 1461084            int? inputAudioBitDepth = audioStream?.BitDepth;
 1085
 1461086            var appliedAudioConditions = options.Profile.CodecProfiles
 1461087                .Where(i => i.Type == CodecType.VideoAudio &&
 1461088                    i.ContainsAnyCodec(playlistItem.AudioCodecs, container) &&
 1461089                    i.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoAudioConditionSatisfied(applyCondi
 1461090                // Reverse codec profiles for backward compatibility - first codec profile has higher priority
 1461091                .Reverse();
 1092
 5961093            foreach (var codecProfile in appliedAudioConditions)
 1094            {
 4561095                foreach (var transcodingAudioCodec in playlistItem.AudioCodecs)
 1096                {
 1521097                    if (codecProfile.ContainsAnyCodec(transcodingAudioCodec, container))
 1098                    {
 1521099                        ApplyTranscodingConditions(playlistItem, codecProfile.Conditions, transcodingAudioCodec, true, t
 1521100                        break;
 1101                    }
 1102                }
 1103            }
 1104
 1461105            var maxBitrateSetting = options.GetMaxBitrate(false);
 1106            // Honor max rate
 1461107            if (maxBitrateSetting.HasValue)
 1108            {
 1461109                var availableBitrateForVideo = maxBitrateSetting.Value;
 1110
 1461111                if (playlistItem.AudioBitrate.HasValue)
 1112                {
 1461113                    availableBitrateForVideo -= playlistItem.AudioBitrate.Value;
 1114                }
 1115
 1116                // Make sure the video bitrate is lower than bitrate settings but at least 64k
 1117                // Don't use Math.Clamp as availableBitrateForVideo can be lower then 64k.
 1461118                var currentValue = playlistItem.VideoBitrate ?? availableBitrateForVideo;
 1461119                playlistItem.VideoBitrate = Math.Max(Math.Min(availableBitrateForVideo, currentValue), 64_000);
 1120            }
 1121
 1461122            _logger.LogDebug(
 1461123                "Transcode Result for Profile: {Profile}, Path: {Path}, PlayMethod: {PlayMethod}, AudioStreamIndex: {Aud
 1461124                options.Profile.Name ?? "Anonymous Profile",
 1461125                item.Path ?? "Unknown path",
 1461126                playlistItem.PlayMethod,
 1461127                audioStream?.Index,
 1461128                playlistItem.SubtitleStreamIndex,
 1461129                playlistItem.TranscodeReasons);
 1461130        }
 1131
 1132        private static int GetDefaultAudioBitrate(string? audioCodec, int? audioChannels)
 1133        {
 601134            if (!string.IsNullOrEmpty(audioCodec))
 1135            {
 1136                // Default to a higher bitrate for stream copy
 601137                if (string.Equals(audioCodec, "aac", StringComparison.OrdinalIgnoreCase)
 601138                    || string.Equals(audioCodec, "mp3", StringComparison.OrdinalIgnoreCase)
 601139                    || string.Equals(audioCodec, "ac3", StringComparison.OrdinalIgnoreCase)
 601140                    || string.Equals(audioCodec, "eac3", StringComparison.OrdinalIgnoreCase))
 1141                {
 551142                    if ((audioChannels ?? 0) < 2)
 1143                    {
 01144                        return 128000;
 1145                    }
 1146
 551147                    return (audioChannels ?? 0) >= 6 ? 640000 : 384000;
 1148                }
 1149
 51150                if (string.Equals(audioCodec, "flac", StringComparison.OrdinalIgnoreCase)
 51151                    || string.Equals(audioCodec, "alac", StringComparison.OrdinalIgnoreCase))
 1152                {
 01153                    if ((audioChannels ?? 0) < 2)
 1154                    {
 01155                        return 768000;
 1156                    }
 1157
 01158                    return (audioChannels ?? 0) >= 6 ? 3584000 : 1536000;
 1159                }
 1160            }
 1161
 51162            return 192000;
 1163        }
 1164
 1165        private static int GetAudioBitrate(long maxTotalBitrate, IReadOnlyList<string> targetAudioCodecs, MediaStream? a
 1166        {
 1461167            string? targetAudioCodec = targetAudioCodecs.Count == 0 ? null : targetAudioCodecs[0];
 1168
 1461169            int? targetAudioChannels = item.GetTargetAudioChannels(targetAudioCodec);
 1170
 1171            int defaultBitrate;
 1461172            int encoderAudioBitrateLimit = int.MaxValue;
 1173
 1461174            if (audioStream is null)
 1175            {
 11176                defaultBitrate = 192000;
 1177            }
 1178            else
 1179            {
 1451180                if (targetAudioChannels.HasValue
 1451181                    && audioStream.Channels.HasValue
 1451182                    && audioStream.Channels.Value > targetAudioChannels.Value)
 1183                {
 1184                    // Reduce the bitrate if we're down mixing.
 461185                    defaultBitrate = GetDefaultAudioBitrate(targetAudioCodec, targetAudioChannels);
 1186                }
 991187                else if (targetAudioChannels.HasValue
 991188                         && audioStream.Channels.HasValue
 991189                         && audioStream.Channels.Value <= targetAudioChannels.Value
 991190                         && !string.IsNullOrEmpty(audioStream.Codec)
 991191                         && targetAudioCodecs is not null
 991192                         && targetAudioCodecs.Count > 0
 991193                         && !targetAudioCodecs.Any(elem => string.Equals(audioStream.Codec, elem, StringComparison.Ordin
 1194                {
 1195                    // Shift the bitrate if we're transcoding to a different audio codec.
 141196                    defaultBitrate = GetDefaultAudioBitrate(targetAudioCodec, audioStream.Channels.Value);
 1197                }
 1198                else
 1199                {
 851200                    defaultBitrate = audioStream.BitRate ?? GetDefaultAudioBitrate(targetAudioCodec, targetAudioChannels
 1201                }
 1202
 1203                // Seeing webm encoding failures when source has 1 audio channel and 22k bitrate.
 1204                // Any attempts to transcode over 64k will fail
 1451205                if (audioStream.Channels == 1
 1451206                    && (audioStream.BitRate ?? 0) < 64000)
 1207                {
 01208                    encoderAudioBitrateLimit = 64000;
 1209                }
 1210            }
 1211
 1461212            if (maxTotalBitrate > 0)
 1213            {
 1461214                defaultBitrate = Math.Min(GetMaxAudioBitrateForTotalBitrate(maxTotalBitrate), defaultBitrate);
 1215            }
 1216
 1461217            return Math.Min(defaultBitrate, encoderAudioBitrateLimit);
 1218        }
 1219
 1220        private static int GetMaxAudioBitrateForTotalBitrate(long totalBitrate)
 1221        {
 1461222            if (totalBitrate <= 640000)
 1223            {
 81224                return 128000;
 1225            }
 1226
 1381227            if (totalBitrate <= 2000000)
 1228            {
 01229                return 384000;
 1230            }
 1231
 1381232            if (totalBitrate <= 3000000)
 1233            {
 01234                return 448000;
 1235            }
 1236
 1381237            if (totalBitrate <= 4000000)
 1238            {
 01239                return 640000;
 1240            }
 1241
 1381242            if (totalBitrate <= 5000000)
 1243            {
 01244                return 768000;
 1245            }
 1246
 1381247            if (totalBitrate <= 10000000)
 1248            {
 81249                return 1536000;
 1250            }
 1251
 1301252            if (totalBitrate <= 15000000)
 1253            {
 01254                return 2304000;
 1255            }
 1256
 1301257            if (totalBitrate <= 20000000)
 1258            {
 141259                return 3584000;
 1260            }
 1261
 1161262            return 7168000;
 1263        }
 1264
 1265        private (DirectPlayProfile? Profile, PlayMethod? PlayMethod, int? AudioStreamIndex, TranscodeReason TranscodeRea
 1266            MediaOptions options,
 1267            MediaSourceInfo mediaSource,
 1268            MediaStream? videoStream,
 1269            MediaStream? audioStream,
 1270            ICollection<MediaStream> candidateAudioStreams,
 1271            MediaStream? subtitleStream,
 1272            bool isEligibleForDirectPlay,
 1273            bool isEligibleForDirectStream)
 1274        {
 2541275            if (options.ForceDirectPlay)
 1276            {
 01277                return (null, PlayMethod.DirectPlay, audioStream?.Index, 0);
 1278            }
 1279
 2541280            if (options.ForceDirectStream)
 1281            {
 01282                return (null, PlayMethod.DirectStream, audioStream?.Index, 0);
 1283            }
 1284
 2541285            DeviceProfile profile = options.Profile;
 2541286            string container = mediaSource.Container;
 1287
 1288            // Check container conditions
 2541289            var containerProfileReasons = GetCompatibilityContainer(options, mediaSource, container, videoStream);
 1290
 1291            // Check video conditions
 2541292            var videoCodecProfileReasons = videoStream is null ? default : GetCompatibilityVideoCodec(options, mediaSour
 1293
 1294            // Check audio candidates profile conditions
 2541295            var audioStreamMatches = candidateAudioStreams.ToDictionary(s => s, audioStream => GetCompatibilityAudioCode
 1296
 2541297            TranscodeReason subtitleProfileReasons = 0;
 2541298            if (subtitleStream is not null)
 1299            {
 2231300                var subtitleProfile = GetSubtitleProfile(mediaSource, subtitleStream, options.Profile.SubtitleProfiles, 
 1301
 2231302                if (subtitleProfile.Method != SubtitleDeliveryMethod.Drop
 2231303                    && subtitleProfile.Method != SubtitleDeliveryMethod.External
 2231304                    && subtitleProfile.Method != SubtitleDeliveryMethod.Embed)
 1305                {
 01306                    _logger.LogDebug("Not eligible for {0} due to unsupported subtitles", PlayMethod.DirectPlay);
 01307                    subtitleProfileReasons |= TranscodeReason.SubtitleCodecNotSupported;
 1308                }
 1309            }
 1310
 2541311            var containerSupported = false;
 2541312            TranscodeReason[] rankings = [TranscodeReason.VideoCodecNotSupported, VideoCodecReasons, TranscodeReason.Aud
 1313
 1314            // Check DirectPlay profiles to see if it can be direct played
 2541315            var analyzedProfiles = profile.DirectPlayProfiles
 2541316                .Where(directPlayProfile => directPlayProfile.Type == DlnaProfileType.Video)
 2541317                .Select((directPlayProfile, order) =>
 2541318                {
 2541319                    TranscodeReason directPlayProfileReasons = 0;
 2541320                    TranscodeReason audioCodecProfileReasons = 0;
 2541321
 2541322                    // Check container type
 2541323                    if (!directPlayProfile.SupportsContainer(container))
 2541324                    {
 2541325                        directPlayProfileReasons |= TranscodeReason.ContainerNotSupported;
 2541326                    }
 2541327                    else
 2541328                    {
 2541329                        containerSupported = true;
 2541330                    }
 2541331
 2541332                    // Check video codec
 2541333                    string? videoCodec = videoStream?.Codec;
 2541334                    if (!directPlayProfile.SupportsVideoCodec(videoCodec))
 2541335                    {
 2541336                        directPlayProfileReasons |= TranscodeReason.VideoCodecNotSupported;
 2541337                    }
 2541338
 2541339                    // Check audio codec
 2541340                    MediaStream? selectedAudioStream = null;
 2541341                    if (candidateAudioStreams.Count != 0)
 2541342                    {
 2541343                        selectedAudioStream = candidateAudioStreams.FirstOrDefault(audioStream => directPlayProfile.Supp
 2541344                        if (selectedAudioStream is null)
 2541345                        {
 2541346                            directPlayProfileReasons |= TranscodeReason.AudioCodecNotSupported;
 2541347                        }
 2541348                        else
 2541349                        {
 2541350                            audioCodecProfileReasons = audioStreamMatches.GetValueOrDefault(selectedAudioStream);
 2541351                        }
 2541352                    }
 2541353
 2541354                    var failureReasons = directPlayProfileReasons | containerProfileReasons | subtitleProfileReasons;
 2541355
 2541356                    if ((failureReasons & TranscodeReason.VideoCodecNotSupported) == 0)
 2541357                    {
 2541358                        failureReasons |= videoCodecProfileReasons;
 2541359                    }
 2541360
 2541361                    if ((failureReasons & TranscodeReason.AudioCodecNotSupported) == 0)
 2541362                    {
 2541363                        failureReasons |= audioCodecProfileReasons;
 2541364                    }
 2541365
 2541366                    var directStreamFailureReasons = failureReasons & (~DirectStreamReasons);
 2541367
 2541368                    PlayMethod? playMethod = null;
 2541369                    if (failureReasons == 0 && isEligibleForDirectPlay && mediaSource.SupportsDirectPlay)
 2541370                    {
 2541371                        playMethod = PlayMethod.DirectPlay;
 2541372                    }
 2541373                    else if (directStreamFailureReasons == 0 && isEligibleForDirectStream && mediaSource.SupportsDirectS
 2541374                    {
 2541375                        playMethod = PlayMethod.DirectStream;
 2541376                    }
 2541377
 2541378                    var ranked = GetRank(ref failureReasons, rankings);
 2541379
 2541380                    return (Result: (Profile: directPlayProfile, PlayMethod: playMethod, AudioStreamIndex: selectedAudio
 2541381                })
 2541382                .OrderByDescending(analysis => analysis.Result.PlayMethod)
 2541383                .ThenByDescending(analysis => analysis.Rank)
 2541384                .ThenBy(analysis => analysis.Order)
 2541385                .ToArray()
 2541386                .ToLookup(analysis => analysis.Result.PlayMethod is not null);
 1387
 2541388            var profileMatch = analyzedProfiles[true]
 2541389                .Select(analysis => analysis.Result)
 2541390                .FirstOrDefault();
 2541391            if (profileMatch.Profile is not null)
 1392            {
 1241393                return profileMatch;
 1394            }
 1395
 1301396            var failureReasons = analyzedProfiles[false]
 1301397                .Select(analysis => analysis.Result)
 1301398                .Where(result => !containerSupported || !result.TranscodeReason.HasFlag(TranscodeReason.ContainerNotSupp
 1301399                .FirstOrDefault().TranscodeReason;
 1301400            if (failureReasons == 0)
 1401            {
 141402                failureReasons = TranscodeReason.DirectPlayError;
 1403            }
 1404
 1301405            return (Profile: null, PlayMethod: null, AudioStreamIndex: null, TranscodeReasons: failureReasons);
 1406        }
 1407
 1408        private TranscodeReason AggregateFailureConditions(MediaSourceInfo mediaSource, DeviceProfile profile, string ty
 1409        {
 16611410            return conditions.Aggregate<ProfileCondition, TranscodeReason>(0, (reasons, i) =>
 16611411            {
 16611412                LogConditionFailure(profile, type, i, mediaSource);
 16611413                var transcodeReasons = GetTranscodeReasonForFailedCondition(i);
 16611414                return reasons | transcodeReasons;
 16611415            });
 1416        }
 1417
 1418        private void LogConditionFailure(DeviceProfile profile, string type, ProfileCondition condition, MediaSourceInfo
 1419        {
 2471420            _logger.LogDebug(
 2471421                "Profile: {0}, DirectPlay=false. Reason={1}.{2} Condition: {3}. ConditionValue: {4}. IsRequired: {5}. Pa
 2471422                type,
 2471423                profile.Name ?? "Unknown Profile",
 2471424                condition.Property,
 2471425                condition.Condition,
 2471426                condition.Value ?? string.Empty,
 2471427                condition.IsRequired,
 2471428                mediaSource.Path ?? "Unknown path");
 2471429        }
 1430
 1431        /// <summary>
 1432        /// Normalizes input container.
 1433        /// </summary>
 1434        /// <param name="mediaSource">The <see cref="MediaSourceInfo"/>.</param>
 1435        /// <param name="subtitleStream">The <see cref="MediaStream"/> of the subtitle stream.</param>
 1436        /// <param name="subtitleProfiles">The list of supported <see cref="SubtitleProfile"/>s.</param>
 1437        /// <param name="playMethod">The <see cref="PlayMethod"/>.</param>
 1438        /// <param name="transcoderSupport">The <see cref="ITranscoderSupport"/>.</param>
 1439        /// <param name="outputContainer">The output container.</param>
 1440        /// <param name="transcodingSubProtocol">The subtitle transcoding protocol.</param>
 1441        /// <returns>The normalized input container.</returns>
 1442        public static SubtitleProfile GetSubtitleProfile(
 1443            MediaSourceInfo mediaSource,
 1444            MediaStream subtitleStream,
 1445            SubtitleProfile[] subtitleProfiles,
 1446            PlayMethod playMethod,
 1447            ITranscoderSupport transcoderSupport,
 1448            string? outputContainer,
 1449            MediaStreamProtocol? transcodingSubProtocol)
 1450        {
 4621451            if (!subtitleStream.IsExternal && (playMethod != PlayMethod.Transcode || transcodingSubProtocol != MediaStre
 1452            {
 1453                // Look for supported embedded subs of the same format
 01454                foreach (var profile in subtitleProfiles)
 1455                {
 01456                    if (!profile.SupportsLanguage(subtitleStream.Language))
 1457                    {
 1458                        continue;
 1459                    }
 1460
 01461                    if (profile.Method != SubtitleDeliveryMethod.Embed)
 1462                    {
 1463                        continue;
 1464                    }
 1465
 01466                    if (!ContainerHelper.ContainsContainer(profile.Container, outputContainer))
 1467                    {
 1468                        continue;
 1469                    }
 1470
 01471                    if (playMethod == PlayMethod.Transcode && !IsSubtitleEmbedSupported(outputContainer))
 1472                    {
 1473                        continue;
 1474                    }
 1475
 01476                    if (subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format) && string.Equals
 1477                    {
 01478                        return profile;
 1479                    }
 1480                }
 1481
 1482                // Look for supported embedded subs of a convertible format
 01483                foreach (var profile in subtitleProfiles)
 1484                {
 01485                    if (!profile.SupportsLanguage(subtitleStream.Language))
 1486                    {
 1487                        continue;
 1488                    }
 1489
 01490                    if (profile.Method != SubtitleDeliveryMethod.Embed)
 1491                    {
 1492                        continue;
 1493                    }
 1494
 01495                    if (!ContainerHelper.ContainsContainer(profile.Container, outputContainer))
 1496                    {
 1497                        continue;
 1498                    }
 1499
 01500                    if (playMethod == PlayMethod.Transcode && !IsSubtitleEmbedSupported(outputContainer))
 1501                    {
 1502                        continue;
 1503                    }
 1504
 01505                    if (subtitleStream.IsTextSubtitleStream && subtitleStream.SupportsSubtitleConversionTo(profile.Forma
 1506                    {
 01507                        return profile;
 1508                    }
 1509                }
 1510            }
 1511
 1512            // Look for an external or hls profile that matches the stream type (text/graphical) and doesn't require con
 4621513            return GetExternalSubtitleProfile(mediaSource, subtitleStream, subtitleProfiles, playMethod, transcoderSuppo
 4621514                GetExternalSubtitleProfile(mediaSource, subtitleStream, subtitleProfiles, playMethod, transcoderSupport,
 4621515                new SubtitleProfile
 4621516                {
 4621517                    Method = SubtitleDeliveryMethod.Encode,
 4621518                    Format = subtitleStream.Codec
 4621519                };
 1520        }
 1521
 1522        private static bool IsSubtitleEmbedSupported(string? transcodingContainer)
 1523        {
 01524            if (!string.IsNullOrEmpty(transcodingContainer))
 1525            {
 01526                if (ContainerHelper.ContainsContainer(transcodingContainer, "ts,mpegts,mp4"))
 1527                {
 01528                    return false;
 1529                }
 1530
 01531                if (ContainerHelper.ContainsContainer(transcodingContainer, "mkv,matroska"))
 1532                {
 01533                    return true;
 1534                }
 1535            }
 1536
 01537            return false;
 1538        }
 1539
 1540        private static SubtitleProfile? GetExternalSubtitleProfile(MediaSourceInfo mediaSource, MediaStream subtitleStre
 1541        {
 50661542            foreach (var profile in subtitleProfiles)
 1543            {
 20161544                if (profile.Method != SubtitleDeliveryMethod.External && profile.Method != SubtitleDeliveryMethod.Hls)
 1545                {
 1546                    continue;
 1547                }
 1548
 13821549                if (profile.Method == SubtitleDeliveryMethod.Hls && playMethod != PlayMethod.Transcode)
 1550                {
 1551                    continue;
 1552                }
 1553
 13821554                if (!profile.SupportsLanguage(subtitleStream.Language))
 1555                {
 1556                    continue;
 1557                }
 1558
 13821559                if (!subtitleStream.IsExternal && !transcoderSupport.CanExtractSubtitles(subtitleStream.Codec))
 1560                {
 1561                    continue;
 1562                }
 1563
 13821564                if ((profile.Method == SubtitleDeliveryMethod.External && subtitleStream.IsTextSubtitleStream == MediaSt
 13821565                    (profile.Method == SubtitleDeliveryMethod.Hls && subtitleStream.IsTextSubtitleStream))
 1566                {
 13641567                    bool requiresConversion = !string.Equals(subtitleStream.Codec, profile.Format, StringComparison.Ordi
 1568
 13641569                    if (!requiresConversion)
 1570                    {
 1761571                        return profile;
 1572                    }
 1573
 11881574                    if (!allowConversion)
 1575                    {
 1576                        continue;
 1577                    }
 1578
 1579                    // TODO: Build this into subtitleStream.SupportsExternalStream
 2861580                    if (mediaSource.IsInfiniteStream)
 1581                    {
 1582                        continue;
 1583                    }
 1584
 2861585                    if (subtitleStream.IsTextSubtitleStream && subtitleStream.SupportsExternalStream && subtitleStream.S
 1586                    {
 2861587                        return profile;
 1588                    }
 1589                }
 1590            }
 1591
 2861592            return null;
 1593        }
 1594
 1595        private bool IsBitrateLimitExceeded(MediaSourceInfo item, long maxBitrate)
 1596        {
 1597            // Don't restrict bitrate if item is remote.
 2781598            if (item.IsRemote)
 1599            {
 01600                return false;
 1601            }
 1602
 1603            // If no maximum bitrate is set, default to no maximum bitrate.
 2781604            long requestedMaxBitrate = maxBitrate > 0 ? maxBitrate : int.MaxValue;
 1605
 1606            // If we don't know the item bitrate, then force a transcode if requested max bitrate is under 40 mbps
 2781607            int itemBitrate = item.Bitrate ?? 40000000;
 1608
 2781609            if (itemBitrate > requestedMaxBitrate)
 1610            {
 241611                _logger.LogDebug(
 241612                    "Bitrate exceeds limit: media bitrate: {MediaBitrate}, max bitrate: {MaxBitrate}",
 241613                    itemBitrate,
 241614                    requestedMaxBitrate);
 241615                return true;
 1616            }
 1617
 2541618            return false;
 1619        }
 1620
 1621        private static void ValidateMediaOptions(MediaOptions options, bool isMediaSource)
 1622        {
 2781623            if (options.ItemId.IsEmpty())
 1624            {
 01625                ArgumentException.ThrowIfNullOrEmpty(options.DeviceId);
 1626            }
 1627
 2781628            if (options.Profile is null)
 1629            {
 01630                throw new ArgumentException("Profile is required");
 1631            }
 1632
 2781633            if (options.MediaSources is null)
 1634            {
 01635                throw new ArgumentException("MediaSources is required");
 1636            }
 1637
 2781638            if (isMediaSource)
 1639            {
 2781640                if (options.AudioStreamIndex.HasValue && string.IsNullOrEmpty(options.MediaSourceId))
 1641                {
 01642                    throw new ArgumentException("MediaSourceId is required when a specific audio stream is requested");
 1643                }
 1644
 2781645                if (options.SubtitleStreamIndex.HasValue && string.IsNullOrEmpty(options.MediaSourceId))
 1646                {
 01647                    throw new ArgumentException("MediaSourceId is required when a specific subtitle stream is requested"
 1648                }
 1649            }
 2781650        }
 1651
 1652        private static IEnumerable<ProfileCondition> GetProfileConditionsForVideoAudio(
 1653            IEnumerable<CodecProfile> codecProfiles,
 1654            string container,
 1655            string codec,
 1656            int? audioChannels,
 1657            int? audioBitrate,
 1658            int? audioSampleRate,
 1659            int? audioBitDepth,
 1660            string audioProfile,
 1661            bool? isSecondaryAudio)
 1662        {
 10051663            return codecProfiles
 10051664                .Where(profile => profile.Type == CodecType.VideoAudio &&
 10051665                    profile.ContainsAnyCodec(codec, container) &&
 10051666                    profile.ApplyConditions.All(applyCondition => ConditionProcessor.IsVideoAudioConditionSatisfied(appl
 10051667                .SelectMany(profile => profile.Conditions)
 10051668                .Where(condition => !ConditionProcessor.IsVideoAudioConditionSatisfied(condition, audioChannels, audioBi
 1669        }
 1670
 1671        private static IEnumerable<ProfileCondition> GetProfileConditionsForAudio(
 1672            IEnumerable<CodecProfile> codecProfiles,
 1673            string container,
 1674            string? codec,
 1675            int? audioChannels,
 1676            int? audioBitrate,
 1677            int? audioSampleRate,
 1678            int? audioBitDepth,
 1679            bool checkConditions)
 1680        {
 01681            var conditions = codecProfiles
 01682                .Where(profile => profile.Type == CodecType.Audio &&
 01683                    profile.ContainsAnyCodec(codec, container) &&
 01684                    profile.ApplyConditions.All(applyCondition => ConditionProcessor.IsAudioConditionSatisfied(applyCond
 01685                .SelectMany(profile => profile.Conditions);
 1686
 01687            if (!checkConditions)
 1688            {
 01689                return conditions;
 1690            }
 1691
 01692            return conditions.Where(condition => !ConditionProcessor.IsAudioConditionSatisfied(condition, audioChannels,
 1693        }
 1694
 1695        private void ApplyTranscodingConditions(StreamInfo item, IEnumerable<ProfileCondition> conditions, string? quali
 1696        {
 34921697            foreach (ProfileCondition condition in conditions)
 1698            {
 12441699                string value = condition.Value;
 1700
 12441701                if (string.IsNullOrEmpty(value))
 1702                {
 1703                    continue;
 1704                }
 1705
 1706                // No way to express this
 12441707                if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1708                {
 1709                    continue;
 1710                }
 1711
 12441712                switch (condition.Property)
 1713                {
 1714                    case ProfileConditionValue.AudioBitrate:
 1715                        {
 01716                            if (!enableNonQualifiedConditions)
 1717                            {
 1718                                continue;
 1719                            }
 1720
 01721                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1722                            {
 01723                                if (condition.Condition == ProfileConditionType.Equals)
 1724                                {
 01725                                    item.AudioBitrate = num;
 1726                                }
 01727                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1728                                {
 01729                                    item.AudioBitrate = Math.Min(num, item.AudioBitrate ?? num);
 1730                                }
 01731                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1732                                {
 01733                                    item.AudioBitrate = Math.Max(num, item.AudioBitrate ?? num);
 1734                                }
 1735                            }
 1736
 01737                            break;
 1738                        }
 1739
 1740                    case ProfileConditionValue.AudioSampleRate:
 1741                        {
 01742                            if (!enableNonQualifiedConditions)
 1743                            {
 1744                                continue;
 1745                            }
 1746
 01747                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1748                            {
 01749                                if (condition.Condition == ProfileConditionType.Equals)
 1750                                {
 01751                                    item.AudioSampleRate = num;
 1752                                }
 01753                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1754                                {
 01755                                    item.AudioSampleRate = Math.Min(num, item.AudioSampleRate ?? num);
 1756                                }
 01757                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1758                                {
 01759                                    item.AudioSampleRate = Math.Max(num, item.AudioSampleRate ?? num);
 1760                                }
 1761                            }
 1762
 01763                            break;
 1764                        }
 1765
 1766                    case ProfileConditionValue.AudioChannels:
 1767                        {
 281768                            if (string.IsNullOrEmpty(qualifier))
 1769                            {
 01770                                if (!enableNonQualifiedConditions)
 1771                                {
 01772                                    continue;
 1773                                }
 1774                            }
 1775                            else
 1776                            {
 281777                                if (!enableQualifiedConditions)
 1778                                {
 1779                                    continue;
 1780                                }
 1781                            }
 1782
 281783                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1784                            {
 281785                                if (condition.Condition == ProfileConditionType.Equals)
 1786                                {
 01787                                    item.SetOption(qualifier, "audiochannels", num.ToString(CultureInfo.InvariantCulture
 1788                                }
 281789                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1790                                {
 281791                                    item.SetOption(qualifier, "audiochannels", Math.Min(num, item.GetTargetAudioChannels
 1792                                }
 01793                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1794                                {
 01795                                    item.SetOption(qualifier, "audiochannels", Math.Max(num, item.GetTargetAudioChannels
 1796                                }
 1797                            }
 1798
 01799                            break;
 1800                        }
 1801
 1802                    case ProfileConditionValue.IsAvc:
 1803                        {
 01804                            if (!enableNonQualifiedConditions)
 1805                            {
 1806                                continue;
 1807                            }
 1808
 01809                            if (bool.TryParse(value, out var isAvc))
 1810                            {
 01811                                if (isAvc && condition.Condition == ProfileConditionType.Equals)
 1812                                {
 01813                                    item.RequireAvc = true;
 1814                                }
 01815                                else if (!isAvc && condition.Condition == ProfileConditionType.NotEquals)
 1816                                {
 01817                                    item.RequireAvc = true;
 1818                                }
 1819                            }
 1820
 01821                            break;
 1822                        }
 1823
 1824                    case ProfileConditionValue.IsAnamorphic:
 1825                        {
 2011826                            if (!enableNonQualifiedConditions)
 1827                            {
 1828                                continue;
 1829                            }
 1830
 2011831                            if (bool.TryParse(value, out var isAnamorphic))
 1832                            {
 2011833                                if (isAnamorphic && condition.Condition == ProfileConditionType.Equals)
 1834                                {
 01835                                    item.RequireNonAnamorphic = true;
 1836                                }
 2011837                                else if (!isAnamorphic && condition.Condition == ProfileConditionType.NotEquals)
 1838                                {
 01839                                    item.RequireNonAnamorphic = true;
 1840                                }
 1841                            }
 1842
 01843                            break;
 1844                        }
 1845
 1846                    case ProfileConditionValue.IsInterlaced:
 1847                        {
 1091848                            if (string.IsNullOrEmpty(qualifier))
 1849                            {
 01850                                if (!enableNonQualifiedConditions)
 1851                                {
 01852                                    continue;
 1853                                }
 1854                            }
 1855                            else
 1856                            {
 1091857                                if (!enableQualifiedConditions)
 1858                                {
 1859                                    continue;
 1860                                }
 1861                            }
 1862
 1091863                            if (bool.TryParse(value, out var isInterlaced))
 1864                            {
 1091865                                if (!isInterlaced && condition.Condition == ProfileConditionType.Equals)
 1866                                {
 01867                                    item.SetOption(qualifier, "deinterlace", "true");
 1868                                }
 1091869                                else if (isInterlaced && condition.Condition == ProfileConditionType.NotEquals)
 1870                                {
 1091871                                    item.SetOption(qualifier, "deinterlace", "true");
 1872                                }
 1873                            }
 1874
 1091875                            break;
 1876                        }
 1877
 1878                    case ProfileConditionValue.AudioProfile:
 1879                    case ProfileConditionValue.Has64BitOffsets:
 1880                    case ProfileConditionValue.PacketLength:
 1881                    case ProfileConditionValue.NumStreams:
 1882                    case ProfileConditionValue.NumAudioStreams:
 1883                    case ProfileConditionValue.NumVideoStreams:
 1884                    case ProfileConditionValue.IsSecondaryAudio:
 1885                    case ProfileConditionValue.VideoTimestamp:
 1886                        {
 1887                            // Not supported yet
 1888                            break;
 1889                        }
 1890
 1891                    case ProfileConditionValue.RefFrames:
 1892                        {
 21893                            if (string.IsNullOrEmpty(qualifier))
 1894                            {
 01895                                if (!enableNonQualifiedConditions)
 1896                                {
 01897                                    continue;
 1898                                }
 1899                            }
 1900                            else
 1901                            {
 21902                                if (!enableQualifiedConditions)
 1903                                {
 1904                                    continue;
 1905                                }
 1906                            }
 1907
 21908                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1909                            {
 21910                                if (condition.Condition == ProfileConditionType.Equals)
 1911                                {
 01912                                    item.SetOption(qualifier, "maxrefframes", num.ToString(CultureInfo.InvariantCulture)
 1913                                }
 21914                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1915                                {
 21916                                    item.SetOption(qualifier, "maxrefframes", Math.Min(num, item.GetTargetRefFrames(qual
 1917                                }
 01918                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1919                                {
 01920                                    item.SetOption(qualifier, "maxrefframes", Math.Max(num, item.GetTargetRefFrames(qual
 1921                                }
 1922                            }
 1923
 01924                            break;
 1925                        }
 1926
 1927                    case ProfileConditionValue.VideoBitDepth:
 1928                        {
 01929                            if (string.IsNullOrEmpty(qualifier))
 1930                            {
 01931                                if (!enableNonQualifiedConditions)
 1932                                {
 01933                                    continue;
 1934                                }
 1935                            }
 1936                            else
 1937                            {
 01938                                if (!enableQualifiedConditions)
 1939                                {
 1940                                    continue;
 1941                                }
 1942                            }
 1943
 01944                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 1945                            {
 01946                                if (condition.Condition == ProfileConditionType.Equals)
 1947                                {
 01948                                    item.SetOption(qualifier, "videobitdepth", num.ToString(CultureInfo.InvariantCulture
 1949                                }
 01950                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 1951                                {
 01952                                    item.SetOption(qualifier, "videobitdepth", Math.Min(num, item.GetTargetVideoBitDepth
 1953                                }
 01954                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 1955                                {
 01956                                    item.SetOption(qualifier, "videobitdepth", Math.Max(num, item.GetTargetVideoBitDepth
 1957                                }
 1958                            }
 1959
 01960                            break;
 1961                        }
 1962
 1963                    case ProfileConditionValue.VideoProfile:
 1964                        {
 2241965                            if (string.IsNullOrEmpty(qualifier))
 1966                            {
 1967                                continue;
 1968                            }
 1969
 1970                            // Change from split by | to comma
 1971                            // Strip spaces to avoid having to encode
 2241972                            var values = value
 2241973                                .Split('|', StringSplitOptions.RemoveEmptyEntries);
 1974
 2241975                            if (condition.Condition == ProfileConditionType.Equals)
 1976                            {
 01977                                item.SetOption(qualifier, "profile", string.Join(',', values));
 1978                            }
 2241979                            else if (condition.Condition == ProfileConditionType.EqualsAny)
 1980                            {
 2241981                                var currentValue = item.GetOption(qualifier, "profile");
 2241982                                if (!string.IsNullOrEmpty(currentValue) && values.Any(value => value == currentValue))
 1983                                {
 711984                                    item.SetOption(qualifier, "profile", currentValue);
 1985                                }
 1986                                else
 1987                                {
 1531988                                    item.SetOption(qualifier, "profile", string.Join(',', values));
 1989                                }
 1990                            }
 1991
 1531992                            break;
 1993                        }
 1994
 1995                    case ProfileConditionValue.VideoRangeType:
 1996                        {
 2581997                            if (string.IsNullOrEmpty(qualifier))
 1998                            {
 1999                                continue;
 2000                            }
 2001
 2002                            // change from split by | to comma
 2003                            // strip spaces to avoid having to encode
 2582004                            var values = value
 2582005                                .Split('|', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 2006
 2582007                            if (condition.Condition == ProfileConditionType.Equals)
 2008                            {
 02009                                item.SetOption(qualifier, "rangetype", string.Join(',', values));
 2010                            }
 2582011                            else if (condition.Condition == ProfileConditionType.NotEquals)
 2012                            {
 02013                                item.SetOption(qualifier, "rangetype", string.Join(',', Enum.GetNames(typeof(VideoRangeT
 2014                            }
 2582015                            else if (condition.Condition == ProfileConditionType.EqualsAny)
 2016                            {
 2582017                                var currentValue = item.GetOption(qualifier, "rangetype");
 2582018                                if (!string.IsNullOrEmpty(currentValue) && values.Any(v => string.Equals(v, currentValue
 2019                                {
 02020                                    item.SetOption(qualifier, "rangetype", currentValue);
 2021                                }
 2022                                else
 2023                                {
 2582024                                    item.SetOption(qualifier, "rangetype", string.Join(',', values));
 2025                                }
 2026                            }
 2027
 2582028                            break;
 2029                        }
 2030
 2031                    case ProfileConditionValue.VideoCodecTag:
 2032                        {
 122033                            if (string.IsNullOrEmpty(qualifier))
 2034                            {
 2035                                continue;
 2036                            }
 2037
 2038                            // change from split by | to comma
 2039                            // strip spaces to avoid having to encode
 122040                            var values = value
 122041                                .Split('|', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
 2042
 122043                            if (condition.Condition == ProfileConditionType.Equals)
 2044                            {
 02045                                item.SetOption(qualifier, "codectag", string.Join(',', values));
 2046                            }
 122047                            else if (condition.Condition == ProfileConditionType.EqualsAny)
 2048                            {
 122049                                var currentValue = item.GetOption(qualifier, "codectag");
 122050                                if (!string.IsNullOrEmpty(currentValue) && values.Any(v => string.Equals(v, currentValue
 2051                                {
 02052                                    item.SetOption(qualifier, "codectag", currentValue);
 2053                                }
 2054                                else
 2055                                {
 122056                                    item.SetOption(qualifier, "codectag", string.Join(',', values));
 2057                                }
 2058                            }
 2059
 122060                            break;
 2061                        }
 2062
 2063                    case ProfileConditionValue.Height:
 2064                        {
 02065                            if (!enableNonQualifiedConditions)
 2066                            {
 2067                                continue;
 2068                            }
 2069
 02070                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2071                            {
 02072                                if (condition.Condition == ProfileConditionType.Equals)
 2073                                {
 02074                                    item.MaxHeight = num;
 2075                                }
 02076                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2077                                {
 02078                                    item.MaxHeight = Math.Min(num, item.MaxHeight ?? num);
 2079                                }
 02080                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2081                                {
 02082                                    item.MaxHeight = Math.Max(num, item.MaxHeight ?? num);
 2083                                }
 2084                            }
 2085
 02086                            break;
 2087                        }
 2088
 2089                    case ProfileConditionValue.VideoBitrate:
 2090                        {
 322091                            if (!enableNonQualifiedConditions)
 2092                            {
 2093                                continue;
 2094                            }
 2095
 322096                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2097                            {
 322098                                if (condition.Condition == ProfileConditionType.Equals)
 2099                                {
 02100                                    item.VideoBitrate = num;
 2101                                }
 322102                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2103                                {
 322104                                    item.VideoBitrate = Math.Min(num, item.VideoBitrate ?? num);
 2105                                }
 02106                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2107                                {
 02108                                    item.VideoBitrate = Math.Max(num, item.VideoBitrate ?? num);
 2109                                }
 2110                            }
 2111
 02112                            break;
 2113                        }
 2114
 2115                    case ProfileConditionValue.VideoFramerate:
 2116                        {
 122117                            if (!enableNonQualifiedConditions)
 2118                            {
 2119                                continue;
 2120                            }
 2121
 122122                            if (float.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2123                            {
 122124                                if (condition.Condition == ProfileConditionType.Equals)
 2125                                {
 02126                                    item.MaxFramerate = num;
 2127                                }
 122128                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2129                                {
 122130                                    item.MaxFramerate = Math.Min(num, item.MaxFramerate ?? num);
 2131                                }
 02132                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2133                                {
 02134                                    item.MaxFramerate = Math.Max(num, item.MaxFramerate ?? num);
 2135                                }
 2136                            }
 2137
 02138                            break;
 2139                        }
 2140
 2141                    case ProfileConditionValue.VideoLevel:
 2142                        {
 2122143                            if (string.IsNullOrEmpty(qualifier))
 2144                            {
 2145                                continue;
 2146                            }
 2147
 2122148                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2149                            {
 2122150                                if (condition.Condition == ProfileConditionType.Equals)
 2151                                {
 02152                                    item.SetOption(qualifier, "level", num.ToString(CultureInfo.InvariantCulture));
 2153                                }
 2122154                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2155                                {
 2122156                                    item.SetOption(qualifier, "level", Math.Min(num, item.GetTargetVideoLevel(qualifier)
 2157                                }
 02158                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2159                                {
 02160                                    item.SetOption(qualifier, "level", Math.Max(num, item.GetTargetVideoLevel(qualifier)
 2161                                }
 2162                            }
 2163
 02164                            break;
 2165                        }
 2166
 2167                    case ProfileConditionValue.Width:
 2168                        {
 42169                            if (!enableNonQualifiedConditions)
 2170                            {
 2171                                continue;
 2172                            }
 2173
 42174                            if (int.TryParse(value, CultureInfo.InvariantCulture, out var num))
 2175                            {
 42176                                if (condition.Condition == ProfileConditionType.Equals)
 2177                                {
 02178                                    item.MaxWidth = num;
 2179                                }
 42180                                else if (condition.Condition == ProfileConditionType.LessThanEqual)
 2181                                {
 42182                                    item.MaxWidth = Math.Min(num, item.MaxWidth ?? num);
 2183                                }
 02184                                else if (condition.Condition == ProfileConditionType.GreaterThanEqual)
 2185                                {
 02186                                    item.MaxWidth = Math.Max(num, item.MaxWidth ?? num);
 2187                                }
 2188                            }
 2189
 2190                            break;
 2191                        }
 2192
 2193                    default:
 2194                        break;
 2195                }
 2196            }
 5022197        }
 2198
 2199        private static bool IsAudioContainerSupported(DirectPlayProfile profile, MediaSourceInfo item)
 2200        {
 2201            // Check container type
 02202            if (!profile.SupportsContainer(item.Container))
 2203            {
 02204                return false;
 2205            }
 2206
 2207            // Never direct play audio in matroska when the device only declare support for webm.
 2208            // The first check is not enough because mkv is assumed can be webm.
 2209            // See https://github.com/jellyfin/jellyfin/issues/13344
 02210            return !ContainerHelper.ContainsContainer("mkv", item.Container)
 02211                   || profile.SupportsContainer("mkv");
 2212        }
 2213
 2214        private static bool IsAudioDirectPlaySupported(DirectPlayProfile profile, MediaSourceInfo item, MediaStream audi
 2215        {
 02216            if (!IsAudioContainerSupported(profile, item))
 2217            {
 02218                return false;
 2219            }
 2220
 2221            // Check audio codec
 02222            string? audioCodec = audioStream?.Codec;
 02223            if (!profile.SupportsAudioCodec(audioCodec))
 2224            {
 02225                return false;
 2226            }
 2227
 02228            return true;
 2229        }
 2230
 2231        private static bool IsAudioDirectStreamSupported(DirectPlayProfile profile, MediaSourceInfo item, MediaStream au
 2232        {
 2233            // Check container type, this should NOT be supported
 2234            // If the container is supported, the file should be directly played
 02235            if (IsAudioContainerSupported(profile, item))
 2236            {
 02237                return false;
 2238            }
 2239
 2240            // Check audio codec, we cannot use the SupportsAudioCodec here
 2241            // Because that one assumes empty container supports all codec, which is just useless
 02242            string? audioCodec = audioStream?.Codec;
 02243            return string.Equals(profile.AudioCodec, audioCodec, StringComparison.OrdinalIgnoreCase)
 02244                   || string.Equals(profile.Container, audioCodec, StringComparison.OrdinalIgnoreCase);
 2245        }
 2246
 2247        private int GetRank(ref TranscodeReason a, TranscodeReason[] rankings)
 2248        {
 12092249            var index = 1;
 87402250            foreach (var flag in rankings)
 2251            {
 36662252                var reason = a & flag;
 36662253                if (reason != 0)
 2254                {
 10102255                    return index;
 2256                }
 2257
 26562258                index++;
 2259            }
 2260
 1992261            return index;
 2262        }
 2263
 2264        /// <summary>
 2265        /// Check the profile conditions.
 2266        /// </summary>
 2267        /// <param name="conditions">Profile conditions.</param>
 2268        /// <param name="mediaSource">Media source.</param>
 2269        /// <param name="videoStream">Video stream.</param>
 2270        /// <returns>Failed profile conditions.</returns>
 2271        private IEnumerable<ProfileCondition> CheckVideoConditions(ProfileCondition[] conditions, MediaSourceInfo mediaS
 2272        {
 7292273            int? width = videoStream?.Width;
 7292274            int? height = videoStream?.Height;
 7292275            int? bitDepth = videoStream?.BitDepth;
 7292276            int? videoBitrate = videoStream?.BitRate;
 7292277            double? videoLevel = videoStream?.Level;
 7292278            string? videoProfile = videoStream?.Profile;
 7292279            VideoRangeType? videoRangeType = videoStream?.VideoRangeType;
 7292280            float videoFramerate = videoStream is null ? 0 : videoStream.ReferenceFrameRate ?? 0;
 7292281            bool? isAnamorphic = videoStream?.IsAnamorphic;
 7292282            bool? isInterlaced = videoStream?.IsInterlaced;
 7292283            string? videoCodecTag = videoStream?.CodecTag;
 7292284            bool? isAvc = videoStream?.IsAVC;
 2285
 7292286            TransportStreamTimestamp? timestamp = videoStream is null ? TransportStreamTimestamp.None : mediaSource.Time
 7292287            int? packetLength = videoStream?.PacketLength;
 7292288            int? refFrames = videoStream?.RefFrames;
 2289
 7292290            int numStreams = mediaSource.MediaStreams.Count;
 7292291            int? numAudioStreams = mediaSource.GetStreamCount(MediaStreamType.Audio);
 7292292            int? numVideoStreams = mediaSource.GetStreamCount(MediaStreamType.Video);
 2293
 7292294            return conditions.Where(applyCondition => !ConditionProcessor.IsVideoConditionSatisfied(applyCondition, widt
 2295        }
 2296
 2297        /// <summary>
 2298        /// Check the compatibility of the container.
 2299        /// </summary>
 2300        /// <param name="options">Media options.</param>
 2301        /// <param name="mediaSource">Media source.</param>
 2302        /// <param name="container">Container.</param>
 2303        /// <param name="videoStream">Video stream.</param>
 2304        /// <returns>Transcode reasons if the container is not fully compatible.</returns>
 2305        private TranscodeReason GetCompatibilityContainer(MediaOptions options, MediaSourceInfo mediaSource, string cont
 2306        {
 2542307            var profile = options.Profile;
 2308
 2542309            var failures = AggregateFailureConditions(
 2542310                mediaSource,
 2542311                profile,
 2542312                "VideoCodecProfile",
 2542313                profile.ContainerProfiles
 2542314                    .Where(containerProfile => containerProfile.Type == DlnaProfileType.Video && containerProfile.Contai
 2542315                    .SelectMany(containerProfile => CheckVideoConditions(containerProfile.Conditions, mediaSource, video
 2316
 2542317            return failures;
 2318        }
 2319
 2320        /// <summary>
 2321        /// Check the compatibility of the video codec.
 2322        /// </summary>
 2323        /// <param name="options">Media options.</param>
 2324        /// <param name="mediaSource">Media source.</param>
 2325        /// <param name="container">Container.</param>
 2326        /// <param name="videoStream">Video stream.</param>
 2327        /// <returns>Transcode reasons if the video stream is not fully compatible.</returns>
 2328        private TranscodeReason GetCompatibilityVideoCodec(MediaOptions options, MediaSourceInfo mediaSource, string con
 2329        {
 4022330            var profile = options.Profile;
 2331
 4022332            string videoCodec = videoStream.Codec;
 2333
 4022334            var failures = AggregateFailureConditions(
 4022335                mediaSource,
 4022336                profile,
 4022337                "VideoCodecProfile",
 4022338                profile.CodecProfiles
 4022339                    .Where(codecProfile => codecProfile.Type == CodecType.Video &&
 4022340                        codecProfile.ContainsAnyCodec(videoCodec, container) &&
 4022341                        !CheckVideoConditions(codecProfile.ApplyConditions, mediaSource, videoStream).Any())
 4022342                    .SelectMany(codecProfile => CheckVideoConditions(codecProfile.Conditions, mediaSource, videoStream))
 2343
 4022344            return failures;
 2345        }
 2346
 2347        /// <summary>
 2348        /// Check the compatibility of the audio codec.
 2349        /// </summary>
 2350        /// <param name="options">Media options.</param>
 2351        /// <param name="mediaSource">Media source.</param>
 2352        /// <param name="container">Container.</param>
 2353        /// <param name="audioStream">Audio stream.</param>
 2354        /// <param name="transcodingAudioCodec">Override audio codec.</param>
 2355        /// <param name="isVideo">The media source is video.</param>
 2356        /// <param name="isSecondaryAudio">The audio stream is secondary.</param>
 2357        /// <returns>Transcode reasons if the audio stream is not fully compatible.</returns>
 2358        private TranscodeReason GetCompatibilityAudioCodec(MediaOptions options, MediaSourceInfo mediaSource, string con
 2359        {
 10052360            var profile = options.Profile;
 2361
 10052362            var audioCodec = transcodingAudioCodec ?? audioStream.Codec;
 10052363            var audioProfile = audioStream.Profile;
 10052364            var audioChannels = audioStream.Channels;
 10052365            var audioBitrate = audioStream.BitRate;
 10052366            var audioSampleRate = audioStream.SampleRate;
 10052367            var audioBitDepth = audioStream.BitDepth;
 2368
 10052369            var audioFailureConditions = isVideo
 10052370                ? GetProfileConditionsForVideoAudio(profile.CodecProfiles, container, audioCodec, audioChannels, audioBi
 10052371                : GetProfileConditionsForAudio(profile.CodecProfiles, container, audioCodec, audioChannels, audioBitrate
 2372
 10052373            var failures = AggregateFailureConditions(mediaSource, profile, "AudioCodecProfile", audioFailureConditions)
 2374
 10052375            return failures;
 2376        }
 2377
 2378        /// <summary>
 2379        /// Check the compatibility of the audio codec for direct playback.
 2380        /// </summary>
 2381        /// <param name="options">Media options.</param>
 2382        /// <param name="mediaSource">Media source.</param>
 2383        /// <param name="container">Container.</param>
 2384        /// <param name="audioStream">Audio stream.</param>
 2385        /// <param name="isVideo">The media source is video.</param>
 2386        /// <param name="isSecondaryAudio">The audio stream is secondary.</param>
 2387        /// <returns>Transcode reasons if the audio stream is not fully compatible for direct playback.</returns>
 2388        private TranscodeReason GetCompatibilityAudioCodecDirect(MediaOptions options, MediaSourceInfo mediaSource, stri
 2389        {
 2732390            var failures = GetCompatibilityAudioCodec(options, mediaSource, container, audioStream, null, isVideo, isSec
 2391
 2732392            if (audioStream.IsExternal)
 2393            {
 62394                failures |= TranscodeReason.AudioIsExternal;
 2395            }
 2396
 2732397            return failures;
 2398        }
 2399    }
 2400}
Generated by: ReportGenerator 5.4.5.0
5/1/2025 - 12:10:10 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)
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)