repo creation with initial code after cloning public repo

Emby.Server.Implementations/Library/CoreResolutionIgnoreRule.cs

@@ -0,0 +1,69 @@
+using System;
+using System.IO;
+using Emby.Naming.Audio;
+using Emby.Naming.Common;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Library
+{
+    /// <summary>
+    /// Provides the core resolver ignore rules.
+    /// </summary>
+    public class CoreResolutionIgnoreRule : IResolverIgnoreRule
+    {
+        private readonly NamingOptions _namingOptions;
+        private readonly IServerApplicationPaths _serverApplicationPaths;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CoreResolutionIgnoreRule"/> class.
+        /// </summary>
+        /// <param name="namingOptions">The naming options.</param>
+        /// <param name="serverApplicationPaths">The server application paths.</param>
+        public CoreResolutionIgnoreRule(NamingOptions namingOptions, IServerApplicationPaths serverApplicationPaths)
+        {
+            _namingOptions = namingOptions;
+            _serverApplicationPaths = serverApplicationPaths;
+        }
+
+        /// <inheritdoc />
+        public bool ShouldIgnore(FileSystemMetadata fileInfo, BaseItem? parent)
+        {
+            // Don't ignore application folders
+            if (fileInfo.FullName.Contains(_serverApplicationPaths.RootFolderPath, StringComparison.InvariantCulture))
+            {
+                return false;
+            }
+
+            if (IgnorePatterns.ShouldIgnore(fileInfo.FullName))
+            {
+                return true;
+            }
+
+            // Don't ignore top level folders
+            if (fileInfo.IsDirectory
+                && (parent is AggregateFolder || (parent?.IsTopParent ?? false)))
+            {
+                return false;
+            }
+
+            if (parent is null)
+            {
+                return false;
+            }
+
+            if (fileInfo.IsDirectory)
+            {
+                // Ignore extras for unsupported types
+                return _namingOptions.AllExtrasTypesFolderNames.ContainsKey(fileInfo.Name)
+                    && parent is not UserRootFolder;
+            }
+
+            // Don't resolve theme songs
+            return Path.GetFileNameWithoutExtension(fileInfo.Name.AsSpan()).Equals(BaseItem.ThemeSongFileName, StringComparison.Ordinal)
+                && AudioFileParser.IsAudioFile(fileInfo.Name, _namingOptions);
+        }
+    }
+}

Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs

@@ -0,0 +1,140 @@
+using System;
+using System.IO;
+using System.Text.RegularExpressions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Library;
+
+/// <summary>
+/// Resolver rule class for ignoring files via .ignore.
+/// </summary>
+public class DotIgnoreIgnoreRule : IResolverIgnoreRule
+{
+    private static readonly bool IsWindows = OperatingSystem.IsWindows();
+
+    private static FileInfo? FindIgnoreFile(DirectoryInfo directory)
+    {
+        for (var current = directory; current is not null; current = current.Parent)
+        {
+            var ignorePath = Path.Join(current.FullName, ".ignore");
+            if (File.Exists(ignorePath))
+            {
+                return new FileInfo(ignorePath);
+            }
+        }
+
+        return null;
+    }
+
+    /// <inheritdoc />
+    public bool ShouldIgnore(FileSystemMetadata fileInfo, BaseItem? parent) => IsIgnored(fileInfo, parent);
+
+    /// <summary>
+    /// Checks whether or not the file is ignored.
+    /// </summary>
+    /// <param name="fileInfo">The file information.</param>
+    /// <param name="parent">The parent BaseItem.</param>
+    /// <returns>True if the file should be ignored.</returns>
+    public static bool IsIgnored(FileSystemMetadata fileInfo, BaseItem? parent)
+    {
+        var searchDirectory = fileInfo.IsDirectory
+            ? new DirectoryInfo(fileInfo.FullName)
+            : new DirectoryInfo(Path.GetDirectoryName(fileInfo.FullName) ?? string.Empty);
+
+        if (string.IsNullOrEmpty(searchDirectory.FullName))
+        {
+            return false;
+        }
+
+        var ignoreFile = FindIgnoreFile(searchDirectory);
+        if (ignoreFile is null)
+        {
+            return false;
+        }
+
+        // Fast path in case the ignore files isn't a symlink and is empty
+        if (ignoreFile.LinkTarget is null && ignoreFile.Length == 0)
+        {
+            // Ignore directory if we just have the file
+            return true;
+        }
+
+        var content = GetFileContent(ignoreFile);
+        return string.IsNullOrWhiteSpace(content)
+            || CheckIgnoreRules(fileInfo.FullName, content, fileInfo.IsDirectory);
+    }
+
+    private static bool CheckIgnoreRules(string path, string ignoreFileContent, bool isDirectory)
+    {
+        // If file has content, base ignoring off the content .gitignore-style rules
+        var rules = ignoreFileContent.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        return CheckIgnoreRules(path, rules, isDirectory);
+    }
+
+    /// <summary>
+    /// Checks whether a path should be ignored based on an array of ignore rules.
+    /// </summary>
+    /// <param name="path">The path to check.</param>
+    /// <param name="rules">The array of ignore rules.</param>
+    /// <param name="isDirectory">Whether the path is a directory.</param>
+    /// <returns>True if the path should be ignored.</returns>
+    internal static bool CheckIgnoreRules(string path, string[] rules, bool isDirectory)
+        => CheckIgnoreRules(path, rules, isDirectory, IsWindows);
+
+    /// <summary>
+    /// Checks whether a path should be ignored based on an array of ignore rules.
+    /// </summary>
+    /// <param name="path">The path to check.</param>
+    /// <param name="rules">The array of ignore rules.</param>
+    /// <param name="isDirectory">Whether the path is a directory.</param>
+    /// <param name="normalizePath">Whether to normalize backslashes to forward slashes (for Windows paths).</param>
+    /// <returns>True if the path should be ignored.</returns>
+    internal static bool CheckIgnoreRules(string path, string[] rules, bool isDirectory, bool normalizePath)
+    {
+        var ignore = new Ignore.Ignore();
+
+        // Add each rule individually to catch and skip invalid patterns
+        var validRulesAdded = 0;
+        foreach (var rule in rules)
+        {
+            try
+            {
+                ignore.Add(rule);
+                validRulesAdded++;
+            }
+            catch (RegexParseException)
+            {
+                // Ignore invalid patterns
+            }
+        }
+
+        // If no valid rules were added, fall back to ignoring everything (like an empty .ignore file)
+        if (validRulesAdded == 0)
+        {
+            return true;
+        }
+
+         // Mitigate the problem of the Ignore library not handling Windows paths correctly.
+         // See https://github.com/jellyfin/jellyfin/issues/15484
+        var pathToCheck = normalizePath ? path.NormalizePath('/') : path;
+
+        // Add trailing slash for directories to match "folder/"
+        if (isDirectory)
+        {
+            pathToCheck = string.Concat(pathToCheck.AsSpan().TrimEnd('/'), "/");
+        }
+
+        return ignore.IsIgnored(pathToCheck);
+    }
+
+    private static string GetFileContent(FileInfo ignoreFile)
+    {
+        ignoreFile = FileSystemHelper.ResolveLinkTarget(ignoreFile, returnFinalTarget: true) ?? ignoreFile;
+        return ignoreFile.Exists
+            ? File.ReadAllText(ignoreFile.FullName)
+            : string.Empty;
+    }
+}

Emby.Server.Implementations/Library/ExternalDataManager.cs

@@ -0,0 +1,77 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Chapters;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.MediaSegments;
+using MediaBrowser.Controller.Trickplay;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library;
+
+/// <summary>
+/// IExternalDataManager implementation.
+/// </summary>
+public class ExternalDataManager : IExternalDataManager
+{
+    private readonly IKeyframeManager _keyframeManager;
+    private readonly IMediaSegmentManager _mediaSegmentManager;
+    private readonly IPathManager _pathManager;
+    private readonly ITrickplayManager _trickplayManager;
+    private readonly IChapterManager _chapterManager;
+    private readonly ILogger<ExternalDataManager> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExternalDataManager"/> class.
+    /// </summary>
+    /// <param name="keyframeManager">The keyframe manager.</param>
+    /// <param name="mediaSegmentManager">The media segment manager.</param>
+    /// <param name="pathManager">The path manager.</param>
+    /// <param name="trickplayManager">The trickplay manager.</param>
+    /// <param name="chapterManager">The chapter manager.</param>
+    /// <param name="logger">The logger.</param>
+    public ExternalDataManager(
+        IKeyframeManager keyframeManager,
+        IMediaSegmentManager mediaSegmentManager,
+        IPathManager pathManager,
+        ITrickplayManager trickplayManager,
+        IChapterManager chapterManager,
+        ILogger<ExternalDataManager> logger)
+    {
+        _keyframeManager = keyframeManager;
+        _mediaSegmentManager = mediaSegmentManager;
+        _pathManager = pathManager;
+        _trickplayManager = trickplayManager;
+        _chapterManager = chapterManager;
+        _logger = logger;
+    }
+
+    /// <inheritdoc/>
+    public async Task DeleteExternalItemDataAsync(BaseItem item, CancellationToken cancellationToken)
+    {
+        var validPaths = _pathManager.GetExtractedDataPaths(item).Where(Directory.Exists).ToList();
+        var itemId = item.Id;
+        if (validPaths.Count > 0)
+        {
+            foreach (var path in validPaths)
+            {
+                try
+                {
+                    Directory.Delete(path, true);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning("Unable to prune external item data at {Path}: {Exception}", path, ex);
+                }
+            }
+        }
+
+        await _keyframeManager.DeleteKeyframeDataAsync(itemId, cancellationToken).ConfigureAwait(false);
+        await _mediaSegmentManager.DeleteSegmentsAsync(itemId, cancellationToken).ConfigureAwait(false);
+        await _trickplayManager.DeleteTrickplayDataAsync(itemId, cancellationToken).ConfigureAwait(false);
+        await _chapterManager.DeleteChapterDataAsync(itemId, cancellationToken).ConfigureAwait(false);
+    }
+}

Emby.Server.Implementations/Library/IgnorePatterns.cs

