From 3eb4091808735858b01855d298226d239be464af Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Thu, 3 Nov 2016 02:37:52 -0400
Subject: move additional classes to new server lib

---
 .../Library/Resolvers/Audio/AudioResolver.cs       |  68 +++
 .../Library/Resolvers/Audio/MusicAlbumResolver.cs  | 173 +++++++
 .../Library/Resolvers/Audio/MusicArtistResolver.cs |  94 ++++
 .../Library/Resolvers/BaseVideoResolver.cs         | 297 +++++++++++
 .../Library/Resolvers/FolderResolver.cs            |  56 +++
 .../Library/Resolvers/ItemResolver.cs              |  62 +++
 .../Library/Resolvers/Movies/BoxSetResolver.cs     |  77 +++
 .../Library/Resolvers/Movies/MovieResolver.cs      | 541 +++++++++++++++++++++
 .../Library/Resolvers/PhotoAlbumResolver.cs        |  56 +++
 .../Library/Resolvers/PhotoResolver.cs             | 103 ++++
 .../Library/Resolvers/PlaylistResolver.cs          |  42 ++
 .../Library/Resolvers/SpecialFolderResolver.cs     |  85 ++++
 .../Library/Resolvers/TV/EpisodeResolver.cs        |  75 +++
 .../Library/Resolvers/TV/SeasonResolver.cs         |  62 +++
 .../Library/Resolvers/TV/SeriesResolver.cs         | 251 ++++++++++
 .../Library/Resolvers/VideoResolver.cs             |  45 ++
 16 files changed, 2087 insertions(+)
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/Audio/AudioResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/FolderResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/ItemResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/Movies/BoxSetResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/PhotoAlbumResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/PhotoResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/SpecialFolderResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/TV/EpisodeResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs
 create mode 100644 Emby.Server.Implementations/Library/Resolvers/VideoResolver.cs

(limited to 'Emby.Server.Implementations/Library/Resolvers')

