repo creation with initial code after cloning public repo

Emby.Server.Implementations/AppBase/BaseApplicationPaths.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Jellyfin.Extensions;
+using MediaBrowser.Common.Configuration;
+
+namespace Emby.Server.Implementations.AppBase
+{
+    /// <summary>
+    /// Provides a base class to hold common application paths used by both the UI and Server.
+    /// This can be subclassed to add application-specific paths.
+    /// </summary>
+    public abstract class BaseApplicationPaths : IApplicationPaths
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseApplicationPaths"/> class.
+        /// </summary>
+        /// <param name="programDataPath">The program data path.</param>
+        /// <param name="logDirectoryPath">The log directory path.</param>
+        /// <param name="configurationDirectoryPath">The configuration directory path.</param>
+        /// <param name="cacheDirectoryPath">The cache directory path.</param>
+        /// <param name="webDirectoryPath">The web directory path.</param>
+        protected BaseApplicationPaths(
+            string programDataPath,
+            string logDirectoryPath,
+            string configurationDirectoryPath,
+            string cacheDirectoryPath,
+            string webDirectoryPath)
+        {
+            ProgramDataPath = programDataPath;
+            LogDirectoryPath = logDirectoryPath;
+            ConfigurationDirectoryPath = configurationDirectoryPath;
+            CachePath = cacheDirectoryPath;
+            WebPath = webDirectoryPath;
+            DataPath = Directory.CreateDirectory(Path.Combine(ProgramDataPath, "data")).FullName;
+        }
+
+        /// <inheritdoc/>
+        public string ProgramDataPath { get; }
+
+        /// <inheritdoc/>
+        public string WebPath { get; }
+
+        /// <inheritdoc/>
+        public string ProgramSystemPath { get; } = AppContext.BaseDirectory;
+
+        /// <inheritdoc/>
+        public string DataPath { get; }
+
+        /// <inheritdoc />
+        public string VirtualDataPath => "%AppDataPath%";
+
+        /// <inheritdoc/>
+        public string ImageCachePath => Path.Combine(CachePath, "images");
+
+        /// <inheritdoc/>
+        public string PluginsPath => Path.Combine(ProgramDataPath, "plugins");
+
+        /// <inheritdoc/>
+        public string PluginConfigurationsPath => Path.Combine(PluginsPath, "configurations");
+
+        /// <inheritdoc/>
+        public string LogDirectoryPath { get; }
+
+        /// <inheritdoc/>
+        public string ConfigurationDirectoryPath { get; }
+
+        /// <inheritdoc/>
+        public string SystemConfigurationFilePath => Path.Combine(ConfigurationDirectoryPath, "system.xml");
+
+        /// <inheritdoc/>
+        public string CachePath { get; set; }
+
+        /// <inheritdoc/>
+        public string TempDirectory => Path.Join(Path.GetTempPath(), "jellyfin");
+
+        /// <inheritdoc />
+        public string TrickplayPath => Path.Combine(DataPath, "trickplay");
+
+        /// <inheritdoc />
+        public string BackupPath => Path.Combine(DataPath, "backups");
+
+        /// <inheritdoc />
+        public virtual void MakeSanityCheckOrThrow()
+        {
+            CreateAndCheckMarker(ConfigurationDirectoryPath, "config");
+            CreateAndCheckMarker(LogDirectoryPath, "log");
+            CreateAndCheckMarker(PluginsPath, "plugin");
+            CreateAndCheckMarker(ProgramDataPath, "data");
+            CreateAndCheckMarker(CachePath, "cache");
+            CreateAndCheckMarker(DataPath, "data");
+        }
+
+        /// <inheritdoc />
+        public void CreateAndCheckMarker(string path, string markerName, bool recursive = false)
+        {
+            Directory.CreateDirectory(path);
+
+            CheckOrCreateMarker(path, $".jellyfin-{markerName}", recursive);
+        }
+
+        private IEnumerable<string> GetMarkers(string path, bool recursive = false)
+        {
+            return Directory.EnumerateFiles(path, ".jellyfin-*", recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
+        }
+
+        private void CheckOrCreateMarker(string path, string markerName, bool recursive = false)
+        {
+            string? otherMarkers = null;
+            try
+            {
+                otherMarkers = GetMarkers(path, recursive).FirstOrDefault(e => !Path.GetFileName(e.AsSpan()).Equals(markerName, StringComparison.OrdinalIgnoreCase));
+            }
+            catch
+            {
+                // Error while checking for marker files, assume none exist and keep going
+                // TODO: add some logging
+            }
+
+            if (otherMarkers is not null)
+            {
+                throw new InvalidOperationException($"Expected to find only {markerName} but found marker for {otherMarkers}.");
+            }
+
+            var markerPath = Path.Combine(path, markerName);
+            if (!File.Exists(markerPath))
+            {
+                FileHelper.CreateEmpty(markerPath);
+            }
+        }
+    }
+}

Emby.Server.Implementations/AppBase/BaseConfigurationManager.cs

@@ -0,0 +1,383 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Events;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Serialization;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.AppBase
+{
+    /// <summary>
+    /// Class BaseConfigurationManager.
+    /// </summary>
+    public abstract class BaseConfigurationManager : IConfigurationManager
+    {
+        private readonly ConcurrentDictionary<string, object> _configurations = new();
+        private readonly Lock _configurationSyncLock = new();
+
+        private ConfigurationStore[] _configurationStores = Array.Empty<ConfigurationStore>();
+        private IConfigurationFactory[] _configurationFactories = Array.Empty<IConfigurationFactory>();
+
+        /// <summary>
+        /// The _configuration.
+        /// </summary>
+        private BaseApplicationConfiguration? _configuration;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseConfigurationManager" /> class.
+        /// </summary>
+        /// <param name="applicationPaths">The application paths.</param>
+        /// <param name="loggerFactory">The logger factory.</param>
+        /// <param name="xmlSerializer">The XML serializer.</param>
+        protected BaseConfigurationManager(
+            IApplicationPaths applicationPaths,
+            ILoggerFactory loggerFactory,
+            IXmlSerializer xmlSerializer)
+        {
+            CommonApplicationPaths = applicationPaths;
+            XmlSerializer = xmlSerializer;
+            Logger = loggerFactory.CreateLogger<BaseConfigurationManager>();
+
+            UpdateCachePath();
+        }
+
+        /// <summary>
+        /// Occurs when [configuration updated].
+        /// </summary>
+        public event EventHandler<EventArgs>? ConfigurationUpdated;
+
+        /// <summary>
+        /// Occurs when [configuration updating].
+        /// </summary>
+        public event EventHandler<ConfigurationUpdateEventArgs>? NamedConfigurationUpdating;
+
+        /// <summary>
+        /// Occurs when [named configuration updated].
+        /// </summary>
+        public event EventHandler<ConfigurationUpdateEventArgs>? NamedConfigurationUpdated;
+
+        /// <summary>
+        /// Gets the type of the configuration.
+        /// </summary>
+        /// <value>The type of the configuration.</value>
+        protected abstract Type ConfigurationType { get; }
+
+        /// <summary>
+        /// Gets the logger.
+        /// </summary>
+        /// <value>The logger.</value>
+        protected ILogger<BaseConfigurationManager> Logger { get; private set; }
+
+        /// <summary>
+        /// Gets the XML serializer.
+        /// </summary>
+        /// <value>The XML serializer.</value>
+        protected IXmlSerializer XmlSerializer { get; private set; }
+
+        /// <summary>
+        /// Gets the application paths.
+        /// </summary>
+        /// <value>The application paths.</value>
+        public IApplicationPaths CommonApplicationPaths { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the system configuration.
+        /// </summary>
+        /// <value>The configuration.</value>
+        public BaseApplicationConfiguration CommonConfiguration
+        {
+            get
+            {
+                if (_configuration is not null)
+                {
+                    return _configuration;
+                }
+
+                lock (_configurationSyncLock)
+                {
+                    if (_configuration is not null)
+                    {
+                        return _configuration;
+                    }
+
+                    return _configuration = (BaseApplicationConfiguration)ConfigurationHelper.GetXmlConfiguration(ConfigurationType, CommonApplicationPaths.SystemConfigurationFilePath, XmlSerializer);
+                }
+            }
+
+            protected set
+            {
+                _configuration = value;
+            }
+        }
+
+        /// <summary>
+        /// Manually pre-loads a factory so that it is available pre system initialisation.
+        /// </summary>
+        /// <typeparam name="T">Class to register.</typeparam>
+        public virtual void RegisterConfiguration<T>()
+            where T : IConfigurationFactory
+        {
+            IConfigurationFactory factory = Activator.CreateInstance<T>();
+
+            if (_configurationFactories is null)
+            {
+                _configurationFactories = [factory];
+            }
+            else
+            {
+                _configurationFactories = [.._configurationFactories, factory];
+            }
+
+            _configurationStores = _configurationFactories
+                .SelectMany(i => i.GetConfigurations())
+                .ToArray();
+        }
+
+        /// <summary>
+        /// Adds parts.
+        /// </summary>
+        /// <param name="factories">The configuration factories.</param>
+        public virtual void AddParts(IEnumerable<IConfigurationFactory> factories)
+        {
+            _configurationFactories = factories.ToArray();
+
+            _configurationStores = _configurationFactories
+                .SelectMany(i => i.GetConfigurations())
+                .ToArray();
+        }
+
+        /// <summary>
+        /// Saves the configuration.
+        /// </summary>
+        public void SaveConfiguration()
+        {
+            Logger.LogInformation("Saving system configuration");
+            var path = CommonApplicationPaths.SystemConfigurationFilePath;
+
+            Directory.CreateDirectory(Path.GetDirectoryName(path) ?? throw new InvalidOperationException("Path can't be a root directory."));
+
+            lock (_configurationSyncLock)
+            {
+                XmlSerializer.SerializeToFile(CommonConfiguration, path);
+            }
+
+            OnConfigurationUpdated();
+        }
+
+        /// <summary>
+        /// Called when [configuration updated].
+        /// </summary>
+        protected virtual void OnConfigurationUpdated()
+        {
+            UpdateCachePath();
+
+            EventHelper.QueueEventIfNotNull(ConfigurationUpdated, this, EventArgs.Empty, Logger);
+        }
+
+        /// <summary>
+        /// Replaces the configuration.
+        /// </summary>
+        /// <param name="newConfiguration">The new configuration.</param>
+        /// <exception cref="ArgumentNullException"><c>newConfiguration</c> is <c>null</c>.</exception>
+        public virtual void ReplaceConfiguration(BaseApplicationConfiguration newConfiguration)
+        {
+            ArgumentNullException.ThrowIfNull(newConfiguration);
+
+            ValidateCachePath(newConfiguration);
+
+            CommonConfiguration = newConfiguration;
+            SaveConfiguration();
+        }
+
+        /// <summary>
+        /// Updates the items by name path.
+        /// </summary>
+        private void UpdateCachePath()
+        {
+            string cachePath;
+
+            // If the configuration file has no entry (i.e. not set in UI)
+            if (string.IsNullOrWhiteSpace(CommonConfiguration.CachePath))
+            {
+                // If the current live configuration has no entry (i.e. not set on CLI/envvars, during startup)
+                if (string.IsNullOrWhiteSpace(((BaseApplicationPaths)CommonApplicationPaths).CachePath))
+                {
+                    // Set cachePath to a default value under ProgramDataPath
+                    cachePath = Path.Combine(((BaseApplicationPaths)CommonApplicationPaths).ProgramDataPath, "cache");
+                }
+                else
+                {
+                    // Set cachePath to the existing live value; will require restart if UI value is removed (but not replaced)
+                    // TODO: Figure out how to re-grab this from the CLI/envvars while running
+                    cachePath = ((BaseApplicationPaths)CommonApplicationPaths).CachePath;
+                }
+            }
+            else
+            {
+                // Set cachePath to the new UI-set value
+                cachePath = CommonConfiguration.CachePath;
+            }
+
+            Logger.LogInformation("Setting cache path: {Path}", cachePath);
+            ((BaseApplicationPaths)CommonApplicationPaths).CachePath = cachePath;
+            CommonApplicationPaths.CreateAndCheckMarker(((BaseApplicationPaths)CommonApplicationPaths).CachePath, "cache");
+        }
+
+        /// <summary>
+        /// Replaces the cache path.
+        /// </summary>
+        /// <param name="newConfig">The new configuration.</param>
+        /// <exception cref="DirectoryNotFoundException">The new cache path doesn't exist.</exception>
+        private void ValidateCachePath(BaseApplicationConfiguration newConfig)
+        {
+            var newPath = newConfig.CachePath;
+
+            if (!string.IsNullOrWhiteSpace(newPath)
+                && !string.Equals(CommonConfiguration.CachePath ?? string.Empty, newPath, StringComparison.Ordinal))
+            {
+                // Validate
+                if (!Directory.Exists(newPath))
+                {
+                    throw new DirectoryNotFoundException(
+                        string.Format(
+                            CultureInfo.InvariantCulture,
+                            "{0} does not exist.",
+                            newPath));
+                }
+
+                EnsureWriteAccess(newPath);
+            }
+        }
+
+        /// <summary>
+        /// Ensures that we have write access to the path.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        protected void EnsureWriteAccess(string path)
+        {
+            var file = Path.Combine(path, Guid.NewGuid().ToString());
+            File.WriteAllText(file, string.Empty);
+            File.Delete(file);
+        }
+
+        private string GetConfigurationFile(string key)
+        {
+            return Path.Combine(CommonApplicationPaths.ConfigurationDirectoryPath, key.ToLowerInvariant() + ".xml");
+        }
+
+        /// <inheritdoc />
+        public object GetConfiguration(string key)
+        {
+            return _configurations.GetOrAdd(
+                key,
+                static (k, configurationManager) =>
+                {
+                    var file = configurationManager.GetConfigurationFile(k);
+
+                    var configurationInfo = Array.Find(
+                        configurationManager._configurationStores,
+                        i => string.Equals(i.Key, k, StringComparison.OrdinalIgnoreCase));
+
+                    if (configurationInfo is null)
+                    {
+                        throw new ResourceNotFoundException("Configuration with key " + k + " not found.");
+                    }
+
+                    var configurationType = configurationInfo.ConfigurationType;
+
+                    lock (configurationManager._configurationSyncLock)
+                    {
+                        return configurationManager.LoadConfiguration(file, configurationType);
+                    }
+                },
+                this);
+        }
+
+        private object LoadConfiguration(string path, Type configurationType)
+        {
+            try
+            {
+                if (File.Exists(path))
+                {
+                    return XmlSerializer.DeserializeFromFile(configurationType, path);
+                }
+            }
+            catch (Exception ex) when (ex is not IOException)
+            {
+                Logger.LogError(ex, "Error loading configuration file: {Path}", path);
+            }
+
+            return Activator.CreateInstance(configurationType)
+                ?? throw new InvalidOperationException("Configuration type can't be Nullable<T>.");
+        }
+
+        /// <inheritdoc />
+        public void SaveConfiguration(string key, object configuration)
+        {
+            var configurationStore = GetConfigurationStore(key);
+            var configurationType = configurationStore.ConfigurationType;
+
+            if (configuration.GetType() != configurationType)
+            {
+                throw new ArgumentException("Expected configuration type is " + configurationType.Name);
+            }
+
+            if (configurationStore is IValidatingConfiguration validatingStore)
+            {
+                var currentConfiguration = GetConfiguration(key);
+
+                validatingStore.Validate(currentConfiguration, configuration);
+            }
+
+            NamedConfigurationUpdating?.Invoke(this, new ConfigurationUpdateEventArgs(key, configuration));
+
+            _configurations.AddOrUpdate(key, configuration, (_, _) => configuration);
+
+            var path = GetConfigurationFile(key);
+            Directory.CreateDirectory(Path.GetDirectoryName(path) ?? throw new InvalidOperationException("Path can't be a root directory."));
+
+            lock (_configurationSyncLock)
+            {
+                XmlSerializer.SerializeToFile(configuration, path);
+            }
+
+            OnNamedConfigurationUpdated(key, configuration);
+        }
+
+        /// <summary>
+        /// Event handler for when a named configuration has been updated.
+        /// </summary>
+        /// <param name="key">The key of the configuration.</param>
+        /// <param name="configuration">The old configuration.</param>
+        protected virtual void OnNamedConfigurationUpdated(string key, object configuration)
+        {
+            NamedConfigurationUpdated?.Invoke(this, new ConfigurationUpdateEventArgs(key, configuration));
+        }
+
+        /// <inheritdoc />
+        public ConfigurationStore[] GetConfigurationStores()
+        {
+            return _configurationStores;
+        }
+
+        /// <inheritdoc />
+        public Type GetConfigurationType(string key)
+        {
+            return GetConfigurationStore(key)
+                .ConfigurationType;
+        }
+
+        private ConfigurationStore GetConfigurationStore(string key)
+        {
+            return _configurationStores
+                .First(i => string.Equals(i.Key, key, StringComparison.OrdinalIgnoreCase));
+        }
+    }
+}

Emby.Server.Implementations/AppBase/ConfigurationHelper.cs

@@ -0,0 +1,62 @@
+using System;
+using System.IO;
+using MediaBrowser.Model.Serialization;
+
+namespace Emby.Server.Implementations.AppBase
+{
+    /// <summary>
+    /// Class ConfigurationHelper.
+    /// </summary>
+    public static class ConfigurationHelper
+    {
+        /// <summary>
+        /// Reads an xml configuration file from the file system
+        /// It will immediately re-serialize and save if new serialization data is available due to property changes.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <param name="path">The path.</param>
+        /// <param name="xmlSerializer">The XML serializer.</param>
+        /// <returns>System.Object.</returns>
+        public static object GetXmlConfiguration(Type type, string path, IXmlSerializer xmlSerializer)
+        {
+            object configuration;
+
+            byte[]? buffer = null;
+
+            // Use try/catch to avoid the extra file system lookup using File.Exists
+            try
+            {
+                buffer = File.ReadAllBytes(path);
+
+                configuration = xmlSerializer.DeserializeFromBytes(type, buffer);
+            }
+            catch (Exception)
+            {
+                // Note: CreateInstance returns null for Nullable<T>, e.g. CreateInstance(typeof(int?)) returns null.
+                configuration = Activator.CreateInstance(type)!;
+            }
+
+            using var stream = new MemoryStream(buffer?.Length ?? 0);
+            xmlSerializer.SerializeToStream(configuration, stream);
+
+            // Take the object we just got and serialize it back to bytes
+            Span<byte> newBytes = stream.GetBuffer().AsSpan(0, (int)stream.Length);
+
+            // If the file didn't exist before, or if something has changed, re-save
+            if (buffer is null || !newBytes.SequenceEqual(buffer))
+            {
+                var directory = Path.GetDirectoryName(path) ?? throw new ArgumentException($"Provided path ({path}) is not valid.", nameof(path));
+
+                Directory.CreateDirectory(directory);
+
+                // Save it after load in case we got new items
+                using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None))
+                {
+                    fs.Write(newBytes);
+                }
+            }
+
+            return configuration;
+        }
+    }
+}

Emby.Server.Implementations/Branding/BrandingConfigurationFactory.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Model.Branding;
+
+namespace Emby.Server.Implementations.Branding
+{
+    /// <summary>
+    /// A configuration factory for <see cref="BrandingOptions"/>.
+    /// </summary>
+    public class BrandingConfigurationFactory : IConfigurationFactory
+    {
+        /// <inheritdoc />
+        public IEnumerable<ConfigurationStore> GetConfigurations()
+        {
+            return new[]
+            {
+                new ConfigurationStore
+                {
+                     ConfigurationType = typeof(BrandingOptions),
+                     Key = "branding"
+                }
+            };
+        }
+    }
+}

Emby.Server.Implementations/Chapters/ChapterManager.cs

@@ -0,0 +1,300 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Chapters;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Chapters;
+
+/// <summary>
+/// The chapter manager.
+/// </summary>
+public class ChapterManager : IChapterManager
+{
+    private readonly IFileSystem _fileSystem;
+    private readonly ILogger<ChapterManager> _logger;
+    private readonly IMediaEncoder _encoder;
+    private readonly IChapterRepository _chapterRepository;
+    private readonly ILibraryManager _libraryManager;
+    private readonly IPathManager _pathManager;
+
+    /// <summary>
+    /// The first chapter ticks.
+    /// </summary>
+    private static readonly long _firstChapterTicks = TimeSpan.FromSeconds(15).Ticks;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ChapterManager"/> class.
+    /// </summary>
+    /// <param name="logger">The <see cref="ILogger{ChapterManager}"/>.</param>
+    /// <param name="fileSystem">The <see cref="IFileSystem"/>.</param>
+    /// <param name="encoder">The <see cref="IMediaEncoder"/>.</param>
+    /// <param name="chapterRepository">The <see cref="IChapterRepository"/>.</param>
+    /// <param name="libraryManager">The <see cref="ILibraryManager"/>.</param>
+    /// <param name="pathManager">The <see cref="IPathManager"/>.</param>
+    public ChapterManager(
+        ILogger<ChapterManager> logger,
+        IFileSystem fileSystem,
+        IMediaEncoder encoder,
+        IChapterRepository chapterRepository,
+        ILibraryManager libraryManager,
+        IPathManager pathManager)
+    {
+        _logger = logger;
+        _fileSystem = fileSystem;
+        _encoder = encoder;
+        _chapterRepository = chapterRepository;
+        _libraryManager = libraryManager;
+        _pathManager = pathManager;
+    }
+
+    /// <summary>
+    /// Determines whether [is eligible for chapter image extraction] [the specified video].
+    /// </summary>
+    /// <param name="video">The video.</param>
+    /// <param name="libraryOptions">The library options for the video.</param>
+    /// <returns><c>true</c> if [is eligible for chapter image extraction] [the specified video]; otherwise, <c>false</c>.</returns>
+    private bool IsEligibleForChapterImageExtraction(Video video, LibraryOptions libraryOptions)
+    {
+        if (video.IsPlaceHolder)
+        {
+            return false;
+        }
+
+        if (libraryOptions is null || !libraryOptions.EnableChapterImageExtraction)
+        {
+            return false;
+        }
+
+        if (video.IsShortcut)
+        {
+            return false;
+        }
+
+        if (!video.IsCompleteMedia)
+        {
+            return false;
+        }
+
+        // Can't extract images if there are no video streams
+        return video.DefaultVideoStreamIndex.HasValue;
+    }
+
+    private long GetAverageDurationBetweenChapters(IReadOnlyList<ChapterInfo> chapters)
+    {
+        if (chapters.Count < 2)
+        {
+            return 0;
+        }
+
+        long sum = 0;
+        for (int i = 1; i < chapters.Count; i++)
+        {
+            sum += chapters[i].StartPositionTicks - chapters[i - 1].StartPositionTicks;
+        }
+
+        return sum / chapters.Count;
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> RefreshChapterImages(Video video, IDirectoryService directoryService, IReadOnlyList<ChapterInfo> chapters, bool extractImages, bool saveChapters, CancellationToken cancellationToken)
+    {
+        if (chapters.Count == 0)
+        {
+            return true;
+        }
+
+        var libraryOptions = _libraryManager.GetLibraryOptions(video);
+
+        if (!IsEligibleForChapterImageExtraction(video, libraryOptions))
+        {
+            extractImages = false;
+        }
+
+        var averageChapterDuration = GetAverageDurationBetweenChapters(chapters);
+        var threshold = TimeSpan.FromSeconds(1).Ticks;
+        if (averageChapterDuration < threshold)
+        {
+            _logger.LogInformation("Skipping chapter image extraction for {Video} as the average chapter duration {AverageDuration} was lower than the minimum threshold {Threshold}", video.Name, averageChapterDuration, threshold);
+            extractImages = false;
+        }
+
+        var success = true;
+        var changesMade = false;
+
+        var runtimeTicks = video.RunTimeTicks ?? 0;
+
+        var currentImages = GetSavedChapterImages(video, directoryService);
+
+        foreach (var chapter in chapters)
+        {
+            if (chapter.StartPositionTicks >= runtimeTicks)
+            {
+                _logger.LogInformation("Stopping chapter extraction for {0} because a chapter was found with a position greater than the runtime.", video.Name);
+                break;
+            }
+
+            var path = _pathManager.GetChapterImagePath(video, chapter.StartPositionTicks);
+
+            if (!currentImages.Contains(path, StringComparison.OrdinalIgnoreCase))
+            {
+                if (extractImages)
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    try
+                    {
+                        // Add some time for the first chapter to make sure we don't end up with a black image
+                        var time = chapter.StartPositionTicks == 0 ? TimeSpan.FromTicks(Math.Min(_firstChapterTicks, video.RunTimeTicks ?? 0)) : TimeSpan.FromTicks(chapter.StartPositionTicks);
+
+                        var inputPath = video.Path;
+                        var directoryPath = Path.GetDirectoryName(path);
+                        if (!string.IsNullOrEmpty(directoryPath))
+                        {
+                            Directory.CreateDirectory(directoryPath);
+                        }
+
+                        var container = video.Container;
+                        var mediaSource = new MediaSourceInfo
+                        {
+                            VideoType = video.VideoType,
+                            IsoType = video.IsoType,
+                            Protocol = video.PathProtocol ?? MediaProtocol.File,
+                        };
+
+                        _logger.LogInformation("Extracting chapter image for {Name} at {Path}", video.Name, inputPath);
+                        var tempFile = await _encoder.ExtractVideoImage(inputPath, container, mediaSource, video.GetDefaultVideoStream(), video.Video3DFormat, time, cancellationToken).ConfigureAwait(false);
+                        File.Copy(tempFile, path, true);
+
+                        try
+                        {
+                            _fileSystem.DeleteFile(tempFile);
+                        }
+                        catch (IOException ex)
+                        {
+                            _logger.LogError(ex, "Error deleting temporary chapter image encoding file {Path}", tempFile);
+                        }
+
+                        chapter.ImagePath = path;
+                        chapter.ImageDateModified = _fileSystem.GetLastWriteTimeUtc(path);
+                        changesMade = true;
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Error extracting chapter images for {0}", string.Join(',', video.Path));
+                        success = false;
+                        break;
+                    }
+                }
+                else if (!string.IsNullOrEmpty(chapter.ImagePath))
+                {
+                    chapter.ImagePath = null;
+                    changesMade = true;
+                }
+            }
+            else if (!string.Equals(path, chapter.ImagePath, StringComparison.OrdinalIgnoreCase))
+            {
+                chapter.ImagePath = path;
+                chapter.ImageDateModified = _fileSystem.GetLastWriteTimeUtc(path);
+                changesMade = true;
+            }
+            else if (libraryOptions?.EnableChapterImageExtraction != true)
+            {
+                // We have an image for the current chapter but the user has disabled chapter image extraction -> delete this chapter's image
+                chapter.ImagePath = null;
+                changesMade = true;
+            }
+        }
+
+        if (saveChapters && changesMade)
+        {
+            SaveChapters(video, chapters);
+        }
+
+        DeleteDeadImages(currentImages, chapters);
+
+        return success;
+    }
+
+    /// <inheritdoc />
+    public void SaveChapters(Video video, IReadOnlyList<ChapterInfo> chapters)
+    {
+        // Remove any chapters that are outside of the runtime of the video
+        var validChapters = chapters.Where(c => c.StartPositionTicks < video.RunTimeTicks).ToList();
+        _chapterRepository.SaveChapters(video.Id, validChapters);
+    }
+
+    /// <inheritdoc />
+    public ChapterInfo? GetChapter(Guid baseItemId, int index)
+    {
+        return _chapterRepository.GetChapter(baseItemId, index);
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<ChapterInfo> GetChapters(Guid baseItemId)
+    {
+        return _chapterRepository.GetChapters(baseItemId);
+    }
+
+    /// <inheritdoc />
+    public async Task DeleteChapterDataAsync(Guid itemId, CancellationToken cancellationToken)
+    {
+        await _chapterRepository.DeleteChaptersAsync(itemId, cancellationToken).ConfigureAwait(false);
+    }
+
+    private IReadOnlyList<string> GetSavedChapterImages(Video video, IDirectoryService directoryService)
+    {
+        var path = _pathManager.GetChapterImageFolderPath(video);
+        if (!Directory.Exists(path))
+        {
+            return [];
+        }
+
+        try
+        {
+            return directoryService.GetFilePaths(path);
+        }
+        catch (IOException)
+        {
+            return [];
+        }
+    }
+
+    private void DeleteDeadImages(IEnumerable<string> images, IEnumerable<ChapterInfo> chapters)
+    {
+        var existingImages = chapters.Select(i => i.ImagePath).Where(i => !string.IsNullOrEmpty(i));
+        var deadImages = images
+            .Except(existingImages, StringComparer.OrdinalIgnoreCase)
+            .Where(i => BaseItem.SupportedImageExtensions.Contains(Path.GetExtension(i.AsSpan()), StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        foreach (var image in deadImages)
+        {
+            _logger.LogDebug("Deleting dead chapter image {Path}", image);
+
+            try
+            {
+                _fileSystem.DeleteFile(image!);
+            }
+            catch (IOException ex)
+            {
+                _logger.LogError(ex, "Error deleting {Path}.", image);
+            }
+        }
+    }
+}

Emby.Server.Implementations/Collections/CollectionImageProvider.cs

@@ -0,0 +1,96 @@
+using System.Collections.Generic;
+using System.Linq;
+using Emby.Server.Implementations.Images;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Collections
+{
+    /// <summary>
+    /// A collection image provider.
+    /// </summary>
+    public class CollectionImageProvider : BaseDynamicImageProvider<BoxSet>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CollectionImageProvider"/> class.
+        /// </summary>
+        /// <param name="fileSystem">The filesystem.</param>
+        /// <param name="providerManager">The provider manager.</param>
+        /// <param name="applicationPaths">The application paths.</param>
+        /// <param name="imageProcessor">The image processor.</param>
+        public CollectionImageProvider(
+            IFileSystem fileSystem,
+            IProviderManager providerManager,
+            IApplicationPaths applicationPaths,
+            IImageProcessor imageProcessor)
+            : base(fileSystem, providerManager, applicationPaths, imageProcessor)
+        {
+        }
+
+        /// <inheritdoc />
+        protected override bool Supports(BaseItem item)
+        {
+            // Right now this is the only way to prevent this image from getting created ahead of internet image providers
+            if (!item.IsLocked)
+            {
+                return false;
+            }
+
+            return base.Supports(item);
+        }
+
+        /// <inheritdoc />
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            var playlist = (BoxSet)item;
+
+            return playlist.Children.Concat(playlist.GetLinkedChildren())
+                .Select(i =>
+                {
+                    var subItem = i;
+
+                    var episode = subItem as Episode;
+
+                    var series = episode?.Series;
+                    if (series is not null && series.HasImage(ImageType.Primary))
+                    {
+                        return series;
+                    }
+
+                    if (subItem.HasImage(ImageType.Primary))
+                    {
+                        return subItem;
+                    }
+
+                    var parent = subItem.GetOwner() ?? subItem.GetParent();
+
+                    if (parent is not null && parent.HasImage(ImageType.Primary))
+                    {
+                        if (parent is MusicAlbum)
+                        {
+                            return parent;
+                        }
+                    }
+
+                    return null;
+                })
+                .Where(i => i is not null)
+                .GroupBy(x => x!.Id) // We removed the null values
+                .Select(x => x.First())
+                .ToList()!; // Again... the list doesn't contain any null values
+        }
+
+        /// <inheritdoc />
+        protected override string CreateImage(BaseItem item, IReadOnlyCollection<BaseItem> itemsWithImages, string outputPathWithoutExtension, ImageType imageType, int imageIndex)
+        {
+            return CreateSingleImage(itemsWithImages, outputPathWithoutExtension, ImageType.Primary);
+        }
+    }
+}

Emby.Server.Implementations/Collections/CollectionManager.cs

@@ -0,0 +1,369 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Database.Implementations.Entities;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Collections;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Collections
+{
+    /// <summary>
+    /// The collection manager.
+    /// </summary>
+    public class CollectionManager : ICollectionManager
+    {
+        private readonly ILibraryManager _libraryManager;
+        private readonly IFileSystem _fileSystem;
+        private readonly ILibraryMonitor _iLibraryMonitor;
+        private readonly ILogger<CollectionManager> _logger;
+        private readonly IProviderManager _providerManager;
+        private readonly ILocalizationManager _localizationManager;
+        private readonly IApplicationPaths _appPaths;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CollectionManager"/> class.
+        /// </summary>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="appPaths">The application paths.</param>
+        /// <param name="localizationManager">The localization manager.</param>
+        /// <param name="fileSystem">The filesystem.</param>
+        /// <param name="iLibraryMonitor">The library monitor.</param>
+        /// <param name="loggerFactory">The logger factory.</param>
+        /// <param name="providerManager">The provider manager.</param>
+        public CollectionManager(
+            ILibraryManager libraryManager,
+            IApplicationPaths appPaths,
+            ILocalizationManager localizationManager,
+            IFileSystem fileSystem,
+            ILibraryMonitor iLibraryMonitor,
+            ILoggerFactory loggerFactory,
+            IProviderManager providerManager)
+        {
+            _libraryManager = libraryManager;
+            _fileSystem = fileSystem;
+            _iLibraryMonitor = iLibraryMonitor;
+            _logger = loggerFactory.CreateLogger<CollectionManager>();
+            _providerManager = providerManager;
+            _localizationManager = localizationManager;
+            _appPaths = appPaths;
+        }
+
+        /// <inheritdoc />
+        public event EventHandler<CollectionCreatedEventArgs>? CollectionCreated;
+
+        /// <inheritdoc />
+        public event EventHandler<CollectionModifiedEventArgs>? ItemsAddedToCollection;
+
+        /// <inheritdoc />
+        public event EventHandler<CollectionModifiedEventArgs>? ItemsRemovedFromCollection;
+
+        private IEnumerable<Folder> FindFolders(string path)
+        {
+            return _libraryManager
+                .RootFolder
+                .Children
+                .OfType<Folder>()
+                .Where(i => _fileSystem.AreEqual(path, i.Path) || _fileSystem.ContainsSubPath(i.Path, path));
+        }
+
+        internal async Task<Folder?> EnsureLibraryFolder(string path, bool createIfNeeded)
+        {
+            var existingFolder = FindFolders(path).FirstOrDefault();
+            if (existingFolder is not null)
+            {
+                return existingFolder;
+            }
+
+            if (!createIfNeeded)
+            {
+                return null;
+            }
+
+            Directory.CreateDirectory(path);
+
+            var libraryOptions = new LibraryOptions
+            {
+                PathInfos = [new MediaPathInfo(path)],
+                EnableRealtimeMonitor = false,
+                SaveLocalMetadata = true
+            };
+
+            var name = _localizationManager.GetLocalizedString("Collections");
+
+            await _libraryManager.AddVirtualFolder(name, CollectionTypeOptions.boxsets, libraryOptions, true).ConfigureAwait(false);
+
+            _libraryManager.RootFolder.Children = null;
+
+            return FindFolders(path).First();
+        }
+
+        internal string GetCollectionsFolderPath()
+        {
+            return Path.Combine(_appPaths.DataPath, "collections");
+        }
+
+        /// <inheritdoc />
+        public Task<Folder?> GetCollectionsFolder(bool createIfNeeded)
+        {
+            return EnsureLibraryFolder(GetCollectionsFolderPath(), createIfNeeded);
+        }
+
+        private IEnumerable<BoxSet> GetCollections(User user)
+        {
+            var folder = GetCollectionsFolder(false).GetAwaiter().GetResult();
+
+            return folder is null
+                ? Enumerable.Empty<BoxSet>()
+                : folder.GetChildren(user, true).OfType<BoxSet>();
+        }
+
+        /// <inheritdoc />
+        public async Task<BoxSet> CreateCollectionAsync(CollectionCreationOptions options)
+        {
+            var name = options.Name;
+
+            // Need to use the [boxset] suffix
+            // If internet metadata is not found, or if xml saving is off there will be no collection.xml
+            // This could cause it to get re-resolved as a plain folder
+            var folderName = _fileSystem.GetValidFilename(name) + " [boxset]";
+
+            var parentFolder = await GetCollectionsFolder(true).ConfigureAwait(false);
+
+            if (parentFolder is null)
+            {
+                throw new ArgumentException(nameof(parentFolder));
+            }
+
+            var path = Path.Combine(parentFolder.Path, folderName);
+
+            _iLibraryMonitor.ReportFileSystemChangeBeginning(path);
+
+            try
+            {
+                var info = Directory.CreateDirectory(path);
+                var collection = new BoxSet
+                {
+                    Name = name,
+                    Path = path,
+                    IsLocked = options.IsLocked,
+                    ProviderIds = options.ProviderIds,
+                    DateCreated = info.CreationTimeUtc,
+                    DateModified = info.LastWriteTimeUtc
+                };
+
+                parentFolder.AddChild(collection);
+
+                if (options.ItemIdList.Count > 0)
+                {
+                    await AddToCollectionAsync(
+                        collection.Id,
+                        options.ItemIdList.Select(x => new Guid(x)),
+                        false,
+                        new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+                        {
+                            // The initial adding of items is going to create a local metadata file
+                            // This will cause internet metadata to be skipped as a result
+                            MetadataRefreshMode = MetadataRefreshMode.FullRefresh
+                        }).ConfigureAwait(false);
+                }
+                else
+                {
+                    _providerManager.QueueRefresh(collection.Id, new MetadataRefreshOptions(new DirectoryService(_fileSystem)), RefreshPriority.High);
+                }
+
+                CollectionCreated?.Invoke(this, new CollectionCreatedEventArgs
+                {
+                    Collection = collection,
+                    Options = options
+                });
+
+                return collection;
+            }
+            finally
+            {
+                // Refresh handled internally
+                _iLibraryMonitor.ReportFileSystemChangeComplete(path, false);
+            }
+        }
+
+        /// <inheritdoc />
+        public Task AddToCollectionAsync(Guid collectionId, IEnumerable<Guid> itemIds)
+            => AddToCollectionAsync(collectionId, itemIds, true, new MetadataRefreshOptions(new DirectoryService(_fileSystem)));
+
+        private async Task AddToCollectionAsync(Guid collectionId, IEnumerable<Guid> ids, bool fireEvent, MetadataRefreshOptions refreshOptions)
+        {
+            if (_libraryManager.GetItemById(collectionId) is not BoxSet collection)
+            {
+                throw new ArgumentException("No collection exists with the supplied collectionId " + collectionId);
+            }
+
+            List<BaseItem>? itemList = null;
+
+            var linkedChildrenList = collection.GetLinkedChildren();
+            var currentLinkedChildrenIds = linkedChildrenList.Select(i => i.Id).ToList();
+
+            foreach (var id in ids)
+            {
+                var item = _libraryManager.GetItemById(id);
+
+                if (item is null)
+                {
+                    throw new ArgumentException("No item exists with the supplied Id " + id);
+                }
+
+                if (!currentLinkedChildrenIds.Contains(id))
+                {
+                    (itemList ??= new()).Add(item);
+
+                    linkedChildrenList.Add(item);
+                }
+            }
+
+            if (itemList is not null)
+            {
+                var originalLen = collection.LinkedChildren.Length;
+                var newItemCount = itemList.Count;
+                LinkedChild[] newChildren = new LinkedChild[originalLen + newItemCount];
+                collection.LinkedChildren.CopyTo(newChildren, 0);
+                for (int i = 0; i < newItemCount; i++)
+                {
+                    newChildren[originalLen + i] = LinkedChild.Create(itemList[i]);
+                }
+
+                collection.LinkedChildren = newChildren;
+                collection.UpdateRatingToItems(linkedChildrenList);
+
+                await collection.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
+
+                refreshOptions.ForceSave = true;
+                _providerManager.QueueRefresh(collection.Id, refreshOptions, RefreshPriority.High);
+
+                if (fireEvent)
+                {
+                    ItemsAddedToCollection?.Invoke(this, new CollectionModifiedEventArgs(collection, itemList));
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public async Task RemoveFromCollectionAsync(Guid collectionId, IEnumerable<Guid> itemIds)
+        {
+            if (_libraryManager.GetItemById(collectionId) is not BoxSet collection)
+            {
+                throw new ArgumentException("No collection exists with the supplied Id");
+            }
+
+            var list = new List<LinkedChild>();
+            var itemList = new List<BaseItem>();
+
+            foreach (var guidId in itemIds)
+            {
+                var childItem = _libraryManager.GetItemById(guidId);
+
+                var child = collection.LinkedChildren.FirstOrDefault(i => (i.ItemId.HasValue && i.ItemId.Value.Equals(guidId)) || (childItem is not null && string.Equals(childItem.Path, i.Path, StringComparison.OrdinalIgnoreCase)));
+
+                if (child is null)
+                {
+                    _logger.LogWarning("No collection title exists with the supplied Id");
+                    continue;
+                }
+
+                list.Add(child);
+
+                if (childItem is not null)
+                {
+                    itemList.Add(childItem);
+                }
+            }
+
+            if (list.Count > 0)
+            {
+                collection.LinkedChildren = collection.LinkedChildren.Except(list).ToArray();
+            }
+
+            await collection.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
+            _providerManager.QueueRefresh(
+                collection.Id,
+                new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+                {
+                    ForceSave = true
+                },
+                RefreshPriority.High);
+
+            ItemsRemovedFromCollection?.Invoke(this, new CollectionModifiedEventArgs(collection, itemList));
+        }
+
+        /// <inheritdoc />
+        public IEnumerable<BaseItem> CollapseItemsWithinBoxSets(IEnumerable<BaseItem> items, User user)
+        {
+            var results = new Dictionary<Guid, BaseItem>();
+
+            var allBoxSets = GetCollections(user).ToList();
+
+            foreach (var item in items)
+            {
+                if (item is ISupportsBoxSetGrouping)
+                {
+                    var itemId = item.Id;
+
+                    var itemIsInBoxSet = false;
+                    foreach (var boxSet in allBoxSets)
+                    {
+                        if (!boxSet.ContainsLinkedChildByItemId(itemId))
+                        {
+                            continue;
+                        }
+
+                        itemIsInBoxSet = true;
+
+                        results.TryAdd(boxSet.Id, boxSet);
+                    }
+
+                    // skip any item that is in a box set
+                    if (itemIsInBoxSet)
+                    {
+                        continue;
+                    }
+
+                    var alreadyInResults = false;
+
+                    // this is kind of a performance hack because only Video has alternate versions that should be in a box set?
+                    if (item is Video video)
+                    {
+                        foreach (var childId in video.GetLocalAlternateVersionIds())
+                        {
+                            if (!results.ContainsKey(childId))
+                            {
+                                continue;
+                            }
+
+                            alreadyInResults = true;
+                            break;
+                        }
+                    }
+
+                    if (alreadyInResults)
+                    {
+                        continue;
+                    }
+                }
+
+                results[item.Id] = item;
+            }
+
+            return results.Values;
+        }
+    }
+}

Emby.Server.Implementations/Configuration/ServerConfigurationManager.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Globalization;
+using System.IO;
+using Emby.Server.Implementations.AppBase;
+using Jellyfin.Data.Events;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Serialization;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Configuration
+{
+    /// <summary>
+    /// Class ServerConfigurationManager.
+    /// </summary>
+    public class ServerConfigurationManager : BaseConfigurationManager, IServerConfigurationManager
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ServerConfigurationManager" /> class.
+        /// </summary>
+        /// <param name="applicationPaths">The application paths.</param>
+        /// <param name="loggerFactory">The logger factory.</param>
+        /// <param name="xmlSerializer">The XML serializer.</param>
+        public ServerConfigurationManager(
+            IApplicationPaths applicationPaths,
+            ILoggerFactory loggerFactory,
+            IXmlSerializer xmlSerializer)
+            : base(applicationPaths, loggerFactory, xmlSerializer)
+        {
+            UpdateMetadataPath();
+        }
+
+        /// <summary>
+        /// Configuration updating event.
+        /// </summary>
+        public event EventHandler<GenericEventArgs<ServerConfiguration>>? ConfigurationUpdating;
+
+        /// <summary>
+        /// Gets the type of the configuration.
+        /// </summary>
+        /// <value>The type of the configuration.</value>
+        protected override Type ConfigurationType => typeof(ServerConfiguration);
+
+        /// <summary>
+        /// Gets the application paths.
+        /// </summary>
+        /// <value>The application paths.</value>
+        public IServerApplicationPaths ApplicationPaths => (IServerApplicationPaths)CommonApplicationPaths;
+
+        /// <summary>
+        /// Gets the configuration.
+        /// </summary>
+        /// <value>The configuration.</value>
+        public ServerConfiguration Configuration => (ServerConfiguration)CommonConfiguration;
+
+        /// <summary>
+        /// Called when [configuration updated].
+        /// </summary>
+        protected override void OnConfigurationUpdated()
+        {
+            UpdateMetadataPath();
+
+            base.OnConfigurationUpdated();
+        }
+
+        /// <summary>
+        /// Updates the metadata path.
+        /// </summary>
+        /// <exception cref="UnauthorizedAccessException">If the directory does not exist, and the caller does not have the required permission to create it.</exception>
+        /// <exception cref="NotSupportedException">If there is a custom path transcoding path specified, but it is invalid.</exception>
+        /// <exception cref="IOException">If the directory does not exist, and it also could not be created.</exception>
+        private void UpdateMetadataPath()
+        {
+            ((ServerApplicationPaths)ApplicationPaths).InternalMetadataPath = string.IsNullOrWhiteSpace(Configuration.MetadataPath)
+                ? ApplicationPaths.DefaultInternalMetadataPath
+                : Configuration.MetadataPath;
+            Directory.CreateDirectory(ApplicationPaths.InternalMetadataPath);
+        }
+
+        /// <summary>
+        /// Replaces the configuration.
+        /// </summary>
+        /// <param name="newConfiguration">The new configuration.</param>
+        /// <exception cref="DirectoryNotFoundException">If the configuration path doesn't exist.</exception>
+        public override void ReplaceConfiguration(BaseApplicationConfiguration newConfiguration)
+        {
+            var newConfig = (ServerConfiguration)newConfiguration;
+
+            ValidateMetadataPath(newConfig);
+
+            ConfigurationUpdating?.Invoke(this, new GenericEventArgs<ServerConfiguration>(newConfig));
+
+            base.ReplaceConfiguration(newConfiguration);
+        }
+
+        /// <summary>
+        /// Validates the metadata path.
+        /// </summary>
+        /// <param name="newConfig">The new configuration.</param>
+        /// <exception cref="DirectoryNotFoundException">The new config path doesn't exist.</exception>
+        private void ValidateMetadataPath(ServerConfiguration newConfig)
+        {
+            var newPath = newConfig.MetadataPath;
+
+            if (!string.IsNullOrWhiteSpace(newPath)
+                && !string.Equals(Configuration.MetadataPath, newPath, StringComparison.Ordinal))
+            {
+                if (!Directory.Exists(newPath))
+                {
+                    throw new DirectoryNotFoundException(
+                        string.Format(
+                            CultureInfo.InvariantCulture,
+                            "{0} does not exist.",
+                            newPath));
+                }
+
+                EnsureWriteAccess(newPath);
+            }
+        }
+    }
+}

Emby.Server.Implementations/ConfigurationOptions.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using static MediaBrowser.Controller.Extensions.ConfigurationExtensions;
+
+namespace Emby.Server.Implementations
+{
+    /// <summary>
+    /// Static class containing the default configuration options for the web server.
+    /// </summary>
+    public static class ConfigurationOptions
+    {
+        /// <summary>
+        /// Gets a new copy of the default configuration options.
+        /// </summary>
+        public static Dictionary<string, string?> DefaultConfiguration => new()
+        {
+            { HostWebClientKey, bool.TrueString },
+            { DefaultRedirectKey, "web/" },
+            { FfmpegProbeSizeKey, "1G" },
+            { FfmpegAnalyzeDurationKey, "200M" },
+            { BindToUnixSocketKey, bool.FalseString },
+            { SqliteCacheSizeKey, "20000" },
+            { FfmpegSkipValidationKey, bool.FalseString },
+            { FfmpegImgExtractPerfTradeoffKey, bool.FalseString },
+            { DetectNetworkChangeKey, bool.TrueString }
+        };
+    }
+}

Emby.Server.Implementations/Cryptography/CryptographyProvider.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Security.Cryptography;
+using MediaBrowser.Model.Cryptography;
+using static MediaBrowser.Model.Cryptography.Constants;
+
+namespace Emby.Server.Implementations.Cryptography
+{
+    /// <summary>
+    /// Class providing abstractions over cryptographic functions.
+    /// </summary>
+    public class CryptographyProvider : ICryptoProvider
+    {
+        /// <inheritdoc />
+        public string DefaultHashMethod => "PBKDF2-SHA512";
+
+        /// <inheritdoc />
+        public PasswordHash CreatePasswordHash(ReadOnlySpan<char> password)
+        {
+            byte[] salt = GenerateSalt();
+            return new PasswordHash(
+                DefaultHashMethod,
+                Rfc2898DeriveBytes.Pbkdf2(
+                    password,
+                    salt,
+                    DefaultIterations,
+                    HashAlgorithmName.SHA512,
+                    DefaultOutputLength),
+                salt,
+                new Dictionary<string, string>
+                {
+                    { "iterations", DefaultIterations.ToString(CultureInfo.InvariantCulture) }
+                });
+        }
+
+        /// <inheritdoc />
+        public bool Verify(PasswordHash hash, ReadOnlySpan<char> password)
+        {
+            if (string.Equals(hash.Id, "PBKDF2", StringComparison.Ordinal))
+            {
+                var iterations = GetIterationsParameter(hash);
+                return hash.Hash.SequenceEqual(
+                    Rfc2898DeriveBytes.Pbkdf2(
+                        password,
+                        hash.Salt,
+                        iterations,
+                        HashAlgorithmName.SHA1,
+                        32));
+            }
+
+            if (string.Equals(hash.Id, "PBKDF2-SHA512", StringComparison.Ordinal))
+            {
+                var iterations = GetIterationsParameter(hash);
+                return hash.Hash.SequenceEqual(
+                    Rfc2898DeriveBytes.Pbkdf2(
+                        password,
+                        hash.Salt,
+                        iterations,
+                        HashAlgorithmName.SHA512,
+                        DefaultOutputLength));
+            }
+
+            throw new NotSupportedException($"Can't verify hash with id: {hash.Id}");
+        }
+
+        /// <summary>
+        /// Extracts and validates the iterations parameter from a password hash.
+        /// </summary>
+        /// <param name="hash">The password hash containing parameters.</param>
+        /// <returns>The number of iterations.</returns>
+        /// <exception cref="FormatException">Thrown when iterations parameter is missing or invalid.</exception>
+        private static int GetIterationsParameter(PasswordHash hash)
+        {
+            if (!hash.Parameters.TryGetValue("iterations", out var iterationsStr))
+            {
+                throw new FormatException($"Password hash with id '{hash.Id}' is missing required 'iterations' parameter.");
+            }
+
+            if (!int.TryParse(iterationsStr, CultureInfo.InvariantCulture, out var iterations))
+            {
+                throw new FormatException($"Password hash with id '{hash.Id}' has invalid 'iterations' parameter: '{iterationsStr}'.");
+            }
+
+            return iterations;
+        }
+
+        /// <inheritdoc />
+        public byte[] GenerateSalt()
+            => GenerateSalt(DefaultSaltLength);
+
+        /// <inheritdoc />
+        public byte[] GenerateSalt(int length)
+        {
+            var salt = new byte[length];
+            using var rng = RandomNumberGenerator.Create();
+            rng.GetNonZeroBytes(salt);
+            return salt;
+        }
+    }
+}

Emby.Server.Implementations/Data/CleanDatabaseScheduledTask.cs

@@ -0,0 +1,119 @@
+#pragma warning disable CS1591
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Database.Implementations;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.Library;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Data;
+
+public class CleanDatabaseScheduledTask : ILibraryPostScanTask
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly ILogger<CleanDatabaseScheduledTask> _logger;
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IPathManager _pathManager;
+
+    public CleanDatabaseScheduledTask(
+        ILibraryManager libraryManager,
+        ILogger<CleanDatabaseScheduledTask> logger,
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IPathManager pathManager)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+        _dbProvider = dbProvider;
+        _pathManager = pathManager;
+    }
+
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        await CleanDeadItems(cancellationToken, progress).ConfigureAwait(false);
+    }
+
+    private async Task CleanDeadItems(CancellationToken cancellationToken, IProgress<double> progress)
+    {
+        var itemIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            HasDeadParentId = true
+        });
+
+        var numComplete = 0;
+        var numItems = itemIds.Count + 1;
+
+        _logger.LogDebug("Cleaning {Number} items with dead parents", numItems);
+
+        IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 2));
+
+        foreach (var itemId in itemIds)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var item = _libraryManager.GetItemById(itemId);
+            if (item is not null)
+            {
+                _logger.LogInformation("Cleaning item {Item} type: {Type} path: {Path}", item.Name, item.GetType().Name, item.Path ?? string.Empty);
+
+                foreach (var mediaSource in item.GetMediaSources(false))
+                {
+                    // Delete extracted data
+                    var mediaSourceItem = _libraryManager.GetItemById(mediaSource.Id);
+                    if (mediaSourceItem is null)
+                    {
+                        continue;
+                    }
+
+                    var extractedDataFolders = _pathManager.GetExtractedDataPaths(mediaSourceItem);
+                    foreach (var folder in extractedDataFolders)
+                    {
+                        if (Directory.Exists(folder))
+                        {
+                            try
+                            {
+                                Directory.Delete(folder, true);
+                            }
+                            catch (Exception e)
+                            {
+                                _logger.LogWarning("Failed to remove {Folder}: {Exception}", folder, e.Message);
+                            }
+                        }
+                    }
+                }
+
+                // Delete item
+                _libraryManager.DeleteItem(item, new DeleteOptions
+                {
+                    DeleteFileLocation = false
+                });
+            }
+
+            numComplete++;
+            double percent = numComplete;
+            percent /= numItems;
+            subProgress.Report(percent * 100);
+        }
+
+        subProgress = new Progress<double>((val) => progress.Report((val / 2) + 50));
+        var context = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        await using (context.ConfigureAwait(false))
+        {
+            var transaction = await context.Database.BeginTransactionAsync(cancellationToken).ConfigureAwait(false);
+            await using (transaction.ConfigureAwait(false))
+            {
+                await context.ItemValues.Where(e => e.BaseItemsMap!.Count == 0).ExecuteDeleteAsync(cancellationToken).ConfigureAwait(false);
+                subProgress.Report(50);
+                await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
+                subProgress.Report(100);
+            }
+        }
+
+        progress.Report(100);
+    }
+}

