< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Library.Resolvers.Movies.MovieResolver
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
Line coverage
38%
Covered lines: 98
Uncovered lines: 154
Coverable lines: 252
Total lines: 602
Line coverage: 38.8%
Branch coverage
33%
Covered branches: 57
Total branches: 172
Branch coverage: 33.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 4/15/2026 - 12:14:34 AM Line coverage: 7.2% (18/250) Branch coverage: 4% (7/172) Total lines: 5865/16/2026 - 12:15:55 AM Line coverage: 39.1% (99/253) Branch coverage: 35.6% (62/174) Total lines: 5935/20/2026 - 12:15:44 AM Line coverage: 39.1% (99/253) Branch coverage: 33.3% (58/174) Total lines: 5937/21/2026 - 12:16:33 AM Line coverage: 38.8% (98/252) Branch coverage: 33.1% (57/172) Total lines: 602 4/15/2026 - 12:14:34 AM Line coverage: 7.2% (18/250) Branch coverage: 4% (7/172) Total lines: 5865/16/2026 - 12:15:55 AM Line coverage: 39.1% (99/253) Branch coverage: 35.6% (62/174) Total lines: 5935/20/2026 - 12:15:44 AM Line coverage: 39.1% (99/253) Branch coverage: 33.3% (58/174) Total lines: 5937/21/2026 - 12:16:33 AM Line coverage: 38.8% (98/252) Branch coverage: 33.1% (57/172) Total lines: 602

Coverage delta

Coverage delta 32 -32

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
get_Priority()100%11100%
ResolveMultiple(...)100%44100%
Resolve(...)7.14%12114212.82%
ResolveMultipleInternal(...)45.45%942247.05%
ResolveVideos(...)60%343084.09%
ContainsFile(...)91.66%121290.9%
ContainsFile(...)100%11100%
SetInitialItemValues(...)100%11100%
SetProviderIdsFromPath(...)70%1010100%
FindMovie(...)0%1482380%
GetMultiDiscMovie(...)0%7280%
IsInvalid(...)66.66%7666.66%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs

