< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Library.MediaStreamSelector
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Library/MediaStreamSelector.cs
Line coverage
85%
Covered lines: 64
Uncovered lines: 11
Coverable lines: 75
Total lines: 193
Line coverage: 85.3%
Branch coverage
65%
Covered branches: 42
Total branches: 64
Branch coverage: 65.6%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 5/31/2026 - 12:15:44 AM Line coverage: 53.3% (40/75) Branch coverage: 37.5% (24/64) Total lines: 19310/29/2026 - 12:17:11 AM Line coverage: 85.3% (64/75) Branch coverage: 65.6% (42/64) Total lines: 193 5/31/2026 - 12:15:44 AM Line coverage: 53.3% (40/75) Branch coverage: 37.5% (24/64) Total lines: 19310/29/2026 - 12:17:11 AM Line coverage: 85.3% (64/75) Branch coverage: 65.6% (42/64) Total lines: 193

Coverage delta

Coverage delta 32 -32

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
GetDefaultAudioStreamIndex(...)100%66100%
GetDefaultSubtitleStreamIndex(...)56.25%181679.16%
GetSortedStreams(...)100%11100%
SetSubtitleStreamScores(...)55.55%261871.42%
MatchesPreferredLanguage(...)50%22100%
IsLanguageUndefined(...)50%1010100%
BehaviorOnlyForced(...)100%11100%
GetStreamScore(...)91.66%1212100%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Library/MediaStreamSelector.cs

