jellyfin/MediaBrowser.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs

425 lines
15 KiB
C#
Raw Normal View History

2013-02-21 01:33:05 +00:00
using MediaBrowser.Common.Extensions;
2014-07-26 17:30:15 +00:00
using MediaBrowser.Common.IO;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Controller;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Library;
2014-02-13 05:11:54 +00:00
using MediaBrowser.Controller.Providers;
using MediaBrowser.Controller.Resolvers;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities;
2014-07-13 04:55:56 +00:00
using MediaBrowser.Model.Logging;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
2014-11-18 02:48:22 +00:00
using MediaBrowser.Naming.Audio;
using MediaBrowser.Naming.Video;
2013-02-21 01:33:05 +00:00
namespace MediaBrowser.Server.Implementations.Library.Resolvers.Movies
2013-02-21 01:33:05 +00:00
{
/// <summary>
/// Class MovieResolver
/// </summary>
public class MovieResolver : BaseVideoResolver<Video>
2013-02-21 01:33:05 +00:00
{
private readonly IServerApplicationPaths _applicationPaths;
private readonly ILogger _logger;
2014-07-26 17:30:15 +00:00
private readonly IFileSystem _fileSystem;
2014-11-16 20:44:08 +00:00
public MovieResolver(ILibraryManager libraryManager, IServerApplicationPaths applicationPaths, ILogger logger, IFileSystem fileSystem) : base(libraryManager)
2013-03-04 05:43:06 +00:00
{
2014-11-16 20:44:08 +00:00
_applicationPaths = applicationPaths;
_logger = logger;
2014-07-26 17:30:15 +00:00
_fileSystem = fileSystem;
2013-03-04 05:43:06 +00:00
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the priority.
/// </summary>
/// <value>The priority.</value>
public override ResolverPriority Priority
{
get
{
// Give plugins a chance to catch iso's first
// Also since we have to loop through child files looking for videos,
// see if we can avoid some of that by letting other resolvers claim folders first
return ResolverPriority.Second;
}
}
/// <summary>
/// Resolves the specified args.
/// </summary>
/// <param name="args">The args.</param>
/// <returns>Video.</returns>
protected override Video Resolve(ItemResolveArgs args)
2013-02-21 01:33:05 +00:00
{
// Avoid expensive tests against VF's and all their children by not allowing this
if (args.Parent != null)
2013-02-21 01:33:05 +00:00
{
if (args.Parent.IsRoot)
2013-02-21 01:33:05 +00:00
{
return null;
}
}
var isDirectory = args.IsDirectory;
if (isDirectory)
{
// Since the looping is expensive, this is an optimization to help us avoid it
if (args.ContainsMetaFileByName("series.xml"))
{
return null;
}
}
var collectionType = args.GetCollectionType();
2013-06-16 19:02:57 +00:00
// Find movies with their own folders
if (isDirectory)
{
if (string.Equals(collectionType, CollectionType.Trailers, StringComparison.OrdinalIgnoreCase))
{
2014-10-23 04:26:01 +00:00
return FindMovie<Trailer>(args.Path, args.Parent, args.FileSystemChildren.ToList(), args.DirectoryService, false, false, collectionType);
}
2013-07-12 19:56:40 +00:00
if (string.Equals(collectionType, CollectionType.MusicVideos, StringComparison.OrdinalIgnoreCase))
{
2014-10-23 04:26:01 +00:00
return FindMovie<MusicVideo>(args.Path, args.Parent, args.FileSystemChildren.ToList(), args.DirectoryService, false, false, collectionType);
2013-07-12 19:56:40 +00:00
}
2013-12-29 05:32:03 +00:00
if (string.Equals(collectionType, CollectionType.HomeVideos, StringComparison.OrdinalIgnoreCase))
{
2014-10-23 04:26:01 +00:00
return FindMovie<Video>(args.Path, args.Parent, args.FileSystemChildren.ToList(), args.DirectoryService, true, false, collectionType);
2013-12-29 05:32:03 +00:00
}
2013-08-29 21:00:27 +00:00
if (string.IsNullOrEmpty(collectionType) ||
string.Equals(collectionType, CollectionType.Movies, StringComparison.OrdinalIgnoreCase) ||
string.Equals(collectionType, CollectionType.BoxSets, StringComparison.OrdinalIgnoreCase))
2013-07-12 19:56:40 +00:00
{
2014-10-23 04:26:01 +00:00
return FindMovie<Movie>(args.Path, args.Parent, args.FileSystemChildren.ToList(), args.DirectoryService, true, true, collectionType);
}
2013-08-29 21:00:27 +00:00
return null;
2013-02-21 01:33:05 +00:00
}
var filename = Path.GetFileName(args.Path);
2014-09-22 21:56:54 +00:00
// Don't misidentify extras or trailers
if (BaseItem.ExtraSuffixes.Any(i => filename.IndexOf(i.Key, StringComparison.OrdinalIgnoreCase) != -1))
{
return null;
}
// Find movies that are mixed in the same folder
2014-03-31 21:04:22 +00:00
if (string.Equals(collectionType, CollectionType.Trailers, StringComparison.OrdinalIgnoreCase))
{
return ResolveVideo<Trailer>(args);
}
Video item = null;
2014-03-31 21:04:22 +00:00
if (string.Equals(collectionType, CollectionType.MusicVideos, StringComparison.OrdinalIgnoreCase))
{
item = ResolveVideo<MusicVideo>(args);
}
// To find a movie file, the collection type must be movies or boxsets
// Otherwise we'll consider it a plain video and let the video resolver handle it
if (string.Equals(collectionType, CollectionType.Movies, StringComparison.OrdinalIgnoreCase) ||
string.Equals(collectionType, CollectionType.BoxSets, StringComparison.OrdinalIgnoreCase))
{
item = ResolveVideo<Movie>(args);
}
if (item != null)
{
item.IsInMixedFolder = true;
}
return item;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Sets the initial item values.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="args">The args.</param>
protected override void SetInitialItemValues(Video item, ItemResolveArgs args)
2013-02-21 01:33:05 +00:00
{
base.SetInitialItemValues(item, args);
SetProviderIdFromPath(item);
}
/// <summary>
/// Sets the provider id from path.
/// </summary>
/// <param name="item">The item.</param>
private void SetProviderIdFromPath(Video item)
2013-02-21 01:33:05 +00:00
{
//we need to only look at the name of this actual item (not parents)
var justName = item.IsInMixedFolder ? Path.GetFileName(item.Path) : Path.GetFileName(item.ContainingFolderPath);
2013-02-21 01:33:05 +00:00
var id = justName.GetAttributeValue("tmdbid");
if (!string.IsNullOrEmpty(id))
{
item.SetProviderId(MetadataProviders.Tmdb, id);
}
}
/// <summary>
/// Finds a movie based on a child file system entries
/// </summary>
2013-06-16 19:02:57 +00:00
/// <typeparam name="T"></typeparam>
/// <param name="path">The path.</param>
2013-12-30 02:41:22 +00:00
/// <param name="parent">The parent.</param>
2013-06-16 19:02:57 +00:00
/// <param name="fileSystemEntries">The file system entries.</param>
/// <param name="directoryService">The directory service.</param>
/// <param name="supportMultiFileItems">if set to <c>true</c> [support multi file items].</param>
2013-02-21 01:33:05 +00:00
/// <returns>Movie.</returns>
2014-10-23 04:26:01 +00:00
private T FindMovie<T>(string path, Folder parent, List<FileSystemInfo> fileSystemEntries, IDirectoryService directoryService, bool supportMultiFileItems, bool supportsMultipleSources, string collectionType)
2013-06-16 19:02:57 +00:00
where T : Video, new()
2013-02-21 01:33:05 +00:00
{
var movies = new List<T>();
2013-02-21 01:33:05 +00:00
2013-06-16 19:02:57 +00:00
var multiDiscFolders = new List<FileSystemInfo>();
2013-02-21 01:33:05 +00:00
// Loop through each child file/folder and see if we find a video
2013-06-16 19:02:57 +00:00
foreach (var child in fileSystemEntries)
2013-02-21 01:33:05 +00:00
{
2013-06-20 02:23:07 +00:00
var filename = child.Name;
if ((child.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
2013-02-21 01:33:05 +00:00
{
2013-06-20 02:23:07 +00:00
if (IsDvdDirectory(filename))
2013-02-21 01:33:05 +00:00
{
return new T
2013-02-21 01:33:05 +00:00
{
2013-06-16 19:02:57 +00:00
Path = path,
2013-02-21 01:33:05 +00:00
VideoType = VideoType.Dvd
};
}
2013-06-20 02:23:07 +00:00
if (IsBluRayDirectory(filename))
2013-02-21 01:33:05 +00:00
{
return new T
2013-02-21 01:33:05 +00:00
{
2013-06-16 19:02:57 +00:00
Path = path,
2013-02-21 01:33:05 +00:00
VideoType = VideoType.BluRay
};
}
2013-06-16 19:02:57 +00:00
2014-11-18 02:48:22 +00:00
multiDiscFolders.Add(child);
2013-02-21 01:33:05 +00:00
continue;
}
2014-09-22 21:56:54 +00:00
// Don't misidentify extras or trailers as a movie
if (BaseItem.ExtraSuffixes.Any(i => filename.IndexOf(i.Key, StringComparison.OrdinalIgnoreCase) != -1))
{
continue;
}
2014-11-16 20:44:08 +00:00
var childArgs = new ItemResolveArgs(_applicationPaths, LibraryManager, directoryService)
2013-02-21 01:33:05 +00:00
{
FileInfo = child,
2013-12-30 02:41:22 +00:00
Path = child.FullName,
2014-10-23 04:26:01 +00:00
Parent = parent,
CollectionType = collectionType
2013-02-21 01:33:05 +00:00
};
var item = ResolveVideo<T>(childArgs);
2013-02-21 01:33:05 +00:00
if (item != null)
{
2013-08-16 20:13:45 +00:00
item.IsInMixedFolder = false;
2013-02-21 01:33:05 +00:00
movies.Add(item);
}
}
if (movies.Count > 1)
{
if (supportMultiFileItems)
{
var result = GetMultiFileMovie(movies);
if (result != null)
{
return result;
}
}
2014-03-22 16:16:43 +00:00
if (supportsMultipleSources)
{
2014-03-22 16:16:43 +00:00
var result = GetMovieWithMultipleSources(movies);
if (result != null)
{
return result;
}
}
return null;
}
2013-06-16 19:02:57 +00:00
if (movies.Count == 1)
{
return movies[0];
}
if (multiDiscFolders.Count > 0)
{
2014-11-18 02:48:22 +00:00
return GetMultiDiscMovie<T>(multiDiscFolders, directoryService);
2013-06-16 19:02:57 +00:00
}
return null;
2013-02-21 01:33:05 +00:00
}
2013-06-16 19:02:57 +00:00
/// <summary>
/// Gets the multi disc movie.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="multiDiscFolders">The folders.</param>
2014-11-18 02:48:22 +00:00
/// <param name="directoryService">The directory service.</param>
2013-06-16 19:02:57 +00:00
/// <returns>``0.</returns>
2014-11-18 02:48:22 +00:00
private T GetMultiDiscMovie<T>(List<FileSystemInfo> multiDiscFolders, IDirectoryService directoryService)
2013-06-16 19:02:57 +00:00
where T : Video, new()
{
var videoTypes = new List<VideoType>();
2013-06-16 19:02:57 +00:00
var folderPaths = multiDiscFolders.Select(i => i.FullName).Where(i =>
2013-06-16 19:02:57 +00:00
{
2014-11-18 02:48:22 +00:00
var subfolders = directoryService.GetDirectories(i)
.Select(d => d.Name)
.ToList();
2013-06-16 19:02:57 +00:00
if (subfolders.Any(IsDvdDirectory))
{
videoTypes.Add(VideoType.Dvd);
2013-06-16 19:02:57 +00:00
return true;
}
if (subfolders.Any(IsBluRayDirectory))
{
videoTypes.Add(VideoType.BluRay);
2013-06-16 19:02:57 +00:00
return true;
}
return false;
2013-06-20 02:23:07 +00:00
}).OrderBy(i => i).ToList();
2013-06-16 19:02:57 +00:00
// If different video types were found, don't allow this
2014-11-18 02:48:22 +00:00
if (videoTypes.Distinct().Count() > 1)
{
return null;
}
2013-06-20 02:23:07 +00:00
if (folderPaths.Count == 0)
2013-06-16 19:02:57 +00:00
{
return null;
}
2014-11-18 02:48:22 +00:00
var resolver = new StackResolver(new ExpandedVideoOptions(), new AudioOptions(), new Naming.Logging.NullLogger());
2014-11-18 02:48:22 +00:00
var result = resolver.ResolveDirectories(folderPaths);
2014-11-18 02:48:22 +00:00
if (result.Stacks.Count != 1)
{
return null;
}
2014-11-18 02:48:22 +00:00
2013-06-16 19:02:57 +00:00
return new T
{
2013-06-20 02:23:07 +00:00
Path = folderPaths[0],
2013-06-16 19:02:57 +00:00
IsMultiPart = true,
2014-11-18 02:48:22 +00:00
VideoType = videoTypes[0],
Name = result.Stacks[0].Name
2013-06-16 19:02:57 +00:00
};
}
/// <summary>
/// Gets the multi file movie.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="movies">The movies.</param>
/// <returns>``0.</returns>
2014-02-20 17:49:07 +00:00
private T GetMultiFileMovie<T>(IEnumerable<T> movies)
where T : Video, new()
{
2014-02-20 17:49:07 +00:00
var sortedMovies = movies.OrderBy(i => i.Path).ToList();
2014-02-20 17:49:07 +00:00
var firstMovie = sortedMovies[0];
2014-11-18 02:48:22 +00:00
var paths = sortedMovies.Select(i => i.Path).ToList();
2014-11-18 02:48:22 +00:00
var resolver = new StackResolver(new ExpandedVideoOptions(), new AudioOptions(), new Naming.Logging.NullLogger());
2014-11-18 02:48:22 +00:00
var result = resolver.ResolveFiles(paths);
if (result.Stacks.Count != 1)
{
return null;
}
2014-11-18 02:48:22 +00:00
firstMovie.IsMultiPart = true;
firstMovie.Name = result.Stacks[0].Name;
// They must all be part of the sequence if we're going to consider it a multi-part movie
return firstMovie;
}
2014-03-22 16:16:43 +00:00
private T GetMovieWithMultipleSources<T>(IEnumerable<T> movies)
where T : Video, new()
{
2014-03-21 16:55:47 +00:00
var sortedMovies = movies.OrderBy(i => i.Path).ToList();
// Cap this at five to help avoid incorrect matching
if (sortedMovies.Count > 5)
{
return null;
}
var firstMovie = sortedMovies[0];
2014-03-21 16:55:47 +00:00
var filenamePrefix = Path.GetFileName(Path.GetDirectoryName(firstMovie.Path));
if (!string.IsNullOrWhiteSpace(filenamePrefix))
{
2014-07-26 17:30:15 +00:00
if (sortedMovies.All(i => _fileSystem.GetFileNameWithoutExtension(i.Path).StartsWith(filenamePrefix + " - ", StringComparison.OrdinalIgnoreCase)))
{
firstMovie.HasLocalAlternateVersions = true;
2014-05-05 00:46:52 +00:00
_logger.Debug("Multi-version video found: " + firstMovie.Path);
return firstMovie;
}
2014-02-20 17:49:07 +00:00
}
2014-02-20 17:49:07 +00:00
return null;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Determines whether [is DVD directory] [the specified directory name].
/// </summary>
/// <param name="directoryName">Name of the directory.</param>
/// <returns><c>true</c> if [is DVD directory] [the specified directory name]; otherwise, <c>false</c>.</returns>
private bool IsDvdDirectory(string directoryName)
{
2013-11-21 16:02:49 +00:00
return string.Equals(directoryName, "video_ts", StringComparison.OrdinalIgnoreCase);
2013-02-21 01:33:05 +00:00
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Determines whether [is blu ray directory] [the specified directory name].
/// </summary>
/// <param name="directoryName">Name of the directory.</param>
/// <returns><c>true</c> if [is blu ray directory] [the specified directory name]; otherwise, <c>false</c>.</returns>
private bool IsBluRayDirectory(string directoryName)
{
2013-11-21 16:02:49 +00:00
return string.Equals(directoryName, "bdmv", StringComparison.OrdinalIgnoreCase);
2013-02-21 01:33:05 +00:00
}
}
}