Emby.Server.Implementations/Data/ItemTypeLookup.cs

@@ -0,0 +1,64 @@
+using System.Collections.Frozen;
+using System.Collections.Generic;
+using System.Threading.Channels;
+using Emby.Server.Implementations.Playlists;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Controller.Playlists;
+
+namespace Emby.Server.Implementations.Data;
+
+/// <inheritdoc />
+public class ItemTypeLookup : IItemTypeLookup
+{
+    /// <inheritdoc />
+    public IReadOnlyList<string> MusicGenreTypes { get; } = [
+         typeof(Audio).FullName!,
+         typeof(MusicVideo).FullName!,
+         typeof(MusicAlbum).FullName!,
+         typeof(MusicArtist).FullName!,
+    ];
+
+    /// <inheritdoc />
+    public IReadOnlyDictionary<BaseItemKind, string> BaseItemKindNames { get; } = new Dictionary<BaseItemKind, string>()
+    {
+        { BaseItemKind.AggregateFolder, typeof(AggregateFolder).FullName! },
+        { BaseItemKind.Audio, typeof(Audio).FullName! },
+        { BaseItemKind.AudioBook, typeof(AudioBook).FullName! },
+        { BaseItemKind.BasePluginFolder, typeof(BasePluginFolder).FullName! },
+        { BaseItemKind.Book, typeof(Book).FullName! },
+        { BaseItemKind.BoxSet, typeof(BoxSet).FullName! },
+        { BaseItemKind.Channel, typeof(Channel).FullName! },
+        { BaseItemKind.CollectionFolder, typeof(CollectionFolder).FullName! },
+        { BaseItemKind.Episode, typeof(Episode).FullName! },
+        { BaseItemKind.Folder, typeof(Folder).FullName! },
+        { BaseItemKind.Genre, typeof(Genre).FullName! },
+        { BaseItemKind.Movie, typeof(Movie).FullName! },
+        { BaseItemKind.LiveTvChannel, typeof(LiveTvChannel).FullName! },
+        { BaseItemKind.LiveTvProgram, typeof(LiveTvProgram).FullName! },
+        { BaseItemKind.MusicAlbum, typeof(MusicAlbum).FullName! },
+        { BaseItemKind.MusicArtist, typeof(MusicArtist).FullName! },
+        { BaseItemKind.MusicGenre, typeof(MusicGenre).FullName! },
+        { BaseItemKind.MusicVideo, typeof(MusicVideo).FullName! },
+        { BaseItemKind.Person, typeof(Person).FullName! },
+        { BaseItemKind.Photo, typeof(Photo).FullName! },
+        { BaseItemKind.PhotoAlbum, typeof(PhotoAlbum).FullName! },
+        { BaseItemKind.Playlist, typeof(Playlist).FullName! },
+        { BaseItemKind.PlaylistsFolder, typeof(PlaylistsFolder).FullName! },
+        { BaseItemKind.Season, typeof(Season).FullName! },
+        { BaseItemKind.Series, typeof(Series).FullName! },
+        { BaseItemKind.Studio, typeof(Studio).FullName! },
+        { BaseItemKind.Trailer, typeof(Trailer).FullName! },
+        { BaseItemKind.TvChannel, typeof(LiveTvChannel).FullName! },
+        { BaseItemKind.TvProgram, typeof(LiveTvProgram).FullName! },
+        { BaseItemKind.UserRootFolder, typeof(UserRootFolder).FullName! },
+        { BaseItemKind.UserView, typeof(UserView).FullName! },
+        { BaseItemKind.Video, typeof(Video).FullName! },
+        { BaseItemKind.Year, typeof(Year).FullName! }
+    }.ToFrozenDictionary();
+}

Emby.Server.Implementations/Data/SqliteExtensions.cs

@@ -0,0 +1,271 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Globalization;
+using Microsoft.Data.Sqlite;
+
+namespace Emby.Server.Implementations.Data
+{
+    public static class SqliteExtensions
+    {
+        private const string DatetimeFormatUtc = "yyyy-MM-dd HH:mm:ss.FFFFFFFK";
+        private const string DatetimeFormatLocal = "yyyy-MM-dd HH:mm:ss.FFFFFFF";
+
+        /// <summary>
+        /// An array of ISO-8601 DateTime formats that we support parsing.
+        /// </summary>
+        private static readonly string[] _datetimeFormats = new string[]
+        {
+            "THHmmssK",
+            "THHmmK",
+            "HH:mm:ss.FFFFFFFK",
+            "HH:mm:ssK",
+            "HH:mmK",
+            DatetimeFormatUtc,
+            "yyyy-MM-dd HH:mm:ssK",
+            "yyyy-MM-dd HH:mmK",
+            "yyyy-MM-ddTHH:mm:ss.FFFFFFFK",
+            "yyyy-MM-ddTHH:mmK",
+            "yyyy-MM-ddTHH:mm:ssK",
+            "yyyyMMddHHmmssK",
+            "yyyyMMddHHmmK",
+            "yyyyMMddTHHmmssFFFFFFFK",
+            "THHmmss",
+            "THHmm",
+            "HH:mm:ss.FFFFFFF",
+            "HH:mm:ss",
+            "HH:mm",
+            DatetimeFormatLocal,
+            "yyyy-MM-dd HH:mm:ss",
+            "yyyy-MM-dd HH:mm",
+            "yyyy-MM-ddTHH:mm:ss.FFFFFFF",
+            "yyyy-MM-ddTHH:mm",
+            "yyyy-MM-ddTHH:mm:ss",
+            "yyyyMMddHHmmss",
+            "yyyyMMddHHmm",
+            "yyyyMMddTHHmmssFFFFFFF",
+            "yyyy-MM-dd",
+            "yyyyMMdd",
+            "yy-MM-dd"
+        };
+
+        public static IEnumerable<SqliteDataReader> Query(this SqliteConnection sqliteConnection, string commandText)
+        {
+            if (sqliteConnection.State != ConnectionState.Open)
+            {
+                sqliteConnection.Open();
+            }
+
+            using var command = sqliteConnection.CreateCommand();
+            command.CommandText = commandText;
+            using (var reader = command.ExecuteReader())
+            {
+                while (reader.Read())
+                {
+                    yield return reader;
+                }
+            }
+        }
+
+        public static void Execute(this SqliteConnection sqliteConnection, string commandText)
+        {
+            using var command = sqliteConnection.CreateCommand();
+            command.CommandText = commandText;
+            command.ExecuteNonQuery();
+        }
+
+        public static string ToDateTimeParamValue(this DateTime dateValue)
+        {
+            var kind = DateTimeKind.Utc;
+
+            return (dateValue.Kind == DateTimeKind.Unspecified)
+                ? DateTime.SpecifyKind(dateValue, kind).ToString(
+                    GetDateTimeKindFormat(kind),
+                    CultureInfo.InvariantCulture)
+                : dateValue.ToString(
+                    GetDateTimeKindFormat(dateValue.Kind),
+                    CultureInfo.InvariantCulture);
+        }
+
+        private static string GetDateTimeKindFormat(DateTimeKind kind)
+            => (kind == DateTimeKind.Utc) ? DatetimeFormatUtc : DatetimeFormatLocal;
+
+        public static bool TryReadDateTime(this SqliteDataReader reader, int index, out DateTime result)
+        {
+            if (reader.IsDBNull(index))
+            {
+                result = default;
+                return false;
+            }
+
+            var dateText = reader.GetString(index);
+
+            if (DateTime.TryParseExact(dateText, _datetimeFormats, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AdjustToUniversal, out var dateTimeResult))
+            {
+                // If the resulting DateTimeKind is Unspecified it is actually Utc.
+                // This is required downstream for the Json serializer.
+                if (dateTimeResult.Kind == DateTimeKind.Unspecified)
+                {
+                    dateTimeResult = DateTime.SpecifyKind(dateTimeResult, DateTimeKind.Utc);
+                }
+
+                result = dateTimeResult;
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
+        public static bool TryGetGuid(this SqliteDataReader reader, int index, out Guid result)
+        {
+            if (reader.IsDBNull(index))
+            {
+                result = default;
+                return false;
+            }
+
+            try
+            {
+                result = reader.GetGuid(index);
+                return true;
+            }
+            catch
+            {
+                result = Guid.Empty;
+                return false;
+            }
+        }
+
+        public static bool TryGetString(this SqliteDataReader reader, int index, out string result)
+        {
+            result = string.Empty;
+
+            if (reader.IsDBNull(index))
+            {
+                return false;
+            }
+
+            result = reader.GetString(index);
+            return true;
+        }
+
+        public static bool TryGetBoolean(this SqliteDataReader reader, int index, out bool result)
+        {
+            if (reader.IsDBNull(index))
+            {
+                result = default;
+                return false;
+            }
+
+            result = reader.GetBoolean(index);
+            return true;
+        }
+
+        public static bool TryGetInt32(this SqliteDataReader reader, int index, out int result)
+        {
+            if (reader.IsDBNull(index))
+            {
+                result = default;
+                return false;
+            }
+
+            result = reader.GetInt32(index);
+            return true;
+        }
+
+        public static bool TryGetInt64(this SqliteDataReader reader, int index, out long result)
+        {
+            if (reader.IsDBNull(index))
+            {
+                result = default;
+                return false;
+            }
+
+            result = reader.GetInt64(index);
+            return true;
+        }
+
+        public static bool TryGetSingle(this SqliteDataReader reader, int index, out float result)
+        {
+            if (reader.IsDBNull(index))
+            {
+                result = default;
+                return false;
+            }
+
+            result = reader.GetFloat(index);
+            return true;
+        }
+
+        public static bool TryGetDouble(this SqliteDataReader reader, int index, out double result)
+        {
+            if (reader.IsDBNull(index))
+            {
+                result = default;
+                return false;
+            }
+
+            result = reader.GetDouble(index);
+            return true;
+        }
+
+        public static void TryBind(this SqliteCommand statement, string name, Guid value)
+        {
+            statement.TryBind(name, value, true);
+        }
+
+        public static void TryBind(this SqliteCommand statement, string name, object? value, bool isBlob = false)
+        {
+            var preparedValue = value ?? DBNull.Value;
+            if (statement.Parameters.Contains(name))
+            {
+                statement.Parameters[name].Value = preparedValue;
+            }
+            else
+            {
+                // Blobs aren't always detected automatically
+                if (isBlob)
+                {
+                    statement.Parameters.Add(new SqliteParameter(name, SqliteType.Blob) { Value = value });
+                }
+                else
+                {
+                    statement.Parameters.AddWithValue(name, preparedValue);
+                }
+            }
+        }
+
+        public static void TryBindNull(this SqliteCommand statement, string name)
+        {
+            statement.TryBind(name, DBNull.Value);
+        }
+
+        public static IEnumerable<SqliteDataReader> ExecuteQuery(this SqliteCommand command)
+        {
+            using (var reader = command.ExecuteReader())
+            {
+                while (reader.Read())
+                {
+                    yield return reader;
+                }
+            }
+        }
+
+        public static int SelectScalarInt(this SqliteCommand command)
+        {
+            var result = command.ExecuteScalar();
+            // Can't be null since the method is used to retrieve Count
+            return Convert.ToInt32(result!, CultureInfo.InvariantCulture);
+        }
+
+        public static SqliteCommand PrepareStatement(this SqliteConnection sqliteConnection, string sql)
+        {
+            var command = sqliteConnection.CreateCommand();
+            command.CommandText = sql;
+            return command;
+        }
+    }
+}

Emby.Server.Implementations/Data/TypeMapper.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+
+namespace Emby.Server.Implementations.Data
+{
+    /// <summary>
+    /// Class TypeMapper.
+    /// </summary>
+    public class TypeMapper
+    {
+        /// <summary>
+        /// This holds all the types in the running assemblies
+        /// so that we can de-serialize properly when we don't have strong types.
+        /// </summary>
+        private readonly ConcurrentDictionary<string, Type?> _typeMap = new ConcurrentDictionary<string, Type?>();
+
+        /// <summary>
+        /// Gets the type.
+        /// </summary>
+        /// <param name="typeName">Name of the type.</param>
+        /// <returns>Type.</returns>
+        /// <exception cref="ArgumentNullException"><c>typeName</c> is null.</exception>
+        public Type? GetType(string typeName)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(typeName);
+
+            return _typeMap.GetOrAdd(typeName, k => AppDomain.CurrentDomain.GetAssemblies()
+                .Select(a => a.GetType(k))
+                .FirstOrDefault(t => t is not null));
+        }
+    }
+}

Emby.Server.Implementations/Devices/DeviceId.cs

@@ -0,0 +1,98 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Threading;
+using MediaBrowser.Common.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Devices
+{
+    public class DeviceId
+    {
+        private readonly IApplicationPaths _appPaths;
+        private readonly ILogger<DeviceId> _logger;
+        private readonly Lock _syncLock = new();
+
+        private string? _id;
+
+        public DeviceId(IApplicationPaths appPaths, ILogger<DeviceId> logger)
+        {
+            _appPaths = appPaths;
+            _logger = logger;
+        }
+
+        public string Value => _id ??= GetDeviceId();
+
+        private string CachePath => Path.Combine(_appPaths.DataPath, "device.txt");
+
+        private string? GetCachedId()
+        {
+            try
+            {
+                lock (_syncLock)
+                {
+                    var value = File.ReadAllText(CachePath, Encoding.UTF8);
+
+                    if (Guid.TryParse(value, out _))
+                    {
+                        return value;
+                    }
+
+                    _logger.LogError("Invalid value found in device id file");
+                }
+            }
+            catch (DirectoryNotFoundException)
+            {
+            }
+            catch (FileNotFoundException)
+            {
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error reading file");
+            }
+
+            return null;
+        }
+
+        private void SaveId(string id)
+        {
+            try
+            {
+                var path = CachePath;
+
+                Directory.CreateDirectory(Path.GetDirectoryName(path) ?? throw new InvalidOperationException("Path can't be a root directory."));
+
+                lock (_syncLock)
+                {
+                    File.WriteAllText(path, id, Encoding.UTF8);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error writing to file");
+            }
+        }
+
+        private static string GetNewId()
+        {
+            return Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
+        }
+
+        private string GetDeviceId()
+        {
+            var id = GetCachedId();
+
+            if (string.IsNullOrWhiteSpace(id))
+            {
+                id = GetNewId();
+                SaveId(id);
+            }
+
+            return id;
+        }
+    }
+}

Emby.Server.Implementations/Emby.Server.Implementations.csproj

@@ -0,0 +1,76 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <!-- ProjectGuid is only included as a requirement for SonarQube analysis -->
+  <PropertyGroup>
+    <ProjectGuid>{E383961B-9356-4D5D-8233-9A1079D03055}</ProjectGuid>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Emby.Naming\Emby.Naming.csproj" />
+    <ProjectReference Include="..\Jellyfin.Api\Jellyfin.Api.csproj" />
+    <ProjectReference Include="..\Jellyfin.Server.Implementations\Jellyfin.Server.Implementations.csproj" />
+    <ProjectReference Include="..\MediaBrowser.Model\MediaBrowser.Model.csproj" />
+    <ProjectReference Include="..\MediaBrowser.Common\MediaBrowser.Common.csproj" />
+    <ProjectReference Include="..\MediaBrowser.Controller\MediaBrowser.Controller.csproj" />
+    <ProjectReference Include="..\MediaBrowser.Providers\MediaBrowser.Providers.csproj" />
+    <ProjectReference Include="..\MediaBrowser.XbmcMetadata\MediaBrowser.XbmcMetadata.csproj" />
+    <ProjectReference Include="..\MediaBrowser.LocalMetadata\MediaBrowser.LocalMetadata.csproj" />
+    <ProjectReference Include="..\Emby.Photos\Emby.Photos.csproj" />
+    <ProjectReference Include="..\src\Jellyfin.Drawing\Jellyfin.Drawing.csproj" />
+    <ProjectReference Include="..\MediaBrowser.MediaEncoding\MediaBrowser.MediaEncoding.csproj" />
+    <ProjectReference Include="..\src\Jellyfin.Database\Jellyfin.Database.Implementations\Jellyfin.Database.Implementations.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BitFaster.Caching" />
+    <PackageReference Include="DiscUtils.Udf" />
+    <PackageReference Include="Microsoft.Data.Sqlite" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
+    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
+    <PackageReference Include="prometheus-net.DotNetRuntime" />
+    <PackageReference Include="DotNet.Glob" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\SharedVersion.cs" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <CodeAnalysisTreatWarningsAsErrors>false</CodeAnalysisTreatWarningsAsErrors>
+  </PropertyGroup>
+
+  <!-- Code Analyzers -->
+  <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <!-- TODO: Add IDisposableAnalyzers -->
+    <!-- <PackageReference Include="IDisposableAnalyzers">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference> -->
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="SerilogAnalyzer" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" PrivateAssets="All" />
+    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Ignore" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="Localization\iso6392.txt" />
+    <EmbeddedResource Include="Localization\countries.json" />
+    <EmbeddedResource Include="Localization\Core\*.json" />
+    <EmbeddedResource Include="Localization\Ratings\*.json" />
+  </ItemGroup>
+</Project>

Emby.Server.Implementations/EntryPoints/LibraryChangedNotifier.cs

@@ -0,0 +1,402 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Events;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Channels;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Session;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.EntryPoints;
+
+/// <summary>
+/// A <see cref="IHostedService"/> responsible for notifying users when libraries are updated.
+/// </summary>
+public sealed class LibraryChangedNotifier : IHostedService, IDisposable
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly IServerConfigurationManager _configurationManager;
+    private readonly IProviderManager _providerManager;
+    private readonly ISessionManager _sessionManager;
+    private readonly IUserManager _userManager;
+    private readonly ILogger<LibraryChangedNotifier> _logger;
+
+    private readonly Lock _libraryChangedSyncLock = new();
+    private readonly List<Folder> _foldersAddedTo = new();
+    private readonly List<Folder> _foldersRemovedFrom = new();
+    private readonly List<BaseItem> _itemsAdded = new();
+    private readonly List<BaseItem> _itemsRemoved = new();
+    private readonly List<BaseItem> _itemsUpdated = new();
+    private readonly ConcurrentDictionary<Guid, DateTime> _lastProgressMessageTimes = new();
+
+    private Timer? _libraryUpdateTimer;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LibraryChangedNotifier"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The <see cref="ILibraryManager"/>.</param>
+    /// <param name="configurationManager">The <see cref="IServerConfigurationManager"/>.</param>
+    /// <param name="sessionManager">The <see cref="ISessionManager"/>.</param>
+    /// <param name="userManager">The <see cref="IUserManager"/>.</param>
+    /// <param name="logger">The <see cref="ILogger"/>.</param>
+    /// <param name="providerManager">The <see cref="IProviderManager"/>.</param>
+    public LibraryChangedNotifier(
+        ILibraryManager libraryManager,
+        IServerConfigurationManager configurationManager,
+        ISessionManager sessionManager,
+        IUserManager userManager,
+        ILogger<LibraryChangedNotifier> logger,
+        IProviderManager providerManager)
+    {
+        _libraryManager = libraryManager;
+        _configurationManager = configurationManager;
+        _sessionManager = sessionManager;
+        _userManager = userManager;
+        _logger = logger;
+        _providerManager = providerManager;
+    }
+
+    /// <inheritdoc />
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _libraryManager.ItemAdded += OnLibraryItemAdded;
+        _libraryManager.ItemUpdated += OnLibraryItemUpdated;
+        _libraryManager.ItemRemoved += OnLibraryItemRemoved;
+
+        _providerManager.RefreshCompleted += OnProviderRefreshCompleted;
+        _providerManager.RefreshStarted += OnProviderRefreshStarted;
+        _providerManager.RefreshProgress += OnProviderRefreshProgress;
+
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        _libraryManager.ItemAdded -= OnLibraryItemAdded;
+        _libraryManager.ItemUpdated -= OnLibraryItemUpdated;
+        _libraryManager.ItemRemoved -= OnLibraryItemRemoved;
+
+        _providerManager.RefreshCompleted -= OnProviderRefreshCompleted;
+        _providerManager.RefreshStarted -= OnProviderRefreshStarted;
+        _providerManager.RefreshProgress -= OnProviderRefreshProgress;
+
+        return Task.CompletedTask;
+    }
+
+    private void OnProviderRefreshProgress(object? sender, GenericEventArgs<Tuple<BaseItem, double>> e)
+    {
+        var item = e.Argument.Item1;
+
+        if (!EnableRefreshMessage(item))
+        {
+            return;
+        }
+
+        var progress = e.Argument.Item2;
+
+        if (_lastProgressMessageTimes.TryGetValue(item.Id, out var lastMessageSendTime))
+        {
+            if (progress > 0 && progress < 100 && (DateTime.UtcNow - lastMessageSendTime).TotalMilliseconds < 1000)
+            {
+                return;
+            }
+        }
+
+        _lastProgressMessageTimes.AddOrUpdate(item.Id, _ => DateTime.UtcNow, (_, _) => DateTime.UtcNow);
+
+        var dict = new Dictionary<string, string>();
+        dict["ItemId"] = item.Id.ToString("N", CultureInfo.InvariantCulture);
+        dict["Progress"] = progress.ToString(CultureInfo.InvariantCulture);
+
+        try
+        {
+            _sessionManager.SendMessageToAdminSessions(SessionMessageType.RefreshProgress, dict, CancellationToken.None);
+        }
+        catch
+        {
+        }
+
+        var collectionFolders = _libraryManager.GetCollectionFolders(item);
+
+        foreach (var collectionFolder in collectionFolders)
+        {
+            var collectionFolderDict = new Dictionary<string, string>
+            {
+                ["ItemId"] = collectionFolder.Id.ToString("N", CultureInfo.InvariantCulture),
+                ["Progress"] = (collectionFolder.GetRefreshProgress() ?? 0).ToString(CultureInfo.InvariantCulture)
+            };
+
+            try
+            {
+                _sessionManager.SendMessageToAdminSessions(SessionMessageType.RefreshProgress, collectionFolderDict, CancellationToken.None);
+            }
+            catch
+            {
+            }
+        }
+    }
+
+    private void OnProviderRefreshStarted(object? sender, GenericEventArgs<BaseItem> e)
+        => OnProviderRefreshProgress(sender, new GenericEventArgs<Tuple<BaseItem, double>>(new Tuple<BaseItem, double>(e.Argument, 0)));
+
+    private void OnProviderRefreshCompleted(object? sender, GenericEventArgs<BaseItem> e)
+    {
+        OnProviderRefreshProgress(sender, new GenericEventArgs<Tuple<BaseItem, double>>(new Tuple<BaseItem, double>(e.Argument, 100)));
+
+        _lastProgressMessageTimes.TryRemove(e.Argument.Id, out _);
+    }
+
+    private static bool EnableRefreshMessage(BaseItem item)
+        => item is Folder { IsRoot: false, IsTopParent: true }
+            and not (AggregateFolder or UserRootFolder or UserView or Channel);
+
+    private void OnLibraryItemAdded(object? sender, ItemChangeEventArgs e)
+        => OnLibraryChange(e.Item, e.Parent, _itemsAdded, _foldersAddedTo);
+
+    private void OnLibraryItemUpdated(object? sender, ItemChangeEventArgs e)
+        => OnLibraryChange(e.Item, e.Parent, _itemsUpdated, null);
+
+    private void OnLibraryItemRemoved(object? sender, ItemChangeEventArgs e)
+        => OnLibraryChange(e.Item, e.Parent, _itemsRemoved, _foldersRemovedFrom);
+
+    private void OnLibraryChange(BaseItem item, BaseItem parent, List<BaseItem> itemsList, List<Folder>? foldersList)
+    {
+        if (!FilterItem(item))
+        {
+            return;
+        }
+
+        lock (_libraryChangedSyncLock)
+        {
+            var updateDuration = TimeSpan.FromSeconds(_configurationManager.Configuration.LibraryUpdateDuration);
+
+            if (_libraryUpdateTimer is null)
+            {
+                _libraryUpdateTimer = new Timer(LibraryUpdateTimerCallback, null, updateDuration, Timeout.InfiniteTimeSpan);
+            }
+            else
+            {
+                _libraryUpdateTimer.Change(updateDuration, Timeout.InfiniteTimeSpan);
+            }
+
+            if (foldersList is not null && parent is Folder folder)
+            {
+                foldersList.Add(folder);
+            }
+
+            itemsList.Add(item);
+        }
+    }
+
+    private async void LibraryUpdateTimerCallback(object? state)
+    {
+        List<Folder> foldersAddedTo;
+        List<Folder> foldersRemovedFrom;
+        List<BaseItem> itemsUpdated;
+        List<BaseItem> itemsAdded;
+        List<BaseItem> itemsRemoved;
+        lock (_libraryChangedSyncLock)
+        {
+            // Remove dupes in case some were saved multiple times
+            foldersAddedTo = _foldersAddedTo
+                .DistinctBy(x => x.Id)
+                .ToList();
+
+            foldersRemovedFrom = _foldersRemovedFrom
+                .DistinctBy(x => x.Id)
+                .ToList();
+
+            itemsUpdated = _itemsUpdated
+                .Where(i => !_itemsAdded.Contains(i))
+                .DistinctBy(x => x.Id)
+                .ToList();
+
+            itemsAdded = _itemsAdded.ToList();
+            itemsRemoved = _itemsRemoved.ToList();
+
+            if (_libraryUpdateTimer is not null)
+            {
+                _libraryUpdateTimer.Dispose();
+                _libraryUpdateTimer = null;
+            }
+
+            _itemsAdded.Clear();
+            _itemsRemoved.Clear();
+            _itemsUpdated.Clear();
+            _foldersAddedTo.Clear();
+            _foldersRemovedFrom.Clear();
+        }
+
+        await SendChangeNotifications(itemsAdded, itemsUpdated, itemsRemoved, foldersAddedTo, foldersRemovedFrom, CancellationToken.None).ConfigureAwait(false);
+    }
+
+    private async Task SendChangeNotifications(
+        List<BaseItem> itemsAdded,
+        List<BaseItem> itemsUpdated,
+        List<BaseItem> itemsRemoved,
+        List<Folder> foldersAddedTo,
+        List<Folder> foldersRemovedFrom,
+        CancellationToken cancellationToken)
+    {
+        var userIds = _sessionManager.Sessions
+            .Select(i => i.UserId)
+            .Where(i => !i.IsEmpty())
+            .Distinct()
+            .ToArray();
+
+        foreach (var userId in userIds)
+        {
+            LibraryUpdateInfo info;
+
+            try
+            {
+                info = GetLibraryUpdateInfo(itemsAdded, itemsUpdated, itemsRemoved, foldersAddedTo, foldersRemovedFrom, userId);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error in GetLibraryUpdateInfo");
+                return;
+            }
+
+            if (info.IsEmpty)
+            {
+                continue;
+            }
+
+            try
+            {
+                await _sessionManager.SendMessageToUserSessions(
+                        new List<Guid> { userId },
+                        SessionMessageType.LibraryChanged,
+                        info,
+                        cancellationToken)
+                    .ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error sending LibraryChanged message");
+            }
+        }
+    }
+
+    private LibraryUpdateInfo GetLibraryUpdateInfo(
+        List<BaseItem> itemsAdded,
+        List<BaseItem> itemsUpdated,
+        List<BaseItem> itemsRemoved,
+        List<Folder> foldersAddedTo,
+        List<Folder> foldersRemovedFrom,
+        Guid userId)
+    {
+        var user = _userManager.GetUserById(userId);
+        ArgumentNullException.ThrowIfNull(user);
+
+        var newAndRemoved = new List<BaseItem>();
+        newAndRemoved.AddRange(foldersAddedTo);
+        newAndRemoved.AddRange(foldersRemovedFrom);
+
+        var allUserRootChildren = _libraryManager.GetUserRootFolder()
+            .GetChildren(user, true)
+            .OfType<Folder>()
+            .ToList();
+
+        return new LibraryUpdateInfo
+        {
+            ItemsAdded = itemsAdded.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user))
+                .Select(i => i.Id.ToString("N", CultureInfo.InvariantCulture))
+                .Distinct()
+                .ToArray(),
+            ItemsUpdated = itemsUpdated.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user))
+                .Select(i => i.Id.ToString("N", CultureInfo.InvariantCulture))
+                .Distinct()
+                .ToArray(),
+            ItemsRemoved = itemsRemoved.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user, true))
+                .Select(i => i.Id.ToString("N", CultureInfo.InvariantCulture))
+                .Distinct()
+                .ToArray(),
+            FoldersAddedTo = foldersAddedTo.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user))
+                .Select(i => i.Id.ToString("N", CultureInfo.InvariantCulture))
+                .Distinct()
+                .ToArray(),
+            FoldersRemovedFrom = foldersRemovedFrom.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user))
+                .Select(i => i.Id.ToString("N", CultureInfo.InvariantCulture))
+                .Distinct()
+                .ToArray(),
+            CollectionFolders = GetTopParentIds(newAndRemoved, allUserRootChildren).ToArray()
+        };
+    }
+
+    private static bool FilterItem(BaseItem item)
+    {
+        if (!item.IsFolder && !item.HasPathProtocol)
+        {
+            return false;
+        }
+
+        if (item is IItemByName && item is not MusicArtist)
+        {
+            return false;
+        }
+
+        return item.SourceType == SourceType.Library;
+    }
+
+    private static IEnumerable<string> GetTopParentIds(List<BaseItem> items, List<Folder> allUserRootChildren)
+    {
+        var list = new List<string>();
+
+        foreach (var item in items)
+        {
+            // If the physical root changed, return the user root
+            if (item is AggregateFolder)
+            {
+                continue;
+            }
+
+            foreach (var folder in allUserRootChildren)
+            {
+                list.Add(folder.Id.ToString("N", CultureInfo.InvariantCulture));
+            }
+        }
+
+        return list.Distinct(StringComparer.Ordinal);
+    }
+
+    private T[] TranslatePhysicalItemToUserLibrary<T>(T item, User user, bool includeIfNotFound = false)
+        where T : BaseItem
+    {
+        // If the physical root changed, return the user root
+        if (item is AggregateFolder)
+        {
+            return _libraryManager.GetUserRootFolder() is T t ? new[] { t } : Array.Empty<T>();
+        }
+
+        // Return it only if it's in the user's library
+        if (includeIfNotFound || item.IsVisibleStandalone(user))
+        {
+            return new[] { item };
+        }
+
+        return Array.Empty<T>();
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        _libraryUpdateTimer?.Dispose();
+        _libraryUpdateTimer = null;
+    }
+}