diff --git a/Emby.Server.Implementations/Library/Resolvers/Audio/AudioResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Audio/AudioResolver.cs
new file mode 100644
index 000000000..d8805355a
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/Audio/AudioResolver.cs
@@ -0,0 +1,68 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using System;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Audio
+{
+    /// <summary>
+    /// Class AudioResolver
+    /// </summary>
+    public class AudioResolver : ItemResolver<MediaBrowser.Controller.Entities.Audio.Audio>
+    {
+        private readonly ILibraryManager _libraryManager;
+
+        public AudioResolver(ILibraryManager libraryManager)
+        {
+            _libraryManager = libraryManager;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority
+        {
+            get { return ResolverPriority.Last; }
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Entities.Audio.Audio.</returns>
+        protected override MediaBrowser.Controller.Entities.Audio.Audio Resolve(ItemResolveArgs args)
+        {
+            // Return audio if the path is a file and has a matching extension
+
+            if (!args.IsDirectory)
+            {
+                var libraryOptions = args.GetLibraryOptions();
+
+                if (_libraryManager.IsAudioFile(args.Path, libraryOptions))
+                {
+                    var collectionType = args.GetCollectionType();
+
+                    var isMixed = string.IsNullOrWhiteSpace(collectionType);
+
+                    // For conflicting extensions, give priority to videos
+                    if (isMixed && _libraryManager.IsVideoFile(args.Path, libraryOptions))
+                    {
+                        return null;
+                    }
+
+                    var isStandalone = args.Parent == null;
+
+                    if (isStandalone ||
+                        string.Equals(collectionType, CollectionType.Music, StringComparison.OrdinalIgnoreCase) ||
+                        isMixed)
+                    {
+                        return new MediaBrowser.Controller.Entities.Audio.Audio();
+                    }
+                }
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
new file mode 100644
index 000000000..f8e105195
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
@@ -0,0 +1,173 @@
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Naming.Audio;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Emby.Server.Implementations.Logging;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Audio
+{
+    /// <summary>
+    /// Class MusicAlbumResolver
+    /// </summary>
+    public class MusicAlbumResolver : ItemResolver<MusicAlbum>
+    {
+        private readonly ILogger _logger;
+        private readonly IFileSystem _fileSystem;
+        private readonly ILibraryManager _libraryManager;
+
+        public MusicAlbumResolver(ILogger logger, IFileSystem fileSystem, ILibraryManager libraryManager)
+        {
+            _logger = logger;
+            _fileSystem = fileSystem;
+            _libraryManager = libraryManager;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority
+        {
+            get
+            {
+                // Behind special folder resolver
+                return ResolverPriority.Second;
+            } 
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>MusicAlbum.</returns>
+        protected override MusicAlbum Resolve(ItemResolveArgs args)
+        {
+            if (!args.IsDirectory) return null;
+
+            // Avoid mis-identifying top folders
+            if (args.HasParent<MusicAlbum>()) return null;
+            if (args.Parent.IsRoot) return null;
+
+            var collectionType = args.GetCollectionType();
+
+            var isMusicMediaFolder = string.Equals(collectionType, CollectionType.Music, StringComparison.OrdinalIgnoreCase);
+
+            // If there's a collection type and it's not music, don't allow it.
+            if (!isMusicMediaFolder)
+            {
+                return null;
+            }
+
+            return IsMusicAlbum(args) ? new MusicAlbum() : null;
+        }
+
+
+        /// <summary>
+        /// Determine if the supplied file data points to a music album
+        /// </summary>
+        public bool IsMusicAlbum(string path, IDirectoryService directoryService, LibraryOptions libraryOptions)
+        {
+            return ContainsMusic(directoryService.GetFileSystemEntries(path), true, directoryService, _logger, _fileSystem, libraryOptions, _libraryManager);
+        }
+
+        /// <summary>
+        /// Determine if the supplied resolve args should be considered a music album
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns><c>true</c> if [is music album] [the specified args]; otherwise, <c>false</c>.</returns>
+        private bool IsMusicAlbum(ItemResolveArgs args)
+        {
+            // Args points to an album if parent is an Artist folder or it directly contains music
+            if (args.IsDirectory)
+            {
+                //if (args.Parent is MusicArtist) return true;  //saves us from testing children twice
+                if (ContainsMusic(args.FileSystemChildren, true, args.DirectoryService, _logger, _fileSystem, args.GetLibraryOptions(), _libraryManager)) return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Determine if the supplied list contains what we should consider music
+        /// </summary>
+        private bool ContainsMusic(IEnumerable<FileSystemMetadata> list,
+            bool allowSubfolders,
+            IDirectoryService directoryService,
+            ILogger logger,
+            IFileSystem fileSystem,
+            LibraryOptions libraryOptions,
+            ILibraryManager libraryManager)
+        {
+            var discSubfolderCount = 0;
+            var notMultiDisc = false;
+
+            foreach (var fileSystemInfo in list)
+            {
+                if (fileSystemInfo.IsDirectory)
+                {
+                    if (allowSubfolders)
+                    {
+                        var path = fileSystemInfo.FullName;
+                        var isMultiDisc = IsMultiDiscFolder(path, libraryOptions);
+
+                        if (isMultiDisc)
+                        {
+                            var hasMusic = ContainsMusic(directoryService.GetFileSystemEntries(path), false, directoryService, logger, fileSystem, libraryOptions, libraryManager);
+
+                            if (hasMusic)
+                            {
+                                logger.Debug("Found multi-disc folder: " + path);
+                                discSubfolderCount++;
+                            }
+                        }
+                        else
+                        {
+                            var hasMusic = ContainsMusic(directoryService.GetFileSystemEntries(path), false, directoryService, logger, fileSystem, libraryOptions, libraryManager);
+
+                            if (hasMusic)
+                            {
+                                // If there are folders underneath with music that are not multidisc, then this can't be a multi-disc album
+                                notMultiDisc = true;
+                            }
+                        }
+                    }
+                }
+
+                var fullName = fileSystemInfo.FullName;
+
+                if (libraryManager.IsAudioFile(fullName, libraryOptions))
+                {
+                    return true;
+                }
+            }
+
+            if (notMultiDisc)
+            {
+                return false;
+            }
+
+            return discSubfolderCount > 0;
+        }
+
+        private bool IsMultiDiscFolder(string path, LibraryOptions libraryOptions)
+        {
+            var namingOptions = ((LibraryManager)_libraryManager).GetNamingOptions(libraryOptions);
+
+            var parser = new AlbumParser(namingOptions, new PatternsLogger());
+            var result = parser.ParseMultiPart(path);
+
+            return result.IsMultiPart;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
new file mode 100644
index 000000000..2971405b9
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
@@ -0,0 +1,94 @@
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using System;
+using System.IO;
+using System.Linq;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.IO;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Audio
+{
+    /// <summary>
+    /// Class MusicArtistResolver
+    /// </summary>
+    public class MusicArtistResolver : ItemResolver<MusicArtist>
+    {
+        private readonly ILogger _logger;
+        private readonly IFileSystem _fileSystem;
+        private readonly ILibraryManager _libraryManager;
+        private readonly IServerConfigurationManager _config;
+
+        public MusicArtistResolver(ILogger logger, IFileSystem fileSystem, ILibraryManager libraryManager, IServerConfigurationManager config)
+        {
+            _logger = logger;
+            _fileSystem = fileSystem;
+            _libraryManager = libraryManager;
+            _config = config;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority
+        {
+            get
+            {
+                // Behind special folder resolver
+                return ResolverPriority.Second;
+            } 
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>MusicArtist.</returns>
+        protected override MusicArtist Resolve(ItemResolveArgs args)
+        {
+            if (!args.IsDirectory) return null;
+
+            // Don't allow nested artists
+            if (args.HasParent<MusicArtist>() || args.HasParent<MusicAlbum>())
+            {
+                return null;
+            }
+
+            var collectionType = args.GetCollectionType();
+
+            var isMusicMediaFolder = string.Equals(collectionType, CollectionType.Music, StringComparison.OrdinalIgnoreCase);
+
+            // If there's a collection type and it's not music, it can't be a series
+            if (!isMusicMediaFolder)
+            {
+                return null;
+            }
+
+            if (args.ContainsFileSystemEntryByName("artist.nfo"))
+            {
+                return new MusicArtist();
+            }
+
+            if (_config.Configuration.EnableSimpleArtistDetection)
+            {
+                return null;
+            }
+
+            // Avoid mis-identifying top folders
+            if (args.Parent.IsRoot) return null;
+
+            var directoryService = args.DirectoryService;
+
+            var albumResolver = new MusicAlbumResolver(_logger, _fileSystem, _libraryManager);
+
+            // If we contain an album assume we are an artist folder
+            return args.FileSystemChildren.Where(i => i.IsDirectory).Any(i => albumResolver.IsMusicAlbum(i.FullName, directoryService, args.GetLibraryOptions())) ? new MusicArtist() : null;
+        }
+
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs b/Emby.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs
new file mode 100644
index 000000000..b7819eb68
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs
@@ -0,0 +1,297 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Naming.Video;
+using System;
+using System.IO;
+using Emby.Server.Implementations.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Resolves a Path into a Video or Video subclass
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class BaseVideoResolver<T> : MediaBrowser.Controller.Resolvers.ItemResolver<T>
+        where T : Video, new()
+    {
+        protected readonly ILibraryManager LibraryManager;
+
+        protected BaseVideoResolver(ILibraryManager libraryManager)
+        {
+            LibraryManager = libraryManager;
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>`0.</returns>
+        protected override T Resolve(ItemResolveArgs args)
+        {
+            return ResolveVideo<T>(args, false);
+        }
+
+        /// <summary>
+        /// Resolves the video.
+        /// </summary>
+        /// <typeparam name="TVideoType">The type of the T video type.</typeparam>
+        /// <param name="args">The args.</param>
+        /// <param name="parseName">if set to <c>true</c> [parse name].</param>
+        /// <returns>``0.</returns>
+        protected TVideoType ResolveVideo<TVideoType>(ItemResolveArgs args, bool parseName)
+              where TVideoType : Video, new()
+        {
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+            
+            // If the path is a file check for a matching extensions
+            var parser = new MediaBrowser.Naming.Video.VideoResolver(namingOptions, new PatternsLogger());
+
+            if (args.IsDirectory)
+            {
+                TVideoType video = null;
+                VideoFileInfo videoInfo = null;
+
+                // Loop through each child file/folder and see if we find a video
+                foreach (var child in args.FileSystemChildren)
+                {
+                    var filename = child.Name;
+
+                    if (child.IsDirectory)
+                    {
+                        if (IsDvdDirectory(filename))
+                        {
+                            videoInfo = parser.ResolveDirectory(args.Path);
+
+                            if (videoInfo == null)
+                            {
+                                return null;
+                            }
+
+                            video = new TVideoType
+                            {
+                                Path = args.Path,
+                                VideoType = VideoType.Dvd,
+                                ProductionYear = videoInfo.Year
+                            };
+                            break;
+                        }
+                        if (IsBluRayDirectory(filename))
+                        {
+                            videoInfo = parser.ResolveDirectory(args.Path);
+
+                            if (videoInfo == null)
+                            {
+                                return null;
+                            }
+
+                            video = new TVideoType
+                            {
+                                Path = args.Path,
+                                VideoType = VideoType.BluRay,
+                                ProductionYear = videoInfo.Year
+                            };
+                            break;
+                        }
+                    }
+                    else if (IsDvdFile(filename))
+                    {
+                        videoInfo = parser.ResolveDirectory(args.Path);
+
+                        if (videoInfo == null)
+                        {
+                            return null;
+                        }
+
+                        video = new TVideoType
+                        {
+                            Path = args.Path,
+                            VideoType = VideoType.Dvd,
+                            ProductionYear = videoInfo.Year
+                        };
+                        break;
+                    }
+                }
+
+                if (video != null)
+                {
+                    video.Name = parseName ? 
+                        videoInfo.Name :
+                        Path.GetFileName(args.Path);
+
+                    Set3DFormat(video, videoInfo);
+                }
+
+                return video;
+            }
+            else
+            {
+                var videoInfo = parser.Resolve(args.Path, false, false);
+
+                if (videoInfo == null)
+                {
+                    return null;
+                }
+
+                if (LibraryManager.IsVideoFile(args.Path, args.GetLibraryOptions()) || videoInfo.IsStub)
+                {
+                    var path = args.Path;
+
+                    var video = new TVideoType
+                    {
+                        Path = path,
+                        IsInMixedFolder = true,
+                        ProductionYear = videoInfo.Year
+                    };
+
+                    SetVideoType(video, videoInfo);
+                    
+                    video.Name = parseName ?
+                        videoInfo.Name :
+                        Path.GetFileNameWithoutExtension(args.Path);
+
+                    Set3DFormat(video, videoInfo);
+
+                    return video;
+                }
+            }
+
+            return null;
+        }
+
+        protected void SetVideoType(Video video, VideoFileInfo videoInfo)
+        {
+            var extension = Path.GetExtension(video.Path);
+            video.VideoType = string.Equals(extension, ".iso", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(extension, ".img", StringComparison.OrdinalIgnoreCase) ?
+              VideoType.Iso :
+              VideoType.VideoFile;
+
+            video.IsShortcut = string.Equals(extension, ".strm", StringComparison.OrdinalIgnoreCase);
+            video.IsPlaceHolder = videoInfo.IsStub;
+
+            if (videoInfo.IsStub)
+            {
+                if (string.Equals(videoInfo.StubType, "dvd", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.VideoType = VideoType.Dvd;
+                }
+                else if (string.Equals(videoInfo.StubType, "hddvd", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.VideoType = VideoType.HdDvd;
+                    video.IsHD = true;
+                }
+                else if (string.Equals(videoInfo.StubType, "bluray", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.VideoType = VideoType.BluRay;
+                    video.IsHD = true;
+                }
+                else if (string.Equals(videoInfo.StubType, "hdtv", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.IsHD = true;
+                }
+            }
+
+            SetIsoType(video);
+        }
+
+        protected void SetIsoType(Video video)
+        {
+            if (video.VideoType == VideoType.Iso)
+            {
+                if (video.Path.IndexOf("dvd", StringComparison.OrdinalIgnoreCase) != -1)
+                {
+                    video.IsoType = IsoType.Dvd;
+                }
+                else if (video.Path.IndexOf("bluray", StringComparison.OrdinalIgnoreCase) != -1)
+                {
+                    video.IsoType = IsoType.BluRay;
+                }
+            }
+        }
+
+        protected void Set3DFormat(Video video, bool is3D, string format3D)
+        {
+            if (is3D)
+            {
+                if (string.Equals(format3D, "fsbs", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.Video3DFormat = Video3DFormat.FullSideBySide;
+                }
+                else if (string.Equals(format3D, "ftab", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.Video3DFormat = Video3DFormat.FullTopAndBottom;
+                }
+                else if (string.Equals(format3D, "hsbs", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.Video3DFormat = Video3DFormat.HalfSideBySide;
+                }
+                else if (string.Equals(format3D, "htab", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
+                }
+                else if (string.Equals(format3D, "sbs", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.Video3DFormat = Video3DFormat.HalfSideBySide;
+                }
+                else if (string.Equals(format3D, "sbs3d", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.Video3DFormat = Video3DFormat.HalfSideBySide;
+                }
+                else if (string.Equals(format3D, "tab", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
+                }
+                else if (string.Equals(format3D, "mvc", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.Video3DFormat = Video3DFormat.MVC;
+                }
+            }
+        }
+
+        protected void Set3DFormat(Video video, VideoFileInfo videoInfo)
+        {
+            Set3DFormat(video, videoInfo.Is3D, videoInfo.Format3D);
+        }
+
+        protected void Set3DFormat(Video video)
+        {
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+
+            var resolver = new Format3DParser(namingOptions, new PatternsLogger());
+            var result = resolver.Parse(video.Path);
+
+            Set3DFormat(video, result.Is3D, result.Format3D);
+        }
+
+        /// <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>
+        protected bool IsDvdDirectory(string directoryName)
+        {
+            return string.Equals(directoryName, "video_ts", StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Determines whether [is DVD file] [the specified name].
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <returns><c>true</c> if [is DVD file] [the specified name]; otherwise, <c>false</c>.</returns>
+        protected bool IsDvdFile(string name)
+        {
+            return string.Equals(name, "video_ts.ifo", StringComparison.OrdinalIgnoreCase);
+        }
+        
+        /// <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>
+        protected bool IsBluRayDirectory(string directoryName)
+        {
+            return string.Equals(directoryName, "bdmv", StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/FolderResolver.cs b/Emby.Server.Implementations/Library/Resolvers/FolderResolver.cs
new file mode 100644
index 000000000..5e73baa5c
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/FolderResolver.cs
@@ -0,0 +1,56 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Class FolderResolver
+    /// </summary>
+    public class FolderResolver : FolderResolver<Folder>
+    {
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority
+        {
+            get { return ResolverPriority.Last; }
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Folder.</returns>
+        protected override Folder Resolve(ItemResolveArgs args)
+        {
+            if (args.IsDirectory)
+            {
+                return new Folder();
+            }
+
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Class FolderResolver
+    /// </summary>
+    /// <typeparam name="TItemType">The type of the T item type.</typeparam>
+    public abstract class FolderResolver<TItemType> : ItemResolver<TItemType>
+        where TItemType : Folder, new()
+    {
+        /// <summary>
+        /// Sets the initial item values.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="args">The args.</param>
+        protected override void SetInitialItemValues(TItemType item, ItemResolveArgs args)
+        {
+            base.SetInitialItemValues(item, args);
+
+            item.IsRoot = args.Parent == null;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/ItemResolver.cs b/Emby.Server.Implementations/Library/Resolvers/ItemResolver.cs
new file mode 100644
index 000000000..b4a37be5f
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/ItemResolver.cs
@@ -0,0 +1,62 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Class ItemResolver
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class ItemResolver<T> : IItemResolver
+        where T : BaseItem, new()
+    {
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>`0.</returns>
+        protected virtual T Resolve(ItemResolveArgs args)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public virtual ResolverPriority Priority
+        {
+            get
+            {
+                return ResolverPriority.First;
+            }
+        }
+
+        /// <summary>
+        /// Sets initial values on the newly resolved item
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="args">The args.</param>
+        protected virtual void SetInitialItemValues(T item, ItemResolveArgs args)
+        {
+        }
+
+        /// <summary>
+        /// Resolves the path.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>BaseItem.</returns>
+        BaseItem IItemResolver.ResolvePath(ItemResolveArgs args)
+        {
+            var item = Resolve(args);
+
+            if (item != null)
+            {
+                SetInitialItemValues(item, args);
+            }
+
+            return item;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/Movies/BoxSetResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Movies/BoxSetResolver.cs
new file mode 100644
index 000000000..df441c5ed
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/Movies/BoxSetResolver.cs
@@ -0,0 +1,77 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using System;
+using System.IO;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Movies
+{
+    /// <summary>
+    /// Class BoxSetResolver
+    /// </summary>
+    public class BoxSetResolver : FolderResolver<BoxSet>
+    {
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>BoxSet.</returns>
+        protected override BoxSet Resolve(ItemResolveArgs args)
+        {
+            // It's a boxset if all of the following conditions are met:
+            // Is a Directory
+            // Contains [boxset] in the path
+            if (args.IsDirectory)
+            {
+                var filename = Path.GetFileName(args.Path);
+
+                if (string.IsNullOrEmpty(filename))
+                {
+                    return null;
+                }
+                
+                if (filename.IndexOf("[boxset]", StringComparison.OrdinalIgnoreCase) != -1 || 
+                    args.ContainsFileSystemEntryByName("collection.xml"))
+                {
+                    return new BoxSet
+                    {
+                        Path = args.Path,
+                        Name = ResolverHelper.StripBrackets(Path.GetFileName(args.Path))
+                    };
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Sets the initial item values.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="args">The args.</param>
+        protected override void SetInitialItemValues(BoxSet item, ItemResolveArgs args)
+        {
+            base.SetInitialItemValues(item, args);
+
+            SetProviderIdFromPath(item);
+        }
+
+        /// <summary>
+        /// Sets the provider id from path.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        private void SetProviderIdFromPath(BaseItem item)
+        {
+            //we need to only look at the name of this actual item (not parents)
+            var justName = Path.GetFileName(item.Path);
+
+            var id = justName.GetAttributeValue("tmdbid");
+
+            if (!string.IsNullOrEmpty(id))
+            {
+                item.SetProviderId(MetadataProviders.Tmdb, id);
+            }
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
new file mode 100644
index 000000000..d8c8b2024
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
@@ -0,0 +1,541 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Extensions;
+using MediaBrowser.Naming.Video;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Emby.Server.Implementations.Logging;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Movies
+{
+    /// <summary>
+    /// Class MovieResolver
+    /// </summary>
+    public class MovieResolver : BaseVideoResolver<Video>, IMultiItemResolver
+    {
+        public MovieResolver(ILibraryManager libraryManager)
+            : base(libraryManager)
+        {
+        }
+
+        /// <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
+                // Also run after series resolver
+                return ResolverPriority.Third;
+            }
+        }
+
+        public MultiItemResolverResult ResolveMultiple(Folder parent,
+            List<FileSystemMetadata> files,
+            string collectionType,
+            IDirectoryService directoryService)
+        {
+            var result = ResolveMultipleInternal(parent, files, collectionType, directoryService);
+
+            if (result != null)
+            {
+                foreach (var item in result.Items)
+                {
+                    SetInitialItemValues((Video)item, null);
+                }
+            }
+
+            return result;
+        }
+
+        private MultiItemResolverResult ResolveMultipleInternal(Folder parent,
+            List<FileSystemMetadata> files,
+            string collectionType,
+            IDirectoryService directoryService)
+        {
+            if (IsInvalid(parent, collectionType))
+            {
+                return null;
+            }
+
+            if (string.Equals(collectionType, CollectionType.MusicVideos, StringComparison.OrdinalIgnoreCase))
+            {
+                return ResolveVideos<MusicVideo>(parent, files, directoryService, false);
+            }
+
+            if (string.Equals(collectionType, CollectionType.HomeVideos, StringComparison.OrdinalIgnoreCase) ||
+                            string.Equals(collectionType, CollectionType.Photos, StringComparison.OrdinalIgnoreCase))
+            {
+                return ResolveVideos<Video>(parent, files, directoryService, false);
+            }
+
+            if (string.IsNullOrEmpty(collectionType))
+            {
+                // Owned items should just use the plain video type
+                if (parent == null)
+                {
+                    return ResolveVideos<Video>(parent, files, directoryService, false);
+                }
+
+                if (parent is Series || parent.GetParents().OfType<Series>().Any())
+                {
+                    return null;
+                }
+
+                return ResolveVideos<Movie>(parent, files, directoryService, false);
+            }
+
+            if (string.Equals(collectionType, CollectionType.Movies, StringComparison.OrdinalIgnoreCase))
+            {
+                return ResolveVideos<Movie>(parent, files, directoryService, true);
+            }
+
+            return null;
+        }
+
+        private MultiItemResolverResult ResolveVideos<T>(Folder parent, IEnumerable<FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, bool suppportMultiEditions)
+            where T : Video, new()
+        {
+            var files = new List<FileSystemMetadata>();
+            var videos = new List<BaseItem>();
+            var leftOver = new List<FileSystemMetadata>();
+
+            // Loop through each child file/folder and see if we find a video
+            foreach (var child in fileSystemEntries)
+            {
+                if (child.IsDirectory)
+                {
+                    leftOver.Add(child);
+                }
+                else if (IsIgnored(child.Name))
+                {
+
+                }
+                else
+                {
+                    files.Add(child);
+                }
+            }
+
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+
+            var resolver = new VideoListResolver(namingOptions, new PatternsLogger());
+            var resolverResult = resolver.Resolve(files, suppportMultiEditions).ToList();
+
+            var result = new MultiItemResolverResult
+            {
+                ExtraFiles = leftOver,
+                Items = videos
+            };
+
+            var isInMixedFolder = resolverResult.Count > 1;
+
+            foreach (var video in resolverResult)
+            {
+                var firstVideo = video.Files.First();
+
+                var videoItem = new T
+                {
+                    Path = video.Files[0].Path,
+                    IsInMixedFolder = isInMixedFolder,
+                    ProductionYear = video.Year,
+                    Name = video.Name,
+                    AdditionalParts = video.Files.Skip(1).Select(i => i.Path).ToList(),
+                    LocalAlternateVersions = video.AlternateVersions.Select(i => i.Path).ToList()
+                };
+
+                SetVideoType(videoItem, firstVideo);
+                Set3DFormat(videoItem, firstVideo);
+
+                result.Items.Add(videoItem);
+            }
+
+            result.ExtraFiles.AddRange(files.Where(i => !ContainsFile(resolverResult, i)));
+
+            return result;
+        }
+
+        private bool ContainsFile(List<VideoInfo> result, FileSystemMetadata file)
+        {
+            return result.Any(i => ContainsFile(i, file));
+        }
+
+        private bool ContainsFile(VideoInfo result, FileSystemMetadata file)
+        {
+            return result.Files.Any(i => ContainsFile(i, file)) ||
+                result.AlternateVersions.Any(i => ContainsFile(i, file)) ||
+                result.Extras.Any(i => ContainsFile(i, file));
+        }
+
+        private bool ContainsFile(VideoFileInfo result, FileSystemMetadata file)
+        {
+            return string.Equals(result.Path, file.FullName, StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Video.</returns>
+        protected override Video Resolve(ItemResolveArgs args)
+        {
+            var collectionType = args.GetCollectionType();
+
+            if (IsInvalid(args.Parent, collectionType))
+            {
+                return null;
+            }
+
+            // Find movies with their own folders
+            if (args.IsDirectory)
+            {
+                var files = args.FileSystemChildren
+                    .Where(i => !LibraryManager.IgnoreFile(i, args.Parent))
+                    .ToList();
+
+                if (string.Equals(collectionType, CollectionType.MusicVideos, StringComparison.OrdinalIgnoreCase))
+                {
+                    return FindMovie<MusicVideo>(args.Path, args.Parent, files, args.DirectoryService, collectionType, false);
+                }
+
+                if (string.Equals(collectionType, CollectionType.HomeVideos, StringComparison.OrdinalIgnoreCase))
+                {
+                    return FindMovie<Video>(args.Path, args.Parent, files, args.DirectoryService, collectionType, false);
+                }
+
+                if (string.IsNullOrEmpty(collectionType))
+                {
+                    // Owned items will be caught by the plain video resolver
+                    if (args.Parent == null)
+                    {
+                        //return FindMovie<Video>(args.Path, args.Parent, files, args.DirectoryService, collectionType);
+                        return null;
+                    }
+
+                    if (args.HasParent<Series>())
+                    {
+                        return null;
+                    }
+
+                    {
+                        return FindMovie<Movie>(args.Path, args.Parent, files, args.DirectoryService, collectionType, true);
+                    }
+                }
+
+                if (string.Equals(collectionType, CollectionType.Movies, StringComparison.OrdinalIgnoreCase))
+                {
+                    return FindMovie<Movie>(args.Path, args.Parent, files, args.DirectoryService, collectionType, true);
+                }
+
+                return null;
+            }
+
+            // Owned items will be caught by the plain video resolver
+            if (args.Parent == null)
+            {
+                return null;
+            }
+
+            Video item = null;
+
+            if (string.Equals(collectionType, CollectionType.MusicVideos, StringComparison.OrdinalIgnoreCase))
+            {
+                item = ResolveVideo<MusicVideo>(args, false);
+            }
+
+            // To find a movie file, the collection type must be movies or boxsets
+            else if (string.Equals(collectionType, CollectionType.Movies, StringComparison.OrdinalIgnoreCase))
+            {
+                item = ResolveVideo<Movie>(args, true);
+            }
+
+            else if (string.Equals(collectionType, CollectionType.HomeVideos, StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(collectionType, CollectionType.Photos, StringComparison.OrdinalIgnoreCase))
+            {
+                item = ResolveVideo<Video>(args, false);
+            }
+            else if (string.IsNullOrEmpty(collectionType))
+            {
+                if (args.HasParent<Series>())
+                {
+                    return null;
+                }
+
+                item = ResolveVideo<Video>(args, false);
+            }
+
+            if (item != null)
+            {
+                item.IsInMixedFolder = true;
+            }
+
+            return item;
+        }
+
+        private bool IsIgnored(string filename)
+        {
+            // Ignore samples
+            var sampleFilename = " " + filename.Replace(".", " ", StringComparison.OrdinalIgnoreCase)
+                .Replace("-", " ", StringComparison.OrdinalIgnoreCase)
+                .Replace("_", " ", StringComparison.OrdinalIgnoreCase)
+                .Replace("!", " ", StringComparison.OrdinalIgnoreCase);
+
+            if (sampleFilename.IndexOf(" sample ", StringComparison.OrdinalIgnoreCase) != -1)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <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)
+        {
+            base.SetInitialItemValues(item, args);
+
+            SetProviderIdsFromPath(item);
+        }
+
+        /// <summary>
+        /// Sets the provider id from path.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        private void SetProviderIdsFromPath(Video item)
+        {
+            if (item is Movie || item is MusicVideo)
+            {
+                //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);
+
+                if (!string.IsNullOrWhiteSpace(justName))
+                {
+                    // check for tmdb id
+                    var tmdbid = justName.GetAttributeValue("tmdbid");
+
+                    if (!string.IsNullOrWhiteSpace(tmdbid))
+                    {
+                        item.SetProviderId(MetadataProviders.Tmdb, tmdbid);
+                    }
+                }
+
+                if (!string.IsNullOrWhiteSpace(item.Path))
+                {
+                    // check for imdb id - we use full media path, as we can assume, that this will match in any use case (wither id in parent dir or in file name)
+                    var imdbid = item.Path.GetAttributeValue("imdbid");
+
+                    if (!string.IsNullOrWhiteSpace(imdbid))
+                    {
+                        item.SetProviderId(MetadataProviders.Imdb, imdbid);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finds a movie based on a child file system entries
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>Movie.</returns>
+        private T FindMovie<T>(string path, Folder parent, List<FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, string collectionType, bool allowFilesAsFolders)
+            where T : Video, new()
+        {
+            var multiDiscFolders = new List<FileSystemMetadata>();
+
+            // Search for a folder rip
+            foreach (var child in fileSystemEntries)
+            {
+                var filename = child.Name;
+
+                if (child.IsDirectory)
+                {
+                    if (IsDvdDirectory(filename))
+                    {
+                        var movie = new T
+                        {
+                            Path = path,
+                            VideoType = VideoType.Dvd
+                        };
+                        Set3DFormat(movie);
+                        return movie;
+                    }
+                    if (IsBluRayDirectory(filename))
+                    {
+                        var movie = new T
+                        {
+                            Path = path,
+                            VideoType = VideoType.BluRay
+                        };
+                        Set3DFormat(movie);
+                        return movie;
+                    }
+
+                    multiDiscFolders.Add(child);
+                }
+                else if (IsDvdFile(filename))
+                {
+                    var movie = new T
+                    {
+                        Path = path,
+                        VideoType = VideoType.Dvd
+                    };
+                    Set3DFormat(movie);
+                    return movie;
+                }
+            }
+
+            if (allowFilesAsFolders)
+            {
+                // TODO: Allow GetMultiDiscMovie in here
+                var supportsMultiVersion = !string.Equals(collectionType, CollectionType.HomeVideos) &&
+                                        !string.Equals(collectionType, CollectionType.Photos) &&
+                                        !string.Equals(collectionType, CollectionType.MusicVideos);
+
+                var result = ResolveVideos<T>(parent, fileSystemEntries, directoryService, supportsMultiVersion);
+
+                if (result.Items.Count == 1)
+                {
+                    var movie = (T)result.Items[0];
+                    movie.IsInMixedFolder = false;
+                    movie.Name = Path.GetFileName(movie.ContainingFolderPath);
+                    return movie;
+                }
+
+                if (result.Items.Count == 0 && multiDiscFolders.Count > 0)
+                {
+                    return GetMultiDiscMovie<T>(multiDiscFolders, directoryService);
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the multi disc movie.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="multiDiscFolders">The folders.</param>
+        /// <param name="directoryService">The directory service.</param>
+        /// <returns>``0.</returns>
+        private T GetMultiDiscMovie<T>(List<FileSystemMetadata> multiDiscFolders, IDirectoryService directoryService)
+               where T : Video, new()
+        {
+            var videoTypes = new List<VideoType>();
+
+            var folderPaths = multiDiscFolders.Select(i => i.FullName).Where(i =>
+            {
+                var subFileEntries = directoryService.GetFileSystemEntries(i)
+                    .ToList();
+
+                var subfolders = subFileEntries
+                 .Where(e => e.IsDirectory)
+                    .Select(d => d.Name)
+                    .ToList();
+
+                if (subfolders.Any(IsDvdDirectory))
+                {
+                    videoTypes.Add(VideoType.Dvd);
+                    return true;
+                }
+                if (subfolders.Any(IsBluRayDirectory))
+                {
+                    videoTypes.Add(VideoType.BluRay);
+                    return true;
+                }
+
+                var subFiles = subFileEntries
+                 .Where(e => !e.IsDirectory)
+                 .Select(d => d.Name);
+
+                if (subFiles.Any(IsDvdFile))
+                {
+                    videoTypes.Add(VideoType.Dvd);
+                    return true;
+                }
+
+                return false;
+
+            }).OrderBy(i => i).ToList();
+
+            // If different video types were found, don't allow this
+            if (videoTypes.Distinct().Count() > 1)
+            {
+                return null;
+            }
+
+            if (folderPaths.Count == 0)
+            {
+                return null;
+            }
+
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+            var resolver = new StackResolver(namingOptions, new PatternsLogger());
+
+            var result = resolver.ResolveDirectories(folderPaths);
+
+            if (result.Stacks.Count != 1)
+            {
+                return null;
+            }
+
+            var returnVideo = new T
+            {
+                Path = folderPaths[0],
+
+                AdditionalParts = folderPaths.Skip(1).ToList(),
+
+                VideoType = videoTypes[0],
+
+                Name = result.Stacks[0].Name
+            };
+
+            SetIsoType(returnVideo);
+
+            return returnVideo;
+        }
+
+        private bool IsInvalid(Folder parent, string collectionType)
+        {
+            if (parent != null)
+            {
+                if (parent.IsRoot)
+                {
+                    return true;
+                }
+            }
+
+            var validCollectionTypes = new[]
+            {
+                CollectionType.Movies,
+                CollectionType.HomeVideos,
+                CollectionType.MusicVideos,
+                CollectionType.Movies,
+                CollectionType.Photos
+            };
+
+            if (string.IsNullOrWhiteSpace(collectionType))
+            {
+                return false;
+            }
+
+            return !validCollectionTypes.Contains(collectionType, StringComparer.OrdinalIgnoreCase);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/PhotoAlbumResolver.cs b/Emby.Server.Implementations/Library/Resolvers/PhotoAlbumResolver.cs
new file mode 100644
index 000000000..3d7ede879
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/PhotoAlbumResolver.cs
@@ -0,0 +1,56 @@
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using System;
+using System.IO;
+using System.Linq;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    public class PhotoAlbumResolver : FolderResolver<PhotoAlbum>
+    {
+        private readonly IImageProcessor _imageProcessor;
+        public PhotoAlbumResolver(IImageProcessor imageProcessor)
+        {
+            _imageProcessor = imageProcessor;
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Trailer.</returns>
+        protected override PhotoAlbum Resolve(ItemResolveArgs args)
+        {
+            // Must be an image file within a photo collection
+            if (args.IsDirectory && string.Equals(args.GetCollectionType(), CollectionType.Photos, StringComparison.OrdinalIgnoreCase))
+            {
+                if (HasPhotos(args))
+                {
+                    return new PhotoAlbum
+                    {
+                        Path = args.Path
+                    };
+                }
+            }
+
+            return null;
+        }
+
+        private bool HasPhotos(ItemResolveArgs args)
+        {
+            return args.FileSystemChildren.Any(i => (!i.IsDirectory) && PhotoResolver.IsImageFile(i.FullName, _imageProcessor));
+        }
+
+        public override ResolverPriority Priority
+        {
+            get
+            {
+                // Behind special folder resolver
+                return ResolverPriority.Second;
+            }
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/PhotoResolver.cs b/Emby.Server.Implementations/Library/Resolvers/PhotoResolver.cs
new file mode 100644
index 000000000..df39e57ad
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/PhotoResolver.cs
@@ -0,0 +1,103 @@
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using System;
+using System.IO;
+using System.Linq;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    public class PhotoResolver : ItemResolver<Photo>
+    {
+        private readonly IImageProcessor _imageProcessor;
+        private readonly ILibraryManager _libraryManager;
+
+        public PhotoResolver(IImageProcessor imageProcessor, ILibraryManager libraryManager)
+        {
+            _imageProcessor = imageProcessor;
+            _libraryManager = libraryManager;
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Trailer.</returns>
+        protected override Photo Resolve(ItemResolveArgs args)
+        {
+            if (!args.IsDirectory)
+            {
+                // Must be an image file within a photo collection
+                var collectionType = args.GetCollectionType();
+
+
+                if (string.Equals(collectionType, CollectionType.Photos, StringComparison.OrdinalIgnoreCase) ||
+                    (string.Equals(collectionType, CollectionType.HomeVideos, StringComparison.OrdinalIgnoreCase) && args.GetLibraryOptions().EnablePhotos))
+                {
+                    if (IsImageFile(args.Path, _imageProcessor))
+                    {
+                        var filename = Path.GetFileNameWithoutExtension(args.Path);
+
+                        // Make sure the image doesn't belong to a video file
+                        if (args.DirectoryService.GetFiles(Path.GetDirectoryName(args.Path)).Any(i => IsOwnedByMedia(args.GetLibraryOptions(), i, filename)))
+                        {
+                            return null;
+                        }
+
+                        return new Photo
+                        {
+                            Path = args.Path
+                        };
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private bool IsOwnedByMedia(LibraryOptions libraryOptions, FileSystemMetadata file, string imageFilename)
+        {
+            if (_libraryManager.IsVideoFile(file.FullName, libraryOptions) && imageFilename.StartsWith(Path.GetFileNameWithoutExtension(file.Name), StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private static readonly string[] IgnoreFiles =
+        {
+            "folder",
+            "thumb",
+            "landscape",
+            "fanart",
+            "backdrop",
+            "poster",
+            "cover"
+        };
+
+        internal static bool IsImageFile(string path, IImageProcessor imageProcessor)
+        {
+            var filename = Path.GetFileNameWithoutExtension(path) ?? string.Empty;
+
+            if (IgnoreFiles.Contains(filename, StringComparer.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            if (IgnoreFiles.Any(i => filename.IndexOf(i, StringComparison.OrdinalIgnoreCase) != -1))
+            {
+                return false;
+            }
+
+            return imageProcessor.SupportedInputFormats.Contains((Path.GetExtension(path) ?? string.Empty).TrimStart('.'), StringComparer.OrdinalIgnoreCase);
+        }
+
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs b/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
new file mode 100644
index 000000000..8c59cf20f
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
@@ -0,0 +1,42 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
+using System;
+using System.IO;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    public class PlaylistResolver : FolderResolver<Playlist>
+    {
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>BoxSet.</returns>
+        protected override Playlist Resolve(ItemResolveArgs args)
+        {
+            // It's a boxset if all of the following conditions are met:
+            // Is a Directory
+            // Contains [playlist] in the path
+            if (args.IsDirectory)
+            {
+                var filename = Path.GetFileName(args.Path);
+
+                if (string.IsNullOrEmpty(filename))
+                {
+                    return null;
+                }
+
+                if (filename.IndexOf("[playlist]", StringComparison.OrdinalIgnoreCase) != -1)
+                {
+                    return new Playlist
+                    {
+                        Path = args.Path,
+                        Name = ResolverHelper.StripBrackets(Path.GetFileName(args.Path))
+                    };
+                }
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/SpecialFolderResolver.cs b/Emby.Server.Implementations/Library/Resolvers/SpecialFolderResolver.cs
new file mode 100644
index 000000000..1bec1073d
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/SpecialFolderResolver.cs
@@ -0,0 +1,85 @@
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+using System;
+using System.IO;
+using System.Linq;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    class SpecialFolderResolver : FolderResolver<Folder>
+    {
+        private readonly IFileSystem _fileSystem;
+        private readonly IServerApplicationPaths _appPaths;
+
+        public SpecialFolderResolver(IFileSystem fileSystem, IServerApplicationPaths appPaths)
+        {
+            _fileSystem = fileSystem;
+            _appPaths = appPaths;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority
+        {
+            get { return ResolverPriority.First; }
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Folder.</returns>
+        protected override Folder Resolve(ItemResolveArgs args)
+        {
+            if (args.IsDirectory)
+            {
+                if (args.IsPhysicalRoot)
+                {
+                    return new AggregateFolder();
+                }
+                if (string.Equals(args.Path, _appPaths.DefaultUserViewsPath, StringComparison.OrdinalIgnoreCase))
+                {
+                    return new UserRootFolder();  //if we got here and still a root - must be user root
+                }
+                if (args.IsVf)
+                {
+                    return new CollectionFolder
+                    {
+                        CollectionType = GetCollectionType(args),
+                        PhysicalLocationsList = args.PhysicalLocations.ToList()
+                    };
+                }
+            }
+
+            return null;
+        }
+
+        private string GetCollectionType(ItemResolveArgs args)
+        {
+            return args.FileSystemChildren
+                .Where(i =>
+                {
+
+                    try
+                    {
+                        return !i.IsDirectory &&
+                               string.Equals(".collection", i.Extension, StringComparison.OrdinalIgnoreCase);
+                    }
+                    catch (IOException)
+                    {
+                        return false;
+                    }
+
+                })
+                .Select(i => _fileSystem.GetFileNameWithoutExtension(i))
+                .FirstOrDefault();
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/TV/EpisodeResolver.cs b/Emby.Server.Implementations/Library/Resolvers/TV/EpisodeResolver.cs
new file mode 100644
index 000000000..2a4cc49b7
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/TV/EpisodeResolver.cs
@@ -0,0 +1,75 @@
+using System;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using System.Linq;
+using MediaBrowser.Model.Entities;
+
+namespace Emby.Server.Implementations.Library.Resolvers.TV
+{
+    /// <summary>
+    /// Class EpisodeResolver
+    /// </summary>
+    public class EpisodeResolver : BaseVideoResolver<Episode>
+    {
+        public EpisodeResolver(ILibraryManager libraryManager) : base(libraryManager)
+        {
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Episode.</returns>
+        protected override Episode Resolve(ItemResolveArgs args)
+        {
+            var parent = args.Parent;
+
+            if (parent == null)
+            {
+                return null;
+            }
+
+            var season = parent as Season;
+            // Just in case the user decided to nest episodes. 
+            // Not officially supported but in some cases we can handle it.
+            if (season == null)
+            {
+                season = parent.GetParents().OfType<Season>().FirstOrDefault();
+            }
+
+            // If the parent is a Season or Series, then this is an Episode if the VideoResolver returns something
+            // Also handle flat tv folders
+            if (season != null || 
+                string.Equals(args.GetCollectionType(), CollectionType.TvShows, StringComparison.OrdinalIgnoreCase) || 
+                args.HasParent<Series>())
+            {
+                var episode = ResolveVideo<Episode>(args, false);
+
+                if (episode != null)
+                {
+                    var series = parent as Series;
+                    if (series == null)
+                    {
+                        series = parent.GetParents().OfType<Series>().FirstOrDefault();
+                    }
+
+                    if (series != null)
+                    {
+                        episode.SeriesId = series.Id;
+                        episode.SeriesName = series.Name;
+                        episode.SeriesSortName = series.SortName;
+                    }
+                    if (season != null)
+                    {
+                        episode.SeasonId = season.Id;
+                        episode.SeasonName = season.Name;
+                    }
+                }
+
+                return episode;
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs b/Emby.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs
new file mode 100644
index 000000000..c065feda1
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs
@@ -0,0 +1,62 @@
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Naming.Common;
+using MediaBrowser.Naming.TV;
+
+namespace Emby.Server.Implementations.Library.Resolvers.TV
+{
+    /// <summary>
+    /// Class SeasonResolver
+    /// </summary>
+    public class SeasonResolver : FolderResolver<Season>
+    {
+        /// <summary>
+        /// The _config
+        /// </summary>
+        private readonly IServerConfigurationManager _config;
+
+        private readonly ILibraryManager _libraryManager;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SeasonResolver"/> class.
+        /// </summary>
+        /// <param name="config">The config.</param>
+        public SeasonResolver(IServerConfigurationManager config, ILibraryManager libraryManager)
+        {
+            _config = config;
+            _libraryManager = libraryManager;
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Season.</returns>
+        protected override Season Resolve(ItemResolveArgs args)
+        {
+            if (args.Parent is Series && args.IsDirectory)
+            {
+                var namingOptions = ((LibraryManager)_libraryManager).GetNamingOptions();
+                var series = ((Series)args.Parent);
+
+                var season = new Season
+                {
+                    IndexNumber = new SeasonPathParser(namingOptions, new RegexProvider()).Parse(args.Path, true, true).SeasonNumber,
+                    SeriesId = series.Id,
+                    SeriesSortName = series.SortName,
+                    SeriesName = series.Name
+                };
+
+                if (season.IndexNumber.HasValue && season.IndexNumber.Value == 0)
+                {
+                    season.Name = _config.Configuration.SeasonZeroDisplayName;
+                }
+
+                return season;
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs b/Emby.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs
new file mode 100644
index 000000000..44eb0e3e2
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs
@@ -0,0 +1,251 @@
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Naming.Common;
+using MediaBrowser.Naming.TV;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Emby.Server.Implementations.Logging;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.Resolvers.TV
+{
+    /// <summary>
+    /// Class SeriesResolver
+    /// </summary>
+    public class SeriesResolver : FolderResolver<Series>
+    {
+        private readonly IFileSystem _fileSystem;
+        private readonly ILogger _logger;
+        private readonly ILibraryManager _libraryManager;
+
+        public SeriesResolver(IFileSystem fileSystem, ILogger logger, ILibraryManager libraryManager)
+        {
+            _fileSystem = fileSystem;
+            _logger = logger;
+            _libraryManager = libraryManager;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority
+        {
+            get
+            {
+                return ResolverPriority.Second;
+            }
+        }
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>Series.</returns>
+        protected override Series Resolve(ItemResolveArgs args)
+        {
+            if (args.IsDirectory)
+            {
+                if (args.HasParent<Series>() || args.HasParent<Season>())
+                {
+                    return null;
+                }
+
+                var collectionType = args.GetCollectionType();
+                if (string.Equals(collectionType, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase))
+                {
+                    //if (args.ContainsFileSystemEntryByName("tvshow.nfo"))
+                    //{
+                    //    return new Series
+                    //    {
+                    //        Path = args.Path,
+                    //        Name = Path.GetFileName(args.Path)
+                    //    };
+                    //}
+
+                    var configuredContentType = _libraryManager.GetConfiguredContentType(args.Path);
+                    if (!string.Equals(configuredContentType, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new Series
+                        {
+                            Path = args.Path,
+                            Name = Path.GetFileName(args.Path)
+                        };
+                    }
+                }
+                else if (string.IsNullOrWhiteSpace(collectionType))
+                {
+                    if (args.ContainsFileSystemEntryByName("tvshow.nfo"))
+                    {
+                        if (args.Parent.IsRoot)
+                        {
+                            // For now, return null, but if we want to allow this in the future then add some additional checks to guard against a misplaced tvshow.nfo
+                            return null;
+                        }
+
+                        return new Series
+                        {
+                            Path = args.Path,
+                            Name = Path.GetFileName(args.Path)
+                        };
+                    }
+
+                    if (args.Parent.IsRoot)
+                    {
+                        return null;
+                    }
+
+                    if (IsSeriesFolder(args.Path, args.FileSystemChildren, args.DirectoryService, _fileSystem, _logger, _libraryManager, args.GetLibraryOptions(), false))
+                    {
+                        return new Series
+                        {
+                            Path = args.Path,
+                            Name = Path.GetFileName(args.Path)
+                        };
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        public static bool IsSeriesFolder(string path,
+            IEnumerable<FileSystemMetadata> fileSystemChildren,
+            IDirectoryService directoryService,
+            IFileSystem fileSystem,
+            ILogger logger,
+            ILibraryManager libraryManager,
+            LibraryOptions libraryOptions,
+            bool isTvContentType)
+        {
+            foreach (var child in fileSystemChildren)
+            {
+                //if ((attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
+                //{
+                //    //logger.Debug("Igoring series file or folder marked hidden: {0}", child.FullName);
+                //    continue;
+                //}
+
+                // Can't enforce this because files saved by Bitcasa are always marked System
+                //if ((attributes & FileAttributes.System) == FileAttributes.System)
+                //{
+                //    logger.Debug("Igoring series subfolder marked system: {0}", child.FullName);
+                //    continue;
+                //}
+
+                if (child.IsDirectory)
+                {
+                    if (IsSeasonFolder(child.FullName, isTvContentType, libraryManager))
+                    {
+                        //logger.Debug("{0} is a series because of season folder {1}.", path, child.FullName);
+                        return true;
+                    }
+                }
+                else
+                {
+                    string fullName = child.FullName;
+                    if (libraryManager.IsVideoFile(fullName, libraryOptions))
+                    {
+                        if (isTvContentType)
+                        {
+                            return true;
+                        }
+
+                        var namingOptions = ((LibraryManager)libraryManager).GetNamingOptions();
+
+                        // In mixed folders we need to be conservative and avoid expressions that may result in false positives (e.g. movies with numbers in the title)
+                        if (!isTvContentType)
+                        {
+                            namingOptions.EpisodeExpressions = namingOptions.EpisodeExpressions
+                                .Where(i => i.IsNamed && !i.IsOptimistic)
+                                .ToList();
+                        }
+
+                        var episodeResolver = new MediaBrowser.Naming.TV.EpisodeResolver(namingOptions, new PatternsLogger());
+                        var episodeInfo = episodeResolver.Resolve(fullName, false, false);
+                        if (episodeInfo != null && episodeInfo.EpisodeNumber.HasValue)
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            logger.Debug("{0} is not a series folder.", path);
+            return false;
+        }
+
+        /// <summary>
+        /// Determines whether [is place holder] [the specified path].
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns><c>true</c> if [is place holder] [the specified path]; otherwise, <c>false</c>.</returns>
+        /// <exception cref="System.ArgumentNullException">path</exception>
+        private static bool IsVideoPlaceHolder(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            var extension = Path.GetExtension(path);
+
+            return string.Equals(extension, ".disc", StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Determines whether [is season folder] [the specified path].
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="isTvContentType">if set to <c>true</c> [is tv content type].</param>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <returns><c>true</c> if [is season folder] [the specified path]; otherwise, <c>false</c>.</returns>
+        private static bool IsSeasonFolder(string path, bool isTvContentType, ILibraryManager libraryManager)
+        {
+            var namingOptions = ((LibraryManager)libraryManager).GetNamingOptions();
+
+            var seasonNumber = new SeasonPathParser(namingOptions, new RegexProvider()).Parse(path, isTvContentType, isTvContentType).SeasonNumber;
+
+            return seasonNumber.HasValue;
+        }
+
+        /// <summary>
+        /// Sets the initial item values.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="args">The args.</param>
+        protected override void SetInitialItemValues(Series item, ItemResolveArgs args)
+        {
+            base.SetInitialItemValues(item, args);
+
+            SetProviderIdFromPath(item, args.Path);
+        }
+
+        /// <summary>
+        /// Sets the provider id from path.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="path">The path.</param>
+        private void SetProviderIdFromPath(Series item, string path)
+        {
+            var justName = Path.GetFileName(path);
+
+            var id = justName.GetAttributeValue("tvdbid");
+
+            if (!string.IsNullOrEmpty(id))
+            {
+                item.SetProviderId(MetadataProviders.Tvdb, id);
+            }
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Resolvers/VideoResolver.cs b/Emby.Server.Implementations/Library/Resolvers/VideoResolver.cs
new file mode 100644
index 000000000..b5e1bf5f7
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Resolvers/VideoResolver.cs
@@ -0,0 +1,45 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Resolves a Path into a Video
+    /// </summary>
+    public class VideoResolver : BaseVideoResolver<Video>
+    {
+        public VideoResolver(ILibraryManager libraryManager)
+            : base(libraryManager)
+        {
+        }
+
+        protected override Video Resolve(ItemResolveArgs args)
+        {
+            if (args.Parent != null)
+            {
+                // The movie resolver will handle this
+                return null;
+            }
+
+            return base.Resolve(args);
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority
+        {
+            get { return ResolverPriority.Last; }
+        }
+    }
+
+    public class GenericVideoResolver<T> : BaseVideoResolver<T>
+        where T : Video, new ()
+    {
+        public GenericVideoResolver(ILibraryManager libraryManager) : base(libraryManager)
+        {
+        }
+    }
+}
-- 
cgit v1.2.3