@@ -0,0 +1,136 @@
+using System;
+using DotNet.Globbing;
+
+namespace Emby.Server.Implementations.Library
+{
+    /// <summary>
+    /// Glob patterns for files to ignore.
+    /// </summary>
+    public static class IgnorePatterns
+    {
+        /// <summary>
+        /// Files matching these glob patterns will be ignored.
+        /// </summary>
+        private static readonly string[] _patterns =
+        {
+            "**/small.jpg",
+            "**/albumart.jpg",
+
+            // We have neither non-greedy matching or character group repetitions, working around that here.
+            // https://github.com/dazinator/DotNet.Glob#patterns
+            // .*/sample\..{1,5}
+            "**/sample.?",
+            "**/sample.??",
+            "**/sample.???", // Matches sample.mkv
+            "**/sample.????", // Matches sample.webm
+            "**/sample.?????",
+            "**/*.sample.?",
+            "**/*.sample.??",
+            "**/*.sample.???",
+            "**/*.sample.????",
+            "**/*.sample.?????",
+            "**/sample/*",
+
+            // Directories
+            "**/metadata/**",
+            "**/metadata",
+            "**/ps3_update/**",
+            "**/ps3_update",
+            "**/ps3_vprm/**",
+            "**/ps3_vprm",
+            "**/extrafanart/**",
+            "**/extrafanart",
+            "**/extrathumbs/**",
+            "**/extrathumbs",
+            "**/.actors/**",
+            "**/.actors",
+            "**/.wd_tv/**",
+            "**/.wd_tv",
+            "**/lost+found/**",
+            "**/lost+found",
+            "**/subs/**",
+            "**/subs",
+            "**/.snapshots/**",
+            "**/.snapshots",
+            "**/.snapshot/**",
+            "**/.snapshot",
+
+            // Trickplay files
+            "**/*.trickplay",
+            "**/*.trickplay/**",
+
+            // WMC temp recording directories that will constantly be written to
+            "**/TempRec/**",
+            "**/TempRec",
+            "**/TempSBE/**",
+            "**/TempSBE",
+
+            // Synology
+            "**/eaDir/**",
+            "**/eaDir",
+            "**/@eaDir/**",
+            "**/@eaDir",
+            "**/#recycle/**",
+            "**/#recycle",
+
+            // Qnap
+            "**/@Recycle/**",
+            "**/@Recycle",
+            "**/.@__thumb/**",
+            "**/.@__thumb",
+            "**/$RECYCLE.BIN/**",
+            "**/$RECYCLE.BIN",
+            "**/System Volume Information/**",
+            "**/System Volume Information",
+            "**/.grab/**",
+            "**/.grab",
+
+            // Unix hidden files
+            "**/.*",
+
+            // Mac - if you ever remove the above.
+            // "**/._*",
+            // "**/.DS_Store",
+
+            // thumbs.db
+            "**/thumbs.db",
+
+            // bts sync files
+            "**/*.bts",
+            "**/*.sync",
+
+            // zfs
+            "**/.zfs/**",
+            "**/.zfs"
+        };
+
+        private static readonly GlobOptions _globOptions = new GlobOptions
+        {
+            Evaluation =
+            {
+                CaseInsensitive = true
+            }
+        };
+
+        private static readonly Glob[] _globs = Array.ConvertAll(_patterns, p => Glob.Parse(p, _globOptions));
+
+        /// <summary>
+        /// Returns true if the supplied path should be ignored.
+        /// </summary>
+        /// <param name="path">The path to test.</param>
+        /// <returns>Whether to ignore the path.</returns>
+        public static bool ShouldIgnore(ReadOnlySpan<char> path)
+        {
+            int len = _globs.Length;
+            for (int i = 0; i < len; i++)
+            {
+                if (_globs[i].IsMatch(path))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

Emby.Server.Implementations/Library/KeyframeManager.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.MediaEncoding.Keyframes;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library;
+
+/// <summary>
+/// Manager for Keyframe data.
+/// </summary>
+public class KeyframeManager : IKeyframeManager
+{
+    private readonly IKeyframeRepository _repository;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="KeyframeManager"/> class.
+    /// </summary>
+    /// <param name="repository">The keyframe repository.</param>
+    public KeyframeManager(IKeyframeRepository repository)
+    {
+        _repository = repository;
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<KeyframeData> GetKeyframeData(Guid itemId)
+    {
+        return _repository.GetKeyframeData(itemId);
+    }
+
+    /// <inheritdoc />
+    public async Task SaveKeyframeDataAsync(Guid itemId, KeyframeData data, CancellationToken cancellationToken)
+    {
+        await _repository.SaveKeyframeDataAsync(itemId, data, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public async Task DeleteKeyframeDataAsync(Guid itemId, CancellationToken cancellationToken)
+    {
+        await _repository.DeleteKeyframeDataAsync(itemId, cancellationToken).ConfigureAwait(false);
+    }
+}

Emby.Server.Implementations/Library/LiveStreamHelper.cs

@@ -0,0 +1,191 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Model.Dlna;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library
+{
+    public class LiveStreamHelper
+    {
+        private readonly IMediaEncoder _mediaEncoder;
+        private readonly ILogger _logger;
+        private readonly IApplicationPaths _appPaths;
+        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+
+        public LiveStreamHelper(IMediaEncoder mediaEncoder, ILogger logger, IApplicationPaths appPaths)
+        {
+            _mediaEncoder = mediaEncoder;
+            _logger = logger;
+            _appPaths = appPaths;
+        }
+
+        public async Task AddMediaInfoWithProbe(MediaSourceInfo mediaSource, bool isAudio, string? cacheKey, bool addProbeDelay, CancellationToken cancellationToken)
+        {
+            var originalRuntime = mediaSource.RunTimeTicks;
+
+            var now = DateTime.UtcNow;
+
+            MediaInfo? mediaInfo = null;
+            var cacheFilePath = string.IsNullOrEmpty(cacheKey) ? null : Path.Combine(_appPaths.CachePath, "mediainfo", cacheKey.GetMD5().ToString("N", CultureInfo.InvariantCulture) + ".json");
+
+            if (cacheFilePath is not null)
+            {
+                try
+                {
+                    FileStream jsonStream = AsyncFile.OpenRead(cacheFilePath);
+
+                    await using (jsonStream.ConfigureAwait(false))
+                    {
+                        mediaInfo = await JsonSerializer.DeserializeAsync<MediaInfo>(jsonStream, _jsonOptions, cancellationToken).ConfigureAwait(false);
+                        // _logger.LogDebug("Found cached media info");
+                    }
+                }
+                catch (IOException ex)
+                {
+                    _logger.LogDebug(ex, "Could not open cached media info");
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error opening cached media info");
+                }
+            }
+
+            if (mediaInfo is null)
+            {
+                if (addProbeDelay)
+                {
+                    var delayMs = mediaSource.AnalyzeDurationMs ?? 0;
+                    delayMs = Math.Max(3000, delayMs);
+                    _logger.LogInformation("Waiting {0}ms before probing the live stream", delayMs);
+                    await Task.Delay(delayMs, cancellationToken).ConfigureAwait(false);
+                }
+
+                mediaSource.AnalyzeDurationMs = 3000;
+
+                mediaInfo = await _mediaEncoder.GetMediaInfo(
+                    new MediaInfoRequest
+                    {
+                        MediaSource = mediaSource,
+                        MediaType = isAudio ? DlnaProfileType.Audio : DlnaProfileType.Video,
+                        ExtractChapters = false
+                    },
+                    cancellationToken).ConfigureAwait(false);
+
+                if (cacheFilePath is not null)
+                {
+                    Directory.CreateDirectory(Path.GetDirectoryName(cacheFilePath) ?? throw new InvalidOperationException("Path can't be a root directory."));
+                    FileStream createStream = AsyncFile.OpenWrite(cacheFilePath);
+                    await using (createStream.ConfigureAwait(false))
+                    {
+                        await JsonSerializer.SerializeAsync(createStream, mediaInfo, _jsonOptions, cancellationToken).ConfigureAwait(false);
+                    }
+
+                    _logger.LogDebug("Saved media info to {0}", cacheFilePath);
+                }
+            }
+
+            var mediaStreams = mediaInfo.MediaStreams;
+
+            if (!string.IsNullOrEmpty(cacheKey))
+            {
+                var newList = new List<MediaStream>();
+                newList.AddRange(mediaStreams.Where(i => i.Type == MediaStreamType.Video).Take(1));
+                newList.AddRange(mediaStreams.Where(i => i.Type == MediaStreamType.Audio).Take(1));
+
+                foreach (var stream in newList)
+                {
+                    stream.Index = -1;
+                    stream.Language = null;
+                }
+
+                mediaStreams = newList;
+            }
+
+            _logger.LogInformation("Live tv media info probe took {0} seconds", (DateTime.UtcNow - now).TotalSeconds.ToString(CultureInfo.InvariantCulture));
+
+            mediaSource.Bitrate = mediaInfo.Bitrate;
+            mediaSource.Container = mediaInfo.Container;
+            mediaSource.Formats = mediaInfo.Formats;
+            mediaSource.MediaStreams = mediaStreams;
+            mediaSource.RunTimeTicks = mediaInfo.RunTimeTicks;
+            mediaSource.Size = mediaInfo.Size;
+            mediaSource.Timestamp = mediaInfo.Timestamp;
+            mediaSource.Video3DFormat = mediaInfo.Video3DFormat;
+            mediaSource.VideoType = mediaInfo.VideoType;
+
+            mediaSource.DefaultSubtitleStreamIndex = null;
+
+            // Null this out so that it will be treated like a live stream
+            if (!originalRuntime.HasValue)
+            {
+                mediaSource.RunTimeTicks = null;
+            }
+
+            var audioStream = mediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Audio);
+
+            if (audioStream is null || audioStream.Index == -1)
+            {
+                mediaSource.DefaultAudioStreamIndex = null;
+            }
+            else
+            {
+                mediaSource.DefaultAudioStreamIndex = audioStream.Index;
+            }
+
+            var videoStream = mediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Video);
+            if (videoStream is not null)
+            {
+                if (!videoStream.BitRate.HasValue)
+                {
+                    var width = videoStream.Width ?? 1920;
+
+                    if (width >= 3000)
+                    {
+                        videoStream.BitRate = 30000000;
+                    }
+                    else if (width >= 1900)
+                    {
+                        videoStream.BitRate = 20000000;
+                    }
+                    else if (width >= 1200)
+                    {
+                        videoStream.BitRate = 8000000;
+                    }
+                    else if (width >= 700)
+                    {
+                        videoStream.BitRate = 2000000;
+                    }
+                }
+
+                // This is coming up false and preventing stream copy
+                videoStream.IsAVC = null;
+            }
+
+            mediaSource.AnalyzeDurationMs = 3000;
+
+            // Try to estimate this
+            mediaSource.InferTotalBitrate(true);
+        }
+
+        public Task AddMediaInfoWithProbe(MediaSourceInfo mediaSource, bool isAudio, bool addProbeDelay, CancellationToken cancellationToken)
+        {
+            return AddMediaInfoWithProbe(mediaSource, isAudio, null, addProbeDelay, cancellationToken);
+        }
+    }
+}

Emby.Server.Implementations/Library/MediaSourceManager.cs

@@ -0,0 +1,924 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using AsyncKeyedLock;
+using Jellyfin.Data;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Enums;
+using Jellyfin.Extensions;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Dlna;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library
+{
+    public class MediaSourceManager : IMediaSourceManager, IDisposable
+    {
+        // Do not use a pipe here because Roku http requests to the server will fail, without any explicit error message.
+        private const char LiveStreamIdDelimiter = '_';
+
+        private readonly IServerApplicationHost _appHost;
+        private readonly IItemRepository _itemRepo;
+        private readonly IUserManager _userManager;
+        private readonly ILibraryManager _libraryManager;
+        private readonly IFileSystem _fileSystem;
+        private readonly ILogger<MediaSourceManager> _logger;
+        private readonly IUserDataManager _userDataManager;
+        private readonly IMediaEncoder _mediaEncoder;
+        private readonly ILocalizationManager _localizationManager;
+        private readonly IApplicationPaths _appPaths;
+        private readonly IDirectoryService _directoryService;
+        private readonly IMediaStreamRepository _mediaStreamRepository;
+        private readonly IMediaAttachmentRepository _mediaAttachmentRepository;
+        private readonly ConcurrentDictionary<string, ILiveStream> _openStreams = new ConcurrentDictionary<string, ILiveStream>(StringComparer.OrdinalIgnoreCase);
+        private readonly AsyncNonKeyedLocker _liveStreamLocker = new(1);
+        private readonly JsonSerializerOptions _jsonOptions = JsonDefaults.Options;
+
+        private IMediaSourceProvider[] _providers;
+
+        public MediaSourceManager(
+            IServerApplicationHost appHost,
+            IItemRepository itemRepo,
+            IApplicationPaths applicationPaths,
+            ILocalizationManager localizationManager,
+            IUserManager userManager,
+            ILibraryManager libraryManager,
+            ILogger<MediaSourceManager> logger,
+            IFileSystem fileSystem,
+            IUserDataManager userDataManager,
+            IMediaEncoder mediaEncoder,
+            IDirectoryService directoryService,
+            IMediaStreamRepository mediaStreamRepository,
+            IMediaAttachmentRepository mediaAttachmentRepository)
+        {
+            _appHost = appHost;
+            _itemRepo = itemRepo;
+            _userManager = userManager;
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _fileSystem = fileSystem;
+            _userDataManager = userDataManager;
+            _mediaEncoder = mediaEncoder;
+            _localizationManager = localizationManager;
+            _appPaths = applicationPaths;
+            _directoryService = directoryService;
+            _mediaStreamRepository = mediaStreamRepository;
+            _mediaAttachmentRepository = mediaAttachmentRepository;
+        }
+
+        public void AddParts(IEnumerable<IMediaSourceProvider> providers)
+        {
+            _providers = providers.ToArray();
+        }
+
+        public IReadOnlyList<MediaStream> GetMediaStreams(MediaStreamQuery query)
+        {
+            var list = _mediaStreamRepository.GetMediaStreams(query);
+
+            foreach (var stream in list)
+            {
+                stream.SupportsExternalStream = StreamSupportsExternalStream(stream);
+            }
+
+            return list;
+        }
+
+        private static bool StreamSupportsExternalStream(MediaStream stream)
+        {
+            if (stream.IsExternal)
+            {
+                return true;
+            }
+
+            if (stream.IsTextSubtitleStream)
+            {
+                return true;
+            }
+
+            if (stream.IsPgsSubtitleStream)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public IReadOnlyList<MediaStream> GetMediaStreams(Guid itemId)
+        {
+            var list = GetMediaStreams(new MediaStreamQuery
+            {
+                ItemId = itemId
+            });
+
+            return GetMediaStreamsForItem(list);
+        }
+
+        private IReadOnlyList<MediaStream> GetMediaStreamsForItem(IReadOnlyList<MediaStream> streams)
+        {
+            foreach (var stream in streams)
+            {
+                if (stream.Type == MediaStreamType.Subtitle)
+                {
+                    stream.SupportsExternalStream = StreamSupportsExternalStream(stream);
+                }
+            }
+
+            return streams;
+        }
+
+        /// <inheritdoc />
+        public IReadOnlyList<MediaAttachment> GetMediaAttachments(MediaAttachmentQuery query)
+        {
+            return _mediaAttachmentRepository.GetMediaAttachments(query);
+        }
+
+        /// <inheritdoc />
+        public IReadOnlyList<MediaAttachment> GetMediaAttachments(Guid itemId)
+        {
+            return GetMediaAttachments(new MediaAttachmentQuery
+            {
+                ItemId = itemId
+            });
+        }
+
+        public async Task<IReadOnlyList<MediaSourceInfo>> GetPlaybackMediaSources(BaseItem item, User user, bool allowMediaProbe, bool enablePathSubstitution, CancellationToken cancellationToken)
+        {
+            var mediaSources = GetStaticMediaSources(item, enablePathSubstitution, user);
+
+            // If file is strm or main media stream is missing, force a metadata refresh with remote probing
+            if (allowMediaProbe && mediaSources[0].Type != MediaSourceType.Placeholder
+                && (item.Path.EndsWith(".strm", StringComparison.OrdinalIgnoreCase)
+                    || (item.MediaType == MediaType.Video && mediaSources[0].MediaStreams.All(i => i.Type != MediaStreamType.Video))
+                    || (item.MediaType == MediaType.Audio && mediaSources[0].MediaStreams.All(i => i.Type != MediaStreamType.Audio))))
+            {
+                await item.RefreshMetadata(
+                    new MetadataRefreshOptions(_directoryService)
+                    {
+                        EnableRemoteContentProbe = true,
+                        MetadataRefreshMode = MetadataRefreshMode.FullRefresh
+                    },
+                    cancellationToken).ConfigureAwait(false);
+
+                mediaSources = GetStaticMediaSources(item, enablePathSubstitution, user);
+            }
+
+            var dynamicMediaSources = await GetDynamicMediaSources(item, cancellationToken).ConfigureAwait(false);
+
+            var list = new List<MediaSourceInfo>();
+
+            list.AddRange(mediaSources);
+
+            foreach (var source in dynamicMediaSources)
+            {
+                // Validate that this is actually possible
+                if (source.SupportsDirectStream)
+                {
+                    source.SupportsDirectStream = SupportsDirectStream(source.Path, source.Protocol);
+                }
+
+                if (user is not null)
+                {
+                    SetDefaultAudioAndSubtitleStreamIndices(item, source, user);
+
+                    if (item.MediaType == MediaType.Audio)
+                    {
+                        source.SupportsTranscoding = user.HasPermission(PermissionKind.EnableAudioPlaybackTranscoding);
+                    }
+                    else if (item.MediaType == MediaType.Video)
+                    {
+                        source.SupportsTranscoding = user.HasPermission(PermissionKind.EnableVideoPlaybackTranscoding);
+                        source.SupportsDirectStream = user.HasPermission(PermissionKind.EnablePlaybackRemuxing);
+                    }
+                }
+
+                list.Add(source);
+            }
+
+            return SortMediaSources(list).ToArray();
+        }
+
+        /// <inheritdoc />>
+        public MediaProtocol GetPathProtocol(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                return MediaProtocol.File;
+            }
+
+            if (path.StartsWith("Rtsp", StringComparison.OrdinalIgnoreCase))
+            {
+                return MediaProtocol.Rtsp;
+            }
+
+            if (path.StartsWith("Rtmp", StringComparison.OrdinalIgnoreCase))
+            {
+                return MediaProtocol.Rtmp;
+            }
+
+            if (path.StartsWith("Http", StringComparison.OrdinalIgnoreCase))
+            {
+                return MediaProtocol.Http;
+            }
+
+            if (path.StartsWith("rtp", StringComparison.OrdinalIgnoreCase))
+            {
+                return MediaProtocol.Rtp;
+            }
+
+            if (path.StartsWith("ftp", StringComparison.OrdinalIgnoreCase))
+            {
+                return MediaProtocol.Ftp;
+            }
+
+            if (path.StartsWith("udp", StringComparison.OrdinalIgnoreCase))
+            {
+                return MediaProtocol.Udp;
+            }
+
+            return _fileSystem.IsPathFile(path) ? MediaProtocol.File : MediaProtocol.Http;
+        }
+
+        public bool SupportsDirectStream(string path, MediaProtocol protocol)
+        {
+            if (protocol == MediaProtocol.File)
+            {
+                return true;
+            }
+
+            if (protocol == MediaProtocol.Http)
+            {
+                if (path is not null)
+                {
+                    if (path.Contains(".m3u", StringComparison.OrdinalIgnoreCase))
+                    {
+                        return false;
+                    }
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private async Task<IEnumerable<MediaSourceInfo>> GetDynamicMediaSources(BaseItem item, CancellationToken cancellationToken)
+        {
+            var tasks = _providers.Select(i => GetDynamicMediaSources(item, i, cancellationToken));
+            var results = await Task.WhenAll(tasks).ConfigureAwait(false);
+
+            return results.SelectMany(i => i);
+        }
+
+        private async Task<IEnumerable<MediaSourceInfo>> GetDynamicMediaSources(BaseItem item, IMediaSourceProvider provider, CancellationToken cancellationToken)
+        {
+            try
+            {
+                var sources = await provider.GetMediaSources(item, cancellationToken).ConfigureAwait(false);
+                var list = sources.ToList();
+
+                foreach (var mediaSource in list)
+                {
+                    mediaSource.InferTotalBitrate();
+
+                    SetKeyProperties(provider, mediaSource);
+                }
+
+                return list;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error getting media sources");
+                return [];
+            }
+        }
+
+        private static void SetKeyProperties(IMediaSourceProvider provider, MediaSourceInfo mediaSource)
+        {
+            var prefix = provider.GetType().FullName.GetMD5().ToString("N", CultureInfo.InvariantCulture) + LiveStreamIdDelimiter;
+
+            if (!string.IsNullOrEmpty(mediaSource.OpenToken) && !mediaSource.OpenToken.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                mediaSource.OpenToken = prefix + mediaSource.OpenToken;
+            }
+
+            if (!string.IsNullOrEmpty(mediaSource.LiveStreamId) && !mediaSource.LiveStreamId.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                mediaSource.LiveStreamId = prefix + mediaSource.LiveStreamId;
+            }
+        }
+
+        public async Task<MediaSourceInfo> GetMediaSource(BaseItem item, string mediaSourceId, string liveStreamId, bool enablePathSubstitution, CancellationToken cancellationToken)
+        {
+            if (!string.IsNullOrEmpty(liveStreamId))
+            {
+                return await GetLiveStream(liveStreamId, cancellationToken).ConfigureAwait(false);
+            }
+
+            var sources = await GetPlaybackMediaSources(item, null, false, enablePathSubstitution, cancellationToken).ConfigureAwait(false);
+
+            return sources.FirstOrDefault(i => string.Equals(i.Id, mediaSourceId, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public IReadOnlyList<MediaSourceInfo> GetStaticMediaSources(BaseItem item, bool enablePathSubstitution, User user = null)
+        {
+            ArgumentNullException.ThrowIfNull(item);
+
+            var hasMediaSources = (IHasMediaSources)item;
+
+            var sources = hasMediaSources.GetMediaSources(enablePathSubstitution);
+
+            if (user is not null)
+            {
+                foreach (var source in sources)
+                {
+                    SetDefaultAudioAndSubtitleStreamIndices(item, source, user);
+
+                    if (item.MediaType == MediaType.Audio)
+                    {
+                        source.SupportsTranscoding = user.HasPermission(PermissionKind.EnableAudioPlaybackTranscoding);
+                    }
+                    else if (item.MediaType == MediaType.Video)
+                    {
+                        source.SupportsTranscoding = user.HasPermission(PermissionKind.EnableVideoPlaybackTranscoding);
+                        source.SupportsDirectStream = user.HasPermission(PermissionKind.EnablePlaybackRemuxing);
+                    }
+                }
+            }
+
+            return sources;
+        }
+
+        private IReadOnlyList<string> NormalizeLanguage(string language)
+        {
+            if (string.IsNullOrEmpty(language))
+            {
+                return [];
+            }
+
+            var culture = _localizationManager.FindLanguageInfo(language);
+            if (culture is not null)
+            {
+                return culture.Name.Contains('-', StringComparison.OrdinalIgnoreCase) ? [culture.Name] : culture.ThreeLetterISOLanguageNames;
+            }
+
+            return [language];
+        }
+
+        private void SetDefaultSubtitleStreamIndex(MediaSourceInfo source, UserItemData userData, User user, bool allowRememberingSelection)
+        {
+            if (userData is not null
+                && userData.SubtitleStreamIndex.HasValue
+                && user.RememberSubtitleSelections
+                && user.SubtitleMode != SubtitlePlaybackMode.None
+                && allowRememberingSelection)
+            {
+                var index = userData.SubtitleStreamIndex.Value;
+                // Make sure the saved index is still valid
+                if (index == -1 || source.MediaStreams.Any(i => i.Type == MediaStreamType.Subtitle && i.Index == index))
+                {
+                    source.DefaultSubtitleStreamIndex = index;
+                    return;
+                }
+            }
+
+            var preferredSubs = NormalizeLanguage(user.SubtitleLanguagePreference);
+
+            var defaultAudioIndex = source.DefaultAudioStreamIndex;
+            var audioLanguage = defaultAudioIndex is null
+                ? null
+                : source.MediaStreams.Where(i => i.Type == MediaStreamType.Audio && i.Index == defaultAudioIndex).Select(i => i.Language).FirstOrDefault();
+
+            source.DefaultSubtitleStreamIndex = MediaStreamSelector.GetDefaultSubtitleStreamIndex(
+                source.MediaStreams,
+                preferredSubs,
+                user.SubtitleMode,
+                audioLanguage);
+
+            MediaStreamSelector.SetSubtitleStreamScores(source.MediaStreams, preferredSubs, user.SubtitleMode, audioLanguage);
+        }
+
+        private void SetDefaultAudioStreamIndex(MediaSourceInfo source, UserItemData userData, User user, bool allowRememberingSelection)
+        {
+            if (userData is not null && userData.AudioStreamIndex.HasValue && user.RememberAudioSelections && allowRememberingSelection)
+            {
+                var index = userData.AudioStreamIndex.Value;
+                // Make sure the saved index is still valid
+                if (source.MediaStreams.Any(i => i.Type == MediaStreamType.Audio && i.Index == index))
+                {
+                    source.DefaultAudioStreamIndex = index;
+                    source.DefaultAudioIndexSource = AudioIndexSource.User;
+                    return;
+                }
+            }
+
+            var preferredAudio = NormalizeLanguage(user.AudioLanguagePreference);
+
+            source.DefaultAudioStreamIndex = MediaStreamSelector.GetDefaultAudioStreamIndex(source.MediaStreams, preferredAudio, user.PlayDefaultAudioTrack);
+            if (user.PlayDefaultAudioTrack)
+            {
+                source.DefaultAudioIndexSource |= AudioIndexSource.Default;
+            }
+
+            if (preferredAudio.Count > 0)
+            {
+                source.DefaultAudioIndexSource |= AudioIndexSource.Language;
+            }
+        }
+
+        public void SetDefaultAudioAndSubtitleStreamIndices(BaseItem item, MediaSourceInfo source, User user)
+        {
+            // Item would only be null if the app didn't supply ItemId as part of the live stream open request
+            var mediaType = item?.MediaType ?? MediaType.Video;
+
+            if (mediaType == MediaType.Video)
+            {
+                var userData = item is null ? null : _userDataManager.GetUserData(user, item);
+
+                var allowRememberingSelection = item is null || item.EnableRememberingTrackSelections;
+
+                SetDefaultAudioStreamIndex(source, userData, user, allowRememberingSelection);
+                SetDefaultSubtitleStreamIndex(source, userData, user, allowRememberingSelection);
+            }
+            else if (mediaType == MediaType.Audio)
+            {
+                var audio = source.MediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Audio);
+
+                if (audio is not null)
+                {
+                    source.DefaultAudioStreamIndex = audio.Index;
+                }
+            }
+        }
+
+        private static IEnumerable<MediaSourceInfo> SortMediaSources(IEnumerable<MediaSourceInfo> sources)
+        {
+            return sources.OrderBy(i =>
+            {
+                if (i.VideoType.HasValue && i.VideoType.Value == VideoType.VideoFile)
+                {
+                    return 0;
+                }
+
+                return 1;
+            }).ThenBy(i => i.Video3DFormat.HasValue ? 1 : 0)
+            .ThenByDescending(i =>
+            {
+                var stream = i.VideoStream;
+
+                return stream?.Width ?? 0;
+            })
+            .Where(i => i.Type != MediaSourceType.Placeholder);
+        }
+
+        public async Task<Tuple<LiveStreamResponse, IDirectStreamProvider>> OpenLiveStreamInternal(LiveStreamRequest request, CancellationToken cancellationToken)
+        {
+            MediaSourceInfo mediaSource;
+            ILiveStream liveStream;
+
+            using (await _liveStreamLocker.LockAsync(cancellationToken).ConfigureAwait(false))
+            {
+                var (provider, keyId) = GetProvider(request.OpenToken);
+
+                var currentLiveStreams = _openStreams.Values.ToList();
+
+                liveStream = await provider.OpenMediaSource(keyId, currentLiveStreams, cancellationToken).ConfigureAwait(false);
+
+                mediaSource = liveStream.MediaSource;
+
+                // Validate that this is actually possible
+                if (mediaSource.SupportsDirectStream)
+                {
+                    mediaSource.SupportsDirectStream = SupportsDirectStream(mediaSource.Path, mediaSource.Protocol);
+                }
+
+                SetKeyProperties(provider, mediaSource);
+
+                _openStreams[mediaSource.LiveStreamId] = liveStream;
+            }
+
+            try
+            {
+                if (mediaSource.MediaStreams.Any(i => i.Index != -1) || !mediaSource.SupportsProbing)
+                {
+                    AddMediaInfo(mediaSource);
+                }
+                else
+                {
+                    // hack - these two values were taken from LiveTVMediaSourceProvider
+                    string cacheKey = request.OpenToken;
+
+                    await new LiveStreamHelper(_mediaEncoder, _logger, _appPaths)
+                        .AddMediaInfoWithProbe(mediaSource, false, cacheKey, true, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error probing live tv stream");
+                AddMediaInfo(mediaSource);
+            }
+
+            // TODO: @bond Fix
+            var json = JsonSerializer.SerializeToUtf8Bytes(mediaSource, _jsonOptions);
+            _logger.LogInformation("Live stream opened: {@MediaSource}", mediaSource);
+            var clone = JsonSerializer.Deserialize<MediaSourceInfo>(json, _jsonOptions);
+
+            if (!request.UserId.IsEmpty())
+            {
+                var user = _userManager.GetUserById(request.UserId);
+                var item = request.ItemId.IsEmpty()
+                    ? null
+                    : _libraryManager.GetItemById(request.ItemId);
+                SetDefaultAudioAndSubtitleStreamIndices(item, clone, user);
+            }
+
+            return new Tuple<LiveStreamResponse, IDirectStreamProvider>(new LiveStreamResponse(clone), liveStream as IDirectStreamProvider);
+        }
+
+        private static void AddMediaInfo(MediaSourceInfo mediaSource)
+        {
+            mediaSource.DefaultSubtitleStreamIndex = null;
+
+            // Null this out so that it will be treated like a live stream
+            if (mediaSource.IsInfiniteStream)
+            {
+                mediaSource.RunTimeTicks = null;
+            }
+
+            var audioStream = mediaSource.MediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Audio);
+
+            if (audioStream is null || audioStream.Index == -1)
+            {
+                mediaSource.DefaultAudioStreamIndex = null;
+            }
+            else
+            {
+                mediaSource.DefaultAudioStreamIndex = audioStream.Index;
+            }
+
+            var videoStream = mediaSource.MediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Video);
+            if (videoStream is not null)
+            {
+                if (!videoStream.BitRate.HasValue)
+                {
+                    var width = videoStream.Width ?? 1920;
+
+                    if (width >= 3000)
+                    {
+                        videoStream.BitRate = 30000000;
+                    }
+                    else if (width >= 1900)
+                    {
+                        videoStream.BitRate = 20000000;
+                    }
+                    else if (width >= 1200)
+                    {
+                        videoStream.BitRate = 8000000;
+                    }
+                    else if (width >= 700)
+                    {
+                        videoStream.BitRate = 2000000;
+                    }
+                }
+            }
+
+            // Try to estimate this
+            mediaSource.InferTotalBitrate();
+        }
+
+        public async Task<LiveStreamResponse> OpenLiveStream(LiveStreamRequest request, CancellationToken cancellationToken)
+        {
+            var result = await OpenLiveStreamInternal(request, cancellationToken).ConfigureAwait(false);
+            return result.Item1;
+        }
+
+        public async Task<MediaSourceInfo> GetLiveStreamMediaInfo(string id, CancellationToken cancellationToken)
+        {
+            // TODO probably shouldn't throw here but it is kept for "backwards compatibility"
+            var liveStreamInfo = GetLiveStreamInfo(id) ?? throw new ResourceNotFoundException();
+
+            var mediaSource = liveStreamInfo.MediaSource;
+
+            if (liveStreamInfo is IDirectStreamProvider)
+            {
+                var info = await _mediaEncoder.GetMediaInfo(
+                    new MediaInfoRequest
+                    {
+                        MediaSource = mediaSource,
+                        ExtractChapters = false,
+                        MediaType = DlnaProfileType.Video
+                    },
+                    cancellationToken).ConfigureAwait(false);
+
+                mediaSource.MediaStreams = info.MediaStreams;
+                mediaSource.Container = info.Container;
+                mediaSource.Bitrate = info.Bitrate;
+            }
+
+            return mediaSource;
+        }
+
+        public async Task AddMediaInfoWithProbe(MediaSourceInfo mediaSource, bool isAudio, string cacheKey, bool addProbeDelay, bool isLiveStream, CancellationToken cancellationToken)
+        {
+            var originalRuntime = mediaSource.RunTimeTicks;
+
+            var now = DateTime.UtcNow;
+
+            MediaInfo mediaInfo = null;
+            var cacheFilePath = string.IsNullOrEmpty(cacheKey) ? null : Path.Combine(_appPaths.CachePath, "mediainfo", cacheKey.GetMD5().ToString("N", CultureInfo.InvariantCulture) + ".json");
+
+            if (!string.IsNullOrEmpty(cacheKey))
+            {
+                FileStream jsonStream = AsyncFile.OpenRead(cacheFilePath);
+                try
+                {
+                    mediaInfo = await JsonSerializer.DeserializeAsync<MediaInfo>(jsonStream, _jsonOptions, cancellationToken).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogDebug(ex, "Error parsing cached media info.");
+                }
+                finally
+                {
+                    await jsonStream.DisposeAsync().ConfigureAwait(false);
+                }
+            }
+
+            if (mediaInfo is null)
+            {
+                if (addProbeDelay)
+                {
+                    var delayMs = mediaSource.AnalyzeDurationMs ?? 0;
+                    delayMs = Math.Max(3000, delayMs);
+                    await Task.Delay(delayMs, cancellationToken).ConfigureAwait(false);
+                }
+
+                if (isLiveStream)
+                {
+                    mediaSource.AnalyzeDurationMs = 3000;
+                }
+
+                mediaInfo = await _mediaEncoder.GetMediaInfo(
+                    new MediaInfoRequest
+                    {
+                        MediaSource = mediaSource,
+                        MediaType = isAudio ? DlnaProfileType.Audio : DlnaProfileType.Video,
+                        ExtractChapters = false
+                    },
+                    cancellationToken).ConfigureAwait(false);
+
+                if (cacheFilePath is not null)
+                {
+                    Directory.CreateDirectory(Path.GetDirectoryName(cacheFilePath));
+                    FileStream createStream = AsyncFile.Create(cacheFilePath);
+                    await using (createStream.ConfigureAwait(false))
+                    {
+                        await JsonSerializer.SerializeAsync(createStream, mediaInfo, _jsonOptions, cancellationToken).ConfigureAwait(false);
+                    }
+
+                    // _logger.LogDebug("Saved media info to {0}", cacheFilePath);
+                }
+            }
+
+            var mediaStreams = mediaInfo.MediaStreams;
+
+            if (isLiveStream && !string.IsNullOrEmpty(cacheKey))
+            {
+                var newList = new List<MediaStream>();
+                newList.AddRange(mediaStreams.Where(i => i.Type == MediaStreamType.Video).Take(1));
+                newList.AddRange(mediaStreams.Where(i => i.Type == MediaStreamType.Audio).Take(1));
+
+                foreach (var stream in newList)
+                {
+                    stream.Index = -1;
+                    stream.Language = null;
+                }
+
+                mediaStreams = newList;
+            }
+
+            _logger.LogInformation("Live tv media info probe took {0} seconds", (DateTime.UtcNow - now).TotalSeconds.ToString(CultureInfo.InvariantCulture));
+
+            mediaSource.Bitrate = mediaInfo.Bitrate;
+            mediaSource.Container = mediaInfo.Container;
+            mediaSource.Formats = mediaInfo.Formats;
+            mediaSource.MediaStreams = mediaStreams;
+            mediaSource.RunTimeTicks = mediaInfo.RunTimeTicks;
+            mediaSource.Size = mediaInfo.Size;
+            mediaSource.Timestamp = mediaInfo.Timestamp;
+            mediaSource.Video3DFormat = mediaInfo.Video3DFormat;
+            mediaSource.VideoType = mediaInfo.VideoType;
+
+            mediaSource.DefaultSubtitleStreamIndex = null;
+
+            if (isLiveStream)
+            {
+                // Null this out so that it will be treated like a live stream
+                if (!originalRuntime.HasValue)
+                {
+                    mediaSource.RunTimeTicks = null;
+                }
+            }
+
+            var audioStream = mediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Audio);
+
+            if (audioStream is null || audioStream.Index == -1)
+            {
+                mediaSource.DefaultAudioStreamIndex = null;
+            }
+            else
+            {
+                mediaSource.DefaultAudioStreamIndex = audioStream.Index;
+            }
+
+            var videoStream = mediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Video);
+            if (videoStream is not null)
+            {
+                if (!videoStream.BitRate.HasValue)
+                {
+                    var width = videoStream.Width ?? 1920;
+
+                    if (width >= 3000)
+                    {
+                        videoStream.BitRate = 30000000;
+                    }
+                    else if (width >= 1900)
+                    {
+                        videoStream.BitRate = 20000000;
+                    }
+                    else if (width >= 1200)
+                    {
+                        videoStream.BitRate = 8000000;
+                    }
+                    else if (width >= 700)
+                    {
+                        videoStream.BitRate = 2000000;
+                    }
+                }
+
+                // This is coming up false and preventing stream copy
+                videoStream.IsAVC = null;
+            }
+
+            if (isLiveStream)
+            {
+                mediaSource.AnalyzeDurationMs = 3000;
+            }
+
+            // Try to estimate this
+            mediaSource.InferTotalBitrate(true);
+        }
+
+        public Task<Tuple<MediaSourceInfo, IDirectStreamProvider>> GetLiveStreamWithDirectStreamProvider(string id, CancellationToken cancellationToken)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(id);
+
+            var info = GetLiveStreamInfo(id);
+            if (info is null)
+            {
+                return Task.FromResult<Tuple<MediaSourceInfo, IDirectStreamProvider>>(new Tuple<MediaSourceInfo, IDirectStreamProvider>(null, null));
+            }
+
+            return Task.FromResult<Tuple<MediaSourceInfo, IDirectStreamProvider>>(new Tuple<MediaSourceInfo, IDirectStreamProvider>(info.MediaSource, info as IDirectStreamProvider));
+        }
+
+        public ILiveStream GetLiveStreamInfo(string id)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(id);
+
+            if (_openStreams.TryGetValue(id, out ILiveStream info))
+            {
+                return info;
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc />
+        public ILiveStream GetLiveStreamInfoByUniqueId(string uniqueId)
+        {
+            return _openStreams.Values.FirstOrDefault(stream => string.Equals(uniqueId, stream?.UniqueId, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public async Task<MediaSourceInfo> GetLiveStream(string id, CancellationToken cancellationToken)
+        {
+            var result = await GetLiveStreamWithDirectStreamProvider(id, cancellationToken).ConfigureAwait(false);
+            return result.Item1;
+        }
+
+        public async Task<IReadOnlyList<MediaSourceInfo>> GetRecordingStreamMediaSources(ActiveRecordingInfo info, CancellationToken cancellationToken)
+        {
+            var stream = new MediaSourceInfo
+            {
+                EncoderPath = _appHost.GetApiUrlForLocalAccess() + "/LiveTv/LiveRecordings/" + info.Id + "/stream",
+                EncoderProtocol = MediaProtocol.Http,
+                Path = info.Path,
+                Protocol = MediaProtocol.File,
+                Id = info.Id,
+                SupportsDirectPlay = false,
+                SupportsDirectStream = true,
+                SupportsTranscoding = true,
+                IsInfiniteStream = true,
+                RequiresOpening = false,
+                RequiresClosing = false,
+                BufferMs = 0,
+                IgnoreDts = true,
+                IgnoreIndex = true
+            };
+
+            await new LiveStreamHelper(_mediaEncoder, _logger, _appPaths)
+                .AddMediaInfoWithProbe(stream, false, false, cancellationToken).ConfigureAwait(false);
+
+            return [stream];
+        }
+
+        public async Task CloseLiveStream(string id)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(id);
+
+            using (await _liveStreamLocker.LockAsync().ConfigureAwait(false))
+            {
+                if (_openStreams.TryGetValue(id, out ILiveStream liveStream))
+                {
+                    liveStream.ConsumerCount--;
+
+                    _logger.LogInformation("Live stream {0} consumer count is now {1}", liveStream.OriginalStreamId, liveStream.ConsumerCount);
+
+                    if (liveStream.ConsumerCount <= 0)
+                    {
+                        _openStreams.TryRemove(id, out _);
+
+                        _logger.LogInformation("Closing live stream {0}", id);
+
+                        await liveStream.Close().ConfigureAwait(false);
+                        _logger.LogInformation("Live stream {0} closed successfully", id);
+                    }
+                }
+            }
+        }
+
+        private (IMediaSourceProvider MediaSourceProvider, string KeyId) GetProvider(string key)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(key);
+
+            var keys = key.Split(LiveStreamIdDelimiter, 2);
+
+            var provider = _providers.FirstOrDefault(i => string.Equals(i.GetType().FullName.GetMD5().ToString("N", CultureInfo.InvariantCulture), keys[0], StringComparison.OrdinalIgnoreCase));
+
+            var splitIndex = key.IndexOf(LiveStreamIdDelimiter, StringComparison.Ordinal);
+            var keyId = key.Substring(splitIndex + 1);
+
+            return (provider, keyId);
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool dispose)
+        {
+            if (dispose)
+            {
+                foreach (var key in _openStreams.Keys.ToList())
+                {
+                    CloseLiveStream(key).GetAwaiter().GetResult();
+                }
+
+                _liveStreamLocker.Dispose();
+            }
+        }
+    }
+}

Emby.Server.Implementations/Library/MediaStreamSelector.cs

@@ -0,0 +1,193 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Jellyfin.Database.Implementations.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Model.Entities;
+
+namespace Emby.Server.Implementations.Library
+{
+    public static class MediaStreamSelector
+    {
+        public static int? GetDefaultAudioStreamIndex(IReadOnlyList<MediaStream> streams, IReadOnlyList<string> preferredLanguages, bool preferDefaultTrack)
+        {
+            var sortedStreams = GetSortedStreams(streams, MediaStreamType.Audio, preferredLanguages).ToList();
+
+            if (preferDefaultTrack)
+            {
+                var defaultStream = sortedStreams.FirstOrDefault(i => i.IsDefault);
+
+                if (defaultStream is not null)
+                {
+                    return defaultStream.Index;
+                }
+            }
+
+            return sortedStreams.FirstOrDefault()?.Index;
+        }
+
+        public static int? GetDefaultSubtitleStreamIndex(
+            IEnumerable<MediaStream> streams,
+            IReadOnlyList<string> preferredLanguages,
+            SubtitlePlaybackMode mode,
+            string audioTrackLanguage)
+        {
+            if (mode == SubtitlePlaybackMode.None)
+            {
+                return null;
+            }
+
+            // Sort in the following order: Default > No tag > Forced
+            var sortedStreams = streams
+                .Where(i => i.Type == MediaStreamType.Subtitle)
+                .OrderByDescending(x => x.IsExternal)
+                .ThenByDescending(x => x.IsDefault)
+                .ThenByDescending(x => !x.IsForced && MatchesPreferredLanguage(x.Language, preferredLanguages))
+                .ThenByDescending(x => x.IsForced && MatchesPreferredLanguage(x.Language, preferredLanguages))
+                .ThenByDescending(x => x.IsForced && IsLanguageUndefined(x.Language))
+                .ThenByDescending(x => x.IsForced)
+                .ToList();
+
+            MediaStream? stream = null;
+
+            if (mode == SubtitlePlaybackMode.Default)
+            {
+                // Load subtitles according to external, default and forced flags.
+                stream = sortedStreams.FirstOrDefault(x => x.IsExternal || x.IsDefault || x.IsForced);
+            }
+            else if (mode == SubtitlePlaybackMode.Smart)
+            {
+                // Only attempt to load subtitles if the audio language is not one of the user's preferred subtitle languages.
+                // If no subtitles of preferred language available, use none.
+                // If the audio language is one of the user's preferred subtitle languages behave like OnlyForced.
+                if (!preferredLanguages.Contains(audioTrackLanguage, StringComparison.OrdinalIgnoreCase))
+                {
+                    stream = sortedStreams.FirstOrDefault(x => MatchesPreferredLanguage(x.Language, preferredLanguages));
+                }
+                else
+                {
+                    stream = BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
+                }
+            }
+            else if (mode == SubtitlePlaybackMode.Always)
+            {
+                // Always load (full/non-forced) subtitles of the user's preferred subtitle language if possible, otherwise OnlyForced behaviour.
+                stream = sortedStreams.FirstOrDefault(x => !x.IsForced && MatchesPreferredLanguage(x.Language, preferredLanguages)) ??
+                    BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
+            }
+            else if (mode == SubtitlePlaybackMode.OnlyForced)
+            {
+                // Load subtitles that are flagged forced of the user's preferred subtitle language or with an undefined language
+                stream = BehaviorOnlyForced(sortedStreams, preferredLanguages).FirstOrDefault();
+            }
+
+            return stream?.Index;
+        }
+
+        private static IEnumerable<MediaStream> GetSortedStreams(IEnumerable<MediaStream> streams, MediaStreamType type, IReadOnlyList<string> languagePreferences)
+        {
+            // Give some preference to external text subs for better performance
+            return streams
+                .Where(i => i.Type == type)
+                .OrderByDescending(i => GetStreamScore(i, languagePreferences));
+        }
+
+        public static void SetSubtitleStreamScores(
+            IReadOnlyList<MediaStream> streams,
+            IReadOnlyList<string> preferredLanguages,
+            SubtitlePlaybackMode mode,
+            string audioTrackLanguage)
+        {
+            if (mode == SubtitlePlaybackMode.None)
+            {
+                return;
+            }
+
+            var sortedStreams = GetSortedStreams(streams, MediaStreamType.Subtitle, preferredLanguages).ToList();
+
+            List<MediaStream>? filteredStreams = null;
+
+            if (mode == SubtitlePlaybackMode.Default)
+            {
+                // Prefer embedded metadata over smart logic
+                // Load subtitles according to external, default, and forced flags.
+                filteredStreams = sortedStreams.Where(s => s.IsExternal || s.IsDefault || s.IsForced)
+                    .ToList();
+            }
+            else if (mode == SubtitlePlaybackMode.Smart)
+            {
+                // Prefer smart logic over embedded metadata
+                // Only attempt to load subtitles if the audio language is not one of the user's preferred subtitle languages, otherwise OnlyForced behavior.
+                if (!preferredLanguages.Contains(audioTrackLanguage, StringComparison.OrdinalIgnoreCase))
+                {
+                    filteredStreams = sortedStreams.Where(s => MatchesPreferredLanguage(s.Language, preferredLanguages))
+                        .ToList();
+                }
+                else
+                {
+                    filteredStreams = BehaviorOnlyForced(sortedStreams, preferredLanguages);
+                }
+            }
+            else if (mode == SubtitlePlaybackMode.Always)
+            {
+                // Always load (full/non-forced) subtitles of the user's preferred subtitle language if possible, otherwise OnlyForced behavior.
+                filteredStreams = sortedStreams.Where(s => !s.IsForced && MatchesPreferredLanguage(s.Language, preferredLanguages))
+                    .ToList() ?? BehaviorOnlyForced(sortedStreams, preferredLanguages);
+            }
+            else if (mode == SubtitlePlaybackMode.OnlyForced)
+            {
+                // Load subtitles that are flagged forced of the user's preferred subtitle language or with an undefined language
+                filteredStreams = BehaviorOnlyForced(sortedStreams, preferredLanguages);
+            }
+
+            // If filteredStreams is null, initialize it as an empty list to avoid null reference errors
+            filteredStreams ??= new List<MediaStream>();
+
+            foreach (var stream in filteredStreams)
+            {
+                stream.Score = GetStreamScore(stream, preferredLanguages);
+            }
+        }
+
+        private static bool MatchesPreferredLanguage(string language, IReadOnlyList<string> preferredLanguages)
+        {
+            // If preferredLanguages is empty, treat it as "any language" (wildcard)
+            return preferredLanguages.Count == 0 ||
+                preferredLanguages.Contains(language, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static bool IsLanguageUndefined(string language)
+        {
+            // Check for null, empty, or known placeholders
+            return string.IsNullOrEmpty(language) ||
+                language.Equals("und", StringComparison.OrdinalIgnoreCase) ||
+                language.Equals("unknown", StringComparison.OrdinalIgnoreCase) ||
+                language.Equals("undetermined", StringComparison.OrdinalIgnoreCase) ||
+                language.Equals("mul", StringComparison.OrdinalIgnoreCase) ||
+                language.Equals("zxx", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static List<MediaStream> BehaviorOnlyForced(IEnumerable<MediaStream> sortedStreams, IReadOnlyList<string> preferredLanguages)
+        {
+            return sortedStreams
+                .Where(s => s.IsForced && (MatchesPreferredLanguage(s.Language, preferredLanguages) || IsLanguageUndefined(s.Language)))
+                .OrderByDescending(s => MatchesPreferredLanguage(s.Language, preferredLanguages))
+                .ThenByDescending(s => IsLanguageUndefined(s.Language))
+                .ToList();
+        }
+
+        internal static int GetStreamScore(MediaStream stream, IReadOnlyList<string> languagePreferences)
+        {
+            var index = languagePreferences.FindIndex(x => string.Equals(x, stream.Language, StringComparison.OrdinalIgnoreCase));
+            var score = index == -1 ? 1 : 101 - index;
+            score = (score * 10) + (stream.IsForced ? 2 : 1);
+            score = (score * 10) + (stream.IsDefault ? 2 : 1);
+            score = (score * 10) + (stream.SupportsExternalStream ? 2 : 1);
+            score = (score * 10) + (stream.IsTextSubtitleStream ? 2 : 1);
+            score = (score * 10) + (stream.IsExternal ? 2 : 1);
+            return score;
+        }
+    }
+}

Emby.Server.Implementations/Library/MusicManager.cs

@@ -0,0 +1,135 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
+using MusicAlbum = MediaBrowser.Controller.Entities.Audio.MusicAlbum;
+
+namespace Emby.Server.Implementations.Library
+{
+    public class MusicManager : IMusicManager
+    {
+        private readonly ILibraryManager _libraryManager;
+
+        public MusicManager(ILibraryManager libraryManager)
+        {
+            _libraryManager = libraryManager;
+        }
+
+        public IReadOnlyList<BaseItem> GetInstantMixFromSong(Audio item, User? user, DtoOptions dtoOptions)
+        {
+            var instantMixItems = GetInstantMixFromGenres(item.Genres, user, dtoOptions);
+
+            return [item, .. instantMixItems.Where(i => !i.Id.Equals(item.Id))];
+        }
+
+        /// <inheritdoc />
+        public IReadOnlyList<BaseItem> GetInstantMixFromArtist(MusicArtist artist, User? user, DtoOptions dtoOptions)
+        {
+            return GetInstantMixFromGenres(artist.Genres, user, dtoOptions);
+        }
+
+        public IReadOnlyList<BaseItem> GetInstantMixFromAlbum(MusicAlbum item, User? user, DtoOptions dtoOptions)
+        {
+            return GetInstantMixFromGenres(item.Genres, user, dtoOptions);
+        }
+
+        public IReadOnlyList<BaseItem> GetInstantMixFromFolder(Folder item, User? user, DtoOptions dtoOptions)
+        {
+            var genres = item
+               .GetRecursiveChildren(
+                user,
+                new InternalItemsQuery(user)
+                {
+                    IncludeItemTypes = [BaseItemKind.Audio],
+                    DtoOptions = dtoOptions
+                },
+                out _)
+               .Cast<Audio>()
+               .SelectMany(i => i.Genres)
+               .Concat(item.Genres)
+               .DistinctNames();
+
+            return GetInstantMixFromGenres(genres, user, dtoOptions);
+        }
+
+        public IReadOnlyList<BaseItem> GetInstantMixFromPlaylist(Playlist item, User? user, DtoOptions dtoOptions)
+        {
+            return GetInstantMixFromGenres(item.Genres, user, dtoOptions);
+        }
+
+        public IReadOnlyList<BaseItem> GetInstantMixFromGenres(IEnumerable<string> genres, User? user, DtoOptions dtoOptions)
+        {
+            var genreIds = genres.DistinctNames().Select(i =>
+            {
+                try
+                {
+                    return _libraryManager.GetMusicGenre(i).Id;
+                }
+                catch
+                {
+                    return Guid.Empty;
+                }
+            }).Where(i => !i.IsEmpty()).ToArray();
+
+            return GetInstantMixFromGenreIds(genreIds, user, dtoOptions);
+        }
+
+        public IReadOnlyList<BaseItem> GetInstantMixFromGenreIds(Guid[] genreIds, User? user, DtoOptions dtoOptions)
+        {
+            return _libraryManager.GetItemList(new InternalItemsQuery(user)
+            {
+                IncludeItemTypes = [BaseItemKind.Audio],
+                GenreIds = genreIds,
+                Limit = 200,
+                OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)],
+                DtoOptions = dtoOptions
+            });
+        }
+
+        public IReadOnlyList<BaseItem> GetInstantMixFromItem(BaseItem item, User? user, DtoOptions dtoOptions)
+        {
+            if (item is MusicGenre)
+            {
+                return GetInstantMixFromGenreIds([item.Id], user, dtoOptions);
+            }
+
+            if (item is Playlist playlist)
+            {
+                return GetInstantMixFromPlaylist(playlist, user, dtoOptions);
+            }
+
+            if (item is MusicAlbum album)
+            {
+                return GetInstantMixFromAlbum(album, user, dtoOptions);
+            }
+
+            if (item is MusicArtist artist)
+            {
+                return GetInstantMixFromArtist(artist, user, dtoOptions);
+            }
+
+            if (item is Audio song)
+            {
+                return GetInstantMixFromSong(song, user, dtoOptions);
+            }
+
+            if (item is Folder folder)
+            {
+                return GetInstantMixFromFolder(folder, user, dtoOptions);
+            }
+
+            return new List<BaseItem>();
+        }
+    }
+}

Emby.Server.Implementations/Library/PathExtensions.cs

@@ -0,0 +1,204 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using MediaBrowser.Common.Providers;
+
+namespace Emby.Server.Implementations.Library
+{
+    /// <summary>
+    /// Class providing extension methods for working with paths.
+    /// </summary>
+    public static class PathExtensions
+    {
+        /// <summary>
+        /// Gets the attribute value.
+        /// </summary>
+        /// <param name="str">The STR.</param>
+        /// <param name="attribute">The attrib.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="ArgumentException"><paramref name="str" /> or <paramref name="attribute" /> is empty.</exception>
+        public static string? GetAttributeValue(this ReadOnlySpan<char> str, ReadOnlySpan<char> attribute)
+        {
+            if (str.Length == 0)
+            {
+                throw new ArgumentException("String can't be empty.", nameof(str));
+            }
+
+            if (attribute.Length == 0)
+            {
+                throw new ArgumentException("String can't be empty.", nameof(attribute));
+            }
+
+            var attributeIndex = str.IndexOf(attribute, StringComparison.OrdinalIgnoreCase);
+
+            // Must be at least 3 characters after the attribute =, ], any character,
+            // then we offset it by 1, because we want the index and not length.
+            var maxIndex = str.Length - attribute.Length - 2;
+            while (attributeIndex > -1 && attributeIndex < maxIndex)
+            {
+                var attributeEnd = attributeIndex + attribute.Length;
+                if (attributeIndex > 0)
+                {
+                    var attributeOpener = str[attributeIndex - 1];
+                    var attributeCloser = attributeOpener switch
+                    {
+                        '[' => ']',
+                        '(' => ')',
+                        '{' => '}',
+                         _ => '\0'
+                    };
+                    if (attributeCloser != '\0' && (str[attributeEnd] == '=' || str[attributeEnd] == '-'))
+                    {
+                        var closingIndex = str[attributeEnd..].IndexOf(attributeCloser);
+
+                        // Must be at least 1 character before the closing bracket.
+                        if (closingIndex > 1)
+                        {
+                            return str[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim().ToString();
+                        }
+                    }
+                }
+
+                str = str[attributeEnd..];
+                attributeIndex = str.IndexOf(attribute, StringComparison.OrdinalIgnoreCase);
+            }
+
+            // for imdbid we also accept pattern matching
+            if (attribute.Equals("imdbid", StringComparison.OrdinalIgnoreCase))
+            {
+                var match = ProviderIdParsers.TryFindImdbId(str, out var imdbId);
+                return match ? imdbId.ToString() : null;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Replaces a sub path with another sub path and normalizes the final path.
+        /// </summary>
+        /// <param name="path">The original path.</param>
+        /// <param name="subPath">The original sub path.</param>
+        /// <param name="newSubPath">The new sub path.</param>
+        /// <param name="newPath">The result of the sub path replacement.</param>
+        /// <returns>The path after replacing the sub path.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path" />, <paramref name="newSubPath" /> or <paramref name="newSubPath" /> is empty.</exception>
+        public static bool TryReplaceSubPath(
+            [NotNullWhen(true)] this string? path,
+            [NotNullWhen(true)] string? subPath,
+            [NotNullWhen(true)] string? newSubPath,
+            [NotNullWhen(true)] out string? newPath)
+        {
+            newPath = null;
+
+            if (string.IsNullOrEmpty(path)
+                || string.IsNullOrEmpty(subPath)
+                || string.IsNullOrEmpty(newSubPath)
+                || subPath.Length > path.Length)
+            {
+                return false;
+            }
+
+            subPath = subPath.NormalizePath(out var newDirectorySeparatorChar);
+            path = path.NormalizePath(newDirectorySeparatorChar);
+
+            // We have to ensure that the sub path ends with a directory separator otherwise we'll get weird results
+            // when the sub path matches a similar but in-complete subpath
+            var oldSubPathEndsWithSeparator = subPath[^1] == newDirectorySeparatorChar;
+            if (!path.StartsWith(subPath, StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            if (path.Length > subPath.Length
+                && !oldSubPathEndsWithSeparator
+                && path[subPath.Length] != newDirectorySeparatorChar)
+            {
+                return false;
+            }
+
+            var newSubPathTrimmed = newSubPath.AsSpan().TrimEnd(newDirectorySeparatorChar);
+            // Ensure that the path with the old subpath removed starts with a leading dir separator
+            int idx = oldSubPathEndsWithSeparator ? subPath.Length - 1 : subPath.Length;
+            newPath = string.Concat(newSubPathTrimmed, path.AsSpan(idx));
+
+            return true;
+        }
+
+        /// <summary>
+        /// Retrieves the full resolved path and normalizes path separators to the <see cref="Path.DirectorySeparatorChar"/>.
+        /// </summary>
+        /// <param name="path">The path to canonicalize.</param>
+        /// <returns>The fully expanded, normalized path.</returns>
+        public static string Canonicalize(this string path)
+        {
+            return Path.GetFullPath(path).NormalizePath();
+        }
+
+        /// <summary>
+        /// Normalizes the path's directory separator character to the currently defined <see cref="Path.DirectorySeparatorChar"/>.
+        /// </summary>
+        /// <param name="path">The path to normalize.</param>
+        /// <returns>The normalized path string or <see langword="null"/> if the input path is null or empty.</returns>
+        [return: NotNullIfNotNull(nameof(path))]
+        public static string? NormalizePath(this string? path)
+        {
+            return path.NormalizePath(Path.DirectorySeparatorChar);
+        }
+
+        /// <summary>
+        /// Normalizes the path's directory separator character.
+        /// </summary>
+        /// <param name="path">The path to normalize.</param>
+        /// <param name="separator">The separator character the path now uses or <see langword="null"/>.</param>
+        /// <returns>The normalized path string or <see langword="null"/> if the input path is null or empty.</returns>
+        [return: NotNullIfNotNull(nameof(path))]
+        public static string? NormalizePath(this string? path, out char separator)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                separator = default;
+                return path;
+            }
+
+            var newSeparator = '\\';
+
+            // True normalization is still not possible https://github.com/dotnet/runtime/issues/2162
+            // The reasoning behind this is that a forward slash likely means it's a Linux path and
+            // so the whole path should be normalized to use / and vice versa for Windows (although Windows doesn't care much).
+            if (path.Contains('/', StringComparison.Ordinal))
+            {
+                newSeparator = '/';
+            }
+
+            separator = newSeparator;
+
+            return path.NormalizePath(newSeparator);
+        }
+
+        /// <summary>
+        /// Normalizes the path's directory separator character to the specified character.
+        /// </summary>
+        /// <param name="path">The path to normalize.</param>
+        /// <param name="newSeparator">The replacement directory separator character. Must be a valid directory separator.</param>
+        /// <returns>The normalized path.</returns>
+        /// <exception cref="ArgumentException">Thrown if the new separator character is not a directory separator.</exception>
+        [return: NotNullIfNotNull(nameof(path))]
+        public static string? NormalizePath(this string? path, char newSeparator)
+        {
+            const char Bs = '\\';
+            const char Fs = '/';
+
+            if (!(newSeparator == Bs || newSeparator == Fs))
+            {
+                throw new ArgumentException("The character must be a directory separator.");
+            }
+
+            if (string.IsNullOrEmpty(path))
+            {
+                return path;
+            }
+
+            return newSeparator == Bs ? path.Replace(Fs, newSeparator) : path.Replace(Bs, newSeparator);
+        }
+    }
+}

Emby.Server.Implementations/Library/PathManager.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.IO;
+
+namespace Emby.Server.Implementations.Library;
+
+/// <summary>
+/// IPathManager implementation.
+/// </summary>
+public class PathManager : IPathManager
+{
+    private readonly IServerConfigurationManager _config;
+    private readonly IApplicationPaths _appPaths;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PathManager"/> class.
+    /// </summary>
+    /// <param name="config">The server configuration manager.</param>
+    /// <param name="appPaths">The application paths.</param>
+    public PathManager(
+        IServerConfigurationManager config,
+        IApplicationPaths appPaths)
+    {
+        _config = config;
+        _appPaths = appPaths;
+    }
+
+    private string SubtitleCachePath => Path.Combine(_appPaths.DataPath, "subtitles");
+
+    private string AttachmentCachePath => Path.Combine(_appPaths.DataPath, "attachments");
+
+    /// <inheritdoc />
+    public string GetAttachmentPath(string mediaSourceId, string fileName)
+    {
+        return Path.Combine(GetAttachmentFolderPath(mediaSourceId), fileName);
+    }
+
+    /// <inheritdoc />
+    public string GetAttachmentFolderPath(string mediaSourceId)
+    {
+        var id = Guid.Parse(mediaSourceId).ToString("D", CultureInfo.InvariantCulture).AsSpan();
+
+        return Path.Join(AttachmentCachePath, id[..2], id);
+    }
+
+    /// <inheritdoc />
+    public string GetSubtitleFolderPath(string mediaSourceId)
+    {
+        var id = Guid.Parse(mediaSourceId).ToString("D", CultureInfo.InvariantCulture).AsSpan();
+
+        return Path.Join(SubtitleCachePath, id[..2], id);
+    }
+
+    /// <inheritdoc />
+    public string GetSubtitlePath(string mediaSourceId, int streamIndex, string extension)
+    {
+        return Path.Combine(GetSubtitleFolderPath(mediaSourceId), streamIndex.ToString(CultureInfo.InvariantCulture) + extension);
+    }
+
+    /// <inheritdoc />
+    public string GetTrickplayDirectory(BaseItem item, bool saveWithMedia = false)
+    {
+        var id = item.Id.ToString("D", CultureInfo.InvariantCulture).AsSpan();
+
+        return saveWithMedia
+            ? Path.Combine(item.ContainingFolderPath, Path.ChangeExtension(Path.GetFileName(item.Path), ".trickplay"))
+            : Path.Join(_config.ApplicationPaths.TrickplayPath, id[..2], id);
+    }
+
+    /// <inheritdoc/>
+    public string GetChapterImageFolderPath(BaseItem item)
+    {
+        return Path.Combine(item.GetInternalMetadataPath(), "chapters");
+    }
+
+    /// <inheritdoc/>
+    public string GetChapterImagePath(BaseItem item, long chapterPositionTicks)
+    {
+        var filename = item.DateModified.Ticks.ToString(CultureInfo.InvariantCulture) + "_" + chapterPositionTicks.ToString(CultureInfo.InvariantCulture) + ".jpg";
+
+        return Path.Combine(GetChapterImageFolderPath(item), filename);
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<string> GetExtractedDataPaths(BaseItem item)
+    {
+        var mediaSourceId = item.Id.ToString("N", CultureInfo.InvariantCulture);
+        return [
+            GetAttachmentFolderPath(mediaSourceId),
+            GetSubtitleFolderPath(mediaSourceId),
+            GetTrickplayDirectory(item, false),
+            GetTrickplayDirectory(item, true),
+            GetChapterImageFolderPath(item)
+        ];
+    }
+}

Emby.Server.Implementations/Library/ResolverHelper.cs

@@ -0,0 +1,168 @@
+using System;
+using System.IO;
+using System.Linq;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Library
+{
+    /// <summary>
+    /// Class ResolverHelper.
+    /// </summary>
+    public static class ResolverHelper
+    {
+        /// <summary>
+        /// Sets the initial item values.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="parent">The parent.</param>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="directoryService">The directory service.</param>
+        /// <returns>True if initializing was successful.</returns>
+        /// <exception cref="ArgumentException">Item must have a path.</exception>
+        public static bool SetInitialItemValues(BaseItem item, Folder? parent, ILibraryManager libraryManager, IDirectoryService directoryService)
+        {
+            // This version of the below method has no ItemResolveArgs, so we have to require the path already being set
+            ArgumentException.ThrowIfNullOrEmpty(item.Path);
+
+            // If the resolver didn't specify this
+            if (parent is not null)
+            {
+                item.SetParent(parent);
+            }
+
+            item.Id = libraryManager.GetNewItemId(item.Path, item.GetType());
+
+            item.IsLocked = item.Path.Contains("[dontfetchmeta]", StringComparison.OrdinalIgnoreCase) ||
+                item.GetParents().Any(i => i.IsLocked);
+
+            // Make sure DateCreated and DateModified have values
+            var fileInfo = directoryService.GetFileSystemEntry(item.Path);
+            if (fileInfo is null)
+            {
+                return false;
+            }
+
+            SetDateCreated(item, fileInfo);
+
+            EnsureName(item, fileInfo);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Sets the initial item values.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="args">The args.</param>
+        /// <param name="fileSystem">The file system.</param>
+        /// <param name="libraryManager">The library manager.</param>
+        public static void SetInitialItemValues(BaseItem item, ItemResolveArgs args, IFileSystem fileSystem, ILibraryManager libraryManager)
+        {
+            // If the resolver didn't specify this
+            if (string.IsNullOrEmpty(item.Path))
+            {
+                item.Path = args.Path;
+            }
+
+            // If the resolver didn't specify this
+            if (args.Parent is not null)
+            {
+                item.SetParent(args.Parent);
+            }
+
+            item.Id = libraryManager.GetNewItemId(item.Path, item.GetType());
+
+            // Make sure the item has a name
+            EnsureName(item, args.FileInfo);
+
+            item.IsLocked = item.Path.Contains("[dontfetchmeta]", StringComparison.OrdinalIgnoreCase) ||
+                item.GetParents().Any(i => i.IsLocked);
+
+            // Make sure DateCreated and DateModified have values
+            EnsureDates(fileSystem, item, args);
+        }
+
+        /// <summary>
+        /// Ensures the name.
+        /// </summary>
+        private static void EnsureName(BaseItem item, FileSystemMetadata fileInfo)
+        {
+            // If the subclass didn't supply a name, add it here
+            if (string.IsNullOrEmpty(item.Name) && !string.IsNullOrEmpty(item.Path))
+            {
+                item.Name = fileInfo.IsDirectory ? fileInfo.Name : Path.GetFileNameWithoutExtension(fileInfo.Name);
+            }
+        }
+
+        /// <summary>
+        /// Ensures DateCreated and DateModified have values.
+        /// </summary>
+        /// <param name="fileSystem">The file system.</param>
+        /// <param name="item">The item.</param>
+        /// <param name="args">The args.</param>
+        private static void EnsureDates(IFileSystem fileSystem, BaseItem item, ItemResolveArgs args)
+        {
+            // See if a different path came out of the resolver than what went in
+            if (!fileSystem.AreEqual(args.Path, item.Path))
+            {
+                var childData = args.IsDirectory ? args.GetFileSystemEntryByPath(item.Path) : null;
+
+                if (childData is not null)
+                {
+                    SetDateCreated(item, childData);
+                }
+                else
+                {
+                    var fileData = fileSystem.GetFileSystemInfo(item.Path);
+
+                    if (fileData.Exists)
+                    {
+                        SetDateCreated(item, fileData);
+                    }
+                }
+            }
+            else
+            {
+                SetDateCreated(item, args.FileInfo);
+            }
+        }
+
+        private static void SetDateCreated(BaseItem item, FileSystemMetadata? info)
+        {
+            var config = BaseItem.ConfigurationManager.GetMetadataConfiguration();
+
+            if (config.UseFileCreationTimeForDateAdded)
+            {
+                var fileCreationDate = info?.CreationTimeUtc;
+                if (fileCreationDate is not null)
+                {
+                    var dateCreated = fileCreationDate;
+                    if (dateCreated == DateTime.MinValue)
+                    {
+                        dateCreated = DateTime.UtcNow;
+                    }
+
+                    item.DateCreated = dateCreated.Value;
+                }
+            }
+            else
+            {
+                item.DateCreated = DateTime.UtcNow;
+            }
+
+            if (info is not null && !info.IsDirectory)
+            {
+                item.Size = info.Length;
+            }
+
+            var fileModificationDate = info?.LastWriteTimeUtc;
+            if (fileModificationDate.HasValue)
+            {
+                item.DateModified = fileModificationDate.Value;
+            }
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/Audio/AudioResolver.cs

@@ -0,0 +1,240 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Emby.Naming.Audio;
+using Emby.Naming.AudioBook;
+using Emby.Naming.Common;
+using Emby.Naming.Video;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Audio
+{
+    /// <summary>
+    /// Class AudioResolver.
+    /// </summary>
+    public class AudioResolver : ItemResolver<MediaBrowser.Controller.Entities.Audio.Audio>, IMultiItemResolver
+    {
+        private readonly NamingOptions _namingOptions;
+
+        public AudioResolver(NamingOptions namingOptions)
+        {
+            _namingOptions = namingOptions;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority => ResolverPriority.Fifth;
+
+        public MultiItemResolverResult ResolveMultiple(
+            Folder parent,
+            List<FileSystemMetadata> files,
+            CollectionType? collectionType,
+            IDirectoryService directoryService)
+        {
+            var result = ResolveMultipleInternal(parent, files, collectionType);
+
+            if (result is not null)
+            {
+                foreach (var item in result.Items)
+                {
+                    SetInitialItemValues((MediaBrowser.Controller.Entities.Audio.Audio)item, null);
+                }
+            }
+
+            return result;
+        }
+
+        private MultiItemResolverResult ResolveMultipleInternal(
+            Folder parent,
+            List<FileSystemMetadata> files,
+            CollectionType? collectionType)
+        {
+            if (collectionType == CollectionType.books)
+            {
+                return ResolveMultipleAudio(parent, files, true);
+            }
+
+            return null;
+        }
+
+        /// <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
+
+            var collectionType = args.GetCollectionType();
+
+            var isBooksCollectionType = collectionType == CollectionType.books;
+
+            if (args.IsDirectory)
+            {
+                if (!isBooksCollectionType)
+                {
+                    return null;
+                }
+
+                return FindAudioBook(args, false);
+            }
+
+            if (AudioFileParser.IsAudioFile(args.Path, _namingOptions))
+            {
+                var extension = Path.GetExtension(args.Path.AsSpan());
+
+                if (extension.Equals(".cue", StringComparison.OrdinalIgnoreCase))
+                {
+                    // if audio file exists of same name, return null
+                    return null;
+                }
+
+                var isMixedCollectionType = collectionType is null;
+
+                // For conflicting extensions, give priority to videos
+                if (isMixedCollectionType && VideoResolver.IsVideoFile(args.Path, _namingOptions))
+                {
+                    return null;
+                }
+
+                MediaBrowser.Controller.Entities.Audio.Audio item = null;
+
+                var isMusicCollectionType = collectionType == CollectionType.music;
+
+                // Use regular audio type for mixed libraries, owned items and music
+                if (isMixedCollectionType ||
+                    args.Parent is null ||
+                    isMusicCollectionType)
+                {
+                    item = new MediaBrowser.Controller.Entities.Audio.Audio();
+                }
+                else if (isBooksCollectionType)
+                {
+                    item = new AudioBook();
+                }
+
+                if (item is not null)
+                {
+                    item.IsShortcut = extension.Equals(".strm", StringComparison.OrdinalIgnoreCase);
+
+                    item.IsInMixedFolder = true;
+                }
+
+                return item;
+            }
+
+            return null;
+        }
+
+        private AudioBook FindAudioBook(ItemResolveArgs args, bool parseName)
+        {
+            // TODO: Allow GetMultiDiscMovie in here
+            var result = ResolveMultipleAudio(args.Parent, args.GetActualFileSystemChildren(), parseName);
+
+            if (result is null || result.Items.Count != 1 || result.Items[0] is not AudioBook item)
+            {
+                return null;
+            }
+
+            // If we were supporting this we'd be checking filesFromOtherItems
+            item.IsInMixedFolder = false;
+            item.Name = Path.GetFileName(item.ContainingFolderPath);
+            return item;
+        }
+
+        private MultiItemResolverResult ResolveMultipleAudio(Folder parent, IEnumerable<FileSystemMetadata> fileSystemEntries, bool parseName)
+        {
+            var files = new List<FileSystemMetadata>();
+            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
+                {
+                    files.Add(child);
+                }
+            }
+
+            var resolver = new AudioBookListResolver(_namingOptions);
+            var resolverResult = resolver.Resolve(files).ToList();
+
+            var result = new MultiItemResolverResult
+            {
+                ExtraFiles = leftOver,
+                Items = new List<BaseItem>()
+            };
+
+            var isInMixedFolder = resolverResult.Count > 1 || (parent is not null && parent.IsTopParent);
+
+            foreach (var resolvedItem in resolverResult)
+            {
+                if (resolvedItem.Files.Count > 1)
+                {
+                    // For now, until we sort out naming for multi-part books
+                    continue;
+                }
+
+                // Until multi-part books are handled letting files stack hides them from browsing in the client
+                if (resolvedItem.Files.Count == 0 || resolvedItem.Extras.Count > 0 || resolvedItem.AlternateVersions.Count > 0)
+                {
+                    continue;
+                }
+
+                var firstMedia = resolvedItem.Files[0];
+
+                var libraryItem = new AudioBook
+                {
+                    Path = firstMedia.Path,
+                    IsInMixedFolder = isInMixedFolder,
+                    ProductionYear = resolvedItem.Year,
+                    Name = parseName ?
+                        resolvedItem.Name :
+                        Path.GetFileNameWithoutExtension(firstMedia.Path),
+                    // AdditionalParts = resolvedItem.Files.Skip(1).Select(i => i.Path).ToArray(),
+                    // LocalAlternateVersions = resolvedItem.AlternateVersions.Select(i => i.Path).ToArray()
+                };
+
+                result.Items.Add(libraryItem);
+            }
+
+            result.ExtraFiles.AddRange(files.Where(i => !ContainsFile(resolverResult, i)));
+
+            return result;
+        }
+
+        private static bool ContainsFile(IEnumerable<AudioBookInfo> result, FileSystemMetadata file)
+        {
+            return result.Any(i => ContainsFile(i, file));
+        }
+
+        private static bool ContainsFile(AudioBookInfo 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 static bool ContainsFile(AudioBookFileInfo result, FileSystemMetadata file)
+        {
+            return string.Equals(result.Path, file.FullName, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs

@@ -0,0 +1,181 @@
+#nullable disable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Emby.Naming.Audio;
+using Emby.Naming.Common;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Audio
+{
+    /// <summary>
+    /// The music album resolver.
+    /// </summary>
+    public class MusicAlbumResolver : ItemResolver<MusicAlbum>
+    {
+        private readonly ILogger<MusicAlbumResolver> _logger;
+        private readonly NamingOptions _namingOptions;
+        private readonly IDirectoryService _directoryService;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MusicAlbumResolver"/> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="namingOptions">The naming options.</param>
+        /// <param name="directoryService">The directory service.</param>
+        public MusicAlbumResolver(ILogger<MusicAlbumResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService)
+        {
+            _logger = logger;
+            _namingOptions = namingOptions;
+            _directoryService = directoryService;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority => ResolverPriority.Third;
+
+        /// <summary>
+        /// Resolves the specified args.
+        /// </summary>
+        /// <param name="args">The args.</param>
+        /// <returns>MusicAlbum.</returns>
+        protected override MusicAlbum Resolve(ItemResolveArgs args)
+        {
+            var collectionType = args.GetCollectionType();
+            var isMusicMediaFolder = collectionType == CollectionType.music;
+
+            // If there's a collection type and it's not music, don't allow it.
+            if (!isMusicMediaFolder)
+            {
+                return null;
+            }
+
+            if (!args.IsDirectory)
+            {
+                return null;
+            }
+
+            // Avoid mis-identifying top folders
+            if (args.HasParent<MusicAlbum>())
+            {
+                return null;
+            }
+
+            if (args.Parent.IsRoot)
+            {
+                return null;
+            }
+
+            return IsMusicAlbum(args) ? new MusicAlbum() : null;
+        }
+
+        /// <summary>
+        /// Determine if the supplied file data points to a music album.
+        /// </summary>
+        /// <param name="path">The path to check.</param>
+        /// <param name="directoryService">The directory service.</param>
+        /// <returns><c>true</c> if the provided path points to a music album; otherwise, <c>false</c>.</returns>
+        public bool IsMusicAlbum(string path, IDirectoryService directoryService)
+        {
+            return ContainsMusic(directoryService.GetFileSystemEntries(path), true, directoryService);
+        }
+
+        /// <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)
+        {
+            if (args.IsDirectory)
+            {
+                // If args is a artist subfolder it's not a music album
+                foreach (var subfolder in _namingOptions.ArtistSubfolders)
+                {
+                    if (Path.GetDirectoryName(args.Path.AsSpan()).Equals(subfolder, StringComparison.OrdinalIgnoreCase))
+                    {
+                        _logger.LogDebug("Found release folder: {Path}", args.Path);
+                        return false;
+                    }
+                }
+
+                // If args contains music it's a music album
+                if (ContainsMusic(args.FileSystemChildren, true, _directoryService))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Determine if the supplied list contains what we should consider music.
+        /// </summary>
+        /// <returns><c>true</c> if the provided path list contains music; otherwise, <c>false</c>.</returns>
+        private bool ContainsMusic(
+            ICollection<FileSystemMetadata> list,
+            bool allowSubfolders,
+            IDirectoryService directoryService)
+        {
+            // Check for audio files before digging down into directories
+            var foundAudioFile = list.Any(fileSystemInfo => !fileSystemInfo.IsDirectory && AudioFileParser.IsAudioFile(fileSystemInfo.FullName, _namingOptions));
+            if (foundAudioFile)
+            {
+                // At least one audio file exists
+                return true;
+            }
+
+            if (!allowSubfolders)
+            {
+                // Not music since no audio file exists and we're not looking into subfolders
+                return false;
+            }
+
+            var discSubfolderCount = 0;
+
+            var parser = new AlbumParser(_namingOptions);
+
+            var directories = list.Where(fileSystemInfo => fileSystemInfo.IsDirectory);
+
+            var result = Parallel.ForEach(directories, (fileSystemInfo, state) =>
+            {
+                var path = fileSystemInfo.FullName;
+                var hasMusic = ContainsMusic(directoryService.GetFileSystemEntries(path), false, directoryService);
+
+                if (hasMusic)
+                {
+                    if (parser.IsMultiPart(path))
+                    {
+                        _logger.LogDebug("Found multi-disc folder: {Path}", path);
+                        Interlocked.Increment(ref discSubfolderCount);
+                    }
+                    else
+                    {
+                        // If there are folders underneath with music that are not multidisc, then this can't be a multi-disc album
+                        state.Stop();
+                    }
+                }
+            });
+
+            if (!result.IsCompleted)
+            {
+                return false;
+            }
+
+            return discSubfolderCount > 0;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs

@@ -0,0 +1,122 @@
+#nullable disable
+
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Emby.Naming.Audio;
+using Emby.Naming.Common;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Audio
+{
+    /// <summary>
+    /// The music artist resolver.
+    /// </summary>
+    public class MusicArtistResolver : ItemResolver<MusicArtist>
+    {
+        private readonly ILogger<MusicAlbumResolver> _logger;
+        private readonly NamingOptions _namingOptions;
+        private readonly IDirectoryService _directoryService;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MusicArtistResolver"/> class.
+        /// </summary>
+        /// <param name="logger">Instance of the <see cref="MusicAlbumResolver"/> interface.</param>
+        /// <param name="namingOptions">The <see cref="NamingOptions"/>.</param>
+        /// <param name="directoryService">The directory service.</param>
+        public MusicArtistResolver(
+            ILogger<MusicAlbumResolver> logger,
+            NamingOptions namingOptions,
+            IDirectoryService directoryService)
+        {
+            _logger = logger;
+            _namingOptions = namingOptions;
+            _directoryService = directoryService;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority => ResolverPriority.Second;
+
+        /// <summary>
+        /// Resolves the specified resolver arguments.
+        /// </summary>
+        /// <param name="args">The resolver arguments.</param>
+        /// <returns>A <see cref="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 = collectionType == CollectionType.music;
+
+            // If there's a collection type and it's not music, it can't be a music artist
+            if (!isMusicMediaFolder)
+            {
+                return null;
+            }
+
+            if (args.ContainsFileSystemEntryByName("artist.nfo"))
+            {
+                return new MusicArtist();
+            }
+
+            // Avoid mis-identifying top folders
+            if (args.Parent.IsRoot)
+            {
+                return null;
+            }
+
+            var albumResolver = new MusicAlbumResolver(_logger, _namingOptions, _directoryService);
+            var albumParser = new AlbumParser(_namingOptions);
+
+            var directories = args.FileSystemChildren.Where(i => i.IsDirectory);
+
+            var result = Parallel.ForEach(directories, (fileSystemInfo, state) =>
+            {
+                // If we contain a artist subfolder assume we are an artist folder
+                foreach (var subfolder in _namingOptions.ArtistSubfolders)
+                {
+                    if (fileSystemInfo.Name.Equals(subfolder, StringComparison.OrdinalIgnoreCase))
+                    {
+                        // Stop once we see an artist subfolder
+                        state.Stop();
+                    }
+                }
+
+                // If the folder is a multi-disc folder, then it is not an artist folder
+                if (albumParser.IsMultiPart(fileSystemInfo.FullName))
+                {
+                    return;
+                }
+
+                // If we contain a music album assume we are an artist folder
+                if (albumResolver.IsMusicAlbum(fileSystemInfo.FullName, _directoryService))
+                {
+                    // Stop once we see a music album
+                    state.Stop();
+                }
+            });
+
+            return !result.IsCompleted ? new MusicArtist() : null;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs

@@ -0,0 +1,289 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.IO;
+using System.Linq;
+using DiscUtils.Udf;
+using Emby.Naming.Common;
+using Emby.Naming.Video;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Resolves a Path into a Video or Video subclass.
+    /// </summary>
+    /// <typeparam name="T">The type of item to resolve.</typeparam>
+    public abstract class BaseVideoResolver<T> : MediaBrowser.Controller.Resolvers.ItemResolver<T>
+        where T : Video, new()
+    {
+        private readonly ILogger _logger;
+
+        protected BaseVideoResolver(ILogger logger, NamingOptions namingOptions, IDirectoryService directoryService)
+        {
+            _logger = logger;
+            NamingOptions = namingOptions;
+            DirectoryService = directoryService;
+        }
+
+        protected NamingOptions NamingOptions { get; }
+
+        protected IDirectoryService DirectoryService { get; }
+
+        /// <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 virtual TVideoType ResolveVideo<TVideoType>(ItemResolveArgs args, bool parseName)
+              where TVideoType : Video, new()
+        {
+            VideoFileInfo videoInfo = null;
+            VideoType? videoType = null;
+
+            // If the path is a file check for a matching extensions
+            if (args.IsDirectory)
+            {
+                // 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(child.FullName, filename, DirectoryService))
+                        {
+                            var videoTmp = new TVideoType
+                            {
+                                Path = args.Path,
+                                VideoType = VideoType.Dvd
+                            };
+                            Set3DFormat(videoTmp);
+                            return videoTmp;
+                        }
+
+                        if (IsBluRayDirectory(filename))
+                        {
+                            var videoTmp = new TVideoType
+                            {
+                                Path = args.Path,
+                                VideoType = VideoType.BluRay
+                            };
+                            Set3DFormat(videoTmp);
+                            return videoTmp;
+                        }
+                    }
+                    else if (IsDvdFile(filename))
+                    {
+                        videoType = VideoType.Dvd;
+                    }
+
+                    if (videoType is null)
+                    {
+                        continue;
+                    }
+
+                    videoInfo = VideoResolver.ResolveDirectory(args.Path, NamingOptions, parseName);
+                    break;
+                }
+            }
+            else
+            {
+                videoInfo = VideoResolver.Resolve(args.Path, false, NamingOptions, parseName);
+            }
+
+            if (videoInfo is null || (!videoInfo.IsStub && !VideoResolver.IsVideoFile(args.Path, NamingOptions)))
+            {
+                return null;
+            }
+
+            var video = new TVideoType
+            {
+                Name = videoInfo.Name,
+                Path = args.Path,
+                ProductionYear = videoInfo.Year,
+                ExtraType = videoInfo.ExtraType
+            };
+
+            if (videoType.HasValue)
+            {
+                video.VideoType = videoType.Value;
+            }
+            else
+            {
+                SetVideoType(video, videoInfo);
+            }
+
+            Set3DFormat(video, videoInfo);
+
+            return video;
+        }
+
+        protected void SetVideoType(Video video, VideoFileInfo videoInfo)
+        {
+            var extension = Path.GetExtension(video.Path.AsSpan());
+            video.VideoType = extension.Equals(".iso", StringComparison.OrdinalIgnoreCase)
+                              || extension.Equals(".img", StringComparison.OrdinalIgnoreCase)
+                ? VideoType.Iso
+                : VideoType.VideoFile;
+
+            video.IsShortcut = extension.Equals(".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, "bluray", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.VideoType = VideoType.BluRay;
+                }
+            }
+
+            SetIsoType(video);
+        }
+
+        protected void SetIsoType(Video video)
+        {
+            if (video.VideoType == VideoType.Iso)
+            {
+                if (video.Path.Contains("dvd", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.IsoType = IsoType.Dvd;
+                }
+                else if (video.Path.Contains("bluray", StringComparison.OrdinalIgnoreCase))
+                {
+                    video.IsoType = IsoType.BluRay;
+                }
+                else
+                {
+                    try
+                    {
+                        // use disc-utils, both DVDs and BDs use UDF filesystem
+                        using var videoFileStream = File.Open(video.Path, FileMode.Open, FileAccess.Read, FileShare.Read);
+                        using UdfReader udfReader = new UdfReader(videoFileStream);
+                        if (udfReader.DirectoryExists("VIDEO_TS"))
+                        {
+                            video.IsoType = IsoType.Dvd;
+                        }
+                        else if (udfReader.DirectoryExists("BDMV"))
+                        {
+                            video.IsoType = IsoType.BluRay;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Error opening UDF/ISO image: {Value}", video.Path ?? video.Name);
+                    }
+                }
+            }
+        }
+
+        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 result = Format3DParser.Parse(video.Path, NamingOptions);
+
+            Set3DFormat(video, result.Is3D, result.Format3D);
+        }
+
+        /// <summary>
+        /// Determines whether [is DVD directory] [the specified directory name].
+        /// </summary>
+        /// <param name="fullPath">The full path of the directory.</param>
+        /// <param name="directoryName">The name of the directory.</param>
+        /// <param name="directoryService">The directory service.</param>
+        /// <returns><c>true</c> if the provided directory is a DVD directory, <c>false</c> otherwise.</returns>
+        protected bool IsDvdDirectory(string fullPath, string directoryName, IDirectoryService directoryService)
+        {
+            if (!string.Equals(directoryName, "video_ts", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            return directoryService.GetFilePaths(fullPath).Any(i => Path.GetExtension(i.AsSpan()).Equals(".vob", 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 bluray directory] [the specified directory name].
+        /// </summary>
+        /// <param name="directoryName">The directory name.</param>
+        /// <returns>Whether the directory is a bluray directory.</returns>
+        protected bool IsBluRayDirectory(string directoryName)
+        {
+            return string.Equals(directoryName, "bdmv", StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/Books/BookResolver.cs

@@ -0,0 +1,86 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.IO;
+using System.Linq;
+using Emby.Naming.Book;
+using Jellyfin.Data.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Books
+{
+    public class BookResolver : ItemResolver<Book>
+    {
+        private readonly string[] _validExtensions = { ".azw", ".azw3", ".cb7", ".cbr", ".cbt", ".cbz", ".epub", ".mobi", ".pdf" };
+
+        protected override Book Resolve(ItemResolveArgs args)
+        {
+            var collectionType = args.GetCollectionType();
+
+            // Only process items that are in a collection folder containing books
+            if (collectionType != CollectionType.books)
+            {
+                return null;
+            }
+
+            if (args.IsDirectory)
+            {
+                return GetBook(args);
+            }
+
+            var extension = Path.GetExtension(args.Path.AsSpan());
+
+            if (!_validExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
+            {
+                return null;
+            }
+
+            var result = BookFileNameParser.Parse(Path.GetFileNameWithoutExtension(args.Path));
+
+            return new Book
+            {
+                Path = args.Path,
+                Name = result.Name ?? string.Empty,
+                IndexNumber = result.Index,
+                ProductionYear = result.Year,
+                SeriesName = result.SeriesName ?? Path.GetFileName(Path.GetDirectoryName(args.Path)),
+                IsInMixedFolder = true,
+            };
+        }
+
+        private Book GetBook(ItemResolveArgs args)
+        {
+            var bookFiles = args.FileSystemChildren.Where(f =>
+            {
+                var fileExtension = Path.GetExtension(f.FullName.AsSpan());
+
+                return _validExtensions.Contains(
+                    fileExtension,
+                    StringComparison.OrdinalIgnoreCase);
+            }).ToList();
+
+            // directory is only considered a book when it contains exactly one supported file
+            // other library structures with multiple books to a directory will get picked up as individual files
+            if (bookFiles.Count != 1)
+            {
+                return null;
+            }
+
+            var result = BookFileNameParser.Parse(Path.GetFileName(args.Path));
+
+            return new Book
+            {
+                Path = bookFiles[0].FullName,
+                Name = result.Name ?? string.Empty,
+                IndexNumber = result.Index,
+                ProductionYear = result.Year,
+                SeriesName = result.SeriesName ?? string.Empty,
+            };
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/ExtraResolver.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using Emby.Naming.Common;
+using Emby.Naming.Video;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+using static Emby.Naming.Video.ExtraRuleResolver;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Resolves a Path into a Video or Video subclass.
+    /// </summary>
+    internal class ExtraResolver : BaseVideoResolver<Video>
+    {
+        private readonly NamingOptions _namingOptions;
+        private readonly IItemResolver[] _trailerResolvers;
+        private readonly IItemResolver[] _videoResolvers;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExtraResolver"/> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="namingOptions">An instance of <see cref="NamingOptions"/>.</param>
+        /// <param name="directoryService">The directory service.</param>
+        public ExtraResolver(ILogger<ExtraResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService)
+            : base(logger, namingOptions, directoryService)
+        {
+            _namingOptions = namingOptions;
+            _trailerResolvers = new IItemResolver[] { new GenericVideoResolver<Trailer>(logger, namingOptions, directoryService) };
+            _videoResolvers = new IItemResolver[] { this };
+        }
+
+        protected override Video Resolve(ItemResolveArgs args)
+        {
+            return ResolveVideo<Video>(args, true);
+        }
+
+        /// <summary>
+        /// Gets the resolvers for the extra type.
+        /// </summary>
+        /// <param name="extraType">The extra type.</param>
+        /// <returns>The resolvers for the extra type.</returns>
+        public IItemResolver[]? GetResolversForExtraType(ExtraType extraType) => extraType switch
+        {
+            ExtraType.Trailer => _trailerResolvers,
+            // For audio we'll have to rely on the AudioResolver, which is a "built-in"
+            ExtraType.ThemeSong => null,
+            _ => _videoResolvers
+        };
+
+        public bool TryGetExtraTypeForOwner(string path, VideoFileInfo ownerVideoFileInfo, [NotNullWhen(true)] out ExtraType? extraType, string? libraryRoot = "")
+        {
+            var extraResult = GetExtraInfo(path, _namingOptions, libraryRoot);
+            if (extraResult.ExtraType is null)
+            {
+                extraType = null;
+                return false;
+            }
+
+            var cleanDateTimeResult = CleanDateTimeParser.Clean(Path.GetFileNameWithoutExtension(path), _namingOptions.CleanDateTimeRegexes);
+            var name = cleanDateTimeResult.Name;
+            var year = cleanDateTimeResult.Year;
+
+            var parentDir = ownerVideoFileInfo.IsDirectory ? ownerVideoFileInfo.Path : Path.GetDirectoryName(ownerVideoFileInfo.Path.AsSpan());
+
+            var trimmedFileNameWithoutExtension = TrimFilenameDelimiters(ownerVideoFileInfo.FileNameWithoutExtension, _namingOptions.VideoFlagDelimiters);
+            var trimmedVideoInfoName = TrimFilenameDelimiters(ownerVideoFileInfo.Name, _namingOptions.VideoFlagDelimiters);
+            var trimmedExtraFileName = TrimFilenameDelimiters(name, _namingOptions.VideoFlagDelimiters);
+
+            // first check filenames
+            bool isValid = StartsWith(trimmedExtraFileName, trimmedFileNameWithoutExtension)
+                           || (StartsWith(trimmedExtraFileName, trimmedVideoInfoName) && year == ownerVideoFileInfo.Year);
+
+            if (!isValid)
+            {
+                // When the extra rule type is DirectoryName we must go one level higher to get the "real" dir name
+                var currentParentDir = extraResult.Rule?.RuleType == ExtraRuleType.DirectoryName
+                    ? Path.GetDirectoryName(Path.GetDirectoryName(path.AsSpan()))
+                    : Path.GetDirectoryName(path.AsSpan());
+
+                isValid = !currentParentDir.IsEmpty && !parentDir.IsEmpty && currentParentDir.Equals(parentDir, StringComparison.OrdinalIgnoreCase);
+            }
+
+            extraType = extraResult.ExtraType;
+            return isValid;
+        }
+
+        private static ReadOnlySpan<char> TrimFilenameDelimiters(ReadOnlySpan<char> name, ReadOnlySpan<char> videoFlagDelimiters)
+        {
+            return name.IsEmpty ? name : name.TrimEnd().TrimEnd(videoFlagDelimiters).TrimEnd();
+        }
+
+        private static bool StartsWith(ReadOnlySpan<char> fileName, ReadOnlySpan<char> baseName)
+        {
+            return !baseName.IsEmpty && fileName.StartsWith(baseName, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/FolderResolver.cs

@@ -0,0 +1,35 @@
+#nullable disable
+
+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 : GenericFolderResolver<Folder>
+    {
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority => 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;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/GenericFolderResolver.cs

@@ -0,0 +1,28 @@
+#nullable disable
+
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Class FolderResolver.
+    /// </summary>
+    /// <typeparam name="TItemType">The type of the T item type.</typeparam>
+    public abstract class GenericFolderResolver<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 is null;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/GenericVideoResolver.cs

@@ -0,0 +1,28 @@
+#nullable disable
+
+using Emby.Naming.Common;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Providers;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Resolves a Path into an instance of the <see cref="Video"/> class.
+    /// </summary>
+    /// <typeparam name="T">The type of item to resolve.</typeparam>
+    public class GenericVideoResolver<T> : BaseVideoResolver<T>
+        where T : Video, new()
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GenericVideoResolver{T}"/> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="namingOptions">The naming options.</param>
+        /// <param name="directoryService">The directory service.</param>
+        public GenericVideoResolver(ILogger logger, NamingOptions namingOptions, IDirectoryService directoryService)
+            : base(logger, namingOptions, directoryService)
+        {
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/Movies/BoxSetResolver.cs

@@ -0,0 +1,74 @@
+#nullable disable
+
+using System;
+using System.IO;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Movies
+{
+    /// <summary>
+    /// Class BoxSetResolver.
+    /// </summary>
+    public class BoxSetResolver : GenericFolderResolver<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.Contains("[boxset]", StringComparison.OrdinalIgnoreCase) || args.ContainsFileSystemEntryByName("collection.xml"))
+                {
+                    return new BoxSet
+                    {
+                        Path = args.Path,
+                        Name = Path.GetFileName(args.Path).Replace("[boxset]", string.Empty, StringComparison.OrdinalIgnoreCase).Trim()
+                    };
+                }
+            }
+
+            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 static void SetProviderIdFromPath(BaseItem item)
+        {
+            // we need to only look at the name of this actual item (not parents)
+            var justName = Path.GetFileName(item.Path.AsSpan());
+
+            var id = justName.GetAttributeValue("tmdbid");
+            item.TrySetProviderId(MetadataProvider.Tmdb, id);
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs

@@ -0,0 +1,586 @@
+#nullable disable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using Emby.Naming.Common;
+using Emby.Naming.Video;
+using Jellyfin.Data.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Drawing;
+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.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers.Movies
+{
+    /// <summary>
+    /// Class MovieResolver.
+    /// </summary>
+    public partial class MovieResolver : BaseVideoResolver<Video>, IMultiItemResolver
+    {
+        private readonly IImageProcessor _imageProcessor;
+
+        private static readonly CollectionType[] _validCollectionTypes = new[]
+        {
+            CollectionType.movies,
+            CollectionType.homevideos,
+            CollectionType.musicvideos,
+            CollectionType.tvshows,
+            CollectionType.photos
+        };
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MovieResolver"/> class.
+        /// </summary>
+        /// <param name="imageProcessor">The image processor.</param>
+        /// <param name="logger">The logger.</param>
+        /// <param name="namingOptions">The naming options.</param>
+        /// <param name="directoryService">The directory service.</param>
+        public MovieResolver(IImageProcessor imageProcessor, ILogger<MovieResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService)
+            : base(logger, namingOptions, directoryService)
+        {
+            _imageProcessor = imageProcessor;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority => ResolverPriority.Fourth;
+
+        [GeneratedRegex(@"\bsample\b", RegexOptions.IgnoreCase)]
+        private static partial Regex IsIgnoredRegex();
+
+        /// <inheritdoc />
+        public MultiItemResolverResult ResolveMultiple(
+            Folder parent,
+            List<FileSystemMetadata> files,
+            CollectionType? collectionType,
+            IDirectoryService directoryService)
+        {
+            var result = ResolveMultipleInternal(parent, files, collectionType);
+
+            if (result is not null)
+            {
+                foreach (var item in result.Items)
+                {
+                    SetInitialItemValues((Video)item, null);
+                }
+            }
+
+            return result;
+        }
+
+        /// <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();
+
+            // Find movies with their own folders
+            if (args.IsDirectory)
+            {
+                if (IsInvalid(args.Parent, collectionType))
+                {
+                    return null;
+                }
+
+                Video movie = null;
+                var files = args.GetActualFileSystemChildren().ToList();
+
+                if (collectionType == CollectionType.musicvideos)
+                {
+                    movie = FindMovie<MusicVideo>(args, args.Path, args.Parent, files, DirectoryService, collectionType, false);
+                }
+
+                if (collectionType == CollectionType.homevideos)
+                {
+                    movie = FindMovie<Video>(args, args.Path, args.Parent, files, DirectoryService, collectionType, false);
+                }
+
+                if (collectionType is null)
+                {
+                    // Owned items will be caught by the video extra resolver
+                    if (args.Parent is null)
+                    {
+                        return null;
+                    }
+
+                    if (args.HasParent<Series>())
+                    {
+                        return null;
+                    }
+
+                    movie = FindMovie<Movie>(args, args.Path, args.Parent, files, DirectoryService, collectionType, true);
+                }
+
+                if (collectionType == CollectionType.movies)
+                {
+                    movie = FindMovie<Movie>(args, args.Path, args.Parent, files, DirectoryService, collectionType, true);
+                }
+
+                // ignore extras
+                return movie?.ExtraType is null ? movie : null;
+            }
+
+            if (args.Parent is null)
+            {
+                return base.Resolve(args);
+            }
+
+            if (IsInvalid(args.Parent, collectionType))
+            {
+                return null;
+            }
+
+            Video item = null;
+
+            if (collectionType == CollectionType.musicvideos)
+            {
+                item = ResolveVideo<MusicVideo>(args, false);
+            }
+
+            // To find a movie file, the collection type must be movies or boxsets
+            else if (collectionType == CollectionType.movies)
+            {
+                item = ResolveVideo<Movie>(args, true);
+            }
+            else if (collectionType == CollectionType.homevideos || collectionType == CollectionType.photos)
+            {
+                item = ResolveVideo<Video>(args, false);
+            }
+            else if (collectionType is null)
+            {
+                if (args.HasParent<Series>())
+                {
+                    return null;
+                }
+
+                item = ResolveVideo<Video>(args, false);
+            }
+
+            // Ignore extras
+            if (item?.ExtraType is not null)
+            {
+                return null;
+            }
+
+            if (item is not null)
+            {
+                item.IsInMixedFolder = true;
+            }
+
+            return item;
+        }
+
+        private MultiItemResolverResult ResolveMultipleInternal(
+            Folder parent,
+            List<FileSystemMetadata> files,
+            CollectionType? collectionType)
+        {
+            if (IsInvalid(parent, collectionType))
+            {
+                return null;
+            }
+
+            if (collectionType is CollectionType.musicvideos)
+            {
+                return ResolveVideos<MusicVideo>(parent, files, true, collectionType, false);
+            }
+
+            if (collectionType == CollectionType.homevideos || collectionType == CollectionType.photos)
+            {
+                return ResolveVideos<Video>(parent, files, false, collectionType, false);
+            }
+
+            if (collectionType is null)
+            {
+                // Owned items should just use the plain video type
+                if (parent is null)
+                {
+                    return ResolveVideos<Video>(parent, files, false, collectionType, false);
+                }
+
+                if (parent is Series || parent.GetParents().OfType<Series>().Any())
+                {
+                    return null;
+                }
+
+                return ResolveVideos<Movie>(parent, files, false, collectionType, true);
+            }
+
+            if (collectionType == CollectionType.movies)
+            {
+                return ResolveVideos<Movie>(parent, files, true, collectionType, true);
+            }
+
+            if (collectionType == CollectionType.tvshows)
+            {
+                return ResolveVideos<Episode>(parent, files, false, collectionType, true);
+            }
+
+            return null;
+        }
+
+        private MultiItemResolverResult ResolveVideos<T>(
+            Folder parent,
+            IEnumerable<FileSystemMetadata> fileSystemEntries,
+            bool supportMultiEditions,
+            CollectionType? collectionType,
+            bool parseName)
+            where T : Video, new()
+        {
+            var files = new List<FileSystemMetadata>();
+            var leftOver = new List<FileSystemMetadata>();
+            var hasCollectionType = collectionType is not null;
+
+            // Loop through each child file/folder and see if we find a video
+            foreach (var child in fileSystemEntries)
+            {
+                // This is a hack but currently no better way to resolve a sometimes ambiguous situation
+                if (!hasCollectionType)
+                {
+                    if (string.Equals(child.Name, "tvshow.nfo", StringComparison.OrdinalIgnoreCase)
+                        || string.Equals(child.Name, "season.nfo", StringComparison.OrdinalIgnoreCase))
+                    {
+                        return null;
+                    }
+                }
+
+                if (child.IsDirectory)
+                {
+                    leftOver.Add(child);
+                }
+                else if (!IsIgnoredRegex().IsMatch(child.Name))
+                {
+                    files.Add(child);
+                }
+            }
+
+            var videoInfos = files
+                .Select(i => VideoResolver.Resolve(i.FullName, i.IsDirectory, NamingOptions, parseName, parent.ContainingFolderPath))
+                .Where(f => f is not null)
+                .ToList();
+
+            var resolverResult = VideoListResolver.Resolve(videoInfos, NamingOptions, supportMultiEditions, parseName, parent.ContainingFolderPath);
+
+            var result = new MultiItemResolverResult
+            {
+                ExtraFiles = leftOver
+            };
+
+            var isInMixedFolder = resolverResult.Count > 1 || parent?.IsTopParent == true;
+
+            foreach (var video in resolverResult)
+            {
+                var firstVideo = video.Files[0];
+                var path = firstVideo.Path;
+                if (video.ExtraType is not null)
+                {
+                    result.ExtraFiles.Add(files.Find(f => string.Equals(f.FullName, path, StringComparison.OrdinalIgnoreCase)));
+                    continue;
+                }
+
+                var additionalParts = video.Files.Count > 1 ? video.Files.Skip(1).Select(i => i.Path).ToArray() : Array.Empty<string>();
+
+                var videoItem = new T
+                {
+                    Path = path,
+                    IsInMixedFolder = isInMixedFolder,
+                    ProductionYear = video.Year,
+                    Name = parseName ? video.Name : firstVideo.Name,
+                    AdditionalParts = additionalParts,
+                    LocalAlternateVersions = video.AlternateVersions.Select(i => i.Path).ToArray()
+                };
+
+                SetVideoType(videoItem, firstVideo);
+                Set3DFormat(videoItem, firstVideo);
+
+                result.Items.Add(videoItem);
+            }
+
+            result.ExtraFiles.AddRange(files.Where(i => !ContainsFile(resolverResult, i)));
+
+            return result;
+        }
+
+        private static bool ContainsFile(IReadOnlyList<VideoInfo> result, FileSystemMetadata file)
+        {
+            for (var i = 0; i < result.Count; i++)
+            {
+                var current = result[i];
+                for (var j = 0; j < current.Files.Count; j++)
+                {
+                    if (ContainsFile(current.Files[j], file))
+                    {
+                        return true;
+                    }
+                }
+
+                for (var j = 0; j < current.AlternateVersions.Count; j++)
+                {
+                    if (ContainsFile(current.AlternateVersions[j], file))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static bool ContainsFile(VideoFileInfo result, FileSystemMetadata file)
+        {
+            return string.Equals(result.Path, file.FullName, StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <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 static 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.AsSpan()) : Path.GetFileName(item.ContainingFolderPath.AsSpan());
+
+                var tmdbid = justName.GetAttributeValue("tmdbid");
+
+                // If not in a mixed folder and ID not found in folder path, check filename
+                if (string.IsNullOrEmpty(tmdbid) && !item.IsInMixedFolder)
+                {
+                    tmdbid = Path.GetFileName(item.Path.AsSpan()).GetAttributeValue("tmdbid");
+                }
+
+                item.TrySetProviderId(MetadataProvider.Tmdb, tmdbid);
+
+                if (!string.IsNullOrEmpty(item.Path))
+                {
+                    // Check for IMDb id - we use full media path, as we can assume that this will match in any use case (whether  id in parent dir or in file name)
+                    var imdbid = item.Path.AsSpan().GetAttributeValue("imdbid");
+                    item.TrySetProviderId(MetadataProvider.Imdb, imdbid);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finds a movie based on a child file system entries.
+        /// </summary>
+        /// <returns>Movie.</returns>
+        private T FindMovie<T>(ItemResolveArgs args, string path, Folder parent, List<FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, CollectionType? collectionType, bool parseName)
+            where T : Video, new()
+        {
+            var multiDiscFolders = new List<FileSystemMetadata>();
+
+            var libraryOptions = args.LibraryOptions;
+            var supportPhotos = collectionType == CollectionType.homevideos && libraryOptions.EnablePhotos;
+            var photos = new List<FileSystemMetadata>();
+
+            // Search for a folder rip
+            foreach (var child in fileSystemEntries)
+            {
+                var filename = child.Name;
+
+                if (child.IsDirectory)
+                {
+                    if (NamingOptions.AllExtrasTypesFolderNames.ContainsKey(filename))
+                    {
+                        continue;
+                    }
+
+                    if (IsDvdDirectory(child.FullName, filename, directoryService))
+                    {
+                        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;
+                }
+                else if (supportPhotos && PhotoResolver.IsImageFile(child.FullName, _imageProcessor))
+                {
+                    photos.Add(child);
+                }
+            }
+
+            // TODO: Allow GetMultiDiscMovie in here
+            const bool SupportsMultiVersion = true;
+
+            var result = ResolveVideos<T>(parent, fileSystemEntries, SupportsMultiVersion, collectionType, parseName) ??
+                new MultiItemResolverResult();
+
+            var isPhotosCollection = collectionType == CollectionType.homevideos || collectionType == CollectionType.photos;
+            if (!isPhotosCollection && result.Items.Count == 1)
+            {
+                var videoPath = result.Items[0].Path;
+                var hasPhotos = photos.Any(i => !PhotoResolver.IsOwnedByResolvedMedia(videoPath, i.Name));
+                var hasOtherSubfolders = multiDiscFolders.Count > 0;
+
+                if (!hasPhotos && !hasOtherSubfolders)
+                {
+                    var movie = (T)result.Items[0];
+                    movie.IsInMixedFolder = false;
+                    if (collectionType == CollectionType.movies || collectionType is null)
+                    {
+                        movie.Name = Path.GetFileName(movie.ContainingFolderPath);
+                    }
+
+                    return movie;
+                }
+            }
+            else if (result.Items.Count == 0 && multiDiscFolders.Count > 0)
+            {
+                return GetMultiDiscMovie<T>(multiDiscFolders, directoryService);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the multi disc movie.
+        /// </summary>
+        /// <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);
+
+                var subfolders = subFileEntries
+                    .Where(e => e.IsDirectory)
+                    .ToList();
+
+                if (subfolders.Any(s => IsDvdDirectory(s.FullName, s.Name, directoryService)))
+                {
+                    videoTypes.Add(VideoType.Dvd);
+                    return true;
+                }
+
+                if (subfolders.Any(s => IsBluRayDirectory(s.Name)))
+                {
+                    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;
+            }).Order().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 result = StackResolver.ResolveDirectories(folderPaths, NamingOptions).ToList();
+
+            if (result.Count != 1)
+            {
+                return null;
+            }
+
+            int additionalPartsLen = folderPaths.Count - 1;
+            var additionalParts = new string[additionalPartsLen];
+            folderPaths.CopyTo(1, additionalParts, 0, additionalPartsLen);
+
+            var returnVideo = new T
+            {
+                Path = folderPaths[0],
+                AdditionalParts = additionalParts,
+                VideoType = videoTypes[0],
+                Name = result[0].Name
+            };
+
+            SetIsoType(returnVideo);
+
+            return returnVideo;
+        }
+
+        private bool IsInvalid(Folder parent, CollectionType? collectionType)
+        {
+            if (parent is not null)
+            {
+                if (parent.IsRoot)
+                {
+                    return true;
+                }
+            }
+
+            if (collectionType is null)
+            {
+                return false;
+            }
+
+            return !_validCollectionTypes.Contains(collectionType.Value);
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/PhotoAlbumResolver.cs

@@ -0,0 +1,95 @@
+#nullable disable
+
+using System;
+using Emby.Naming.Common;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Class PhotoAlbumResolver.
+    /// </summary>
+    public class PhotoAlbumResolver : GenericFolderResolver<PhotoAlbum>
+    {
+        private readonly IImageProcessor _imageProcessor;
+        private readonly NamingOptions _namingOptions;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PhotoAlbumResolver"/> class.
+        /// </summary>
+        /// <param name="imageProcessor">The image processor.</param>
+        /// <param name="namingOptions">The naming options.</param>
+        public PhotoAlbumResolver(IImageProcessor imageProcessor, NamingOptions namingOptions)
+        {
+            _imageProcessor = imageProcessor;
+            _namingOptions = namingOptions;
+        }
+
+        /// <inheritdoc />
+        public override ResolverPriority Priority => ResolverPriority.Second;
+
+        /// <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)
+            {
+                // Must be an image file within a photo collection
+                var collectionType = args.GetCollectionType();
+
+                if (collectionType == CollectionType.photos
+                    || (collectionType == CollectionType.homevideos && args.LibraryOptions.EnablePhotos))
+                {
+                    if (HasPhotos(args))
+                    {
+                        return new PhotoAlbum
+                        {
+                            Path = args.Path
+                        };
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private bool HasPhotos(ItemResolveArgs args)
+        {
+            var files = args.FileSystemChildren;
+
+            foreach (var file in files)
+            {
+                if (!file.IsDirectory && PhotoResolver.IsImageFile(file.FullName, _imageProcessor))
+                {
+                    var filename = file.Name;
+                    var ownedByMedia = false;
+
+                    foreach (var siblingFile in files)
+                    {
+                        if (PhotoResolver.IsOwnedByMedia(_namingOptions, siblingFile.FullName, filename))
+                        {
+                            ownedByMedia = true;
+                            break;
+                        }
+                    }
+
+                    if (!ownedByMedia)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/PhotoResolver.cs

@@ -0,0 +1,122 @@
+using System;
+using System.IO;
+using System.Linq;
+using Emby.Naming.Common;
+using Emby.Naming.Video;
+using Jellyfin.Data.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// Class PhotoResolver.
+    /// </summary>
+    public class PhotoResolver : ItemResolver<Photo>
+    {
+        private readonly IImageProcessor _imageProcessor;
+        private readonly NamingOptions _namingOptions;
+        private readonly IDirectoryService _directoryService;
+
+        private static readonly string[] _ignoreFiles = new[]
+        {
+            "folder",
+            "thumb",
+            "landscape",
+            "fanart",
+            "backdrop",
+            "poster",
+            "cover",
+            "logo",
+            "default"
+        };
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PhotoResolver"/> class.
+        /// </summary>
+        /// <param name="imageProcessor">The image processor.</param>
+        /// <param name="namingOptions">The naming options.</param>
+        /// <param name="directoryService">The directory service.</param>
+        public PhotoResolver(IImageProcessor imageProcessor, NamingOptions namingOptions, IDirectoryService directoryService)
+        {
+            _imageProcessor = imageProcessor;
+            _namingOptions = namingOptions;
+            _directoryService = directoryService;
+        }
+
+        /// <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.CollectionType;
+
+                if (collectionType == CollectionType.photos
+                    || (collectionType == CollectionType.homevideos && args.LibraryOptions.EnablePhotos))
+                {
+                    if (IsImageFile(args.Path, _imageProcessor))
+                    {
+                        var filename = Path.GetFileNameWithoutExtension(args.Path.AsSpan());
+
+                        // Make sure the image doesn't belong to a video file
+                        var files = _directoryService.GetFiles(Path.GetDirectoryName(args.Path)
+                            ?? throw new InvalidOperationException("Path can't be a root directory."));
+
+                        foreach (var file in files)
+                        {
+                            if (IsOwnedByMedia(_namingOptions, file.FullName, filename))
+                            {
+                                return null;
+                            }
+                        }
+
+                        return new Photo
+                        {
+                            Path = args.Path
+                        };
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        internal static bool IsOwnedByMedia(NamingOptions namingOptions, string file, ReadOnlySpan<char> imageFilename)
+        {
+            return VideoResolver.IsVideoFile(file, namingOptions) && IsOwnedByResolvedMedia(file, imageFilename);
+        }
+
+        internal static bool IsOwnedByResolvedMedia(ReadOnlySpan<char> file, ReadOnlySpan<char> imageFilename)
+            => imageFilename.StartsWith(Path.GetFileNameWithoutExtension(file), StringComparison.OrdinalIgnoreCase);
+
+        internal static bool IsImageFile(string path, IImageProcessor imageProcessor)
+        {
+            ArgumentNullException.ThrowIfNull(path);
+
+            var extension = Path.GetExtension(path.AsSpan()).TrimStart('.');
+            if (!imageProcessor.SupportedInputFormats.Contains(extension, StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            var filename = Path.GetFileNameWithoutExtension(path);
+
+            if (_ignoreFiles.Any(i => filename.StartsWith(i, StringComparison.OrdinalIgnoreCase)))
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs

@@ -0,0 +1,82 @@
+#nullable disable
+
+using System;
+using System.IO;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.LocalMetadata.Savers;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    /// <summary>
+    /// <see cref="IItemResolver"/> for <see cref="Playlist"/> library items.
+    /// </summary>
+    public class PlaylistResolver : GenericFolderResolver<Playlist>
+    {
+        private readonly CollectionType?[] _musicPlaylistCollectionTypes =
+        [
+            null,
+            CollectionType.music
+        ];
+
+        /// <inheritdoc/>
+        protected override Playlist Resolve(ItemResolveArgs args)
+        {
+            if (args.IsDirectory)
+            {
+                // It's a playlist if the path is a directory with [playlist] in its name
+                var filename = Path.GetFileName(Path.TrimEndingDirectorySeparator(args.Path));
+                if (string.IsNullOrEmpty(filename))
+                {
+                    return null;
+                }
+
+                if (filename.Contains("[playlist]", StringComparison.OrdinalIgnoreCase))
+                {
+                    return new Playlist
+                    {
+                        Path = args.Path,
+                        Name = filename.Replace("[playlist]", string.Empty, StringComparison.OrdinalIgnoreCase).Trim(),
+                        OpenAccess = true
+                    };
+                }
+
+                // It's a directory-based playlist if the directory contains a playlist file
+                var filePaths = Directory.EnumerateFiles(args.Path, "*", new EnumerationOptions { IgnoreInaccessible = true });
+                if (filePaths.Any(f => f.EndsWith(PlaylistXmlSaver.DefaultPlaylistFilename, StringComparison.OrdinalIgnoreCase)))
+                {
+                    return new Playlist
+                    {
+                        Path = args.Path,
+                        Name = filename,
+                        OpenAccess = true
+                    };
+                }
+            }
+
+            // Check if this is a music playlist file
+            // It should have the correct collection type and a supported file extension
+            else if (_musicPlaylistCollectionTypes.Contains(args.CollectionType))
+            {
+                var extension = Path.GetExtension(args.Path.AsSpan());
+                if (Playlist.SupportedExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
+                {
+                    return new Playlist
+                    {
+                        Path = args.Path,
+                        Name = Path.GetFileNameWithoutExtension(args.Path),
+                        IsInMixedFolder = true,
+                        PlaylistMediaType = MediaType.Audio,
+                        OpenAccess = true
+                    };
+                }
+            }
+
+            return null;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/SpecialFolderResolver.cs

@@ -0,0 +1,86 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.IO;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Library.Resolvers
+{
+    public class SpecialFolderResolver : GenericFolderResolver<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 => 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
+                    };
+                }
+            }
+
+            return null;
+        }
+
+        private CollectionType? 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))
+                .Select(i => Enum.TryParse<CollectionType>(i, out var collectionType) ? collectionType : (CollectionType?)null)
+                .FirstOrDefault(i => i is not null);
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/TV/EpisodeResolver.cs

@@ -0,0 +1,90 @@
+#nullable disable
+
+using System;
+using System.Linq;
+using Emby.Naming.Common;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers.TV
+{
+    /// <summary>
+    /// Class EpisodeResolver.
+    /// </summary>
+    public class EpisodeResolver : BaseVideoResolver<Episode>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EpisodeResolver"/> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="namingOptions">The naming options.</param>
+        /// <param name="directoryService">The directory service.</param>
+        public EpisodeResolver(ILogger<EpisodeResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService)
+            : base(logger, namingOptions, directoryService)
+        {
+        }
+
+        /// <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 is null)
+            {
+                return null;
+            }
+
+            // Just in case the user decided to nest episodes.
+            // Not officially supported but in some cases we can handle it.
+
+            var season = parent as Season ?? parent.GetParents().OfType<Season>().FirstOrDefault();
+
+            // If the parent is a Season or Series and the parent is not an extras folder, then this is an Episode if the VideoResolver returns something
+            // Also handle flat tv folders
+            if (season is not null
+                || args.GetCollectionType() == CollectionType.tvshows
+                || args.HasParent<Series>())
+            {
+                var episode = ResolveVideo<Episode>(args, false);
+
+                // Ignore extras
+                if (episode is null || episode.ExtraType is not null)
+                {
+                    return null;
+                }
+
+                var series = parent as Series ?? parent.GetParents().OfType<Series>().FirstOrDefault();
+
+                if (series is not null)
+                {
+                    episode.SeriesId = series.Id;
+                    episode.SeriesName = series.Name;
+                }
+
+                if (season is not null)
+                {
+                    episode.SeasonId = season.Id;
+                    episode.SeasonName = season.Name;
+                }
+
+                // Assume season 1 if there's no season folder and a season number could not be determined
+                if (season is null && !episode.ParentIndexNumber.HasValue && (episode.IndexNumber.HasValue || episode.PremiereDate.HasValue))
+                {
+                    episode.ParentIndexNumber = 1;
+                }
+
+                return episode;
+            }
+
+            return null;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs

@@ -0,0 +1,100 @@
+#nullable disable
+
+using System.Globalization;
+using Emby.Naming.Common;
+using Emby.Naming.TV;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Globalization;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers.TV
+{
+    /// <summary>
+    /// Class SeasonResolver.
+    /// </summary>
+    public class SeasonResolver : GenericFolderResolver<Season>
+    {
+        private readonly ILocalizationManager _localization;
+        private readonly ILogger<SeasonResolver> _logger;
+        private readonly NamingOptions _namingOptions;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SeasonResolver"/> class.
+        /// </summary>
+        /// <param name="namingOptions">The naming options.</param>
+        /// <param name="localization">The localization.</param>
+        /// <param name="logger">The logger.</param>
+        public SeasonResolver(
+            NamingOptions namingOptions,
+            ILocalizationManager localization,
+            ILogger<SeasonResolver> logger)
+        {
+            _namingOptions = namingOptions;
+            _localization = localization;
+            _logger = logger;
+        }
+
+        /// <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 series && args.IsDirectory)
+            {
+                var namingOptions = _namingOptions;
+
+                var path = args.Path;
+
+                var seasonParserResult = SeasonPathParser.Parse(path, series.ContainingFolderPath, true, true);
+
+                var season = new Season
+                {
+                    IndexNumber = seasonParserResult.SeasonNumber,
+                    SeriesId = series.Id,
+                    SeriesName = series.Name,
+                    Path = seasonParserResult.IsSeasonFolder ? path : null
+                };
+
+                if (!season.IndexNumber.HasValue || !seasonParserResult.IsSeasonFolder)
+                {
+                    var resolver = new Naming.TV.EpisodeResolver(namingOptions);
+
+                    var folderName = System.IO.Path.GetFileName(path);
+                    var testPath = @"\\test\" + folderName;
+
+                    var episodeInfo = resolver.Resolve(testPath, true);
+
+                    if (episodeInfo?.EpisodeNumber is not null && episodeInfo.SeasonNumber.HasValue)
+                    {
+                        _logger.LogDebug(
+                            "Found folder underneath series with episode number: {0}. Season {1}. Episode {2}",
+                            path,
+                            episodeInfo.SeasonNumber.Value,
+                            episodeInfo.EpisodeNumber.Value);
+
+                        return null;
+                    }
+                }
+
+                if (season.IndexNumber.HasValue && string.IsNullOrEmpty(season.Name))
+                {
+                    var seasonNumber = season.IndexNumber.Value;
+                    season.Name = seasonNumber == 0 ?
+                        args.LibraryOptions.SeasonZeroDisplayName :
+                        string.Format(
+                            CultureInfo.InvariantCulture,
+                            _localization.GetLocalizedString("NameSeasonNumber"),
+                            seasonNumber,
+                            args.LibraryOptions.PreferredMetadataLanguage);
+                }
+
+                return season;
+            }
+
+            return null;
+        }
+    }
+}

Emby.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs

@@ -0,0 +1,211 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Emby.Naming.Common;
+using Emby.Naming.TV;
+using Emby.Naming.Video;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Resolvers.TV
+{
+    /// <summary>
+    /// Class SeriesResolver.
+    /// </summary>
+    public class SeriesResolver : GenericFolderResolver<Series>
+    {
+        private readonly ILogger<SeriesResolver> _logger;
+        private readonly NamingOptions _namingOptions;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SeriesResolver"/> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="namingOptions">The naming options.</param>
+        public SeriesResolver(ILogger<SeriesResolver> logger,  NamingOptions namingOptions)
+        {
+            _logger = logger;
+            _namingOptions = namingOptions;
+        }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>The priority.</value>
+        public override ResolverPriority Priority => 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 seriesInfo = Naming.TV.SeriesResolver.Resolve(_namingOptions, args.Path);
+
+                var collectionType = args.GetCollectionType();
+                if (collectionType == CollectionType.tvshows)
+                {
+                    // TODO refactor into separate class or something, this is copied from LibraryManager.GetConfiguredContentType
+                    var configuredContentType = args.GetConfiguredContentType();
+                    if (configuredContentType != CollectionType.tvshows)
+                    {
+                        return new Series
+                        {
+                            Path = args.Path,
+                            Name = seriesInfo.Name
+                        };
+                    }
+                }
+                else if (collectionType is null)
+                {
+                    if (args.ContainsFileSystemEntryByName("tvshow.nfo"))
+                    {
+                        if (args.Parent is not null && 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 = seriesInfo.Name
+                        };
+                    }
+
+                    if (args.Parent is not null && args.Parent.IsRoot)
+                    {
+                        return null;
+                    }
+
+                    if (IsSeriesFolder(args.Path, args.FileSystemChildren, false))
+                    {
+                        return new Series
+                        {
+                            Path = args.Path,
+                            Name = seriesInfo.Name
+                        };
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private bool IsSeriesFolder(
+            string path,
+            IEnumerable<FileSystemMetadata> fileSystemChildren,
+            bool isTvContentType)
+        {
+            foreach (var child in fileSystemChildren)
+            {
+                if (child.IsDirectory)
+                {
+                    if (IsSeasonFolder(child.FullName, path, isTvContentType))
+                    {
+                        _logger.LogDebug("{Path} is a series because of season folder {Dir}.", path, child.FullName);
+                        return true;
+                    }
+                }
+                else
+                {
+                    string fullName = child.FullName;
+                    if (VideoResolver.IsVideoFile(path, _namingOptions))
+                    {
+                        if (isTvContentType)
+                        {
+                            return true;
+                        }
+
+                        var namingOptions = _namingOptions;
+
+                        var episodeResolver = new Naming.TV.EpisodeResolver(namingOptions);
+
+                        var episodeInfo = episodeResolver.Resolve(fullName, false, true, false, fillExtendedInfo: false);
+                        if (episodeInfo is not null && episodeInfo.EpisodeNumber.HasValue)
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            _logger.LogDebug("{Path} is not a series folder.", path);
+            return false;
+        }
+
+        /// <summary>
+        /// Determines whether [is season folder] [the specified path].
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="parentPath">The parentpath.</param>
+        /// <param name="isTvContentType">if set to <c>true</c> [is tv content type].</param>
+        /// <returns><c>true</c> if [is season folder] [the specified path]; otherwise, <c>false</c>.</returns>
+        private static bool IsSeasonFolder(string path, string parentPath, bool isTvContentType)
+        {
+            var seasonNumber = SeasonPathParser.Parse(path, parentPath, 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 static void SetProviderIdFromPath(Series item, string path)
+        {
+            var justName = Path.GetFileName(path.AsSpan());
+
+            var imdbId = justName.GetAttributeValue("imdbid");
+            item.TrySetProviderId(MetadataProvider.Imdb, imdbId);
+
+            var tvdbId = justName.GetAttributeValue("tvdbid");
+            item.TrySetProviderId(MetadataProvider.Tvdb, tvdbId);
+
+            var tvmazeId = justName.GetAttributeValue("tvmazeid");
+            item.TrySetProviderId(MetadataProvider.TvMaze, tvmazeId);
+
+            var tmdbId = justName.GetAttributeValue("tmdbid");
+            item.TrySetProviderId(MetadataProvider.Tmdb, tmdbId);
+
+            var anidbId = justName.GetAttributeValue("anidbid");
+            item.TrySetProviderId("AniDB", anidbId);
+
+            var aniListId = justName.GetAttributeValue("anilistid");
+            item.TrySetProviderId("AniList", aniListId);
+
+            var aniSearchId = justName.GetAttributeValue("anisearchid");
+            item.TrySetProviderId("AniSearch", aniSearchId);
+        }
+    }
+}

Emby.Server.Implementations/Library/SearchEngine.cs

@@ -0,0 +1,200 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Querying;
+using MediaBrowser.Model.Search;
+
+namespace Emby.Server.Implementations.Library
+{
+    public class SearchEngine : ISearchEngine
+    {
+        private readonly ILibraryManager _libraryManager;
+        private readonly IUserManager _userManager;
+
+        public SearchEngine(ILibraryManager libraryManager, IUserManager userManager)
+        {
+            _libraryManager = libraryManager;
+            _userManager = userManager;
+        }
+
+        public QueryResult<SearchHintInfo> GetSearchHints(SearchQuery query)
+        {
+            User? user = null;
+            if (!query.UserId.IsEmpty())
+            {
+                user = _userManager.GetUserById(query.UserId);
+            }
+
+            var results = GetSearchHints(query, user);
+            var totalRecordCount = results.Count;
+
+            if (query.StartIndex.HasValue)
+            {
+                results = results.GetRange(query.StartIndex.Value, totalRecordCount - query.StartIndex.Value);
+            }
+
+            if (query.Limit.HasValue && query.Limit.Value > 0)
+            {
+                results = results.GetRange(0, Math.Min(query.Limit.Value, results.Count));
+            }
+
+            return new QueryResult<SearchHintInfo>(
+                query.StartIndex,
+                totalRecordCount,
+                results);
+        }
+
+        private static void AddIfMissing(List<BaseItemKind> list, BaseItemKind value)
+        {
+            if (!list.Contains(value))
+            {
+                list.Add(value);
+            }
+        }
+
+        /// <summary>
+        /// Gets the search hints.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <param name="user">The user.</param>
+        /// <returns>IEnumerable{SearchHintResult}.</returns>
+        /// <exception cref="ArgumentException"><c>query.SearchTerm</c> is <c>null</c> or empty.</exception>
+        private List<SearchHintInfo> GetSearchHints(SearchQuery query, User? user)
+        {
+            var searchTerm = query.SearchTerm;
+
+            ArgumentException.ThrowIfNullOrEmpty(searchTerm);
+
+            searchTerm = searchTerm.Trim().RemoveDiacritics();
+
+            var excludeItemTypes = query.ExcludeItemTypes.ToList();
+            var includeItemTypes = query.IncludeItemTypes.ToList();
+
+            excludeItemTypes.Add(BaseItemKind.Year);
+            excludeItemTypes.Add(BaseItemKind.Folder);
+
+            if (query.IncludeGenres && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Genre)))
+            {
+                if (!query.IncludeMedia)
+                {
+                    AddIfMissing(includeItemTypes, BaseItemKind.Genre);
+                    AddIfMissing(includeItemTypes, BaseItemKind.MusicGenre);
+                }
+            }
+            else
+            {
+                AddIfMissing(excludeItemTypes, BaseItemKind.Genre);
+                AddIfMissing(excludeItemTypes, BaseItemKind.MusicGenre);
+            }
+
+            if (query.IncludePeople && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Person)))
+            {
+                if (!query.IncludeMedia)
+                {
+                    AddIfMissing(includeItemTypes, BaseItemKind.Person);
+                }
+            }
+            else
+            {
+                AddIfMissing(excludeItemTypes, BaseItemKind.Person);
+            }
+
+            if (query.IncludeStudios && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Studio)))
+            {
+                if (!query.IncludeMedia)
+                {
+                    AddIfMissing(includeItemTypes, BaseItemKind.Studio);
+                }
+            }
+            else
+            {
+                AddIfMissing(excludeItemTypes, BaseItemKind.Studio);
+            }
+
+            if (query.IncludeArtists && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.MusicArtist)))
+            {
+                if (!query.IncludeMedia)
+                {
+                    AddIfMissing(includeItemTypes, BaseItemKind.MusicArtist);
+                }
+            }
+            else
+            {
+                AddIfMissing(excludeItemTypes, BaseItemKind.MusicArtist);
+            }
+
+            AddIfMissing(excludeItemTypes, BaseItemKind.CollectionFolder);
+            AddIfMissing(excludeItemTypes, BaseItemKind.Folder);
+            var mediaTypes = query.MediaTypes.ToList();
+
+            if (includeItemTypes.Count > 0)
+            {
+                excludeItemTypes.Clear();
+                mediaTypes.Clear();
+            }
+
+            var searchQuery = new InternalItemsQuery(user)
+            {
+                SearchTerm = searchTerm,
+                ExcludeItemTypes = excludeItemTypes.ToArray(),
+                IncludeItemTypes = includeItemTypes.ToArray(),
+                Limit = query.Limit,
+                IncludeItemsByName = !query.ParentId.HasValue,
+                ParentId = query.ParentId ?? Guid.Empty,
+                OrderBy = new[] { (ItemSortBy.SortName, SortOrder.Ascending) },
+                Recursive = true,
+
+                IsKids = query.IsKids,
+                IsMovie = query.IsMovie,
+                IsNews = query.IsNews,
+                IsSeries = query.IsSeries,
+                IsSports = query.IsSports,
+                MediaTypes = mediaTypes.ToArray(),
+
+                DtoOptions = new DtoOptions
+                {
+                    Fields = new ItemFields[]
+                    {
+                        ItemFields.AirTime,
+                        ItemFields.DateCreated,
+                        ItemFields.ChannelInfo,
+                        ItemFields.ParentId
+                    }
+                }
+            };
+
+            IReadOnlyList<BaseItem> mediaItems;
+
+            if (searchQuery.IncludeItemTypes.Length == 1 && searchQuery.IncludeItemTypes[0] == BaseItemKind.MusicArtist)
+            {
+                if (!searchQuery.ParentId.IsEmpty())
+                {
+                    searchQuery.AncestorIds = [searchQuery.ParentId];
+                    searchQuery.ParentId = Guid.Empty;
+                }
+
+                searchQuery.IncludeItemsByName = true;
+                searchQuery.IncludeItemTypes = Array.Empty<BaseItemKind>();
+                mediaItems = _libraryManager.GetAllArtists(searchQuery).Items.Select(i => i.Item).ToList();
+            }
+            else
+            {
+                mediaItems = _libraryManager.GetItemList(searchQuery);
+            }
+
+            return mediaItems.Select(i => new SearchHintInfo
+            {
+                Item = i
+            }).ToList();
+        }
+    }
+}

Emby.Server.Implementations/Library/SplashscreenPostScanTask.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library;
+
+/// <summary>
+/// The splashscreen post scan task.
+/// </summary>
+public class SplashscreenPostScanTask : ILibraryPostScanTask
+{
+    private readonly IItemRepository _itemRepository;
+    private readonly IImageEncoder _imageEncoder;
+    private readonly ILogger<SplashscreenPostScanTask> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SplashscreenPostScanTask"/> class.
+    /// </summary>
+    /// <param name="itemRepository">Instance of the <see cref="IItemRepository"/> interface.</param>
+    /// <param name="imageEncoder">Instance of the <see cref="IImageEncoder"/> interface.</param>
+    /// <param name="logger">Instance of the <see cref="ILogger{SplashscreenPostScanTask}"/> interface.</param>
+    public SplashscreenPostScanTask(
+        IItemRepository itemRepository,
+        IImageEncoder imageEncoder,
+        ILogger<SplashscreenPostScanTask> logger)
+    {
+        _itemRepository = itemRepository;
+        _imageEncoder = imageEncoder;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var posters = GetItemsWithImageType(ImageType.Primary)
+            .Select(x => x.GetImages(ImageType.Primary).FirstOrDefault()?.Path)
+            .Where(path => !string.IsNullOrEmpty(path))
+            .Select(path => path!)
+            .ToList();
+        var backdrops = GetItemsWithImageType(ImageType.Thumb)
+            .Select(x => x.GetImages(ImageType.Thumb).FirstOrDefault()?.Path)
+            .Where(path => !string.IsNullOrEmpty(path))
+            .Select(path => path!)
+            .ToList();
+        if (backdrops.Count == 0)
+        {
+            // Thumb images fit better because they include the title in the image but are not provided with TMDb.
+            // Using backdrops as a fallback to generate an image at all
+            _logger.LogDebug("No thumb images found. Using backdrops to generate splashscreen");
+            backdrops = GetItemsWithImageType(ImageType.Backdrop)
+                .Select(x => x.GetImages(ImageType.Backdrop).FirstOrDefault()?.Path)
+                .Where(path => !string.IsNullOrEmpty(path))
+                .Select(path => path!)
+                .ToList();
+        }
+
+        _imageEncoder.CreateSplashscreen(posters, backdrops);
+        return Task.CompletedTask;
+    }
+
+    private IReadOnlyList<BaseItem> GetItemsWithImageType(ImageType imageType)
+    {
+        // TODO make included libraries configurable
+        return _itemRepository.GetItemList(new InternalItemsQuery
+        {
+            CollapseBoxSetItems = false,
+            Recursive = true,
+            DtoOptions = new DtoOptions(false),
+            ImageTypes = [imageType],
+            Limit = 30,
+            // TODO max parental rating configurable
+            MaxParentalRating = new(10, null),
+            OrderBy =
+            [
+                (ItemSortBy.Random, SortOrder.Ascending)
+            ],
+            IncludeItemTypes = [BaseItemKind.Movie, BaseItemKind.Series]
+        });
+    }
+}

Emby.Server.Implementations/Library/UserDataManager.cs

@@ -0,0 +1,368 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using BitFaster.Caching.Lru;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using Microsoft.EntityFrameworkCore;
+using AudioBook = MediaBrowser.Controller.Entities.AudioBook;
+using Book = MediaBrowser.Controller.Entities.Book;
+
+namespace Emby.Server.Implementations.Library
+{
+    /// <summary>
+    /// Class UserDataManager.
+    /// </summary>
+    public class UserDataManager : IUserDataManager
+    {
+        private readonly IServerConfigurationManager _config;
+        private readonly IDbContextFactory<JellyfinDbContext> _repository;
+        private readonly FastConcurrentLru<string, UserItemData> _cache;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UserDataManager"/> class.
+        /// </summary>
+        /// <param name="config">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
+        /// <param name="repository">Instance of the <see cref="IDbContextFactory{JellyfinDbContext}"/> interface.</param>
+        public UserDataManager(
+            IServerConfigurationManager config,
+            IDbContextFactory<JellyfinDbContext> repository)
+        {
+            _config = config;
+            _repository = repository;
+            _cache = new FastConcurrentLru<string, UserItemData>(Environment.ProcessorCount, _config.Configuration.CacheSize, StringComparer.OrdinalIgnoreCase);
+        }
+
+        /// <inheritdoc />
+        public event EventHandler<UserDataSaveEventArgs>? UserDataSaved;
+
+        /// <inheritdoc />
+        public void SaveUserData(User user, BaseItem item, UserItemData userData, UserDataSaveReason reason, CancellationToken cancellationToken)
+        {
+            ArgumentNullException.ThrowIfNull(userData);
+
+            ArgumentNullException.ThrowIfNull(item);
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var keys = item.GetUserDataKeys();
+
+            using var dbContext = _repository.CreateDbContext();
+            using var transaction = dbContext.Database.BeginTransaction();
+
+            foreach (var key in keys)
+            {
+                userData.Key = key;
+                var userDataEntry = Map(userData, user.Id, item.Id);
+                if (dbContext.UserData.Any(f => f.ItemId == userDataEntry.ItemId && f.UserId == userDataEntry.UserId && f.CustomDataKey == userDataEntry.CustomDataKey))
+                {
+                    dbContext.UserData.Attach(userDataEntry).State = EntityState.Modified;
+                }
+                else
+                {
+                    dbContext.UserData.Add(userDataEntry);
+                }
+            }
+
+            dbContext.SaveChanges();
+            transaction.Commit();
+
+            var userId = user.InternalId;
+            var cacheKey = GetCacheKey(userId, item.Id);
+            _cache.AddOrUpdate(cacheKey, userData);
+            item.UserData = dbContext.UserData.Where(e => e.ItemId == item.Id).AsNoTracking().ToArray(); // rehydrate the cached userdata
+
+            UserDataSaved?.Invoke(this, new UserDataSaveEventArgs
+            {
+                Keys = keys,
+                UserData = userData,
+                SaveReason = reason,
+                UserId = user.Id,
+                Item = item
+            });
+        }
+
+        /// <inheritdoc />
+        public void SaveUserData(User user, BaseItem item, UpdateUserItemDataDto userDataDto, UserDataSaveReason reason)
+        {
+            ArgumentNullException.ThrowIfNull(user);
+            ArgumentNullException.ThrowIfNull(item);
+            ArgumentNullException.ThrowIfNull(userDataDto);
+
+            var userData = GetUserData(user, item) ?? throw new InvalidOperationException("UserData should not be null.");
+
+            if (userDataDto.PlaybackPositionTicks.HasValue)
+            {
+                userData.PlaybackPositionTicks = userDataDto.PlaybackPositionTicks.Value;
+            }
+
+            if (userDataDto.PlayCount.HasValue)
+            {
+                userData.PlayCount = userDataDto.PlayCount.Value;
+            }
+
+            if (userDataDto.IsFavorite.HasValue)
+            {
+                userData.IsFavorite = userDataDto.IsFavorite.Value;
+            }
+
+            if (userDataDto.Likes.HasValue)
+            {
+                userData.Likes = userDataDto.Likes.Value;
+            }
+
+            if (userDataDto.Played.HasValue)
+            {
+                userData.Played = userDataDto.Played.Value;
+            }
+
+            if (userDataDto.LastPlayedDate.HasValue)
+            {
+                userData.LastPlayedDate = userDataDto.LastPlayedDate.Value;
+            }
+
+            if (userDataDto.Rating.HasValue)
+            {
+                userData.Rating = userDataDto.Rating.Value;
+            }
+
+            SaveUserData(user, item, userData, reason, CancellationToken.None);
+        }
+
+        private UserData Map(UserItemData dto, Guid userId, Guid itemId)
+        {
+            return new UserData()
+            {
+                ItemId = itemId,
+                CustomDataKey = dto.Key,
+                Item = null,
+                User = null,
+                AudioStreamIndex = dto.AudioStreamIndex,
+                IsFavorite = dto.IsFavorite,
+                LastPlayedDate = dto.LastPlayedDate,
+                Likes = dto.Likes,
+                PlaybackPositionTicks = dto.PlaybackPositionTicks,
+                PlayCount = dto.PlayCount,
+                Played = dto.Played,
+                Rating = dto.Rating,
+                UserId = userId,
+                SubtitleStreamIndex = dto.SubtitleStreamIndex,
+            };
+        }
+
+        private static UserItemData Map(UserData dto)
+        {
+            return new UserItemData()
+            {
+                Key = dto.CustomDataKey!,
+                AudioStreamIndex = dto.AudioStreamIndex,
+                IsFavorite = dto.IsFavorite,
+                LastPlayedDate = dto.LastPlayedDate,
+                Likes = dto.Likes,
+                PlaybackPositionTicks = dto.PlaybackPositionTicks,
+                PlayCount = dto.PlayCount,
+                Played = dto.Played,
+                Rating = dto.Rating,
+                SubtitleStreamIndex = dto.SubtitleStreamIndex,
+            };
+        }
+
+        private UserItemData? GetUserData(User user, Guid itemId, List<string> keys)
+        {
+            var cacheKey = GetCacheKey(user.InternalId, itemId);
+
+            if (_cache.TryGet(cacheKey, out var data))
+            {
+                return data;
+            }
+
+            data = GetUserDataInternal(user.Id, itemId, keys);
+
+            if (data is null)
+            {
+                return new UserItemData()
+                {
+                    Key = keys[0],
+                };
+            }
+
+            return _cache.GetOrAdd(cacheKey, _ => data);
+        }
+
+        private UserItemData? GetUserDataInternal(Guid userId, Guid itemId, List<string> keys)
+        {
+            if (keys.Count == 0)
+            {
+                return null;
+            }
+
+            using var context = _repository.CreateDbContext();
+            var userData = context.UserData.AsNoTracking().Where(e => e.ItemId == itemId && keys.Contains(e.CustomDataKey) && e.UserId.Equals(userId)).ToArray();
+
+            if (userData.Length > 0)
+            {
+                var directDataReference = userData.FirstOrDefault(e => e.CustomDataKey == itemId.ToString("N"));
+                if (directDataReference is not null)
+                {
+                    return Map(directDataReference);
+                }
+
+                return Map(userData.First());
+            }
+
+            return new UserItemData
+            {
+                Key = keys.Last()!
+            };
+        }
+
+        /// <summary>
+        /// Gets the internal key.
+        /// </summary>
+        /// <returns>System.String.</returns>
+        private static string GetCacheKey(long internalUserId, Guid itemId)
+        {
+            return internalUserId.ToString(CultureInfo.InvariantCulture) + "-" + itemId.ToString("N", CultureInfo.InvariantCulture);
+        }
+
+        /// <inheritdoc />
+        public UserItemData? GetUserData(User user, BaseItem item)
+        {
+            return item.UserData?.Where(e => e.UserId.Equals(user.Id)).Select(Map).FirstOrDefault() ?? new UserItemData()
+            {
+                Key = item.GetUserDataKeys()[0],
+            };
+        }
+
+        /// <inheritdoc />
+        public UserItemDataDto? GetUserDataDto(BaseItem item, User user)
+            => GetUserDataDto(item, null, user, new DtoOptions());
+
+        /// <inheritdoc />
+        public UserItemDataDto? GetUserDataDto(BaseItem item, BaseItemDto? itemDto, User user, DtoOptions options)
+        {
+            var userData = GetUserData(user, item);
+            if (userData is null)
+            {
+                return null;
+            }
+
+            var dto = GetUserItemDataDto(userData, item.Id);
+
+            item.FillUserDataDtoValues(dto, userData, itemDto, user, options);
+            return dto;
+        }
+
+        /// <summary>
+        /// Converts a UserItemData to a DTOUserItemData.
+        /// </summary>
+        /// <param name="data">The data.</param>
+        /// <param name="itemId">The reference key to an Item.</param>
+        /// <returns>DtoUserItemData.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="data"/> is <c>null</c>.</exception>
+        private UserItemDataDto GetUserItemDataDto(UserItemData data, Guid itemId)
+        {
+            ArgumentNullException.ThrowIfNull(data);
+
+            return new UserItemDataDto
+            {
+                IsFavorite = data.IsFavorite,
+                Likes = data.Likes,
+                PlaybackPositionTicks = data.PlaybackPositionTicks,
+                PlayCount = data.PlayCount,
+                Rating = data.Rating,
+                Played = data.Played,
+                LastPlayedDate = data.LastPlayedDate,
+                ItemId = itemId,
+                Key = data.Key
+            };
+        }
+
+        /// <inheritdoc />
+        public bool UpdatePlayState(BaseItem item, UserItemData data, long? reportedPositionTicks)
+        {
+            var playedToCompletion = false;
+
+            var runtimeTicks = item.GetRunTimeTicksForPlayState();
+
+            var positionTicks = reportedPositionTicks ?? runtimeTicks;
+            var hasRuntime = runtimeTicks > 0;
+
+            // If a position has been reported, and if we know the duration
+            if (positionTicks > 0 && hasRuntime && item is not AudioBook && item is not Book)
+            {
+                var pctIn = decimal.Divide(positionTicks, runtimeTicks) * 100;
+
+                if (pctIn < _config.Configuration.MinResumePct)
+                {
+                    // ignore progress during the beginning
+                    positionTicks = 0;
+                }
+                else if (pctIn > _config.Configuration.MaxResumePct || positionTicks >= (runtimeTicks - TimeSpan.TicksPerSecond))
+                {
+                    // mark as completed close to the end
+                    positionTicks = 0;
+                    data.Played = playedToCompletion = true;
+                }
+                else
+                {
+                    // Enforce MinResumeDuration
+                    var durationSeconds = TimeSpan.FromTicks(runtimeTicks).TotalSeconds;
+                    if (durationSeconds < _config.Configuration.MinResumeDurationSeconds)
+                    {
+                        positionTicks = 0;
+                        data.Played = playedToCompletion = true;
+                    }
+                }
+            }
+            else if (positionTicks > 0 && hasRuntime && item is AudioBook)
+            {
+                var playbackPositionInMinutes = TimeSpan.FromTicks(positionTicks).TotalMinutes;
+                var remainingTimeInMinutes = TimeSpan.FromTicks(runtimeTicks - positionTicks).TotalMinutes;
+
+                if (playbackPositionInMinutes < _config.Configuration.MinAudiobookResume)
+                {
+                    // ignore progress during the beginning
+                    positionTicks = 0;
+                }
+                else if (remainingTimeInMinutes < _config.Configuration.MaxAudiobookResume || positionTicks >= runtimeTicks)
+                {
+                    // mark as completed close to the end
+                    positionTicks = 0;
+                    data.Played = playedToCompletion = true;
+                }
+            }
+            else if (!hasRuntime)
+            {
+                // If we don't know the runtime we'll just have to assume it was fully played
+                data.Played = playedToCompletion = true;
+                positionTicks = 0;
+            }
+
+            if (!item.SupportsPlayedStatus)
+            {
+                positionTicks = 0;
+                data.Played = false;
+            }
+
+            if (!item.SupportsPositionTicksResume)
+            {
+                positionTicks = 0;
+            }
+
+            data.PlaybackPositionTicks = positionTicks;
+
+            return playedToCompletion;
+        }
+    }
+}

Emby.Server.Implementations/Library/UserViewManager.cs

@@ -0,0 +1,402 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using Jellyfin.Data;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Channels;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Channels;
+using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.Library;
+using MediaBrowser.Model.Querying;
+
+namespace Emby.Server.Implementations.Library
+{
+    public class UserViewManager : IUserViewManager
+    {
+        private readonly ILibraryManager _libraryManager;
+        private readonly ILocalizationManager _localizationManager;
+
+        private readonly IChannelManager _channelManager;
+        private readonly ILiveTvManager _liveTvManager;
+        private readonly IServerConfigurationManager _config;
+
+        public UserViewManager(ILibraryManager libraryManager, ILocalizationManager localizationManager, IChannelManager channelManager, ILiveTvManager liveTvManager, IServerConfigurationManager config)
+        {
+            _libraryManager = libraryManager;
+            _localizationManager = localizationManager;
+            _channelManager = channelManager;
+            _liveTvManager = liveTvManager;
+            _config = config;
+        }
+
+        public Folder[] GetUserViews(UserViewQuery query)
+        {
+            var user = query.User;
+
+            var folders = _libraryManager.GetUserRootFolder()
+                .GetChildren(user, true)
+                .OfType<Folder>()
+                .ToList();
+
+            var groupedFolders = new List<ICollectionFolder>();
+            var list = new List<Folder>();
+
+            foreach (var folder in folders)
+            {
+                var collectionFolder = folder as ICollectionFolder;
+                var folderViewType = collectionFolder?.CollectionType;
+
+                // Playlist library requires special handling because the folder only references user playlists
+                if (folderViewType == CollectionType.playlists)
+                {
+                    var items = folder.GetItemList(new InternalItemsQuery(user)
+                    {
+                        ParentId = folder.ParentId
+                    });
+
+                    if (!items.Any(item => item.IsVisible(user)))
+                    {
+                        continue;
+                    }
+                }
+
+                if (UserView.IsUserSpecific(folder))
+                {
+                    list.Add(_libraryManager.GetNamedView(user, folder.Name, folder.Id, folderViewType, null));
+                    continue;
+                }
+
+                if (collectionFolder is not null && UserView.IsEligibleForGrouping(folder) && user.IsFolderGrouped(folder.Id))
+                {
+                    groupedFolders.Add(collectionFolder);
+                    continue;
+                }
+
+                if (query.PresetViews.Contains(folderViewType))
+                {
+                    list.Add(GetUserView(folder, folderViewType, string.Empty));
+                }
+                else
+                {
+                    list.Add(folder);
+                }
+            }
+
+            foreach (var viewType in new[] { CollectionType.movies, CollectionType.tvshows })
+            {
+                var parents = groupedFolders.Where(i => i.CollectionType == viewType || i.CollectionType is null)
+                    .ToList();
+
+                if (parents.Count > 0)
+                {
+                    var localizationKey = viewType == CollectionType.tvshows
+                        ? "TvShows"
+                        : "Movies";
+
+                    list.Add(GetUserView(parents, viewType, localizationKey, string.Empty, user, query.PresetViews));
+                }
+            }
+
+            if (_config.Configuration.EnableFolderView)
+            {
+                var name = _localizationManager.GetLocalizedString("Folders");
+                list.Add(_libraryManager.GetNamedView(name, CollectionType.folders, string.Empty));
+            }
+
+            if (query.IncludeExternalContent)
+            {
+                var channelResult = _channelManager.GetChannelsInternalAsync(new ChannelQuery
+                {
+                    UserId = user.Id
+                }).GetAwaiter().GetResult();
+
+                var channels = channelResult.Items;
+
+                list.AddRange(channels);
+
+                if (_liveTvManager.GetEnabledUsers().Select(i => i.Id).Contains(user.Id))
+                {
+                    list.Add(_liveTvManager.GetInternalLiveTvFolder(CancellationToken.None));
+                }
+            }
+
+            if (!query.IncludeHidden)
+            {
+                list = list.Where(i => !user.GetPreferenceValues<Guid>(PreferenceKind.MyMediaExcludes).Contains(i.Id)).ToList();
+            }
+
+            var sorted = _libraryManager.Sort(list, user, new[] { ItemSortBy.SortName }, SortOrder.Ascending).ToList();
+            var orders = user.GetPreferenceValues<Guid>(PreferenceKind.OrderedViews);
+
+            return list
+                .OrderBy(i =>
+                {
+                    var index = Array.IndexOf(orders, i.Id);
+                    if (index == -1
+                        && i is UserView view
+                        && !view.DisplayParentId.IsEmpty())
+                    {
+                        index = Array.IndexOf(orders, view.DisplayParentId);
+                    }
+
+                    return index == -1 ? int.MaxValue : index;
+                })
+                .ThenBy(sorted.IndexOf)
+                .ThenBy(i => i.SortName)
+                .ToArray();
+        }
+
+        public UserView GetUserSubViewWithName(string name, Guid parentId, CollectionType? type, string sortName)
+        {
+            var uniqueId = parentId + "subview" + type;
+
+            return _libraryManager.GetNamedView(name, parentId, type, sortName, uniqueId);
+        }
+
+        public UserView GetUserSubView(Guid parentId, CollectionType? type, string localizationKey, string sortName)
+        {
+            var name = _localizationManager.GetLocalizedString(localizationKey);
+
+            return GetUserSubViewWithName(name, parentId, type, sortName);
+        }
+
+        private Folder GetUserView(
+            List<ICollectionFolder> parents,
+            CollectionType? viewType,
+            string localizationKey,
+            string sortName,
+            User user,
+            CollectionType?[] presetViews)
+        {
+            if (parents.Count == 1 && parents.All(i => i.CollectionType == viewType))
+            {
+                if (!presetViews.Contains(viewType))
+                {
+                    return (Folder)parents[0];
+                }
+
+                return GetUserView((Folder)parents[0], viewType, string.Empty);
+            }
+
+            var name = _localizationManager.GetLocalizedString(localizationKey);
+            return _libraryManager.GetNamedView(user, name, viewType, sortName);
+        }
+
+        public UserView GetUserView(Folder parent, CollectionType? viewType, string sortName)
+        {
+            return _libraryManager.GetShadowView(parent, viewType, sortName);
+        }
+
+        public List<Tuple<BaseItem, List<BaseItem>>> GetLatestItems(LatestItemsQuery request, DtoOptions options)
+        {
+            var libraryItems = GetItemsForLatestItems(request.User, request, options);
+
+            var list = new List<Tuple<BaseItem, List<BaseItem>>>();
+
+            foreach (var item in libraryItems)
+            {
+                // Only grab the index container for media
+                var container = item.IsFolder || !request.GroupItems ? null : item.LatestItemsIndexContainer;
+
+                if (container is null)
+                {
+                    list.Add(new Tuple<BaseItem, List<BaseItem>>(null, new List<BaseItem> { item }));
+                }
+                else
+                {
+                    var current = list.FirstOrDefault(i => i.Item1 is not null && i.Item1.Id.Equals(container.Id));
+
+                    if (current is not null)
+                    {
+                        current.Item2.Add(item);
+                    }
+                    else
+                    {
+                        list.Add(new Tuple<BaseItem, List<BaseItem>>(container, new List<BaseItem> { item }));
+                    }
+                }
+
+                if (list.Count >= request.Limit)
+                {
+                    break;
+                }
+            }
+
+            return list;
+        }
+
+        private IReadOnlyList<BaseItem> GetItemsForLatestItems(User user, LatestItemsQuery request, DtoOptions options)
+        {
+            var parentId = request.ParentId;
+
+            var includeItemTypes = request.IncludeItemTypes;
+            var limit = request.Limit ?? 10;
+
+            var parents = new List<BaseItem>();
+
+            if (!parentId.IsEmpty())
+            {
+                var parentItem = _libraryManager.GetItemById(parentId);
+                if (parentItem is Channel)
+                {
+                    return _channelManager.GetLatestChannelItemsInternal(
+                        new InternalItemsQuery(user)
+                        {
+                            ChannelIds = new[] { parentId },
+                            IsPlayed = request.IsPlayed,
+                            StartIndex = request.StartIndex,
+                            Limit = request.Limit,
+                            IncludeItemTypes = request.IncludeItemTypes,
+                            EnableTotalRecordCount = false
+                        },
+                        CancellationToken.None).GetAwaiter().GetResult().Items;
+                }
+
+                if (parentItem is Folder parent)
+                {
+                    parents.Add(parent);
+                }
+            }
+
+            var isPlayed = request.IsPlayed;
+
+            if (parents.OfType<ICollectionFolder>().Any(i => i.CollectionType == CollectionType.music))
+            {
+                isPlayed = null;
+            }
+
+            if (parents.Count == 0)
+            {
+                parents = _libraryManager.GetUserRootFolder().GetChildren(user, true)
+                    .Where(i => i is Folder)
+                    .Where(i => !user.GetPreferenceValues<Guid>(PreferenceKind.LatestItemExcludes)
+                        .Contains(i.Id))
+                    .ToList();
+            }
+
+            if (parents.Count == 0)
+            {
+                return Array.Empty<BaseItem>();
+            }
+
+            if (includeItemTypes.Length == 0)
+            {
+                // Handle situations with the grouping setting, e.g. movies showing up in tv, etc.
+                // Thanks to mixed content libraries included in the UserView
+                var hasCollectionType = parents.OfType<UserView>().ToList();
+                if (hasCollectionType.Count > 0)
+                {
+                    if (hasCollectionType.All(i => i.CollectionType == CollectionType.movies))
+                    {
+                        includeItemTypes = new[] { BaseItemKind.Movie };
+                    }
+                    else if (hasCollectionType.All(i => i.CollectionType == CollectionType.tvshows))
+                    {
+                        includeItemTypes = new[] { BaseItemKind.Episode };
+                    }
+                }
+            }
+
+            MediaType[] mediaTypes = [];
+
+            if (includeItemTypes.Length == 0)
+            {
+                HashSet<MediaType> tmpMediaTypes = [];
+                foreach (var parent in parents.OfType<ICollectionFolder>())
+                {
+                    switch (parent.CollectionType)
+                    {
+                        case CollectionType.books:
+                            tmpMediaTypes.Add(MediaType.Book);
+                            tmpMediaTypes.Add(MediaType.Audio);
+                            break;
+                        case CollectionType.music:
+                            tmpMediaTypes.Add(MediaType.Audio);
+                            break;
+                        case CollectionType.photos:
+                            tmpMediaTypes.Add(MediaType.Photo);
+                            tmpMediaTypes.Add(MediaType.Video);
+                            break;
+                        case CollectionType.homevideos:
+                            tmpMediaTypes.Add(MediaType.Photo);
+                            tmpMediaTypes.Add(MediaType.Video);
+                            break;
+                        default:
+                            tmpMediaTypes.Add(MediaType.Video);
+                            break;
+                    }
+                }
+
+                mediaTypes = tmpMediaTypes.ToArray();
+            }
+
+            var excludeItemTypes = includeItemTypes.Length == 0 && mediaTypes.Length == 0
+                ? new[]
+                {
+                    BaseItemKind.Person,
+                    BaseItemKind.Studio,
+                    BaseItemKind.Year,
+                    BaseItemKind.MusicGenre,
+                    BaseItemKind.Genre
+                }
+                : Array.Empty<BaseItemKind>();
+
+            var query = new InternalItemsQuery(user)
+            {
+                IncludeItemTypes = includeItemTypes,
+                OrderBy = new[]
+                {
+                    (ItemSortBy.DateCreated, SortOrder.Descending),
+                    (ItemSortBy.SortName, SortOrder.Descending),
+                    (ItemSortBy.ProductionYear, SortOrder.Descending)
+                },
+                IsFolder = includeItemTypes.Length == 0 ? false : null,
+                ExcludeItemTypes = excludeItemTypes,
+                IsVirtualItem = false,
+                Limit = limit * 5,
+                IsPlayed = isPlayed,
+                DtoOptions = options,
+                MediaTypes = mediaTypes
+            };
+
+            if (request.GroupItems)
+            {
+                var collectionType = parents
+                    .Select(parent => parent switch
+                    {
+                        ICollectionFolder collectionFolder => collectionFolder.CollectionType,
+                        UserView userView => userView.CollectionType,
+                        _ => null
+                    })
+                    .FirstOrDefault(type => type is not null);
+
+                if (collectionType == CollectionType.tvshows)
+                {
+                    query.Limit = limit;
+                    return _libraryManager.GetLatestItemList(query, parents, CollectionType.tvshows);
+                }
+
+                if (collectionType == CollectionType.music)
+                {
+                    query.Limit = limit;
+                    return _libraryManager.GetLatestItemList(query, parents, CollectionType.music);
+                }
+            }
+
+            return _libraryManager.GetItemList(query, parents);
+        }
+    }
+}

Emby.Server.Implementations/Library/Validators/ArtistsPostScanTask.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class ArtistsPostScanTask.
+/// </summary>
+public class ArtistsPostScanTask : ILibraryPostScanTask
+{
+    /// <summary>
+    /// The _library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+    private readonly ILogger<ArtistsValidator> _logger;
+    private readonly IItemRepository _itemRepo;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ArtistsPostScanTask" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="itemRepo">The item repository.</param>
+    public ArtistsPostScanTask(
+        ILibraryManager libraryManager,
+        ILogger<ArtistsValidator> logger,
+        IItemRepository itemRepo)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _itemRepo = itemRepo;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        return new ArtistsValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+    }
+}

Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class ArtistsValidator.
+/// </summary>
+public class ArtistsValidator
+{
+    /// <summary>
+    /// The library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// The logger.
+    /// </summary>
+    private readonly ILogger<ArtistsValidator> _logger;
+    private readonly IItemRepository _itemRepo;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ArtistsValidator" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="itemRepo">The item repository.</param>
+    public ArtistsValidator(ILibraryManager libraryManager, ILogger<ArtistsValidator> logger, IItemRepository itemRepo)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _itemRepo = itemRepo;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var names = _itemRepo.GetAllArtistNames();
+
+        var numComplete = 0;
+        var count = names.Count;
+
+        foreach (var name in names)
+        {
+            try
+            {
+                var item = _libraryManager.GetArtist(name);
+
+                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                // Don't clutter the log
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error refreshing {ArtistName}", name);
+            }
+
+            numComplete++;
+            double percent = numComplete;
+            percent /= count;
+            percent *= 100;
+
+            progress.Report(percent);
+        }
+
+        var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.MusicArtist],
+            IsDeadArtist = true,
+            IsLocked = false
+        }).Cast<MusicArtist>().ToList();
+
+        foreach (var item in deadEntities)
+        {
+            if (!item.IsAccessedByName)
+            {
+                continue;
+            }
+
+            _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
+
+            _libraryManager.DeleteItem(
+                item,
+                new DeleteOptions
+                {
+                    DeleteFileLocation = false
+                },
+                false);
+        }
+
+        progress.Report(100);
+    }
+}

Emby.Server.Implementations/Library/Validators/CollectionPostScanTask.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Collections;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class CollectionPostScanTask.
+/// </summary>
+public class CollectionPostScanTask : ILibraryPostScanTask
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly ICollectionManager _collectionManager;
+    private readonly ILogger<CollectionPostScanTask> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CollectionPostScanTask" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="collectionManager">The collection manager.</param>
+    /// <param name="logger">The logger.</param>
+    public CollectionPostScanTask(
+        ILibraryManager libraryManager,
+        ICollectionManager collectionManager,
+        ILogger<CollectionPostScanTask> logger)
+    {
+        _libraryManager = libraryManager;
+        _collectionManager = collectionManager;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var collectionNameMoviesMap = new Dictionary<string, HashSet<Guid>>();
+
+        foreach (var library in _libraryManager.RootFolder.Children)
+        {
+            if (!_libraryManager.GetLibraryOptions(library).AutomaticallyAddToCollection)
+            {
+                continue;
+            }
+
+            var startIndex = 0;
+            var pagesize = 1000;
+
+            while (true)
+            {
+                var movies = _libraryManager.GetItemList(new InternalItemsQuery
+                {
+                    MediaTypes = [MediaType.Video],
+                    IncludeItemTypes = [BaseItemKind.Movie],
+                    IsVirtualItem = false,
+                    OrderBy = [(ItemSortBy.SortName, SortOrder.Ascending)],
+                    Parent = library,
+                    StartIndex = startIndex,
+                    Limit = pagesize,
+                    Recursive = true
+                });
+
+                foreach (var m in movies)
+                {
+                    if (m is Movie movie && !string.IsNullOrEmpty(movie.CollectionName))
+                    {
+                        if (collectionNameMoviesMap.TryGetValue(movie.CollectionName, out var movieList))
+                        {
+                            movieList.Add(movie.Id);
+                        }
+                        else
+                        {
+                            collectionNameMoviesMap[movie.CollectionName] = new HashSet<Guid> { movie.Id };
+                        }
+                    }
+                }
+
+                if (movies.Count < pagesize)
+                {
+                    break;
+                }
+
+                startIndex += pagesize;
+            }
+        }
+
+        var numComplete = 0;
+        var count = collectionNameMoviesMap.Count;
+
+        if (count == 0)
+        {
+            progress.Report(100);
+            return;
+        }
+
+        var boxSets = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.BoxSet],
+            CollapseBoxSetItems = false,
+            Recursive = true
+        });
+
+        foreach (var (collectionName, movieIds) in collectionNameMoviesMap)
+        {
+            try
+            {
+                var boxSet = boxSets.FirstOrDefault(b => b?.Name == collectionName) as BoxSet;
+                if (boxSet is null)
+                {
+                    // won't automatically create collection if only one movie in it
+                    if (movieIds.Count >= 2)
+                    {
+                        boxSet = await _collectionManager.CreateCollectionAsync(new CollectionCreationOptions
+                        {
+                            Name = collectionName,
+                        }).ConfigureAwait(false);
+
+                        await _collectionManager.AddToCollectionAsync(boxSet.Id, movieIds).ConfigureAwait(false);
+                    }
+                }
+                else
+                {
+                    await _collectionManager.AddToCollectionAsync(boxSet.Id, movieIds).ConfigureAwait(false);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= count;
+                percent *= 100;
+
+                progress.Report(percent);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error refreshing {CollectionName} with {@MovieIds}", collectionName, movieIds);
+            }
+        }
+
+        progress.Report(100);
+    }
+}

Emby.Server.Implementations/Library/Validators/GenresPostScanTask.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class GenresPostScanTask.
+/// </summary>
+public class GenresPostScanTask : ILibraryPostScanTask
+{
+    /// <summary>
+    /// The _library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+    private readonly ILogger<GenresValidator> _logger;
+    private readonly IItemRepository _itemRepo;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GenresPostScanTask" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="itemRepo">The item repository.</param>
+    public GenresPostScanTask(
+        ILibraryManager libraryManager,
+        ILogger<GenresValidator> logger,
+        IItemRepository itemRepo)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _itemRepo = itemRepo;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        return new GenresValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+    }
+}

Emby.Server.Implementations/Library/Validators/GenresValidator.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class GenresValidator.
+/// </summary>
+public class GenresValidator
+{
+    /// <summary>
+    /// The library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+    private readonly IItemRepository _itemRepo;
+
+    /// <summary>
+    /// The logger.
+    /// </summary>
+    private readonly ILogger<GenresValidator> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GenresValidator"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="itemRepo">The item repository.</param>
+    public GenresValidator(ILibraryManager libraryManager, ILogger<GenresValidator> logger, IItemRepository itemRepo)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _itemRepo = itemRepo;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var names = _itemRepo.GetGenreNames();
+
+        var numComplete = 0;
+        var count = names.Count;
+
+        foreach (var name in names)
+        {
+            try
+            {
+                var item = _libraryManager.GetGenre(name);
+
+                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                // Don't clutter the log
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error refreshing {GenreName}", name);
+            }
+
+            numComplete++;
+            double percent = numComplete;
+            percent /= count;
+            percent *= 100;
+
+            progress.Report(percent);
+        }
+
+        var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Genre, BaseItemKind.MusicGenre],
+            IsDeadGenre = true,
+            IsLocked = false
+        });
+
+        foreach (var item in deadEntities)
+        {
+            _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
+
+            _libraryManager.DeleteItem(
+                item,
+                new DeleteOptions
+                {
+                    DeleteFileLocation = false
+                },
+                false);
+        }
+
+        progress.Report(100);
+    }
+}

Emby.Server.Implementations/Library/Validators/MusicGenresPostScanTask.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class MusicGenresPostScanTask.
+/// </summary>
+public class MusicGenresPostScanTask : ILibraryPostScanTask
+{
+    /// <summary>
+    /// The library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+    private readonly ILogger<MusicGenresValidator> _logger;
+    private readonly IItemRepository _itemRepo;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MusicGenresPostScanTask" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="itemRepo">The item repository.</param>
+    public MusicGenresPostScanTask(
+        ILibraryManager libraryManager,
+        ILogger<MusicGenresValidator> logger,
+        IItemRepository itemRepo)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _itemRepo = itemRepo;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        return new MusicGenresValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+    }
+}

Emby.Server.Implementations/Library/Validators/MusicGenresValidator.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class MusicGenresValidator.
+/// </summary>
+public class MusicGenresValidator
+{
+    /// <summary>
+    /// The library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// The logger.
+    /// </summary>
+    private readonly ILogger<MusicGenresValidator> _logger;
+    private readonly IItemRepository _itemRepo;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MusicGenresValidator" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="itemRepo">The item repository.</param>
+    public MusicGenresValidator(ILibraryManager libraryManager, ILogger<MusicGenresValidator> logger, IItemRepository itemRepo)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _itemRepo = itemRepo;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var names = _itemRepo.GetMusicGenreNames();
+
+        var numComplete = 0;
+        var count = names.Count;
+
+        foreach (var name in names)
+        {
+            try
+            {
+                var item = _libraryManager.GetMusicGenre(name);
+
+                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                // Don't clutter the log
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error refreshing {GenreName}", name);
+            }
+
+            numComplete++;
+            double percent = numComplete;
+            percent /= count;
+            percent *= 100;
+
+            progress.Report(percent);
+        }
+
+        progress.Report(100);
+    }
+}

Emby.Server.Implementations/Library/Validators/PeopleValidator.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class PeopleValidator.
+/// </summary>
+public class PeopleValidator
+{
+    /// <summary>
+    /// The _library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// The _logger.
+    /// </summary>
+    private readonly ILogger _logger;
+
+    private readonly IFileSystem _fileSystem;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PeopleValidator" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="fileSystem">The file system.</param>
+    public PeopleValidator(ILibraryManager libraryManager, ILogger logger, IFileSystem fileSystem)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _fileSystem = fileSystem;
+    }
+
+    /// <summary>
+    /// Validates the people.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <param name="progress">The progress.</param>
+    /// <returns>Task.</returns>
+    public async Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
+    {
+        var people = _libraryManager.GetPeopleNames(new InternalPeopleQuery());
+
+        var numComplete = 0;
+
+        var numPeople = people.Count;
+
+        IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 2));
+
+        _logger.LogDebug("Will refresh {Amount} people", numPeople);
+
+        foreach (var person in people)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                var item = _libraryManager.GetPerson(person);
+                if (item is null)
+                {
+                    _logger.LogWarning("Failed to get person: {Name}", person);
+                    continue;
+                }
+
+                var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+                {
+                    ImageRefreshMode = MetadataRefreshMode.ValidationOnly,
+                    MetadataRefreshMode = MetadataRefreshMode.ValidationOnly
+                };
+
+                await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error validating IBN entry {Person}", person);
+            }
+
+            // Update progress
+            numComplete++;
+            double percent = numComplete;
+            percent /= numPeople;
+
+            subProgress.Report(100 * percent);
+        }
+
+        var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Person],
+            IsDeadPerson = true,
+            IsLocked = false
+        });
+
+        subProgress = new Progress<double>((val) => progress.Report((val / 2) + 50));
+
+        var i = 0;
+        foreach (var item in deadEntities.Chunk(500))
+        {
+            _libraryManager.DeleteItemsUnsafeFast(item);
+            subProgress.Report(100f / deadEntities.Count * (i++ * 100));
+        }
+
+        progress.Report(100);
+
+        _logger.LogInformation("People validation complete");
+    }
+}

Emby.Server.Implementations/Library/Validators/StudiosPostScanTask.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class MusicGenresPostScanTask.
+/// </summary>
+public class StudiosPostScanTask : ILibraryPostScanTask
+{
+    /// <summary>
+    /// The _library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+
+    private readonly ILogger<StudiosValidator> _logger;
+    private readonly IItemRepository _itemRepo;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StudiosPostScanTask" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="itemRepo">The item repository.</param>
+    public StudiosPostScanTask(
+        ILibraryManager libraryManager,
+        ILogger<StudiosValidator> logger,
+        IItemRepository itemRepo)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _itemRepo = itemRepo;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        return new StudiosValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+    }
+}

Emby.Server.Implementations/Library/Validators/StudiosValidator.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Class StudiosValidator.
+/// </summary>
+public class StudiosValidator
+{
+    /// <summary>
+    /// The library manager.
+    /// </summary>
+    private readonly ILibraryManager _libraryManager;
+
+    private readonly IItemRepository _itemRepo;
+
+    /// <summary>
+    /// The logger.
+    /// </summary>
+    private readonly ILogger<StudiosValidator> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StudiosValidator" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="itemRepo">The item repository.</param>
+    public StudiosValidator(ILibraryManager libraryManager, ILogger<StudiosValidator> logger, IItemRepository itemRepo)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _itemRepo = itemRepo;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var names = _itemRepo.GetStudioNames();
+
+        var numComplete = 0;
+        var count = names.Count;
+
+        foreach (var name in names)
+        {
+            try
+            {
+                var item = _libraryManager.GetStudio(name);
+
+                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                // Don't clutter the log
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error refreshing {StudioName}", name);
+            }
+
+            numComplete++;
+            double percent = numComplete;
+            percent /= count;
+            percent *= 100;
+
+            progress.Report(percent);
+        }
+
+        var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Studio],
+            IsDeadStudio = true,
+            IsLocked = false
+        });
+
+        foreach (var item in deadEntities)
+        {
+            _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
+
+            _libraryManager.DeleteItem(
+                item,
+                new DeleteOptions
+                {
+                    DeleteFileLocation = false
+                },
+                false);
+        }
+
+        progress.Report(100);
+    }
+}