Cutlery/jellyfin
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2025-11-03 19:17:24 -05:00
Code Issues Packages Projects Releases Wiki Activity

Respect preferred language when selecting forced subtitles (#13098)

Browse Source 
Rework subtitle selection logic
This commit is contained in:
timminator 2025-03-19 00:40:06 +01:00 committed by GitHub
parent 85b5bebda4
commit c24d0c1240
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 60 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
Emby.Server.Implementations/Library/MediaStreamSelector.cs
View File

@ -39,46 +39,48 @@ namespace Emby.Server.Implementations.Library
return null; return null;
} }
// Sort in the following order: Default > No tag > Forced
var sortedStreams = streams var sortedStreams = streams
.Where(i => i.Type == MediaStreamType.Subtitle) .Where(i => i.Type == MediaStreamType.Subtitle)
.OrderByDescending(x => x.IsExternal) .OrderByDescending(x => x.IsExternal)
.ThenByDescending(x => x.IsForced && string.Equals(x.Language, audioTrackLanguage, StringComparison.OrdinalIgnoreCase))
.ThenByDescending(x => x.IsForced)
.ThenByDescending(x => x.IsDefault) .ThenByDescending(x => x.IsDefault)
.ThenByDescending(x => preferredLanguages.Contains(x.Language, StringComparison.OrdinalIgnoreCase)) .ThenByDescending(x => !x.IsForced && MatchesPreferredLanguage(x.Language, preferredLanguages))
.ThenByDescending(x => x.IsForced && MatchesPreferredLanguage(x.Language, preferredLanguages))
.ThenByDescending(x => x.IsForced && IsLanguageUndefined(x.Language))
.ThenByDescending(x => x.IsForced)
.ToList(); .ToList();
MediaStream? stream = null; MediaStream? stream = null;
if (mode == SubtitlePlaybackMode.Default) if (mode == SubtitlePlaybackMode.Default)
{ {
// Load subtitles according to external, forced and default flags. // Load subtitles according to external, default and forced flags.
stream = sortedStreams.FirstOrDefault(x => x.IsExternal || x.IsForced || x.IsDefault); stream = sortedStreams.FirstOrDefault(x => x.IsExternal || x.IsDefault || x.IsForced);
} }
else if (mode == SubtitlePlaybackMode.Smart) else if (mode == SubtitlePlaybackMode.Smart)
{ {
// Only attempt to load subtitles if the audio language is not one of the user's preferred subtitle languages. // Only attempt to load subtitles if the audio language is not one of the user's preferred subtitle languages.
// If no subtitles of preferred language available, use default behaviour. // If no subtitles of preferred language available, use none.
// If the audio language is one of the user's preferred subtitle languages behave like OnlyForced.
if (!preferredLanguages.Contains(audioTrackLanguage, StringComparison.OrdinalIgnoreCase)) if (!preferredLanguages.Contains(audioTrackLanguage, StringComparison.OrdinalIgnoreCase))
{ {
stream = sortedStreams.FirstOrDefault(x => preferredLanguages.Contains(x.Language, StringComparison.OrdinalIgnoreCase)) ?? stream = sortedStreams.FirstOrDefault(x => MatchesPreferredLanguage(x.Language, preferredLanguages));
sortedStreams.FirstOrDefault(x => x.IsExternal || x.IsForced || x.IsDefault);
} }
else else
{ {
// Respect forced flag. stream = BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
stream = sortedStreams.FirstOrDefault(x => x.IsForced);
} }
} }
else if (mode == SubtitlePlaybackMode.Always) else if (mode == SubtitlePlaybackMode.Always)
{ {
// Always load (full/non-forced) subtitles of the user's preferred subtitle language if possible, otherwise default behaviour. // Always load (full/non-forced) subtitles of the user's preferred subtitle language if possible, otherwise OnlyForced behaviour.
stream = sortedStreams.FirstOrDefault(x => !x.IsForced && preferredLanguages.Contains(x.Language, StringComparison.OrdinalIgnoreCase)) ?? stream = sortedStreams.FirstOrDefault(x => !x.IsForced && MatchesPreferredLanguage(x.Language, preferredLanguages)) ??
sortedStreams.FirstOrDefault(x => x.IsExternal || x.IsForced || x.IsDefault); BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
} }
else if (mode == SubtitlePlaybackMode.OnlyForced) else if (mode == SubtitlePlaybackMode.OnlyForced)
{ {
// Only load subtitles that are flagged forced. // Load subtitles that are flagged forced of the user's preferred subtitle language or with an undefined language
stream = sortedStreams.FirstOrDefault(x => x.IsForced); stream = BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
} }
return stream?.Index; return stream?.Index;
@ -110,40 +112,72 @@ namespace Emby.Server.Implementations.Library
if (mode == SubtitlePlaybackMode.Default) if (mode == SubtitlePlaybackMode.Default)
{ {
// Prefer embedded metadata over smart logic // Prefer embedded metadata over smart logic
filteredStreams = sortedStreams.Where(s => s.IsForced || s.IsDefault) // Load subtitles according to external, default, and forced flags.
filteredStreams = sortedStreams.Where(s => s.IsExternal || s.IsDefault || s.IsForced)
.ToList(); .ToList();
} }
else if (mode == SubtitlePlaybackMode.Smart) else if (mode == SubtitlePlaybackMode.Smart)
{ {
// Prefer smart logic over embedded metadata // Prefer smart logic over embedded metadata
// Only attempt to load subtitles if the audio language is not one of the user's preferred subtitle languages, otherwise OnlyForced behavior.
if (!preferredLanguages.Contains(audioTrackLanguage, StringComparison.OrdinalIgnoreCase)) if (!preferredLanguages.Contains(audioTrackLanguage, StringComparison.OrdinalIgnoreCase))
{ {
filteredStreams = sortedStreams.Where(s => !s.IsForced && preferredLanguages.Contains(s.Language, StringComparison.OrdinalIgnoreCase)) filteredStreams = sortedStreams.Where(s => MatchesPreferredLanguage(s.Language, preferredLanguages))
.ToList(); .ToList();
} }
else
{
filteredStreams = BehaviorOnlyForced(sortedStreams, preferredLanguages);
}
} }
else if (mode == SubtitlePlaybackMode.Always) else if (mode == SubtitlePlaybackMode.Always)
{ {
// Always load the most suitable full subtitles // Always load (full/non-forced) subtitles of the user's preferred subtitle language if possible, otherwise OnlyForced behavior.
filteredStreams = sortedStreams.Where(s => !s.IsForced).ToList(); filteredStreams = sortedStreams.Where(s => !s.IsForced && MatchesPreferredLanguage(s.Language, preferredLanguages))
.ToList() ?? BehaviorOnlyForced(sortedStreams, preferredLanguages);
} }
else if (mode == SubtitlePlaybackMode.OnlyForced) else if (mode == SubtitlePlaybackMode.OnlyForced)
{ {
// Always load the most suitable full subtitles // Load subtitles that are flagged forced of the user's preferred subtitle language or with an undefined language
filteredStreams = sortedStreams.Where(s => s.IsForced).ToList(); filteredStreams = BehaviorOnlyForced(sortedStreams, preferredLanguages);
} }
// Load forced subs if we have found no suitable full subtitles // If filteredStreams is null, initialize it as an empty list to avoid null reference errors
var iterStreams = filteredStreams is null || filteredStreams.Count == 0 filteredStreams ??= new List<MediaStream>();
? sortedStreams.Where(s => s.IsForced && string.Equals(s.Language, audioTrackLanguage, StringComparison.OrdinalIgnoreCase))
: filteredStreams;
foreach (var stream in iterStreams) foreach (var stream in filteredStreams)
{ {
stream.Score = GetStreamScore(stream, preferredLanguages); stream.Score = GetStreamScore(stream, preferredLanguages);
} }
} }
private static bool MatchesPreferredLanguage(string language, IReadOnlyList<string> preferredLanguages)
{
// If preferredLanguages is empty, treat it as "any language" (wildcard)
return preferredLanguages.Count == 0 ||
preferredLanguages.Contains(language, StringComparison.OrdinalIgnoreCase);
}
private static bool IsLanguageUndefined(string language)
{
// Check for null, empty, or known placeholders
return string.IsNullOrEmpty(language) ||
language.Equals("und", StringComparison.OrdinalIgnoreCase) ||
language.Equals("unknown", StringComparison.OrdinalIgnoreCase) ||
language.Equals("undetermined", StringComparison.OrdinalIgnoreCase) ||
language.Equals("mul", StringComparison.OrdinalIgnoreCase) ||
language.Equals("zxx", StringComparison.OrdinalIgnoreCase);
}
private static List<MediaStream> BehaviorOnlyForced(IEnumerable<MediaStream> sortedStreams, IReadOnlyList<string> preferredLanguages)
{
return sortedStreams
.Where(s => s.IsForced && (MatchesPreferredLanguage(s.Language, preferredLanguages) || IsLanguageUndefined(s.Language)))
.OrderByDescending(s => MatchesPreferredLanguage(s.Language, preferredLanguages))
.ThenByDescending(s => IsLanguageUndefined(s.Language))
.ToList();
}
internal static int GetStreamScore(MediaStream stream, IReadOnlyList<string> languagePreferences) internal static int GetStreamScore(MediaStream stream, IReadOnlyList<string> languagePreferences)
{ {
var index = languagePreferences.FindIndex(x => string.Equals(x, stream.Language, StringComparison.OrdinalIgnoreCase)); var index = languagePreferences.FindIndex(x => string.Equals(x, stream.Language, StringComparison.OrdinalIgnoreCase));