fix resources (offline background and font) (#211)

* fix xmltv artwork for jf and emby

* proxy jellyfin and emby artwork for xmltv

.github/workflows/release.yml

@@ -42,7 +42,7 @@ jobs:
           #release_name_cli="ErsatzTV.CommandLine-$tag-${{ matrix.target }}"
 
           # Build everything
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}"
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}" /property:PublishSingleFile=true --self-contained true
           #dotnet publish ErsatzTV.CommandLine/ErsatzTV.CommandLine.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name_cli" /property:InformationalVersion="${tag:1}-${{ matrix.target }}"
 
           # Pack files

ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record DisconnectEmby : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class DisconnectEmbyHandler : MediatR.IRequestHandler<DisconnectEmby, Either<BaseError, Unit>>
+    {
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly IEntityLocker _entityLocker;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public DisconnectEmbyHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IEmbySecretStore embySecretStore,
+            IEntityLocker entityLocker,
+            ISearchIndex searchIndex)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _embySecretStore = embySecretStore;
+            _entityLocker = entityLocker;
+            _searchIndex = searchIndex;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DisconnectEmby request,
+            CancellationToken cancellationToken)
+        {
+            List<int> ids = await _mediaSourceRepository.DeleteAllEmby();
+            await _searchIndex.RemoveItems(ids);
+            await _embySecretStore.DeleteAll();
+            _entityLocker.UnlockRemoteMediaSource<EmbyMediaSource>();
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/SaveEmbySecrets.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Emby;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record SaveEmbySecrets(EmbySecrets Secrets) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

@@ -0,0 +1,60 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class SaveEmbySecretsHandler : MediatR.IRequestHandler<SaveEmbySecrets, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+        private readonly IEmbyApiClient _embyApiClient;
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SaveEmbySecretsHandler(
+            IEmbySecretStore embySecretStore,
+            IEmbyApiClient embyApiClient,
+            IMediaSourceRepository mediaSourceRepository,
+            ChannelWriter<IEmbyBackgroundServiceRequest> channel)
+        {
+            _embySecretStore = embySecretStore;
+            _embyApiClient = embyApiClient;
+            _mediaSourceRepository = mediaSourceRepository;
+            _channel = channel;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(SaveEmbySecrets request, CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(PerformSave)
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Validation<BaseError, Parameters>> Validate(SaveEmbySecrets request)
+        {
+            Either<BaseError, EmbyServerInformation> maybeServerInformation = await _embyApiClient
+                .GetServerInformation(request.Secrets.Address, request.Secrets.ApiKey);
+
+            return maybeServerInformation.Match(
+                info => Validation<BaseError, Parameters>.Success(new Parameters(request.Secrets, info)),
+                error => error);
+        }
+
+        private async Task<Unit> PerformSave(Parameters parameters)
+        {
+            await _embySecretStore.SaveSecrets(parameters.Secrets);
+            await _mediaSourceRepository.UpsertEmby(
+                parameters.Secrets.Address,
+                parameters.ServerInformation.ServerName,
+                parameters.ServerInformation.OperatingSystem);
+            await _channel.WriteAsync(new SynchronizeEmbyMediaSources());
+
+            return Unit.Default;
+        }
+
+        private record Parameters(EmbySecrets Secrets, EmbyServerInformation ServerInformation);
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record SynchronizeEmbyLibraries(int EmbyMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+        IEmbyBackgroundServiceRequest;
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

@@ -0,0 +1,109 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class
+        SynchronizeEmbyLibrariesHandler : MediatR.IRequestHandler<SynchronizeEmbyLibraries, Either<BaseError, Unit>>
+    {
+        private readonly IEmbyApiClient _embyApiClient;
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly ILogger<SynchronizeEmbyLibrariesHandler> _logger;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeEmbyLibrariesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IEmbySecretStore embySecretStore,
+            IEmbyApiClient embyApiClient,
+            ILogger<SynchronizeEmbyLibrariesHandler> logger)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _embySecretStore = embySecretStore;
+            _embyApiClient = embyApiClient;
+            _logger = logger;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(
+            SynchronizeEmbyLibraries request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(SynchronizeLibraries)
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeEmbyLibraries request) =>
+            MediaSourceMustExist(request)
+                .BindT(MediaSourceMustHaveActiveConnection)
+                .BindT(MediaSourceMustHaveApiKey);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> MediaSourceMustExist(
+            SynchronizeEmbyLibraries request) =>
+            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
+                .Map(o => o.ToValidation<BaseError>("Emby media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            EmbyMediaSource embyMediaSource)
+        {
+            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
+            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+                .ToValidation<BaseError>("Emby media source requires an active connection");
+        }
+
+        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+            ConnectionParameters connectionParameters)
+        {
+            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
+            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+                .Filter(match => match)
+                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+                .ToValidation<BaseError>("Emby media source requires an api key");
+        }
+
+        private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
+        {
+            Either<BaseError, List<EmbyLibrary>> maybeLibraries = await _embyApiClient.GetLibraries(
+                connectionParameters.ActiveConnection.Address,
+                connectionParameters.ApiKey);
+
+            await maybeLibraries.Match(
+                libraries =>
+                {
+                    var existing = connectionParameters.EmbyMediaSource.Libraries.OfType<EmbyLibrary>()
+                        .ToList();
+                    var toAdd = libraries.Filter(library => existing.All(l => l.ItemId != library.ItemId)).ToList();
+                    var toRemove = existing.Filter(library => libraries.All(l => l.ItemId != library.ItemId)).ToList();
+                    return _mediaSourceRepository.UpdateLibraries(
+                        connectionParameters.EmbyMediaSource.Id,
+                        toAdd,
+                        toRemove);
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Unable to synchronize libraries from emby server {EmbyServer}: {Error}",
+                        connectionParameters.EmbyMediaSource.ServerName,
+                        error.Value);
+
+                    return Task.CompletedTask;
+                });
+
+            return Unit.Default;
+        }
+
+        private record ConnectionParameters(
+            EmbyMediaSource EmbyMediaSource,
+            EmbyConnection ActiveConnection)
+        {
+            public string ApiKey { get; set; }
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs

@@ -0,0 +1,23 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>,
+        IEmbyBackgroundServiceRequest
+    {
+        int EmbyLibraryId { get; }
+        bool ForceScan { get; }
+    }
+
+    public record SynchronizeEmbyLibraryByIdIfNeeded(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+    {
+        public bool ForceScan => false;
+    }
+
+    public record ForceSynchronizeEmbyLibraryById(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+    {
+        public bool ForceScan => true;
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs

@@ -0,0 +1,172 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class SynchronizeEmbyLibraryByIdHandler :
+        IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+        IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
+    {
+        private readonly IConfigElementRepository _configElementRepository;
+        private readonly IEmbyMovieLibraryScanner _embyMovieLibraryScanner;
+
+        private readonly IEmbySecretStore _embySecretStore;
+        private readonly IEmbyTelevisionLibraryScanner _embyTelevisionLibraryScanner;
+        private readonly IEntityLocker _entityLocker;
+        private readonly ILibraryRepository _libraryRepository;
+        private readonly ILogger<SynchronizeEmbyLibraryByIdHandler> _logger;
+
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeEmbyLibraryByIdHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            IEmbySecretStore embySecretStore,
+            IEmbyMovieLibraryScanner embyMovieLibraryScanner,
+            IEmbyTelevisionLibraryScanner embyTelevisionLibraryScanner,
+            ILibraryRepository libraryRepository,
+            IEntityLocker entityLocker,
+            IConfigElementRepository configElementRepository,
+            ILogger<SynchronizeEmbyLibraryByIdHandler> logger)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _embySecretStore = embySecretStore;
+            _embyMovieLibraryScanner = embyMovieLibraryScanner;
+            _embyTelevisionLibraryScanner = embyTelevisionLibraryScanner;
+            _libraryRepository = libraryRepository;
+            _entityLocker = entityLocker;
+            _configElementRepository = configElementRepository;
+            _logger = logger;
+        }
+
+        public Task<Either<BaseError, string>> Handle(
+            ForceSynchronizeEmbyLibraryById request,
+            CancellationToken cancellationToken) => Handle(request);
+
+        public Task<Either<BaseError, string>> Handle(
+            SynchronizeEmbyLibraryByIdIfNeeded request,
+            CancellationToken cancellationToken) => Handle(request);
+
+        private Task<Either<BaseError, string>>
+            Handle(ISynchronizeEmbyLibraryById request) =>
+            Validate(request)
+                .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
+                .Bind(v => v.ToEitherAsync());
+
+        private async Task<Unit> Synchronize(RequestParameters parameters)
+        {
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            if (parameters.ForceScan || lastScan < DateTimeOffset.Now - TimeSpan.FromHours(6))
+            {
+                switch (parameters.Library.MediaKind)
+                {
+                    case LibraryMediaKind.Movies:
+                        await _embyMovieLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection.Address,
+                            parameters.ConnectionParameters.ApiKey,
+                            parameters.Library,
+                            parameters.FFprobePath);
+                        break;
+                    case LibraryMediaKind.Shows:
+                        await _embyTelevisionLibraryScanner.ScanLibrary(
+                            parameters.ConnectionParameters.ActiveConnection.Address,
+                            parameters.ConnectionParameters.ApiKey,
+                            parameters.Library,
+                            parameters.FFprobePath);
+                        break;
+                }
+
+                parameters.Library.LastScan = DateTime.UtcNow;
+                await _libraryRepository.UpdateLastScan(parameters.Library);
+            }
+            else
+            {
+                _logger.LogDebug(
+                    "Skipping unforced scan of emby media library {Name}",
+                    parameters.Library.Name);
+            }
+
+            _entityLocker.UnlockLibrary(parameters.Library.Id);
+            return Unit.Default;
+        }
+
+        private async Task<Validation<BaseError, RequestParameters>> Validate(
+            ISynchronizeEmbyLibraryById request) =>
+            (await ValidateConnection(request), await EmbyLibraryMustExist(request), await ValidateFFprobePath())
+            .Apply(
+                (connectionParameters, embyLibrary, ffprobePath) => new RequestParameters(
+                    connectionParameters,
+                    embyLibrary,
+                    request.ForceScan,
+                    ffprobePath
+                ));
+
+        private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
+            ISynchronizeEmbyLibraryById request) =>
+            EmbyMediaSourceMustExist(request)
+                .BindT(MediaSourceMustHaveActiveConnection)
+                .BindT(MediaSourceMustHaveApiKey);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
+            ISynchronizeEmbyLibraryById request) =>
+            _mediaSourceRepository.GetEmbyByLibraryId(request.EmbyLibraryId)
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        $"Emby media source for library {request.EmbyLibraryId} does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            EmbyMediaSource embyMediaSource)
+        {
+            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
+            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+                .ToValidation<BaseError>("Emby media source requires an active connection");
+        }
+
+        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+            ConnectionParameters connectionParameters)
+        {
+            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
+            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+                .Filter(match => match)
+                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+                .ToValidation<BaseError>("Emby media source requires an api key");
+        }
+
+        private Task<Validation<BaseError, EmbyLibrary>> EmbyLibraryMustExist(
+            ISynchronizeEmbyLibraryById request) =>
+            _mediaSourceRepository.GetEmbyLibrary(request.EmbyLibraryId)
+                .Map(v => v.ToValidation<BaseError>($"Emby library {request.EmbyLibraryId} does not exist."));
+
+        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
+            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
+                .FilterT(File.Exists)
+                .Map(
+                    ffprobePath =>
+                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
+
+        private record RequestParameters(
+            ConnectionParameters ConnectionParameters,
+            EmbyLibrary Library,
+            bool ForceScan,
+            string FFprobePath);
+
+        private record ConnectionParameters(
+            EmbyMediaSource EmbyMediaSource,
+            EmbyConnection ActiveConnection)
+        {
+            public string ApiKey { get; set; }
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record SynchronizeEmbyMediaSources : IRequest<Either<BaseError, List<EmbyMediaSource>>>,
+        IEmbyBackgroundServiceRequest;
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmbyMediaSources,
+        Either<BaseError, List<EmbyMediaSource>>>
+    {
+        private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public SynchronizeEmbyMediaSourcesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            ChannelWriter<IEmbyBackgroundServiceRequest> channel)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, List<EmbyMediaSource>>> Handle(
+            SynchronizeEmbyMediaSources request,
+            CancellationToken cancellationToken)
+        {
+            List<EmbyMediaSource> mediaSources = await _mediaSourceRepository.GetAllEmby();
+            foreach (EmbyMediaSource mediaSource in mediaSources)
+            {
+                // await _channel.WriteAsync(new SynchronizeEmbyAdminUserId(mediaSource.Id), cancellationToken);
+                await _channel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);
+            }
+
+            return mediaSources;
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record UpdateEmbyLibraryPreferences
+        (List<EmbyLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+    public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);
+}

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class
+        UpdateEmbyLibraryPreferencesHandler : MediatR.IRequestHandler<UpdateEmbyLibraryPreferences,
+            Either<BaseError, Unit>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public UpdateEmbyLibraryPreferencesHandler(
+            IMediaSourceRepository mediaSourceRepository,
+            ISearchIndex searchIndex)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _searchIndex = searchIndex;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            UpdateEmbyLibraryPreferences request,
+            CancellationToken cancellationToken)
+        {
+            var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
+            List<int> ids = await _mediaSourceRepository.DisableEmbyLibrarySync(toDisable);
+            await _searchIndex.RemoveItems(ids);
+
+            IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
+            await _mediaSourceRepository.EnableEmbyLibrarySync(toEnable);
+
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public record UpdateEmbyPathReplacements(
+        int EmbyMediaSourceId,
+        List<EmbyPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+    public record EmbyPathReplacementItem(int Id, string EmbyPath, string LocalPath);
+}

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Emby.Commands
+{
+    public class UpdateEmbyPathReplacementsHandler : MediatR.IRequestHandler<UpdateEmbyPathReplacements,
+        Either<BaseError, Unit>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public UpdateEmbyPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<Either<BaseError, Unit>> Handle(
+            UpdateEmbyPathReplacements request,
+            CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(pms => MergePathReplacements(request, pms))
+                .Bind(v => v.ToEitherAsync());
+
+        private Task<Unit> MergePathReplacements(
+            UpdateEmbyPathReplacements request,
+            EmbyMediaSource embyMediaSource)
+        {
+            embyMediaSource.PathReplacements ??= new List<EmbyPathReplacement>();
+
+            var incoming = request.PathReplacements.Map(Project).ToList();
+
+            var toAdd = incoming.Filter(r => r.Id < 1).ToList();
+            var toRemove = embyMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
+            var toUpdate = incoming.Except(toAdd).ToList();
+
+            return _mediaSourceRepository.UpdatePathReplacements(embyMediaSource.Id, toAdd, toUpdate, toRemove);
+        }
+
+        private static EmbyPathReplacement Project(EmbyPathReplacementItem vm) =>
+            new() { Id = vm.Id, EmbyPath = vm.EmbyPath, LocalPath = vm.LocalPath };
+
+        private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request) =>
+            EmbyMediaSourceMustExist(request);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
+            UpdateEmbyPathReplacements request) =>
+            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        $"Emby media source {request.EmbyMediaSourceId} does not exist."));
+    }
+}

ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Emby
+{
+    public record EmbyConnectionParametersViewModel(string Address);
+}

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Emby
+{
+    public record EmbyLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems)
+        : LibraryViewModel("Emby", Id, Name, MediaKind);
+}

ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs

@@ -0,0 +1,9 @@
+using ErsatzTV.Application.MediaSources;
+
+namespace ErsatzTV.Application.Emby
+{
+    public record EmbyMediaSourceViewModel(int Id, string Name, string Address) : RemoteMediaSourceViewModel(
+        Id,
+        Name,
+        Address);
+}

ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Emby
+{
+    public record EmbyPathReplacementViewModel(int Id, string EmbyPath, string LocalPath);
+}

ErsatzTV.Application/Emby/Mapper.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Emby
+{
+    internal static class Mapper
+    {
+        internal static EmbyMediaSourceViewModel ProjectToViewModel(EmbyMediaSource embyMediaSource) =>
+            new(
+                embyMediaSource.Id,
+                embyMediaSource.ServerName,
+                embyMediaSource.Connections.HeadOrNone().Match(c => c.Address, string.Empty));
+
+        internal static EmbyLibraryViewModel ProjectToViewModel(EmbyLibrary library) =>
+            new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
+
+        internal static EmbyPathReplacementViewModel ProjectToViewModel(EmbyPathReplacement pathReplacement) =>
+            new(pathReplacement.Id, pathReplacement.EmbyPath, pathReplacement.LocalPath);
+    }
+}

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetAllEmbyMediaSources : IRequest<List<EmbyMediaSourceViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Emby.Mapper;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class GetAllEmbyMediaSourcesHandler : IRequestHandler<GetAllEmbyMediaSources, List<EmbyMediaSourceViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetAllEmbyMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<EmbyMediaSourceViewModel>> Handle(
+            GetAllEmbyMediaSources request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetAllEmby().Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParameters.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyConnectionParameters : IRequest<Either<BaseError, EmbyConnectionParametersViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
+        Either<BaseError, EmbyConnectionParametersViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IMemoryCache _memoryCache;
+
+        public GetEmbyConnectionParametersHandler(
+            IMemoryCache memoryCache,
+            IMediaSourceRepository mediaSourceRepository)
+        {
+            _memoryCache = memoryCache;
+            _mediaSourceRepository = mediaSourceRepository;
+        }
+
+        public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
+            GetEmbyConnectionParameters request,
+            CancellationToken cancellationToken)
+        {
+            if (_memoryCache.TryGetValue(request, out EmbyConnectionParametersViewModel parameters))
+            {
+                return parameters;
+            }
+
+            Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
+                await Validate()
+                    .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address))
+                    .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
+
+            return maybeParameters.Match(
+                p =>
+                {
+                    _memoryCache.Set(request, p, TimeSpan.FromHours(1));
+                    return maybeParameters;
+                },
+                error => error);
+        }
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+            EmbyMediaSourceMustExist()
+                .BindT(MediaSourceMustHaveActiveConnection);
+
+        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
+            _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        "Emby media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            EmbyMediaSource embyMediaSource)
+        {
+            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.FirstOrDefault();
+            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+                .ToValidation<BaseError>("Emby media source requires an active connection");
+        }
+
+        private record ConnectionParameters(
+            EmbyMediaSource EmbyMediaSource,
+            EmbyConnection ActiveConnection);
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceId.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyLibrariesBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyLibraryViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceIdHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Emby.Mapper;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class
+        GetEmbyLibrariesBySourceIdHandler : IRequestHandler<GetEmbyLibrariesBySourceId, List<EmbyLibraryViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetEmbyLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<EmbyLibraryViewModel>> Handle(
+            GetEmbyLibrariesBySourceId request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetEmbyLibraries(request.EmbyMediaSourceId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceById.cs

@@ -0,0 +1,7 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyMediaSourceById(int EmbyMediaSourceId) : IRequest<Option<EmbyMediaSourceViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs

@@ -0,0 +1,23 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Emby.Mapper;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class
+        GetEmbyMediaSourceByIdHandler : IRequestHandler<GetEmbyMediaSourceById, Option<EmbyMediaSourceViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetEmbyMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<Option<EmbyMediaSourceViewModel>> Handle(
+            GetEmbyMediaSourceById request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbyPathReplacementsBySourceId
+        (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceIdHandler.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Emby.Mapper;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class GetEmbyPathReplacementsBySourceIdHandler : IRequestHandler<GetEmbyPathReplacementsBySourceId,
+        List<EmbyPathReplacementViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+
+        public GetEmbyPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+            _mediaSourceRepository = mediaSourceRepository;
+
+        public Task<List<EmbyPathReplacementViewModel>> Handle(
+            GetEmbyPathReplacementsBySourceId request,
+            CancellationToken cancellationToken) =>
+            _mediaSourceRepository.GetEmbyPathReplacements(request.EmbyMediaSourceId)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+    }
+}

ErsatzTV.Application/Emby/Queries/GetEmbySecrets.cs

@@ -0,0 +1,7 @@
+using ErsatzTV.Core.Emby;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public record GetEmbySecrets : IRequest<EmbySecrets>;
+}

ErsatzTV.Application/Emby/Queries/GetEmbySecretsHandler.cs

@@ -0,0 +1,19 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Interfaces.Emby;
+using MediatR;
+
+namespace ErsatzTV.Application.Emby.Queries
+{
+    public class GetEmbySecretsHandler : IRequestHandler<GetEmbySecrets, EmbySecrets>
+    {
+        private readonly IEmbySecretStore _embySecretStore;
+
+        public GetEmbySecretsHandler(IEmbySecretStore embySecretStore) =>
+            _embySecretStore = embySecretStore;
+
+        public Task<EmbySecrets> Handle(GetEmbySecrets request, CancellationToken cancellationToken) =>
+            _embySecretStore.ReadSecrets();
+    }
+}

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -16,7 +16,7 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
       <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
     </ItemGroup>
 

ErsatzTV.Application/IEmbyBackgroundServiceRequest.cs

@@ -0,0 +1,6 @@
+namespace ErsatzTV.Application
+{
+    public interface IEmbyBackgroundServiceRequest
+    {
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfinHandler.cs

@@ -2,6 +2,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Repositories;
@@ -36,7 +37,7 @@ namespace ErsatzTV.Application.Jellyfin.Commands
             List<int> ids = await _mediaSourceRepository.DeleteAllJellyfin();
             await _searchIndex.RemoveItems(ids);
             await _jellyfinSecretStore.DeleteAll();
-            _entityLocker.UnlockJellyfin();
+            _entityLocker.UnlockRemoteMediaSource<JellyfinMediaSource>();
 
             return Unit.Default;
         }

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs

@@ -57,7 +57,7 @@ namespace ErsatzTV.Application.Jellyfin.Commands
             return await maybeUserId.Match(
                 userId =>
                 {
-                    _logger.LogDebug("Jellyfin admin user id is {UserId}", userId);
+                    // _logger.LogDebug("Jellyfin admin user id is {UserId}", userId);
                     _memoryCache.Set($"jellyfin_admin_user_id.{parameters.JellyfinMediaSource.Id}", userId);
                     return Task.FromResult<Either<BaseError, Unit>>(Unit.Default);
                 },

ErsatzTV.Application/Jellyfin/JellyfinConnectionParametersViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Jellyfin
+{
+    public record JellyfinConnectionParametersViewModel(string Address);
+}

ErsatzTV.Application/Jellyfin/JellyfinMediaSourceViewModel.cs

@@ -2,5 +2,8 @@
 
 namespace ErsatzTV.Application.Jellyfin
 {
-    public record JellyfinMediaSourceViewModel(int Id, string Name, string Address) : MediaSourceViewModel(Id, Name);
+    public record JellyfinMediaSourceViewModel(int Id, string Name, string Address) : RemoteMediaSourceViewModel(
+        Id,
+        Name,
+        Address);
 }

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParameters.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public record GetJellyfinConnectionParameters : IRequest<Either<BaseError, JellyfinConnectionParametersViewModel>>;
+}

ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParametersHandler.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace ErsatzTV.Application.Jellyfin.Queries
+{
+    public class GetJellyfinConnectionParametersHandler : IRequestHandler<GetJellyfinConnectionParameters,
+        Either<BaseError, JellyfinConnectionParametersViewModel>>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IMemoryCache _memoryCache;
+
+        public GetJellyfinConnectionParametersHandler(
+            IMemoryCache memoryCache,
+            IMediaSourceRepository mediaSourceRepository)
+        {
+            _memoryCache = memoryCache;
+            _mediaSourceRepository = mediaSourceRepository;
+        }
+
+        public async Task<Either<BaseError, JellyfinConnectionParametersViewModel>> Handle(
+            GetJellyfinConnectionParameters request,
+            CancellationToken cancellationToken)
+        {
+            if (_memoryCache.TryGetValue(request, out JellyfinConnectionParametersViewModel parameters))
+            {
+                return parameters;
+            }
+
+            Either<BaseError, JellyfinConnectionParametersViewModel> maybeParameters =
+                await Validate()
+                    .MapT(cp => new JellyfinConnectionParametersViewModel(cp.ActiveConnection.Address))
+                    .Map(v => v.ToEither<JellyfinConnectionParametersViewModel>());
+
+            return maybeParameters.Match(
+                p =>
+                {
+                    _memoryCache.Set(request, p, TimeSpan.FromHours(1));
+                    return maybeParameters;
+                },
+                error => error);
+        }
+
+        private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+            JellyfinMediaSourceMustExist()
+                .BindT(MediaSourceMustHaveActiveConnection);
+
+        private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist() =>
+            _mediaSourceRepository.GetAllJellyfin().Map(list => list.HeadOrNone())
+                .Map(
+                    v => v.ToValidation<BaseError>(
+                        "Jellyfin media source does not exist."));
+
+        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+            JellyfinMediaSource jellyfinMediaSource)
+        {
+            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.FirstOrDefault();
+            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+        }
+
+        private record ConnectionParameters(
+            JellyfinMediaSource JellyfinMediaSource,
+            JellyfinConnection ActiveConnection);
+    }
+}

ErsatzTV.Application/Libraries/Mapper.cs

@@ -1,4 +1,5 @@
 using System;
+using ErsatzTV.Application.Emby;
 using ErsatzTV.Application.Jellyfin;
 using ErsatzTV.Core.Domain;
 
@@ -12,6 +13,7 @@ namespace ErsatzTV.Application.Libraries
                 LocalLibrary l => ProjectToViewModel(l),
                 PlexLibrary p => new PlexLibraryViewModel(p.Id, p.Name, p.MediaKind),
                 JellyfinLibrary j => new JellyfinLibraryViewModel(j.Id, j.Name, j.MediaKind, j.ShouldSyncItems),
+                EmbyLibrary e => new EmbyLibraryViewModel(e.Id, e.Name, e.MediaKind, e.ShouldSyncItems),
                 _ => throw new ArgumentOutOfRangeException(nameof(library))
             };
 

ErsatzTV.Application/Libraries/Queries/GetAllLibrariesHandler.cs

@@ -31,6 +31,7 @@ namespace ErsatzTV.Application.Libraries.Queries
                 LocalLibrary => true,
                 PlexLibrary plex => plex.ShouldSyncItems,
                 JellyfinLibrary jellyfin => jellyfin.ShouldSyncItems,