Emby.Server.Implementations/EntryPoints/UserDataChangeNotifier.cs

@@ -0,0 +1,167 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Session;
+using Microsoft.Extensions.Hosting;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    /// <summary>
+    /// <see cref="IHostedService"/> responsible for notifying users when associated item data is updated.
+    /// </summary>
+    public sealed class UserDataChangeNotifier : IHostedService, IDisposable
+    {
+        private const int UpdateDuration = 500;
+
+        private readonly ISessionManager _sessionManager;
+        private readonly IUserDataManager _userDataManager;
+        private readonly IUserManager _userManager;
+
+        private readonly Dictionary<Guid, List<BaseItem>> _changedItems = new();
+        private readonly Lock _syncLock = new();
+
+        private Timer? _updateTimer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UserDataChangeNotifier"/> class.
+        /// </summary>
+        /// <param name="userDataManager">The <see cref="IUserDataManager"/>.</param>
+        /// <param name="sessionManager">The <see cref="ISessionManager"/>.</param>
+        /// <param name="userManager">The <see cref="IUserManager"/>.</param>
+        public UserDataChangeNotifier(
+            IUserDataManager userDataManager,
+            ISessionManager sessionManager,
+            IUserManager userManager)
+        {
+            _userDataManager = userDataManager;
+            _sessionManager = sessionManager;
+            _userManager = userManager;
+        }
+
+        /// <inheritdoc />
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _userDataManager.UserDataSaved += OnUserDataManagerUserDataSaved;
+
+            return Task.CompletedTask;
+        }
+
+        /// <inheritdoc />
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            _userDataManager.UserDataSaved -= OnUserDataManagerUserDataSaved;
+
+            return Task.CompletedTask;
+        }
+
+        private void OnUserDataManagerUserDataSaved(object? sender, UserDataSaveEventArgs e)
+        {
+            if (e.SaveReason == UserDataSaveReason.PlaybackProgress)
+            {
+                return;
+            }
+
+            lock (_syncLock)
+            {
+                if (_updateTimer is null)
+                {
+                    _updateTimer = new Timer(
+                        UpdateTimerCallback,
+                        null,
+                        UpdateDuration,
+                        Timeout.Infinite);
+                }
+                else
+                {
+                    _updateTimer.Change(UpdateDuration, Timeout.Infinite);
+                }
+
+                if (!_changedItems.TryGetValue(e.UserId, out List<BaseItem>? keys))
+                {
+                    keys = new List<BaseItem>();
+                    _changedItems[e.UserId] = keys;
+                }
+
+                keys.Add(e.Item);
+
+                var baseItem = e.Item;
+
+                // Go up one level for indicators
+                if (baseItem is not null)
+                {
+                    var parent = baseItem.GetOwner() ?? baseItem.GetParent();
+
+                    if (parent is not null)
+                    {
+                        keys.Add(parent);
+                    }
+                }
+            }
+        }
+
+        private async void UpdateTimerCallback(object? state)
+        {
+            List<KeyValuePair<Guid, List<BaseItem>>> changes;
+            lock (_syncLock)
+            {
+                // Remove dupes in case some were saved multiple times
+                changes = _changedItems.ToList();
+                _changedItems.Clear();
+
+                if (_updateTimer is not null)
+                {
+                    _updateTimer.Dispose();
+                    _updateTimer = null;
+                }
+            }
+
+            foreach (var (userId, changedItems) in changes)
+            {
+                await _sessionManager.SendMessageToUserSessions(
+                    [userId],
+                    SessionMessageType.UserDataChanged,
+                    () => GetUserDataChangeInfo(userId, changedItems),
+                    default).ConfigureAwait(false);
+            }
+        }
+
+        private UserDataChangeInfo GetUserDataChangeInfo(Guid userId, List<BaseItem> changedItems)
+        {
+            var user = _userManager.GetUserById(userId)
+                ?? throw new ArgumentException("Invalid user ID", nameof(userId));
+
+            return new UserDataChangeInfo
+            {
+                UserId = userId,
+                UserDataList = changedItems
+                    .DistinctBy(x => x.Id)
+                    .Select(i =>
+                    {
+                        var dto = _userDataManager.GetUserDataDto(i, user);
+                        if (dto is null)
+                        {
+                            return null!;
+                        }
+
+                        dto.ItemId = i.Id;
+                        return dto;
+                    })
+                    .Where(e => e is not null)
+                    .ToArray()
+            };
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            _updateTimer?.Dispose();
+            _updateTimer = null;
+        }
+    }
+}

Emby.Server.Implementations/HttpServer/Security/AuthService.cs

@@ -0,0 +1,43 @@
+#pragma warning disable CS1591
+
+using System.Threading.Tasks;
+using Jellyfin.Data;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Net;
+using Microsoft.AspNetCore.Http;
+
+namespace Emby.Server.Implementations.HttpServer.Security
+{
+    public class AuthService : IAuthService
+    {
+        private readonly IAuthorizationContext _authorizationContext;
+
+        public AuthService(
+            IAuthorizationContext authorizationContext)
+        {
+            _authorizationContext = authorizationContext;
+        }
+
+        public async Task<AuthorizationInfo> Authenticate(HttpRequest request)
+        {
+            var auth = await _authorizationContext.GetAuthorizationInfo(request).ConfigureAwait(false);
+
+            if (!auth.HasToken)
+            {
+                return auth;
+            }
+
+            if (!auth.IsAuthenticated)
+            {
+                throw new SecurityException("Invalid token.");
+            }
+
+            if (auth.User?.HasPermission(PermissionKind.IsDisabled) ?? false)
+            {
+                throw new SecurityException("User account has been disabled.");
+            }
+
+            return auth;
+        }
+    }
+}

Emby.Server.Implementations/HttpServer/WebSocketConnection.cs