#LineLine coverage
 1#pragma warning disable CS1591
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Linq;
 6using Jellyfin.Database.Implementations.Enums;
 7using Jellyfin.Extensions;
 8using MediaBrowser.Model.Entities;
 9
 10namespace Emby.Server.Implementations.Library
 11{
 12    public static class MediaStreamSelector
 13    {
 14        public static int? GetDefaultAudioStreamIndex(IReadOnlyList<MediaStream> streams, IReadOnlyList<string> preferre
 15        {
 4516            var sortedStreams = GetSortedStreams(streams, MediaStreamType.Audio, preferredLanguages).ToList();
 17
 4518            if (preferDefaultTrack)
 19            {
 3020                var defaultStream = sortedStreams.FirstOrDefault(i => i.IsDefault);
 21
 3022                if (defaultStream is not null)
 23                {
 2024                    return defaultStream.Index;
 25                }
 26            }
 27
 2528            return sortedStreams.FirstOrDefault()?.Index;
 29        }
 30
 31        public static int? GetDefaultSubtitleStreamIndex(
 32            IEnumerable<MediaStream> streams,
 33            IReadOnlyList<string> preferredLanguages,
 34            SubtitlePlaybackMode mode,
 35            string audioTrackLanguage)
 36        {
 3437            if (mode == SubtitlePlaybackMode.None)
 38            {
 139                return null;
 40            }
 41
 42            // Sort in the following order: Default > No tag > Forced
 3343            var sortedStreams = streams
 3344                .Where(i => i.Type == MediaStreamType.Subtitle)
 3345                .OrderByDescending(x => x.IsExternal)
 3346                .ThenByDescending(x => x.IsDefault)
 3347                .ThenByDescending(x => !x.IsForced && MatchesPreferredLanguage(x.Language, preferredLanguages))
 3348                .ThenByDescending(x => x.IsForced && MatchesPreferredLanguage(x.Language, preferredLanguages))
 3349                .ThenByDescending(x => x.IsForced && IsLanguageUndefined(x.Language))
 3350                .ThenByDescending(x => x.IsForced)
 3351                .ToList();
 52
 3353            MediaStream? stream = null;
 54
 3355            if (mode == SubtitlePlaybackMode.Default)
 56            {
 57                // Load subtitles according to external, default and forced flags.
 3158                stream = sortedStreams.FirstOrDefault(x => x.IsExternal || x.IsDefault || x.IsForced);
 59            }
 260            else if (mode == SubtitlePlaybackMode.Smart)
 61            {
 62                // Only attempt to load subtitles if the audio language is not one of the user's preferred subtitle lang
 63                // If no subtitles of preferred language available, use none.
 64                // If the audio language is one of the user's preferred subtitle languages behave like OnlyForced.
 065                if (!preferredLanguages.Contains(audioTrackLanguage, StringComparison.OrdinalIgnoreCase))
 66                {
 067                    stream = sortedStreams.FirstOrDefault(x => MatchesPreferredLanguage(x.Language, preferredLanguages))
 68                }
 69                else
 70                {
 071                    stream = BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
 72                }
 73            }
 274            else if (mode == SubtitlePlaybackMode.Always)
 75            {
 76                // Always load (full/non-forced) subtitles of the user's preferred subtitle language if possible, otherw
 077                stream = sortedStreams.FirstOrDefault(x => !x.IsForced && MatchesPreferredLanguage(x.Language, preferred
 078                    BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
 79            }
 280            else if (mode == SubtitlePlaybackMode.OnlyForced)
 81            {
 82                // Load subtitles that are flagged forced of the user's preferred subtitle language or with an undefined
 283                stream = BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
 84            }
 85
 3386            return stream?.Index;
 87        }
 88
 89        private static IEnumerable<MediaStream> GetSortedStreams(IEnumerable<MediaStream> streams, MediaStreamType type,
 90        {
 91            // Give some preference to external text subs for better performance
 7892            return streams
 7893                .Where(i => i.Type == type)
 7894                .OrderByDescending(i => GetStreamScore(i, languagePreferences));
 95        }
 96
 97        public static void SetSubtitleStreamScores(
 98            IReadOnlyList<MediaStream> streams,
 99            IReadOnlyList<string> preferredLanguages,
 100            SubtitlePlaybackMode mode,
 101            string audioTrackLanguage)
 102        {
 34103            if (mode == SubtitlePlaybackMode.None)
 104            {
 1105                return;
 106            }
 107
 33108            var sortedStreams = GetSortedStreams(streams, MediaStreamType.Subtitle, preferredLanguages).ToList();
 109
 33110            List<MediaStream>? filteredStreams = null;
 111
 33112            if (mode == SubtitlePlaybackMode.Default)
 113            {
 114                // Prefer embedded metadata over smart logic
 115                // Load subtitles according to external, default, and forced flags.
 31116                filteredStreams = sortedStreams.Where(s => s.IsExternal || s.IsDefault || s.IsForced)
 31117                    .ToList();
 118            }
 2119            else if (mode == SubtitlePlaybackMode.Smart)
 120            {
 121                // Prefer smart logic over embedded metadata
 122                // Only attempt to load subtitles if the audio language is not one of the user's preferred subtitle lang
 0123                if (!preferredLanguages.Contains(audioTrackLanguage, StringComparison.OrdinalIgnoreCase))
 124                {
 0125                    filteredStreams = sortedStreams.Where(s => MatchesPreferredLanguage(s.Language, preferredLanguages))
 0126                        .ToList();
 127                }
 128                else
 129                {
 0130                    filteredStreams = BehaviorOnlyForced(sortedStreams, preferredLanguages);
 131                }
 132            }
 2133            else if (mode == SubtitlePlaybackMode.Always)
 134            {
 135                // Always load (full/non-forced) subtitles of the user's preferred subtitle language if possible, otherw
 0136                filteredStreams = sortedStreams.Where(s => !s.IsForced && MatchesPreferredLanguage(s.Language, preferred
 0137                    .ToList() ?? BehaviorOnlyForced(sortedStreams, preferredLanguages);
 138            }
 2139            else if (mode == SubtitlePlaybackMode.OnlyForced)
 140            {
 141                // Load subtitles that are flagged forced of the user's preferred subtitle language or with an undefined
 2142                filteredStreams = BehaviorOnlyForced(sortedStreams, preferredLanguages);
 143            }
 144
 145            // If filteredStreams is null, initialize it as an empty list to avoid null reference errors
 33146            filteredStreams ??= new List<MediaStream>();
 147
 68148            foreach (var stream in filteredStreams)
 149            {
 1150                stream.Score = GetStreamScore(stream, preferredLanguages);
 151            }
 33152        }
 153
 154        private static bool MatchesPreferredLanguage(string language, IReadOnlyList<string> preferredLanguages)
 155        {
 156            // If preferredLanguages is empty, treat it as "any language" (wildcard)
 4157            return preferredLanguages.Count == 0 ||
 4158                preferredLanguages.Contains(language, StringComparison.OrdinalIgnoreCase);
 159        }
 160
 161        private static bool IsLanguageUndefined(string language)
 162        {
 163            // Check for null, empty, or known placeholders
 1164            return string.IsNullOrEmpty(language) ||
 1165                language.Equals("und", StringComparison.OrdinalIgnoreCase) ||
 1166                language.Equals("unknown", StringComparison.OrdinalIgnoreCase) ||
 1167                language.Equals("undetermined", StringComparison.OrdinalIgnoreCase) ||
 1168                language.Equals("mul", StringComparison.OrdinalIgnoreCase) ||
 1169                language.Equals("zxx", StringComparison.OrdinalIgnoreCase);
 170        }
 171
 172        private static List<MediaStream> BehaviorOnlyForced(IEnumerable<MediaStream> sortedStreams, IReadOnlyList<string
 173        {
 4174            return sortedStreams
 4175                .Where(s => s.IsForced && (MatchesPreferredLanguage(s.Language, preferredLanguages) || IsLanguageUndefin
 4176                .OrderByDescending(s => MatchesPreferredLanguage(s.Language, preferredLanguages))
 4177                .ThenByDescending(s => IsLanguageUndefined(s.Language))
 4178                .ToList();
 179        }
 180
 181        internal static int GetStreamScore(MediaStream stream, IReadOnlyList<string> languagePreferences)
 182        {
 120183            var index = languagePreferences.FindIndex(x => string.Equals(x, stream.Language, StringComparison.OrdinalIgn
 120184            var score = index == -1 ? 1 : 101 - index;
 120185            score = (score * 10) + (stream.IsForced ? 2 : 1);
 120186            score = (score * 10) + (stream.IsDefault ? 2 : 1);
 120187            score = (score * 10) + (stream.SupportsExternalStream ? 2 : 1);
 120188            score = (score * 10) + (stream.IsTextSubtitleStream ? 2 : 1);
 120189            score = (score * 10) + (stream.IsExternal ? 2 : 1);
 120190            return score;
 191        }
 192    }
 193}