+                EmbyLibrary emby => emby.ShouldSyncItems,
                 _ => false
             };
     }

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Linq;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Jellyfin;
 using LanguageExt;
 using static LanguageExt.Prelude;
 
@@ -10,17 +12,19 @@ namespace ErsatzTV.Application.MediaCards
     {
         internal static TelevisionShowCardViewModel ProjectToViewModel(
             ShowMetadata showMetadata,
-            Option<JellyfinMediaSource> maybeJellyfin) =>
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 showMetadata.ShowId,
                 showMetadata.Title,
                 showMetadata.Year?.ToString(),
                 showMetadata.SortTitle,
-                GetPoster(showMetadata, maybeJellyfin));
+                GetPoster(showMetadata, maybeJellyfin, maybeEmby));
 
         internal static TelevisionSeasonCardViewModel ProjectToViewModel(
             Season season,
-            Option<JellyfinMediaSource> maybeJellyfin) =>
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 season.Show.ShowMetadata.HeadOrNone().Match(m => m.Title ?? string.Empty, () => string.Empty),
                 season.Id,
@@ -28,12 +32,14 @@ namespace ErsatzTV.Application.MediaCards
                 GetSeasonName(season.SeasonNumber),
                 string.Empty,
                 GetSeasonName(season.SeasonNumber),
-                season.SeasonMetadata.HeadOrNone().Map(sm => GetPoster(sm, maybeJellyfin)).IfNone(string.Empty),
+                season.SeasonMetadata.HeadOrNone().Map(sm => GetPoster(sm, maybeJellyfin, maybeEmby))
+                    .IfNone(string.Empty),
                 season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString());
 
         internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
             EpisodeMetadata episodeMetadata,
-            Option<JellyfinMediaSource> maybeJellyfin) =>
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 episodeMetadata.EpisodeId,
                 episodeMetadata.ReleaseDate ?? DateTime.MinValue,
@@ -47,17 +53,18 @@ namespace ErsatzTV.Application.MediaCards
                 episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(
                     em => em.Plot ?? string.Empty,
                     () => string.Empty),
-                GetThumbnail(episodeMetadata, maybeJellyfin));
+                GetThumbnail(episodeMetadata, maybeJellyfin, maybeEmby));
 
         internal static MovieCardViewModel ProjectToViewModel(
             MovieMetadata movieMetadata,
-            Option<JellyfinMediaSource> maybeJellyfin) =>
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 movieMetadata.MovieId,
                 movieMetadata.Title,
                 movieMetadata.Year?.ToString(),
                 movieMetadata.SortTitle,
-                GetPoster(movieMetadata, maybeJellyfin));
+                GetPoster(movieMetadata, maybeJellyfin, maybeEmby));
 
         internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
             new(
@@ -66,7 +73,7 @@ namespace ErsatzTV.Application.MediaCards
                 musicVideoMetadata.MusicVideo.Artist.ArtistMetadata.Head().Title,
                 musicVideoMetadata.SortTitle,
                 musicVideoMetadata.Plot,
-                GetThumbnail(musicVideoMetadata, None));
+                GetThumbnail(musicVideoMetadata, None, None));
 
         internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
             new(
@@ -74,37 +81,48 @@ namespace ErsatzTV.Application.MediaCards
                 artistMetadata.Title,
                 artistMetadata.Disambiguation,
                 artistMetadata.SortTitle,
-                GetThumbnail(artistMetadata, None));
+                GetThumbnail(artistMetadata, None, None));
 
         internal static CollectionCardResultsViewModel
-            ProjectToViewModel(Collection collection, Option<JellyfinMediaSource> maybeJellyfin) =>
+            ProjectToViewModel(
+                Collection collection,
+                Option<JellyfinMediaSource> maybeJellyfin,
+                Option<EmbyMediaSource> maybeEmby) =>
             new(
                 collection.Name,
                 collection.MediaItems.OfType<Movie>().Map(
-                    m => ProjectToViewModel(m.MovieMetadata.Head(), maybeJellyfin) with
+                    m => ProjectToViewModel(m.MovieMetadata.Head(), maybeJellyfin, maybeEmby) with
                     {
                         CustomIndex = GetCustomIndex(collection, m.Id)
                     }).ToList(),
-                collection.MediaItems.OfType<Show>().Map(s => ProjectToViewModel(s.ShowMetadata.Head(), maybeJellyfin))
+                collection.MediaItems.OfType<Show>()
+                    .Map(s => ProjectToViewModel(s.ShowMetadata.Head(), maybeJellyfin, maybeEmby))
+                    .ToList(),
+                collection.MediaItems.OfType<Season>().Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby))
                     .ToList(),
-                collection.MediaItems.OfType<Season>().Map(s => ProjectToViewModel(s, maybeJellyfin)).ToList(),
                 collection.MediaItems.OfType<Episode>()
-                    .Map(e => ProjectToViewModel(e.EpisodeMetadata.Head(), maybeJellyfin))
+                    .Map(e => ProjectToViewModel(e.EpisodeMetadata.Head(), maybeJellyfin, maybeEmby))
                     .ToList(),
                 collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
                 collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
                     .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
 
-        internal static ActorCardViewModel ProjectToViewModel(Actor actor, Option<JellyfinMediaSource> maybeJellyfin)
+        internal static ActorCardViewModel ProjectToViewModel(
+            Actor actor,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
         {
             string artwork = actor.Artwork?.Path ?? string.Empty;
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
-                    .Flatten()
-                    .IfNone("jellyfin://");
-                artwork = artwork.Replace("jellyfin://", address) + "&fillheight=440";
+                artwork = JellyfinUrl.ForArtwork(maybeJellyfin, artwork)
+                    .SetQueryParam("fillHeight", 440);
+            }
+            else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
+            {
+                artwork = EmbyUrl.ForArtwork(maybeEmby, artwork)
+                    .SetQueryParam("maxHeight", 440);
             }
 
             return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork);
@@ -118,34 +136,45 @@ namespace ErsatzTV.Application.MediaCards
         private static string GetSeasonName(int number) =>
             number == 0 ? "Specials" : $"Season {number}";
 
-        private static string GetPoster(Metadata metadata, Option<JellyfinMediaSource> maybeJellyfin)
+        private static string GetPoster(
+            Metadata metadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
         {
             string poster = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster))
                 .Match(a => a.Path, string.Empty);
 
             if (maybeJellyfin.IsSome && poster.StartsWith("jellyfin://"))
             {
-                string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
-                    .Flatten()
-                    .IfNone("jellyfin://");
-                poster = poster.Replace("jellyfin://", address) + "&fillHeight=440";
+                poster = JellyfinUrl.ForArtwork(maybeJellyfin, poster)
+                    .SetQueryParam("fillHeight", 440);
+            }
+            else if (maybeEmby.IsSome && poster.StartsWith("emby://"))
+            {
+                poster = EmbyUrl.ForArtwork(maybeEmby, poster)
+                    .SetQueryParam("maxHeight", 440);
             }
 
             return poster;
         }
 
-        private static string GetThumbnail(Metadata metadata, Option<JellyfinMediaSource> maybeJellyfin)
+        private static string GetThumbnail(
+            Metadata metadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
         {
             string thumb = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail))
                 .Match(a => a.Path, string.Empty);
 
             if (maybeJellyfin.IsSome && thumb.StartsWith("jellyfin://"))
             {
-                string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
-                    .Flatten()
-                    .IfNone("jellyfin://");
-                thumb = thumb.Replace("jellyfin://", address) +
-                        "&fillHeight=220"; // TODO: this height is optimized for episode
+                thumb = JellyfinUrl.ForArtwork(maybeJellyfin, thumb)
+                    .SetQueryParam("fillHeight", 220);
+            }
+            else if (maybeEmby.IsSome && thumb.StartsWith("emby://"))
+            {
+                thumb = EmbyUrl.ForArtwork(maybeEmby, thumb)
+                    .SetQueryParam("maxHeight", 220);
             }
 
             return thumb;

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

@@ -30,10 +30,13 @@ namespace ErsatzTV.Application.MediaCards.Queries
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());
 
+            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                .Map(list => list.HeadOrNone());
+
             return await _collectionRepository
                 .GetCollectionWithItemsUntracked(request.Id)
                 .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
-                .MapT(c => ProjectToViewModel(c, maybeJellyfin));
+                .MapT(c => ProjectToViewModel(c, maybeJellyfin, maybeEmby));
         }
     }
 }

ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCardsHandler.cs

@@ -34,9 +34,12 @@ namespace ErsatzTV.Application.MediaCards.Queries
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());
 
+            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                .Map(list => list.HeadOrNone());
+
             List<TelevisionEpisodeCardViewModel> results = await _televisionRepository
                 .GetPagedEpisodes(request.TelevisionSeasonId, request.PageNumber, request.PageSize)
-                .Map(list => list.Map(e => ProjectToViewModel(e, maybeJellyfin)).ToList());
+                .Map(list => list.Map(e => ProjectToViewModel(e, maybeJellyfin, maybeEmby)).ToList());
 
             return new TelevisionEpisodeCardResultsViewModel(count, results);
         }

ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs

@@ -34,9 +34,12 @@ namespace ErsatzTV.Application.MediaCards.Queries
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());
 
+            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                .Map(list => list.HeadOrNone());
+
             List<TelevisionSeasonCardViewModel> results = await _televisionRepository
                 .GetPagedSeasons(request.TelevisionShowId, request.PageNumber, request.PageSize)
-                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin)).ToList());
+                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
 
             return new TelevisionSeasonCardResultsViewModel(count, results);
         }

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs

@@ -17,7 +17,5 @@ namespace ErsatzTV.Application.MediaCards
         Title,
         $"Episode {Episode}",
         $"Episode {Episode}",
-        Poster)
-    {
-    }
+        Poster);
 }

ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs

@@ -14,7 +14,5 @@
         Title,
         Subtitle,
         SortTitle,
-        Poster)
-    {
-    }
+        Poster);
 }

ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs

@@ -6,7 +6,5 @@
             Title,
             Subtitle,
             SortTitle,
-            Poster)
-    {
-    }
+            Poster);
 }

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -90,7 +90,6 @@ namespace ErsatzTV.Application.MediaSources.Commands
                             await _movieFolderScanner.ScanFolder(
                                 libraryPath,
                                 ffprobePath,
-                                lastScan,
                                 progressMin,
                                 progressMax);
                             break;
@@ -98,7 +97,6 @@ namespace ErsatzTV.Application.MediaSources.Commands
                             await _televisionFolderScanner.ScanFolder(
                                 libraryPath,
                                 ffprobePath,
-                                lastScan,
                                 progressMin,
                                 progressMax);
                             break;
@@ -106,7 +104,6 @@ namespace ErsatzTV.Application.MediaSources.Commands
                             await _musicVideoFolderScanner.ScanFolder(
                                 libraryPath,
                                 ffprobePath,
-                                lastScan,
                                 progressMin,
                                 progressMax);
                             break;

ErsatzTV.Application/MediaSources/RemoteMediaSourceViewModel.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.MediaSources
+{
+    public record RemoteMediaSourceViewModel(int Id, string Name, string Address) : MediaSourceViewModel(Id, Name);
+}

ErsatzTV.Application/Movies/Mapper.cs

@@ -3,6 +3,9 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Jellyfin;
+using Flurl;
 using LanguageExt;
 using static LanguageExt.Prelude;
 
@@ -10,7 +13,10 @@ namespace ErsatzTV.Application.Movies
 {
     internal static class Mapper
     {
-        internal static MovieViewModel ProjectToViewModel(Movie movie, Option<JellyfinMediaSource> maybeJellyfin)
+        internal static MovieViewModel ProjectToViewModel(
+            Movie movie,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
         {
             MovieMetadata metadata = Optional(movie.MovieMetadata).Flatten().Head();
             return new MovieViewModel(
@@ -22,11 +28,11 @@ namespace ErsatzTV.Application.Movies
                 metadata.Studios.Map(s => s.Name).ToList(),
                 LanguagesForMovie(movie),
                 metadata.Actors.OrderBy(a => a.Order).ThenBy(a => a.Id)
-                    .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin))
+                    .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin, maybeEmby))
                     .ToList())
             {
-                Poster = Artwork(metadata, ArtworkKind.Poster, maybeJellyfin),
-                FanArt = Artwork(metadata, ArtworkKind.FanArt, maybeJellyfin)
+                Poster = Artwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby),
+                FanArt = Artwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby)
             };
         }
 
@@ -49,22 +55,31 @@ namespace ErsatzTV.Application.Movies
         private static string Artwork(
             Metadata metadata,
             ArtworkKind artworkKind,
-            Option<JellyfinMediaSource> maybeJellyfin)
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
         {
             string artwork = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
                 .Match(a => a.Path, string.Empty);
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
-                    .Flatten()
-                    .IfNone("jellyfin://");
-                artwork = artwork.Replace("jellyfin://", address);
-
+                Url url = JellyfinUrl.ForArtwork(maybeJellyfin, artwork);
                 if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
                 {
-                    artwork += "&fillHeight=440";
+                    url.SetQueryParam("fillHeight", 440);
                 }
+
+                artwork = url;
+            }
+            else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
+            {
+                Url url = EmbyUrl.ForArtwork(maybeEmby, artwork);
+                if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
+                {
+                    url.SetQueryParam("maxHeight", 440);
+                }
+
+                artwork = url;
             }
 
             return artwork;