@@ -0,0 +1,283 @@
+using System;
+using System.Buffers;
+using System.IO.Pipelines;
+using System.Net;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Controller.Net;
+using MediaBrowser.Controller.Net.WebSocketMessages;
+using MediaBrowser.Controller.Net.WebSocketMessages.Outbound;
+using MediaBrowser.Model.Session;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.HttpServer
+{
+    /// <summary>
+    /// Class WebSocketConnection.
+    /// </summary>
+    public class WebSocketConnection : IWebSocketConnection
+    {
+        /// <summary>
+        /// The logger.
+        /// </summary>
+        private readonly ILogger<WebSocketConnection> _logger;
+
+        /// <summary>
+        /// The json serializer options.
+        /// </summary>
+        private readonly JsonSerializerOptions _jsonOptions;
+
+        /// <summary>
+        /// The socket.
+        /// </summary>
+        private readonly WebSocket _socket;
+
+        private bool _disposed = false;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WebSocketConnection" /> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="socket">The socket.</param>
+        /// <param name="authorizationInfo">The authorization information.</param>
+        /// <param name="remoteEndPoint">The remote end point.</param>
+        public WebSocketConnection(
+            ILogger<WebSocketConnection> logger,
+            WebSocket socket,
+            AuthorizationInfo authorizationInfo,
+            IPAddress? remoteEndPoint)
+        {
+            _logger = logger;
+            _socket = socket;
+            AuthorizationInfo = authorizationInfo;
+            RemoteEndPoint = remoteEndPoint;
+
+            _jsonOptions = JsonDefaults.Options;
+            LastActivityDate = DateTime.UtcNow;
+        }
+
+        /// <inheritdoc />
+        public event EventHandler<EventArgs>? Closed;
+
+        /// <inheritdoc />
+        public AuthorizationInfo AuthorizationInfo { get; }
+
+        /// <inheritdoc />
+        public IPAddress? RemoteEndPoint { get; }
+
+        /// <inheritdoc />
+        public Func<WebSocketMessageInfo, Task>? OnReceive { get; set; }
+
+        /// <inheritdoc />
+        public DateTime LastActivityDate { get; private set; }
+
+        /// <inheritdoc />
+        public DateTime LastKeepAliveDate { get; set; }
+
+        /// <inheritdoc />
+        public WebSocketState State => _socket.State;
+
+        /// <inheritdoc />
+        public async Task SendAsync(OutboundWebSocketMessage message, CancellationToken cancellationToken)
+        {
+            var json = JsonSerializer.SerializeToUtf8Bytes(message, _jsonOptions);
+            await _socket.SendAsync(json, WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <inheritdoc />
+        public async Task SendAsync<T>(OutboundWebSocketMessage<T> message, CancellationToken cancellationToken)
+        {
+            var json = JsonSerializer.SerializeToUtf8Bytes(message, _jsonOptions);
+            await _socket.SendAsync(json, WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <inheritdoc />
+        public async Task ReceiveAsync(CancellationToken cancellationToken = default)
+        {
+            var pipe = new Pipe();
+            var writer = pipe.Writer;
+
+            ValueWebSocketReceiveResult receiveResult;
+            do
+            {
+                // Allocate at least 512 bytes from the PipeWriter
+                Memory<byte> memory = writer.GetMemory(512);
+                try
+                {
+                    receiveResult = await _socket.ReceiveAsync(memory, cancellationToken).ConfigureAwait(false);
+                }
+                catch (WebSocketException ex)
+                {
+                    _logger.LogWarning("WS {IP} error receiving data: {Message}", RemoteEndPoint, ex.Message);
+                    break;
+                }
+
+                int bytesRead = receiveResult.Count;
+                if (bytesRead == 0)
+                {
+                    break;
+                }
+
+                // Tell the PipeWriter how much was read from the Socket
+                writer.Advance(bytesRead);
+
+                // Make the data available to the PipeReader
+                FlushResult flushResult = await writer.FlushAsync(cancellationToken).ConfigureAwait(false);
+                if (flushResult.IsCompleted)
+                {
+                    // The PipeReader stopped reading
+                    break;
+                }
+
+                LastActivityDate = DateTime.UtcNow;
+
+                if (receiveResult.EndOfMessage)
+                {
+                    await ProcessInternal(pipe.Reader).ConfigureAwait(false);
+                }
+            }
+            while ((_socket.State == WebSocketState.Open || _socket.State == WebSocketState.Connecting)
+                && receiveResult.MessageType != WebSocketMessageType.Close);
+
+            Closed?.Invoke(this, EventArgs.Empty);
+
+            if (_socket.State == WebSocketState.Open
+                || _socket.State == WebSocketState.CloseReceived
+                || _socket.State == WebSocketState.CloseSent)
+            {
+                await _socket.CloseAsync(
+                    WebSocketCloseStatus.NormalClosure,
+                    string.Empty,
+                    cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        private async Task ProcessInternal(PipeReader reader)
+        {
+            ReadResult result = await reader.ReadAsync().ConfigureAwait(false);
+            ReadOnlySequence<byte> buffer = result.Buffer;
+
+            if (OnReceive is null)
+            {
+                // Tell the PipeReader how much of the buffer we have consumed
+                reader.AdvanceTo(buffer.End);
+                return;
+            }
+
+            InboundWebSocketMessage<object>? stub;
+            long bytesConsumed;
+            try
+            {
+                stub = DeserializeWebSocketMessage(buffer, out bytesConsumed);
+            }
+            catch (JsonException ex)
+            {
+                // Tell the PipeReader how much of the buffer we have consumed
+                reader.AdvanceTo(buffer.End);
+                _logger.LogError(ex, "Error processing web socket message: {Data}", Encoding.UTF8.GetString(buffer));
+                return;
+            }
+
+            if (stub is null)
+            {
+                _logger.LogError("Error processing web socket message");
+                return;
+            }
+
+            // Tell the PipeReader how much of the buffer we have consumed
+            reader.AdvanceTo(buffer.GetPosition(bytesConsumed));
+
+            _logger.LogDebug("WS {IP} received message: {@Message}", RemoteEndPoint, stub);
+
+            if (stub.MessageType == SessionMessageType.KeepAlive)
+            {
+                await SendKeepAliveResponse().ConfigureAwait(false);
+            }
+            else
+            {
+                try
+                {
+                    await OnReceive(
+                        new WebSocketMessageInfo
+                        {
+                            MessageType = stub.MessageType,
+                            Data = stub.Data?.ToString(), // Data can be null
+                            Connection = this
+                        }).ConfigureAwait(false);
+                }
+                catch (Exception exception)
+                {
+                    _logger.LogWarning(exception, "Failed to process WebSocket message");
+                }
+            }
+        }
+
+        internal InboundWebSocketMessage<object>? DeserializeWebSocketMessage(ReadOnlySequence<byte> bytes, out long bytesConsumed)
+        {
+            var jsonReader = new Utf8JsonReader(bytes);
+            var ret = JsonSerializer.Deserialize<InboundWebSocketMessage<object>>(ref jsonReader, _jsonOptions);
+            bytesConsumed = jsonReader.BytesConsumed;
+            return ret;
+        }
+
+        private async Task SendKeepAliveResponse()
+        {
+            LastKeepAliveDate = DateTime.UtcNow;
+            await SendAsync(
+                new OutboundKeepAliveMessage(),
+                CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <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 (_disposed)
+            {
+                return;
+            }
+
+            if (dispose)
+            {
+                _socket.Dispose();
+            }
+
+            _disposed = true;
+        }
+
+        /// <inheritdoc />
+        public async ValueTask DisposeAsync()
+        {
+            await DisposeAsyncCore().ConfigureAwait(false);
+            Dispose(false);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Used to perform asynchronous cleanup of managed resources or for cascading calls to <see cref="DisposeAsync"/>.
+        /// </summary>
+        /// <returns>A ValueTask.</returns>
+        protected virtual async ValueTask DisposeAsyncCore()
+        {
+            if (_socket.State == WebSocketState.Open)
+            {
+                await _socket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "System Shutdown", CancellationToken.None).ConfigureAwait(false);
+            }
+
+            _socket.Dispose();
+        }
+    }
+}

Emby.Server.Implementations/HttpServer/WebSocketManager.cs

@@ -0,0 +1,98 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Threading.Tasks;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.Net;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.HttpServer
+{
+    public class WebSocketManager : IWebSocketManager
+    {
+        private readonly IWebSocketListener[] _webSocketListeners;
+        private readonly IAuthService _authService;
+        private readonly ILogger<WebSocketManager> _logger;
+        private readonly ILoggerFactory _loggerFactory;
+
+        public WebSocketManager(
+            IAuthService authService,
+            IEnumerable<IWebSocketListener> webSocketListeners,
+            ILogger<WebSocketManager> logger,
+            ILoggerFactory loggerFactory)
+        {
+            _webSocketListeners = webSocketListeners.ToArray();
+            _authService = authService;
+            _logger = logger;
+            _loggerFactory = loggerFactory;
+        }
+
+        /// <inheritdoc />
+        public async Task WebSocketRequestHandler(HttpContext context)
+        {
+            var authorizationInfo = await _authService.Authenticate(context.Request).ConfigureAwait(false);
+            if (!authorizationInfo.IsAuthenticated)
+            {
+                throw new SecurityException("Token is required");
+            }
+
+            try
+            {
+                _logger.LogInformation("WS {IP} request", context.Connection.RemoteIpAddress);
+
+                WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false);
+
+                var connection = new WebSocketConnection(
+                    _loggerFactory.CreateLogger<WebSocketConnection>(),
+                    webSocket,
+                    authorizationInfo,
+                    context.GetNormalizedRemoteIP())
+                {
+                    OnReceive = ProcessWebSocketMessageReceived
+                };
+                await using (connection.ConfigureAwait(false))
+                {
+                    var tasks = new Task[_webSocketListeners.Length];
+                    for (var i = 0; i < _webSocketListeners.Length; ++i)
+                    {
+                        tasks[i] = _webSocketListeners[i].ProcessWebSocketConnectedAsync(connection, context);
+                    }
+
+                    await Task.WhenAll(tasks).ConfigureAwait(false);
+
+                    await connection.ReceiveAsync().ConfigureAwait(false);
+                    _logger.LogInformation("WS {IP} closed", context.Connection.RemoteIpAddress);
+                }
+            }
+            catch (Exception ex) // Otherwise ASP.Net will ignore the exception
+            {
+                _logger.LogError(ex, "WS {IP} WebSocketRequestHandler error", context.Connection.RemoteIpAddress);
+                if (!context.Response.HasStarted)
+                {
+                    context.Response.StatusCode = 500;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Processes the web socket message received.
+        /// </summary>
+        /// <param name="result">The result.</param>
+        private async Task ProcessWebSocketMessageReceived(WebSocketMessageInfo result)
+        {
+            var tasks = new Task[_webSocketListeners.Length];
+            for (var i = 0; i < _webSocketListeners.Length; ++i)
+            {
+                tasks[i] = _webSocketListeners[i].ProcessMessageAsync(result);
+            }
+
+            await Task.WhenAll(tasks).ConfigureAwait(false);
+        }
+    }
+}

Emby.Server.Implementations/IO/FileRefresher.cs

@@ -0,0 +1,215 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.IO
+{
+    public sealed class FileRefresher : IDisposable
+    {
+        private readonly ILogger _logger;
+        private readonly ILibraryManager _libraryManager;
+        private readonly IServerConfigurationManager _configurationManager;
+
+        private readonly List<string> _affectedPaths = new();
+        private readonly Lock _timerLock = new();
+        private Timer? _timer;
+        private bool _disposed;
+
+        public FileRefresher(string path, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, ILogger logger)
+        {
+            logger.LogDebug("New file refresher created for {0}", path);
+            Path = path;
+
+            _configurationManager = configurationManager;
+            _libraryManager = libraryManager;
+            _logger = logger;
+            AddPath(path);
+        }
+
+        public event EventHandler<EventArgs>? Completed;
+
+        public string Path { get; private set; }
+
+        private void AddAffectedPath(string path)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(path);
+
+            if (!_affectedPaths.Contains(path, StringComparer.Ordinal))
+            {
+                _affectedPaths.Add(path);
+            }
+        }
+
+        public void AddPath(string path)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(path);
+
+            lock (_timerLock)
+            {
+                AddAffectedPath(path);
+            }
+
+            RestartTimer();
+        }
+
+        public void RestartTimer()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            lock (_timerLock)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                if (_timer is null)
+                {
+                    _timer = new Timer(OnTimerCallback, null, TimeSpan.FromSeconds(_configurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
+                }
+                else
+                {
+                    _timer.Change(TimeSpan.FromSeconds(_configurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
+                }
+            }
+        }
+
+        public void ResetPath(string path, string? affectedFile)
+        {
+            lock (_timerLock)
+            {
+                _logger.LogDebug("Resetting file refresher from {0} to {1}", Path, path);
+
+                Path = path;
+                AddAffectedPath(path);
+
+                if (!string.IsNullOrEmpty(affectedFile))
+                {
+                    AddAffectedPath(affectedFile);
+                }
+            }
+
+            RestartTimer();
+        }
+
+        private void OnTimerCallback(object? state)
+        {
+            List<string> paths;
+
+            lock (_timerLock)
+            {
+                paths = _affectedPaths.ToList();
+            }
+
+            _logger.LogDebug("Timer stopped.");
+
+            DisposeTimer();
+            Completed?.Invoke(this, EventArgs.Empty);
+
+            try
+            {
+                ProcessPathChanges(paths);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error processing directory changes");
+            }
+        }
+
+        private void ProcessPathChanges(List<string> paths)
+        {
+            IEnumerable<BaseItem> itemsToRefresh = paths
+                .Distinct()
+                .Select(GetAffectedBaseItem)
+                .Where(item => item is not null)
+                .DistinctBy(x => x!.Id)!;  // Removed null values in the previous .Where()
+
+            foreach (var item in itemsToRefresh)
+            {
+                if (item is AggregateFolder)
+                {
+                    continue;
+                }
+
+                _logger.LogInformation("{Name} ({Path}) will be refreshed.", item.Name, item.Path);
+
+                try
+                {
+                    item.ChangedExternally();
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error refreshing {Name}", item.Name);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the affected base item.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns>BaseItem.</returns>
+        private BaseItem? GetAffectedBaseItem(string path)
+        {
+            BaseItem? item = null;
+
+            while (item is null && !string.IsNullOrEmpty(path))
+            {
+                item = _libraryManager.FindByPath(path, null);
+
+                path = System.IO.Path.GetDirectoryName(path) ?? string.Empty;
+            }
+
+            if (item is not null)
+            {
+                // If the item has been deleted find the first valid parent that still exists
+                while (!Directory.Exists(item.Path) && !File.Exists(item.Path))
+                {
+                    item = item.GetOwner() ?? item.GetParent();
+
+                    if (item is null)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            return item;
+        }
+
+        private void DisposeTimer()
+        {
+            lock (_timerLock)
+            {
+                if (_timer is not null)
+                {
+                    _timer.Dispose();
+                    _timer = null;
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            DisposeTimer();
+            _disposed = true;
+        }
+    }
+}

Emby.Server.Implementations/IO/LibraryMonitor.cs

@@ -0,0 +1,491 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Emby.Server.Implementations.Library;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.IO
+{
+    /// <inheritdoc cref="ILibraryMonitor" />
+    public sealed class LibraryMonitor : ILibraryMonitor, IDisposable
+    {
+        private readonly ILogger<LibraryMonitor> _logger;
+        private readonly ILibraryManager _libraryManager;
+        private readonly IServerConfigurationManager _configurationManager;
+        private readonly IFileSystem _fileSystem;
+
+        /// <summary>
+        /// The file system watchers.
+        /// </summary>
+        private readonly ConcurrentDictionary<string, FileSystemWatcher> _fileSystemWatchers = new(StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// The affected paths.
+        /// </summary>
+        private readonly List<FileRefresher> _activeRefreshers = [];
+
+        /// <summary>
+        /// A dynamic list of paths that should be ignored.  Added to during our own file system modifications.
+        /// </summary>
+        private readonly ConcurrentDictionary<string, string> _tempIgnoredPaths = new(StringComparer.OrdinalIgnoreCase);
+
+        private bool _disposed;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LibraryMonitor" /> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="configurationManager">The configuration manager.</param>
+        /// <param name="fileSystem">The filesystem.</param>
+        /// <param name="appLifetime">The <see cref="IHostApplicationLifetime"/>.</param>
+        public LibraryMonitor(
+            ILogger<LibraryMonitor> logger,
+            ILibraryManager libraryManager,
+            IServerConfigurationManager configurationManager,
+            IFileSystem fileSystem,
+            IHostApplicationLifetime appLifetime)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _configurationManager = configurationManager;
+            _fileSystem = fileSystem;
+
+            appLifetime.ApplicationStarted.Register(Start);
+        }
+
+        /// <inheritdoc />
+        public void ReportFileSystemChangeBeginning(string path)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(path);
+
+            _tempIgnoredPaths[path] = path;
+        }
+
+        /// <inheritdoc />
+        public async void ReportFileSystemChangeComplete(string path, bool refreshPath)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(path);
+
+            // This is an arbitrary amount of time, but delay it because file system writes often trigger events long after the file was actually written to.
+            // Seeing long delays in some situations, especially over the network, sometimes up to 45 seconds
+            // But if we make this delay too high, we risk missing legitimate changes, such as user adding a new file, or hand-editing metadata
+            await Task.Delay(45000).ConfigureAwait(false);
+
+            _tempIgnoredPaths.TryRemove(path, out _);
+
+            if (refreshPath)
+            {
+                try
+                {
+                    ReportFileSystemChanged(path);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error in ReportFileSystemChanged for {Path}", path);
+                }
+            }
+        }
+
+        private bool IsLibraryMonitorEnabled(BaseItem item)
+        {
+            if (item is BasePluginFolder)
+            {
+                return false;
+            }
+
+            var options = _libraryManager.GetLibraryOptions(item);
+
+            return options is not null && options.EnableRealtimeMonitor;
+        }
+
+        /// <inheritdoc />
+        public void Start()
+        {
+            _libraryManager.ItemAdded += OnLibraryManagerItemAdded;
+            _libraryManager.ItemRemoved += OnLibraryManagerItemRemoved;
+
+            var pathsToWatch = new List<string>();
+
+            var paths = _libraryManager
+                .RootFolder
+                .Children
+                .Where(IsLibraryMonitorEnabled)
+                .OfType<Folder>()
+                .SelectMany(f => f.PhysicalLocations)
+                .Distinct()
+                .Order();
+
+            foreach (var path in paths)
+            {
+                if (!ContainsParentFolder(pathsToWatch, path))
+                {
+                    pathsToWatch.Add(path);
+                }
+            }
+
+            foreach (var path in pathsToWatch)
+            {
+                StartWatchingPath(path);
+            }
+        }
+
+        private void StartWatching(BaseItem item)
+        {
+            if (IsLibraryMonitorEnabled(item))
+            {
+                StartWatchingPath(item.Path);
+            }
+        }
+
+        /// <summary>
+        /// Handles the ItemRemoved event of the LibraryManager control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="ItemChangeEventArgs"/> instance containing the event data.</param>
+        private void OnLibraryManagerItemRemoved(object? sender, ItemChangeEventArgs e)
+        {
+            if (e.Parent is AggregateFolder)
+            {
+                StopWatchingPath(e.Item.Path);
+            }
+        }
+
+        /// <summary>
+        /// Handles the ItemAdded event of the LibraryManager control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="ItemChangeEventArgs"/> instance containing the event data.</param>
+        private void OnLibraryManagerItemAdded(object? sender, ItemChangeEventArgs e)
+        {
+            if (e.Parent is AggregateFolder)
+            {
+                StartWatching(e.Item);
+            }
+        }
+
+        /// <summary>
+        /// Examine a list of strings assumed to be file paths to see if it contains a parent of
+        /// the provided path.
+        /// </summary>
+        /// <param name="lst">The LST.</param>
+        /// <param name="path">The path.</param>
+        /// <returns><c>true</c> if [contains parent folder] [the specified LST]; otherwise, <c>false</c>.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path"/> is <c>null</c>.</exception>
+        private static bool ContainsParentFolder(IReadOnlyList<string> lst, ReadOnlySpan<char> path)
+        {
+            if (path.IsEmpty)
+            {
+                throw new ArgumentException("Path can't be empty", nameof(path));
+            }
+
+            path = path.TrimEnd(Path.DirectorySeparatorChar);
+
+            foreach (var str in lst)
+            {
+                // this should be a little quicker than examining each actual parent folder...
+                var compare = str.AsSpan().TrimEnd(Path.DirectorySeparatorChar);
+
+                if (path.Equals(compare, StringComparison.OrdinalIgnoreCase)
+                    || (path.StartsWith(compare, StringComparison.OrdinalIgnoreCase) && path[compare.Length] == Path.DirectorySeparatorChar))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Starts the watching path.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        private void StartWatchingPath(string path)
+        {
+            if (!Directory.Exists(path))
+            {
+                // Seeing a crash in the mono runtime due to an exception being thrown on a different thread
+                _logger.LogInformation("Skipping realtime monitor for {Path} because the path does not exist", path);
+                return;
+            }
+
+            // Already being watched
+            if (_fileSystemWatchers.ContainsKey(path))
+            {
+                return;
+            }
+
+            // Creating a FileSystemWatcher over the LAN can take hundreds of milliseconds, so wrap it in a Task to do them all in parallel
+            Task.Run(() =>
+            {
+                try
+                {
+                    var newWatcher = new FileSystemWatcher(path, "*")
+                    {
+                        IncludeSubdirectories = true,
+                        InternalBufferSize = 65536,
+                        NotifyFilter = NotifyFilters.CreationTime |
+                                       NotifyFilters.DirectoryName |
+                                       NotifyFilters.FileName |
+                                       NotifyFilters.LastWrite |
+                                       NotifyFilters.Size |
+                                       NotifyFilters.Attributes
+                    };
+
+                    newWatcher.Created += OnWatcherChanged;
+                    newWatcher.Deleted += OnWatcherChanged;
+                    newWatcher.Renamed += OnWatcherChanged;
+                    newWatcher.Changed += OnWatcherChanged;
+                    newWatcher.Error += OnWatcherError;
+
+                    if (_fileSystemWatchers.TryAdd(path, newWatcher))
+                    {
+                        newWatcher.EnableRaisingEvents = true;
+                        _logger.LogInformation("Watching directory {Path}", path);
+                    }
+                    else
+                    {
+                        DisposeWatcher(newWatcher, false);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error watching path: {Path}", path);
+                }
+            });
+        }
+
+        /// <summary>
+        /// Stops the watching path.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        private void StopWatchingPath(string path)
+        {
+            if (_fileSystemWatchers.TryGetValue(path, out var watcher))
+            {
+                DisposeWatcher(watcher, true);
+            }
+        }
+
+        /// <summary>
+        /// Disposes the watcher.
+        /// </summary>
+        private void DisposeWatcher(FileSystemWatcher watcher, bool removeFromList)
+        {
+            try
+            {
+                using (watcher)
+                {
+                    _logger.LogInformation("Stopping directory watching for path {Path}", watcher.Path);
+
+                    watcher.Created -= OnWatcherChanged;
+                    watcher.Deleted -= OnWatcherChanged;
+                    watcher.Renamed -= OnWatcherChanged;
+                    watcher.Changed -= OnWatcherChanged;
+                    watcher.Error -= OnWatcherError;
+
+                    watcher.EnableRaisingEvents = false;
+                }
+            }
+            finally
+            {
+                if (removeFromList)
+                {
+                    _fileSystemWatchers.TryRemove(watcher.Path, out _);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Handles the Error event of the watcher control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="ErrorEventArgs" /> instance containing the event data.</param>
+        private void OnWatcherError(object sender, ErrorEventArgs e)
+        {
+            var ex = e.GetException();
+            var dw = (FileSystemWatcher)sender;
+
+            if (ex is UnauthorizedAccessException unauthorizedAccessException)
+            {
+                _logger.LogError(unauthorizedAccessException, "Permission error for Directory watcher: {Path}", dw.Path);
+                return;
+            }
+
+            _logger.LogError(ex, "Error in Directory watcher for: {Path}", dw.Path);
+
+            DisposeWatcher(dw, true);
+        }
+
+        /// <summary>
+        /// Handles the Changed event of the watcher control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="FileSystemEventArgs" /> instance containing the event data.</param>
+        private void OnWatcherChanged(object sender, FileSystemEventArgs e)
+        {
+            try
+            {
+                ReportFileSystemChanged(e.FullPath);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Exception in ReportFileSystemChanged. Path: {FullPath}", e.FullPath);
+            }
+        }
+
+        /// <inheritdoc />
+        public void ReportFileSystemChanged(string path)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(path);
+
+            if (IgnorePatterns.ShouldIgnore(path))
+            {
+                return;
+            }
+
+            var fileInfo = _fileSystem.GetFileSystemInfo(path);
+            if (DotIgnoreIgnoreRule.IsIgnored(fileInfo, null))
+            {
+                return;
+            }
+
+            // Ignore certain files, If the parent of an ignored path has a change event, ignore that too
+            foreach (var i in _tempIgnoredPaths.Keys)
+            {
+                if (_fileSystem.AreEqual(i, path)
+                    || _fileSystem.ContainsSubPath(i, path))
+                {
+                    _logger.LogDebug("Ignoring change to {Path}", path);
+                    return;
+                }
+
+                // Go up a level
+                var parent = Path.GetDirectoryName(i);
+                if (!string.IsNullOrEmpty(parent) && _fileSystem.AreEqual(parent, path))
+                {
+                    _logger.LogDebug("Ignoring change to {Path}", path);
+                    return;
+                }
+            }
+
+            CreateRefresher(path);
+        }
+
+        private void CreateRefresher(string path)
+        {
+            var parentPath = Path.GetDirectoryName(path);
+
+            lock (_activeRefreshers)
+            {
+                foreach (var refresher in _activeRefreshers)
+                {
+                    // Path is already being refreshed
+                    if (_fileSystem.AreEqual(path, refresher.Path))
+                    {
+                        refresher.RestartTimer();
+                        return;
+                    }
+
+                    // Parent folder is already being refreshed
+                    if (_fileSystem.ContainsSubPath(refresher.Path, path))
+                    {
+                        refresher.AddPath(path);
+                        return;
+                    }
+
+                    // New path is a parent
+                    if (_fileSystem.ContainsSubPath(path, refresher.Path))
+                    {
+                        refresher.ResetPath(path, null);
+                        return;
+                    }
+
+                    // They are siblings. Rebase the refresher to the parent folder.
+                    if (parentPath is not null
+                        && Path.GetDirectoryName(refresher.Path.AsSpan()).Equals(parentPath, StringComparison.Ordinal))
+                    {
+                        refresher.ResetPath(parentPath, path);
+                        return;
+                    }
+                }
+
+                var newRefresher = new FileRefresher(path, _configurationManager, _libraryManager, _logger);
+                newRefresher.Completed += OnNewRefresherCompleted;
+                _activeRefreshers.Add(newRefresher);
+            }
+        }
+
+        private void OnNewRefresherCompleted(object? sender, EventArgs e)
+        {
+            if (sender is null)
+            {
+                return;
+            }
+
+            var refresher = (FileRefresher)sender;
+            DisposeRefresher(refresher);
+        }
+
+        /// <summary>
+        /// Stops this instance.
+        /// </summary>
+        public void Stop()
+        {
+            _libraryManager.ItemAdded -= OnLibraryManagerItemAdded;
+            _libraryManager.ItemRemoved -= OnLibraryManagerItemRemoved;
+
+            foreach (var watcher in _fileSystemWatchers.Values.ToList())
+            {
+                DisposeWatcher(watcher, false);
+            }
+
+            _fileSystemWatchers.Clear();
+            DisposeRefreshers();
+        }
+
+        private void DisposeRefresher(FileRefresher refresher)
+        {
+            lock (_activeRefreshers)
+            {
+                refresher.Completed -= OnNewRefresherCompleted;
+                refresher.Dispose();
+                _activeRefreshers.Remove(refresher);
+            }
+        }
+
+        private void DisposeRefreshers()
+        {
+            lock (_activeRefreshers)
+            {
+                foreach (var refresher in _activeRefreshers)
+                {
+                    refresher.Completed -= OnNewRefresherCompleted;
+                    refresher.Dispose();
+                }
+
+                _activeRefreshers.Clear();
+            }
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            Stop();
+            _disposed = true;
+        }
+    }
+}

Emby.Server.Implementations/IO/ManagedFileSystem.cs

@@ -0,0 +1,716 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Security;
+using Jellyfin.Extensions;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.IO
+{
+    /// <summary>
+    /// Class ManagedFileSystem.
+    /// </summary>
+    public class ManagedFileSystem : IFileSystem
+    {
+        private static readonly bool _isEnvironmentCaseInsensitive = OperatingSystem.IsWindows();
+        private static readonly char[] _invalidPathCharacters =
+        {
+            '\"', '<', '>', '|', '\0',
+            (char)1, (char)2, (char)3, (char)4, (char)5, (char)6, (char)7, (char)8, (char)9, (char)10,
+            (char)11, (char)12, (char)13, (char)14, (char)15, (char)16, (char)17, (char)18, (char)19, (char)20,
+            (char)21, (char)22, (char)23, (char)24, (char)25, (char)26, (char)27, (char)28, (char)29, (char)30,
+            (char)31, ':', '*', '?', '\\', '/'
+        };
+
+        private readonly ILogger<ManagedFileSystem> _logger;
+        private readonly List<IShortcutHandler> _shortcutHandlers;
+        private readonly string _tempPath;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ManagedFileSystem"/> class.
+        /// </summary>
+        /// <param name="logger">The <see cref="ILogger"/> instance to use.</param>
+        /// <param name="applicationPaths">The <see cref="IApplicationPaths"/> instance to use.</param>
+        /// <param name="shortcutHandlers">the <see cref="IShortcutHandler"/>'s to use.</param>
+        public ManagedFileSystem(
+            ILogger<ManagedFileSystem> logger,
+            IApplicationPaths applicationPaths,
+            IEnumerable<IShortcutHandler> shortcutHandlers)
+        {
+            _logger = logger;
+            _tempPath = applicationPaths.TempDirectory;
+            _shortcutHandlers = shortcutHandlers.ToList();
+        }
+
+        /// <summary>
+        /// Determines whether the specified filename is shortcut.
+        /// </summary>
+        /// <param name="filename">The filename.</param>
+        /// <returns><c>true</c> if the specified filename is shortcut; otherwise, <c>false</c>.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="filename"/> is <c>null</c>.</exception>
+        public virtual bool IsShortcut(string filename)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(filename);
+
+            var extension = Path.GetExtension(filename);
+            return _shortcutHandlers.Any(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase));
+        }
+
+        /// <summary>
+        /// Resolves the shortcut.
+        /// </summary>
+        /// <param name="filename">The filename.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="filename"/> is <c>null</c>.</exception>
+        public virtual string? ResolveShortcut(string filename)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(filename);
+
+            var extension = Path.GetExtension(filename);
+            var handler = _shortcutHandlers.Find(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase));
+
+            return handler?.Resolve(filename);
+        }
+
+        /// <inheritdoc />
+        public virtual string MakeAbsolutePath(string folderPath, string filePath)
+        {
+            // path is actually a stream
+            if (string.IsNullOrWhiteSpace(filePath))
+            {
+                return filePath;
+            }
+
+            var isAbsolutePath = Path.IsPathRooted(filePath) && (!OperatingSystem.IsWindows() || filePath[0] != '\\');
+
+            if (isAbsolutePath)
+            {
+                // absolute local path
+                return filePath;
+            }
+
+            // unc path
+            if (filePath.StartsWith(@"\\", StringComparison.Ordinal))
+            {
+                return filePath;
+            }
+
+            var filePathSpan = filePath.AsSpan();
+
+            // relative path on windows
+            if (filePath[0] == '\\')
+            {
+                filePathSpan = filePathSpan.Slice(1);
+            }
+
+            try
+            {
+                return Path.GetFullPath(Path.Join(folderPath, filePathSpan));
+            }
+            catch (ArgumentException)
+            {
+                return filePath;
+            }
+            catch (PathTooLongException)
+            {
+                return filePath;
+            }
+            catch (NotSupportedException)
+            {
+                return filePath;
+            }
+        }
+
+        /// <summary>
+        /// Creates the shortcut.
+        /// </summary>
+        /// <param name="shortcutPath">The shortcut path.</param>
+        /// <param name="target">The target.</param>
+        /// <exception cref="ArgumentNullException">The shortcutPath or target is null.</exception>
+        public virtual void CreateShortcut(string shortcutPath, string target)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(shortcutPath);
+            ArgumentException.ThrowIfNullOrEmpty(target);
+
+            var extension = Path.GetExtension(shortcutPath);
+            var handler = _shortcutHandlers.Find(i => string.Equals(extension, i.Extension, StringComparison.OrdinalIgnoreCase));
+
+            if (handler is not null)
+            {
+                handler.Create(shortcutPath, target);
+            }
+            else
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        /// <inheritdoc />
+        public void MoveDirectory(string source, string destination)
+        {
+            // Make sure parent directory of target exists
+            var parent = Directory.GetParent(destination);
+            parent?.Create();
+
+            try
+            {
+                Directory.Move(source, destination);
+            }
+            catch (IOException)
+            {
+                // Cross device move requires a copy
+                Directory.CreateDirectory(destination);
+                var sourceDir = new DirectoryInfo(source);
+                foreach (var file in sourceDir.EnumerateFiles())
+                {
+                    file.CopyTo(Path.Combine(destination, file.Name), true);
+                }
+
+                sourceDir.Delete(true);
+            }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="FileSystemMetadata"/> object for the specified file or directory path.
+        /// </summary>
+        /// <param name="path">A path to a file or directory.</param>
+        /// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
+        /// <remarks>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's
+        /// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and all other properties will reflect the properties of the directory.</remarks>
+        public virtual FileSystemMetadata GetFileSystemInfo(string path)
+        {
+            // Take a guess to try and avoid two file system hits, but we'll double-check by calling Exists
+            if (Path.HasExtension(path))
+            {
+                var fileInfo = new FileInfo(path);
+
+                if (fileInfo.Exists)
+                {
+                    return GetFileSystemMetadata(fileInfo);
+                }
+
+                return GetFileSystemMetadata(new DirectoryInfo(path));
+            }
+            else
+            {
+                var fileInfo = new DirectoryInfo(path);
+
+                if (fileInfo.Exists)
+                {
+                    return GetFileSystemMetadata(fileInfo);
+                }
+
+                return GetFileSystemMetadata(new FileInfo(path));
+            }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="FileSystemMetadata"/> object for the specified file path.
+        /// </summary>
+        /// <param name="path">A path to a file.</param>
+        /// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
+        /// <remarks><para>If the specified path points to a directory, the returned <see cref="FileSystemMetadata"/> object's
+        /// <see cref="FileSystemMetadata.IsDirectory"/> property and the <see cref="FileSystemMetadata.Exists"/> property will both be set to false.</para>
+        /// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></remarks>
+        public virtual FileSystemMetadata GetFileInfo(string path)
+        {
+            var fileInfo = new FileInfo(path);
+
+            return GetFileSystemMetadata(fileInfo);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="FileSystemMetadata"/> object for the specified directory path.
+        /// </summary>
+        /// <param name="path">A path to a directory.</param>
+        /// <returns>A <see cref="FileSystemMetadata"/> object.</returns>
+        /// <remarks><para>If the specified path points to a file, the returned <see cref="FileSystemMetadata"/> object's
+        /// <see cref="FileSystemMetadata.IsDirectory"/> property will be set to true and the <see cref="FileSystemMetadata.Exists"/> property will be set to false.</para>
+        /// <para>For automatic handling of files <b>and</b> directories, use <see cref="GetFileSystemInfo"/>.</para></remarks>
+        public virtual FileSystemMetadata GetDirectoryInfo(string path)
+        {
+            var fileInfo = new DirectoryInfo(path);
+
+            return GetFileSystemMetadata(fileInfo);
+        }
+
+        private FileSystemMetadata GetFileSystemMetadata(FileSystemInfo info)
+        {
+            var result = new FileSystemMetadata
+            {
+                Exists = info.Exists,
+                FullName = info.FullName,
+                Extension = info.Extension,
+                Name = info.Name
+            };
+
+            if (result.Exists)
+            {
+                result.IsDirectory = info is DirectoryInfo || (info.Attributes & FileAttributes.Directory) == FileAttributes.Directory;
+
+                if (info is FileInfo fileInfo)
+                {
+                    result.CreationTimeUtc = GetCreationTimeUtc(info);
+                    result.LastWriteTimeUtc = GetLastWriteTimeUtc(info);
+                    if (fileInfo.LinkTarget is not null)
+                    {
+                        try
+                        {
+                            var targetFileInfo = FileSystemHelper.ResolveLinkTarget(fileInfo, returnFinalTarget: true);
+                            if (targetFileInfo is not null)
+                            {
+                                result.Exists = targetFileInfo.Exists;
+                                if (result.Exists)
+                                {
+                                    result.Length = targetFileInfo.Length;
+                                    result.CreationTimeUtc = GetCreationTimeUtc(targetFileInfo);
+                                    result.LastWriteTimeUtc = GetLastWriteTimeUtc(targetFileInfo);
+                                }
+                            }
+                            else
+                            {
+                                result.Exists = false;
+                            }
+                        }
+                        catch (UnauthorizedAccessException ex)
+                        {
+                            _logger.LogError(ex, "Reading the file at {Path} failed due to a permissions exception.", fileInfo.FullName);
+                        }
+                    }
+                    else
+                    {
+                        result.Length = fileInfo.Length;
+                    }
+                }
+            }
+            else
+            {
+                result.IsDirectory = info is DirectoryInfo;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Takes a filename and removes invalid characters.
+        /// </summary>
+        /// <param name="filename">The filename.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="ArgumentNullException">The filename is null.</exception>
+        public string GetValidFilename(string filename)
+        {
+            var first = filename.IndexOfAny(_invalidPathCharacters);
+            if (first == -1)
+            {
+                // Fast path for clean strings
+                return filename;
+            }
+
+            return string.Create(
+                filename.Length,
+                (filename, _invalidPathCharacters, first),
+                (chars, state) =>
+                {
+                    state.filename.AsSpan().CopyTo(chars);
+
+                    chars[state.first++] = ' ';
+
+                    var len = chars.Length;
+                    foreach (var c in state._invalidPathCharacters)
+                    {
+                        for (int i = state.first; i < len; i++)
+                        {
+                            if (chars[i] == c)
+                            {
+                                chars[i] = ' ';
+                            }
+                        }
+                    }
+                });
+        }
+
+        /// <summary>
+        /// Gets the creation time UTC.
+        /// </summary>
+        /// <param name="info">The info.</param>
+        /// <returns>DateTime.</returns>
+        public DateTime GetCreationTimeUtc(FileSystemInfo info)
+        {
+            // This could throw an error on some file systems that have dates out of range
+            try
+            {
+                return info.CreationTimeUtc;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error determining CreationTimeUtc for {FullName}", info.FullName);
+                return DateTime.MinValue;
+            }
+        }
+
+        /// <inheritdoc />
+        public virtual DateTime GetCreationTimeUtc(string path)
+        {
+            return GetCreationTimeUtc(GetFileSystemInfo(path));
+        }
+
+        /// <inheritdoc />
+        public virtual DateTime GetCreationTimeUtc(FileSystemMetadata info)
+        {
+            return info.CreationTimeUtc;
+        }
+
+        /// <inheritdoc />
+        public virtual DateTime GetLastWriteTimeUtc(FileSystemMetadata info)
+        {
+            return info.LastWriteTimeUtc;
+        }
+
+        /// <summary>
+        /// Gets the creation time UTC.
+        /// </summary>
+        /// <param name="info">The info.</param>
+        /// <returns>DateTime.</returns>
+        public DateTime GetLastWriteTimeUtc(FileSystemInfo info)
+        {
+            // This could throw an error on some file systems that have dates out of range
+            try
+            {
+                return info.LastWriteTimeUtc;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error determining LastAccessTimeUtc for {FullName}", info.FullName);
+                return DateTime.MinValue;
+            }
+        }
+
+        /// <inheritdoc />
+        public virtual DateTime GetLastWriteTimeUtc(string path)
+        {
+            return GetLastWriteTimeUtc(GetFileSystemInfo(path));
+        }
+
+        /// <inheritdoc />
+        public virtual void SetHidden(string path, bool isHidden)
+        {
+            if (!OperatingSystem.IsWindows())
+            {
+                return;
+            }
+
+            var info = new FileInfo(path);
+
+            if (info.Exists &&
+                (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden != isHidden)
+            {
+                if (isHidden)
+                {
+                    File.SetAttributes(path, info.Attributes | FileAttributes.Hidden);
+                }
+                else
+                {
+                    File.SetAttributes(path, info.Attributes & ~FileAttributes.Hidden);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public virtual void SetAttributes(string path, bool isHidden, bool readOnly)
+        {
+            if (!OperatingSystem.IsWindows())
+            {
+                return;
+            }
+
+            var info = new FileInfo(path);
+
+            if (!info.Exists)
+            {
+                return;
+            }
+
+            if ((info.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly == readOnly
+                && (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden == isHidden)
+            {
+                return;
+            }
+
+            var attributes = info.Attributes;
+
+            if (readOnly)
+            {
+                attributes |= FileAttributes.ReadOnly;
+            }
+            else
+            {
+                attributes &= ~FileAttributes.ReadOnly;
+            }
+
+            if (isHidden)
+            {
+                attributes |= FileAttributes.Hidden;
+            }
+            else
+            {
+                attributes &= ~FileAttributes.Hidden;
+            }
+
+            File.SetAttributes(path, attributes);
+        }
+
+        /// <inheritdoc />
+        public virtual void SwapFiles(string file1, string file2)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(file1);
+            ArgumentException.ThrowIfNullOrEmpty(file2);
+
+            var temp1 = Path.Combine(_tempPath, Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture));
+
+            // Copying over will fail against hidden files
+            SetHidden(file1, false);
+            SetHidden(file2, false);
+
+            Directory.CreateDirectory(_tempPath);
+            File.Copy(file1, temp1, true);
+
+            File.Copy(file2, file1, true);
+            File.Move(temp1, file2, true);
+        }
+
+        /// <inheritdoc />
+        public virtual bool ContainsSubPath(string parentPath, string path)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(parentPath);
+            ArgumentException.ThrowIfNullOrEmpty(path);
+
+            return path.Contains(
+                Path.TrimEndingDirectorySeparator(parentPath) + Path.DirectorySeparatorChar,
+                _isEnvironmentCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+        }
+
+        /// <inheritdoc />
+        public virtual bool AreEqual(string path1, string path2)
+        {
+            if (string.IsNullOrWhiteSpace(path1) || string.IsNullOrWhiteSpace(path2))
+            {
+                return false;
+            }
+
+            var normalized1 = Path.TrimEndingDirectorySeparator(path1);
+            var normalized2 = Path.TrimEndingDirectorySeparator(path2);
+
+            return string.Equals(
+                normalized1,
+                normalized2,
+                _isEnvironmentCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
+        }
+
+        /// <inheritdoc />
+        public virtual string GetFileNameWithoutExtension(FileSystemMetadata info)
+        {
+            if (info.IsDirectory)
+            {
+                return info.Name;
+            }
+
+            return Path.GetFileNameWithoutExtension(info.FullName);
+        }
+
+        /// <inheritdoc />
+        public virtual bool IsPathFile(string path)
+        {
+            if (path.Contains("://", StringComparison.OrdinalIgnoreCase)
+                && !path.StartsWith("file://", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc />
+        public virtual void DeleteFile(string path)
+        {
+            SetAttributes(path, false, false);
+            File.Delete(path);
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<FileSystemMetadata> GetDrives()
+        {
+            // check for ready state to avoid waiting for drives to timeout
+            // some drives on linux have no actual size or are used for other purposes
+            return DriveInfo.GetDrives()
+                .Where(
+                    d => (d.DriveType == DriveType.Fixed || d.DriveType == DriveType.Network || d.DriveType == DriveType.Removable)
+                         && d.IsReady
+                         && d.TotalSize != 0)
+                .Select(d => new FileSystemMetadata
+                {
+                    Name = d.Name,
+                    FullName = d.RootDirectory.FullName,
+                    IsDirectory = true
+                });
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<FileSystemMetadata> GetDirectories(string path, bool recursive = false)
+        {
+            return ToMetadata(new DirectoryInfo(path).EnumerateDirectories("*", GetEnumerationOptions(recursive)));
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, bool recursive = false)
+        {
+            return GetFiles(path, "*", recursive);
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, string searchPattern, bool recursive = false)
+        {
+            return GetFiles(path, searchPattern, null, false, recursive);
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, IReadOnlyList<string>? extensions, bool enableCaseSensitiveExtensions, bool recursive)
+        {
+            return GetFiles(path, "*", extensions, enableCaseSensitiveExtensions, recursive);
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, string searchPattern, IReadOnlyList<string>? extensions, bool enableCaseSensitiveExtensions, bool recursive = false)
+        {
+            var enumerationOptions = GetEnumerationOptions(recursive);
+
+            // On linux and macOS the search pattern is case-sensitive
+            // If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method
+            if ((enableCaseSensitiveExtensions || _isEnvironmentCaseInsensitive) && extensions is not null && extensions.Count == 1)
+            {
+                searchPattern = searchPattern.EndsWith(extensions[0], StringComparison.Ordinal) ? searchPattern : searchPattern + extensions[0];
+
+                return ToMetadata(new DirectoryInfo(path).EnumerateFiles(searchPattern, enumerationOptions));
+            }
+
+            var files = new DirectoryInfo(path).EnumerateFiles(searchPattern, enumerationOptions);
+
+            if (extensions is not null && extensions.Count > 0)
+            {
+                files = files.Where(i =>
+                {
+                    var ext = i.Extension.AsSpan();
+                    if (ext.IsEmpty)
+                    {
+                        return false;
+                    }
+
+                    return extensions.Contains(ext, StringComparison.OrdinalIgnoreCase);
+                });
+            }
+
+            return ToMetadata(files);
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<FileSystemMetadata> GetFileSystemEntries(string path, bool recursive = false)
+        {
+            // Note: any of unhandled exceptions thrown by this method may cause the caller to believe the whole path is not accessible.
+            // But what causing the exception may be a single file under that path. This could lead to unexpected behavior.
+            // For example, the scanner will remove everything in that path due to unhandled errors.
+            var directoryInfo = new DirectoryInfo(path);
+            var enumerationOptions = GetEnumerationOptions(recursive);
+
+            return ToMetadata(directoryInfo.EnumerateFileSystemInfos("*", enumerationOptions));
+        }
+
+        private IEnumerable<FileSystemMetadata> ToMetadata(IEnumerable<FileSystemInfo> infos)
+        {
+            return infos.Select(GetFileSystemMetadata);
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<string> GetDirectoryPaths(string path, bool recursive = false)
+        {
+            return Directory.EnumerateDirectories(path, "*", GetEnumerationOptions(recursive));
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<string> GetFilePaths(string path, bool recursive = false)
+        {
+            return GetFilePaths(path, null, false, recursive);
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<string> GetFilePaths(string path, string[]? extensions, bool enableCaseSensitiveExtensions, bool recursive = false)
+        {
+            var enumerationOptions = GetEnumerationOptions(recursive);
+
+            // On linux and macOS the search pattern is case-sensitive
+            // If we're OK with case-sensitivity, and we're only filtering for one extension, then use the native method
+            if ((enableCaseSensitiveExtensions || _isEnvironmentCaseInsensitive) && extensions is not null && extensions.Length == 1)
+            {
+                return Directory.EnumerateFiles(path, "*" + extensions[0], enumerationOptions);
+            }
+
+            var files = Directory.EnumerateFiles(path, "*", enumerationOptions);
+
+            if (extensions is not null && extensions.Length > 0)
+            {
+                files = files.Where(i =>
+                {
+                    var ext = Path.GetExtension(i.AsSpan());
+                    if (ext.IsEmpty)
+                    {
+                        return false;
+                    }
+
+                    return extensions.Contains(ext, StringComparison.OrdinalIgnoreCase);
+                });
+            }
+
+            return files;
+        }
+
+        /// <inheritdoc />
+        public virtual IEnumerable<string> GetFileSystemEntryPaths(string path, bool recursive = false)
+        {
+            try
+            {
+                return Directory.EnumerateFileSystemEntries(path, "*", GetEnumerationOptions(recursive));
+            }
+            catch (Exception ex) when (ex is UnauthorizedAccessException or DirectoryNotFoundException or SecurityException)
+            {
+                _logger.LogError(ex, "Failed to enumerate path {Path}", path);
+                return Enumerable.Empty<string>();
+            }
+        }
+
+        /// <inheritdoc />
+        public virtual bool DirectoryExists(string path)
+        {
+            return Directory.Exists(path);
+        }
+
+        /// <inheritdoc />
+        public virtual bool FileExists(string path)
+        {
+            return File.Exists(path);
+        }
+
+        private EnumerationOptions GetEnumerationOptions(bool recursive)
+        {
+            return new EnumerationOptions
+            {
+                RecurseSubdirectories = recursive,
+                IgnoreInaccessible = true,
+                // Don't skip any files.
+                AttributesToSkip = 0
+            };
+        }
+    }
+}

Emby.Server.Implementations/IO/MbLinkShortcutHandler.cs

@@ -0,0 +1,35 @@
+#pragma warning disable CS1591
+
+using System;
+using System.IO;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.IO
+{
+    public class MbLinkShortcutHandler : IShortcutHandler
+    {
+        public string Extension => ".mblink";
+
+        public string? Resolve(string shortcutPath)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(shortcutPath);
+
+            if (Path.GetExtension(shortcutPath.AsSpan()).Equals(".mblink", StringComparison.OrdinalIgnoreCase))
+            {
+                var path = File.ReadAllText(shortcutPath);
+
+                return Path.TrimEndingDirectorySeparator(path);
+            }
+
+            return null;
+        }
+
+        public void Create(string shortcutPath, string targetPath)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(shortcutPath);
+            ArgumentException.ThrowIfNullOrEmpty(targetPath);
+
+            File.WriteAllText(shortcutPath, targetPath);
+        }
+    }
+}

Emby.Server.Implementations/IStartupOptions.cs

@@ -0,0 +1,28 @@
+namespace Emby.Server.Implementations
+{
+    /// <summary>
+    /// Specifies the contract for server startup options.
+    /// </summary>
+    public interface IStartupOptions
+    {
+        /// <summary>
+        /// Gets the value of the --ffmpeg command line option.
+        /// </summary>
+        string? FFmpegPath { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether to run as service by the --service command line option.
+        /// </summary>
+        bool IsService { get; }
+
+        /// <summary>
+        /// Gets the value of the --package-name command line option.
+        /// </summary>
+        string? PackageName { get; }
+
+        /// <summary>
+        /// Gets the value of the --published-server-url command line option.
+        /// </summary>
+        string? PublishedServerUrl { get; }
+    }
+}

Emby.Server.Implementations/Images/ArtistImageProvider.cs

@@ -0,0 +1,46 @@
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Images
+{
+    /// <summary>
+    /// Class ArtistImageProvider.
+    /// </summary>
+    public class ArtistImageProvider : BaseDynamicImageProvider<MusicArtist>
+    {
+        public ArtistImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor)
+            : base(fileSystem, providerManager, applicationPaths, imageProcessor)
+        {
+        }
+
+        /// <summary>
+        /// Get children objects used to create an artist image.
+        /// </summary>
+        /// <param name="item">The artist used to create the image.</param>
+        /// <returns>Any relevant children objects.</returns>
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            return Array.Empty<BaseItem>();
+
+            // TODO enable this when BaseDynamicImageProvider objects are configurable
+            // return _libraryManager.GetItemList(new InternalItemsQuery
+            // {
+            //    ArtistIds = new[] { item.Id },
+            //    IncludeItemTypes = new[] { nameof(MusicAlbum) },
+            //    OrderBy = new[] { (ItemSortBy.Random, SortOrder.Ascending) },
+            //    Limit = 4,
+            //    Recursive = true,
+            //    ImageTypes = new[] { ImageType.Primary },
+            //    DtoOptions = new DtoOptions(false)
+            // });
+        }
+    }
+}

Emby.Server.Implementations/Images/BaseDynamicImageProvider.cs

@@ -0,0 +1,325 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net.Mime;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Net;
+
+namespace Emby.Server.Implementations.Images
+{
+    public abstract class BaseDynamicImageProvider<T> : IHasItemChangeMonitor, IForcedProvider, ICustomMetadataProvider<T>, IHasOrder
+        where T : BaseItem
+    {
+        protected BaseDynamicImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor)
+        {
+            ApplicationPaths = applicationPaths;
+            ProviderManager = providerManager;
+            FileSystem = fileSystem;
+            ImageProcessor = imageProcessor;
+        }
+
+        protected IFileSystem FileSystem { get; }
+
+        protected IProviderManager ProviderManager { get; }
+
+        protected IApplicationPaths ApplicationPaths { get; }
+
+        protected IImageProcessor ImageProcessor { get; set; }
+
+        protected virtual IReadOnlyCollection<ImageType> SupportedImages { get; }
+            = [ImageType.Primary];
+
+        /// <inheritdoc />
+        public string Name => "Dynamic Image Provider";
+
+        public int Order => 0;
+
+        protected virtual bool Supports(BaseItem item) => true;
+
+        public async Task<ItemUpdateType> FetchAsync(T item, MetadataRefreshOptions options, CancellationToken cancellationToken)
+        {
+            if (!Supports(item))
+            {
+                return ItemUpdateType.None;
+            }
+
+            var updateType = ItemUpdateType.None;
+
+            if (SupportedImages.Contains(ImageType.Primary))
+            {
+                var primaryResult = await FetchAsync(item, ImageType.Primary, options, cancellationToken).ConfigureAwait(false);
+                updateType |= primaryResult;
+            }
+
+            if (SupportedImages.Contains(ImageType.Thumb))
+            {
+                var thumbResult = await FetchAsync(item, ImageType.Thumb, options, cancellationToken).ConfigureAwait(false);
+                updateType |= thumbResult;
+            }
+
+            return updateType;
+        }
+
+        protected Task<ItemUpdateType> FetchAsync(BaseItem item, ImageType imageType, MetadataRefreshOptions options, CancellationToken cancellationToken)
+        {
+            var image = item.GetImageInfo(imageType, 0);
+
+            if (image is not null)
+            {
+                if (!image.IsLocalFile)
+                {
+                    return Task.FromResult(ItemUpdateType.None);
+                }
+
+                if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
+                {
+                    return Task.FromResult(ItemUpdateType.None);
+                }
+            }
+
+            var items = GetItemsWithImages(item);
+
+            return FetchToFileInternal(item, items, imageType, cancellationToken);
+        }
+
+        protected async Task<ItemUpdateType> FetchToFileInternal(
+            BaseItem item,
+            IReadOnlyList<BaseItem> itemsWithImages,
+            ImageType imageType,
+            CancellationToken cancellationToken)
+        {
+            var outputPathWithoutExtension = Path.Combine(ApplicationPaths.TempDirectory, Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture));
+            Directory.CreateDirectory(Path.GetDirectoryName(outputPathWithoutExtension));
+            string outputPath = CreateImage(item, itemsWithImages, outputPathWithoutExtension, imageType, 0);
+
+            if (string.IsNullOrEmpty(outputPath))
+            {
+                return ItemUpdateType.None;
+            }
+
+            var mimeType = MimeTypes.GetMimeType(outputPath);
+
+            if (string.Equals(mimeType, MediaTypeNames.Application.Octet, StringComparison.OrdinalIgnoreCase))
+            {
+                mimeType = MediaTypeNames.Image.Png;
+            }
+
+            await ProviderManager.SaveImage(item, outputPath, mimeType, imageType, null, false, cancellationToken).ConfigureAwait(false);
+
+            return ItemUpdateType.ImageUpdate;
+        }
+
+        protected abstract IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item);
+
+        protected string CreateThumbCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
+        {
+            return CreateCollage(primaryItem, items, outputPath, 640, 360);
+        }
+
+        protected virtual IEnumerable<string> GetStripCollageImagePaths(BaseItem primaryItem, IEnumerable<BaseItem> items)
+        {
+            var useBackdrop = primaryItem is CollectionFolder || primaryItem is UserView;
+            return items
+                .Select(i =>
+                {
+                    // Use Backdrop instead of Primary image for Library images.
+                    if (useBackdrop)
+                    {
+                        var backdrop = i.GetImageInfo(ImageType.Backdrop, 0);
+                        if (backdrop is not null && backdrop.IsLocalFile)
+                        {
+                            return backdrop.Path;
+                        }
+                    }
+
+                    var image = i.GetImageInfo(ImageType.Primary, 0);
+                    if (image is not null && image.IsLocalFile)
+                    {
+                        return image.Path;
+                    }
+
+                    image = i.GetImageInfo(ImageType.Thumb, 0);
+                    if (image is not null && image.IsLocalFile)
+                    {
+                        return image.Path;
+                    }
+
+                    return null;
+                })
+                .Where(i => !string.IsNullOrEmpty(i));
+        }
+
+        protected string CreatePosterCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
+        {
+            return CreateCollage(primaryItem, items, outputPath, 400, 600);
+        }
+
+        protected string CreateSquareCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath)
+        {
+            return CreateCollage(primaryItem, items, outputPath, 600, 600);
+        }
+
+        protected string CreateThumbCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath, int width, int height)
+        {
+            return CreateCollage(primaryItem, items, outputPath, width, height);
+        }
+
+        private string CreateCollage(BaseItem primaryItem, IEnumerable<BaseItem> items, string outputPath, int width, int height)
+        {
+            Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
+
+            var options = new ImageCollageOptions
+            {
+                Height = height,
+                Width = width,
+                OutputPath = outputPath,
+                InputPaths = GetStripCollageImagePaths(primaryItem, items).ToArray()
+            };
+
+            if (options.InputPaths.Count == 0)
+            {
+                return null;
+            }
+
+            if (!ImageProcessor.SupportsImageCollageCreation)
+            {
+                return null;
+            }
+
+            ImageProcessor.CreateImageCollage(options, primaryItem.Name);
+            return outputPath;
+        }
+
+        protected virtual string CreateImage(
+            BaseItem item,
+            IReadOnlyCollection<BaseItem> itemsWithImages,
+            string outputPathWithoutExtension,
+            ImageType imageType,
+            int imageIndex)
+        {
+            if (itemsWithImages.Count == 0)
+            {
+                return null;
+            }
+
+            string outputPath = Path.ChangeExtension(outputPathWithoutExtension, ".png");
+
+            if (imageType == ImageType.Thumb)
+            {
+                return CreateThumbCollage(item, itemsWithImages, outputPath);
+            }
+
+            if (imageType == ImageType.Primary)
+            {
+                if (item is UserView
+                    || item is Playlist
+                    || item is MusicGenre
+                    || item is Genre
+                    || item is PhotoAlbum
+                    || item is MusicArtist)
+                {
+                    return CreateSquareCollage(item, itemsWithImages, outputPath);
+                }
+
+                return CreatePosterCollage(item, itemsWithImages, outputPath);
+            }
+
+            throw new ArgumentException("Unexpected image type", nameof(imageType));
+        }
+
+        public bool HasChanged(BaseItem item, IDirectoryService directoryService)
+        {
+            if (!Supports(item))
+            {
+                return false;
+            }
+
+            if (SupportedImages.Contains(ImageType.Primary) && HasChanged(item, ImageType.Primary))
+            {
+                return true;
+            }
+
+            if (SupportedImages.Contains(ImageType.Thumb) && HasChanged(item, ImageType.Thumb))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        protected bool HasChanged(BaseItem item, ImageType type)
+        {
+            var image = item.GetImageInfo(type, 0);
+
+            if (image is null)
+            {
+                return GetItemsWithImages(item).Count is not 0;
+            }
+
+            if (!image.IsLocalFile)
+            {
+                return false;
+            }
+
+            if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
+            {
+                return false;
+            }
+
+            if (!HasChangedByDate(item, image))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        protected virtual bool HasChangedByDate(BaseItem item, ItemImageInfo image)
+        {
+            var path = image.Path;
+            if (!string.IsNullOrEmpty(path))
+            {
+                var modificationDate = FileSystem.GetLastWriteTimeUtc(path);
+                return image.DateModified != modificationDate;
+            }
+
+            return false;
+        }
+
+        protected string CreateSingleImage(IEnumerable<BaseItem> itemsWithImages, string outputPathWithoutExtension, ImageType imageType)
+        {
+            var image = itemsWithImages
+                .Where(i => i.HasImage(imageType) && i.GetImageInfo(imageType, 0).IsLocalFile && Path.HasExtension(i.GetImagePath(imageType)))
+                .Select(i => i.GetImagePath(imageType))
+                .FirstOrDefault();
+
+            if (string.IsNullOrEmpty(image))
+            {
+                return null;
+            }
+
+            var ext = Path.GetExtension(image);
+
+            var outputPath = Path.ChangeExtension(outputPathWithoutExtension, ext);
+            File.Copy(image, outputPath, true);
+
+            return outputPath;
+        }
+    }
+}

Emby.Server.Implementations/Images/BaseFolderImageProvider.cs

@@ -0,0 +1,66 @@
+#pragma warning disable CS1591
+
+using System.Collections.Generic;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Images
+{
+    public abstract class BaseFolderImageProvider<T> : BaseDynamicImageProvider<T>
+        where T : Folder, new()
+    {
+        private readonly ILibraryManager _libraryManager;
+
+        protected BaseFolderImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, ILibraryManager libraryManager)
+            : base(fileSystem, providerManager, applicationPaths, imageProcessor)
+        {
+            _libraryManager = libraryManager;
+        }
+
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            return _libraryManager.GetItemList(new InternalItemsQuery
+            {
+                Parent = item,
+                Recursive = true,
+                DtoOptions = new DtoOptions(true),
+                ImageTypes = [ImageType.Primary],
+                OrderBy =
+                [
+                    (ItemSortBy.IsFolder, SortOrder.Ascending),
+                    (ItemSortBy.SortName, SortOrder.Ascending)
+                ],
+                Limit = 1
+            });
+        }
+
+        protected override string CreateImage(BaseItem item, IReadOnlyCollection<BaseItem> itemsWithImages, string outputPathWithoutExtension, ImageType imageType, int imageIndex)
+        {
+            return CreateSingleImage(itemsWithImages, outputPathWithoutExtension, ImageType.Primary);
+        }
+
+        protected override bool Supports(BaseItem item)
+        {
+            return item is T;
+        }
+
+        protected override bool HasChangedByDate(BaseItem item, ItemImageInfo image)
+        {
+            if (item is MusicAlbum)
+            {
+                return false;
+            }
+
+            return base.HasChangedByDate(item, image);
+        }
+    }
+}

Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs

@@ -0,0 +1,108 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Querying;
+
+namespace Emby.Server.Implementations.Images
+{
+    public class CollectionFolderImageProvider : BaseDynamicImageProvider<CollectionFolder>
+    {
+        public CollectionFolderImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor) : base(fileSystem, providerManager, applicationPaths, imageProcessor)
+        {
+        }
+
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            var view = (CollectionFolder)item;
+            var viewType = view.CollectionType;
+
+            BaseItemKind[] includeItemTypes;
+
+            switch (viewType)
+            {
+                case CollectionType.movies:
+                    includeItemTypes = new[] { BaseItemKind.Movie };
+                    break;
+                case CollectionType.tvshows:
+                    includeItemTypes = new[] { BaseItemKind.Series };
+                    break;
+                case CollectionType.music:
+                    includeItemTypes = new[] { BaseItemKind.MusicAlbum };
+                    break;
+                case CollectionType.musicvideos:
+                    includeItemTypes = new[] { BaseItemKind.MusicVideo };
+                    break;
+                case CollectionType.books:
+                    includeItemTypes = new[] { BaseItemKind.Book, BaseItemKind.AudioBook };
+                    break;
+                case CollectionType.boxsets:
+                    includeItemTypes = new[] { BaseItemKind.BoxSet };
+                    break;
+                case CollectionType.homevideos:
+                case CollectionType.photos:
+                    includeItemTypes = new[] { BaseItemKind.Video, BaseItemKind.Photo };
+                    break;
+                default:
+                    includeItemTypes = new[] { BaseItemKind.Video, BaseItemKind.Audio, BaseItemKind.Photo, BaseItemKind.Movie, BaseItemKind.Series };
+                    break;
+            }
+
+            var recursive = viewType != CollectionType.playlists;
+
+            return view.GetItemList(new InternalItemsQuery
+            {
+                CollapseBoxSetItems = false,
+                Recursive = recursive,
+                DtoOptions = new DtoOptions(false),
+                ImageTypes = new[] { ImageType.Primary },
+                Limit = 8,
+                OrderBy = new[]
+                {
+                    (ItemSortBy.Random, SortOrder.Ascending)
+                },
+                IncludeItemTypes = includeItemTypes
+            });
+        }
+
+        protected override bool Supports(BaseItem item)
+        {
+            return item is CollectionFolder;
+        }
+
+        protected override string CreateImage(BaseItem item, IReadOnlyCollection<BaseItem> itemsWithImages, string outputPathWithoutExtension, ImageType imageType, int imageIndex)
+        {
+            var outputPath = Path.ChangeExtension(outputPathWithoutExtension, ".png");
+
+            if (imageType == ImageType.Primary)
+            {
+                if (itemsWithImages.Count == 0)
+                {
+                    return null;
+                }
+
+                return CreateThumbCollage(item, itemsWithImages, outputPath, 960, 540);
+            }
+
+            return base.CreateImage(item, itemsWithImages, outputPath, imageType, imageIndex);
+        }
+
+        protected override bool HasChangedByDate(BaseItem item, ItemImageInfo image)
+        {
+            var age = DateTime.UtcNow - image.DateModified;
+            return age.TotalDays > 7;
+        }
+    }
+}

Emby.Server.Implementations/Images/DynamicImageProvider.cs

@@ -0,0 +1,137 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Images
+{
+    public class DynamicImageProvider : BaseDynamicImageProvider<UserView>
+    {
+        private readonly IUserManager _userManager;
+
+        public DynamicImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, IUserManager userManager)
+            : base(fileSystem, providerManager, applicationPaths, imageProcessor)
+        {
+            _userManager = userManager;
+        }
+
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            var view = (UserView)item;
+
+            var isUsingCollectionStrip = IsUsingCollectionStrip(view);
+            var recursive = isUsingCollectionStrip && view?.ViewType is not null && view.ViewType != CollectionType.boxsets && view.ViewType != CollectionType.playlists;
+
+            var result = view.GetItemList(new InternalItemsQuery
+            {
+                User = view.UserId.HasValue ? _userManager.GetUserById(view.UserId.Value) : null,
+                CollapseBoxSetItems = false,
+                Recursive = recursive,
+                ExcludeItemTypes = new[] { BaseItemKind.UserView, BaseItemKind.CollectionFolder, BaseItemKind.Person },
+                DtoOptions = new DtoOptions(false)
+            });
+
+            var items = result.Select(i =>
+            {
+                if (i is Episode episode)
+                {
+                    var series = episode.Series;
+                    if (series is not null)
+                    {
+                        return series;
+                    }
+
+                    return episode;
+                }
+
+                if (i is Season season)
+                {
+                    var series = season.Series;
+                    if (series is not null)
+                    {
+                        return series;
+                    }
+
+                    return season;
+                }
+
+                if (i is Audio audio)
+                {
+                    var album = audio.AlbumEntity;
+                    if (album is not null && album.HasImage(ImageType.Primary))
+                    {
+                        return album;
+                    }
+                }
+
+                return i;
+            }).DistinctBy(x => x.Id);
+
+            List<BaseItem> returnItems;
+            if (isUsingCollectionStrip)
+            {
+                returnItems = items
+                    .Where(i => i.HasImage(ImageType.Primary) || i.HasImage(ImageType.Thumb))
+                    .ToList();
+                returnItems.Shuffle();
+                return returnItems;
+            }
+
+            returnItems = items
+                .Where(i => i.HasImage(ImageType.Primary))
+                .ToList();
+            returnItems.Shuffle();
+            return returnItems;
+        }
+
+        protected override bool Supports(BaseItem item)
+        {
+            if (item is UserView view)
+            {
+                return IsUsingCollectionStrip(view);
+            }
+
+            return false;
+        }
+
+        private static bool IsUsingCollectionStrip(UserView view)
+        {
+            CollectionType[] collectionStripViewTypes =
+            {
+                CollectionType.movies,
+                CollectionType.tvshows,
+                CollectionType.playlists
+            };
+
+            return view?.ViewType is not null && collectionStripViewTypes.Contains(view.ViewType.Value);
+        }
+
+        protected override string CreateImage(BaseItem item, IReadOnlyCollection<BaseItem> itemsWithImages, string outputPathWithoutExtension, ImageType imageType, int imageIndex)
+        {
+            if (itemsWithImages.Count == 0)
+            {
+                return null;
+            }
+
+            var outputPath = Path.ChangeExtension(outputPathWithoutExtension, ".png");
+
+            return CreateThumbCollage(item, itemsWithImages, outputPath, 960, 540);
+        }
+    }
+}

Emby.Server.Implementations/Images/FolderImageProvider.cs

@@ -0,0 +1,35 @@
+#pragma warning disable CS1591
+
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Images
+{
+    public class FolderImageProvider : BaseFolderImageProvider<Folder>
+    {
+        public FolderImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, ILibraryManager libraryManager)
+            : base(fileSystem, providerManager, applicationPaths, imageProcessor, libraryManager)
+        {
+        }
+
+        protected override bool Supports(BaseItem item)
+        {
+            if (item is PhotoAlbum || item is MusicAlbum)
+            {
+                return false;
+            }
+
+            if (item is Folder && item.IsTopParent)
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

Emby.Server.Implementations/Images/GenreImageProvider.cs

@@ -0,0 +1,52 @@
+#pragma warning disable CS1591
+
+using System.Collections.Generic;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Querying;
+
+namespace Emby.Server.Implementations.Images
+{
+    /// <summary>
+    /// Class GenreImageProvider.
+    /// </summary>
+    public class GenreImageProvider : BaseDynamicImageProvider<Genre>
+    {
+        /// <summary>
+        /// The library manager.
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+
+        public GenreImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, ILibraryManager libraryManager) : base(fileSystem, providerManager, applicationPaths, imageProcessor)
+        {
+            _libraryManager = libraryManager;
+        }
+
+        /// <summary>
+        /// Get children objects used to create an genre image.
+        /// </summary>
+        /// <param name="item">The genre used to create the image.</param>
+        /// <returns>Any relevant children objects.</returns>
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            return _libraryManager.GetItemList(new InternalItemsQuery
+            {
+                Genres = new[] { item.Name },
+                IncludeItemTypes = new[] { BaseItemKind.Series, BaseItemKind.Movie },
+                OrderBy = new[] { (ItemSortBy.Random, SortOrder.Ascending) },
+                Limit = 4,
+                Recursive = true,
+                ImageTypes = new[] { ImageType.Primary },
+                DtoOptions = new DtoOptions(false)
+            });
+        }
+    }
+}

Emby.Server.Implementations/Images/MusicAlbumImageProvider.cs

@@ -0,0 +1,30 @@
+#pragma warning disable CS1591
+
+using System.Collections.Generic;
+using System.Linq;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Images
+{
+    public class MusicAlbumImageProvider : BaseFolderImageProvider<MusicAlbum>
+    {
+        public MusicAlbumImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, ILibraryManager libraryManager)
+            : base(fileSystem, providerManager, applicationPaths, imageProcessor, libraryManager)
+        {
+        }
+
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            var items = base.GetItemsWithImages(item);
+
+            // Ignore any folders because they can have generated collages
+            return items.Where(i => i is not Folder).ToList();
+        }
+    }
+}

Emby.Server.Implementations/Images/MusicGenreImageProvider.cs

@@ -0,0 +1,60 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System.Collections.Generic;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Querying;
+
+namespace Emby.Server.Implementations.Images
+{
+    /// <summary>
+    /// Class MusicGenreImageProvider.
+    /// </summary>
+    public class MusicGenreImageProvider : BaseDynamicImageProvider<MusicGenre>
+    {
+        /// <summary>
+        /// The library manager.
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+
+        public MusicGenreImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, ILibraryManager libraryManager) : base(fileSystem, providerManager, applicationPaths, imageProcessor)
+        {
+            _libraryManager = libraryManager;
+        }
+
+        /// <summary>
+        /// Get children objects used to create an music genre image.
+        /// </summary>
+        /// <param name="item">The music genre used to create the image.</param>
+        /// <returns>Any relevant children objects.</returns>
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            return _libraryManager.GetItemList(new InternalItemsQuery
+            {
+                Genres = new[] { item.Name },
+                IncludeItemTypes = new[]
+                {
+                    BaseItemKind.MusicAlbum,
+                    BaseItemKind.MusicVideo,
+                    BaseItemKind.Audio
+                },
+                OrderBy = new[] { (ItemSortBy.Random, SortOrder.Ascending) },
+                Limit = 4,
+                Recursive = true,
+                ImageTypes = new[] { ImageType.Primary },
+                DtoOptions = new DtoOptions(false)
+            });
+        }
+    }
+}

Emby.Server.Implementations/Images/PhotoAlbumImageProvider.cs

@@ -0,0 +1,19 @@
+#pragma warning disable CS1591
+
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Images
+{
+    public class PhotoAlbumImageProvider : BaseFolderImageProvider<PhotoAlbum>
+    {
+        public PhotoAlbumImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor, ILibraryManager libraryManager)
+            : base(fileSystem, providerManager, applicationPaths, imageProcessor, libraryManager)
+        {
+        }
+    }
+}

Emby.Server.Implementations/Images/PlaylistImageProvider.cs

@@ -0,0 +1,65 @@
+#nullable disable
+
+#pragma warning disable CS1591
+
+using System.Collections.Generic;
+using System.Linq;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Playlists;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Images
+{
+    public class PlaylistImageProvider : BaseDynamicImageProvider<Playlist>
+    {
+        public PlaylistImageProvider(IFileSystem fileSystem, IProviderManager providerManager, IApplicationPaths applicationPaths, IImageProcessor imageProcessor) : base(fileSystem, providerManager, applicationPaths, imageProcessor)
+        {
+        }
+
+        protected override IReadOnlyList<BaseItem> GetItemsWithImages(BaseItem item)
+        {
+            var playlist = (Playlist)item;
+
+            return playlist.GetManageableItems()
+                .Select(i =>
+                {
+                    var subItem = i.Item2;
+
+                    if (subItem is Episode episode)
+                    {
+                        var series = episode.Series;
+                        if (series is not null && series.HasImage(ImageType.Primary))
+                        {
+                            return series;
+                        }
+                    }
+
+                    if (subItem.HasImage(ImageType.Primary))
+                    {
+                        return subItem;
+                    }
+
+                    var parent = subItem.GetOwner() ?? subItem.GetParent();
+
+                    if (parent is not null && parent.HasImage(ImageType.Primary))
+                    {
+                        if (parent is MusicAlbum)
+                        {
+                            return parent;
+                        }
+                    }
+
+                    return null;
+                })
+                .Where(i => i is not null)
+                .DistinctBy(x => x.Id)
+                .ToList();
+        }
+    }
+}

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);
+    }
+}

Emby.Server.Implementations/Localization/Core/ab.json

@@ -0,0 +1,3 @@
+{
+    "Albums": "аальбомқәа"
+}

Emby.Server.Implementations/Localization/Core/af.json

@@ -0,0 +1,139 @@
+{
+    "Artists": "Kunstenare",
+    "Channels": "Kanale",
+    "Folders": "Lêergidse",
+    "Favorites": "Gunstelinge",
+    "HeaderFavoriteShows": "Gunsteling Vertonings",
+    "ValueSpecialEpisodeName": "Spesiale - {0}",
+    "HeaderAlbumArtists": "Album kunstenaars",
+    "Books": "Boeke",
+    "HeaderNextUp": "Volgende",
+    "Movies": "Flieks",
+    "Shows": "Televisie Reekse",
+    "HeaderContinueWatching": "Hou aan kyk",
+    "HeaderFavoriteEpisodes": "Gunsteling Episodes",
+    "Photos": "Foto's",
+    "Playlists": "Snitlyste",
+    "HeaderFavoriteArtists": "Gunsteling Kunstenaars",
+    "HeaderFavoriteAlbums": "Gunsteling Albums",
+    "Sync": "Sinkroniseer",
+    "HeaderFavoriteSongs": "Gunsteling Liedjies",
+    "Songs": "Liedjies",
+    "DeviceOnlineWithName": "{0} is aanlyn",
+    "DeviceOfflineWithName": "{0} is ontkoppel",
+    "Collections": "Versamelings",
+    "Inherit": "Ontvang",
+    "HeaderLiveTV": "Lewendige TV",
+    "Application": "Program",
+    "AppDeviceValues": "App: {0}, Toestel: {1}",
+    "VersionNumber": "Weergawe {0}",
+    "ValueHasBeenAddedToLibrary": "{0} is by jou media biblioteek bygevoeg",
+    "UserStoppedPlayingItemWithValues": "{0} het klaar {1} op {2} gespeel",
+    "UserStartedPlayingItemWithValues": "{0} is besig om {1} op {2} te speel",
+    "UserPolicyUpdatedWithName": "Gebruiker beleid is verander vir {0}",
+    "UserPasswordChangedWithName": "Gebruiker {0} se wagwoord is verander",
+    "UserOnlineFromDevice": "{0} is aanlyn van {1}",
+    "UserOfflineFromDevice": "{0} is ontkoppel van {1}",
+    "UserLockedOutWithName": "Gebruiker {0} is uitgesluit",
+    "UserDownloadingItemWithValues": "{0} is besig om {1} af te laai",
+    "UserDeletedWithName": "Gebruiker {0} is verwyder",
+    "UserCreatedWithName": "Gebruiker {0} is geskep",
+    "User": "Gebruiker",
+    "TvShows": "TV Programme",
+    "System": "Stelsel",
+    "SubtitleDownloadFailureFromForItem": "Ondertitels het misluk om af te laai van {0} vir {1}",
+    "StartupEmbyServerIsLoading": "Jellyfin Bediener is besig om te laai. Probeer weer in 'n kort tyd.",
+    "ServerNameNeedsToBeRestarted": "{0} moet herbegin word",
+    "ScheduledTaskStartedWithName": "{0} het begin",
+    "ScheduledTaskFailedWithName": "{0} het misluk",
+    "ProviderValue": "Voorsiener: {0}",
+    "PluginUpdatedWithName": "{0} was opgedateer",
+    "PluginUninstalledWithName": "{0} was verwyder",
+    "PluginInstalledWithName": "{0} is geïnstalleer",
+    "Plugin": "Inprop module",
+    "NotificationOptionVideoPlaybackStopped": "Video terugspeel het gestop",
+    "NotificationOptionVideoPlayback": "Video terugspeel het begin",
+    "NotificationOptionUserLockedOut": "Gebruiker uitgeslyt",
+    "NotificationOptionTaskFailed": "Geskeduleerde taak het misluk",
+    "NotificationOptionServerRestartRequired": "Bediener herbegin nodig",
+    "NotificationOptionPluginUpdateInstalled": "Nuwe inprop module geïnstalleer",
+    "NotificationOptionPluginUninstalled": "Inprop module verwyder",
+    "NotificationOptionPluginInstalled": "Inprop module geïnstalleer",
+    "NotificationOptionPluginError": "Inprop module het misluk",
+    "NotificationOptionNewLibraryContent": "Nuwe inhoud bygevoeg",
+    "NotificationOptionInstallationFailed": "Installasie mislukking",
+    "NotificationOptionCameraImageUploaded": "Kamera foto is opgelaai",
+    "NotificationOptionAudioPlaybackStopped": "Oudio terugspeel het gestop",
+    "NotificationOptionAudioPlayback": "Oudio terugspeel het begin",
+    "NotificationOptionApplicationUpdateInstalled": "Nuwe program weergawe geïnstalleer",
+    "NotificationOptionApplicationUpdateAvailable": "Nuwe program weergawe beskikbaar",
+    "NewVersionIsAvailable": "'n Nuwe Jellyfin Bedienaar weergawe kan afgelaai word.",
+    "NameSeasonUnknown": "Seisoen Onbekend",
+    "NameSeasonNumber": "Seisoen {0}",
+    "NameInstallFailed": "{0} installering het misluk",
+    "MusicVideos": "Musiek Videos",
+    "Music": "Musiek",
+    "MixedContent": "Gemengde inhoud",
+    "MessageServerConfigurationUpdated": "Bediener konfigurasie is opgedateer",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Bediener konfigurasie seksie {0} is opgedateer",
+    "MessageApplicationUpdatedTo": "Jellyfin Bediener is opgedateer na {0}",
+    "MessageApplicationUpdated": "Jellyfin Bediener is opgedateer",
+    "Latest": "Nuutste",
+    "LabelRunningTimeValue": "Werktyd: {0}",
+    "LabelIpAddressValue": "IP adres: {0}",
+    "ItemRemovedWithName": "{0} is uit versameling verwyder",
+    "ItemAddedWithName": "{0} is by die versameling gevoeg",
+    "HomeVideos": "Tuis Videos",
+    "HeaderRecordingGroups": "Groep Opnames",
+    "Genres": "Genres",
+    "FailedLoginAttemptWithUserName": "Mislukte aanmeldpoging van {0}",
+    "ChapterNameValue": "Hoofstuk {0}",
+    "CameraImageUploadedFrom": "'n Nuwe kamera foto is opgelaai vanaf {0}",
+    "AuthenticationSucceededWithUserName": "{0} suksesvol geverifieer",
+    "Albums": "Albums",
+    "TasksChannelsCategory": "Internet kanale",
+    "TasksApplicationCategory": "aansoek",
+    "TasksLibraryCategory": "biblioteek",
+    "TasksMaintenanceCategory": "onderhoud",
+    "TaskCleanCacheDescription": "Vee kasregister lêers uit wat nie meer deur die stelsel benodig word nie.",
+    "TaskCleanCache": "Reinig Kasgeheue Lêergids",
+    "TaskDownloadMissingSubtitlesDescription": "Soek aanlyn vir vermiste onderskrifte gebasseer op metadata verstellings.",
+    "TaskDownloadMissingSubtitles": "Laai vermiste onderskrifte af",
+    "TaskRefreshChannelsDescription": "Vervris internet kanaal inligting.",
+    "TaskRefreshChannels": "Vervris Kanale",
+    "TaskCleanTranscodeDescription": "Vee transkodering lêers uit wat ouer is as een dag.",
+    "TaskCleanTranscode": "Reinig Transkoderings Leêrbinder",
+    "TaskUpdatePluginsDescription": "Laai opgedateerde inprop-sagteware af en installeer inprop-sagteware wat verstel is om outomaties op te dateer.",
+    "TaskUpdatePlugins": "Dateer Inprop-Sagteware Op",
+    "TaskRefreshPeopleDescription": "Vervris metadata oor akteurs en regisseurs in u media versameling.",
+    "TaskRefreshPeople": "Vervris Mense",
+    "TaskCleanLogsDescription": "Vee loglêers wat ouer as {0} dae is uit.",
+    "TaskCleanLogs": "Reinig Loglêer Lêervouer",
+    "TaskRefreshLibraryDescription": "Skandeer u media versameling vir nuwe lêers en verfris metadata.",
+    "TaskRefreshLibrary": "Skandeer Media Versameling",
+    "TaskRefreshChapterImagesDescription": "Maak kleinkiekeis (fotos) vir films wat hoofstukke het.",
+    "TaskRefreshChapterImages": "Verkry Hoofstuk Beelde",
+    "Undefined": "Ongedefineerd",
+    "Forced": "Geforseerd",
+    "Default": "Standaard",
+    "TaskCleanActivityLogDescription": "Verwyder aktiwiteitsaantekeninge ouer as die opgestelde ouderdom.",
+    "TaskCleanActivityLog": "Maak Aktiwiteitsaantekeninge Skoon",
+    "TaskOptimizeDatabaseDescription": "Komprimeer databasis en verkort vrye ruimte. As hierdie taak uitgevoer word nadat die media versameling geskandeer is of ander veranderings aangebring is wat databasisaanpassings impliseer, kan dit die prestasie verbeter.",
+    "TaskOptimizeDatabase": "Optimaliseer databasis",
+    "TaskKeyframeExtractorDescription": "Haal keyframes vanuit video lêers om meer presiese HLS afspeellyste te maak. Dit kan lank duur.",
+    "TaskKeyframeExtractor": "Keyframe Ekstraktor",
+    "External": "Ekstern",
+    "HearingImpaired": "gehoorgestremd",
+    "TaskRefreshTrickplayImages": "Genereer Fopspeel Beelde",
+    "TaskRefreshTrickplayImagesDescription": "Skep fopspeel voorskou vir videos in aangeskakelde media versameling.",
+    "TaskAudioNormalizationDescription": "Skandeer lêers vir oudio-normaliseringsdata.",
+    "TaskAudioNormalization": "Odio Normalisering",
+    "TaskCleanCollectionsAndPlaylists": "Maak versamelings en snitlyste skoon",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Verwyder items uit versamelings en snitlyste wat nie meer bestaan nie.",
+    "TaskDownloadMissingLyrics": "Laai tekorte lirieke af",
+    "TaskDownloadMissingLyricsDescription": "Laai lirieke af vir liedjies",
+    "TaskExtractMediaSegments": "Media Segment Skandeer",
+    "TaskExtractMediaSegmentsDescription": "Onttrek of verkry mediasegmente van MediaSegment-geaktiveerde inproppe.",
+    "TaskMoveTrickplayImages": "Migreer Trickplay Beeldligging",
+    "TaskMoveTrickplayImagesDescription": "Skuif ontstaande trickplay lêers volgens die biblioteekinstellings."
+}

Emby.Server.Implementations/Localization/Core/ar.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "ألبومات",
+    "AppDeviceValues": "تطبيق: {0}, جهاز: {1}",
+    "Application": "تطبيق",
+    "Artists": "فنانون",
+    "AuthenticationSucceededWithUserName": "نجحت عملية التوثيق بـ {0}",
+    "Books": "الكتب",
+    "CameraImageUploadedFrom": "رُفعت صورة الكاميرا الجديدة من {0}",
+    "Channels": "القنوات",
+    "ChapterNameValue": "الفصل {0}",
+    "Collections": "مجموعات",
+    "DeviceOfflineWithName": "قُطِع الاتصال ب{0}",
+    "DeviceOnlineWithName": "{0} متصل",
+    "FailedLoginAttemptWithUserName": "محاولة تسجيل الدخول فاشلة من {0}",
+    "Favorites": "المفضلة",
+    "Folders": "المجلدات",
+    "Genres": "التصنيفات",
+    "HeaderAlbumArtists": "فناني الألبوم",
+    "HeaderContinueWatching": "متابعة المشاهدة",
+    "HeaderFavoriteAlbums": "الألبومات المفضلة",
+    "HeaderFavoriteArtists": "الفنانون المفضلون",
+    "HeaderFavoriteEpisodes": "الحلقات المفضلة",
+    "HeaderFavoriteShows": "المسلسلات المفضلة",
+    "HeaderFavoriteSongs": "الأغاني المفضلة",
+    "HeaderLiveTV": "التلفاز المباشر",
+    "HeaderNextUp": "التالي",
+    "HeaderRecordingGroups": "مجموعات التسجيل",
+    "HomeVideos": "الفيديوهات الشخصية",
+    "Inherit": "توريث",
+    "ItemAddedWithName": "أُضيف {0} للمكتبة",
+    "ItemRemovedWithName": "أُزيل {0} من المكتبة",
+    "LabelIpAddressValue": "عنوان الآي بي: {0}",
+    "LabelRunningTimeValue": "مدة التشغيل: {0}",
+    "Latest": "الأحدث",
+    "MessageApplicationUpdated": "حُدث خادم Jellyfin",
+    "MessageApplicationUpdatedTo": "حُدث خادم Jellyfin إلى {0}",
+    "MessageNamedServerConfigurationUpdatedWithValue": "حُدثت إعدادات الخادم في قسم {0}",
+    "MessageServerConfigurationUpdated": "حُدثت إعدادات الخادم",
+    "MixedContent": "محتوى مختلط",
+    "Movies": "الأفلام",
+    "Music": "الموسيقى",
+    "MusicVideos": "الفيديوهات الموسيقية",
+    "NameInstallFailed": "فشل تثبيت {0}",
+    "NameSeasonNumber": "الموسم {0}",
+    "NameSeasonUnknown": "الموسم غير معروف",
+    "NewVersionIsAvailable": "نسخة جديدة من خادم Jellyfin متوفرة للتحميل.",
+    "NotificationOptionApplicationUpdateAvailable": "يوجد تحديث للتطبيق",
+    "NotificationOptionApplicationUpdateInstalled": "نُصب تحديث التطبيق",
+    "NotificationOptionAudioPlayback": "بدأ تشغيل المقطع الصوتي",
+    "NotificationOptionAudioPlaybackStopped": "أُوقف تشغيل المقطع الصوتي",
+    "NotificationOptionCameraImageUploaded": "رُفعت صورة الكاميرا",
+    "NotificationOptionInstallationFailed": "فشل في التثبيت",
+    "NotificationOptionNewLibraryContent": "أُضيف محتوى جديدا",
+    "NotificationOptionPluginError": "فشل في الملحق",
+    "NotificationOptionPluginInstalled": "ثُبتت الملحق",
+    "NotificationOptionPluginUninstalled": "تمت إزالة الملحق",
+    "NotificationOptionPluginUpdateInstalled": "تم تثبيت تحديثات الملحق",
+    "NotificationOptionServerRestartRequired": "يجب إعادة تشغيل الخادم",
+    "NotificationOptionTaskFailed": "فشل في المهمة المجدولة",
+    "NotificationOptionUserLockedOut": "تم إقفال حساب المستخدم",
+    "NotificationOptionVideoPlayback": "بدأ تشغيل الفيديو",
+    "NotificationOptionVideoPlaybackStopped": "تم إيقاف تشغيل الفيديو",
+    "Photos": "الصور",
+    "Playlists": "قوائم التشغيل",
+    "Plugin": "الملحق",
+    "PluginInstalledWithName": "تم تثبيت {0}",
+    "PluginUninstalledWithName": "تمت إزالة {0}",
+    "PluginUpdatedWithName": "تم تحديث {0}",
+    "ProviderValue": "المزود: {0}",
+    "ScheduledTaskFailedWithName": "فشلت العملية {0}",
+    "ScheduledTaskStartedWithName": "تم بدء العملية {0}",
+    "ServerNameNeedsToBeRestarted": "يحتاج {0} لإعادة التشغيل",
+    "Shows": "العروض",
+    "Songs": "الأغاني",
+    "StartupEmbyServerIsLoading": "يتم تحميل خادم Jellyfin . الرجاء المحاولة بعد قليل.",
+    "SubtitleDownloadFailureFromForItem": "فشل تحميل الترجمات من {0} ل {1}",
+    "Sync": "مزامنة",
+    "System": "النظام",
+    "TvShows": "البرامج التلفزيونية",
+    "User": "المستخدم",
+    "UserCreatedWithName": "تم إنشاء المستخدم {0}",
+    "UserDeletedWithName": "تم حذف المستخدم {0}",
+    "UserDownloadingItemWithValues": "يقوم {0} بتنزيل {1}",
+    "UserLockedOutWithName": "تم منع المستخدم {0} من الدخول",
+    "UserOfflineFromDevice": "تم قطع اتصال {0} من {1}",
+    "UserOnlineFromDevice": "{0} متصل عبر {1}",
+    "UserPasswordChangedWithName": "تم تغيير كلمة السر للمستخدم {0}",
+    "UserPolicyUpdatedWithName": "تم تحديث سياسة المستخدم {0}",
+    "UserStartedPlayingItemWithValues": "قام {0} ببدء تشغيل {1} على {2}",
+    "UserStoppedPlayingItemWithValues": "قام {0} بإيقاف تشغيل {1} على {2}",
+    "ValueHasBeenAddedToLibrary": "تمت اضافت {0} إلى مكتبة الوسائط",
+    "ValueSpecialEpisodeName": "حلقة خاصه - {0}",
+    "VersionNumber": "الإصدار {0}",
+    "TaskCleanCacheDescription": "يحذف الملفات المؤقتة التي لم يعد النظام بحاجة إليها.",
+    "TaskCleanCache": "حذف الملفات المؤقتة",
+    "TasksChannelsCategory": "قنوات الإنترنت",
+    "TasksLibraryCategory": "مكتبة",
+    "TasksMaintenanceCategory": "صيانة",
+    "TaskRefreshLibraryDescription": "يفحص مكتبة الوسائط الخاصة بك باحثا عن ملفات جديدة، ومن ثم يُحدث البيانات الوصفية.",
+    "TaskRefreshLibrary": "افحص مكتبة الوسائط",
+    "TaskRefreshChapterImagesDescription": "يُنشئ صور مصغرة لمقاطع الفيديو التي تحتوي على فصول.",
+    "TaskRefreshChapterImages": "استخراج صور الفصل",
+    "TasksApplicationCategory": "تطبيق",
+    "TaskDownloadMissingSubtitlesDescription": "يبحث في الإنترنت على الترجمات الناقصة استنادا على البيانات الوصفية.",
+    "TaskDownloadMissingSubtitles": "تحميل الترجمات الناقصة",
+    "TaskRefreshChannelsDescription": "يحدث معلومات قنوات الإنترنت.",
+    "TaskRefreshChannels": "إعادة تحديث القنوات",
+    "TaskCleanTranscodeDescription": "يحذف ملفات الترميز الأقدم من يوم واحد.",
+    "TaskCleanTranscode": "حذف ما بمجلد الترميز",
+    "TaskUpdatePluginsDescription": "تحميل وتثبيت الإضافات التي تم تفعيل التحديث التلقائي لها.",
+    "TaskUpdatePlugins": "تحديث الإضافات",
+    "TaskRefreshPeopleDescription": "يقوم بتحديث البيانات الوصفية للممثلين والمخرجين في مكتبة الوسائط الخاصة بك.",
+    "TaskRefreshPeople": "إعادة تحميل الأشخاص",
+    "TaskCleanLogsDescription": "يحذف السجلات الأقدم من {0} يوم.",
+    "TaskCleanLogs": "حذف مسار السجل",
+    "TaskCleanActivityLogDescription": "يحذف سجل الأنشطة الأقدم من الوقت الذي تم تحديده.",
+    "TaskCleanActivityLog": "حذف سجل الأنشطة",
+    "Default": "افتراضي",
+    "Undefined": "غير معرف",
+    "Forced": "ملحقة",
+    "TaskOptimizeDatabaseDescription": "يضغط قاعدة البيانات ويقتطع المساحة الحرة. تشغيل هذه المهمة بعد فحص المكتبة أو إجراء تغييرات أخرى تتضمن تعديلات في قاعدة البيانات قد تؤدي إلى تحسين الأداء.",
+    "TaskOptimizeDatabase": "تحسين قاعدة البيانات",
+    "TaskKeyframeExtractorDescription": "يستخرج الإطارات الرئيسية من ملفات الفيديو لكي ينشئ قوائم تشغيل بث HTTP المباشر. قد تستمر هذه العملية لوقت طويل.",
+    "TaskKeyframeExtractor": "مستخرج الإطار الرئيسي",
+    "External": "خارجي",
+    "HearingImpaired": "ضعاف السمع",
+    "TaskRefreshTrickplayImages": "توليد صور المعاينة السريعة",
+    "TaskRefreshTrickplayImagesDescription": "يُولّد معاينات تنقل سريع لمقاطع الفيديو ضمن المكتبات المفعّلة.",
+    "TaskCleanCollectionsAndPlaylists": "حذف المجموعات وقوائم التشغيل",
+    "TaskCleanCollectionsAndPlaylistsDescription": "حذف عناصر من المجموعات وقوائم التشغيل التي لم تعد موجودة.",
+    "TaskAudioNormalization": "تسوية الصوت",
+    "TaskAudioNormalizationDescription": "مسح الملفات لتطبيع بيانات الصوت.",
+    "TaskDownloadMissingLyrics": "تنزيل عبارات القصيدة",
+    "TaskDownloadMissingLyricsDescription": "كلمات",
+    "TaskExtractMediaSegments": "فحص مقاطع الوسائط",
+    "TaskExtractMediaSegmentsDescription": "يستخرج مقاطع وسائط من إضافات MediaSegment المُفعّلة.",
+    "TaskMoveTrickplayImages": "تغيير مكان صور المعاينة السريعة",
+    "TaskMoveTrickplayImagesDescription": "تُنقل ملفات التشغيل السريع الحالية بناءً على إعدادات المكتبة.",
+    "CleanupUserDataTask": "مهمة تنظيف بيانات المستخدم",
+    "CleanupUserDataTaskDescription": "مسح جميع بيانات المستخدم (حالة المشاهدة، والحالة المفضلة وما إلى ذلك) من الوسائط التي لم تعد موجودة لمدة 90 يومًا على الأقل."
+}

Emby.Server.Implementations/Localization/Core/as.json

@@ -0,0 +1,43 @@
+{
+    "Albums": "এলবাম",
+    "Application": "আবেদন",
+    "AppDeviceValues": "এপ্‌: {0}, ডিভাইচ: {1}",
+    "Artists": "শিল্পী",
+    "Channels": "চেনেলস",
+    "Default": "ডিফল্ট",
+    "AuthenticationSucceededWithUserName": "{0} সফলভাবে প্রমাণিত",
+    "Books": "পুস্তক",
+    "Movies": "চলচ্চিত্ৰ",
+    "CameraImageUploadedFrom": "একটি নতুন ক্যামেরা চিত্র আপলোড করা হয়েছে {0}",
+    "Collections": "সংগ্রহ",
+    "HeaderFavoriteShows": "প্রিয় শোসমূহ",
+    "Latest": "শেহতীয়া",
+    "MessageApplicationUpdated": "জেলিফিন চাইভাৰ আপডেট কৰা হৈছে",
+    "MixedContent": "মিশ্ৰিত সমগ্ৰতা",
+    "NewVersionIsAvailable": "ডাউনলোড কৰিবলৈ জেলিফিন চাইভাৰৰ এটা নতুন সংস্কৰণ উপলব্ধ আছে.",
+    "NotificationOptionCameraImageUploaded": "কেমেৰাৰ চিত্ৰ আপল'ড কৰা হ'ল",
+    "External": "বাহ্যিক",
+    "Favorites": "পছন্দসই",
+    "Folders": "ফোল্ডাৰ",
+    "Forced": "বলপূর্বক",
+    "Genres": "শ্রেণী",
+    "HeaderAlbumArtists": "অ্যালবাম শিল্পী",
+    "HeaderContinueWatching": "দেখা চালিয়ে যান",
+    "FailedLoginAttemptWithUserName": "লগইন ব্যর্থ চেষ্টা কৰা হৈছে থেকে {0}",
+    "HeaderFavoriteAlbums": "প্রিয় অ্যালবামসমূহ",
+    "HeaderFavoriteArtists": "প্রিয় শিল্পীসমূহ",
+    "HeaderFavoriteEpisodes": "প্রিয় পর্বসমূহ",
+    "HeaderFavoriteSongs": "প্ৰিয় গীত",
+    "HeaderLiveTV": "প্ৰতিবেদন টিভি",
+    "HeaderNextUp": "পৰৱৰ্তী অংশ",
+    "HeaderRecordingGroups": "অলংকৰণ গোষ্ঠীসমূহ",
+    "HearingImpaired": "শ্ৰবণ অক্ষম",
+    "HomeVideos": "ঘৰৰ ভিডিঅ'সমূহ",
+    "Inherit": "উত্তপ্ত কৰা",
+    "MessageServerConfigurationUpdated": "চাইভাৰ কনফিগাৰেশ্যন আপডেট কৰা হৈছে",
+    "NotificationOptionApplicationUpdateAvailable": "অ্যাপ্লিকেশ্যন আপডেট উপলব্ধ",
+    "NotificationOptionApplicationUpdateInstalled": "অ্যাপ্লিকেশ্যন আপডেট ইনষ্টল কৰা হ'ল",
+    "NotificationOptionAudioPlayback": "অডিঅ' প্লেবেক আৰম্ভ হ'ল",
+    "NotificationOptionAudioPlaybackStopped": "অডিঅ' প্লেবেক আঁতৰ হ'ল",
+    "NotificationOptionInstallationFailed": "ইনষ্টলেশ্যন ব্যৰ্থতা"
+}

Emby.Server.Implementations/Localization/Core/be.json

@@ -0,0 +1,141 @@
+{
+    "Sync": "Сінхранізаваць",
+    "Playlists": "Плэй-лісты",
+    "Latest": "Апошняе",
+    "LabelIpAddressValue": "IP-адрас: {0}",
+    "ItemAddedWithName": "{0} дададзены ў бібліятэку",
+    "MessageApplicationUpdated": "Сервер Jellyfin абноўлены",
+    "NotificationOptionApplicationUpdateInstalled": "Абнаўленне праграмы ўсталявана",
+    "PluginInstalledWithName": "{0} быў усталяваны",
+    "UserCreatedWithName": "Карыстальнік {0} быў створаны",
+    "Albums": "Альбомы",
+    "Application": "Праграма",
+    "AuthenticationSucceededWithUserName": "{0} паспяхова аўтарызаваны",
+    "Channels": "Каналы",
+    "ChapterNameValue": "Раздзел {0}",
+    "Collections": "Калекцыі",
+    "Default": "Прадвызначана",
+    "FailedLoginAttemptWithUserName": "Няўдалая спроба ўваходу з {0}",
+    "Folders": "Папкі",
+    "Favorites": "Абранае",
+    "External": "Знешні",
+    "Genres": "Жанры",
+    "HeaderContinueWatching": "Працягнуць прагляд",
+    "HeaderFavoriteAlbums": "Абраныя альбомы",
+    "HeaderFavoriteEpisodes": "Абраныя серыі",
+    "HeaderFavoriteShows": "Абраныя шоу",
+    "HeaderFavoriteSongs": "Абраныя песні",
+    "HeaderLiveTV": "Прамы эфір",
+    "HeaderAlbumArtists": "Выканаўцы альбома",
+    "LabelRunningTimeValue": "Працягласць: {0}",
+    "HomeVideos": "Хатнія відэа",
+    "ItemRemovedWithName": "{0} выдалены з бібліятэкі",
+    "MessageApplicationUpdatedTo": "Сервер Jellyfin абноўлены да версіі {0}",
+    "Movies": "Фільмы",
+    "Music": "Музыка",
+    "MusicVideos": "Музычныя кліпы",
+    "NameInstallFailed": "Усталяванне {0} не атрымалася",
+    "NameSeasonNumber": "Сезон {0}",
+    "NotificationOptionApplicationUpdateAvailable": "Даступна абнаўленне праграмы",
+    "NotificationOptionPluginInstalled": "Плагін усталяваны",
+    "NotificationOptionPluginUpdateInstalled": "Абнаўленне плагіна ўсталявана",
+    "NotificationOptionServerRestartRequired": "Патрабуецца перазапуск сервера",
+    "Photos": "Фотаздымкі",
+    "Plugin": "Плагін",
+    "PluginUninstalledWithName": "{0} быў выдалены",
+    "PluginUpdatedWithName": "{0} быў абноўлены",
+    "ProviderValue": "Пастаўшчык: {0}",
+    "Songs": "Песні",
+    "System": "Сістэма",
+    "User": "Карыстальнік",
+    "UserDeletedWithName": "Карыстальнік {0} быў выдалены",
+    "UserDownloadingItemWithValues": "{0} спампоўваецца {1}",
+    "TaskOptimizeDatabase": "Аптымізацыя базы даных",
+    "Artists": "Выканаўцы",
+    "UserOfflineFromDevice": "{0} адлучыўся ад {1}",
+    "UserPolicyUpdatedWithName": "Палітыка карыстальніка абноўлена для {0}",
+    "TaskCleanActivityLogDescription": "Выдаляе запісы старэйшыя за зададзены ўзрост ў журнале актыўнасці.",
+    "TaskRefreshChapterImagesDescription": "Стварае мініяцюры для відэа, якія маюць раздзелы.",
+    "TaskCleanLogsDescription": "Выдаляе файлы журналу, якім больш за {0} дзён.",
+    "TaskUpdatePluginsDescription": "Спампоўвае і ўсталёўвае абнаўленні для плагінаў, якія сканфігураваныя на аўтаматычнае абнаўленне.",
+    "TaskRefreshChannelsDescription": "Абнаўляе інфармацыю аб інтэрнэт-канале.",
+    "TaskDownloadMissingSubtitlesDescription": "Шукае ў інтэрнэце адсутныя субцітры на аснове канфігурацыі метаданых.",
+    "TaskOptimizeDatabaseDescription": "Сціскае базу даных і вызваляе вольную прастору. Выкананне гэтай задачы пасля сканіравання бібліятэкі або іншых змяненняў, якія мадыфікуюць базу даных, можа палепшыць прадукцыйнасць.",
+    "TaskKeyframeExtractor": "Экстрактар ключавых кадраў",
+    "TasksApplicationCategory": "Праграма",
+    "AppDeviceValues": "Праграма: {0}, Прылада: {1}",
+    "Books": "Кнігі",
+    "CameraImageUploadedFrom": "Новая выява камеры была загружана з {0}",
+    "DeviceOfflineWithName": "{0} адлучыўся",
+    "DeviceOnlineWithName": "{0} падлучаны",
+    "Forced": "Прымусова",
+    "HeaderRecordingGroups": "Групы запісаў",
+    "HeaderNextUp": "Наступнае",
+    "HeaderFavoriteArtists": "Абраныя выканаўцы",
+    "HearingImpaired": "Са слабым слыхам",
+    "Inherit": "Атрымаць у спадчыну",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Канфігурацыя сервера (секцыя {0}) абноўлена",
+    "MessageServerConfigurationUpdated": "Канфігурацыя сервера абноўлена",
+    "MixedContent": "Змешаны змест",
+    "NameSeasonUnknown": "Невядомы сезон",
+    "NotificationOptionInstallationFailed": "Збой усталёўкі",
+    "NewVersionIsAvailable": "Новая версія сервера Jellyfin даступная для cпампоўкі.",
+    "NotificationOptionCameraImageUploaded": "Выява камеры запампавана",
+    "NotificationOptionAudioPlaybackStopped": "Прайграванне аўдыя спынена",
+    "NotificationOptionAudioPlayback": "Прайграванне аўдыя пачалося",
+    "NotificationOptionNewLibraryContent": "Дададзены новы кантэнт",
+    "NotificationOptionPluginError": "Збой плагіна",
+    "NotificationOptionPluginUninstalled": "Плагін выдалены",
+    "NotificationOptionTaskFailed": "Збой запланаванага задання",
+    "NotificationOptionUserLockedOut": "Карыстальнік заблакіраваны",
+    "NotificationOptionVideoPlayback": "Пачалося прайграванне відэа",
+    "NotificationOptionVideoPlaybackStopped": "Прайграванне відэа спынена",
+    "ScheduledTaskFailedWithName": "{0} не атрымалася",
+    "ScheduledTaskStartedWithName": "{0} пачалося",
+    "ServerNameNeedsToBeRestarted": "{0} патрабуе перазапуску",
+    "Shows": "Шоу",
+    "StartupEmbyServerIsLoading": "Jellyfin Server загружаецца. Калі ласка, паўтарыце спробу крыху пазней.",
+    "SubtitleDownloadFailureFromForItem": "Субцітры для {1} не ўдалося спампаваць з {0}",
+    "TvShows": "Тэлепраграма",
+    "Undefined": "Нявызначана",
+    "UserLockedOutWithName": "Карыстальнік {0} быў заблакіраваны",
+    "UserOnlineFromDevice": "{0} падключаны з {1}",
+    "UserPasswordChangedWithName": "Пароль быў зменены для карыстальніка {0}",
+    "UserStartedPlayingItemWithValues": "{0} прайграваецца {1} на {2}",
+    "UserStoppedPlayingItemWithValues": "{0} скончыў прайграванне {1} на {2}",
+    "ValueHasBeenAddedToLibrary": "{0} быў дададзены ў вашу медыятэку",
+    "ValueSpecialEpisodeName": "Спецвыпуск - {0}",
+    "VersionNumber": "Версія {0}",
+    "TasksMaintenanceCategory": "Абслугоўванне",
+    "TasksLibraryCategory": "Бібліятэка",
+    "TasksChannelsCategory": "Інтэрнэт-каналы",
+    "TaskCleanActivityLog": "Ачысціць журнал актыўнасці",
+    "TaskCleanCache": "Ачысціць кэш",
+    "TaskCleanCacheDescription": "Выдаляе файлы кэша, якія больш не патрэбныя сістэме.",
+    "TaskRefreshChapterImages": "Вынуць выявы раздзелаў",
+    "TaskRefreshLibrary": "Сканаваць бібліятэку",
+    "TaskRefreshLibraryDescription": "Сканіруе вашу медыятэку на наяўнасць новых файлаў і абнаўляе метаданыя.",
+    "TaskCleanLogs": "Ачысціць журнал",
+    "TaskRefreshPeople": "Абнавіць выканаўцаў",
+    "TaskRefreshPeopleDescription": "Абнаўленне метаданых для акцёраў і рэжысёраў у вашай медыятэцы.",
+    "TaskUpdatePlugins": "Абнавіць плагіны",
+    "TaskCleanTranscode": "Ачысціць каталог перакадзіравання",
+    "TaskCleanTranscodeDescription": "Выдаляе перакадзіраваныя файлы, старэйшыя за адзін дзень.",
+    "TaskRefreshChannels": "Абнавіць каналы",
+    "TaskDownloadMissingSubtitles": "Спампаваць адсутныя субцітры",
+    "TaskKeyframeExtractorDescription": "Выдае ключавыя кадры з відэафайлаў для стварэння больш дакладных плэй-лістоў HLS. Гэта задача можа працягнуцца шмат часу.",
+    "TaskRefreshTrickplayImages": "Стварыць выявы Trickplay",
+    "TaskRefreshTrickplayImagesDescription": "Стварае перадпрагляды відэаролікаў для Trickplay у падключаных бібліятэках.",
+    "TaskCleanCollectionsAndPlaylists": "Ачысціце калекцыі і плэй-лісты",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Выдаляе элементы з калекцый і плэй-лістоў, якія больш не існуюць.",
+    "TaskAudioNormalizationDescription": "Скануе файлы на прадмет нармалізацыі гуку.",
+    "TaskAudioNormalization": "Нармалізацыя гуку",
+    "TaskExtractMediaSegmentsDescription": "Выдае або атрымлівае медыясегменты з убудоў з падтрымкай MediaSegment.",
+    "TaskMoveTrickplayImagesDescription": "Перамяшчае існуючыя файлы trickplay у адпаведнасці з наладамі бібліятэкі.",
+    "TaskDownloadMissingLyrics": "Спампаваць адсутныя тэксты песняў",
+    "TaskDownloadMissingLyricsDescription": "Спампоўвае тэксты для песняў",
+    "TaskExtractMediaSegments": "Сканіраванне медыя-сегмента",
+    "TaskMoveTrickplayImages": "Перанесці месцазнаходжанне выявы Trickplay",
+    "CleanupUserDataTask": "Задача па ачыстцы даных карыстальніка",
+    "CleanupUserDataTaskDescription": "Ачышчае ўсе даныя карыстальніка (стан прагляду, абранае і г.д.) для медыяфайлаў, што адсутнічаюць больш за 90 дзён."
+}

Emby.Server.Implementations/Localization/Core/bg-BG.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "Албуми",
+    "AppDeviceValues": "Програма: {0}, Устройство: {1}",
+    "Application": "Програма",
+    "Artists": "Артисти",
+    "AuthenticationSucceededWithUserName": "{0} се удостовери успешно",
+    "Books": "Книги",
+    "CameraImageUploadedFrom": "Нова снимка от камера беше качена от {0}",
+    "Channels": "Канали",
+    "ChapterNameValue": "Глава {0}",
+    "Collections": "Колекции",
+    "DeviceOfflineWithName": "{0} се разкачи",
+    "DeviceOnlineWithName": "{0} е свързан",
+    "FailedLoginAttemptWithUserName": "Неуспешен опит за влизане от {0}",
+    "Favorites": "Любими",
+    "Folders": "Папки",
+    "Genres": "Жанрове",
+    "HeaderAlbumArtists": "Изпълнители на албуми",
+    "HeaderContinueWatching": "Продължаване на гледането",
+    "HeaderFavoriteAlbums": "Любими албуми",
+    "HeaderFavoriteArtists": "Любими изпълнители",
+    "HeaderFavoriteEpisodes": "Любими епизоди",
+    "HeaderFavoriteShows": "Любими сериали",
+    "HeaderFavoriteSongs": "Любими песни",
+    "HeaderLiveTV": "Телевизия на живо",
+    "HeaderNextUp": "Следва",
+    "HeaderRecordingGroups": "Запис групи",
+    "HomeVideos": "Домашни Клипове",
+    "Inherit": "Наследяване",
+    "ItemAddedWithName": "{0} е добавено към библиотеката",
+    "ItemRemovedWithName": "{0} е премахнато от библиотеката",
+    "LabelIpAddressValue": "IP адрес: {0}",
+    "LabelRunningTimeValue": "Продължителност: {0}",
+    "Latest": "Последни",
+    "MessageApplicationUpdated": "Сървърът беше обновен",
+    "MessageApplicationUpdatedTo": "Сървърът беше обновен до {0}",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Секцията {0} от сървърната конфигурация беше актуализирана",
+    "MessageServerConfigurationUpdated": "Конфигурацията на сървъра беше актуализирана",
+    "MixedContent": "Смесено съдържание",
+    "Movies": "Филми",
+    "Music": "Музика",
+    "MusicVideos": "Музикални Видеа",
+    "NameInstallFailed": "{0} не можа да се инсталира",
+    "NameSeasonNumber": "Сезон {0}",
+    "NameSeasonUnknown": "Неразпознат сезон",
+    "NewVersionIsAvailable": "Нова версия на Джелифин сървъра е достъпна за сваляне.",
+    "NotificationOptionApplicationUpdateAvailable": "Налично е обновление на програмата",
+    "NotificationOptionApplicationUpdateInstalled": "Обновлението на програмата е инсталирано",
+    "NotificationOptionAudioPlayback": "Възпроизвеждането на звук започна",
+    "NotificationOptionAudioPlaybackStopped": "Възпроизвеждането на звук е спряно",
+    "NotificationOptionCameraImageUploaded": "Изображението от фотоапарата е качено",
+    "NotificationOptionInstallationFailed": "Неуспешно инсталиране",
+    "NotificationOptionNewLibraryContent": "Добавено е ново съдържание",
+    "NotificationOptionPluginError": "Грешка в приставка",
+    "NotificationOptionPluginInstalled": "Приставката е инсталирана",
+    "NotificationOptionPluginUninstalled": "Приставката е деинсталирана",
+    "NotificationOptionPluginUpdateInstalled": "Обновлението на приставката е инсталирано",
+    "NotificationOptionServerRestartRequired": "Сървърът трябва да се рестартира",
+    "NotificationOptionTaskFailed": "Грешка в планирана задача",
+    "NotificationOptionUserLockedOut": "Потребителят е заключен",
+    "NotificationOptionVideoPlayback": "Възпроизвеждането на видео започна",
+    "NotificationOptionVideoPlaybackStopped": "Възпроизвеждането на видео е спряно",
+    "Photos": "Снимки",
+    "Playlists": "Списъци",
+    "Plugin": "Добавка",
+    "PluginInstalledWithName": "{0} е инсталиранa",
+    "PluginUninstalledWithName": "{0} е деинсталиранa",
+    "PluginUpdatedWithName": "{0} е обновенa",
+    "ProviderValue": "Доставчик: {0}",
+    "ScheduledTaskFailedWithName": "{0} се провали",
+    "ScheduledTaskStartedWithName": "{0} започна",
+    "ServerNameNeedsToBeRestarted": "{0} трябва да се рестартира",
+    "Shows": "Сериали",
+    "Songs": "Песни",
+    "StartupEmbyServerIsLoading": "Сървърът зарежда. Моля, опитайте отново след малко.",
+    "SubtitleDownloadFailureFromForItem": "Субтитрите за {1} от {0} не можаха да бъдат изтеглени",
+    "Sync": "Синхронизиране",
+    "System": "Система",
+    "TvShows": "Телевизионни сериали",
+    "User": "Потребител",
+    "UserCreatedWithName": "Потребителят {0} е създаден",
+    "UserDeletedWithName": "Потребителят {0} е изтрит",
+    "UserDownloadingItemWithValues": "{0} изтегля {1}",
+    "UserLockedOutWithName": "Потребител {0} се заключи",
+    "UserOfflineFromDevice": "{0} се разкачи от {1}",
+    "UserOnlineFromDevice": "{0} е на линия от {1}",
+    "UserPasswordChangedWithName": "Паролата на потребителя {0} е променена",
+    "UserPolicyUpdatedWithName": "Потребителската политика за {0} се актуализира",
+    "UserStartedPlayingItemWithValues": "{0} пусна {1}",
+    "UserStoppedPlayingItemWithValues": "{0} спря {1}",
+    "ValueHasBeenAddedToLibrary": "{0} беше добавен във Вашата библиотека",
+    "ValueSpecialEpisodeName": "Специални - {0}",
+    "VersionNumber": "Версия {0}",
+    "TaskDownloadMissingSubtitlesDescription": "Търси Интернет за липсващи субтитри, на база конфигурацията за мета-данни.",
+    "TaskDownloadMissingSubtitles": "Изтегляне на липсващи субтитри",
+    "TaskRefreshChannelsDescription": "Обновява информацията за интернет канала.",
+    "TaskRefreshChannels": "Обновяване на Канали",
+    "TaskCleanTranscodeDescription": "Изтрива транскодирани файлове по-стари от един ден.",
+    "TaskCleanTranscode": "Изчиства директорията за транскодиране",
+    "TaskUpdatePluginsDescription": "Изтегля и инсталира актуализации за добавките, които са настроени за автоматична актуализация.",
+    "TaskUpdatePlugins": "Актуализира добавките",
+    "TaskRefreshPeopleDescription": "Актуализира мета-данните за артистите и режисьорите за Вашата медийна библиотека.",
+    "TaskRefreshPeople": "Обновяване на участниците",
+    "TaskCleanLogsDescription": "Изтрива лог файлове по-стари от {0} дни.",
+    "TaskCleanLogs": "Изчисти директорията с логове",
+    "TaskRefreshLibraryDescription": "Сканира Вашата библиотека с медия за нови файлове и обновява мета-данните.",
+    "TaskRefreshLibrary": "Сканиране на библиотеката с медия",
+    "TaskRefreshChapterImagesDescription": "Създава иконки за видеа, които имат епизоди.",
+    "TaskRefreshChapterImages": "Извличане на изображения за епизода",
+    "TaskCleanCacheDescription": "Изтриване на ненужните от системата файлове.",
+    "TaskCleanCache": "Изчистване на Кеш-директорията",
+    "TasksChannelsCategory": "Интернет Канали",
+    "TasksApplicationCategory": "Приложение",
+    "TasksLibraryCategory": "Библиотека",
+    "TasksMaintenanceCategory": "Поддръжка",
+    "Undefined": "Неопределено",
+    "Forced": "Принудително",
+    "Default": "По подразбиране",
+    "TaskCleanActivityLogDescription": "Изтрива записите в дневника с активност по стари от конфигурираната възраст.",
+    "TaskCleanActivityLog": "Изчисти дневника с активност",
+    "TaskOptimizeDatabaseDescription": "Прави базата данни по-компактна и освобождава място. Пускането на тази задача след сканиране на библиотеката или правене на други промени, свързани с модификации на базата данни, може да подобри производителността.",
+    "TaskOptimizeDatabase": "Оптимизирай базата данни",
+    "TaskKeyframeExtractorDescription": "Извличат се ключови кадри от видеофайловете ,за да се създаде по точен HLS списък . Задачата може да отнеме много време.",
+    "TaskKeyframeExtractor": "Извличане на ключови кадри",
+    "External": "Външен",
+    "HearingImpaired": "Увреден слух",
+    "TaskRefreshTrickplayImages": "Генерирай изображение",
+    "TaskRefreshTrickplayImagesDescription": "Създава прегледи на Trickplay за видеа в активирани библиотеки.",
+    "TaskDownloadMissingLyrics": "Свали липсващи текстове",
+    "TaskDownloadMissingLyricsDescription": "Свали текстове за песни",
+    "TaskCleanCollectionsAndPlaylists": "Изчисти колекциите и плейлистите",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Премахни несъществуващи файлове в колекциите и плейлистите.",
+    "TaskAudioNormalization": "Нормализиране на звука",
+    "TaskAudioNormalizationDescription": "Сканирай файловете за нормализация на звука.",
+    "TaskExtractMediaSegmentsDescription": "Изважда медиини сегменти от MediaSegment плъгини.",
+    "TaskMoveTrickplayImages": "Мигриране на Локацията за Trickplay изображения",
+    "TaskMoveTrickplayImagesDescription": "Премества съществуващите trickplay изображения спрямо настройките на библиотеката.",
+    "TaskExtractMediaSegments": "Сканиране за сегменти",
+    "CleanupUserDataTask": "Задача за почистване на потребителски данни",
+    "CleanupUserDataTaskDescription": "Почиства всички потребителски данни (статус на гледане, любими и т.н.) от медия, която вече не е налична от поне 90 дни."
+}

Emby.Server.Implementations/Localization/Core/bn.json

@@ -0,0 +1,141 @@
+{
+    "DeviceOnlineWithName": "{0}-এর সাথে সংযুক্ত হয়েছে",
+    "DeviceOfflineWithName": "{0}-এর সাথে সংযোগ বিচ্ছিন্ন হয়েছে",
+    "Collections": "সংগ্রহশালা",
+    "ChapterNameValue": "অধ্যায় {0}",
+    "Channels": "চ্যানেলসমূহ",
+    "CameraImageUploadedFrom": "{0} থেকে একটি নতুন ক্যামেরার চিত্র আপলোড করা হয়েছে",
+    "Books": "পুস্তকসমূহ",
+    "AuthenticationSucceededWithUserName": "{0} সফলভাবে অথেন্টিকেট করেছেন",
+    "Artists": "শিল্পীগণ",
+    "Application": "অ্যাপ্লিকেশন",
+    "Albums": "অ্যালবামসমূহ",
+    "HeaderFavoriteEpisodes": "প্রিয় পর্বগুলো",
+    "HeaderFavoriteArtists": "প্রিয় শিল্পীরা",
+    "HeaderFavoriteAlbums": "প্রিয় এলবামগুলো",
+    "HeaderContinueWatching": "দেখতে থাকুন",
+    "HeaderAlbumArtists": "অ্যালবাম শিল্পীবৃন্দ",
+    "Genres": "ধরণ",
+    "Folders": "ফোল্ডারসমূহ",
+    "Favorites": "পছন্দসমূহ",
+    "FailedLoginAttemptWithUserName": "{0} লগিন করতে ব্যর্থ হয়েছে",
+    "AppDeviceValues": "অ্যাপ: {0}, ডিভাইস: {1}",
+    "VersionNumber": "সংস্করণ {0}",
+    "ValueSpecialEpisodeName": "বিশেষ পর্ব - {0}",
+    "ValueHasBeenAddedToLibrary": "আপনার লাইব্রেরিতে {0} যোগ করা হয়েছে",
+    "UserStoppedPlayingItemWithValues": "{2}তে {1} প্লে শেষ করেছেন {0}",
+    "UserStartedPlayingItemWithValues": "{2}তে {1} প্লে করেছেন {0}",
+    "UserPolicyUpdatedWithName": "{0} এর জন্য ব্যবহার নীতি আপডেট করা হয়েছে",
+    "UserPasswordChangedWithName": "ব্যবহারকারী {0} এর পাসওয়ার্ড পরিবর্তিত হয়েছে",
+    "UserOnlineFromDevice": "{0}, {1} থেকে অনলাইন আছে",
+    "UserOfflineFromDevice": "{0} {1} থেকে বিচ্ছিন্ন হয়ে গেছে",
+    "UserLockedOutWithName": "ব্যবহারকারী {0} ঢুকতে পারছে না",
+    "UserDownloadingItemWithValues": "{0}, {1} ডাউনলোড করছে",
+    "UserDeletedWithName": "ব্যবহারকারী {0}কে বাদ দেয়া হয়েছে",
+    "UserCreatedWithName": "ব্যবহারকারী {0} সৃষ্টি করা হয়েছে",
+    "User": "ব্যবহারকারী",
+    "TvShows": "টিভি শোগুলো",
+    "System": "সিস্টেম",
+    "Sync": "সমন্বয় করুন",
+    "SubtitleDownloadFailureFromForItem": "{0} থেকে {1} এর জন্য সাবটাইটেল ডাউনলোড ব্যর্থ হয়েছে",
+    "StartupEmbyServerIsLoading": "জেলিফিন সার্ভার লোড হচ্ছে। দয়া করে একটু পরে আবার চেষ্টা করুন।",
+    "Songs": "সঙ্গীত সমূহ",
+    "Shows": "শো সমূহ",
+    "ServerNameNeedsToBeRestarted": "{0} রিস্টার্ট করা প্রয়োজন",
+    "ScheduledTaskStartedWithName": "{0} শুরু হয়েছে",
+    "ScheduledTaskFailedWithName": "{0} ব্যর্থ",
+    "ProviderValue": "প্রদানকারী: {0}",
+    "PluginUpdatedWithName": "{0} আপডেট করা হয়েছে",
+    "PluginUninstalledWithName": "{0} আনইন্সটল হয়েছে",
+    "PluginInstalledWithName": "{0} ইন্সটল হয়েছে",
+    "Plugin": "প্লাগিন",
+    "Playlists": "প্লে লিস্ট সমূহ",
+    "Photos": "ছবিসমূহ",
+    "NotificationOptionVideoPlaybackStopped": "ভিডিও প্লেব্যাক বন্ধ হয়েছে",
+    "NotificationOptionVideoPlayback": "ভিডিও প্লেব্যাক শুরু হয়েছে",
+    "NotificationOptionUserLockedOut": "ব্যবহারকারী লক আউট হয়েছে",
+    "NotificationOptionTaskFailed": "পরিকল্পিত কাজটি ব্যর্থ",
+    "NotificationOptionServerRestartRequired": "সার্ভার রিস্টার্ট করা লাগবে",
+    "NotificationOptionPluginUpdateInstalled": "প্লাগিন আপডেট ইন্সটল হয়েছে",
+    "NotificationOptionPluginUninstalled": "প্লাগিন আনইনষ্টল হয়েছে",
+    "NotificationOptionPluginInstalled": "প্লাগিন ইন্সটল করা হয়েছে",
+    "NotificationOptionPluginError": "প্লাগিন ব্যর্থ",
+    "NotificationOptionNewLibraryContent": "নতুন কন্টেন্ট যোগ করা হয়েছে",
+    "NotificationOptionInstallationFailed": "ইন্সটল ব্যর্থ হয়েছে",
+    "NotificationOptionCameraImageUploaded": "ক্যামেরার ছবি আপলোড হয়েছে",
+    "NotificationOptionAudioPlaybackStopped": "গান বাজা বন্ধ হয়েছে",
+    "NotificationOptionAudioPlayback": "গান বাজা শুরু হয়েছে",
+    "NotificationOptionApplicationUpdateInstalled": "এপ্লিকেশনের আপডেট ইনস্টল করা হয়েছে",
+    "NotificationOptionApplicationUpdateAvailable": "এপ্লিকেশনের আপডেট রয়েছে",
+    "NewVersionIsAvailable": "জেলিফিন সার্ভারের একটি নতুন ভার্শন ডাউনলোডের জন্য তৈরী।",
+    "NameSeasonUnknown": "সিজন অজানা",
+    "NameSeasonNumber": "সিজন {0}",
+    "NameInstallFailed": "{0} ইন্সটল ব্যর্থ",
+    "MusicVideos": "সঙ্গীত ভিডিয়ো সমূহ",
+    "Music": "গান",
+    "Movies": "চলচ্চিত্রসমূহ",
+    "MixedContent": "মিশ্র কন্টেন্ট",
+    "MessageServerConfigurationUpdated": "সার্ভারের কনফিগারেশন আপডেট করা হয়েছে",
+    "HeaderRecordingGroups": "রেকর্ডিং গ্রুপগুলো",
+    "MessageNamedServerConfigurationUpdatedWithValue": "সার্ভার কনফিগারেশন সেকশন {0} আপডেট করা হয়েছে",
+    "MessageApplicationUpdatedTo": "জেলিফিন সার্ভার {0} তে আপডেট করা হয়েছে",
+    "MessageApplicationUpdated": "জেলিফিন সার্ভার আপডেট করা হয়েছে",
+    "Latest": "সর্বশেষ",
+    "LabelRunningTimeValue": "চলার সময়: {0}",
+    "LabelIpAddressValue": "আইপি এড্রেস: {0}",
+    "ItemRemovedWithName": "{0} লাইব্রেরি থেকে বাদ দেয়া হয়েছে",
+    "ItemAddedWithName": "{0} লাইব্রেরিতে যোগ করা হয়েছে",
+    "Inherit": "উত্তরাধিকারসূত্র থেকে গ্রহণ করুন",
+    "HomeVideos": "হোম ভিডিও",
+    "HeaderNextUp": "এরপরে আসছে",
+    "HeaderLiveTV": "লাইভ টিভি",
+    "HeaderFavoriteSongs": "প্রিয় গানগুলো",
+    "HeaderFavoriteShows": "প্রিয় শোগুলো",
+    "TasksLibraryCategory": "লাইব্রেরি",
+    "TasksMaintenanceCategory": "রক্ষণাবেক্ষণ",
+    "TaskRefreshLibrary": "স্ক্যান মিডিয়া লাইব্রেরি",
+    "TaskRefreshChapterImagesDescription": "যেসব ভিডিওতে চ্যাপ্টার রয়েছে, তাদের জন্য থাম্বনেইল তৈরি করবে।",
+    "TaskRefreshChapterImages": "চ্যাপ্টার ইমেজ বের করুন",
+    "TaskCleanCacheDescription": "সিস্টেমের অপ্রয়োজনীয় ক্যাশ ফাইলগুলো মুছে ফেলবে।",
+    "TaskCleanCache": "ক্লিন ক্যাশ ডিরেক্টরি",
+    "TasksChannelsCategory": "ইন্টারনেট চ্যানেল",
+    "TasksApplicationCategory": "অ্যাপ্লিকেশন",
+    "TaskDownloadMissingSubtitlesDescription": "মেটাডেটা কনফিগারেশনের উপর ভিত্তি করে অনুপস্থিত সাবটাইটেলগুলির জন্য ইন্টারনেট অনুসন্ধান করে।",
+    "TaskDownloadMissingSubtitles": "অনুপস্থিত সাবটাইটেলগুলি ডাউনলোড করুন",
+    "TaskRefreshChannelsDescription": "ইন্টারনেট চ্যানেল তথ্য রিফ্রেশ করুন।",
+    "TaskRefreshChannels": "চ্যানেল রিফ্রেশ করুন",
+    "TaskCleanTranscodeDescription": "এক দিনেরও বেশি পুরানো ট্রান্সকোড ফাইলগুলি মুছে ফেলবে।",
+    "TaskCleanTranscode": "ট্রান্সকোড ডিরেক্টরি ক্লিন করুন",
+    "TaskUpdatePluginsDescription": "স্বয়ংক্রিয়ভাবে আপডেট কনফিগার করা প্লাগইনগুলির জন্য আপডেট ডাউনলোড এবং ইনস্টল করুন।",
+    "TaskUpdatePlugins": "আপডেট প্লাগইন",
+    "TaskRefreshPeopleDescription": "আপনার মিডিয়া লাইব্রেরিতে অভিনেতা এবং পরিচালকদের জন্য মেটাডাটা আপডেট করবে।",
+    "TaskRefreshPeople": "ব্যক্তিদের তথ্য রিফ্রেশ",
+    "TaskCleanLogsDescription": "{0} দিনের বেশী পুরানো লগ ফাইলগুলি মুছে ফেলবে।",
+    "TaskCleanLogs": "ক্লিন লগ ডিরেক্টরি",
+    "TaskRefreshLibraryDescription": "নতুন ফাইলের জন্য মিডিয়া লাইব্রেরি স্ক্যান এবং মেটাডাটা রিফ্রেশ করবে।",
+    "Undefined": "অসঙ্গায়িত",
+    "Forced": "জোরকরে",
+    "TaskCleanActivityLogDescription": "নির্ধারিত সময়ের আগের অ্যাক্টিভিটি লগ মুছে দিবে।",
+    "TaskCleanActivityLog": "অ্যাক্টিভিটি লগ মুছুন",
+    "Default": "ডিফল্ট",
+    "HearingImpaired": "শ্রবণ প্রতিবন্ধী",
+    "TaskOptimizeDatabaseDescription": "তথ্যভাণ্ডার সুবিন্যস্ত করে ও অব্যবহৃত জায়গা ছেড়ে দেয়। লাইব্রেরী স্ক্যান অথবা যেকোনো তথ্যভাণ্ডার পরিবর্তনের পর এই প্রক্রিয়া চালালে তথ্যভাণ্ডারের তথ্য প্রদান দ্রুততর হতে পারে।",
+    "External": "বাহ্যিক",
+    "TaskOptimizeDatabase": "তথ্যভাণ্ডার সুবিন্যাস",
+    "TaskKeyframeExtractor": "কি-ফ্রেম নিষ্কাশক",
+    "TaskKeyframeExtractorDescription": "ভিডিয়ো থেকে কি-ফ্রেম নিষ্কাশনের মাধ্যমে অধিকতর সঠিক HLS প্লে লিস্ট তৈরী করে। এই প্রক্রিয়া দীর্ঘ সময় ধরে চলতে পারে।",
+    "TaskRefreshTrickplayImages": "ট্রিকপ্লে ইমেজ তৈরি",
+    "TaskRefreshTrickplayImagesDescription": "সক্ষম লাইব্রেরিতে ভিডিওর জন্য ট্রিকপ্লে প্রিভিউ তৈরি করে।",
+    "TaskDownloadMissingLyricsDescription": "গানের জন্য লিরিকস ডাউনলোড করুন",
+    "TaskCleanCollectionsAndPlaylists": "কালেকশন এবং প্লেলিস্ট পরিষ্কার করুন",
+    "TaskCleanCollectionsAndPlaylistsDescription": "কালেকশন এবং প্লেলিস্ট থেকে আইটেমগুলি সরিয়ে দেয় যা আর বিদ্যমান নেই।",
+    "TaskExtractMediaSegments": "মিডিয়া সেগমেন্ট স্ক্যান",
+    "TaskExtractMediaSegmentsDescription": "মিডিয়া সেগমেন্ট সক্ষম প্লাগইনগুলি থেকে মিডিয়া সেগমেন্ট বের করে বা অর্জন করে।",
+    "TaskDownloadMissingLyrics": "অনুপস্থিত গান ডাউনলোড করুন",
+    "TaskMoveTrickplayImagesDescription": "লাইব্রেরির সেটিং অনুযায়ী বিদ্যমান ট্রিকপ্লে ফাইলগুলো সরিয়ে নেবে।",
+    "TaskAudioNormalizationDescription": "অডিও নর্মালাইজেশন তথ্যের জন্য ফাইল স্ক্যান করবে।",
+    "CleanupUserDataTaskDescription": "৯০ দিন বা তার বেশি সময় ধরে অনুপস্থিত মিডিয়া থেকে সকল ব্যবহারকারীর ডেটা (ওয়াচ স্টেট, ফেভারিট স্ট্যাটাস ইত্যাদি) মুছে ফেলবে।",
+    "TaskMoveTrickplayImages": "ট্রিকপ্লে ইমেজের অবস্থান পরিবর্তন",
+    "TaskAudioNormalization": "অডিও নর্মলাইজেশন",
+    "CleanupUserDataTask": "ইউজার ডেটা ক্লিনআপ কাজ"
+}

Emby.Server.Implementations/Localization/Core/ca.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "Àlbums",
+    "AppDeviceValues": "Aplicació: {0}, Dispositiu: {1}",
+    "Application": "Aplicació",
+    "Artists": "Artistes",
+    "AuthenticationSucceededWithUserName": "{0} s'ha autenticat correctament",
+    "Books": "Llibres",
+    "CameraImageUploadedFrom": "S'ha pujat una nova imatge de càmera des de {0}",
+    "Channels": "Canals",
+    "ChapterNameValue": "Capítol {0}",
+    "Collections": "Col·leccions",
+    "DeviceOfflineWithName": "{0} s'ha desconnectat",
+    "DeviceOnlineWithName": "{0} està connectat",
+    "FailedLoginAttemptWithUserName": "Intent de connexió fallit des de {0}",
+    "Favorites": "Preferits",
+    "Folders": "Directoris",
+    "Genres": "Gèneres",
+    "HeaderAlbumArtists": "Artistes de l'àlbum",
+    "HeaderContinueWatching": "Continueu mirant",
+    "HeaderFavoriteAlbums": "Àlbums preferits",
+    "HeaderFavoriteArtists": "Artistes preferits",
+    "HeaderFavoriteEpisodes": "Episodis preferits",
+    "HeaderFavoriteShows": "Sèries preferides",
+    "HeaderFavoriteSongs": "Cançons preferides",
+    "HeaderLiveTV": "TV en directe",
+    "HeaderNextUp": "A continuació",
+    "HeaderRecordingGroups": "Grups musicals",
+    "HomeVideos": "Vídeos domèstics",
+    "Inherit": "Heretat",
+    "ItemAddedWithName": "{0} s'ha afegit a la mediateca",
+    "ItemRemovedWithName": "{0} s'ha eliminat de la mediateca",
+    "LabelIpAddressValue": "Adreça IP: {0}",
+    "LabelRunningTimeValue": "Temps en marxa: {0}",
+    "Latest": "Darrers",
+    "MessageApplicationUpdated": "El servidor de Jellyfin ha estat actualitzat",
+    "MessageApplicationUpdatedTo": "El servidor de Jellyfin ha estat actualitzat a {0}",
+    "MessageNamedServerConfigurationUpdatedWithValue": "La secció {0} de la configuració del servidor ha estat actualitzada",
+    "MessageServerConfigurationUpdated": "S'ha actualitzat la configuració del servidor",
+    "MixedContent": "Contingut barrejat",
+    "Movies": "Pel·lícules",
+    "Music": "Música",
+    "MusicVideos": "Videoclips",
+    "NameInstallFailed": "{0} instal·lació fallida",
+    "NameSeasonNumber": "Temporada {0}",
+    "NameSeasonUnknown": "Temporada desconeguda",
+    "NewVersionIsAvailable": "Hi ha disponible una versió nova del servidor de Jellyfin per a la descàrrega.",
+    "NotificationOptionApplicationUpdateAvailable": "Actualització de l'aplicatiu disponible",
+    "NotificationOptionApplicationUpdateInstalled": "Actualització de l'aplicatiu instal·lada",
+    "NotificationOptionAudioPlayback": "Reproducció d'àudio iniciada",
+    "NotificationOptionAudioPlaybackStopped": "Reproducció d'àudio aturada",
+    "NotificationOptionCameraImageUploaded": "Imatge de càmera pujada",
+    "NotificationOptionInstallationFailed": "Instal·lació fallida",
+    "NotificationOptionNewLibraryContent": "Nou contingut afegit",
+    "NotificationOptionPluginError": "Un complement ha fallat",
+    "NotificationOptionPluginInstalled": "Complement instal·lat",
+    "NotificationOptionPluginUninstalled": "Complement desinstal·lat",
+    "NotificationOptionPluginUpdateInstalled": "Actualització del complement instal·lada",
+    "NotificationOptionServerRestartRequired": "El servidor s'ha de reiniciar",
+    "NotificationOptionTaskFailed": "Tasca programada fallida",
+    "NotificationOptionUserLockedOut": "Usuari expulsat",
+    "NotificationOptionVideoPlayback": "Reproducció de vídeo iniciada",
+    "NotificationOptionVideoPlaybackStopped": "Reproducció de vídeo aturada",
+    "Photos": "Fotos",
+    "Playlists": "Llistes de reproducció",
+    "Plugin": "Complement",
+    "PluginInstalledWithName": "{0} ha estat instal·lat",
+    "PluginUninstalledWithName": "S'ha instal·lat {0}",
+    "PluginUpdatedWithName": "S'ha actualitzat {0}",
+    "ProviderValue": "Proveïdor: {0}",
+    "ScheduledTaskFailedWithName": "{0} ha fallat",
+    "ScheduledTaskStartedWithName": "S'ha iniciat {0}",
+    "ServerNameNeedsToBeRestarted": "S'ha de reiniciar {0}",
+    "Shows": "Sèries",
+    "Songs": "Cançons",
+    "StartupEmbyServerIsLoading": "El servidor de Jellyfin s'està carregant. Proveu-ho de nou en una estona.",
+    "SubtitleDownloadFailureFromForItem": "Els subtítols per a {1} no s'han pogut baixar de {0}",
+    "Sync": "Sincronitza",
+    "System": "Sistema",
+    "TvShows": "Sèries de TV",
+    "User": "Usuari",
+    "UserCreatedWithName": "S'ha creat l'usuari {0}",
+    "UserDeletedWithName": "S'ha eliminat l'usuari {0}",
+    "UserDownloadingItemWithValues": "{0} està descarregant {1}",
+    "UserLockedOutWithName": "S'ha expulsat a l'usuari {0}",
+    "UserOfflineFromDevice": "{0} s'ha desconnectat de {1}",
+    "UserOnlineFromDevice": "{0} està connectat des de {1}",
+    "UserPasswordChangedWithName": "S'ha canviat la contrasenya per a l'usuari {0}",
+    "UserPolicyUpdatedWithName": "La política d'usuari s'ha actualitzat per a {0}",
+    "UserStartedPlayingItemWithValues": "{0} ha començat a reproduir {1} a {2}",
+    "UserStoppedPlayingItemWithValues": "{0} ha parat de reproduir {1} a {2}",
+    "ValueHasBeenAddedToLibrary": "S'ha afegit {0} a la mediateca",
+    "ValueSpecialEpisodeName": "Especial - {0}",
+    "VersionNumber": "Versió {0}",
+    "TaskDownloadMissingSubtitlesDescription": "Cerca a internet els subtítols que faltin a partir de la configuració de metadades.",
+    "TaskDownloadMissingSubtitles": "Descàrrega dels subtítols que faltin",
+    "TaskRefreshChannelsDescription": "Actualitza la informació dels canals per internet.",
+    "TaskRefreshChannels": "Actualitza els canals",
+    "TaskCleanTranscodeDescription": "Elimina els fitxers de transcodificacions que tinguin més d'un dia.",
+    "TaskCleanTranscode": "Neteja de les transcodificacions",
+    "TaskUpdatePluginsDescription": "Descarrega i instal·la els complements que estiguin configurats per a actualitzar-se automàticament.",
+    "TaskUpdatePlugins": "Actualització dels complements",
+    "TaskRefreshPeopleDescription": "Actualització de les metadades dels actors i directors de la mediateca.",
+    "TaskRefreshPeople": "Actualització de les persones",
+    "TaskCleanLogsDescription": "Esborra els registres que tinguin més de {0} dies.",
+    "TaskCleanLogs": "Neteja dels registres",
+    "TaskRefreshLibraryDescription": "Escaneja les mediateques, a la cerca de fitxers nous i refresca les metadades.",
+    "TaskRefreshLibrary": "Escaneja la mediateca",
+    "TaskRefreshChapterImagesDescription": "Creació de les miniatures dels vídeos que tinguin capítols.",
+    "TaskRefreshChapterImages": "Extracció de les imatges dels capítols",
+    "TaskCleanCacheDescription": "Eliminació de la memòria cau no necessària per al servidor.",
+    "TaskCleanCache": "Eliminació de la memòria cau",
+    "TasksChannelsCategory": "Canals per internet",
+    "TasksApplicationCategory": "Aplicatiu",
+    "TasksLibraryCategory": "Mediateca",
+    "TasksMaintenanceCategory": "Manteniment",
+    "TaskCleanActivityLogDescription": "Eliminació de les entrades del registre d'activitats més antigues que l'antiguitat configurada.",
+    "TaskCleanActivityLog": "Buidatge del registre d'activitat",
+    "Undefined": "Indefinit",
+    "Forced": "Forçat",
+    "Default": "Per defecte",
+    "TaskOptimizeDatabaseDescription": "Compacta la base de dades i trunca l'espai lliure. Executar aquesta tasca després d’escanejar la mediateca o fer d'altres canvis que impliquin modificacions a la base de dades pot millorar el rendiment.",
+    "TaskOptimizeDatabase": "Optimització de la base de dades",
+    "TaskKeyframeExtractorDescription": "Extracció de fotogrames clau dels fitxers de vídeo per a crear llistes de reproducció HLS més precises. Aquesta tasca pot allargar-se molt en el temps.",
+    "TaskKeyframeExtractor": "Extracció de fotogrames clau",
+    "External": "Extern",
+    "HearingImpaired": "Discapacitat auditiva",
+    "TaskRefreshTrickplayImages": "Generació d'imatges de previsualització",
+    "TaskRefreshTrickplayImagesDescription": "Creació d'imatges de previsualització per a vídeos en les mediateques habilitades.",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Esborra elements de col·leccions i llistes de reproducció que ja no existeixen.",
+    "TaskCleanCollectionsAndPlaylists": "Neteja de les col·leccions i llistes de reproducció",
+    "TaskAudioNormalization": "Estabilització de l'àudio",
+    "TaskAudioNormalizationDescription": "Escaneja els fitxer per a obtenir dades de normalització de l'àudio.",
+    "TaskDownloadMissingLyricsDescription": "Descàrrega de les lletres de les cançons",
+    "TaskDownloadMissingLyrics": "Descàrrega de les lletres que faltin",
+    "TaskExtractMediaSegments": "Escaneig de segments multimèdia",
+    "TaskExtractMediaSegmentsDescription": "Extreu o obté segments multimèdia usant els connectors MediaSegment activats.",
+    "TaskMoveTrickplayImages": "Migració de la ubicació de la imatge de previsualització",
+    "TaskMoveTrickplayImagesDescription": "Mou els fitxers existents d'imatges de previsualització segons la configuració de la mediateca.",
+    "CleanupUserDataTaskDescription": "Neteja totes les dades d'usuari (estat de la visualització, estat dels preferits, etc.) del contingut multimèdia que no ha estat present durant almenys 90 dies.",
+    "CleanupUserDataTask": "Tasca de neteja de dades d'usuari"
+}

Emby.Server.Implementations/Localization/Core/chr.json

@@ -0,0 +1,52 @@
+{
+    "ChapterNameValue": "Didanedi {0}",
+    "HeaderAlbumArtists": "Didanidanolisgisgi",
+    "HeaderFavoriteAlbums": "Dvganidi didanidisgisgi",
+    "HeaderLiveTV": "Anigadi didanidisgosgi",
+    "HeaderRecordingGroups": "Didanisquodiisgisgi",
+    "HomeVideos": "Diganadi dinagadisgisgi",
+    "Inherit": "Anigwe",
+    "MessageApplicationUpdatedTo": "Tsenigwidinonvhi Jellyfin Server tsadanidigwe anigadi {0}",
+    "MixedContent": "Ganinidi dininoladisgisgi",
+    "Movies": "Anidvnisgisgi",
+    "MusicVideos": "Danodisgisgi didanidisgosgi",
+    "NotificationOptionAudioPlayback": "Didanidigwe diganuyisgisgi anigadi",
+    "NotificationOptionInstallationFailed": "Diudvdi anadvnatisgisgi",
+    "NotificationOptionPluginUninstalled": "Ditsigvhnidv anawvdisgisgi",
+    "Albums": "Anigawidaniyv",
+    "Application": "Didanvyi",
+    "Artists": "Dinidaniyi",
+    "AuthenticationSucceededWithUserName": "{0} Sesoquonisdi nagadani",
+    "Books": "Didanedi",
+    "CameraImageUploadedFrom": "Anigawidaniyv nasgi didagwalanvyi {0}",
+    "Channels": "Diganadasgi",
+    "Collections": "Diganadisgi",
+    "Default": "Dinadi",
+    "DeviceOfflineWithName": "{0} Aniyvolehvi nasgi",
+    "External": "Amohdi",
+    "Favorites": "Nvdayelvdisgi",
+    "Folders": "Didanididisgi",
+    "Forced": "Ganedi",
+    "Genres": "Diganadisgi",
+    "HeaderContinueWatching": "Uwoditsu asdanidisgisgi",
+    "HeaderFavoriteArtists": "Dvganidi dinidanolisgisgi",
+    "HeaderFavoriteEpisodes": "Dvganidi didanidilisgadisgisgi",
+    "HeaderFavoriteShows": "Dvganidi didanididanolisgisgi)",
+    "HeaderFavoriteSongs": "Dvganidi danodisgisgi",
+    "HeaderNextUp": "Anidvli uwodoli",
+    "HearingImpaired": "Anitsunidi talunidisgisgi",
+    "ItemAddedWithName": "{0} Dinigwe anididanidisgi",
+    "Latest": "Uwodoli",
+    "MessageApplicationUpdated": "Tsenigwidinonvhi Jellyfin Server tsadanidigwe",
+    "MessageServerConfigurationUpdated": "Sedanidvdi anigadi diganidinonvhi",
+    "Music": "Danodisgisgi",
+    "NameSeasonUnknown": "Tsunita anidvdisgi",
+    "NewVersionIsAvailable": "Danodigwe anigadi Jellyfin Server tsadanidigwe adisdi uwodvdi diganidinonvhi.",
+    "NotificationOptionApplicationUpdateAvailable": "Disisdi tsadanidigwe udvdi",
+    "NotificationOptionApplicationUpdateInstalled": "Disisdi tsadanidigwe digawvdi",
+    "NotificationOptionAudioPlaybackStopped": "Didanidigwe diganuyisgisgi digawvdi",
+    "NotificationOptionCameraImageUploaded": "Asdayi adininisgisgi diganuyisgisgi",
+    "NotificationOptionNewLibraryContent": "Danodisgisgi anigadi digawvdi",
+    "NotificationOptionPluginError": "Ditsigvhnidv anadvnatisgisgi",
+    "NotificationOptionPluginInstalled": "Ditsigvhnidv digawvdi"
+}

Emby.Server.Implementations/Localization/Core/cs.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "Alba",
+    "AppDeviceValues": "Aplikace: {0}, Zařízení: {1}",
+    "Application": "Aplikace",
+    "Artists": "Umělci",
+    "AuthenticationSucceededWithUserName": "{0} úspěšně ověřen",
+    "Books": "Knihy",
+    "CameraImageUploadedFrom": "Z {0} byla nahrána nová fotografie z fotoaparátu",
+    "Channels": "Kanály",
+    "ChapterNameValue": "Kapitola {0}",
+    "Collections": "Kolekce",
+    "DeviceOfflineWithName": "{0} se odpojil",
+    "DeviceOnlineWithName": "{0} je připojen",
+    "FailedLoginAttemptWithUserName": "Neúspěšný pokus o přihlášení z {0}",
+    "Favorites": "Oblíbené",
+    "Folders": "Složky",
+    "Genres": "Žánry",
+    "HeaderAlbumArtists": "Umělci alba",
+    "HeaderContinueWatching": "Pokračovat ve sledování",
+    "HeaderFavoriteAlbums": "Oblíbená alba",
+    "HeaderFavoriteArtists": "Oblíbení interpreti",
+    "HeaderFavoriteEpisodes": "Oblíbené epizody",
+    "HeaderFavoriteShows": "Oblíbené seriály",
+    "HeaderFavoriteSongs": "Oblíbená hudba",
+    "HeaderLiveTV": "TV vysílání",
+    "HeaderNextUp": "Další díly",
+    "HeaderRecordingGroups": "Skupiny nahrávek",
+    "HomeVideos": "Domácí videa",
+    "Inherit": "Zdědit",
+    "ItemAddedWithName": "{0} byl přidán do knihovny",
+    "ItemRemovedWithName": "{0} byl odstraněn z knihovny",
+    "LabelIpAddressValue": "IP adresa: {0}",
+    "LabelRunningTimeValue": "Délka média: {0}",
+    "Latest": "Nejnovější",
+    "MessageApplicationUpdated": "Jellyfin Server byl aktualizován",
+    "MessageApplicationUpdatedTo": "Jellyfin server byl aktualizován na verzi {0}",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Konfigurace sekce {0} na serveru byla aktualizována",
+    "MessageServerConfigurationUpdated": "Konfigurace serveru aktualizována",
+    "MixedContent": "Smíšený obsah",
+    "Movies": "Filmy",
+    "Music": "Hudba",
+    "MusicVideos": "Hudební videa",
+    "NameInstallFailed": "Instalace {0} selhala",
+    "NameSeasonNumber": "Sezóna {0}",
+    "NameSeasonUnknown": "Neznámá sezóna",
+    "NewVersionIsAvailable": "Nová verze Jellyfin serveru je k dispozici ke stažení.",
+    "NotificationOptionApplicationUpdateAvailable": "Dostupná aktualizace aplikace",
+    "NotificationOptionApplicationUpdateInstalled": "Aktualizace aplikace instalována",
+    "NotificationOptionAudioPlayback": "Přehrávání audia zahájeno",
+    "NotificationOptionAudioPlaybackStopped": "Přehrávání audia ukončeno",
+    "NotificationOptionCameraImageUploaded": "Kamerový záznam nahrán",
+    "NotificationOptionInstallationFailed": "Chyba instalace",
+    "NotificationOptionNewLibraryContent": "Přidán nový obsah",
+    "NotificationOptionPluginError": "Chyba zásuvného modulu",
+    "NotificationOptionPluginInstalled": "Zásuvný modul instalován",
+    "NotificationOptionPluginUninstalled": "Zásuvný modul odstraněn",
+    "NotificationOptionPluginUpdateInstalled": "Aktualizace zásuvného modulu instalována",
+    "NotificationOptionServerRestartRequired": "Je vyžadován restart serveru",
+    "NotificationOptionTaskFailed": "Chyba naplánované úlohy",
+    "NotificationOptionUserLockedOut": "Uživatel uzamčen",
+    "NotificationOptionVideoPlayback": "Přehrávání videa zahájeno",
+    "NotificationOptionVideoPlaybackStopped": "Přehrávání videa ukončeno",
+    "Photos": "Fotky",
+    "Playlists": "Seznamy skladeb",
+    "Plugin": "Zásuvný modul",
+    "PluginInstalledWithName": "{0} byl nainstalován",
+    "PluginUninstalledWithName": "{0} byl odinstalován",
+    "PluginUpdatedWithName": "{0} byl aktualizován",
+    "ProviderValue": "Poskytl: {0}",
+    "ScheduledTaskFailedWithName": "{0} selhalo",
+    "ScheduledTaskStartedWithName": "{0} zahájeno",
+    "ServerNameNeedsToBeRestarted": "{0} vyžaduje restart",
+    "Shows": "Seriály",
+    "Songs": "Skladby",
+    "StartupEmbyServerIsLoading": "Jellyfin Server je spouštěn. Zkuste to prosím v brzké době znovu.",
+    "SubtitleDownloadFailureFromForItem": "Stažení titulků pro {1} z {0} selhalo",
+    "Sync": "Synchronizace",
+    "System": "Systém",
+    "TvShows": "Seriály",
+    "User": "Uživatel",
+    "UserCreatedWithName": "Uživatel {0} byl vytvořen",
+    "UserDeletedWithName": "Uživatel {0} byl smazán",
+    "UserDownloadingItemWithValues": "{0} stahuje {1}",
+    "UserLockedOutWithName": "Uživatel {0} byl odemčen",
+    "UserOfflineFromDevice": "{0} se odpojil ze zařízení {1}",
+    "UserOnlineFromDevice": "{0} se připojil ze zařízení {1}",
+    "UserPasswordChangedWithName": "Provedena změna hesla pro uživatele {0}",
+    "UserPolicyUpdatedWithName": "Zásady uživatele pro {0} byly aktualizovány",
+    "UserStartedPlayingItemWithValues": "{0} spustil přehrávání {1}",
+    "UserStoppedPlayingItemWithValues": "{0} zastavil přehrávání {1}",
+    "ValueHasBeenAddedToLibrary": "{0} byl přidán do vaší knihovny médií",
+    "ValueSpecialEpisodeName": "Speciál - {0}",
+    "VersionNumber": "Verze {0}",
+    "TaskDownloadMissingSubtitlesDescription": "Vyhledá na internetu chybějící titulky na základě nastavení metadat.",
+    "TaskDownloadMissingSubtitles": "Stáhnout chybějící titulky",
+    "TaskRefreshChannelsDescription": "Obnoví informace o internetových kanálech.",
+    "TaskRefreshChannels": "Obnovit kanály",
+    "TaskCleanTranscodeDescription": "Odstraní více než 1 den staré transkódované soubory.",
+    "TaskCleanTranscode": "Vyčistit adresář s transkódovaným obsahem",
+    "TaskUpdatePluginsDescription": "Stáhne a nainstaluje aktualizace zásuvných modulů, které mají nastavenou automatickou aktualizaci.",
+    "TaskUpdatePlugins": "Aktualizovat zásuvné moduly",
+    "TaskRefreshPeopleDescription": "Aktualizuje metadata umělců a režisérů ve Vaší knihovně médií.",
+    "TaskRefreshPeople": "Obnovit umělce",
+    "TaskCleanLogsDescription": "Odstraní soubory protokolu, které jsou starší více než {0} dní.",
+    "TaskCleanLogs": "Vyčistit adresář se souborem protokolu",
+    "TaskRefreshLibraryDescription": "Prohledá Vaši knihovnu médií zda neobsahuje nové soubory a obnoví metadatada.",
+    "TaskRefreshLibrary": "Prohledat knihovnu médií",
+    "TaskRefreshChapterImagesDescription": "Vytvoří náhledy videí, které obsahují kapitoly.",
+    "TaskRefreshChapterImages": "Extrahovat obrázky kapitol",
+    "TaskCleanCacheDescription": "Odstraní soubory mezipaměti, které systém již nebude potřebovat.",
+    "TaskCleanCache": "Vyčistit složku s mezipamětí",
+    "TasksChannelsCategory": "Internetové kanály",
+    "TasksApplicationCategory": "Aplikace",
+    "TasksLibraryCategory": "Knihovna",
+    "TasksMaintenanceCategory": "Údržba",
+    "TaskCleanActivityLogDescription": "Smazat záznamy o aktivitě, které jsou starší než zadaná doba.",
+    "TaskCleanActivityLog": "Smazat záznam aktivity",
+    "Undefined": "Nedefinované",
+    "Forced": "Vynucené",
+    "Default": "Výchozí",
+    "TaskOptimizeDatabaseDescription": "Zmenší databázi a odstraní prázdné místo. Spuštění této úlohy po skenování knihovny či jiných změnách databáze může zlepšit výkon.",
+    "TaskOptimizeDatabase": "Optimalizovat databázi",
+    "TaskKeyframeExtractorDescription": "Vytahuje klíčové snímky ze souborů videa za účelem vytváření přesnějších seznamů přehrávání HLS. Tento úkol může trvat velmi dlouho.",
+    "TaskKeyframeExtractor": "Vytahovač klíčových snímků",
+    "External": "Externí",
+    "HearingImpaired": "Sluchově postižení",
+    "TaskRefreshTrickplayImages": "Generovat obrázky pro Trickplay",
+    "TaskRefreshTrickplayImagesDescription": "Obrázky Trickplay se používají k zobrazení náhledů u videí v knihovnách, kde je to povoleno.",
+    "TaskCleanCollectionsAndPlaylists": "Pročistit kolekce a seznamy přehrávání",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Odstraní neexistující položky z kolekcí a seznamů přehrávání.",
+    "TaskAudioNormalization": "Normalizace zvuku",
+    "TaskAudioNormalizationDescription": "Skenovat soubory za účelem normalizace zvuku.",
+    "TaskDownloadMissingLyrics": "Stáhnout chybějící texty k písni",
+    "TaskDownloadMissingLyricsDescription": "Stáhne texty k písni",
+    "TaskExtractMediaSegments": "Skenování segmentů médií",
+    "TaskExtractMediaSegmentsDescription": "Extrahuje či získá segmenty médií pomocí zásuvných modulů MediaSegment.",
+    "TaskMoveTrickplayImages": "Přesunout úložiště obrázků Trickplay",
+    "TaskMoveTrickplayImagesDescription": "Přesune existující soubory Trickplay podle nastavení knihovny.",
+    "CleanupUserDataTaskDescription": "Odstraní všechna uživatelská data (stav zhlédnutí, oblíbené atd.) z médií, které již neexistují více než 90 dní.",
+    "CleanupUserDataTask": "Pročistit uživatelská data"
+}

Emby.Server.Implementations/Localization/Core/cy.json

@@ -0,0 +1,136 @@
+{
+    "DeviceOnlineWithName": "Mae {0} wedi'i gysylltu",
+    "DeviceOfflineWithName": "Mae {0} wedi datgysylltu",
+    "Default": "Diofyn",
+    "Collections": "Casgliadau",
+    "ChapterNameValue": "Pennod {0}",
+    "Channels": "Sianeli",
+    "CameraImageUploadedFrom": "Mae delwedd camera newydd wedi'i lanlwytho o {0}",
+    "Books": "Llyfrau",
+    "AuthenticationSucceededWithUserName": "{0} wedi’i ddilysu’n llwyddiannus",
+    "Artists": "Crewyr",
+    "AppDeviceValues": "Ap: {0}, Dyfais: {1}",
+    "Albums": "Albwmau",
+    "Genres": "Genres",
+    "Folders": "Ffolderi",
+    "Favorites": "Ffefrynnau",
+    "LabelRunningTimeValue": "Amser rhedeg: {0}",
+    "TaskOptimizeDatabase": "Optimeiddio cronfa ddata",
+    "TaskRefreshChannels": "Adnewyddu Sianeli",
+    "TaskRefreshPeople": "Adnewyddu Pobl",
+    "TasksChannelsCategory": "Sianeli Internet",
+    "VersionNumber": "Fersiwn {0}",
+    "ScheduledTaskStartedWithName": "{0} wedi dechrau",
+    "ScheduledTaskFailedWithName": "{0} wedi methu",
+    "ProviderValue": "Darparwr: {0}",
+    "NotificationOptionInstallationFailed": "Fethu Gosod",
+    "NameSeasonUnknown": "Tymor Anhysbys",
+    "NameSeasonNumber": "Tymor {0}",
+    "MusicVideos": "Fideos Cerddoriaeth",
+    "MixedContent": "Cynnwys amrywiol",
+    "HomeVideos": "Genres",
+    "HeaderNextUp": "Nesaf i Fyny",
+    "HeaderFavoriteArtists": "Ffefryn Artistiaid",
+    "HeaderFavoriteAlbums": "Ffefryn Albwmau",
+    "HeaderContinueWatching": "Parhewch i Wylio",
+    "TasksApplicationCategory": "Rhaglen",
+    "TasksLibraryCategory": "Llyfrgell",
+    "TasksMaintenanceCategory": "Cynnal a Chadw",
+    "System": "System",
+    "Plugin": "Ategyn",
+    "Music": "Cerddoriaeth",
+    "Latest": "Diweddaraf",
+    "Inherit": "Etifeddu",
+    "Forced": "Orfodi",
+    "Application": "Rhaglen",
+    "HeaderAlbumArtists": "Artistiaid albwm",
+    "Sync": "Cysoni",
+    "Songs": "Caneuon",
+    "Shows": "Rhaglenni",
+    "Playlists": "Rhestri Chwarae",
+    "Photos": "Lluniau",
+    "ValueSpecialEpisodeName": "Arbennig - {0}",
+    "Movies": "Ffilmiau",
+    "Undefined": "Heb ddiffiniad",
+    "TvShows": "Rhaglenni teledu",
+    "HeaderLiveTV": "Teledu Byw",
+    "User": "Defnyddiwr",
+    "TaskCleanLogsDescription": "Dileu ffeiliau log sy'n fwy na {0} diwrnod oed.",
+    "TaskCleanLogs": "Glanhau ffolder log",
+    "TaskRefreshLibraryDescription": "Sganio'ch llyfrgell gyfryngau am ffeiliau newydd ac yn adnewyddu metaddata.",
+    "TaskRefreshLibrary": "Sganwich Llyfrgell Cyfryngau",
+    "TaskCleanActivityLogDescription": "Yn dileu cofnodion log gweithgaredd sy'n hŷn na'r oedran a nodwyd.",
+    "TaskCleanActivityLog": "Glanhau Log Gweithgaredd",
+    "SubtitleDownloadFailureFromForItem": "Methodd is-deitlau lawrlwytho o {0} ar gyfer {1}",
+    "NotificationOptionPluginError": "Methodd ategyn",
+    "NotificationOptionAudioPlaybackStopped": "Stopiwyd chwarae sain",
+    "NotificationOptionAudioPlayback": "Dechreuwyd chwarae sain",
+    "MessageServerConfigurationUpdated": "Mae gosodiadau gweinydd wedi'i ddiweddaru",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Mae adran gosodiadau gweinydd {0} wedi'i diweddaru",
+    "FailedLoginAttemptWithUserName": "Cais mewngofnodi wedi methu o {0}",
+    "ValueHasBeenAddedToLibrary": "{0} wedi'i hychwanegu at eich llyfrgell gyfryngau",
+    "UserStoppedPlayingItemWithValues": "{0} wedi gorffen chwarae {1} ar {2}",
+    "UserStartedPlayingItemWithValues": "{0} yn chwarae {1} ar {2}",
+    "UserPolicyUpdatedWithName": "Polisi defnyddiwr wedi'i newid ar gyfer {0}",
+    "UserPasswordChangedWithName": "Cyfrinair wedi'i newid ar gyfer defnyddiwr {0}",
+    "UserOnlineFromDevice": "Mae {0} ar-lein o {1}",
+    "UserOfflineFromDevice": "Mae {0} wedi datgysylltu o {1}",
+    "UserLockedOutWithName": "Mae defnyddiwr {0} wedi'i gloi allan",
+    "UserDownloadingItemWithValues": "Mae {0} yn lawrlwytho {1}",
+    "UserDeletedWithName": "Defnyddiwr {0} wedi'i ddileu",
+    "UserCreatedWithName": "Defnyddiwr {0} wedi'i greu",
+    "StartupEmbyServerIsLoading": "Gweinydd Jellyfin yn llwytho. Triwch eto mewn ychydig.",
+    "ServerNameNeedsToBeRestarted": "Mae angen ailddechrau {0}",
+    "PluginUpdatedWithName": "{0} wedi'i ddiweddaru",
+    "PluginUninstalledWithName": "{0} wedi'i ddadosod",
+    "PluginInstalledWithName": "{0} wedi'i osod",
+    "NotificationOptionVideoPlaybackStopped": "Stopiwyd chwarae fideo",
+    "NotificationOptionVideoPlayback": "Dechreuwyd chwarae fideo",
+    "NotificationOptionUserLockedOut": "Defnyddiwr wedi'i gloi allan",
+    "NotificationOptionTaskFailed": "Methwyd cyflawni y dasg a drefnwyd",
+    "NotificationOptionServerRestartRequired": "Mae angen ailgychwyn y gweinydd",
+    "NotificationOptionPluginUpdateInstalled": "Diweddariad ategyn wedi'i osod",
+    "NotificationOptionPluginUninstalled": "Ategyn wedi'i ddadosod",
+    "NotificationOptionPluginInstalled": "Ategyn wedi'i osod",
+    "NotificationOptionNewLibraryContent": "Cynnwys newydd ar gael",
+    "NotificationOptionCameraImageUploaded": "Llun camera wedi'i huwchlwytho",
+    "NotificationOptionApplicationUpdateInstalled": "Diweddariad ap wedi'i osod",
+    "NotificationOptionApplicationUpdateAvailable": "Diweddariad ap ar gael",
+    "NewVersionIsAvailable": "Mae fersiwn diweddarach o'r gweinydd Jellyfin ar gael.",
+    "NameInstallFailed": "Gosodiad {0} wedi methu",
+    "MessageApplicationUpdatedTo": "Gweinydd Jellyfin wedi'i ddiweddaru i {0}",
+    "MessageApplicationUpdated": "Gweinydd Jellyfin wedi'i ddiweddaru",
+    "LabelIpAddressValue": "Cyfeiriad IP: {0}",
+    "ItemRemovedWithName": "{0} wedi'i dynnu o'r llyfrgell",
+    "ItemAddedWithName": "{0} wedi'i adio i'r llyfrgell",
+    "HeaderRecordingGroups": "Grwpiau Recordio",
+    "HeaderFavoriteSongs": "Ffefryn Ganeuon",
+    "HeaderFavoriteShows": "Ffefryn Shoeau",
+    "HeaderFavoriteEpisodes": "Ffefryn Rhaglenni",
+    "TaskDownloadMissingSubtitlesDescription": "Chwilio'r rhyngrwyd am is-deitlau coll yn seiliedig ar gosodiadau metaddata.",
+    "TaskDownloadMissingSubtitles": "Lawrlwytho isdeitlau coll",
+    "TaskCleanTranscodeDescription": "Dileu ffeiliau trawsgodio fwy nag un diwrnod oed.",
+    "External": "Allanol",
+    "TaskKeyframeExtractorDescription": "Echdynnu fframiau o ffeiliau fideo i greu rhestrau chwarae HLS mwy manwl gywir. Gall y dasg hon redeg am amser hir.",
+    "TaskKeyframeExtractor": "Echdynnwr ffram-allwedd",
+    "TaskOptimizeDatabaseDescription": "Crynhoi cronfa ddata ac yn cwtogi'r gofod rhydd. Gallai rhedeg y dasg hon ar ôl sganio'r llyfrgell neu wneud newidiadau eraill sy'n addasu'r cronfa ddata wella perfformiad.",
+    "TaskRefreshChannelsDescription": "Diweddaru gwybodaeth sianeli rhyngrwyd.",
+    "TaskCleanTranscode": "Gwaghau Ffolder Trawsgodau",
+    "TaskUpdatePluginsDescription": "Lawrlwytho ac yn gosod diweddariadau ar gyfer ategion sydd wedi'u gosod i'w diweddaru'n awtomatig.",
+    "TaskUpdatePlugins": "Diweddaru Ategion",
+    "TaskRefreshPeopleDescription": "Yn diweddaru metaddata ar gyfer actorion a chyfarwyddwyr yn eich llyfrgell gyfryngau.",
+    "TaskRefreshChapterImagesDescription": "Creu mân-luniau ar gyfer fideos sydd â phenodau.",
+    "TaskRefreshChapterImages": "Echdynnu Lluniau Pennod",
+    "TaskCleanCacheDescription": "Dileu ffeiliau cache nad oes eu hangen ar y system mwyach.",
+    "TaskCleanCache": "Gwaghau Ffolder Cache",
+    "HearingImpaired": "Nam ar y clyw",
+    "TaskAudioNormalization": "Gwastatau Sain",
+    "TaskAudioNormalizationDescription": "Yn sganio ffeiliau am ddata gwastatau sain.",
+    "TaskRefreshTrickplayImages": "Creuwch lluniau Trickplay",
+    "TaskRefreshTrickplayImagesDescription": "Creu rhagolygon Trickplay ar gyfer fideos mewn llyfrgelloedd gweithredol.",
+    "TaskDownloadMissingLyrics": "Lawrlwytho geiriau coll",
+    "TaskDownloadMissingLyricsDescription": "Lawrlwytho geiriau caneuon",
+    "TaskCleanCollectionsAndPlaylists": "Glanhau casgliadau a rhestrau chwarae",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Dileu eitemau o gasgliadau a rhestrau chwarae sydd ddim yn bodoli bellach.",
+    "TaskExtractMediaSegments": "Sganio Darnau Cyfryngau"
+}

Emby.Server.Implementations/Localization/Core/da.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "Albummer",
+    "AppDeviceValues": "App: {0}, Enhed: {1}",
+    "Application": "Applikation",
+    "Artists": "Kunstnere",
+    "AuthenticationSucceededWithUserName": "{0} er logget ind",
+    "Books": "Bøger",
+    "CameraImageUploadedFrom": "Et nyt kamerabillede er blevet uploadet fra {0}",
+    "Channels": "Kanaler",
+    "ChapterNameValue": "Kapitel {0}",
+    "Collections": "Samlinger",
+    "DeviceOfflineWithName": "{0} har afbrudt forbindelsen",
+    "DeviceOnlineWithName": "{0} er forbundet",
+    "FailedLoginAttemptWithUserName": "Mislykket loginforsøg fra {0}",
+    "Favorites": "Favoritter",
+    "Folders": "Mapper",
+    "Genres": "Genrer",
+    "HeaderAlbumArtists": "Albumkunstnere",
+    "HeaderContinueWatching": "Fortsæt afspilning",
+    "HeaderFavoriteAlbums": "Favoritalbum",
+    "HeaderFavoriteArtists": "Favoritkunstnere",
+    "HeaderFavoriteEpisodes": "Yndlingsafsnit",
+    "HeaderFavoriteShows": "Yndlingsserier",
+    "HeaderFavoriteSongs": "Yndlingssange",
+    "HeaderLiveTV": "Live-TV",
+    "HeaderNextUp": "Næste",
+    "HeaderRecordingGroups": "Optagelsesgrupper",
+    "HomeVideos": "Hjemmevideoer",
+    "Inherit": "Nedarv",
+    "ItemAddedWithName": "{0} blev tilføjet til biblioteket",
+    "ItemRemovedWithName": "{0} blev fjernet fra biblioteket",
+    "LabelIpAddressValue": "IP-adresse: {0}",
+    "LabelRunningTimeValue": "Spilletid: {0}",
+    "Latest": "Seneste",
+    "MessageApplicationUpdated": "Jellyfin Server er blevet opdateret",
+    "MessageApplicationUpdatedTo": "Jellyfin Server er blevet opdateret til {0}",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Serverkonfiguration sektion {0} er blevet opdateret",
+    "MessageServerConfigurationUpdated": "Serverkonfigurationen er blevet opdateret",
+    "MixedContent": "Blandet indhold",
+    "Movies": "Film",
+    "Music": "Musik",
+    "MusicVideos": "Musikvideoer",
+    "NameInstallFailed": "{0} installationen mislykkedes",
+    "NameSeasonNumber": "Sæson {0}",
+    "NameSeasonUnknown": "Ukendt sæson",
+    "NewVersionIsAvailable": "En ny version af Jellyfin Server er tilgængelig.",
+    "NotificationOptionApplicationUpdateAvailable": "Opdatering til applikationen er tilgængelig",
+    "NotificationOptionApplicationUpdateInstalled": "Opdatering til applikationen blev installeret",
+    "NotificationOptionAudioPlayback": "Lydafspilning påbegyndt",
+    "NotificationOptionAudioPlaybackStopped": "Lydafspilning stoppet",
+    "NotificationOptionCameraImageUploaded": "Kamerabillede uploadet",
+    "NotificationOptionInstallationFailed": "Installationen mislykkedes",
+    "NotificationOptionNewLibraryContent": "Nyt indhold tilføjet",
+    "NotificationOptionPluginError": "Plugin-fejl",
+    "NotificationOptionPluginInstalled": "Plugin blev installeret",
+    "NotificationOptionPluginUninstalled": "Plugin blev afinstalleret",
+    "NotificationOptionPluginUpdateInstalled": "Opdatering til plugin blev installeret",
+    "NotificationOptionServerRestartRequired": "Genstart af serveren er påkrævet",
+    "NotificationOptionTaskFailed": "Planlagt opgave er fejlet",
+    "NotificationOptionUserLockedOut": "Bruger er låst ude",
+    "NotificationOptionVideoPlayback": "Videoafspilning påbegyndt",
+    "NotificationOptionVideoPlaybackStopped": "Videoafspilning blev stoppet",
+    "Photos": "Fotos",
+    "Playlists": "Afspilningslister",
+    "Plugin": "Plugin",
+    "PluginInstalledWithName": "{0} blev installeret",
+    "PluginUninstalledWithName": "{0} blev afinstalleret",
+    "PluginUpdatedWithName": "{0} blev opdateret",
+    "ProviderValue": "Udbyder: {0}",
+    "ScheduledTaskFailedWithName": "{0} mislykkedes",
+    "ScheduledTaskStartedWithName": "{0} påbegyndte",
+    "ServerNameNeedsToBeRestarted": "{0} skal genstartes",
+    "Shows": "Serier",
+    "Songs": "Sange",
+    "StartupEmbyServerIsLoading": "Jellyfin er i gang med at starte. Prøv igen om et øjeblik.",
+    "SubtitleDownloadFailureFromForItem": "Undertekster kunne ikke hentes fra {0} til {1}",
+    "Sync": "Synkroniser",
+    "System": "System",
+    "TvShows": "TV-serier",
+    "User": "Bruger",
+    "UserCreatedWithName": "Bruger {0} er blevet oprettet",
+    "UserDeletedWithName": "Brugeren {0} er nu slettet",
+    "UserDownloadingItemWithValues": "{0} henter {1}",
+    "UserLockedOutWithName": "Brugeren {0} er blevet låst ude",
+    "UserOfflineFromDevice": "{0} har afbrudt fra {1}",
+    "UserOnlineFromDevice": "{0} er online fra {1}",
+    "UserPasswordChangedWithName": "Adgangskode er ændret for brugeren {0}",
+    "UserPolicyUpdatedWithName": "Brugerpolitikken er blevet opdateret for {0}",
+    "UserStartedPlayingItemWithValues": "{0} afspiller {1} på {2}",
+    "UserStoppedPlayingItemWithValues": "{0} har afsluttet afspilning af {1} på {2}",
+    "ValueHasBeenAddedToLibrary": "{0} er blevet tilføjet til dit mediebibliotek",
+    "ValueSpecialEpisodeName": "Special - {0}",
+    "VersionNumber": "Version {0}",
+    "TaskDownloadMissingSubtitlesDescription": "Søger på internettet efter manglende undertekster baseret på metadata-konfigurationen.",
+    "TaskDownloadMissingSubtitles": "Hent manglende undertekster",
+    "TaskUpdatePluginsDescription": "Henter og installerer opdateringer for plugins, som er konfigurerede til at blive opdateret automatisk.",
+    "TaskUpdatePlugins": "Opdater plugins",
+    "TaskCleanLogsDescription": "Sletter log-filer som er mere end {0} dage gamle.",
+    "TaskCleanLogs": "Ryd log-mappe",
+    "TaskRefreshLibraryDescription": "Scanner dit mediebibliotek for nye filer og opdateret metadata.",
+    "TaskRefreshLibrary": "Scan mediebibliotek",
+    "TaskCleanCacheDescription": "Sletter cache-filer som systemet ikke længere bruger.",
+    "TaskCleanCache": "Ryd cache-mappe",
+    "TasksChannelsCategory": "Internetkanaler",
+    "TasksApplicationCategory": "Applikation",
+    "TasksLibraryCategory": "Bibliotek",
+    "TasksMaintenanceCategory": "Vedligeholdelse",
+    "TaskRefreshChapterImages": "Udtræk kapitelbilleder",
+    "TaskRefreshChapterImagesDescription": "Laver miniaturebilleder for videoer, der har kapitler.",
+    "TaskRefreshChannelsDescription": "Opdaterer information for internetkanaler.",
+    "TaskRefreshChannels": "Opdater kanaler",
+    "TaskCleanTranscodeDescription": "Fjerner omkodningsfiler, som er mere end 1 dag gamle.",
+    "TaskCleanTranscode": "Tøm omkodningsmappen",
+    "TaskRefreshPeople": "Opdater personer",
+    "TaskRefreshPeopleDescription": "Opdaterer metadata for skuespillere og instruktører i dit mediebibliotek.",
+    "TaskCleanActivityLogDescription": "Sletter linjer i aktivitetsloggen ældre end den konfigurerede alder.",
+    "TaskCleanActivityLog": "Ryd aktivitetslog",
+    "Undefined": "Udefineret",
+    "Forced": "Tvunget",
+    "Default": "Standard",
+    "TaskOptimizeDatabaseDescription": "Komprimerer databasen for at frigøre plads. Denne handling køres efter at have scannet mediebiblioteket, eller efter at have lavet ændringer til databasen.",
+    "TaskOptimizeDatabase": "Optimer database",
+    "TaskKeyframeExtractorDescription": "Udtrækker rammer fra videofiler for at lave mere præcise HLS-playlister. Denne opgave kan tage lang tid.",
+    "TaskKeyframeExtractor": "Udtræk nøglerammer",
+    "External": "Ekstern",
+    "HearingImpaired": "Hørehæmmet",
+    "TaskRefreshTrickplayImages": "Generer trickplay-billeder",
+    "TaskRefreshTrickplayImagesDescription": "Laver trickplay-billeder for videoer i aktiverede biblioteker.",
+    "TaskCleanCollectionsAndPlaylists": "Ryd op i samlinger og afspilningslister",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Fjerner elementer fra samlinger og afspilningslister der ikke eksisterer længere.",
+    "TaskAudioNormalizationDescription": "Skanner filer for data vedrørende lydnormalisering.",
+    "TaskAudioNormalization": "Lydnormalisering",
+    "TaskDownloadMissingLyricsDescription": "Søger på internettet efter manglende sangtekster baseret på metadata-konfigurationen",
+    "TaskDownloadMissingLyrics": "Hent manglende sangtekster",
+    "TaskExtractMediaSegments": "Scan for mediesegmenter",
+    "TaskMoveTrickplayImages": "Migrer billedelokationer for trickplay-billeder",
+    "TaskMoveTrickplayImagesDescription": "Flyt eksisterende trickplay-billeder jævnfør biblioteksindstillinger.",
+    "TaskExtractMediaSegmentsDescription": "Udtrækker eller henter mediesegmenter fra plugins som understøtter MediaSegment.",
+    "CleanupUserDataTask": "Brugerdata oprydningsopgave",
+    "CleanupUserDataTaskDescription": "Rydder alle brugerdata (eks. visning- og favoritstatus) fra medier, der har været utilgængelige i mindst 90 dage."
+}

Emby.Server.Implementations/Localization/Core/de.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "Alben",
+    "AppDeviceValues": "App: {0}, Gerät: {1}",
+    "Application": "Anwendung",
+    "Artists": "Interpreten",
+    "AuthenticationSucceededWithUserName": "{0} erfolgreich authentifiziert",
+    "Books": "Bücher",
+    "CameraImageUploadedFrom": "Ein neues Kamerabild wurde von {0} hochgeladen",
+    "Channels": "Kanäle",
+    "ChapterNameValue": "Kapitel {0}",
+    "Collections": "Sammlungen",
+    "DeviceOfflineWithName": "{0} ist offline",
+    "DeviceOnlineWithName": "{0} ist online",
+    "FailedLoginAttemptWithUserName": "Anmeldung von {0} fehlgeschlagen",
+    "Favorites": "Favoriten",
+    "Folders": "Verzeichnisse",
+    "Genres": "Genres",
+    "HeaderAlbumArtists": "Album-Interpreten",
+    "HeaderContinueWatching": "Weiterschauen",
+    "HeaderFavoriteAlbums": "Lieblingsalben",
+    "HeaderFavoriteArtists": "Lieblingsinterpreten",
+    "HeaderFavoriteEpisodes": "Lieblingsepisoden",
+    "HeaderFavoriteShows": "Lieblingsserien",
+    "HeaderFavoriteSongs": "Lieblingssongs",
+    "HeaderLiveTV": "Live TV",
+    "HeaderNextUp": "Als Nächstes",
+    "HeaderRecordingGroups": "Aufnahme-Gruppen",
+    "HomeVideos": "Heimvideos",
+    "Inherit": "Vererben",
+    "ItemAddedWithName": "{0} wurde der Bibliothek hinzugefügt",
+    "ItemRemovedWithName": "{0} wurde aus der Bibliothek entfernt",
+    "LabelIpAddressValue": "IP-Adresse: {0}",
+    "LabelRunningTimeValue": "Laufzeit: {0}",
+    "Latest": "Neueste",
+    "MessageApplicationUpdated": "Jellyfin-Server wurde aktualisiert",
+    "MessageApplicationUpdatedTo": "Jellyfin-Server wurde auf Version {0} aktualisiert",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Der Server-Einstellungsbereich {0} wurde aktualisiert",
+    "MessageServerConfigurationUpdated": "Servereinstellungen wurden aktualisiert",
+    "MixedContent": "Gemischte Inhalte",
+    "Movies": "Filme",
+    "Music": "Musik",
+    "MusicVideos": "Musikvideos",
+    "NameInstallFailed": "Installation von {0} fehlgeschlagen",
+    "NameSeasonNumber": "Staffel {0}",
+    "NameSeasonUnknown": "Staffel unbekannt",
+    "NewVersionIsAvailable": "Eine neue Jellyfin-Serverversion steht zum Download bereit.",
+    "NotificationOptionApplicationUpdateAvailable": "Anwendungsaktualisierung verfügbar",
+    "NotificationOptionApplicationUpdateInstalled": "Anwendungsaktualisierung installiert",
+    "NotificationOptionAudioPlayback": "Audio wird abgespielt",
+    "NotificationOptionAudioPlaybackStopped": "Audiowiedergabe gestoppt",
+    "NotificationOptionCameraImageUploaded": "Foto hochgeladen",
+    "NotificationOptionInstallationFailed": "Installation fehlgeschlagen",
+    "NotificationOptionNewLibraryContent": "Neuer Inhalt hinzugefügt",
+    "NotificationOptionPluginError": "Plugin-Fehler",
+    "NotificationOptionPluginInstalled": "Plugin installiert",
+    "NotificationOptionPluginUninstalled": "Plugin deinstalliert",
+    "NotificationOptionPluginUpdateInstalled": "Pluginaktualisierung installiert",
+    "NotificationOptionServerRestartRequired": "Serverneustart notwendig",
+    "NotificationOptionTaskFailed": "Geplante Aufgabe fehlgeschlagen",
+    "NotificationOptionUserLockedOut": "Benutzer gesperrt",
+    "NotificationOptionVideoPlayback": "Video wird abgespielt",
+    "NotificationOptionVideoPlaybackStopped": "Videowiedergabe gestoppt",
+    "Photos": "Fotos",
+    "Playlists": "Wiedergabelisten",
+    "Plugin": "Plugin",
+    "PluginInstalledWithName": "{0} wurde installiert",
+    "PluginUninstalledWithName": "{0} wurde deinstalliert",
+    "PluginUpdatedWithName": "{0} wurde aktualisiert",
+    "ProviderValue": "Anbieter: {0}",
+    "ScheduledTaskFailedWithName": "{0} ist fehlgeschlagen",
+    "ScheduledTaskStartedWithName": "{0} wurde gestartet",
+    "ServerNameNeedsToBeRestarted": "{0} muss neu gestartet werden",
+    "Shows": "Serien",
+    "Songs": "Lieder",
+    "StartupEmbyServerIsLoading": "Jellyfin-Server lädt. Bitte versuche es gleich noch einmal.",
+    "SubtitleDownloadFailureFromForItem": "Untertitel von {0} für {1} konnten nicht heruntergeladen werden",
+    "Sync": "Synchronisation",
+    "System": "System",
+    "TvShows": "Serien",
+    "User": "Benutzer",
+    "UserCreatedWithName": "Benutzer {0} wurde erstellt",
+    "UserDeletedWithName": "Benutzer {0} wurde gelöscht",
+    "UserDownloadingItemWithValues": "{0} lädt {1} herunter",
+    "UserLockedOutWithName": "Benutzer {0} wurde gesperrt",
+    "UserOfflineFromDevice": "{0} wurde getrennt von {1}",
+    "UserOnlineFromDevice": "{0} ist online von {1}",
+    "UserPasswordChangedWithName": "Das Passwort für Benutzer {0} wurde geändert",
+    "UserPolicyUpdatedWithName": "Benutzerrichtlinie von {0} wurde aktualisiert",
+    "UserStartedPlayingItemWithValues": "{0} hat die Wiedergabe von {1} auf {2} gestartet",
+    "UserStoppedPlayingItemWithValues": "{0} hat die Wiedergabe von {1} auf {2} beendet",
+    "ValueHasBeenAddedToLibrary": "{0} wurde deiner Bibliothek hinzugefügt",
+    "ValueSpecialEpisodeName": "Extra – {0}",
+    "VersionNumber": "Version {0}",
+    "TaskDownloadMissingSubtitlesDescription": "Sucht im Internet basierend auf den Metadaten-Einstellungen nach fehlenden Untertiteln.",
+    "TaskDownloadMissingSubtitles": "Fehlende Untertitel herunterladen",
+    "TaskRefreshChannelsDescription": "Aktualisiert Internet-Kanal-Informationen.",
+    "TaskRefreshChannels": "Kanäle aktualisieren",
+    "TaskCleanTranscodeDescription": "Löscht Transkodierungsdateien, die älter als einen Tag sind.",
+    "TaskCleanTranscode": "Transkodierungsverzeichnis leeren",
+    "TaskUpdatePluginsDescription": "Lädt Updates für Plugins herunter, welche für automatische Updates konfiguriert sind und installiert diese.",
+    "TaskUpdatePlugins": "Plugins aktualisieren",
+    "TaskRefreshPeopleDescription": "Aktualisiert Metadaten für Schauspieler und Regisseure in deinen Bibliotheken.",
+    "TaskRefreshPeople": "Personen aktualisieren",
+    "TaskCleanLogsDescription": "Lösche Log-Dateien, die älter als {0} Tage sind.",
+    "TaskCleanLogs": "Protokollverzeichnis leeren",
+    "TaskRefreshLibraryDescription": "Durchsucht deine Medienbibliothek nach neuen Dateien und aktualisiert Metadaten.",
+    "TaskRefreshLibrary": "Medien-Bibliothek scannen",
+    "TaskRefreshChapterImagesDescription": "Erstellt Vorschaubilder für Videokapitel.",
+    "TaskRefreshChapterImages": "Kapitelvorschauen erstellen",
+    "TaskCleanCacheDescription": "Löscht Cache-Dateien, die vom System nicht mehr benötigt werden.",
+    "TaskCleanCache": "Cache-Verzeichnis leeren",
+    "TasksChannelsCategory": "Internet-Kanäle",
+    "TasksApplicationCategory": "Anwendung",
+    "TasksLibraryCategory": "Bibliothek",
+    "TasksMaintenanceCategory": "Wartung",
+    "TaskCleanActivityLogDescription": "Löscht Aktivitätsprotokolleinträge, die älter als das konfigurierte Alter sind.",
+    "TaskCleanActivityLog": "Aktivitätsverlauf bereinigen",
+    "Undefined": "Undefiniert",
+    "Forced": "Erzwungen",
+    "Default": "Standard",
+    "TaskOptimizeDatabaseDescription": "Komprimiert die Datenbank und trimmt den freien Speicherplatz. Die Ausführung dieser Aufgabe nach dem Scannen der Bibliothek oder nach anderen Änderungen, die Datenbankänderungen implizieren, kann die Leistung verbessern.",
+    "TaskOptimizeDatabase": "Datenbank optimieren",
+    "TaskKeyframeExtractorDescription": "Extrahiert Keyframes aus Videodateien, um präzisere HLS-Playlisten zu erzeugen. Dieser Vorgang kann sehr lange dauern.",
+    "TaskKeyframeExtractor": "Keyframe-Extraktor",
+    "External": "Extern",
+    "HearingImpaired": "Hörgeschädigt",
+    "TaskRefreshTrickplayImages": "Trickplay-Bilder generieren",
+    "TaskRefreshTrickplayImagesDescription": "Erstellt ein Trickplay-Vorschauen für Videos in aktivierten Bibliotheken.",
+    "TaskCleanCollectionsAndPlaylists": "Sammlungen und Playlisten aufräumen",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Löscht nicht mehr vorhandene Einträge aus den Sammlungen und Playlisten.",
+    "TaskAudioNormalization": "Audio Normalisierung",
+    "TaskAudioNormalizationDescription": "Durchsucht Dateien nach Audionormalisierungsdaten.",
+    "TaskDownloadMissingLyricsDescription": "Lädt Songtexte herunter",
+    "TaskDownloadMissingLyrics": "Fehlende Songtexte herunterladen",
+    "TaskExtractMediaSegments": "Mediensegmente scannen",
+    "TaskExtractMediaSegmentsDescription": "Extrahiert oder empfängt Mediensegmente von Plugins die Mediensegmente nutzen.",
+    "TaskMoveTrickplayImages": "Verzeichnis für Trickplay-Bilder migrieren",
+    "TaskMoveTrickplayImagesDescription": "Trickplay-Bilder werden entsprechend der Bibliothekseinstellungen verschoben.",
+    "CleanupUserDataTask": "Aufgabe zur Bereinigung von Benutzerdaten",
+    "CleanupUserDataTaskDescription": "Löscht alle Benutzerdaten (Abspielstatus, Favoritenstatus, usw.) von Medien, die seit mindestens 90 Tagen nicht mehr vorhanden sind."
+}

Emby.Server.Implementations/Localization/Core/el.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "Άλμπουμ",
+    "AppDeviceValues": "Εφαρμογή: {0}, Συσκευή: {1}",
+    "Application": "Εφαρμογή",
+    "Artists": "Καλλιτέχνες",
+    "AuthenticationSucceededWithUserName": "Ο χρήστης {0} επαληθεύτηκε επιτυχώς",
+    "Books": "Βιβλία",
+    "CameraImageUploadedFrom": "Μια νέα φωτογραφία φορτώθηκε από {0}",
+    "Channels": "Κανάλια",
+    "ChapterNameValue": "Κεφάλαιο {0}",
+    "Collections": "Συλλογές",
+    "DeviceOfflineWithName": "Ο/Η {0} αποσυνδέθηκε",
+    "DeviceOnlineWithName": "Ο/Η {0} συνδέθηκε",
+    "FailedLoginAttemptWithUserName": "Αποτυχία προσπάθειας σύνδεσης από {0}",
+    "Favorites": "Αγαπημένα",
+    "Folders": "Φάκελοι",
+    "Genres": "Είδη",
+    "HeaderAlbumArtists": "Καλλιτέχνες άλμπουμ",
+    "HeaderContinueWatching": "Συνεχίστε την παρακολούθηση",
+    "HeaderFavoriteAlbums": "Αγαπημένα Άλμπουμ",
+    "HeaderFavoriteArtists": "Αγαπημένοι Καλλιτέχνες",
+    "HeaderFavoriteEpisodes": "Αγαπημένα Επεισόδια",
+    "HeaderFavoriteShows": "Αγαπημένες Σειρές",
+    "HeaderFavoriteSongs": "Αγαπημένα Τραγούδια",
+    "HeaderLiveTV": "Ζωντανή Τηλεόραση",
+    "HeaderNextUp": "Επόμενο",
+    "HeaderRecordingGroups": "Ομάδες Ηχογράφησης",
+    "HomeVideos": "Προσωπικά Βίντεο",
+    "Inherit": "Κληρονόμηση",
+    "ItemAddedWithName": "Το {0} προστέθηκε στη βιβλιοθήκη",
+    "ItemRemovedWithName": "Το {0} διαγράφτηκε από τη βιβλιοθήκη",
+    "LabelIpAddressValue": "Διεύθυνση IP: {0}",
+    "LabelRunningTimeValue": "Διάρκεια: {0}",
+    "Latest": "Πρόσφατα",
+    "MessageApplicationUpdated": "Ο διακομιστής Jellyfin έχει ενημερωθεί",
+    "MessageApplicationUpdatedTo": "Ο διακομιστής Jellyfin αναβαθμίστηκε στην έκδοση {0}",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Η ενότητα {0} ρύθμισης παραμέτρων του διακομιστή έχει ενημερωθεί",
+    "MessageServerConfigurationUpdated": "Η ρύθμιση παραμέτρων του διακομιστή έχει ενημερωθεί",
+    "MixedContent": "Ανάμεικτο Περιεχόμενο",
+    "Movies": "Ταινίες",
+    "Music": "Μουσική",
+    "MusicVideos": "Μουσικά Βίντεο",
+    "NameInstallFailed": "H εγκατάσταση του {0} απέτυχε",
+    "NameSeasonNumber": "Κύκλος {0}",
+    "NameSeasonUnknown": "Άγνωστος Κύκλος",
+    "NewVersionIsAvailable": "Μια νέα έκδοση του διακομιστή Jellyfin είναι διαθέσιμη για λήψη.",
+    "NotificationOptionApplicationUpdateAvailable": "Διαθέσιμη ενημερωμένη έκδοση εφαρμογής",
+    "NotificationOptionApplicationUpdateInstalled": "Η ενημέρωση εφαρμογής εγκαταστάθηκε",
+    "NotificationOptionAudioPlayback": "Η αναπαραγωγή ήχου ξεκίνησε",
+    "NotificationOptionAudioPlaybackStopped": "Η αναπαραγωγή ήχου σταμάτησε",
+    "NotificationOptionCameraImageUploaded": "Μεταφορτώθηκε φωτογραφία απο κάμερα",
+    "NotificationOptionInstallationFailed": "Αποτυχία εγκατάστασης",
+    "NotificationOptionNewLibraryContent": "Προστέθηκε νέο περιεχόμενο",
+    "NotificationOptionPluginError": "Αποτυχία του πρόσθετου",
+    "NotificationOptionPluginInstalled": "Το πρόσθετο εγκαταστάθηκε",
+    "NotificationOptionPluginUninstalled": "Το πρόσθετο απεγκαταστάθηκε",
+    "NotificationOptionPluginUpdateInstalled": "Η ενημέρωση του πρόσθετου εγκαταστάθηκε",
+    "NotificationOptionServerRestartRequired": "Ο διακομιστής χρειάζεται επανεκκίνηση",
+    "NotificationOptionTaskFailed": "Αποτυχία προγραμματισμένης εργασίας",
+    "NotificationOptionUserLockedOut": "Ο χρήστης αποκλείστηκε",
+    "NotificationOptionVideoPlayback": "Η αναπαραγωγή βίντεο ξεκίνησε",
+    "NotificationOptionVideoPlaybackStopped": "Η αναπαραγωγή βίντεο σταμάτησε",
+    "Photos": "Φωτογραφίες",
+    "Playlists": "Λίστες αναπαραγωγής",
+    "Plugin": "Πρόσθετο",
+    "PluginInstalledWithName": "Το {0} εγκαταστάθηκε",
+    "PluginUninstalledWithName": "Το {0} έχει απεγκατασταθεί",
+    "PluginUpdatedWithName": "Το {0} ενημερώθηκε",
+    "ProviderValue": "Πάροχος: {0}",
+    "ScheduledTaskFailedWithName": "{0} αποτυχία",
+    "ScheduledTaskStartedWithName": "{0} ξεκίνησε",
+    "ServerNameNeedsToBeRestarted": "{0} χρειάζεται επανεκκίνηση",
+    "Shows": "Σειρές",
+    "Songs": "Τραγούδια",
+    "StartupEmbyServerIsLoading": "Ο διακομιστής Jellyfin φορτώνει. Περιμένετε λίγο και δοκιμάστε ξανά.",
+    "SubtitleDownloadFailureFromForItem": "Αποτυχίες μεταφόρτωσης υποτίτλων από {0} για {1}",
+    "Sync": "Συγχρονισμός",
+    "System": "Σύστημα",
+    "TvShows": "Τηλεοπτικές Σειρές",
+    "User": "Χρήστης",
+    "UserCreatedWithName": "Ο χρήστης {0} δημιουργήθηκε",
+    "UserDeletedWithName": "Ο χρήστης {0} έχει διαγραφεί",
+    "UserDownloadingItemWithValues": "{0} κατεβάζει {1}",
+    "UserLockedOutWithName": "Ο χρήστης {0} αποκλείστηκε",
+    "UserOfflineFromDevice": "{0} αποσυνδέθηκε από {1}",
+    "UserOnlineFromDevice": "{0} είναι online απο {1}",
+    "UserPasswordChangedWithName": "Ο κωδικός του χρήστη {0} έχει αλλάξει",
+    "UserPolicyUpdatedWithName": "Η πολιτική χρήστη έχει ενημερωθεί για {0}",
+    "UserStartedPlayingItemWithValues": "{0} παίζει {1} σε {2}",
+    "UserStoppedPlayingItemWithValues": "{0} τελείωσε να παίζει {1} σε {2}",
+    "ValueHasBeenAddedToLibrary": "{0} προστέθηκαν στη βιβλιοθήκη πολυμέσων σας",
+    "ValueSpecialEpisodeName": "Σπέσιαλ - {0}",
+    "VersionNumber": "Έκδοση {0}",
+    "TaskRefreshPeople": "Ανανέωση Ατόμων",
+    "TaskCleanLogsDescription": "Διαγράφει αρχεία καταγραφής που είναι πάνω από {0} ημέρες.",
+    "TaskCleanLogs": "Εκκαθάριση Καταλόγου Καταγραφής",
+    "TaskRefreshLibraryDescription": "Σαρώνει την βιβλιοθήκη πολυμέσων σας για νέα αρχεία και ανανεώνει τα μεταδεδομένα.",
+    "TaskRefreshLibrary": "Σάρωση Βιβλιοθήκης Πολυμέσων",
+    "TaskRefreshChapterImagesDescription": "Δημιουργεί μικρογραφίες για βίντεο που έχουν κεφάλαια.",
+    "TaskRefreshChapterImages": "Εξαγωγή Εικόνων Κεφαλαίου",
+    "TaskCleanCacheDescription": "Διαγράφει αρχεία προσωρινής μνήμης που δεν χρειάζονται πλέον το σύστημα.",
+    "TaskCleanCache": "Καθαρισμός Καταλόγου Προσωρινής Μνήμης",
+    "TasksChannelsCategory": "Κανάλια Διαδικτύου",
+    "TasksApplicationCategory": "Εφαρμογή",
+    "TasksLibraryCategory": "Βιβλιοθήκη",
+    "TasksMaintenanceCategory": "Συντήρηση",
+    "TaskDownloadMissingSubtitlesDescription": "Ψάχνει στο διαδίκτυο για υπότιτλους που λείπουν με βάση τη διαμόρφωση μεταδεδομένων.",
+    "TaskDownloadMissingSubtitles": "Λήψη υπότιτλων που λείπουν",
+    "TaskRefreshChannelsDescription": "Ανανεώνει τις πληροφορίες καναλιού στο διαδικτύου.",
+    "TaskRefreshChannels": "Ανανέωση Καναλιών",
+    "TaskCleanTranscodeDescription": "Διαγράφει αρχεία διακωδικοποίησης άνω της μίας ημέρας.",
+    "TaskCleanTranscode": "Εκκαθάριση Kαταλόγου Διακωδικοποίησης",
+    "TaskUpdatePluginsDescription": "Κατεβάζει και εγκαθιστά ενημερώσεις για τα πρόσθετα που έχουν ρυθμιστεί για αυτόματη ενημέρωση.",
+    "TaskUpdatePlugins": "Ενημέρωση Πρόσθετων",
+    "TaskRefreshPeopleDescription": "Ενημερώνει τα μεταδεδομένα για ηθοποιούς και σκηνοθέτες στη βιβλιοθήκη πολυμέσων σας.",
+    "TaskCleanActivityLogDescription": "Διαγράφει καταχωρήσεις απο το αρχείο καταγραφής παλαιότερες από την επιλεγμένη ηλικία.",
+    "TaskCleanActivityLog": "Εκκαθάριση Αρχείου Καταγραφής Δραστηριοτήτων",
+    "Undefined": "Απροσδιόριστο",
+    "Forced": "Εξαναγκασμένο",
+    "Default": "Προεπιλογή",
+    "TaskOptimizeDatabaseDescription": "Συμπιέζει τη βάση δεδομένων και δημιουργεί ελεύθερο χώρο. Η εκτέλεση αυτής της εργασίας μετά τη σάρωση της βιβλιοθήκης ή την πραγματοποίηση άλλων αλλαγών που συνεπάγονται τροποποιήσεις της βάσης δεδομένων μπορεί να βελτιώσει την απόδοση.",
+    "TaskOptimizeDatabase": "Βελτιστοποίηση βάσης δεδομένων",
+    "TaskKeyframeExtractorDescription": "Εξάγει καρέ από αρχεία βίντεο για να δημιουργήσει πιο ακριβείς λίστες αναπαραγωγής HLS. Αυτή η διεργασία μπορεί να πάρει χρόνο.",
+    "TaskKeyframeExtractor": "Εξαγωγέας βασικών καρέ βίντεο",
+    "External": "Εξωτερικό",
+    "HearingImpaired": "Με προβλήματα ακοής",
+    "TaskRefreshTrickplayImages": "Δημιουργία εικόνων Trickplay",
+    "TaskRefreshTrickplayImagesDescription": "Δημιουργεί προεπισκοπήσεις trickplay για βίντεο σε ενεργοποιημένες βιβλιοθήκες.",
+    "TaskAudioNormalization": "Ομοιομορφία ήχου",
+    "TaskAudioNormalizationDescription": "Ανίχνευση αρχείων για δεδομένα ομοιομορφίας ήχου.",
+    "TaskCleanCollectionsAndPlaylists": "Καθαρισμός συλλογών και λιστών αναπαραγωγής",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Αφαιρούνται στοιχεία από τις συλλογές και τις λίστες αναπαραγωγής που δεν υπάρχουν πλέον.",
+    "TaskMoveTrickplayImages": "Αλλαγή τοποθεσίας εικόνων Trickplay",
+    "TaskDownloadMissingLyrics": "Λήψη στίχων που λείπουν",
+    "TaskMoveTrickplayImagesDescription": "Μετακινεί τα υπάρχοντα αρχεία trickplay σύμφωνα με τις ρυθμίσεις της βιβλιοθήκης.",
+    "TaskDownloadMissingLyricsDescription": "Κατεβάζει στίχους για τραγούδια",
+    "TaskExtractMediaSegments": "Σάρωση τμημάτων πολυμέσων",
+    "TaskExtractMediaSegmentsDescription": "Εξάγει ή βρίσκει τμήματα πολυμέσων από επεκτάσεις που χρησιμοποιούν το MediaSegment.",
+    "CleanupUserDataTaskDescription": "Καθαρίζει όλα τα δεδομένα χρήστη (κατάσταση παρακολούθησης, κατάσταση αγαπημένων κ.λπ.) από πολυμέσα που δεν υπάρχουν πλέον για τουλάχιστον 90 ημέρες.",
+    "CleanupUserDataTask": "Εργασία εκκαθάρισης δεδομένων χρήστη"
+}

Emby.Server.Implementations/Localization/Core/en-GB.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "Albums",
+    "AppDeviceValues": "App: {0}, Device: {1}",
+    "Application": "Application",
+    "Artists": "Artists",
+    "AuthenticationSucceededWithUserName": "{0} successfully authenticated",
+    "Books": "Books",
+    "CameraImageUploadedFrom": "A new camera image has been uploaded from {0}",
+    "Channels": "Channels",
+    "ChapterNameValue": "Chapter {0}",
+    "Collections": "Collections",
+    "DeviceOfflineWithName": "{0} has disconnected",
+    "DeviceOnlineWithName": "{0} is connected",
+    "FailedLoginAttemptWithUserName": "Failed login attempt from {0}",
+    "Favorites": "Favourites",
+    "Folders": "Folders",
+    "Genres": "Genres",
+    "HeaderAlbumArtists": "Album artists",
+    "HeaderContinueWatching": "Continue Watching",
+    "HeaderFavoriteAlbums": "Favourite Albums",
+    "HeaderFavoriteArtists": "Favourite Artists",
+    "HeaderFavoriteEpisodes": "Favourite Episodes",
+    "HeaderFavoriteShows": "Favourite Shows",
+    "HeaderFavoriteSongs": "Favourite Songs",
+    "HeaderLiveTV": "Live TV",
+    "HeaderNextUp": "Next Up",
+    "HeaderRecordingGroups": "Recording Groups",
+    "HomeVideos": "Home Videos",
+    "Inherit": "Inherit",
+    "ItemAddedWithName": "{0} was added to the library",
+    "ItemRemovedWithName": "{0} was removed from the library",
+    "LabelIpAddressValue": "IP address: {0}",
+    "LabelRunningTimeValue": "Running time: {0}",
+    "Latest": "Latest",
+    "MessageApplicationUpdated": "Jellyfin Server has been updated",
+    "MessageApplicationUpdatedTo": "Jellyfin Server has been updated to {0}",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Server configuration section {0} has been updated",
+    "MessageServerConfigurationUpdated": "Server configuration has been updated",
+    "MixedContent": "Mixed content",
+    "Movies": "Movies",
+    "Music": "Music",
+    "MusicVideos": "Music Videos",
+    "NameInstallFailed": "{0} installation failed",
+    "NameSeasonNumber": "Season {0}",
+    "NameSeasonUnknown": "Season Unknown",
+    "NewVersionIsAvailable": "A new version of Jellyfin Server is available for download.",
+    "NotificationOptionApplicationUpdateAvailable": "Application update available",
+    "NotificationOptionApplicationUpdateInstalled": "Application update installed",
+    "NotificationOptionAudioPlayback": "Audio playback started",
+    "NotificationOptionAudioPlaybackStopped": "Audio playback stopped",
+    "NotificationOptionCameraImageUploaded": "Camera image uploaded",
+    "NotificationOptionInstallationFailed": "Installation failure",
+    "NotificationOptionNewLibraryContent": "New content added",
+    "NotificationOptionPluginError": "Plugin failure",
+    "NotificationOptionPluginInstalled": "Plugin installed",
+    "NotificationOptionPluginUninstalled": "Plugin uninstalled",
+    "NotificationOptionPluginUpdateInstalled": "Plugin update installed",
+    "NotificationOptionServerRestartRequired": "Server restart required",
+    "NotificationOptionTaskFailed": "Scheduled task failure",
+    "NotificationOptionUserLockedOut": "User locked out",
+    "NotificationOptionVideoPlayback": "Video playback started",
+    "NotificationOptionVideoPlaybackStopped": "Video playback stopped",
+    "Photos": "Photos",
+    "Playlists": "Playlists",
+    "Plugin": "Plugin",
+    "PluginInstalledWithName": "{0} was installed",
+    "PluginUninstalledWithName": "{0} was uninstalled",
+    "PluginUpdatedWithName": "{0} was updated",
+    "ProviderValue": "Provider: {0}",
+    "ScheduledTaskFailedWithName": "{0} failed",
+    "ScheduledTaskStartedWithName": "{0} started",
+    "ServerNameNeedsToBeRestarted": "{0} needs to be restarted",
+    "Shows": "Shows",
+    "Songs": "Songs",
+    "StartupEmbyServerIsLoading": "Jellyfin Server is loading. Please try again shortly.",
+    "SubtitleDownloadFailureFromForItem": "Subtitles failed to download from {0} for {1}",
+    "Sync": "Sync",
+    "System": "System",
+    "TvShows": "TV Shows",
+    "User": "User",
+    "UserCreatedWithName": "User {0} has been created",
+    "UserDeletedWithName": "User {0} has been deleted",
+    "UserDownloadingItemWithValues": "{0} is downloading {1}",
+    "UserLockedOutWithName": "User {0} has been locked out",
+    "UserOfflineFromDevice": "{0} has disconnected from {1}",
+    "UserOnlineFromDevice": "{0} is online from {1}",
+    "UserPasswordChangedWithName": "Password has been changed for user {0}",
+    "UserPolicyUpdatedWithName": "User policy has been updated for {0}",
+    "UserStartedPlayingItemWithValues": "{0} has started playing {1}",
+    "UserStoppedPlayingItemWithValues": "{0} has finished playing {1} on {2}",
+    "ValueHasBeenAddedToLibrary": "{0} has been added to your media library",
+    "ValueSpecialEpisodeName": "Special - {0}",
+    "VersionNumber": "Version {0}",
+    "TaskDownloadMissingSubtitlesDescription": "Searches the internet for missing subtitles based on metadata configuration.",
+    "TaskDownloadMissingSubtitles": "Download missing subtitles",
+    "TaskRefreshChannelsDescription": "Refreshes internet channel information.",
+    "TaskRefreshChannels": "Refresh Channels",
+    "TaskCleanTranscodeDescription": "Deletes transcode files more than one day old.",
+    "TaskCleanTranscode": "Clean Transcode Directory",
+    "TaskUpdatePluginsDescription": "Downloads and installs updates for plugins that are configured to update automatically.",
+    "TaskUpdatePlugins": "Update Plugins",
+    "TaskRefreshPeopleDescription": "Updates metadata for actors and directors in your media library.",
+    "TaskRefreshPeople": "Refresh People",
+    "TaskCleanLogsDescription": "Deletes log files that are more than {0} days old.",
+    "TaskCleanLogs": "Clean Log Directory",
+    "TaskRefreshLibraryDescription": "Scans your media library for new files and refreshes metadata.",
+    "TaskRefreshLibrary": "Scan Media Library",
+    "TaskRefreshChapterImagesDescription": "Creates thumbnails for videos that have chapters.",
+    "TaskRefreshChapterImages": "Extract Chapter Images",
+    "TaskCleanCacheDescription": "Deletes cache files no longer needed by the system.",
+    "TaskCleanCache": "Clean Cache Directory",
+    "TasksChannelsCategory": "Internet Channels",
+    "TasksApplicationCategory": "Application",
+    "TasksLibraryCategory": "Library",
+    "TasksMaintenanceCategory": "Maintenance",
+    "TaskCleanActivityLogDescription": "Deletes activity log entries older than the configured age.",
+    "TaskCleanActivityLog": "Clean Activity Log",
+    "Undefined": "Undefined",
+    "Forced": "Forced",
+    "Default": "Default",
+    "TaskOptimizeDatabaseDescription": "Compacts database and truncates free space. Running this task after scanning the library or doing other changes that imply database modifications might improve performance.",
+    "TaskOptimizeDatabase": "Optimise database",
+    "TaskKeyframeExtractorDescription": "Extracts keyframes from video files to create more precise HLS playlists. This task may run for a long time.",
+    "TaskKeyframeExtractor": "Keyframe Extractor",
+    "External": "External",
+    "HearingImpaired": "Hearing Impaired",
+    "TaskRefreshTrickplayImages": "Generate Trickplay Images",
+    "TaskRefreshTrickplayImagesDescription": "Creates trickplay previews for videos in enabled libraries.",
+    "TaskCleanCollectionsAndPlaylists": "Clean up collections and playlists",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Removes items from collections and playlists that no longer exist.",
+    "TaskAudioNormalization": "Audio Normalisation",
+    "TaskAudioNormalizationDescription": "Scans files for audio normalisation data.",
+    "TaskDownloadMissingLyrics": "Download missing lyrics",
+    "TaskDownloadMissingLyricsDescription": "Downloads lyrics for songs",
+    "TaskExtractMediaSegments": "Media Segment Scan",
+    "TaskExtractMediaSegmentsDescription": "Extracts or obtains media segments from MediaSegment enabled plugins.",
+    "TaskMoveTrickplayImages": "Migrate Trickplay Image Location",
+    "TaskMoveTrickplayImagesDescription": "Moves existing trickplay files according to the library settings.",
+    "CleanupUserDataTask": "User data cleanup task",
+    "CleanupUserDataTaskDescription": "Cleans all user data (Watch state, favourite status etc) from media that is no longer present for at least 90 days."
+}

Emby.Server.Implementations/Localization/Core/en-US.json

@@ -0,0 +1,141 @@
+{
+    "Albums": "Albums",
+    "AppDeviceValues": "App: {0}, Device: {1}",
+    "Application": "Application",
+    "Artists": "Artists",
+    "AuthenticationSucceededWithUserName": "{0} successfully authenticated",
+    "Books": "Books",
+    "CameraImageUploadedFrom": "A new camera image has been uploaded from {0}",
+    "Channels": "Channels",
+    "ChapterNameValue": "Chapter {0}",
+    "Collections": "Collections",
+    "Default": "Default",
+    "DeviceOfflineWithName": "{0} has disconnected",
+    "DeviceOnlineWithName": "{0} is connected",
+    "External": "External",
+    "FailedLoginAttemptWithUserName": "Failed login attempt from {0}",
+    "Favorites": "Favorites",
+    "Folders": "Folders",
+    "Forced": "Forced",
+    "Genres": "Genres",
+    "HeaderAlbumArtists": "Album artists",
+    "HeaderContinueWatching": "Continue Watching",
+    "HeaderFavoriteAlbums": "Favorite Albums",
+    "HeaderFavoriteArtists": "Favorite Artists",
+    "HeaderFavoriteEpisodes": "Favorite Episodes",
+    "HeaderFavoriteShows": "Favorite Shows",
+    "HeaderFavoriteSongs": "Favorite Songs",
+    "HeaderLiveTV": "Live TV",
+    "HeaderNextUp": "Next Up",
+    "HeaderRecordingGroups": "Recording Groups",
+    "HearingImpaired": "Hearing Impaired",
+    "HomeVideos": "Home Videos",
+    "Inherit": "Inherit",
+    "ItemAddedWithName": "{0} was added to the library",
+    "ItemRemovedWithName": "{0} was removed from the library",
+    "LabelIpAddressValue": "IP address: {0}",
+    "LabelRunningTimeValue": "Running time: {0}",
+    "Latest": "Latest",
+    "MessageApplicationUpdated": "Jellyfin Server has been updated",
+    "MessageApplicationUpdatedTo": "Jellyfin Server has been updated to {0}",
+    "MessageNamedServerConfigurationUpdatedWithValue": "Server configuration section {0} has been updated",
+    "MessageServerConfigurationUpdated": "Server configuration has been updated",
+    "MixedContent": "Mixed content",
+    "Movies": "Movies",
+    "Music": "Music",
+    "MusicVideos": "Music Videos",
+    "NameInstallFailed": "{0} installation failed",
+    "NameSeasonNumber": "Season {0}",
+    "NameSeasonUnknown": "Season Unknown",
+    "NewVersionIsAvailable": "A new version of Jellyfin Server is available for download.",
+    "NotificationOptionApplicationUpdateAvailable": "Application update available",
+    "NotificationOptionApplicationUpdateInstalled": "Application update installed",
+    "NotificationOptionAudioPlayback": "Audio playback started",
+    "NotificationOptionAudioPlaybackStopped": "Audio playback stopped",
+    "NotificationOptionCameraImageUploaded": "Camera image uploaded",
+    "NotificationOptionInstallationFailed": "Installation failure",
+    "NotificationOptionNewLibraryContent": "New content added",
+    "NotificationOptionPluginError": "Plugin failure",
+    "NotificationOptionPluginInstalled": "Plugin installed",
+    "NotificationOptionPluginUninstalled": "Plugin uninstalled",
+    "NotificationOptionPluginUpdateInstalled": "Plugin update installed",
+    "NotificationOptionServerRestartRequired": "Server restart required",
+    "NotificationOptionTaskFailed": "Scheduled task failure",
+    "NotificationOptionUserLockedOut": "User locked out",
+    "NotificationOptionVideoPlayback": "Video playback started",
+    "NotificationOptionVideoPlaybackStopped": "Video playback stopped",
+    "Photos": "Photos",
+    "Playlists": "Playlists",
+    "Plugin": "Plugin",
+    "PluginInstalledWithName": "{0} was installed",
+    "PluginUninstalledWithName": "{0} was uninstalled",
+    "PluginUpdatedWithName": "{0} was updated",
+    "ProviderValue": "Provider: {0}",
+    "ScheduledTaskFailedWithName": "{0} failed",
+    "ScheduledTaskStartedWithName": "{0} started",
+    "ServerNameNeedsToBeRestarted": "{0} needs to be restarted",
+    "Shows": "Shows",
+    "Songs": "Songs",
+    "StartupEmbyServerIsLoading": "Jellyfin Server is loading. Please try again shortly.",
+    "SubtitleDownloadFailureFromForItem": "Subtitles failed to download from {0} for {1}",
+    "Sync": "Sync",
+    "System": "System",
+    "TvShows": "TV Shows",
+    "Undefined": "Undefined",
+    "User": "User",
+    "UserCreatedWithName": "User {0} has been created",
+    "UserDeletedWithName": "User {0} has been deleted",
+    "UserDownloadingItemWithValues": "{0} is downloading {1}",
+    "UserLockedOutWithName": "User {0} has been locked out",
+    "UserOfflineFromDevice": "{0} has disconnected from {1}",
+    "UserOnlineFromDevice": "{0} is online from {1}",
+    "UserPasswordChangedWithName": "Password has been changed for user {0}",
+    "UserPolicyUpdatedWithName": "User policy has been updated for {0}",
+    "UserStartedPlayingItemWithValues": "{0} is playing {1} on {2}",
+    "UserStoppedPlayingItemWithValues": "{0} has finished playing {1} on {2}",
+    "ValueHasBeenAddedToLibrary": "{0} has been added to your media library",
+    "ValueSpecialEpisodeName": "Special - {0}",
+    "VersionNumber": "Version {0}",
+    "TasksMaintenanceCategory": "Maintenance",
+    "TasksLibraryCategory": "Library",
+    "TasksApplicationCategory": "Application",
+    "TasksChannelsCategory": "Internet Channels",
+    "TaskCleanActivityLog": "Clean Activity Log",
+    "TaskCleanActivityLogDescription": "Deletes activity log entries older than the configured age.",
+    "TaskCleanCache": "Clean Cache Directory",
+    "TaskCleanCacheDescription": "Deletes cache files no longer needed by the system.",
+    "TaskRefreshChapterImages": "Extract Chapter Images",
+    "TaskRefreshChapterImagesDescription": "Creates thumbnails for videos that have chapters.",
+    "TaskAudioNormalization": "Audio Normalization",
+    "TaskAudioNormalizationDescription": "Scans files for audio normalization data.",
+    "TaskRefreshLibrary": "Scan Media Library",
+    "TaskRefreshLibraryDescription": "Scans your media library for new files and refreshes metadata.",
+    "TaskCleanLogs": "Clean Log Directory",
+    "TaskCleanLogsDescription": "Deletes log files that are more than {0} days old.",
+    "TaskRefreshPeople": "Refresh People",
+    "TaskRefreshPeopleDescription": "Updates metadata for actors and directors in your media library.",
+    "TaskRefreshTrickplayImages": "Generate Trickplay Images",
+    "TaskRefreshTrickplayImagesDescription": "Creates trickplay previews for videos in enabled libraries.",
+    "TaskUpdatePlugins": "Update Plugins",
+    "TaskUpdatePluginsDescription": "Downloads and installs updates for plugins that are configured to update automatically.",
+    "TaskCleanTranscode": "Clean Transcode Directory",
+    "TaskCleanTranscodeDescription": "Deletes transcode files more than one day old.",
+    "TaskRefreshChannels": "Refresh Channels",
+    "TaskRefreshChannelsDescription": "Refreshes internet channel information.",
+    "TaskDownloadMissingLyrics": "Download missing lyrics",
+    "TaskDownloadMissingLyricsDescription": "Downloads lyrics for songs",
+    "TaskDownloadMissingSubtitles": "Download missing subtitles",
+    "TaskDownloadMissingSubtitlesDescription": "Searches the internet for missing subtitles based on metadata configuration.",
+    "TaskOptimizeDatabase": "Optimize database",
+    "TaskOptimizeDatabaseDescription": "Compacts database and truncates free space. Running this task after scanning the library or doing other changes that imply database modifications might improve performance.",
+    "TaskKeyframeExtractor": "Keyframe Extractor",
+    "TaskKeyframeExtractorDescription": "Extracts keyframes from video files to create more precise HLS playlists. This task may run for a long time.",
+    "TaskCleanCollectionsAndPlaylists": "Clean up collections and playlists",
+    "TaskCleanCollectionsAndPlaylistsDescription": "Removes items from collections and playlists that no longer exist.",
+    "TaskExtractMediaSegments": "Media Segment Scan",
+    "TaskExtractMediaSegmentsDescription": "Extracts or obtains media segments from MediaSegment enabled plugins.",
+    "TaskMoveTrickplayImages": "Migrate Trickplay Image Location",
+    "TaskMoveTrickplayImagesDescription": "Moves existing trickplay files according to the library settings.",
+    "CleanupUserDataTask": "User data cleanup task",
+    "CleanupUserDataTaskDescription": "Cleans all user data (Watch state, favorite status etc) from media that is no longer present for at least 90 days."
+}