#LineLine coverage
 1#nullable disable
 2
 3using System;
 4using System.Collections.Generic;
 5using System.IO;
 6using System.Linq;
 7using System.Text.RegularExpressions;
 8using Emby.Naming.Common;
 9using Emby.Naming.Video;
 10using Jellyfin.Data.Enums;
 11using Jellyfin.Extensions;
 12using MediaBrowser.Controller.Drawing;
 13using MediaBrowser.Controller.Entities;
 14using MediaBrowser.Controller.Entities.Movies;
 15using MediaBrowser.Controller.Entities.TV;
 16using MediaBrowser.Controller.Library;
 17using MediaBrowser.Controller.Providers;
 18using MediaBrowser.Controller.Resolvers;
 19using MediaBrowser.Model.Entities;
 20using MediaBrowser.Model.IO;
 21using Microsoft.Extensions.Logging;
 22
 23namespace Emby.Server.Implementations.Library.Resolvers.Movies
 24{
 25    /// <summary>
 26    /// Class MovieResolver.
 27    /// </summary>
 28    public partial class MovieResolver : BaseVideoResolver<Video>, IMultiItemResolver
 29    {
 30        private readonly IImageProcessor _imageProcessor;
 31        private readonly VideoListResolver _videoListResolver;
 32
 133        private static readonly CollectionType[] _validCollectionTypes =
 134        [
 135            CollectionType.movies,
 136            CollectionType.homevideos,
 137            CollectionType.musicvideos,
 138            CollectionType.tvshows,
 139            CollectionType.photos
 140        ];
 41
 42        /// <summary>
 43        /// Initializes a new instance of the <see cref="MovieResolver"/> class.
 44        /// </summary>
 45        /// <param name="imageProcessor">The image processor.</param>
 46        /// <param name="logger">The logger.</param>
 47        /// <param name="namingOptions">The naming options.</param>
 48        /// <param name="directoryService">The directory service.</param>
 49        /// <param name="videoListResolver">The video list resolver.</param>
 50        public MovieResolver(IImageProcessor imageProcessor, ILogger<MovieResolver> logger, NamingOptions namingOptions,
 2551            : base(logger, namingOptions, directoryService)
 52        {
 2553            _imageProcessor = imageProcessor;
 2554            _videoListResolver = videoListResolver;
 2555        }
 56
 57        /// <summary>
 58        /// Gets the priority.
 59        /// </summary>
 60        /// <value>The priority.</value>
 2261        public override ResolverPriority Priority => ResolverPriority.Fourth;
 62
 63        [GeneratedRegex(@"\bsample\b", RegexOptions.IgnoreCase)]
 64        private static partial Regex IsIgnoredRegex();
 65
 66        /// <inheritdoc />
 67        public MultiItemResolverResult ResolveMultiple(
 68            Folder parent,
 69            List<FileSystemMetadata> files,
 70            CollectionType? collectionType,
 71            IDirectoryService directoryService)
 72        {
 6273            var result = ResolveMultipleInternal(parent, files, collectionType);
 74
 6275            if (result is not null)
 76            {
 1077                foreach (var item in result.Items)
 78                {
 379                    SetInitialItemValues((Video)item, null);
 80                }
 81            }
 82
 6283            return result;
 84        }
 85
 86        /// <summary>
 87        /// Resolves the specified args.
 88        /// </summary>
 89        /// <param name="args">The args.</param>
 90        /// <returns>Video.</returns>
 91        protected override Video Resolve(ItemResolveArgs args)
 92        {
 1193            var collectionType = args.GetCollectionType();
 94
 95            // Find movies with their own folders
 1196            if (args.IsDirectory)
 97            {
 098                if (IsInvalid(args.Parent, collectionType))
 99                {
 0100                    return null;
 101                }
 102
 0103                Video movie = null;
 0104                var files = args.GetActualFileSystemChildren().ToList();
 105
 0106                if (collectionType == CollectionType.musicvideos)
 107                {
 0108                    movie = FindMovie<MusicVideo>(args, args.Path, args.Parent, files, DirectoryService, collectionType,
 109                }
 110
 0111                if (collectionType == CollectionType.homevideos)
 112                {
 0113                    movie = FindMovie<Video>(args, args.Path, args.Parent, files, DirectoryService, collectionType, fals
 114                }
 115
 0116                if (collectionType is null)
 117                {
 118                    // Owned items will be caught by the video extra resolver
 0119                    if (args.Parent is null)
 120                    {
 0121                        return null;
 122                    }
 123
 0124                    if (args.HasParent<Series>())
 125                    {
 0126                        return null;
 127                    }
 128
 0129                    movie = FindMovie<Movie>(args, args.Path, args.Parent, files, DirectoryService, collectionType, true
 130                }
 131
 0132                if (collectionType == CollectionType.movies)
 133                {
 0134                    movie = FindMovie<Movie>(args, args.Path, args.Parent, files, DirectoryService, collectionType, true
 135                }
 136
 137                // ignore extras
 0138                return movie?.ExtraType is null ? movie : null;
 139            }
 140
 11141            if (args.Parent is null)
 142            {
 1143                return base.Resolve(args);
 144            }
 145
 10146            if (IsInvalid(args.Parent, collectionType))
 147            {
 10148                return null;
 149            }
 150
 0151            Video item = null;
 152
 0153            if (collectionType == CollectionType.musicvideos)
 154            {
 0155                item = ResolveVideo<MusicVideo>(args, false);
 156            }
 157
 158            // To find a movie file, the collection type must be movies or boxsets
 0159            else if (collectionType == CollectionType.movies)
 160            {
 0161                item = ResolveVideo<Movie>(args, true);
 162            }
 0163            else if (collectionType == CollectionType.homevideos || collectionType == CollectionType.photos)
 164            {
 0165                item = ResolveVideo<Video>(args, false);
 166            }
 0167            else if (collectionType is null)
 168            {
 0169                if (args.HasParent<Series>())
 170                {
 0171                    return null;
 172                }
 173
 0174                item = ResolveVideo<Video>(args, false);
 175            }
 176
 177            // Ignore extras
 0178            if (item?.ExtraType is not null)
 179            {
 0180                return null;
 181            }
 182
 0183            if (item is not null)
 184            {
 0185                item.IsInMixedFolder = true;
 186            }
 187
 0188            return item;
 189        }
 190
 191        private MultiItemResolverResult ResolveMultipleInternal(
 192            Folder parent,
 193            List<FileSystemMetadata> files,
 194            CollectionType? collectionType)
 195        {
 62196            if (IsInvalid(parent, collectionType))
 197            {
 60198                return null;
 199            }
 200
 2201            if (collectionType is CollectionType.musicvideos)
 202            {
 0203                return ResolveVideos<MusicVideo>(parent, files, true, collectionType, false);
 204            }
 205
 2206            if (collectionType == CollectionType.homevideos || collectionType == CollectionType.photos)
 207            {
 0208                return ResolveVideos<Video>(parent, files, false, collectionType, false);
 209            }
 210
 2211            if (collectionType is null)
 212            {
 213                // Owned items should just use the plain video type
 0214                if (parent is null)
 215                {
 0216                    return ResolveVideos<Video>(parent, files, false, collectionType, false);
 217                }
 218
 0219                if (parent is Series || parent.GetParents().OfType<Series>().Any())
 220                {
 0221                    return null;
 222                }
 223
 0224                return ResolveVideos<Movie>(parent, files, false, collectionType, true);
 225            }
 226
 2227            if (collectionType == CollectionType.movies)
 228            {
 1229                return ResolveVideos<Movie>(parent, files, true, collectionType, true);
 230            }
 231
 1232            if (collectionType == CollectionType.tvshows)
 233            {
 1234                return ResolveVideos<Episode>(parent, files, true, collectionType, true);
 235            }
 236
 0237            return null;
 238        }
 239
 240        private MultiItemResolverResult ResolveVideos<T>(
 241            Folder parent,
 242            IEnumerable<FileSystemMetadata> fileSystemEntries,
 243            bool supportMultiEditions,
 244            CollectionType? collectionType,
 245            bool parseName)
 246            where T : Video, new()
 247        {
 2248            var files = new List<FileSystemMetadata>();
 2249            var leftOver = new List<FileSystemMetadata>();
 2250            var hasCollectionType = collectionType is not null;
 251
 252            // Loop through each child file/folder and see if we find a video
 14253            foreach (var child in fileSystemEntries)
 254            {
 255                // This is a hack but currently no better way to resolve a sometimes ambiguous situation
 5256                if (!hasCollectionType)
 257                {
 0258                    if (string.Equals(child.Name, "tvshow.nfo", StringComparison.OrdinalIgnoreCase)
 0259                        || string.Equals(child.Name, "season.nfo", StringComparison.OrdinalIgnoreCase))
 260                    {
 0261                        return null;
 262                    }
 263                }
 264
 5265                if (child.IsDirectory)
 266                {
 0267                    leftOver.Add(child);
 268                }
 5269                else if (!IsIgnoredRegex().IsMatch(child.Name))
 270                {
 5271                    files.Add(child);
 272                }
 273            }
 274
 2275            var videoInfos = files
 2276                .Select(i => VideoResolver.Resolve(i.FullName, i.IsDirectory, NamingOptions, parseName, parent.Containin
 2277                .Where(f => f is not null)
 2278                .ToList();
 279
 2280            var resolverResult = _videoListResolver.Resolve(videoInfos, supportMultiEditions, parseName, parent.Containi
 281
 2282            var result = new MultiItemResolverResult
 2283            {
 2284                ExtraFiles = leftOver
 2285            };
 286
 2287            var isInMixedFolder = resolverResult.Count > 1 || parent?.IsTopParent == true;
 288
 10289            foreach (var video in resolverResult)
 290            {
 3291                var firstVideo = video.Files[0];
 3292                var path = firstVideo.Path;
 3293                if (video.ExtraType is not null)
 294                {
 0295                    result.ExtraFiles.Add(files.Find(f => string.Equals(f.FullName, path, StringComparison.OrdinalIgnore
 0296                    continue;
 297                }
 298
 3299                var additionalParts = video.Files.Count > 1 ? video.Files.Skip(1).Select(i => i.Path).ToArray() : Array.
 300
 3301                var videoItem = new T
 3302                {
 3303                    Path = path,
 3304                    IsInMixedFolder = isInMixedFolder,
 3305                    ProductionYear = video.Year,
 3306                    Name = parseName ? video.Name : firstVideo.Name,
 3307                    AdditionalParts = additionalParts,
 3308                    LocalAlternateVersions = video.AlternateVersions.Select(av => av.Files[0].Path).ToArray()
 3309                };
 310
 3311                SetVideoType(videoItem, firstVideo);
 3312                Set3DFormat(videoItem, firstVideo);
 313
 3314                result.Items.Add(videoItem);
 315            }
 316
 2317            result.ExtraFiles.AddRange(files.Where(i => !ContainsFile(resolverResult, i)));
 318
 2319            return result;
 0320        }
 321
 322        private static bool ContainsFile(IReadOnlyList<VideoInfo> result, FileSystemMetadata file)
 323        {
 12324            for (var i = 0; i < result.Count; i++)
 325            {
 6326                var current = result[i];
 18327                for (var j = 0; j < current.Files.Count; j++)
 328                {
 6329                    if (ContainsFile(current.Files[j], file))
 330                    {
 3331                        return true;
 332                    }
 333                }
 334
 8335                for (var j = 0; j < current.AlternateVersions.Count; j++)
 336                {
 3337                    var alternate = current.AlternateVersions[j];
 8338                    for (var k = 0; k < alternate.Files.Count; k++)
 339                    {
 3340                        if (ContainsFile(alternate.Files[k], file))
 341                        {
 2342                            return true;
 343                        }
 344                    }
 345                }
 346            }
 347
 0348            return false;
 349        }
 350
 351        private static bool ContainsFile(VideoFileInfo result, FileSystemMetadata file)
 352        {
 9353            return string.Equals(result.Path, file.FullName, StringComparison.OrdinalIgnoreCase);
 354        }
 355
 356        /// <summary>
 357        /// Sets the initial item values.
 358        /// </summary>
 359        /// <param name="item">The item.</param>
 360        /// <param name="args">The args.</param>
 361        protected override void SetInitialItemValues(Video item, ItemResolveArgs args)
 362        {
 3363            base.SetInitialItemValues(item, args);
 364
 3365            SetProviderIdsFromPath(item);
 3366        }
 367
 368        /// <summary>
 369        /// Sets the provider id from path.
 370        /// </summary>
 371        /// <param name="item">The item.</param>
 372        private static void SetProviderIdsFromPath(Video item)
 373        {
 3374            if (item is Movie || item is MusicVideo)
 375            {
 376                // We need to only look at the name of this actual item (not parents)
 1377                var justName = item.IsInMixedFolder ? Path.GetFileName(item.Path.AsSpan()) : Path.GetFileName(item.Conta
 378
 379                // The fallback filename is only used when the item isn't in a mixed folder
 1380                var fileName = item.IsInMixedFolder ? ReadOnlySpan<char>.Empty : Path.GetFileName(item.Path.AsSpan());
 381
 1382                item.TrySetProviderId(MetadataProvider.Tmdb, GetIdFromNameOrPath(justName, fileName, "tmdbid"));
 1383                item.TrySetProviderId(MetadataProvider.Tvdb, GetIdFromNameOrPath(justName, fileName, "tvdbid"));
 384
 385                string GetIdFromNameOrPath(ReadOnlySpan<char> name, ReadOnlySpan<char> fallbackName, string attribute)
 386                {
 387                    var id = name.GetAttributeValue(attribute);
 388
 389                    // If not in a mixed folder and ID not found in folder path, check filename
 390                    if (string.IsNullOrEmpty(id) && !item.IsInMixedFolder)
 391                    {
 392                        id = fallbackName.GetAttributeValue(attribute);
 393                    }
 394
 395                    return id;
 396                }
 397
 1398                if (!string.IsNullOrEmpty(item.Path))
 399                {
 400                    // Check for IMDb id - we use full media path, as we can assume that this will match in any use case
 1401                    var imdbid = item.Path.AsSpan().GetAttributeValue("imdbid");
 1402                    item.TrySetProviderId(MetadataProvider.Imdb, imdbid);
 403                }
 404            }
 3405        }
 406
 407        /// <summary>
 408        /// Finds a movie based on a child file system entries.
 409        /// </summary>
 410        /// <returns>Movie.</returns>
 411        private T FindMovie<T>(ItemResolveArgs args, string path, Folder parent, List<FileSystemMetadata> fileSystemEntr
 412            where T : Video, new()
 413        {
 0414            var multiDiscFolders = new List<FileSystemMetadata>();
 415
 0416            var libraryOptions = args.LibraryOptions;
 0417            var supportPhotos = collectionType == CollectionType.homevideos && libraryOptions.EnablePhotos;
 0418            var photos = new List<FileSystemMetadata>();
 419
 420            // Search for a folder rip
 0421            foreach (var child in fileSystemEntries)
 422            {
 0423                var filename = child.Name;
 424
 0425                if (child.IsDirectory)
 426                {
 0427                    if (NamingOptions.AllExtrasTypesFolderNames.ContainsKey(filename))
 428                    {
 429                        continue;
 430                    }
 431
 0432                    if (IsDvdDirectory(child.FullName, filename, directoryService))
 433                    {
 0434                        var movie = new T
 0435                        {
 0436                            Path = path,
 0437                            VideoType = VideoType.Dvd
 0438                        };
 0439                        Set3DFormat(movie);
 0440                        return movie;
 441                    }
 442
 0443                    if (IsBluRayDirectory(filename))
 444                    {
 0445                        var movie = new T
 0446                        {
 0447                            Path = path,
 0448                            VideoType = VideoType.BluRay
 0449                        };
 0450                        Set3DFormat(movie);
 0451                        return movie;
 452                    }
 453
 0454                    multiDiscFolders.Add(child);
 455                }
 0456                else if (IsDvdFile(filename))
 457                {
 0458                    var movie = new T
 0459                    {
 0460                        Path = path,
 0461                        VideoType = VideoType.Dvd
 0462                    };
 0463                    Set3DFormat(movie);
 0464                    return movie;
 465                }
 0466                else if (supportPhotos && PhotoResolver.IsImageFile(child.FullName, _imageProcessor))
 467                {
 0468                    photos.Add(child);
 469                }
 470            }
 471
 472            // TODO: Allow GetMultiDiscMovie in here
 473            const bool SupportsMultiVersion = true;
 474
 0475            var result = ResolveVideos<T>(parent, fileSystemEntries, SupportsMultiVersion, collectionType, parseName) ??
 0476                new MultiItemResolverResult();
 477
 0478            var isPhotosCollection = collectionType == CollectionType.homevideos || collectionType == CollectionType.pho
 0479            if (!isPhotosCollection && result.Items.Count == 1)
 480            {
 0481                var videoPath = result.Items[0].Path;
 0482                var hasPhotos = photos.Any(i => !PhotoResolver.IsOwnedByResolvedMedia(videoPath, i.Name));
 0483                var hasOtherSubfolders = multiDiscFolders.Count > 0;
 484
 0485                if (!hasPhotos && !hasOtherSubfolders)
 486                {
 0487                    var movie = (T)result.Items[0];
 0488                    movie.IsInMixedFolder = false;
 0489                    if (collectionType == CollectionType.movies || collectionType is null)
 490                    {
 0491                        movie.Name = Path.GetFileName(movie.ContainingFolderPath);
 492                    }
 493
 0494                    return movie;
 495                }
 496            }
 0497            else if (result.Items.Count == 0 && multiDiscFolders.Count > 0)
 498            {
 0499                return GetMultiDiscMovie<T>(multiDiscFolders, directoryService);
 500            }
 501
 0502            return null;
 0503        }
 504
 505        /// <summary>
 506        /// Gets the multi disc movie.
 507        /// </summary>
 508        /// <param name="multiDiscFolders">The folders.</param>
 509        /// <param name="directoryService">The directory service.</param>
 510        /// <returns>``0.</returns>
 511        private T GetMultiDiscMovie<T>(List<FileSystemMetadata> multiDiscFolders, IDirectoryService directoryService)
 512               where T : Video, new()
 513        {
 0514            var videoTypes = new List<VideoType>();
 515
 0516            var folderPaths = multiDiscFolders.Select(i => i.FullName).Where(i =>
 0517            {
 0518                var subFileEntries = directoryService.GetFileSystemEntries(i);
 0519
 0520                var subfolders = subFileEntries
 0521                    .Where(e => e.IsDirectory)
 0522                    .ToList();
 0523
 0524                if (subfolders.Any(s => IsDvdDirectory(s.FullName, s.Name, directoryService)))
 0525                {
 0526                    videoTypes.Add(VideoType.Dvd);
 0527                    return true;
 0528                }
 0529
 0530                if (subfolders.Any(s => IsBluRayDirectory(s.Name)))
 0531                {
 0532                    videoTypes.Add(VideoType.BluRay);
 0533                    return true;
 0534                }
 0535
 0536                var subFiles = subFileEntries
 0537                 .Where(e => !e.IsDirectory)
 0538                 .Select(d => d.Name);
 0539
 0540                if (subFiles.Any(IsDvdFile))
 0541                {
 0542                    videoTypes.Add(VideoType.Dvd);
 0543                    return true;
 0544                }
 0545
 0546                return false;
 0547            }).Order().ToList();
 548
 549            // If different video types were found, don't allow this
 0550            if (videoTypes.Distinct().Count() > 1)
 551            {
 0552                return null;
 553            }
 554
 0555            if (folderPaths.Count == 0)
 556            {
 0557                return null;
 558            }
 559
 0560            var result = StackResolver.ResolveDirectories(folderPaths, NamingOptions).ToList();
 561
 0562            if (result.Count != 1)
 563            {
 0564                return null;
 565            }
 566
 0567            int additionalPartsLen = folderPaths.Count - 1;
 0568            var additionalParts = new string[additionalPartsLen];
 0569            folderPaths.CopyTo(1, additionalParts, 0, additionalPartsLen);
 570
 0571            var returnVideo = new T
 0572            {
 0573                Path = folderPaths[0],
 0574                AdditionalParts = additionalParts,
 0575                VideoType = videoTypes[0],
 0576                Name = result[0].Name
 0577            };
 578
 0579            SetIsoType(returnVideo);
 580
 0581            return returnVideo;
 582        }
 583
 584        private bool IsInvalid(Folder parent, CollectionType? collectionType)
 585        {
 72586            if (parent is not null)
 587            {
 72588                if (parent.IsRoot)
 589                {
 70590                    return true;
 591                }
 592            }
 593
 2594            if (collectionType is null)
 595            {
 0596                return false;
 597            }
 598
 2599            return !_validCollectionTypes.Contains(collectionType.Value);
 600        }
 601    }
 602}
Generated by: ReportGenerator 5.5.10.0
7/26/2026 - 12:17:51 AM
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(MediaBrowser.Controller.Drawing.IImageProcessor,Microsoft.Extensions.Logging.ILogger`1<Emby.Server.Implementations.Library.Resolvers.Movies.MovieResolver>,Emby.Naming.Common.NamingOptions,MediaBrowser.Controller.Providers.IDirectoryService,Emby.Naming.Video.VideoListResolver)
get_Priority()
ResolveMultiple(MediaBrowser.Controller.Entities.Folder,System.Collections.Generic.List`1<MediaBrowser.Model.IO.FileSystemMetadata>,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,MediaBrowser.Controller.Providers.IDirectoryService)
Resolve(MediaBrowser.Controller.Library.ItemResolveArgs)
ResolveMultipleInternal(MediaBrowser.Controller.Entities.Folder,System.Collections.Generic.List`1<MediaBrowser.Model.IO.FileSystemMetadata>,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>)
ResolveVideos(MediaBrowser.Controller.Entities.Folder,System.Collections.Generic.IEnumerable`1<MediaBrowser.Model.IO.FileSystemMetadata>,System.Boolean,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,System.Boolean)
ContainsFile(System.Collections.Generic.IReadOnlyList`1<Emby.Naming.Video.VideoInfo>,MediaBrowser.Model.IO.FileSystemMetadata)
ContainsFile(Emby.Naming.Video.VideoFileInfo,MediaBrowser.Model.IO.FileSystemMetadata)
SetInitialItemValues(MediaBrowser.Controller.Entities.Video,MediaBrowser.Controller.Library.ItemResolveArgs)
SetProviderIdsFromPath(MediaBrowser.Controller.Entities.Video)
FindMovie(MediaBrowser.Controller.Library.ItemResolveArgs,System.String,MediaBrowser.Controller.Entities.Folder,System.Collections.Generic.List`1<MediaBrowser.Model.IO.FileSystemMetadata>,MediaBrowser.Controller.Providers.IDirectoryService,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>,System.Boolean)
GetMultiDiscMovie(System.Collections.Generic.List`1<MediaBrowser.Model.IO.FileSystemMetadata>,MediaBrowser.Controller.Providers.IDirectoryService)
IsInvalid(MediaBrowser.Controller.Entities.Folder,System.Nullable`1<Jellyfin.Data.Enums.CollectionType>)