ErsatzTV.Application/Movies/Queries/GetMovieByIdHandler.cs

@@ -26,8 +26,11 @@ namespace ErsatzTV.Application.Movies.Queries
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());
 
+            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                .Map(list => list.HeadOrNone());
+
             Option<Movie> movie = await _movieRepository.GetMovie(request.Id);
-            return movie.Map(m => ProjectToViewModel(m, maybeJellyfin));
+            return movie.Map(m => ProjectToViewModel(m, maybeJellyfin, maybeEmby));
         }
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramSchedule.cs

@@ -5,6 +5,8 @@ using MediatR;
 
 namespace ErsatzTV.Application.ProgramSchedules.Commands
 {
-    public record CreateProgramSchedule(string Name, PlaybackOrder MediaCollectionPlaybackOrder) :
-        IRequest<Either<BaseError, ProgramScheduleViewModel>>;
+    public record CreateProgramSchedule(
+        string Name,
+        PlaybackOrder MediaCollectionPlaybackOrder,
+        bool KeepMultiPartEpisodesTogether) : IRequest<Either<BaseError, ProgramScheduleViewModel>>;
 }

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs

@@ -36,7 +36,11 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                 .MapT(
                     name => new ProgramSchedule
                     {
-                        Name = name, MediaCollectionPlaybackOrder = request.MediaCollectionPlaybackOrder
+                        Name = name,
+                        MediaCollectionPlaybackOrder = request.MediaCollectionPlaybackOrder,
+                        KeepMultiPartEpisodesTogether =
+                            request.MediaCollectionPlaybackOrder == PlaybackOrder.Shuffle &&
+                            request.KeepMultiPartEpisodesTogether
                     });
 
         private async Task<Validation<BaseError, string>> ValidateName(CreateProgramSchedule createProgramSchedule)

ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs

@@ -132,11 +132,14 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     CollectionType = item.CollectionType,
                     CollectionId = item.CollectionId,
                     MediaItemId = item.MediaItemId,
-                    PlayoutDuration = item.PlayoutDuration.GetValueOrDefault(),
+                    PlayoutDuration = FixDuration(item.PlayoutDuration.GetValueOrDefault()),
                     OfflineTail = item.OfflineTail.GetValueOrDefault(),
                     CustomTitle = item.CustomTitle
                 },
                 _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
             };
+
+        private static TimeSpan FixDuration(TimeSpan duration) =>
+            duration > TimeSpan.FromDays(1) ? duration.Subtract(TimeSpan.FromDays(1)) : duration;
     }
 }

ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramSchedule.cs

@@ -9,5 +9,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
     (
         int ProgramScheduleId,
         string Name,
-        PlaybackOrder MediaCollectionPlaybackOrder) : IRequest<Either<BaseError, ProgramScheduleViewModel>>;
+        PlaybackOrder MediaCollectionPlaybackOrder,
+        bool KeepMultiPartEpisodesTogether) : IRequest<Either<BaseError, ProgramScheduleViewModel>>;
 }

ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleHandler.cs

@@ -37,12 +37,16 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             ProgramSchedule programSchedule,
             UpdateProgramSchedule update)
         {
-            // we only need to rebuild playouts if the playback order has been modified
+            // we need to rebuild playouts if the playback order or keep multi-episodes has been modified
             bool needToRebuildPlayout =
-                programSchedule.MediaCollectionPlaybackOrder != update.MediaCollectionPlaybackOrder;
+                programSchedule.MediaCollectionPlaybackOrder != update.MediaCollectionPlaybackOrder ||
+                programSchedule.KeepMultiPartEpisodesTogether != update.KeepMultiPartEpisodesTogether;
 
             programSchedule.Name = update.Name;
             programSchedule.MediaCollectionPlaybackOrder = update.MediaCollectionPlaybackOrder;
+            programSchedule.KeepMultiPartEpisodesTogether =
+                update.MediaCollectionPlaybackOrder == PlaybackOrder.Shuffle &&
+                update.KeepMultiPartEpisodesTogether;
             await _programScheduleRepository.Update(programSchedule);
 
             if (needToRebuildPlayout)

ErsatzTV.Application/ProgramSchedules/Mapper.cs

@@ -6,7 +6,11 @@ namespace ErsatzTV.Application.ProgramSchedules
     internal static class Mapper
     {
         internal static ProgramScheduleViewModel ProjectToViewModel(ProgramSchedule programSchedule) =>
-            new(programSchedule.Id, programSchedule.Name, programSchedule.MediaCollectionPlaybackOrder);
+            new(
+                programSchedule.Id,
+                programSchedule.Name,
+                programSchedule.MediaCollectionPlaybackOrder,
+                programSchedule.KeepMultiPartEpisodesTogether);
 
         internal static ProgramScheduleItemViewModel ProjectToViewModel(ProgramScheduleItem programScheduleItem) =>
             programScheduleItem switch

ErsatzTV.Application/ProgramSchedules/ProgramScheduleViewModel.cs

@@ -2,5 +2,9 @@
 
 namespace ErsatzTV.Application.ProgramSchedules
 {
-    public record ProgramScheduleViewModel(int Id, string Name, PlaybackOrder MediaCollectionPlaybackOrder);
+    public record ProgramScheduleViewModel(
+        int Id,
+        string Name,
+        PlaybackOrder MediaCollectionPlaybackOrder,
+        bool KeepMultiPartEpisodesTogether);
 }

ErsatzTV.Application/Search/Queries/QuerySearchIndexMoviesHandler.cs

@@ -41,9 +41,12 @@ namespace ErsatzTV.Application.Search.Queries
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());
 
+            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                .Map(list => list.HeadOrNone());
+
             List<MovieCardViewModel> items = await _movieRepository
                 .GetMoviesForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(m => ProjectToViewModel(m, maybeJellyfin)).ToList());
+                .Map(list => list.Map(m => ProjectToViewModel(m, maybeJellyfin, maybeEmby)).ToList());
 
             return new MovieCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
         }

ErsatzTV.Application/Search/Queries/QuerySearchIndexShowsHandler.cs

@@ -42,9 +42,12 @@ namespace ErsatzTV.Application.Search.Queries
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());
 
+            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                .Map(list => list.HeadOrNone());
+
             List<TelevisionShowCardViewModel> items = await _televisionRepository
                 .GetShowsForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin)).ToList());
+                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
 
             return new TelevisionShowCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
         }

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -5,6 +5,7 @@ using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Plex;
@@ -18,6 +19,7 @@ namespace ErsatzTV.Application.Streaming.Queries
         GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<GetPlayoutItemProcessByChannelNumber>
     {
         private readonly IConfigElementRepository _configElementRepository;
+        private readonly IEmbyPathReplacementService _embyPathReplacementService;
         private readonly FFmpegProcessService _ffmpegProcessService;
         private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
         private readonly ILocalFileSystem _localFileSystem;
@@ -31,7 +33,8 @@ namespace ErsatzTV.Application.Streaming.Queries
             FFmpegProcessService ffmpegProcessService,
             ILocalFileSystem localFileSystem,
             IPlexPathReplacementService plexPathReplacementService,
-            IJellyfinPathReplacementService jellyfinPathReplacementService)
+            IJellyfinPathReplacementService jellyfinPathReplacementService,
+            IEmbyPathReplacementService embyPathReplacementService)
             : base(channelRepository, configElementRepository)
         {
             _configElementRepository = configElementRepository;
@@ -40,6 +43,7 @@ namespace ErsatzTV.Application.Streaming.Queries
             _localFileSystem = localFileSystem;
             _plexPathReplacementService = plexPathReplacementService;
             _jellyfinPathReplacementService = jellyfinPathReplacementService;
+            _embyPathReplacementService = embyPathReplacementService;
         }
 
         protected override async Task<Either<BaseError, Process>> GetProcess(
@@ -178,6 +182,12 @@ namespace ErsatzTV.Application.Streaming.Queries
                 JellyfinEpisode jellyfinEpisode => await _jellyfinPathReplacementService.GetReplacementJellyfinPath(
                     jellyfinEpisode.LibraryPathId,
                     path),
+                EmbyMovie embyMovie => await _embyPathReplacementService.GetReplacementEmbyPath(
+                    embyMovie.LibraryPathId,
+                    path),
+                EmbyEpisode embyEpisode => await _embyPathReplacementService.GetReplacementEmbyPath(
+                    embyEpisode.LibraryPathId,
+                    path),
                 _ => path
             };
         }

ErsatzTV.Application/Television/Mapper.cs

@@ -4,6 +4,9 @@ using System.Globalization;
 using System.Linq;
 using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Jellyfin;
+using Flurl;
 using LanguageExt;
 using static LanguageExt.Prelude;
 
@@ -14,14 +17,15 @@ namespace ErsatzTV.Application.Television
         internal static TelevisionShowViewModel ProjectToViewModel(
             Show show,
             List<string> languages,
-            Option<JellyfinMediaSource> maybeJellyfin) =>
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 show.Id,
                 show.ShowMetadata.HeadOrNone().Map(m => m.Title ?? string.Empty).IfNone(string.Empty),
                 show.ShowMetadata.HeadOrNone().Map(m => m.Year?.ToString() ?? string.Empty).IfNone(string.Empty),
                 show.ShowMetadata.HeadOrNone().Map(m => m.Plot ?? string.Empty).IfNone(string.Empty),
-                show.ShowMetadata.HeadOrNone().Map(m => GetPoster(m, maybeJellyfin)).IfNone(string.Empty),
-                show.ShowMetadata.HeadOrNone().Map(m => GetFanArt(m, maybeJellyfin)).IfNone(string.Empty),
+                show.ShowMetadata.HeadOrNone().Map(m => GetPoster(m, maybeJellyfin, maybeEmby)).IfNone(string.Empty),
+                show.ShowMetadata.HeadOrNone().Map(m => GetFanArt(m, maybeJellyfin, maybeEmby)).IfNone(string.Empty),
                 show.ShowMetadata.HeadOrNone().Map(m => m.Genres.Map(g => g.Name).ToList()).IfNone(new List<string>()),
                 show.ShowMetadata.HeadOrNone().Map(m => m.Tags.Map(g => g.Name).ToList()).IfNone(new List<string>()),
                 show.ShowMetadata.HeadOrNone().Map(m => m.Studios.Map(s => s.Name).ToList())
@@ -30,21 +34,24 @@ namespace ErsatzTV.Application.Television
                 show.ShowMetadata.HeadOrNone()
                     .Map(
                         m => m.Actors.OrderBy(a => a.Order).ThenBy(a => a.Id)
-                            .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin))
+                            .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin, maybeEmby))
                             .ToList())
                     .IfNone(new List<ActorCardViewModel>()));
 
         internal static TelevisionSeasonViewModel ProjectToViewModel(
             Season season,
-            Option<JellyfinMediaSource> maybeJellyfin) =>
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
             new(
                 season.Id,
                 season.ShowId,
                 season.Show.ShowMetadata.HeadOrNone().Map(m => m.Title ?? string.Empty).IfNone(string.Empty),
                 season.Show.ShowMetadata.HeadOrNone().Map(m => m.Year?.ToString() ?? string.Empty).IfNone(string.Empty),
                 season.SeasonNumber == 0 ? "Specials" : $"Season {season.SeasonNumber}",
-                season.SeasonMetadata.HeadOrNone().Map(m => GetPoster(m, maybeJellyfin)).IfNone(string.Empty),
-                season.Show.ShowMetadata.HeadOrNone().Map(m => GetFanArt(m, maybeJellyfin)).IfNone(string.Empty));
+                season.SeasonMetadata.HeadOrNone().Map(m => GetPoster(m, maybeJellyfin, maybeEmby))
+                    .IfNone(string.Empty),
+                season.Show.ShowMetadata.HeadOrNone().Map(m => GetFanArt(m, maybeJellyfin, maybeEmby))
+                    .IfNone(string.Empty));
 
         internal static TelevisionEpisodeViewModel ProjectToViewModel(Episode episode) =>
             new(
@@ -53,36 +60,54 @@ namespace ErsatzTV.Application.Television
                 episode.EpisodeNumber,
                 episode.EpisodeMetadata.HeadOrNone().Map(m => m.Title ?? string.Empty).IfNone(string.Empty),
                 episode.EpisodeMetadata.HeadOrNone().Map(m => m.Plot ?? string.Empty).IfNone(string.Empty),
-                episode.EpisodeMetadata.HeadOrNone().Map(m => GetThumbnail(m, None)).IfNone(string.Empty));
+                episode.EpisodeMetadata.HeadOrNone().Map(m => GetThumbnail(m, None, None)).IfNone(string.Empty));
 
-        private static string GetPoster(Metadata metadata, Option<JellyfinMediaSource> maybeJellyfin) =>
-            GetArtwork(metadata, ArtworkKind.Poster, maybeJellyfin);
+        private static string GetPoster(
+            Metadata metadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
+            GetArtwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby);
 
-        private static string GetFanArt(Metadata metadata, Option<JellyfinMediaSource> maybeJellyfin) =>
-            GetArtwork(metadata, ArtworkKind.FanArt, maybeJellyfin);
+        private static string GetFanArt(
+            Metadata metadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
+            GetArtwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby);
 
