| | | 1 | | using System; |
| | | 2 | | using System.Collections.Generic; |
| | | 3 | | using System.Globalization; |
| | | 4 | | using System.IO; |
| | | 5 | | using System.Linq; |
| | | 6 | | using System.Text.RegularExpressions; |
| | | 7 | | using Emby.Naming.Common; |
| | | 8 | | using Emby.Naming.TV; |
| | | 9 | | using Jellyfin.Data.Enums; |
| | | 10 | | using MediaBrowser.Model.IO; |
| | | 11 | | |
| | | 12 | | namespace Emby.Naming.Video |
| | | 13 | | { |
| | | 14 | | /// <summary> |
| | | 15 | | /// Resolves alternative versions and extras from list of video files. |
| | | 16 | | /// </summary> |
| | | 17 | | public partial class VideoListResolver |
| | | 18 | | { |
| | 2 | 19 | | private static readonly StringComparer _numericOrdinalComparer = StringComparer.Create(CultureInfo.InvariantCult |
| | | 20 | | |
| | | 21 | | private readonly NamingOptions _namingOptions; |
| | | 22 | | private readonly EpisodePathParser _episodePathParser; |
| | | 23 | | |
| | | 24 | | /// <summary> |
| | | 25 | | /// Initializes a new instance of the <see cref="VideoListResolver"/> class. |
| | | 26 | | /// </summary> |
| | | 27 | | /// <param name="namingOptions">The naming options.</param> |
| | | 28 | | public VideoListResolver(NamingOptions namingOptions) |
| | | 29 | | { |
| | 103 | 30 | | _namingOptions = namingOptions; |
| | 103 | 31 | | _episodePathParser = new EpisodePathParser(namingOptions); |
| | 103 | 32 | | } |
| | | 33 | | |
| | | 34 | | [GeneratedRegex("[0-9]{2}[0-9]+[ip]", RegexOptions.IgnoreCase)] |
| | | 35 | | private static partial Regex ResolutionRegex(); |
| | | 36 | | |
| | | 37 | | [GeneratedRegex(@"^\[([^]]*)\]")] |
| | | 38 | | private static partial Regex CheckMultiVersionRegex(); |
| | | 39 | | |
| | | 40 | | /// <summary> |
| | | 41 | | /// Resolves alternative versions and extras from list of video files. |
| | | 42 | | /// </summary> |
| | | 43 | | /// <param name="videoInfos">List of related video files.</param> |
| | | 44 | | /// <param name="supportMultiVersion">Indication we should consider multi-versions of content.</param> |
| | | 45 | | /// <param name="parseName">Whether to parse the name or use the filename.</param> |
| | | 46 | | /// <param name="libraryRoot">Top-level folder for the containing library.</param> |
| | | 47 | | /// <param name="collectionType">The type of the containing collection, if known.</param> |
| | | 48 | | /// <returns>Returns enumerable of <see cref="VideoInfo"/> which groups files together when related.</returns> |
| | | 49 | | public IReadOnlyList<VideoInfo> Resolve(IReadOnlyList<VideoFileInfo> videoInfos, bool supportMultiVersion = true |
| | | 50 | | { |
| | | 51 | | // Filter out all extras, otherwise they could cause stacks to not be resolved |
| | | 52 | | // See the unit test TestStackedWithTrailer |
| | 82 | 53 | | var nonExtras = videoInfos |
| | 82 | 54 | | .Where(i => i.ExtraType is null) |
| | 82 | 55 | | .Select(i => new FileSystemMetadata { FullName = i.Path, IsDirectory = i.IsDirectory }); |
| | | 56 | | |
| | 82 | 57 | | var stackResult = StackResolver.Resolve(nonExtras, _namingOptions).ToList(); |
| | | 58 | | |
| | 82 | 59 | | var remainingFiles = new List<VideoFileInfo>(); |
| | 82 | 60 | | var standaloneMedia = new List<VideoFileInfo>(); |
| | | 61 | | |
| | 720 | 62 | | for (var i = 0; i < videoInfos.Count; i++) |
| | | 63 | | { |
| | 278 | 64 | | var current = videoInfos[i]; |
| | 278 | 65 | | if (stackResult.Any(s => s.ContainsFile(current.Path, current.IsDirectory))) |
| | | 66 | | { |
| | | 67 | | continue; |
| | | 68 | | } |
| | | 69 | | |
| | 226 | 70 | | if (current.ExtraType is null) |
| | | 71 | | { |
| | 198 | 72 | | standaloneMedia.Add(current); |
| | | 73 | | } |
| | | 74 | | else |
| | | 75 | | { |
| | 28 | 76 | | remainingFiles.Add(current); |
| | | 77 | | } |
| | | 78 | | } |
| | | 79 | | |
| | 82 | 80 | | var list = new List<VideoInfo>(); |
| | | 81 | | |
| | 212 | 82 | | foreach (var stack in stackResult) |
| | | 83 | | { |
| | 24 | 84 | | var info = new VideoInfo(stack.Name) |
| | 24 | 85 | | { |
| | 24 | 86 | | Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, _namingOptions, par |
| | 24 | 87 | | .OfType<VideoFileInfo>() |
| | 24 | 88 | | .ToList() |
| | 24 | 89 | | }; |
| | | 90 | | |
| | 24 | 91 | | info.Year = info.Files[0].Year; |
| | 24 | 92 | | list.Add(info); |
| | | 93 | | } |
| | | 94 | | |
| | 560 | 95 | | foreach (var media in standaloneMedia) |
| | | 96 | | { |
| | 198 | 97 | | var info = new VideoInfo(media.Name) { Files = new[] { media } }; |
| | | 98 | | |
| | 198 | 99 | | info.Year = info.Files[0].Year; |
| | 198 | 100 | | list.Add(info); |
| | | 101 | | } |
| | | 102 | | |
| | 82 | 103 | | if (supportMultiVersion) |
| | | 104 | | { |
| | 82 | 105 | | list = collectionType is CollectionType.tvshows |
| | 82 | 106 | | ? GetEpisodesGroupedByVersion(list) |
| | 82 | 107 | | : GetVideosGroupedByVersion(list); |
| | | 108 | | } |
| | | 109 | | |
| | | 110 | | // Whatever files are left, just add them |
| | 82 | 111 | | list.AddRange(remainingFiles.Select(i => new VideoInfo(i.Name) |
| | 82 | 112 | | { |
| | 82 | 113 | | Files = new[] { i }, |
| | 82 | 114 | | Year = i.Year, |
| | 82 | 115 | | ExtraType = i.ExtraType |
| | 82 | 116 | | })); |
| | | 117 | | |
| | 82 | 118 | | return list; |
| | | 119 | | } |
| | | 120 | | |
| | | 121 | | private List<VideoInfo> GetVideosGroupedByVersion(List<VideoInfo> videos) |
| | | 122 | | { |
| | 56 | 123 | | if (videos.Count == 0) |
| | | 124 | | { |
| | 1 | 125 | | return videos; |
| | | 126 | | } |
| | | 127 | | |
| | 55 | 128 | | var folderName = Path.GetFileName(Path.GetDirectoryName(videos[0].Files[0].Path.AsSpan())); |
| | | 129 | | |
| | 55 | 130 | | if (folderName.Length <= 1 || !HaveSameYear(videos)) |
| | | 131 | | { |
| | 17 | 132 | | return videos; |
| | | 133 | | } |
| | | 134 | | |
| | | 135 | | // Cannot use Span inside local functions and delegates thus we cannot use LINQ here nor merge with the abov |
| | 38 | 136 | | VideoInfo? primary = null; |
| | 240 | 137 | | for (var i = 0; i < videos.Count; i++) |
| | | 138 | | { |
| | 93 | 139 | | var video = videos[i]; |
| | 93 | 140 | | if (video.ExtraType is not null) |
| | | 141 | | { |
| | | 142 | | continue; |
| | | 143 | | } |
| | | 144 | | |
| | 93 | 145 | | if (!IsEligibleForMultiVersion(folderName, video.Files[0].FileNameWithoutExtension)) |
| | | 146 | | { |
| | 11 | 147 | | return videos; |
| | | 148 | | } |
| | | 149 | | |
| | 82 | 150 | | if (folderName.Equals(video.Files[0].FileNameWithoutExtension, StringComparison.Ordinal)) |
| | | 151 | | { |
| | 14 | 152 | | primary = video; |
| | | 153 | | } |
| | | 154 | | } |
| | | 155 | | |
| | 27 | 156 | | var organized = OrganizeAlternateVersions(videos, primary, folderName.ToString()); |
| | | 157 | | |
| | 27 | 158 | | return [organized]; |
| | | 159 | | } |
| | | 160 | | |
| | | 161 | | private static bool HaveSameYear(IReadOnlyList<VideoInfo> videos) |
| | | 162 | | { |
| | 42 | 163 | | if (videos.Count == 1) |
| | | 164 | | { |
| | 17 | 165 | | return true; |
| | | 166 | | } |
| | | 167 | | |
| | 25 | 168 | | var firstYear = videos[0].Year ?? -1; |
| | 186 | 169 | | for (var i = 1; i < videos.Count; i++) |
| | | 170 | | { |
| | 72 | 171 | | if ((videos[i].Year ?? -1) != firstYear) |
| | | 172 | | { |
| | 4 | 173 | | return false; |
| | | 174 | | } |
| | | 175 | | } |
| | | 176 | | |
| | 21 | 177 | | return true; |
| | | 178 | | } |
| | | 179 | | |
| | | 180 | | private bool IsEligibleForMultiVersion(ReadOnlySpan<char> folderName, ReadOnlySpan<char> testFilename) |
| | | 181 | | { |
| | 93 | 182 | | if (!testFilename.StartsWith(folderName, StringComparison.OrdinalIgnoreCase)) |
| | | 183 | | { |
| | 5 | 184 | | return false; |
| | | 185 | | } |
| | | 186 | | |
| | | 187 | | // Remove the folder name before cleaning as we don't care about cleaning that part |
| | 88 | 188 | | if (folderName.Length <= testFilename.Length) |
| | | 189 | | { |
| | 88 | 190 | | testFilename = testFilename[folderName.Length..].Trim(); |
| | | 191 | | } |
| | | 192 | | |
| | | 193 | | // There are no span overloads for regex unfortunately |
| | 88 | 194 | | if (CleanStringParser.TryClean(testFilename.ToString(), _namingOptions.CleanStringRegexes, out var cleanName |
| | | 195 | | { |
| | 28 | 196 | | testFilename = cleanName.AsSpan().Trim(); |
| | | 197 | | } |
| | | 198 | | |
| | | 199 | | // The CleanStringParser should have removed common keywords etc. |
| | 88 | 200 | | return testFilename.IsEmpty |
| | 88 | 201 | | || testFilename[0] == '-' |
| | 88 | 202 | | || testFilename[0] == '_' |
| | 88 | 203 | | || testFilename[0] == '.' |
| | 88 | 204 | | || CheckMultiVersionRegex().IsMatch(testFilename); |
| | | 205 | | } |
| | | 206 | | |
| | | 207 | | private List<VideoInfo> GetEpisodesGroupedByVersion(List<VideoInfo> videos) |
| | | 208 | | { |
| | 26 | 209 | | if (videos.Count < 2) |
| | | 210 | | { |
| | 0 | 211 | | return videos; |
| | | 212 | | } |
| | | 213 | | |
| | 26 | 214 | | var result = new List<VideoInfo>(); |
| | 26 | 215 | | var groups = new Dictionary<string, List<VideoInfo>>(StringComparer.OrdinalIgnoreCase); |
| | | 216 | | |
| | 200 | 217 | | for (var i = 0; i < videos.Count; i++) |
| | | 218 | | { |
| | 74 | 219 | | var video = videos[i]; |
| | 74 | 220 | | var key = GetEpisodeVersionKey(video.Files[0].Path); |
| | | 221 | | |
| | 74 | 222 | | if (key is null) |
| | | 223 | | { |
| | 7 | 224 | | result.Add(video); |
| | 7 | 225 | | continue; |
| | | 226 | | } |
| | | 227 | | |
| | 67 | 228 | | if (!groups.TryGetValue(key, out var group)) |
| | | 229 | | { |
| | 37 | 230 | | group = []; |
| | 37 | 231 | | groups[key] = group; |
| | | 232 | | } |
| | | 233 | | |
| | 67 | 234 | | group.Add(video); |
| | | 235 | | } |
| | | 236 | | |
| | 126 | 237 | | foreach (var group in groups.Values) |
| | | 238 | | { |
| | 37 | 239 | | if (group.Count == 1) |
| | | 240 | | { |
| | 11 | 241 | | result.Add(group[0]); |
| | 11 | 242 | | continue; |
| | | 243 | | } |
| | | 244 | | |
| | 26 | 245 | | result.Add(OrganizeAlternateVersions(group)); |
| | | 246 | | } |
| | | 247 | | |
| | 26 | 248 | | return result; |
| | | 249 | | } |
| | | 250 | | |
| | | 251 | | private string? GetEpisodeVersionKey(string path) |
| | | 252 | | { |
| | | 253 | | // Optimistic expressions are guesses, so they are not consulted here: merging is destructive, |
| | | 254 | | // a file collapsed into the alternate versions of another one is no longer an episode of its own. |
| | 74 | 255 | | var episodeResult = _episodePathParser.Parse(path, false, isOptimistic: false, fillExtendedInfo: false); |
| | 74 | 256 | | if (!episodeResult.Success) |
| | | 257 | | { |
| | 3 | 258 | | return null; |
| | | 259 | | } |
| | | 260 | | |
| | 71 | 261 | | if (episodeResult.IsByDate) |
| | | 262 | | { |
| | 0 | 263 | | return episodeResult.Year.HasValue && episodeResult.Month.HasValue && episodeResult.Day.HasValue |
| | 0 | 264 | | ? FormattableString.Invariant( |
| | 0 | 265 | | $"D{episodeResult.Year.Value}{episodeResult.Month.Value:D2}{episodeResult.Day.Value:D2}") |
| | 0 | 266 | | : null; |
| | | 267 | | } |
| | | 268 | | |
| | 71 | 269 | | return episodeResult.SeasonNumber.HasValue && episodeResult.EpisodeNumber.HasValue |
| | 71 | 270 | | ? FormattableString.Invariant($"S{episodeResult.SeasonNumber.Value}E{episodeResult.EpisodeNumber.Value}" |
| | 71 | 271 | | : null; |
| | | 272 | | } |
| | | 273 | | |
| | | 274 | | private static VideoInfo OrganizeAlternateVersions( |
| | | 275 | | List<VideoInfo> videos, |
| | | 276 | | VideoInfo? primaryOverride = null, |
| | | 277 | | string? nameOverride = null) |
| | | 278 | | { |
| | 53 | 279 | | if (videos.Count > 1) |
| | | 280 | | { |
| | 43 | 281 | | var groups = videos |
| | 43 | 282 | | .Select(x => (filename: x.Files[0].FileNameWithoutExtension.ToString(), value: x)) |
| | 43 | 283 | | .Select(x => (x.filename, resolutionMatch: ResolutionRegex().Match(x.filename), x.value)) |
| | 43 | 284 | | .GroupBy(x => x.resolutionMatch.Success) |
| | 43 | 285 | | .ToList(); |
| | | 286 | | |
| | 43 | 287 | | videos = []; |
| | | 288 | | |
| | 190 | 289 | | foreach (var group in groups) |
| | | 290 | | { |
| | 52 | 291 | | if (group.Key) |
| | | 292 | | { |
| | 32 | 293 | | videos.InsertRange(0, group |
| | 32 | 294 | | .OrderByDescending(x => x.resolutionMatch.Value, _numericOrdinalComparer) |
| | 32 | 295 | | .ThenBy(x => x.filename, _numericOrdinalComparer) |
| | 32 | 296 | | .Select(x => x.value)); |
| | | 297 | | } |
| | | 298 | | else |
| | | 299 | | { |
| | 20 | 300 | | videos.AddRange(group.OrderBy(x => x.filename, _numericOrdinalComparer).Select(x => x.value)); |
| | | 301 | | } |
| | | 302 | | } |
| | | 303 | | } |
| | | 304 | | |
| | | 305 | | // Prefer a stacked entry (more than one part) as primary |
| | 53 | 306 | | var primary = primaryOverride |
| | 53 | 307 | | ?? videos.FirstOrDefault(v => v.Files.Count > 1) |
| | 53 | 308 | | ?? videos[0]; |
| | 53 | 309 | | videos.Remove(primary); |
| | | 310 | | |
| | 53 | 311 | | primary.AlternateVersions = videos; |
| | | 312 | | |
| | 53 | 313 | | if (nameOverride is not null) |
| | | 314 | | { |
| | 27 | 315 | | primary.Name = nameOverride; |
| | | 316 | | } |
| | | 317 | | |
| | 53 | 318 | | return primary; |
| | | 319 | | } |
| | | 320 | | } |
| | | 321 | | } |