-        private static string GetThumbnail(Metadata metadata, Option<JellyfinMediaSource> maybeJellyfin) =>
-            GetArtwork(metadata, ArtworkKind.Thumbnail, maybeJellyfin);
+        private static string GetThumbnail(
+            Metadata metadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
+            GetArtwork(metadata, ArtworkKind.Thumbnail, maybeJellyfin, maybeEmby);
 
         private static string GetArtwork(
             Metadata metadata,
             ArtworkKind artworkKind,
-            Option<JellyfinMediaSource> maybeJellyfin)
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
         {
             string artwork = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
                 .Match(a => a.Path, string.Empty);
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
-                    .Flatten()
-                    .IfNone("jellyfin://");
-                artwork = artwork.Replace("jellyfin://", address);
-
+                Url url = JellyfinUrl.ForArtwork(maybeJellyfin, artwork);
                 if (artworkKind == ArtworkKind.Poster)
                 {
-                    artwork += "&fillHeight=440";
+                    url.SetQueryParam("fillHeight", 440);
                 }
+
+                artwork = url;
+            }
+            else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
+            {
+                Url url = EmbyUrl.ForArtwork(maybeEmby, artwork);
+                if (artworkKind == ArtworkKind.Poster)
+                {
+                    url.SetQueryParam("maxHeight", 440);
+                }
+
+                artwork = url;
             }
 
             return artwork;

ErsatzTV.Application/Television/Queries/GetTelevisionSeasonByIdHandler.cs

@@ -29,8 +29,11 @@ namespace ErsatzTV.Application.Television.Queries
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());
 
+            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                .Map(list => list.HeadOrNone());
+
             return await _televisionRepository.GetSeason(request.SeasonId)
-                .MapT(s => ProjectToViewModel(s, maybeJellyfin));
+                .MapT(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby));
         }
     }
 }

ErsatzTV.Application/Television/Queries/GetTelevisionShowByIdHandler.cs

@@ -36,8 +36,11 @@ namespace ErsatzTV.Application.Television.Queries
                     Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                         .Map(list => list.HeadOrNone());
 
+                    Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                        .Map(list => list.HeadOrNone());
+
                     List<string> languages = await _searchRepository.GetLanguagesForShow(show);
-                    return ProjectToViewModel(show, languages, maybeJellyfin);
+                    return ProjectToViewModel(show, languages, maybeJellyfin, maybeEmby);
                 },
                 () => Task.FromResult(Option<TelevisionShowViewModel>.None));
         }

ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj

@@ -13,13 +13,13 @@
       <PackageReference Include="FluentAssertions" Version="5.10.3" />
       <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
       <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
-      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
       <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.9.60">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
       <PackageReference Include="Moq" Version="4.16.1" />
-      <PackageReference Include="NUnit" Version="3.13.1" />
+      <PackageReference Include="NUnit" Version="3.13.2" />
       <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.Extensions.Logging" Version="3.0.1" />

ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs

@@ -1,6 +1,7 @@
 using System;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
 using FluentAssertions;
 using NUnit.Framework;
 
@@ -106,7 +107,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
 
             [Test]
-            public void ShouldNot_SetRealtime_ForHttpLiveStreaming()
+            public void Should_SetRealtime_ForHttpLiveStreaming()
             {
                 FFmpegProfile ffmpegProfile = TestProfile();
 
@@ -119,7 +120,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now);
 
-                actual.RealtimeOutput.Should().BeFalse();
+                actual.RealtimeOutput.Should().BeTrue();
             }
 
             [Test]
@@ -277,6 +278,32 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 actual.PadToDesiredResolution.Should().BeTrue();
             }
 
+            [Test]
+            public void Should_ScaleToEvenDimensions_ForTransportStream()
+            {
+                FFmpegProfile ffmpegProfile = TestProfile() with
+                {
+                    NormalizeVideo = true,
+                    Resolution = new Resolution { Width = 1280, Height = 720 }
+                };
+
+                var version = new MediaVersion { Width = 706, Height = 362, SampleAspectRatio = "32:27" };
+
+                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                    StreamingMode.TransportStream,
+                    ffmpegProfile,
+                    version,
+                    new MediaStream(),
+                    new MediaStream(),
+                    DateTimeOffset.Now,
+                    DateTimeOffset.Now);
+
+                IDisplaySize scaledSize = actual.ScaledSize.IfNone(new MediaVersion { Width = 0, Height = 0 });
+                scaledSize.Width.Should().Be(1280);
+                scaledSize.Height.Should().Be(554);
+                actual.PadToDesiredResolution.Should().BeTrue();
+            }
+
             [Test]
             public void Should_NotPadToDesiredResolution_When_UnscaledContentIsUnderSized_ForHttpLiveStreaming()
             {
@@ -440,6 +467,36 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 actual.VideoCodec.Should().Be("copy");
             }
 
+            [Test]
+            public void
+                Should_SetCorrectVideoCodec_When_ContentIsCorrectSize_And_CorrectCodec_And_Framerate_ForTransportStream()
+            {
+                var ffmpegProfile = new FFmpegProfile
+                {
+                    NormalizeVideo = true,
+                    Resolution = new Resolution { Width = 1920, Height = 1080 },
+                    VideoCodec = "libx264",
+                    FrameRate = "24"
+                };
+
+                // not anamorphic
+                var version = new MediaVersion
+                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                    StreamingMode.TransportStream,
+                    ffmpegProfile,
+                    version,
+                    new MediaStream { Codec = "libx264" },
+                    new MediaStream(),
+                    DateTimeOffset.Now,
+                    DateTimeOffset.Now);
+
+                actual.ScaledSize.IsNone.Should().BeTrue();
+                actual.PadToDesiredResolution.Should().BeFalse();
+                actual.VideoCodec.Should().Be("libx264");
+            }
+
             [Test]
             public void
                 Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NotNormalizingVideo_ForTransportStream()

ErsatzTV.Core.Tests/Jellyfin/JellyfinUrlTests.cs

@@ -0,0 +1,121 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Jellyfin;
+using FluentAssertions;
+using Flurl;
+using NUnit.Framework;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Core.Tests.Jellyfin
+{
+    public class JellyfinUrlTests
+    {
+        [Test]
+        public void Should_Work_Without_Trailing_Slash()
+        {
+            var artwork = "jellyfin://Items/2/Images/3?tag=4";
+            var address = "https://some.jellyfin.server";
+            var mediaSource = new JellyfinMediaSource
+            {
+                Connections = new List<JellyfinConnection>
+                {
+                    new() { Address = address }
+                }
+            };
+
+            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+            url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
+        }
+
+        [Test]
+        public void Should_Work_With_Trailing_Slash()
+        {
+            var artwork = "jellyfin://Items/2/Images/3?tag=4";
+            var address = "https://some.jellyfin.server/";
+            var mediaSource = new JellyfinMediaSource
+            {
+                Connections = new List<JellyfinConnection>
+                {
+                    new() { Address = address }
+                }
+            };
+
+            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+            url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
+        }
+
+        [Test]
+        public void Should_Work_With_Port_Without_Trailing_Slash()
+        {
+            var artwork = "jellyfin://Items/2/Images/3?tag=4";
+            var address = "https://some.jellyfin.server:1000";
+            var mediaSource = new JellyfinMediaSource
+            {
+                Connections = new List<JellyfinConnection>
+                {
+                    new() { Address = address }
+                }
+            };
+
+            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+            url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
+        }
+
+        [Test]
+        public void Should_Work_With_Port_With_Trailing_Slash()
+        {
+            var artwork = "jellyfin://Items/2/Images/3?tag=4";
+            var address = "https://some.jellyfin.server:1000/";
+            var mediaSource = new JellyfinMediaSource
+            {
+                Connections = new List<JellyfinConnection>
+                {
+                    new() { Address = address }
+                }
+            };
+
+            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+            url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
+        }
+
+        [Test]
+        public void Should_Work_With_Path_Prefix_Without_Trailing_Slash()
+        {
+            var artwork = "jellyfin://Items/2/Images/3?tag=4";
+            var address = "https://some.jellyfin.server/jellyfin";
+            var mediaSource = new JellyfinMediaSource
+            {
+                Connections = new List<JellyfinConnection>
+                {
+                    new() { Address = address }
+                }
+            };
+
+            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+            url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
+        }
+
+        [Test]
+        public void Should_Work_With_Path_Prefix_With_Trailing_Slash()
+        {
+            var artwork = "jellyfin://Items/2/Images/3?tag=4";
+            var address = "https://some.jellyfin.server/jellyfin/";
+            var mediaSource = new JellyfinMediaSource
+            {
+                Connections = new List<JellyfinConnection>
+                {
+                    new() { Address = address }
+                }
+            };
+
+            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+            url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
+        }
+    }
+}

ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs

@@ -81,12 +81,11 @@ namespace ErsatzTV.Core.Tests.Metadata
                 MovieFolderScanner service = GetService(
                     new FakeFileEntry(Path.Combine(FakeRoot, Path.Combine("Movie (2020)", "Movie (2020).mkv")))
                 );
-                var libraryPath = new LibraryPath { Path = BadFakeRoot };
+                var libraryPath = new LibraryPath { Path = BadFakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -106,12 +105,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                 MovieFolderScanner service = GetService(
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -147,12 +146,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
                     new FakeFileEntry(metadataPath)
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -189,12 +188,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
                     new FakeFileEntry(metadataPath)
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -235,12 +234,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
                     new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -284,12 +283,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
                     new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -333,12 +332,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
                     new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -381,12 +380,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                             Path.GetDirectoryName(moviePath) ?? string.Empty,
                             $"Movie (2020)-{extraFile}{videoExtension}"))
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -425,12 +424,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                             Path.GetDirectoryName(moviePath) ?? string.Empty,
                             Path.Combine(extraFolder, $"Movie (2020){videoExtension}")))
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -463,12 +462,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                 MovieFolderScanner service = GetService(
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -503,12 +502,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                 MovieFolderScanner service = GetService(
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -532,12 +531,12 @@ namespace ErsatzTV.Core.Tests.Metadata
                 MovieFolderScanner service = GetService(
                     new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
                 );
-                var libraryPath = new LibraryPath { Id = 1, Path = FakeRoot };
+                var libraryPath = new LibraryPath
+                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
 
                 Either<BaseError, Unit> result = await service.ScanFolder(
                     libraryPath,
                     FFprobePath,
-                    DateTimeOffset.MinValue,
                     0,
                     1);
 
@@ -558,6 +557,7 @@ namespace ErsatzTV.Core.Tests.Metadata
                     _imageCache.Object,
                     new Mock<ISearchIndex>().Object,
                     new Mock<ISearchRepository>().Object,
+                    new Mock<ILibraryRepository>().Object,
                     new Mock<IMediator>().Object,
                     new Mock<ILogger<MovieFolderScanner>>().Object
                 );

ErsatzTV.Core.Tests/Scheduling/MultiPartEpisodeGrouperTests.cs

@@ -0,0 +1,100 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Scheduling
+{
+    public class MultiPartEpisodeGrouperTests
+    {
+        [Test]
+        public void NotGrouped_Grouped_NotGrouped()
+        {
+            var mediaItems = new List<MediaItem>
+            {
+                NamedEpisode("Episode 1"),
+                NamedEpisode("Episode 2 (1)"),
+                NamedEpisode("Episode 3 (2)"),
+                NamedEpisode("Episode 4")
+            };
+
+            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems);
+
+            result.Count.Should().Be(3);
+            result[0].First.Should().Be(mediaItems[0]);
+            result[1].First.Should().Be(mediaItems[1]);
+            result[1].Additional[0].Should().Be(mediaItems[2]);
+            result[2].First.Should().Be(mediaItems[3]);
+        }
+
+        [Test]
+        public void Grouped_NotGrouped()
+        {
+            var mediaItems = new List<MediaItem>
+            {
+                NamedEpisode("Episode 1 (1)"),
+                NamedEpisode("Episode 2 (2)"),
+                NamedEpisode("Episode 3")
+            };
+
+            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems);
+
+            result.Count.Should().Be(2);
+            result[0].First.Should().Be(mediaItems[0]);
+            result[0].Additional[0].Should().Be(mediaItems[1]);
+            result[1].First.Should().Be(mediaItems[2]);
+        }
+
+        [Test]
+        public void Grouped_NotGrouped_Grouped()
+        {
+            var mediaItems = new List<MediaItem>
+            {
+                NamedEpisode("Episode 1 (1)"),
+                NamedEpisode("Episode 2 (2)"),
+                NamedEpisode("Episode 3"),
+                NamedEpisode("Episode 4 (1)"),
+                NamedEpisode("Episode 5 (2)")
+            };
+
+            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems);
+
+            result.Count.Should().Be(3);
+            result[0].First.Should().Be(mediaItems[0]);
+            result[0].Additional[0].Should().Be(mediaItems[1]);
+            result[1].First.Should().Be(mediaItems[2]);
+            result[2].First.Should().Be(mediaItems[3]);
+            result[2].Additional[0].Should().Be(mediaItems[4]);
+        }
+
+        [Test]
+        public void Grouped_Grouped()
+        {
+            var mediaItems = new List<MediaItem>
+            {
+                NamedEpisode("Episode 1 (1)"),
+                NamedEpisode("Episode 2 (2)"),
+                NamedEpisode("Episode 3 (1)"),
+                NamedEpisode("Episode 4 (2)")
+            };
+
+            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems);
+
+            result.Count.Should().Be(2);
+            result[0].First.Should().Be(mediaItems[0]);
+            result[0].Additional[0].Should().Be(mediaItems[1]);
+            result[1].First.Should().Be(mediaItems[2]);
+            result[1].Additional[0].Should().Be(mediaItems[3]);
+        }
+
+        private static Episode NamedEpisode(string title) =>
+            new()
+            {
+                EpisodeMetadata = new List<EpisodeMetadata>
+                {
+                    new() { Title = title }
+                }
+            };
+    }
+}

ErsatzTV.Core.Tests/Scheduling/ShuffledContentTests.cs

@@ -23,7 +23,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             // normally returns 10 5 7 4 3 6 2 8 9 1 1 (note duplicate 1 at end)
             var state = new CollectionEnumeratorState { Seed = 8 };
 
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state);
+            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state, false);
 
             var list = new List<int>();
             for (var i = 1; i <= 1000; i++)
@@ -50,7 +50,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
 
             var state = new CollectionEnumeratorState();
 
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state);
+            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state, false);
 
             var list = new List<int>();
             for (var i = 1; i <= 10; i++)
@@ -70,7 +70,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
 
             var state = new CollectionEnumeratorState();
 
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state);
+            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state, false);
 
             var list = new List<int>();
             for (var i = 1; i <= 10; i++)
@@ -90,7 +90,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             List<MediaItem> contents = Episodes(10);
             var state = new CollectionEnumeratorState();
 
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state);
+            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state, false);
 
             for (var i = 0; i < 10; i++)
             {
@@ -105,7 +105,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             List<MediaItem> contents = Episodes(10);
             var state = new CollectionEnumeratorState { Index = 5, Seed = MagicSeed };
 
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state);
+            var shuffledContent = new ShuffledMediaCollectionEnumerator(contents, state, false);
 
             for (var i = 6; i <= 10; i++)
             {

ErsatzTV.Core/Domain/Library/EmbyLibrary.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class EmbyLibrary : Library
+    {
+        public string ItemId { get; set; }
+        public bool ShouldSyncItems { get; set; }
+    }
+}

ErsatzTV.Core/Domain/Library/LibraryFolder.cs

@@ -0,0 +1,11 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class LibraryFolder
+    {
+        public int Id { get; set; }
+        public string Path { get; set; }
+        public int LibraryPathId { get; set; }
+        public LibraryPath LibraryPath { get; set; }
+        public string Etag { get; set; }
+    }
+}

ErsatzTV.Core/Domain/Library/LibraryPath.cs

@@ -13,5 +13,6 @@ namespace ErsatzTV.Core.Domain
         public Library Library { get; set; }
 
         public List<MediaItem> MediaItems { get; set; }
+        public List<LibraryFolder> LibraryFolders { get; set; }
     }
 }

ErsatzTV.Core/Domain/MediaItem/EmbyEpisode.cs

@@ -0,0 +1,11 @@
+using System.Diagnostics;
+
+namespace ErsatzTV.Core.Domain
+{
+    [DebuggerDisplay("{EpisodeMetadata[0].Title}")]
+    public class EmbyEpisode : Episode
+    {
+        public string ItemId { get; set; }
+        public string Etag { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaItem/EmbyMovie.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class EmbyMovie : Movie
+    {
+        public string ItemId { get; set; }
+        public string Etag { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaItem/EmbySeason.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class EmbySeason : Season
+    {
+        public string ItemId { get; set; }
+        public string Etag { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaItem/EmbyShow.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class EmbyShow : Show
+    {
+        public string ItemId { get; set; }
+        public string Etag { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaItem/Episode.cs

@@ -1,7 +1,9 @@
 using System.Collections.Generic;
+using System.Diagnostics;
 
 namespace ErsatzTV.Core.Domain
 {
+    [DebuggerDisplay("{EpisodeMetadata[0].Title}")]
     public class Episode : MediaItem
     {
         public int EpisodeNumber { get; set; }

ErsatzTV.Core/Domain/MediaItem/JellyfinEpisode.cs

@@ -1,5 +1,8 @@
-namespace ErsatzTV.Core.Domain
+using System.Diagnostics;
+
+namespace ErsatzTV.Core.Domain
 {
+    [DebuggerDisplay("{EpisodeMetadata[0].Title}")]
     public class JellyfinEpisode : Episode
     {
         public string ItemId { get; set; }

ErsatzTV.Core/Domain/MediaSource/EmbyConnection.cs

@@ -0,0 +1,10 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class EmbyConnection
+    {
+        public int Id { get; set; }
+        public string Address { get; set; }
+        public int EmbyMediaSourceId { get; set; }
+        public EmbyMediaSource EmbyMediaSource { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaSource/EmbyMediaSource.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class EmbyMediaSource : MediaSource
+    {
+        public string ServerName { get; set; }
+        public string OperatingSystem { get; set; }
+        public List<EmbyConnection> Connections { get; set; }
+        public List<EmbyPathReplacement> PathReplacements { get; set; }
+    }
+}

ErsatzTV.Core/Domain/MediaSource/EmbyPathReplacement.cs

@@ -0,0 +1,11 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class EmbyPathReplacement
+    {
+        public int Id { get; set; }
+        public string EmbyPath { get; set; }
+        public string LocalPath { get; set; }
+        public int EmbyMediaSourceId { get; set; }
+        public EmbyMediaSource EmbyMediaSource { get; set; }
+    }
+}

ErsatzTV.Core/Domain/ProgramSchedule.cs

@@ -7,6 +7,7 @@ namespace ErsatzTV.Core.Domain
         public int Id { get; set; }
         public string Name { get; set; }
         public PlaybackOrder MediaCollectionPlaybackOrder { get; set; }
+        public bool KeepMultiPartEpisodesTogether { get; set; }
         public List<ProgramScheduleItem> Items { get; set; }
         public List<Playout> Playouts { get; set; }
     }

ErsatzTV.Core/Emby/EmbyItemEtag.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Core.Emby
+{
+    public class EmbyItemEtag
+    {
+        public string ItemId { get; set; }
+        public string Etag { get; set; }
+    }
+}

ErsatzTV.Core/Emby/EmbyMovieLibraryScanner.cs

@@ -0,0 +1,230 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Metadata;
+using LanguageExt;
+using LanguageExt.UnsafeValueAccess;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Core.Emby
+{
+    public class EmbyMovieLibraryScanner : IEmbyMovieLibraryScanner
+    {
+        private readonly IEmbyApiClient _embyApiClient;
+        private readonly ILocalFileSystem _localFileSystem;
+        private readonly ILocalStatisticsProvider _localStatisticsProvider;
+        private readonly ILogger<EmbyMovieLibraryScanner> _logger;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IMediator _mediator;
+        private readonly IMovieRepository _movieRepository;
+        private readonly IEmbyPathReplacementService _pathReplacementService;
+        private readonly ISearchIndex _searchIndex;
+        private readonly ISearchRepository _searchRepository;
+
+        public EmbyMovieLibraryScanner(
+            IEmbyApiClient embyApiClient,
+            ISearchIndex searchIndex,
+            IMediator mediator,
+            IMovieRepository movieRepository,
+            ISearchRepository searchRepository,
+            IEmbyPathReplacementService pathReplacementService,
+            IMediaSourceRepository mediaSourceRepository,
+            ILocalFileSystem localFileSystem,
+            ILocalStatisticsProvider localStatisticsProvider,
+            ILogger<EmbyMovieLibraryScanner> logger)
+        {
+            _embyApiClient = embyApiClient;
+            _searchIndex = searchIndex;
+            _mediator = mediator;
+            _movieRepository = movieRepository;
+            _searchRepository = searchRepository;
+            _pathReplacementService = pathReplacementService;
+            _mediaSourceRepository = mediaSourceRepository;
+            _localFileSystem = localFileSystem;
+            _localStatisticsProvider = localStatisticsProvider;
+            _logger = logger;
+        }
+
+        public async Task<Either<BaseError, Unit>> ScanLibrary(
+            string address,
+            string apiKey,
+            EmbyLibrary library,
+            string ffprobePath)
+        {
+            List<EmbyItemEtag> existingMovies = await _movieRepository.GetExistingEmbyMovies(library);
+
+            // TODO: maybe get quick list of item ids and etags from api to compare first
+            // TODO: paging?
+
+            List<EmbyPathReplacement> pathReplacements = await _mediaSourceRepository
+                .GetEmbyPathReplacements(library.MediaSourceId);
+
+            Either<BaseError, List<EmbyMovie>> maybeMovies = await _embyApiClient.GetMovieLibraryItems(
+                address,
+                apiKey,
+                library.MediaSourceId,
+                library.ItemId);
+
+            await maybeMovies.Match(
+                async movies =>
+                {
+                    var validMovies = new List<EmbyMovie>();
+                    foreach (EmbyMovie movie in movies.OrderBy(m => m.MovieMetadata.Head().Title))
+                    {
+                        string localPath = _pathReplacementService.GetReplacementEmbyPath(
+                            pathReplacements,
+                            movie.MediaVersions.Head().MediaFiles.Head().Path,
+                            false);
+
+                        if (!_localFileSystem.FileExists(localPath))
+                        {
+                            _logger.LogWarning("Skipping emby movie that does not exist at {Path}", localPath);
+                        }
+                        else
+                        {
+                            validMovies.Add(movie);
+                        }
+                    }
+
+                    foreach (EmbyMovie incoming in validMovies)
+                    {
+                        decimal percentCompletion = (decimal) validMovies.IndexOf(incoming) / validMovies.Count;
+                        await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
+
+                        Option<EmbyItemEtag> maybeExisting =
+                            existingMovies.Find(ie => ie.ItemId == incoming.ItemId);
+
+                        var updateStatistics = false;
+
+                        await maybeExisting.Match(
+                            async existing =>
+                            {
+                                try
+                                {
+                                    if (existing.Etag == incoming.Etag)
+                                    {
+                                        // _logger.LogDebug(
+                                        //     $"NOOP: Etag has not changed for movie {incoming.MovieMetadata.Head().Title}");
+                                        return;
+                                    }
+
+                                    _logger.LogDebug(
+                                        "UPDATE: Etag has changed for movie {Movie}",
+                                        incoming.MovieMetadata.Head().Title);
+
+                                    updateStatistics = true;
+                                    incoming.LibraryPathId = library.Paths.Head().Id;
+                                    Option<EmbyMovie> updated = await _movieRepository.UpdateEmby(incoming);
+                                    if (updated.IsSome)
+                                    {
+                                        await _searchIndex.UpdateItems(
+                                            _searchRepository,
+                                            new List<MediaItem> { updated.ValueUnsafe() });
+                                    }
+                                }
+                                catch (Exception ex)
+                                {
+                                    updateStatistics = false;
+                                    _logger.LogError(
+                                        ex,
+                                        "Error updating movie {Movie}",
+                                        incoming.MovieMetadata.Head().Title);
+                                }
+                            },
+                            async () =>
+                            {
+                                try
+                                {
+                                    // _logger.LogDebug(
+                                    //     $"INSERT: Item id is new for movie {incoming.MovieMetadata.Head().Title}");
+
+                                    updateStatistics = true;
+                                    incoming.LibraryPathId = library.Paths.Head().Id;
+                                    if (await _movieRepository.AddEmby(incoming))
+                                    {
+                                        await _searchIndex.AddItems(
+                                            _searchRepository,
+                                            new List<MediaItem> { incoming });
+                                    }
+                                }
+                                catch (Exception ex)
+                                {
+                                    updateStatistics = false;
+                                    _logger.LogError(
+                                        ex,
+                                        "Error adding movie {Movie}",
+                                        incoming.MovieMetadata.Head().Title);
+                                }
+                            });
+
+                        if (updateStatistics)
+                        {
+                            string localPath = _pathReplacementService.GetReplacementEmbyPath(
+                                pathReplacements,
+                                incoming.MediaVersions.Head().MediaFiles.Head().Path,
+                                false);
+
+                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
+                            Either<BaseError, bool> refreshResult =
+                                await _localStatisticsProvider.RefreshStatistics(ffprobePath, incoming, localPath);
+
+                            await refreshResult.Match(
+                                async _ =>
+                                {
+                                    Option<MediaItem> updated = await _searchRepository.GetItemToIndex(incoming.Id);
+                                    if (updated.IsSome)
+                                    {
+                                        await _searchIndex.UpdateItems(
+                                            _searchRepository,
+                                            new List<MediaItem> { updated.ValueUnsafe() });
+                                    }
+                                },
+                                error =>
+                                {
+                                    _logger.LogWarning(
+                                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                                        "Statistics",
+                                        localPath,
+                                        error.Value);
+
+                                    return Task.CompletedTask;
+                                });
+                        }
+
+                        // TODO: figure out how to rebuild playlists
+                    }
+
+                    var incomingMovieIds = validMovies.Map(s => s.ItemId).ToList();
+                    var movieIds = existingMovies
+                        .Filter(i => !incomingMovieIds.Contains(i.ItemId))
+                        .Map(m => m.ItemId)
+                        .ToList();
+                    List<int> ids = await _movieRepository.RemoveMissingEmbyMovies(library, movieIds);
+                    await _searchIndex.RemoveItems(ids);
+
+                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+                    _searchIndex.Commit();
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Error synchronizing emby library {Path}: {Error}",
+                        library.Name,
+                        error.Value);
+
+                    return Task.CompletedTask;
+                });
+
+            _searchIndex.Commit();
+            return Unit.Default;
+        }
+    }
+}

ErsatzTV.Core/Emby/EmbyPathReplacementService.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Runtime;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.Core.Emby
+{
+    public class EmbyPathReplacementService : IEmbyPathReplacementService
+    {
+        private readonly ILogger<EmbyPathReplacementService> _logger;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IRuntimeInfo _runtimeInfo;
+
+        public EmbyPathReplacementService(
+            IMediaSourceRepository mediaSourceRepository,
+            IRuntimeInfo runtimeInfo,
+            ILogger<EmbyPathReplacementService> logger)
+        {
+            _mediaSourceRepository = mediaSourceRepository;
+            _runtimeInfo = runtimeInfo;
+            _logger = logger;
+        }
+
+        public async Task<string> GetReplacementEmbyPath(int libraryPathId, string path)
+        {
+            List<EmbyPathReplacement> replacements =
+                await _mediaSourceRepository.GetEmbyPathReplacementsByLibraryId(libraryPathId);
+
+            return GetReplacementEmbyPath(replacements, path);
+        }
+
+        public string GetReplacementEmbyPath(
+            List<EmbyPathReplacement> pathReplacements,
+            string path,
+            bool log = true)
+        {
+            Option<EmbyPathReplacement> maybeReplacement = pathReplacements
+                .SingleOrDefault(
+                    r =>
+                    {
+                        string separatorChar = IsWindows(r.EmbyMediaSource, path) ? @"\" : @"/";
+                        string prefix = r.EmbyPath.EndsWith(separatorChar)
+                            ? r.EmbyPath
+                            : r.EmbyPath + separatorChar;
+                        return path.StartsWith(prefix);
+                    });
+
+            return maybeReplacement.Match(
+                replacement =>
+                {
+                    string finalPath = path.Replace(replacement.EmbyPath, replacement.LocalPath);
+                    if (IsWindows(replacement.EmbyMediaSource, path) && !_runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                    {
+                        finalPath = finalPath.Replace(@"\", @"/");
+                    }
+                    else if (!IsWindows(replacement.EmbyMediaSource, path) &&
+                             _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                    {
+                        finalPath = finalPath.Replace(@"/", @"\");
+                    }
+
+                    if (log)
+                    {
+                        _logger.LogDebug(
+                            "Replacing emby path {EmbyPath} with {LocalPath} resulting in {FinalPath}",
+                            replacement.EmbyPath,
+                            replacement.LocalPath,
+                            finalPath);
+                    }
+
+                    return finalPath;
+                },
+                () => path);
+        }
+
+        private static bool IsWindows(EmbyMediaSource embyMediaSource, string path)
+        {
+            bool isUnc = Uri.TryCreate(path, UriKind.Absolute, out Uri uri) && uri.IsUnc;
+            return isUnc || embyMediaSource.OperatingSystem.ToLowerInvariant().StartsWith("windows");
+        }
+    }
+}

ErsatzTV.Core/Emby/EmbySecrets.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core.MediaSources;
+
+namespace ErsatzTV.Core.Emby
+{
+    public class EmbySecrets : RemoteMediaSourceSecrets
+    {
+    }
+}

ErsatzTV.Core/Emby/EmbyServerInformation.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Core.Emby
+{
+    public record EmbyServerInformation(string ServerName, string OperatingSystem);
+}

ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs

@@ -0,0 +1,416 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Metadata;
+using LanguageExt;
+using LanguageExt.UnsafeValueAccess;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Core.Emby
+{
+    public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
+    {
+        private readonly IEmbyApiClient _embyApiClient;
+        private readonly ILocalFileSystem _localFileSystem;
+        private readonly ILocalStatisticsProvider _localStatisticsProvider;
+        private readonly ILogger<EmbyTelevisionLibraryScanner> _logger;
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly IMediator _mediator;
+        private readonly IEmbyPathReplacementService _pathReplacementService;
+        private readonly ISearchIndex _searchIndex;
+        private readonly ISearchRepository _searchRepository;
+        private readonly IEmbyTelevisionRepository _televisionRepository;
+
+        public EmbyTelevisionLibraryScanner(
+            IEmbyApiClient embyApiClient,
+            IMediaSourceRepository mediaSourceRepository,
+            IEmbyTelevisionRepository televisionRepository,
+            ISearchIndex searchIndex,
+            ISearchRepository searchRepository,
+            IEmbyPathReplacementService pathReplacementService,
+            ILocalFileSystem localFileSystem,
+            ILocalStatisticsProvider localStatisticsProvider,
+            IMediator mediator,
+            ILogger<EmbyTelevisionLibraryScanner> logger)
+        {
+            _embyApiClient = embyApiClient;
+            _mediaSourceRepository = mediaSourceRepository;
+            _televisionRepository = televisionRepository;
+            _searchIndex = searchIndex;
+            _searchRepository = searchRepository;
+            _pathReplacementService = pathReplacementService;
+            _localFileSystem = localFileSystem;
+            _localStatisticsProvider = localStatisticsProvider;
+            _mediator = mediator;
+            _logger = logger;
+        }
+
+        public async Task<Either<BaseError, Unit>> ScanLibrary(
+            string address,
+            string apiKey,
+            EmbyLibrary library,
+            string ffprobePath)
+        {
+            List<EmbyItemEtag> existingShows = await _televisionRepository.GetExistingShows(library);
+
+            // TODO: maybe get quick list of item ids and etags from api to compare first
+            // TODO: paging?
+
+            List<EmbyPathReplacement> pathReplacements = await _mediaSourceRepository
+                .GetEmbyPathReplacements(library.MediaSourceId);
+
+            Either<BaseError, List<EmbyShow>> maybeShows = await _embyApiClient.GetShowLibraryItems(
+                address,
+                apiKey,
+                library.MediaSourceId,
+                library.ItemId);
+
+            await maybeShows.Match(
+                async shows =>
+                {
+                    await ProcessShows(address, apiKey, library, ffprobePath, pathReplacements, existingShows, shows);
+
+                    var incomingShowIds = shows.Map(s => s.ItemId).ToList();
+                    var showIds = existingShows
+                        .Filter(i => !incomingShowIds.Contains(i.ItemId))
+                        .Map(m => m.ItemId)
+                        .ToList();
+                    List<int> missingShowIds = await _televisionRepository.RemoveMissingShows(library, showIds);
+                    await _searchIndex.RemoveItems(missingShowIds);
+
+                    await _televisionRepository.DeleteEmptySeasons(library);
+                    List<int> emptyShowIds = await _televisionRepository.DeleteEmptyShows(library);
+                    await _searchIndex.RemoveItems(emptyShowIds);
+
+                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+                    _searchIndex.Commit();
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Error synchronizing emby library {Path}: {Error}",
+                        library.Name,
+                        error.Value);
+
+                    return Task.CompletedTask;
+                });
+
+            return Unit.Default;
+        }
+
+        private async Task ProcessShows(
+            string address,
+            string apiKey,
+            EmbyLibrary library,
+            string ffprobePath,
+            List<EmbyPathReplacement> pathReplacements,
+            List<EmbyItemEtag> existingShows,
+            List<EmbyShow> shows)
+        {
+            foreach (EmbyShow incoming in shows.OrderBy(s => s.ShowMetadata.Head().Title))
+            {
+                decimal percentCompletion = (decimal) shows.IndexOf(incoming) / shows.Count;
+                await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
+
+                var changed = false;
+
+                Option<EmbyItemEtag> maybeExisting = existingShows.Find(ie => ie.ItemId == incoming.ItemId);
+                await maybeExisting.Match(
+                    async existing =>
+                    {
+                        if (existing.Etag == incoming.Etag)
+                        {
+                            return;
+                        }
+
+                        _logger.LogDebug(
+                            "UPDATE: Etag has changed for show {Show}",
+                            incoming.ShowMetadata.Head().Title);
+
+                        changed = true;
+                        incoming.LibraryPathId = library.Paths.Head().Id;
+
+                        Option<EmbyShow> updated = await _televisionRepository.Update(incoming);
+                        if (updated.IsSome)
+                        {
+                            await _searchIndex.UpdateItems(
+                                _searchRepository,
+                                new List<MediaItem> { updated.ValueUnsafe() });
+                        }
+                    },
+                    async () =>
+                    {
+                        changed = true;
+                        incoming.LibraryPathId = library.Paths.Head().Id;
+
+                        // _logger.LogDebug("INSERT: Item id is new for show {Show}", incoming.ShowMetadata.Head().Title);
+
+                        if (await _televisionRepository.AddShow(incoming))
+                        {
+                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
+                        }
+                    });
+
+                if (changed)
+                {
+                    List<EmbyItemEtag> existingSeasons =
+                        await _televisionRepository.GetExistingSeasons(library, incoming.ItemId);
+
+                    Either<BaseError, List<EmbySeason>> maybeSeasons =
+                        await _embyApiClient.GetSeasonLibraryItems(
+                            address,
+                            apiKey,
+                            library.MediaSourceId,
+                            incoming.ItemId);
+
+                    await maybeSeasons.Match(
+                        async seasons =>
+                        {
+                            await ProcessSeasons(
+                                address,
+                                apiKey,
+                                library,
+                                ffprobePath,
+                                pathReplacements,
+                                incoming,
+                                existingSeasons,
+                                seasons);
+
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { incoming });
+
+                            var incomingSeasonIds = seasons.Map(s => s.ItemId).ToList();
+                            var seasonIds = existingSeasons
+                                .Filter(i => !incomingSeasonIds.Contains(i.ItemId))
+                                .Map(m => m.ItemId)
+                                .ToList();
+                            await _televisionRepository.RemoveMissingSeasons(library, seasonIds);
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning(
+                                "Error synchronizing emby library {Path}: {Error}",
+                                library.Name,
+                                error.Value);
+
+                            return Task.CompletedTask;
+                        });
+                }
+            }
+        }
+
+        private async Task ProcessSeasons(
+            string address,
+            string apiKey,
+            EmbyLibrary library,
+            string ffprobePath,
+            List<EmbyPathReplacement> pathReplacements,
+            EmbyShow show,
+            List<EmbyItemEtag> existingSeasons,
+            List<EmbySeason> seasons)
+        {
+            foreach (EmbySeason incoming in seasons)
+            {
+                var changed = false;
+
+                Option<EmbyItemEtag> maybeExisting = existingSeasons.Find(ie => ie.ItemId == incoming.ItemId);
+                await maybeExisting.Match(
+                    async existing =>
+                    {
+                        if (existing.Etag == incoming.Etag)
+                        {
+                            return;
+                        }
+
+                        _logger.LogDebug(
+                            "UPDATE: Etag has changed for show {Show} season {Season}",
+                            show.ShowMetadata.Head().Title,
+                            incoming.SeasonMetadata.Head().Title);
+
+                        changed = true;
+                        incoming.ShowId = show.Id;
+                        incoming.LibraryPathId = library.Paths.Head().Id;
+
+                        await _televisionRepository.Update(incoming);
+                    },
+                    async () =>
+                    {
+                        changed = true;
+                        incoming.ShowId = show.Id;
+                        incoming.LibraryPathId = library.Paths.Head().Id;
+
+                        _logger.LogDebug(
+                            "INSERT: Item id is new for show {Show} season {Season}",
+                            show.ShowMetadata.Head().Title,
+                            incoming.SeasonMetadata.Head().Title);
+
+                        await _televisionRepository.AddSeason(incoming);
+                    });
+
+                if (changed)
+                {
+                    List<EmbyItemEtag> existingEpisodes =
+                        await _televisionRepository.GetExistingEpisodes(library, incoming.ItemId);
+
+                    Either<BaseError, List<EmbyEpisode>> maybeEpisodes =
+                        await _embyApiClient.GetEpisodeLibraryItems(
+                            address,
+                            apiKey,
+                            library.MediaSourceId,
+                            incoming.ItemId);
+
+                    await maybeEpisodes.Match(
+                        async episodes =>
+                        {
+                            var validEpisodes = new List<EmbyEpisode>();
+                            foreach (EmbyEpisode episode in episodes)
+                            {
+                                string localPath = _pathReplacementService.GetReplacementEmbyPath(
+                                    pathReplacements,
+                                    episode.MediaVersions.Head().MediaFiles.Head().Path,
+                                    false);
+
+                                if (!_localFileSystem.FileExists(localPath))
+                                {
+                                    _logger.LogWarning(
+                                        "Skipping emby episode that does not exist at {Path}",
+                                        localPath);
+                                }
+                                else
+                                {
+                                    validEpisodes.Add(episode);
+                                }
+                            }
+
+                            await ProcessEpisodes(
+                                show.ShowMetadata.Head().Title,
+                                incoming.SeasonMetadata.Head().Title,
+                                library,
+                                ffprobePath,
+                                pathReplacements,
+                                incoming,
+                                existingEpisodes,
+                                validEpisodes);
+
+                            var incomingEpisodeIds = episodes.Map(s => s.ItemId).ToList();
+                            var episodeIds = existingEpisodes
+                                .Filter(i => !incomingEpisodeIds.Contains(i.ItemId))
+                                .Map(m => m.ItemId)
+                                .ToList();
+                            await _televisionRepository.RemoveMissingEpisodes(library, episodeIds);
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning(
+                                "Error synchronizing emby library {Path}: {Error}",
+                                library.Name,
+                                error.Value);
+
+                            return Task.CompletedTask;
+                        });
+                }
+            }
+        }
+
+        private async Task ProcessEpisodes(
+            string showName,
+            string seasonName,
+            EmbyLibrary library,
+            string ffprobePath,
+            List<EmbyPathReplacement> pathReplacements,
+            EmbySeason season,
+            List<EmbyItemEtag> existingEpisodes,
+            List<EmbyEpisode> episodes)
+        {
+            foreach (EmbyEpisode incoming in episodes)
+            {
+                var updateStatistics = false;
+
+                Option<EmbyItemEtag> maybeExisting = existingEpisodes.Find(ie => ie.ItemId == incoming.ItemId);
+                await maybeExisting.Match(
+                    async existing =>
+                    {
+                        try
+                        {
+                            if (existing.Etag == incoming.Etag)
+                            {
+                                return;
+                            }
+
+                            _logger.LogDebug(
+                                "UPDATE: Etag has changed for show {Show} season {Season} episode {Episode}",
+                                showName,
+                                seasonName,
+                                incoming.EpisodeNumber);
+
+                            updateStatistics = true;
+                            incoming.SeasonId = season.Id;
+                            incoming.LibraryPathId = library.Paths.Head().Id;
+
+                            await _televisionRepository.Update(incoming);
+                        }
+                        catch (Exception ex)
+                        {
+                            updateStatistics = false;
+                            _logger.LogError(
+                                ex,
+                                "Error updating episode {Path}",
+                                incoming.MediaVersions.Head().MediaFiles.Head().Path);
+                        }
+                    },
+                    async () =>
+                    {
+                        try
+                        {
+                            updateStatistics = true;
+                            incoming.SeasonId = season.Id;
+                            incoming.LibraryPathId = library.Paths.Head().Id;
+
+                            _logger.LogDebug(
+                                "INSERT: Item id is new for show {Show} season {Season} episode {Episode}",
+                                showName,
+                                seasonName,
+                                incoming.EpisodeNumber);
+
+                            await _televisionRepository.AddEpisode(incoming);
+                        }
+                        catch (Exception ex)
+                        {
+                            updateStatistics = false;
+                            _logger.LogError(
+                                ex,
+                                "Error adding episode {Path}",
+                                incoming.MediaVersions.Head().MediaFiles.Head().Path);
+                        }
+                    });
+
+                if (updateStatistics)
+                {
+                    string localPath = _pathReplacementService.GetReplacementEmbyPath(
+                        pathReplacements,
+                        incoming.MediaVersions.Head().MediaFiles.Head().Path,
+                        false);
+
+                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
+                    Either<BaseError, bool> refreshResult =
+                        await _localStatisticsProvider.RefreshStatistics(ffprobePath, incoming, localPath);
+
+                    refreshResult.Match(
+                        _ => { },
+                        error => _logger.LogWarning(
+                            "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                            "Statistics",
+                            localPath,
+                            error.Value));
+                }
+            }
+        }
+    }
+}

ErsatzTV.Core/Emby/EmbyUrl.cs

@@ -0,0 +1,61 @@
+using ErsatzTV.Core.Domain;
+using Flurl;
+using LanguageExt;
+
+namespace ErsatzTV.Core.Emby
+{
+    public static class EmbyUrl
+    {
+        public static Url ForArtwork(Option<EmbyMediaSource> maybeEmby, string artwork)
+        {
+            string address = maybeEmby.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
+                .Flatten()
+                .IfNone("emby://");
+
+            string[] split = artwork.Replace("emby://", string.Empty).Split('?');
+            if (split.Length != 2)
+            {
+                return artwork;
+            }
+
+            string pathSegment = split[0];
+            QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+            return Url.Parse(address)
+                .AppendPathSegment(pathSegment)
+                .SetQueryParams(query);
+        }
+
+        public static Url ForArtwork(string address, string artwork)
+        {
+            string[] split = artwork.Replace("emby://", string.Empty).Split('?');
+            if (split.Length != 2)
+            {
+                return artwork;
+            }
+
+            string pathSegment = split[0];
+            QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+            return Url.Parse(address)
+                .AppendPathSegment(pathSegment)
+                .SetQueryParams(query);
+        }
+
+        public static Url ProxyForArtwork(string scheme, string host, string artwork)
+        {
+            string[] split = artwork.Replace("emby://", string.Empty).Split('?');
+            if (split.Length != 2)
+            {
+                return artwork;
+            }
+
+            string pathSegment = split[0];
+            QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+            return Url.Parse($"{scheme}://{host}/iptv/artwork/posters/emby")
+                .AppendPathSegment(pathSegment)
+                .SetQueryParams(query);
+        }
+    }
+}

ErsatzTV.Core/ErsatzTV.Core.csproj

@@ -10,6 +10,7 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
+      <PackageReference Include="Flurl" Version="3.0.2" />
       <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
       <PackageReference Include="MediatR" Version="9.0.0" />
       <PackageReference Include="Microsoft.Extensions.Http" Version="5.0.0" />
@@ -18,7 +19,7 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
     </ItemGroup>

ErsatzTV.Core/FFmpeg/ConcatPlaylist.cs

@@ -4,7 +4,7 @@
     {
         public override string ToString() =>
             $@"ffconcat version 1.0
-file http://localhost:8409/ffmpeg/stream/{ChannelNumber}
-file http://localhost:8409/ffmpeg/stream/{ChannelNumber}";
+file http://localhost:{Settings.ListenPort}/ffmpeg/stream/{ChannelNumber}
+file http://localhost:{Settings.ListenPort}/ffmpeg/stream/{ChannelNumber}";
     }
 }

ErsatzTV.Core/FFmpeg/FFmpegComplexFilterBuilder.cs

@@ -18,7 +18,6 @@ namespace ErsatzTV.Core.FFmpeg
         private string _inputCodec;
         private bool _normalizeLoudness;
         private Option<IDisplaySize> _padToSize = None;
-        private bool _realtime;
         private Option<IDisplaySize> _scaleToSize = None;
 
         public FFmpegComplexFilterBuilder WithHardwareAcceleration(HardwareAccelerationKind hardwareAccelerationKind)
@@ -27,12 +26,6 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public FFmpegComplexFilterBuilder WithRealtime(bool realtime)
-        {
-            _realtime = realtime;
-            return this;
-        }
-
         public FFmpegComplexFilterBuilder WithScaling(IDisplaySize scaleToSize)
         {
             _scaleToSize = Some(scaleToSize);
@@ -102,11 +95,6 @@ namespace ErsatzTV.Core.FFmpeg
             _audioDuration.IfSome(
                 audioDuration => audioFilterQueue.Add($"apad=whole_dur={audioDuration.TotalMilliseconds}ms"));
 
-            if (_realtime)
-            {
-                videoFilterQueue.Add("realtime");
-            }
-
             bool usesHardwareFilters = acceleration != HardwareAccelerationKind.None && !isHardwareDecode &&
                                        (_deinterlace || _scaleToSize.IsSome);
             if (usesHardwareFilters)

ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettings.cs

@@ -12,7 +12,7 @@ namespace ErsatzTV.Core.FFmpeg
         public List<string> FormatFlags { get; set; }
         public HardwareAccelerationKind HardwareAcceleration { get; set; }
         public string VideoDecoder { get; set; }
-        public bool RealtimeOutput { get; set; }
+        public bool RealtimeOutput => true;
         public Option<TimeSpan> StreamSeek { get; set; }
         public Option<IDisplaySize> ScaledSize { get; set; }
         public bool PadToDesiredResolution { get; set; }

ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs

@@ -68,10 +68,8 @@ namespace ErsatzTV.Core.FFmpeg
                     result.AudioCodec = "copy";
                     result.VideoCodec = "copy";
                     result.Deinterlace = false;
-                    result.RealtimeOutput = false;
                     break;
                 case StreamingMode.TransportStream:
-                    result.RealtimeOutput = true;
                     result.HardwareAcceleration = ffmpegProfile.HardwareAcceleration;
 
                     if (NeedToScale(ffmpegProfile, version))
@@ -79,7 +77,9 @@ namespace ErsatzTV.Core.FFmpeg
                         IDisplaySize scaledSize = CalculateScaledSize(ffmpegProfile, version);
                         if (!scaledSize.IsSameSizeAs(version))
                         {
-                            result.ScaledSize = Some(CalculateScaledSize(ffmpegProfile, version));
+                            int fixedHeight = scaledSize.Height + scaledSize.Height % 2;
+                            int fixedWidth = scaledSize.Width + scaledSize.Width % 2;
+                            result.ScaledSize = Some((IDisplaySize) new DisplaySize(fixedWidth, fixedHeight));
                         }
                     }
 
@@ -99,7 +99,7 @@ namespace ErsatzTV.Core.FFmpeg
                     }
 
                     if (result.ScaledSize.IsSome || result.PadToDesiredResolution ||
-                        NeedToNormalizeVideoCodec(ffmpegProfile, videoStream))
+                        NeedToNormalizeVideoCodec(ffmpegProfile, videoStream) || result.FrameRate.IsSome)
                     {
                         result.VideoCodec = ffmpegProfile.VideoCodec;
                         result.VideoBitrate = ffmpegProfile.VideoBitrate;

ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs

@@ -90,7 +90,11 @@ namespace ErsatzTV.Core.FFmpeg
 
         public FFmpegProcessBuilder WithRealtimeOutput(bool realtimeOutput)
         {
-            _complexFilterBuilder = _complexFilterBuilder.WithRealtime(realtimeOutput);
+            if (realtimeOutput)
+            {
+                _arguments.Add("-re");
+            }
+
             return this;
         }
 
@@ -221,7 +225,8 @@ namespace ErsatzTV.Core.FFmpeg
 
         public FFmpegProcessBuilder WithErrorText(IDisplaySize desiredResolution, string text)
         {
-            const string FONT_FILE = "fontfile=Resources/Roboto-Regular.ttf";
+            string fontPath = Path.Combine(FileSystemLayout.ResourcesCacheFolder, "Roboto-Regular.ttf");            
+            var fontFile = $"fontfile={fontPath}";
             const string FONT_COLOR = "fontcolor=white";
             const string X = "x=(w-text_w)/2";
             const string Y = "y=(h-text_h)/3*2";
@@ -229,7 +234,7 @@ namespace ErsatzTV.Core.FFmpeg
             string fontSize = text.Length > 80 ? "fontsize=30" : text.Length > 60 ? "fontsize=40" : "fontsize=60";
 
             return WithFilterComplex(
-                $"[0:0]scale={desiredResolution.Width}:{desiredResolution.Height},drawtext={FONT_FILE}:{fontSize}:{FONT_COLOR}:{X}:{Y}:text='{text}'[v]",
+                $"[0:0]scale={desiredResolution.Width}:{desiredResolution.Height},drawtext={fontFile}:{fontSize}:{FONT_COLOR}:{X}:{Y}:text='{text}'[v]",
                 "[v]",
                 "1:a");
         }
@@ -389,7 +394,7 @@ namespace ErsatzTV.Core.FFmpeg
             {
                 FileName = _ffmpegPath,
                 RedirectStandardOutput = true,
-                RedirectStandardError = true,
+                RedirectStandardError = false,
                 UseShellExecute = false,
                 CreateNoWindow = true,
                 StandardOutputEncoding = Encoding.UTF8

ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
@@ -110,7 +111,7 @@ namespace ErsatzTV.Core.FFmpeg
                 .WithQuiet()
                 .WithFormatFlags(playbackSettings.FormatFlags)
                 .WithRealtimeOutput(playbackSettings.RealtimeOutput)
-                .WithLoopedImage("Resources/background.png")
+                .WithLoopedImage(Path.Combine(FileSystemLayout.ResourcesCacheFolder, "background.png"))
                 .WithLibavfilter()
                 .WithInput("anullsrc")
                 .WithErrorText(desiredResolution, errorMessage)
@@ -134,7 +135,7 @@ namespace ErsatzTV.Core.FFmpeg
                 .WithFormatFlags(playbackSettings.FormatFlags)
                 .WithRealtimeOutput(playbackSettings.RealtimeOutput)
                 .WithInfiniteLoop()
-                .WithConcat($"http://localhost:8409/ffmpeg/concat/{channel.Number}")
+                .WithConcat($"http://localhost:{Settings.ListenPort}/ffmpeg/concat/{channel.Number}")
                 .WithMetadata(channel)
                 .WithFormat("mpegts")
                 .WithPipe()

ErsatzTV.Core/FileSystemLayout.cs

@@ -16,9 +16,11 @@ namespace ErsatzTV.Core
         public static readonly string LogDatabasePath = Path.Combine(AppDataFolder, "logs.sqlite3");
 
         public static readonly string LegacyImageCacheFolder = Path.Combine(AppDataFolder, "cache", "images");
+        public static readonly string ResourcesCacheFolder = Path.Combine(AppDataFolder, "cache", "resources");
 
         public static readonly string PlexSecretsPath = Path.Combine(AppDataFolder, "plex-secrets.json");
         public static readonly string JellyfinSecretsPath = Path.Combine(AppDataFolder, "jellyfin-secrets.json");
+        public static readonly string EmbySecretsPath = Path.Combine(AppDataFolder, "emby-secrets.json");
 
         public static readonly string FFmpegReportsFolder = Path.Combine(AppDataFolder, "ffmpeg-reports");
         public static readonly string SearchIndexFolder = Path.Combine(AppDataFolder, "search-index");