add videotoolbox acceleration (#575)

* flag local movies as file not found

* show warning icon on cards

* unflag movie that is found during scan

* skip missing files when building playouts

* add state to search index

* add file not found health check

* link to search from file not found health check

* support flagging other media kinds as file not found

* continue to schedule missing items

* support episode files not found

* wip trash page

* fix trash url

* trash page is functional

* update changelog

* fix changelog merge

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "jetbrains.resharper.globaltools": {
-      "version": "2021.1.3",
+      "version": "2021.2.2",
       "commands": [
         "jb"
       ]

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
       - name: Setup .NET Core
         uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: 5.0.x
+          dotnet-version: 6.0.x
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear

.github/workflows/docs.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout master
-        uses: actions/checkout@v1
+        uses: actions/checkout@v2
 
       - name: Deploy docs
         uses: mhausenblas/mkdocs-deploy-gh-pages@master

.github/workflows/release.yml

@@ -18,8 +18,11 @@ jobs:
             kind: windows
             target: win-x64
           - os: macos-latest
-            kind: maxOS
+            kind: macOS
             target: osx-x64
+          - os: macos-latest
+            kind: macOS
+            target: osx-arm64
     runs-on: ${{ matrix.os }}
     steps:
       - name: Get the sources
@@ -28,7 +31,7 @@ jobs:
       - name: Setup .NET Core
         uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: 5.0.x
+          dotnet-version: 6.0.x
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -44,14 +47,11 @@ jobs:
           release_name="ErsatzTV-$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 }}" /property:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}" /property:EnableCompressionInSingleFile=true /property:DebugType=Embedded /property:PublishSingleFile=true --self-contained true
 
           # Pack files
           if [ "${{ matrix.target }}" == "win-x64" ]; then
             7z a -tzip "${release_name}.zip" "./${release_name}/*"
-          elif [ "${{ matrix.target }}" == "linux-arm" ]; then
-            cp lib/linux-arm/* "$release_name/"
-            tar czvf "${release_name}.tar.gz" "$release_name"
           else
             tar czvf "${release_name}.tar.gz" "$release_name"
           fi

CHANGELOG.md

@@ -4,6 +4,139 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
+### Fixed
+- Fix local folder scanners to properly detect removed/re-added folders with unchanged contents
+- Fix double-click startup on mac
+- Fix trakt list sync when show does not contain a year
+- Properly unlock libraries when a scan is unable to be performed because ffmpeg or ffprobe have not been found
+
+### Added
+- Add trash system for local libraries to maintain collection and schedule integrity through media share outages
+  - When items are missing from disk, they will be flagged and present in the `Media` > `Trash` page
+  - The trash page can be used to permanently remove missing items from the database
+  - When items reappear at the expected location on disk, they will be unflagged and removed from the trash
+- Add basic Mac hardware acceleration using VideoToolbox
+
+### Changed
+- Local libraries only: when items are missing from disk, they will be added to the trash and no longer removed from collections, etc.
+- Show song thumbnail in song list
+
+## [0.3.6-alpha] - 2022-01-10
+### Fixed
+- Properly index `minutes` field when adding new items during scan (vs when rebuilding index)
+- Fix some nvenc edge cases where only padding is needed for normalization
+- Properly overwrite environment variables for ffmpeg processes (`LIBVA_DRIVER_NAME`, `FFREPORT`)
+
+### Added
+- Add music video `artist` to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Remove `HLS Hybrid` streaming mode; all channels have been reconfigured to use the superior `HLS Segmenter` streaming mode
+- Update `MPEG-TS` streaming mode to internally use the HLS segmenter
+  - This improves compatibility with many clients and also improves performance at program boundaries
+- Renamed existing `MPEG-TS` mode as `MPEG-TS (Legacy)`
+  - This mode will be removed in a future release
+
+## [0.3.5-alpha] - 2022-01-05
+### Fixed
+- Fix bundled ffmpeg version in base docker image (NOT nvidia or vaapi) which prevented playback since v0.3.0-alpha
+- Use software decoding for mpeg4 content when VAAPI acceleration is enabled
+- Fix hardware acceleration health check to recognize QSV on non-Windows platforms
+
+### Changed
+- Treat `setsar` as a hardware filter, avoiding unneeded `hwdownload` and `hwupload` steps when padding isn't required
+
+## [0.3.4-alpha] - 2021-12-21
+### Fixed
+- Fix other video and song scanners to include videos contained directly in top-level folders that are added to a library
+- Allow saving ffmpeg troubleshooting reports on Windows
+
+## [0.3.3-alpha] - 2021-12-12
+### Fixed
+- Fix bug with saving multiple blurhash versions for cover art; all cover art will be automatically rescanned
+- Fix song detail margin when no cover art exists and no watermark exists
+- Fix synchronizing virtual shows and seasons from Jellyfin
+- Properly sort channels in M3U
+
+### Changed
+- Use blurhash of ErsatzTV colors instead of solid colors for default song backgrounds
+- Use select control instead of autocomplete control in many places
+    - The autocomplete control is not intuitive to use and has focus bugs
+
+## [0.3.2-alpha] - 2021-12-03
+### Fixed
+- Fix artwork upload on Windows
+- Fix unicode song metadata on Windows
+- Fix unicode console output on Windows
+- Fix TV Show NFO metadata processing when `year` is missing
+- Fix song detail outline to help legibility on white backgrounds
+- Optimize song artwork scanning to prevent re-processing album artwork for each song
+
+### Changed
+- Use custom log database backend which should be more portable (i.e. work in osx-arm64)
+- Use cover art blurhashes for song backgrounds instead of solid colors or box blur
+
+## [0.3.1-alpha] - 2021-11-30
+### Fixed
+- Fix song page links in UI
+- Show song artist in playout detail
+- Include song artist and cover art in channel guide (xmltv)
+- Use subtitles to display errors, which fixes many edge cases of unescaped characters
+- Properly split song genre tags
+- Properly display all songs that have an identical album and title
+- Fix channel logo and watermark uploads
+- Fix regression introduced with `v0.2.4-alpha` that caused some filler edge cases to crash the playout builder
+
+### Added
+- Add song genres to search index
+- Use embedded song cover art when sidecar cover art is unavailable
+
+### Changed
+- Randomly place song cover art on left or right side of screen
+- Randomly use a solid color from the cover art instead of blurred cover art for song background
+- Randomly select song detail layout (large title/small artist or small artist/title/album)
+
+## [0.3.0-alpha] - 2021-11-25
+### Fixed
+- Properly fix database incompatibility introduced with `v0.2.4-alpha` and partially fixed with `v0.2.5-alpha`
+  - The proper fix requires rebuilding all playouts, which will happen on startup after upgrading
+- Fix local library locking/progress display when adding paths
+- Fix grouping duration items in EPG when custom title is configured
+
+### Added
+- Add *experimental* `Songs` local libraries
+    - Like `Other Videos`, `Songs` require no metadata or particular folder layout, and will have tags added for each containing folder
+    - For Example, a song at `rock/band/1990 - Album/01 whatever.flac` will have the tags `rock`, `band` and `1990 - Album`, and the title `01 whatever`
+    - Songs will also have basic metadata read from embedded tags (album, artist, title)
+    - Video will be automatically generated for songs using metadata and cover art or watermarks if available
+- Add support for `.webm` video files
+
+## [0.2.5-alpha] - 2021-11-21
+### Fixed
+- Include other video title in channel guide (xmltv)
+- Fix bug introduced with 0.2.4-alpha that caused some playouts to build from year 0
+- Use less memory matching Trakt list items
+
+### Added
+- Build osx-arm64 packages on release
+
+### Changed
+- No longer warn about local Plex guids; they aren't used for Trakt matching and can be ignored
+
+## [0.2.4-alpha] - 2021-11-13
+### Changed
+- Upgrade to dotnet 6
+- Use `scale_cuda` instead of `scale_npp` for NVIDIA scaling in all cases
+
+## [0.2.3-alpha] - 2021-11-03
+### Fixed
+- Fix bug with audio filter in cultures where `.` is a group/thousands separator
+- Fix bug where flood playout mode would only schedule one item
+  - This would happen if the flood was followed by another flood with a fixed start time
+
+### Added
+- Support empty `.etvignore` file to instruct local movie scanner to ignore the containing folder
 
 ## [0.2.2-alpha] - 2021-10-30
 ### Fixed
@@ -776,7 +909,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Initial release to facilitate testing outside of Docker.
 
 
-[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.1-alpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.6-alpha...HEAD
+[0.3.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.5-alpha...v0.3.6-alpha
+[0.3.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.4-alpha...v0.3.5-alpha
+[0.3.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.3-alpha...v0.3.4-alpha
+[0.3.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.2-alpha...v0.3.3-alpha
+[0.3.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.1-alpha...v0.3.2-alpha
+[0.3.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.0-alpha...v0.3.1-alpha
+[0.3.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.5-alpha...v0.3.0-alpha
+[0.2.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.4-alpha...v0.2.5-alpha
+[0.2.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.3-alpha...v0.2.4-alpha
+[0.2.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.2-alpha...v0.2.3-alpha
+[0.2.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.1-alpha...v0.2.2-alpha
 [0.2.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.0-alpha...v0.2.1-alpha
 [0.2.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.5-alpha...v0.2.0-alpha
 [0.1.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.4-alpha...v0.1.5-alpha

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -11,5 +11,6 @@ namespace ErsatzTV.Application.Channels
         string PreferredLanguageCode,
         StreamingMode StreamingMode,
         int? WatermarkId,
-        int? FallbackFillerId);
+        int? FallbackFillerId,
+        int PlayoutCount);
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -16,7 +16,8 @@ namespace ErsatzTV.Application.Channels
                 channel.PreferredLanguageCode,
                 channel.StreamingMode,
                 channel.WatermarkId,
-                channel.FallbackFillerId);
+                channel.FallbackFillerId,
+                channel.Playouts?.Count ?? 0);
 
         private static string GetLogo(Channel channel) =>
             Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,15 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net5.0</TargetFramework>
+        <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
-        <DebugType>embedded</DebugType>
     </PropertyGroup>
 
     <ItemGroup>
       <PackageReference Include="MediatR" Version="9.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.63">
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.64">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,13 +1,11 @@
 using System.Diagnostics;
 using System.IO;
-using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.Core.Interfaces.Runtime;
 using LanguageExt;
 
 namespace ErsatzTV.Application.FFmpegProfiles.Commands
@@ -16,16 +14,13 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
     {
         private readonly IConfigElementRepository _configElementRepository;
         private readonly ILocalFileSystem _localFileSystem;
-        private readonly IRuntimeInfo _runtimeInfo;
 
         public UpdateFFmpegSettingsHandler(
             IConfigElementRepository configElementRepository,
-            ILocalFileSystem localFileSystem,
+            ILocalFileSystem localFileSystem)
-            IRuntimeInfo runtimeInfo)
         {
             _configElementRepository = configElementRepository;
             _localFileSystem = localFileSystem;
-            _runtimeInfo = runtimeInfo;
         }
 
         public Task<Either<BaseError, Unit>> Handle(
@@ -36,8 +31,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(v => v.ToEitherAsync());
 
         private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
-            (await FFmpegMustExist(request), await FFprobeMustExist(request), ReportsAreNotSupportedOnWindows(request))
+            (await FFmpegMustExist(request), await FFprobeMustExist(request))
-            .Apply((_, _, _) => Unit.Default);
+            .Apply((_, _) => Unit.Default);
 
         private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
             ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
@@ -45,16 +40,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         private Task<Validation<BaseError, Unit>> FFprobeMustExist(UpdateFFmpegSettings request) =>
             ValidateToolPath(request.Settings.FFprobePath, "ffprobe");
 
-        private Validation<BaseError, Unit> ReportsAreNotSupportedOnWindows(UpdateFFmpegSettings request)
-        {
-            if (request.Settings.SaveReports && _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
-            {
-                return BaseError.New("FFmpeg reports are not supported on Windows");
-            }
-
-            return Unit.Default;
-        }
-
         private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
         {
             if (!_localFileSystem.FileExists(path))

ErsatzTV.Application/Images/Commands/SaveArtworkToDisk.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Core;
+using System.IO;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using LanguageExt;
 using MediatR;
@@ -6,5 +7,5 @@ using MediatR;
 namespace ErsatzTV.Application.Images.Commands
 {
     // ReSharper disable once SuggestBaseTypeForParameter
-    public record SaveArtworkToDisk(byte[] Buffer, ArtworkKind ArtworkKind) : IRequest<Either<BaseError, string>>;
+    public record SaveArtworkToDisk(Stream Stream, ArtworkKind ArtworkKind) : IRequest<Either<BaseError, string>>;
 }

ErsatzTV.Application/Images/Commands/SaveArtworkToDiskHandler.cs

@@ -14,6 +14,6 @@ namespace ErsatzTV.Application.Images.Commands
         public SaveArtworkToDiskHandler(IImageCache imageCache) => _imageCache = imageCache;
 
         public Task<Either<BaseError, string>> Handle(SaveArtworkToDisk request, CancellationToken cancellationToken) =>
-            _imageCache.SaveArtworkToCache(request.Buffer, request.ArtworkKind);
+            _imageCache.SaveArtworkToCache(request.Stream, request.ArtworkKind);
     }
 }

ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs

@@ -1,5 +1,4 @@
-using System.Collections.Generic;
+using System.Linq;
-using System.Linq;
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
@@ -37,7 +36,7 @@ namespace ErsatzTV.Application.Libraries.Commands
             CreateLocalLibrary request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             Validation<BaseError, LocalLibrary> validation = await Validate(dbContext, request);
             return await validation.Apply(localLibrary => PersistLocalLibrary(dbContext, localLibrary));
         }

ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs

@@ -43,7 +43,7 @@ namespace ErsatzTV.Application.Libraries.Commands
             UpdateLocalLibrary request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
             return await validation.Apply(parameters => UpdateLocalLibrary(dbContext, parameters));
         }
@@ -53,7 +53,6 @@ namespace ErsatzTV.Application.Libraries.Commands
             (LocalLibrary existing, LocalLibrary incoming) = parameters;
             existing.Name = incoming.Name;
             
-            // toAdd
             var toAdd = incoming.Paths
                 .Filter(p => existing.Paths.All(ep => NormalizePath(ep.Path) != NormalizePath(p.Path)))
                 .ToList();
@@ -77,7 +76,7 @@ namespace ErsatzTV.Application.Libraries.Commands
                 _searchIndex.Commit();
             }
 
-            if (toAdd.Count > 0 || toRemove.Count > 0 && _entityLocker.LockLibrary(existing.Id))
+            if ((toAdd.Count > 0 || toRemove.Count > 0) && _entityLocker.LockLibrary(existing.Id))
             {
                 await _workerChannel.WriteAsync(new ForceScanLocalLibrary(existing.Id));
             }

ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabase.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Maintenance.Commands;
+
+public record DeleteItemsFromDatabase(List<int> MediaItemIds) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabaseHandler.cs

@@ -0,0 +1,38 @@
+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.Maintenance.Commands
+{
+    public class
+        DeleteItemsFromDatabaseHandler : MediatR.IRequestHandler<DeleteItemsFromDatabase, Either<BaseError, Unit>>
+    {
+        private readonly IMediaItemRepository _mediaItemRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public DeleteItemsFromDatabaseHandler(
+            IMediaItemRepository mediaItemRepository,
+            ISearchIndex searchIndex)
+        {
+            _mediaItemRepository = mediaItemRepository;
+            _searchIndex = searchIndex;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DeleteItemsFromDatabase request,
+            CancellationToken cancellationToken)
+        {
+            Either<BaseError, Unit> deleteResult = await _mediaItemRepository.DeleteItems(request.MediaItemIds);
+            if (deleteResult.IsRight)
+            {
+                await _searchIndex.RemoveItems(request.MediaItemIds);
+                _searchIndex.Commit();
+            }
+
+            return deleteResult;
+        }
+    }
+}

ErsatzTV.Application/MediaCards/ActorCardViewModel.cs

@@ -1,5 +1,7 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
-    public record ActorCardViewModel(int Id, string Name, string Role, string Thumb) :
+    public record ActorCardViewModel(int Id, string Name, string Role, string Thumb, MediaItemState State) :
-        MediaCardViewModel(Id, Name, Role, Name, Thumb);
+        MediaCardViewModel(Id, Name, Role, Name, Thumb, State);
 }

ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs

@@ -1,10 +1,19 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
     public record ArtistCardViewModel
-        (int ArtistId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+    (
-            ArtistId,
+        int ArtistId,
-            Title,
+        string Title,
-            Subtitle,
+        string Subtitle,
-            SortTitle,
+        string SortTitle,
-            Poster);
+        string Poster,
+        MediaItemState State) : MediaCardViewModel(
+        ArtistId,
+        Title,
+        Subtitle,
+        SortTitle,
+        Poster,
+        State);
 }

ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs

@@ -10,7 +10,8 @@ namespace ErsatzTV.Application.MediaCards
         List<TelevisionEpisodeCardViewModel> EpisodeCards,
         List<ArtistCardViewModel> ArtistCards,
         List<MusicVideoCardViewModel> MusicVideoCards,
-        List<OtherVideoCardViewModel> OtherVideoCards)
+        List<OtherVideoCardViewModel> OtherVideoCards,
+        List<SongCardViewModel> SongCards)
     {
         public bool UseCustomPlaybackOrder { get; set; }
     }

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -2,6 +2,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Jellyfin;
 using LanguageExt;
 using static LanguageExt.Prelude;
@@ -19,7 +20,8 @@ namespace ErsatzTV.Application.MediaCards
                 showMetadata.Title,
                 showMetadata.Year?.ToString(),
                 showMetadata.SortTitle,
-                GetPoster(showMetadata, maybeJellyfin, maybeEmby));
+                GetPoster(showMetadata, maybeJellyfin, maybeEmby),
+                showMetadata.Show.State);
         
         internal static TelevisionSeasonCardViewModel ProjectToViewModel(
             Season season,
@@ -34,7 +36,8 @@ namespace ErsatzTV.Application.MediaCards
                 GetSeasonName(season.SeasonNumber),
                 season.SeasonMetadata.HeadOrNone().Map(sm => GetPoster(sm, maybeJellyfin, maybeEmby))
                     .IfNone(string.Empty),
-                season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString());
+                season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString(),
+                season.State);
 
         internal static TelevisionSeasonCardViewModel ProjectToViewModel(
             SeasonMetadata seasonMetadata,
@@ -53,7 +56,8 @@ namespace ErsatzTV.Application.MediaCards
                 GetSeasonName(seasonMetadata.Season.SeasonNumber),
                 $"{showTitle}_{seasonMetadata.Season.SeasonNumber:0000}",
                 GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
-                seasonMetadata.Season.SeasonNumber == 0 ? "S" : seasonMetadata.Season.SeasonNumber.ToString());
+                seasonMetadata.Season.SeasonNumber == 0 ? "S" : seasonMetadata.Season.SeasonNumber.ToString(),
+                seasonMetadata.Season.State);
         }
 
         internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
@@ -80,7 +84,9 @@ namespace ErsatzTV.Application.MediaCards
                     ? GetEpisodePoster(episodeMetadata, maybeJellyfin, maybeEmby)
                     : GetThumbnail(episodeMetadata, maybeJellyfin, maybeEmby),
                 episodeMetadata.Directors.Map(d => d.Name).ToList(),
-                episodeMetadata.Writers.Map(w => w.Name).ToList());
+                episodeMetadata.Writers.Map(w => w.Name).ToList(),
+                episodeMetadata.Episode.State,
+                episodeMetadata.Episode.GetHeadVersion().MediaFiles.Head().Path);
 
         internal static MovieCardViewModel ProjectToViewModel(
             MovieMetadata movieMetadata,
@@ -91,7 +97,8 @@ namespace ErsatzTV.Application.MediaCards
                 movieMetadata.Title,
                 movieMetadata.Year?.ToString(),
                 movieMetadata.SortTitle,
-                GetPoster(movieMetadata, maybeJellyfin, maybeEmby));
+                GetPoster(movieMetadata, maybeJellyfin, maybeEmby),
+                movieMetadata.Movie.State);
 
         internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
             new(
@@ -101,14 +108,29 @@ namespace ErsatzTV.Application.MediaCards
                 musicVideoMetadata.SortTitle,
                 musicVideoMetadata.Plot,
                 musicVideoMetadata.Album,
-                GetThumbnail(musicVideoMetadata, None, None));
+                GetThumbnail(musicVideoMetadata, None, None),
+                musicVideoMetadata.MusicVideo.State,
+                musicVideoMetadata.MusicVideo.GetHeadVersion().MediaFiles.Head().Path);
 
         internal static OtherVideoCardViewModel ProjectToViewModel(OtherVideoMetadata otherVideoMetadata) =>
             new(
                 otherVideoMetadata.OtherVideoId,
                 otherVideoMetadata.Title,
                 otherVideoMetadata.OriginalTitle,
-                otherVideoMetadata.SortTitle);
+                otherVideoMetadata.SortTitle,
+                otherVideoMetadata.OtherVideo.State);
+
+        internal static SongCardViewModel ProjectToViewModel(SongMetadata songMetadata)
+        {
+            string album = string.IsNullOrWhiteSpace(songMetadata.Album) ? "" : $" - {songMetadata.Album}";
+            return new SongCardViewModel(
+                songMetadata.SongId,
+                songMetadata.Title,
+                songMetadata.Artist + album,
+                songMetadata.SortTitle,
+                GetThumbnail(songMetadata, None, None),
+                songMetadata.Song.State);
+        }
 
         internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
             new(
@@ -116,7 +138,8 @@ namespace ErsatzTV.Application.MediaCards
                 artistMetadata.Title,
                 artistMetadata.Disambiguation,
                 artistMetadata.SortTitle,
-                GetThumbnail(artistMetadata, None, None));
+                GetThumbnail(artistMetadata, None, None),
+                artistMetadata.Artist.State);
 
         internal static CollectionCardResultsViewModel
             ProjectToViewModel(
@@ -141,7 +164,9 @@ namespace ErsatzTV.Application.MediaCards
                 collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
                 collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
                     .ToList(),
-                collection.MediaItems.OfType<OtherVideo>().Map(mv => ProjectToViewModel(mv.OtherVideoMetadata.Head()))
+                collection.MediaItems.OfType<OtherVideo>().Map(ov => ProjectToViewModel(ov.OtherVideoMetadata.Head()))
+                    .ToList(),
+                collection.MediaItems.OfType<Song>().Map(s => ProjectToViewModel(s.SongMetadata.Head()))
                     .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
 
         internal static ActorCardViewModel ProjectToViewModel(
@@ -162,7 +187,7 @@ namespace ErsatzTV.Application.MediaCards
                     .SetQueryParam("maxHeight", 440);
             }
 
-            return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork);
+            return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork, MediaItemState.Normal);
         }
 
         private static int GetCustomIndex(Collection collection, int mediaItemId) =>

ErsatzTV.Application/MediaCards/MediaCardViewModel.cs

@@ -1,4 +1,12 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
-    public record MediaCardViewModel(int MediaItemId, string Title, string Subtitle, string SortTitle, string Poster);
+    public record MediaCardViewModel(
+        int MediaItemId,
+        string Title,
+        string Subtitle,
+        string SortTitle,
+        string Poster,
+        MediaItemState State);
 }

ErsatzTV.Application/MediaCards/MovieCardViewModel.cs

@@ -1,12 +1,21 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
     public record MovieCardViewModel
-        (int MovieId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+    (
-            MovieId,
+        int MovieId,
-            Title,
+        string Title,
-            Subtitle,
+        string Subtitle,
-            SortTitle,
+        string SortTitle,
-            Poster)
+        string Poster,
+        MediaItemState State) : MediaCardViewModel(
+        MovieId,
+        Title,
+        Subtitle,
+        SortTitle,
+        Poster,
+        State)
     {
         public int CustomIndex { get; set; }
     }

ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs

@@ -1,4 +1,6 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
     public record MusicVideoCardViewModel
     (
@@ -8,12 +10,15 @@
         string SortTitle,
         string Plot,
         string Album,
-        string Poster) : MediaCardViewModel(
+        string Poster,
+        MediaItemState State,
+        string Path) : MediaCardViewModel(
         MusicVideoId,
         Title,
         Subtitle,
         SortTitle,
-        Poster)
+        Poster,
+        State)
     {
         public int CustomIndex { get; set; }
     }

ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs

@@ -1,16 +1,20 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
     public record OtherVideoCardViewModel
     (
         int OtherVideoId,
         string Title,
         string Subtitle,
-        string SortTitle) : MediaCardViewModel(
+        string SortTitle,
+        MediaItemState State) : MediaCardViewModel(
         OtherVideoId,
         Title,
         Subtitle,
         SortTitle,
-        null)
+        null,
+        State)
     {
         public int CustomIndex { get; set; }
     }

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

@@ -30,7 +30,7 @@ namespace ErsatzTV.Application.MediaCards.Queries
             GetCollectionCards request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());
@@ -83,6 +83,9 @@ namespace ErsatzTV.Application.MediaCards.Queries
                 .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
                 .ThenInclude(ovm => ovm.Artwork)
+                .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as Song).SongMetadata)
+                .ThenInclude(ovm => ovm.Artwork)
                 .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
                 .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
                 .MapT(c => ProjectToViewModel(c, maybeJellyfin, maybeEmby));

ErsatzTV.Application/MediaCards/SongCardResultsViewModel.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record SongCardResultsViewModel(
+        int Count,
+        List<SongCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
+}

ErsatzTV.Application/MediaCards/SongCardViewModel.cs

@@ -0,0 +1,22 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record SongCardViewModel
+    (
+        int SongId,
+        string Title,
+        string Subtitle,
+        string SortTitle,
+        string Poster,
+        MediaItemState State) : MediaCardViewModel(
+        SongId,
+        Title,
+        Subtitle,
+        SortTitle,
+        Poster,
+        State)
+    {
+        public int CustomIndex { get; set; }
+    }
+}

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.MediaCards
 {
@@ -17,10 +18,13 @@ namespace ErsatzTV.Application.MediaCards
         string Plot,
         string Poster,
         List<string> Directors,
-        List<string> Writers) : MediaCardViewModel(
+        List<string> Writers,
+        MediaItemState State,
+        string Path) : MediaCardViewModel(
         EpisodeId,
         Title,
         $"Episode {Episode}",
         SortTitle,
-        Poster);
+        Poster,
+        State);
 }

ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs

@@ -1,4 +1,6 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
     public record TelevisionSeasonCardViewModel
     (
@@ -9,10 +11,12 @@
         string Subtitle,
         string SortTitle,
         string Poster,
-        string Placeholder) : MediaCardViewModel(
+        string Placeholder,
+        MediaItemState State) : MediaCardViewModel(
         TelevisionSeasonId,
         Title,
         Subtitle,
         SortTitle,
-        Poster);
+        Poster,
+        State);
 }

ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs

@@ -1,10 +1,19 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
     public record TelevisionShowCardViewModel
-        (int TelevisionShowId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+    (
-            TelevisionShowId,
+        int TelevisionShowId,
-            Title,
+        string Title,
-            Subtitle,
+        string Subtitle,
-            SortTitle,
+        string SortTitle,
-            Poster);
+        string Poster,
+        MediaItemState State) : MediaCardViewModel(
+        TelevisionShowId,
+        Title,
+        Subtitle,
+        SortTitle,
+        Poster,
+        State);
 }

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs

@@ -13,5 +13,6 @@ namespace ErsatzTV.Application.MediaCollections.Commands
         List<int> EpisodeIds,
         List<int> ArtistIds,
         List<int> MusicVideoIds,
-        List<int> OtherVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
+        List<int> OtherVideoIds,
+        List<int> SongIds) : MediatR.IRequest<Either<BaseError, Unit>>;
 }

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs

@@ -57,6 +57,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                 .Append(request.ArtistIds)
                 .Append(request.MusicVideoIds)
                 .Append(request.OtherVideoIds)
+                .Append(request.SongIds)
                 .ToList();
 
             var toAddIds = allItems.Where(item => collection.MediaItems.All(mi => mi.Id != item)).ToList();

ErsatzTV.Application/MediaCollections/Commands/AddSongToCollection.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddSongToCollection
+        (int CollectionId, int SongId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}

ErsatzTV.Application/MediaCollections/Commands/AddSongToCollectionHandler.cs

@@ -0,0 +1,80 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class AddSongToCollectionHandler :
+        MediatR.IRequestHandler<AddSongToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public AddSongToCollectionHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _dbContextFactory = dbContextFactory;
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            AddSongToCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+            return await validation.Apply(parameters => ApplyAddSongRequest(dbContext, parameters));
+        }
+
+        private async Task<Unit> ApplyAddSongRequest(TvContext dbContext, Parameters parameters)
+        {
+            parameters.Collection.MediaItems.Add(parameters.Song);
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private static async Task<Validation<BaseError, Parameters>> Validate(
+            TvContext dbContext,
+            AddSongToCollection request) =>
+            (await CollectionMustExist(dbContext, request), await ValidateSong(dbContext, request))
+            .Apply((collection, episode) => new Parameters(collection, episode));
+
+        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+            TvContext dbContext,
+            AddSongToCollection request) =>
+            dbContext.Collections
+                .Include(c => c.MediaItems)
+                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+        private static Task<Validation<BaseError, Song>> ValidateSong(
+            TvContext dbContext,
+            AddSongToCollection request) =>
+            dbContext.Songs
+                .SelectOneAsync(m => m.Id, e => e.Id == request.SongId)
+                .Map(o => o.ToValidation<BaseError>("Song does not exist"));
+
+        private record Parameters(Collection Collection, Song Song);
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs

@@ -39,7 +39,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
         {
             try
             {
-                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+                await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
                 Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
                 return await validation.Match(

ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs

@@ -208,6 +208,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             var guids = item.Guids.Map(g => g.Guid).ToList();
             
             Option<int> maybeMovieByGuid = await dbContext.MovieMetadata
+                .AsNoTracking()
                 .Filter(mm => mm.Guids.Any(g => guids.Contains(g.Guid)))
                 .FirstOrDefaultAsync()
                 .Map(Optional)
@@ -220,6 +221,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             }
 
             Option<int> maybeMovieByTitleYear = await dbContext.MovieMetadata
+                .AsNoTracking()
                 .Filter(mm => mm.Title == item.Title && mm.Year == item.Year)
                 .FirstOrDefaultAsync()
                 .Map(Optional)
@@ -241,6 +243,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             var guids = item.Guids.Map(g => g.Guid).ToList();
 
             Option<int> maybeShowByGuid = await dbContext.ShowMetadata
+                .AsNoTracking()
                 .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
                 .FirstOrDefaultAsync()
                 .Map(Optional)
@@ -253,6 +256,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             }
 
             Option<int> maybeShowByTitleYear = await dbContext.ShowMetadata
+                .AsNoTracking()
                 .Filter(sm => sm.Title == item.Title && sm.Year == item.Year)
                 .FirstOrDefaultAsync()
                 .Map(Optional)
@@ -274,6 +278,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             var guids = item.Guids.Map(g => g.Guid).ToList();
 
             Option<int> maybeSeasonByGuid = await dbContext.SeasonMetadata
+                .AsNoTracking()
                 .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
                 .FirstOrDefaultAsync()
                 .Map(Optional)
@@ -286,6 +291,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             }
 
             Option<int> maybeSeasonByTitleYear = await dbContext.SeasonMetadata
+                .AsNoTracking()
                 .Filter(sm => sm.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
                 .Filter(sm => sm.Season.SeasonNumber == item.Season)
                 .FirstOrDefaultAsync()
@@ -308,6 +314,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             var guids = item.Guids.Map(g => g.Guid).ToList();
 
             Option<int> maybeEpisodeByGuid = await dbContext.EpisodeMetadata
+                .AsNoTracking()
                 .Filter(em => em.Guids.Any(g => guids.Contains(g.Guid)))
                 .FirstOrDefaultAsync()
                 .Map(Optional)
@@ -320,6 +327,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             }
 
             Option<int> maybeEpisodeByTitleYear = await dbContext.EpisodeMetadata
+                .AsNoTracking()
                 .Filter(sm => sm.Episode.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
                 .Filter(em => em.Episode.Season.SeasonNumber == item.Season)
                 .Filter(sm => sm.Episode.EpisodeMetadata.Any(e => e.EpisodeNumber == item.Episode))

ErsatzTV.Application/MediaCollections/Mapper.cs

@@ -7,7 +7,7 @@ namespace ErsatzTV.Application.MediaCollections
     internal static class Mapper
     {
         internal static MediaCollectionViewModel ProjectToViewModel(Collection collection) =>
-            new(collection.Id, collection.Name, collection.UseCustomPlaybackOrder);
+            new(collection.Id, collection.Name, collection.UseCustomPlaybackOrder, MediaItemState.Normal);
 
         internal static MultiCollectionViewModel ProjectToViewModel(MultiCollection multiCollection) =>
             new(

ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs

@@ -1,11 +1,17 @@
 using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.MediaCollections
 {
-    public record MediaCollectionViewModel(int Id, string Name, bool UseCustomPlaybackOrder) : MediaCardViewModel(
+    public record MediaCollectionViewModel(
+        int Id,
+        string Name,
+        bool UseCustomPlaybackOrder,
+        MediaItemState State) : MediaCardViewModel(
         Id,
         Name,
         string.Empty,
         Name,
-        string.Empty);
+        string.Empty,
+        State);
 }

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -27,6 +27,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
         private readonly IMovieFolderScanner _movieFolderScanner;
         private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
         private readonly IOtherVideoFolderScanner _otherVideoFolderScanner;
+        private readonly ISongFolderScanner _songFolderScanner;
         private readonly ITelevisionFolderScanner _televisionFolderScanner;
 
         public ScanLocalLibraryHandler(
@@ -36,6 +37,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
             ITelevisionFolderScanner televisionFolderScanner,
             IMusicVideoFolderScanner musicVideoFolderScanner,
             IOtherVideoFolderScanner otherVideoFolderScanner,
+            ISongFolderScanner songFolderScanner,
             IEntityLocker entityLocker,
             IMediator mediator,
             ILogger<ScanLocalLibraryHandler> logger)
@@ -46,6 +48,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
             _televisionFolderScanner = televisionFolderScanner;
             _musicVideoFolderScanner = musicVideoFolderScanner;
             _otherVideoFolderScanner = otherVideoFolderScanner;
+            _songFolderScanner = songFolderScanner;
             _entityLocker = entityLocker;
             _mediator = mediator;
             _logger = logger;
@@ -67,7 +70,8 @@ namespace ErsatzTV.Application.MediaSources.Commands
 
         private async Task<Unit> PerformScan(RequestParameters parameters)
         {
-            (LocalLibrary localLibrary, string ffprobePath, bool forceScan, int libraryRefreshInterval) = parameters;
+            (LocalLibrary localLibrary, string ffprobePath, string ffmpegPath, bool forceScan,
+                int libraryRefreshInterval) = parameters;
 
             var sw = new Stopwatch();
             sw.Start();
@@ -117,6 +121,14 @@ namespace ErsatzTV.Application.MediaSources.Commands
                                 progressMin,
                                 progressMax);
                             break;
+                        case LibraryMediaKind.Songs:
+                            await _songFolderScanner.ScanFolder(
+                                libraryPath,
+                                ffprobePath,
+                                ffmpegPath,
+                                progressMin,
+                                progressMax);
+                            break;
                     }
 
                     libraryPath.LastScan = DateTime.UtcNow;
@@ -148,14 +160,36 @@ namespace ErsatzTV.Application.MediaSources.Commands
             return Unit.Default;
         }
 
-        private async Task<Validation<BaseError, RequestParameters>> Validate(IScanLocalLibrary request) =>
+        private async Task<Validation<BaseError, RequestParameters>> Validate(IScanLocalLibrary request)
-            (await LocalLibraryMustExist(request), await ValidateFFprobePath(), await ValidateLibraryRefreshInterval())
+        {
-            .Apply(
+            Validation<BaseError, LocalLibrary> libraryResult = await LocalLibraryMustExist(request);
-                (library, ffprobePath, libraryRefreshInterval) => new RequestParameters(
+            Validation<BaseError, string> ffprobePathResult = await ValidateFFprobePath();
-                    library,
+            Validation<BaseError, string> ffmpegPathResult = await ValidateFFmpegPath();
-                    ffprobePath,
+            Validation<BaseError, int> refreshIntervalResult = await ValidateLibraryRefreshInterval();
-                    request.ForceScan,
+
-                    libraryRefreshInterval));
+            try
+            {
+                return (libraryResult, ffprobePathResult, ffmpegPathResult, refreshIntervalResult)
+                    .Apply(
+                        (library, ffprobePath, ffmpegPath, libraryRefreshInterval) => new RequestParameters(
+                            library,
+                            ffprobePath,
+                            ffmpegPath,
+                            request.ForceScan,
+                            libraryRefreshInterval));
+            }
+            finally
+            {
+                // ensure we unlock the library if any validation is unsuccessful
+                foreach (LocalLibrary library in libraryResult.SuccessToSeq())
+                {
+                    if (ffprobePathResult.IsFail || ffmpegPathResult.IsFail || refreshIntervalResult.IsFail)
+                    {
+                        _entityLocker.UnlockLibrary(library.Id);
+                    }
+                }
+            }
+        }
 
         private Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
             IScanLocalLibrary request) =>
@@ -170,6 +204,13 @@ namespace ErsatzTV.Application.MediaSources.Commands
                     ffprobePath =>
                         ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
 
+        private Task<Validation<BaseError, string>> ValidateFFmpegPath() =>
+            _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath)
+                .FilterT(File.Exists)
+                .Map(
+                    ffmpegPath =>
+                        ffmpegPath.ToValidation<BaseError>("FFmpeg path does not exist on the file system"));
+
         private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
             _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
                 .FilterT(lri => lri > 0)
@@ -178,6 +219,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
         private record RequestParameters(
             LocalLibrary LocalLibrary,
             string FFprobePath,
+            string FFmpegPath,
             bool ForceScan,
             int LibraryRefreshInterval);
     }

ErsatzTV.Application/Movies/Mapper.cs

@@ -4,6 +4,7 @@ using System.Globalization;
 using System.Linq;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Jellyfin;
 using Flurl;
 using LanguageExt;
@@ -34,7 +35,9 @@ namespace ErsatzTV.Application.Movies
                     .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin, maybeEmby))
                     .ToList(),
                 metadata.Directors.Map(d => d.Name).ToList(),
-                metadata.Writers.Map(w => w.Name).ToList())
+                metadata.Writers.Map(w => w.Name).ToList(),
+                movie.GetHeadVersion().MediaFiles.Head().Path,
+                movie.State)
             {
                 Poster = Artwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby),
                 FanArt = Artwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby)

ErsatzTV.Application/Movies/MovieViewModel.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Movies
 {
@@ -15,7 +16,9 @@ namespace ErsatzTV.Application.Movies
         List<CultureInfo> Languages,
         List<ActorCardViewModel> Actors,
         List<string> Directors,
-        List<string> Writers)
+        List<string> Writers,
+        string Path,
+        MediaItemState MediaItemState)
     {
         public string Poster { get; set; }
         public string FanArt { get; set; }

ErsatzTV.Application/Movies/Queries/GetMovieByIdHandler.cs

@@ -33,7 +33,7 @@ namespace ErsatzTV.Application.Movies.Queries
             GetMovieById request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());

ErsatzTV.Application/Playouts/Mapper.cs

@@ -48,6 +48,14 @@ namespace ErsatzTV.Application.Playouts
                         .Map(ovm => ovm.Title ?? string.Empty)
                         .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
                         .IfNone("[unknown video]");
+                case Song s:
+                    string songArtist = s.SongMetadata.HeadOrNone()
+                        .Map(sm => string.IsNullOrWhiteSpace(sm.Artist) ? string.Empty : $"{sm.Artist} - ")
+                        .IfNone(string.Empty);
+                    return s.SongMetadata.HeadOrNone()
+                        .Map(sm => $"{songArtist}{sm.Title ?? string.Empty}")
+                        .Map(t => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? t : $"{s} ({playoutItem.ChapterTitle})")
+                        .IfNone("[unknown song]");
                 default:
                     return string.Empty;
             }

ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs

@@ -24,7 +24,7 @@ namespace ErsatzTV.Application.Playouts.Queries
             GetFuturePlayoutItemsById request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
             DateTime now = DateTimeOffset.Now.UtcDateTime;
 
@@ -57,6 +57,10 @@ namespace ErsatzTV.Application.Playouts.Queries
                 .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
                 .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as Song).SongMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as Song).MediaVersions)
                 .Filter(i => i.PlayoutId == request.PlayoutId)
                 .Filter(i => i.Finish >= now)
                 .Filter(i => request.ShowFiller || i.FillerKind == FillerKind.None)

ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs

@@ -26,7 +26,8 @@ namespace ErsatzTV.Application.Search.Queries
                 await GetIds(SearchIndex.EpisodeType, request.Query),
                 await GetIds(SearchIndex.ArtistType, request.Query),
                 await GetIds(SearchIndex.MusicVideoType, request.Query),
-                await GetIds(SearchIndex.OtherVideoType, request.Query));
+                await GetIds(SearchIndex.OtherVideoType, request.Query),
+                await GetIds(SearchIndex.SongType, request.Query));
 
         private Task<List<int>> GetIds(string type, string query) =>
             _searchIndex.Search($"type:{type} AND ({query})", 0, 0)

ErsatzTV.Application/Search/Queries/QuerySearchIndexSongs.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.MediaCards;
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public record QuerySearchIndexSongs
+        (string Query, int PageNumber, int PageSize) : IRequest<SongCardResultsViewModel>;
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexSongsHandler.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class
+        QuerySearchIndexSongsHandler : IRequestHandler<QuerySearchIndexSongs,
+            SongCardResultsViewModel>
+    {
+        private readonly ISongRepository _songRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public QuerySearchIndexSongsHandler(ISearchIndex searchIndex, ISongRepository songRepository)
+        {
+            _searchIndex = searchIndex;
+            _songRepository = songRepository;
+        }
+
+        public async Task<SongCardResultsViewModel> Handle(
+            QuerySearchIndexSongs request,
+            CancellationToken cancellationToken)
+        {
+            SearchResult searchResult = await _searchIndex.Search(
+                request.Query,
+                (request.PageNumber - 1) * request.PageSize,
+                request.PageSize);
+
+            List<SongCardViewModel> items = await _songRepository
+                .GetSongsForCards(searchResult.Items.Map(i => i.Id).ToList())
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new SongCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+        }
+    }
+}

ErsatzTV.Application/Search/SearchResultAllItemsViewModel.cs

@@ -9,5 +9,6 @@ namespace ErsatzTV.Application.Search
         List<int> EpisodeIds,
         List<int> ArtistIds,
         List<int> MusicVideoIds,
-        List<int> OtherVideoIds);
+        List<int> OtherVideoIds,
+        List<int> SongIds);
 }

ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs

@@ -23,7 +23,7 @@ namespace ErsatzTV.Application.Streaming.Queries
 
         public async Task<Either<BaseError, PlayoutItemProcessModel>> Handle(T request, CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             Validation<BaseError, Tuple<Channel, string>> validation = await Validate(dbContext, request);
             return await validation.Match(
                 tuple => GetProcess(dbContext, request, tuple.Item1, tuple.Item2),
@@ -56,7 +56,8 @@ namespace ErsatzTV.Application.Streaming.Queries
                         {
                             "hls-direct" => StreamingMode.HttpLiveStreamingDirect,
                             "segmenter" => StreamingMode.HttpLiveStreamingSegmenter,
-                            "ts" => StreamingMode.TransportStream,
+                            "ts" => StreamingMode.TransportStreamHybrid,
+                            "ts-legacy" => StreamingMode.TransportStream,
                             _ => channel.StreamingMode
                         };
 

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs

@@ -6,7 +6,7 @@ namespace ErsatzTV.Application.Streaming.Queries
     {
         public GetConcatProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
             channelNumber,
-            "ts",
+            "ts-legacy",
             DateTimeOffset.Now,
             false,
             true)

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs

@@ -1,11 +1,9 @@
 using System;
 using System.Diagnostics;
-using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
-using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using LanguageExt;
@@ -15,17 +13,14 @@ namespace ErsatzTV.Application.Streaming.Queries
 {
     public class GetConcatProcessByChannelNumberHandler : FFmpegProcessHandler<GetConcatProcessByChannelNumber>
     {
-        private readonly FFmpegProcessService _ffmpegProcessService;
+        private readonly IFFmpegProcessService _ffmpegProcessService;
-        private readonly IRuntimeInfo _runtimeInfo;
 
         public GetConcatProcessByChannelNumberHandler(
             IDbContextFactory<TvContext> dbContextFactory,
-            FFmpegProcessService ffmpegProcessService,
+            IFFmpegProcessService ffmpegProcessService)
-            IRuntimeInfo runtimeInfo)
             : base(dbContextFactory)
         {
             _ffmpegProcessService = ffmpegProcessService;
-            _runtimeInfo = runtimeInfo;
         }
 
         protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
@@ -34,7 +29,7 @@ namespace ErsatzTV.Application.Streaming.Queries
             Channel channel,
             string ffmpegPath)
         {
-            bool saveReports = !_runtimeInfo.IsOSPlatform(OSPlatform.Windows) && await dbContext.ConfigElements
+            bool saveReports = await dbContext.ConfigElements
                 .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
                 .Map(result => result.IfNone(false));
 

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -2,19 +2,18 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Errors;
-using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Emby;
+using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -31,15 +30,15 @@ namespace ErsatzTV.Application.Streaming.Queries
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
         private readonly ITelevisionRepository _televisionRepository;
         private readonly IArtistRepository _artistRepository;
-        private readonly FFmpegProcessService _ffmpegProcessService;
+        private readonly IFFmpegProcessService _ffmpegProcessService;
         private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
         private readonly ILocalFileSystem _localFileSystem;
         private readonly IPlexPathReplacementService _plexPathReplacementService;
-        private readonly IRuntimeInfo _runtimeInfo;
+        private readonly ISongVideoGenerator _songVideoGenerator;
 
         public GetPlayoutItemProcessByChannelNumberHandler(
             IDbContextFactory<TvContext> dbContextFactory,
-            FFmpegProcessService ffmpegProcessService,
+            IFFmpegProcessService ffmpegProcessService,
             ILocalFileSystem localFileSystem,
             IPlexPathReplacementService plexPathReplacementService,
             IJellyfinPathReplacementService jellyfinPathReplacementService,
@@ -47,7 +46,7 @@ namespace ErsatzTV.Application.Streaming.Queries
             IMediaCollectionRepository mediaCollectionRepository,
             ITelevisionRepository televisionRepository,
             IArtistRepository artistRepository,
-            IRuntimeInfo runtimeInfo)
+            ISongVideoGenerator songVideoGenerator)
             : base(dbContextFactory)
         {
             _ffmpegProcessService = ffmpegProcessService;
@@ -58,7 +57,7 @@ namespace ErsatzTV.Application.Streaming.Queries
             _mediaCollectionRepository = mediaCollectionRepository;
             _televisionRepository = televisionRepository;
             _artistRepository = artistRepository;
-            _runtimeInfo = runtimeInfo;
+            _songVideoGenerator = songVideoGenerator;
         }
 
         protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
@@ -94,6 +93,15 @@ namespace ErsatzTV.Application.Streaming.Queries
                 .Include(i => i.MediaItem)
                 .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
                 .ThenInclude(ov => ov.Streams)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as Song).MediaVersions)
+                .ThenInclude(mv => mv.MediaFiles)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as Song).MediaVersions)
+                .ThenInclude(mv => mv.Streams)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as Song).SongMetadata)
+                .ThenInclude(sm => sm.Artwork)
                 .ForChannelAndTime(channel.Id, now)
                 .Map(o => o.ToEither<BaseError>(new UnableToLocatePlayoutItem()))
                 .BindT(ValidatePlayoutItemPath);
@@ -106,18 +114,13 @@ namespace ErsatzTV.Application.Streaming.Queries
             return await maybePlayoutItem.Match(
                 async playoutItemWithPath =>
                 {
-                    MediaVersion version = playoutItemWithPath.PlayoutItem.MediaItem switch
+                    MediaVersion version = playoutItemWithPath.PlayoutItem.MediaItem.GetHeadVersion();
-                    {
-                        Movie m => m.MediaVersions.Head(),
-                        Episode e => e.MediaVersions.Head(),
-                        MusicVideo mv => mv.MediaVersions.Head(),
-                        OtherVideo ov => ov.MediaVersions.Head(),
-                        _ => throw new ArgumentOutOfRangeException(nameof(playoutItemWithPath))
-                    };
 
-                    bool saveReports = !_runtimeInfo.IsOSPlatform(OSPlatform.Windows) && await dbContext.ConfigElements
+                    string videoPath = playoutItemWithPath.Path;
-                        .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+                    MediaVersion videoVersion = version;
-                        .Map(result => result.IfNone(false));
+
+                    string audioPath = playoutItemWithPath.Path;
+                    MediaVersion audioVersion = version;
 
                     Option<ChannelWatermark> maybeGlobalWatermark = await dbContext.ConfigElements
                         .GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId)
@@ -125,12 +128,27 @@ namespace ErsatzTV.Application.Streaming.Queries
                             watermarkId => dbContext.ChannelWatermarks
                                 .SelectOneAsync(w => w.Id, w => w.Id == watermarkId));
 
+                    if (playoutItemWithPath.PlayoutItem.MediaItem is Song song)
+                    {
+                        (videoPath, videoVersion) = await _songVideoGenerator.GenerateSongVideo(
+                            song,
+                            channel,
+                            maybeGlobalWatermark,
+                            ffmpegPath);
+                    }
+
+                    bool saveReports = await dbContext.ConfigElements
+                        .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+                        .Map(result => result.IfNone(false));
+
                     Process process = await _ffmpegProcessService.ForPlayoutItem(
                         ffmpegPath,
                         saveReports,
                         channel,
-                        version,
+                        videoVersion,
-                        playoutItemWithPath.Path,
+                        audioVersion,
+                        videoPath,
+                        audioPath,
                         playoutItemWithPath.PlayoutItem.StartOffset,
                         playoutItemWithPath.PlayoutItem.FinishOffset,
                         request.StartAtZero ? playoutItemWithPath.PlayoutItem.StartOffset : now,
@@ -170,7 +188,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                         case UnableToLocatePlayoutItem:
                             if (channel.FFmpegProfile.Transcode)
                             {
-                                Process errorProcess = _ffmpegProcessService.ForError(
+                                Process errorProcess = await _ffmpegProcessService.ForError(
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
@@ -189,7 +207,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                         case PlayoutItemDoesNotExistOnDisk:
                             if (channel.FFmpegProfile.Transcode)
                             {
-                                Process errorProcess = _ffmpegProcessService.ForError(
+                                Process errorProcess = await _ffmpegProcessService.ForError(
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
@@ -208,7 +226,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                         default:
                             if (channel.FFmpegProfile.Transcode)
                             {
-                                Process errorProcess = _ffmpegProcessService.ForError(
+                                Process errorProcess = await _ffmpegProcessService.ForError(
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
@@ -271,14 +289,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                             .MapT(pi => pi.StartOffset - now),
                         () => Option<TimeSpan>.None.AsTask());
 
-                MediaVersion version = item switch
+                MediaVersion version = item.GetHeadVersion();
-                {
-                    Movie m => m.MediaVersions.Head(),
-                    Episode e => e.MediaVersions.Head(),
-                    MusicVideo mv => mv.MediaVersions.Head(),
-                    OtherVideo ov => ov.MediaVersions.Head(),
-                    _ => throw new ArgumentOutOfRangeException(nameof(item))
-                };
 
                 version.MediaFiles = await dbContext.MediaFiles
                     .AsNoTracking()
@@ -331,14 +342,7 @@ namespace ErsatzTV.Application.Streaming.Queries
 
         private async Task<string> GetPlayoutItemPath(PlayoutItem playoutItem)
         {
-            MediaVersion version = playoutItem.MediaItem switch
+            MediaVersion version = playoutItem.MediaItem.GetHeadVersion();
-            {
-                Movie m => m.MediaVersions.Head(),
-                Episode e => e.MediaVersions.Head(),
-                MusicVideo mv => mv.MediaVersions.Head(),
-                OtherVideo ov => ov.MediaVersions.Head(),
-                _ => throw new ArgumentOutOfRangeException(nameof(playoutItem))
-            };
 
             MediaFile file = version.MediaFiles.Head();
             string path = file.Path;

ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumber.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace ErsatzTV.Application.Streaming.Queries
+{
+    public record GetWrappedProcessByChannelNumber : FFmpegProcessRequest
+    {
+        public GetWrappedProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
+            channelNumber,
+            "ts",
+            DateTimeOffset.Now,
+            false,
+            true)
+        {
+            Scheme = scheme;
+            Host = host;
+        }
+
+        public string Scheme { get; }
+        public string Host { get; }
+    }
+}

ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumberHandler.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Streaming.Queries
+{
+    public class GetWrappedProcessByChannelNumberHandler : FFmpegProcessHandler<GetWrappedProcessByChannelNumber>
+    {
+        private readonly IFFmpegProcessService _ffmpegProcessService;
+
+        public GetWrappedProcessByChannelNumberHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IFFmpegProcessService ffmpegProcessService)
+            : base(dbContextFactory)
+        {
+            _ffmpegProcessService = ffmpegProcessService;
+        }
+
+        protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
+            TvContext dbContext,
+            GetWrappedProcessByChannelNumber request,
+            Channel channel,
+            string ffmpegPath)
+        {
+            bool saveReports = await dbContext.ConfigElements
+                .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+                .Map(result => result.IfNone(false));
+
+            Process process = _ffmpegProcessService.WrapSegmenter(
+                ffmpegPath,
+                saveReports,
+                channel,
+                request.Scheme,
+                request.Host);
+
+            return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
+        }
+    }
+}

ErsatzTV.CommandLine/Commands/ChannelCommand.cs

@@ -1,106 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using CliFx;
-using CliFx.Attributes;
-using ErsatzTV.Api.Sdk.Api;
-using ErsatzTV.Api.Sdk.Model;
-using LanguageExt;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-
-namespace ErsatzTV.CommandLine.Commands
-{
-    [Command("channel", Description = "Create or rename a channel")]
-    public class ChannelCommand : ICommand
-    {
-        private readonly ChannelsApi _channelsApi;
-        private readonly FFmpegProfileApi _ffmpegProfileApi;
-        private readonly ILogger<ChannelCommand> _logger;
-
-        public ChannelCommand(IConfiguration configuration, ILogger<ChannelCommand> logger)
-        {
-            _logger = logger;
-            _channelsApi = new ChannelsApi(configuration["ServerUrl"]);
-            _ffmpegProfileApi = new FFmpegProfileApi(configuration["ServerUrl"]);
-        }
-
-        [CommandParameter(0, Name = "channel-number", Description = "The channel number")]
-        public int Number { get; set; }
-
-        [CommandParameter(1, Name = "channel-name", Description = "The channel name")]
-        public string Name { get; set; }
-
-        [CommandParameter(2, Name = "streaming-mode", Description = "The streaming mode")]
-        public StreamingMode StreamingMode { get; set; }
-
-        [CommandOption("ffmpeg-profile", Description = "The ffmpeg profile name")]
-        public string FFmpegProfileName { get; set; }
-
-        public async ValueTask ExecuteAsync(IConsole console)
-        {
-            try
-            {
-                Option<ChannelViewModel> maybeChannel = await _channelsApi.ApiChannelsGetAsync()
-                    .Map(list => Optional(list.SingleOrDefault(c => c.Number == Number)));
-
-                FFmpegProfileViewModel ffmpegProfile = await _ffmpegProfileApi.ApiFfmpegProfilesGetAsync()
-                    .Map(
-                        list => Optional(list.SingleOrDefault(p => p.Name == FFmpegProfileName))
-                            .IfNone(new FFmpegProfileViewModel { Id = 1 }));
-
-                await maybeChannel.Match(
-                    channel => RenameChannel(channel, ffmpegProfile),
-                    () => AddChannel(ffmpegProfile));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError("Unable to synchronize channel: {Message}", ex.Message);
-            }
-        }
-
-        private async ValueTask RenameChannel(ChannelViewModel existing, FFmpegProfileViewModel ffmpegProfile)
-        {
-            int newFFmpegProfileId = string.IsNullOrWhiteSpace(FFmpegProfileName)
-                ? existing.FfmpegProfileId
-                : ffmpegProfile.Id;
-
-            if (existing.Name != Name || existing.FfmpegProfileId != newFFmpegProfileId ||
-                existing.StreamingMode != StreamingMode)
-            {
-                var updateChannel = new UpdateChannel(
-                    existing.Id,
-                    Name,
-                    existing.Number,
-                    newFFmpegProfileId,
-                    existing.Logo,
-                    StreamingMode);
-
-                await _channelsApi.ApiChannelsPatchAsync(updateChannel);
-            }
-
-            _logger.LogInformation(
-                "Successfully synchronized channel {ChannelNumber} - {ChannelName}",
-                Number,
-                Name);
-        }
-
-        private async ValueTask AddChannel(FFmpegProfileViewModel ffmpegProfile)
-        {
-            var createChannel = new CreateChannel(
-                Name,
-                Number,
-                ffmpegProfile.Id,
-                null,
-                StreamingMode);
-
-            await _channelsApi.ApiChannelsPostAsync(createChannel);
-
-            _logger.LogInformation(
-                "Successfully created channel {ChannelNumber} - {ChannelName}",
-                Number,
-                Name);
-        }
-    }
-}

ErsatzTV.CommandLine/Commands/ConfigCommand.cs

@@ -1,31 +0,0 @@
-using System;
-using System.IO;
-using System.Text.Json;
-using System.Threading.Tasks;
-using CliFx;
-using CliFx.Attributes;
-
-namespace ErsatzTV.CommandLine.Commands
-{
-    [Command("config", Description = "Configure ErsatzTV server url")]
-    public class ConfigCommand : ICommand
-    {
-        [CommandParameter(0, Name = "server-url", Description = "The url of the ErsatzTV server")]
-        public string ServerUrl { get; set; }
-
-        public async ValueTask ExecuteAsync(IConsole console)
-        {
-            // TODO: validate URL
-
-            string configFolder = Path.Combine(
-                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
-                "ersatztv");
-
-            string configFile = Path.Combine(configFolder, "cli.json");
-
-            var config = new Config { ServerUrl = ServerUrl };
-            string contents = JsonSerializer.Serialize(config);
-            await File.WriteAllTextAsync(configFile, contents);
-        }
-    }
-}

ErsatzTV.CommandLine/Commands/FFmpegProfileCommand.cs

@@ -1,151 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using CliFx;
-using CliFx.Attributes;
-using ErsatzTV.Api.Sdk.Api;
-using ErsatzTV.Api.Sdk.Model;
-using LanguageExt;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-
-namespace ErsatzTV.CommandLine.Commands
-{
-    [Command("ffmpeg-profile", Description = "Synchronize an ffmpeg profile")]
-    public class FFmpegProfileCommand : ICommand
-    {
-        private readonly FFmpegProfileApi _ffmpegProfileApi;
-        private readonly ILogger<FFmpegProfileCommand> _logger;
-
-        public FFmpegProfileCommand(IConfiguration configuration, ILogger<FFmpegProfileCommand> logger)
-        {
-            _logger = logger;
-            _ffmpegProfileApi = new FFmpegProfileApi(configuration["ServerUrl"]);
-        }
-
-        [CommandParameter(0, Name = "profile-name", Description = "The ffmpeg profile name")]
-        public string Name { get; set; }
-
-        [CommandOption("thread-count", Description = "The number of threads")]
-        public int ThreadCount { get; set; } = 0;
-
-        [CommandOption("transcode", Description = "Whether to transcode all media")]
-        public bool Transcode { get; set; } = true;
-
-        // public int ResolutionId { get; set; } = resolution.Id;
-        // Resolution { get; set; } = resolution;
-        [CommandOption("resolution", Description = "The resolution")]
-        public DesiredResolution Resolution { get; set; } = DesiredResolution.W1920H1080;
-
-        [CommandOption("video-codec", Description = "The video codec")]
-        public string VideoCodec { get; set; } = "libx264";
-
-        [CommandOption("audio-codec", Description = "The audio codec")]
-        public string AudioCodec { get; set; } = "ac3";
-
-        [CommandOption("video-bitrate", Description = "The video bitrate in kBit/s")]
-        public int VideoBitrate { get; set; } = 2000;
-
-        [CommandOption("video-buffer-size", Description = "The video buffer size in kBit")]
-        public int VideoBufferSize { get; set; } = 2000;
-
-        [CommandOption("audio-bitrate", Description = "The audio bitrate in kBit/s")]
-        public int AudioBitrate { get; set; } = 192;
-
-        [CommandOption("audio-buffer-size", Description = "The audio buffer size in kBits")]
-        public int AudioBufferSize { get; set; } = 50;
-
-        [CommandOption("audio-volume", Description = "The audio volume as a whole number percent")]
-        public int AudioVolume { get; set; } = 100;
-
-        [CommandOption("audio-channels", Description = "The number of audio channels")]
-        public int AudioChannels { get; set; } = 2;
-
-        [CommandOption("audio-sample-rate", Description = "The audio sample rate in kHz")]
-        public int AudioSampleRate { get; set; } = 48;
-
-        [CommandOption("normalize-resolution", Description = "Whether to normalize the resolution of all media")]
-        public bool NormalizeResolution { get; set; } = true;
-
-        [CommandOption("normalize-video-codec", Description = "Whether to normalize the video codec of all media")]
-        public bool NormalizeVideoCodec { get; set; } = true;
-
-        [CommandOption("normalize-audio-codec", Description = "Whether to normalize the audio codec of all media")]
-        public bool NormalizeAudioCodec { get; set; } = true;
-
-        [CommandOption(
-            "normalize-audio",
-            Description = "Whether to normalize audio channels and sample rate of all media")]
-        public bool NormalizeAudio { get; set; } = true;
-
-        public async ValueTask ExecuteAsync(IConsole console)
-        {
-            try
-            {
-                Option<FFmpegProfileViewModel> maybeFFmpegProfile = await _ffmpegProfileApi.ApiFfmpegProfilesGetAsync()
-                    .Map(list => Optional(list.SingleOrDefault(p => p.Name == Name)));
-
-                await maybeFFmpegProfile.Match(UpdateProfile, AddProfile);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError("Unable to synchronize ffmpeg profile: {Message}", ex.Message);
-            }
-        }
-
-        private async ValueTask UpdateProfile(FFmpegProfileViewModel existing)
-        {
-            var updateFFmpegProfile = new UpdateFFmpegProfile(
-                existing.Id,
-                Name,
-                ThreadCount,
-                Transcode,
-                (int) Resolution,
-                NormalizeResolution,
-                VideoCodec,
-                NormalizeVideoCodec,
-                VideoBitrate,
-                VideoBufferSize,
-                AudioCodec,
-                NormalizeAudioCodec,
-                AudioBitrate,
-                AudioBufferSize,
-                AudioVolume,
-                AudioChannels,
-                AudioSampleRate,
-                NormalizeAudio);
-
-            await _ffmpegProfileApi.ApiFfmpegProfilesPatchAsync(updateFFmpegProfile);
-
-            _logger.LogInformation("Successfully synchronized ffmpeg profile {ProfileName}", Name);
-        }
-
-        private async ValueTask AddProfile()
-        {
-            var createFFmpegProfile = new CreateFFmpegProfile(
-                Name,
-                ThreadCount,
-                Transcode,
-                (int) Resolution,
-                NormalizeResolution,
-                VideoCodec,
-                NormalizeVideoCodec,
-                VideoBitrate,
-                VideoBufferSize,
-                AudioCodec,
-                NormalizeAudioCodec,
-                AudioBitrate,
-                AudioBufferSize,
-                AudioVolume,
-                AudioChannels,
-                AudioSampleRate,
-                NormalizeAudio);
-
-
-            await _ffmpegProfileApi.ApiFfmpegProfilesPostAsync(createFFmpegProfile);
-
-            _logger.LogInformation("Successfully created ffmpeg profile {ProfileName}", Name);
-        }
-    }
-}

ErsatzTV.CommandLine/Commands/MediaCollections/MediaCollectionClearCommand.cs

@@ -1,86 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using CliFx;
-using CliFx.Attributes;
-using ErsatzTV.Api.Sdk.Api;
-using ErsatzTV.Api.Sdk.Model;
-using LanguageExt;
-using LanguageExt.Common;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-
-namespace ErsatzTV.CommandLine.Commands.MediaCollections
-{
-    [Command("collection clear", Description = "Removes all items from a media collection")]
-    public class MediaCollectionClearCommand : ICommand
-    {
-        private readonly ILogger<MediaCollectionClearCommand> _logger;
-        private readonly string _serverUrl;
-
-        public MediaCollectionClearCommand(IConfiguration configuration, ILogger<MediaCollectionClearCommand> logger)
-        {
-            _logger = logger;
-            _serverUrl = configuration["ServerUrl"];
-        }
-
-        [CommandParameter(0, Name = "collection-name", Description = "The name of the media collection")]
-        public string Name { get; set; }
-
-        public async ValueTask ExecuteAsync(IConsole console)
-        {
-            try
-            {
-                CancellationToken cancellationToken = console.GetCancellationToken();
-
-                Either<Error, Unit> result = await ClearMediaCollection(cancellationToken);
-
-                result.Match(
-                    _ => _logger.LogInformation("Successfully cleared media collection {MediaCollection}", Name),
-                    error => _logger.LogError(
-                        "Unable to clear media collection: {Error}",
-                        error.Message));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError("Unable to clear media collection: {Error}", ex.Message);
-            }
-        }
-
-        private async Task<Either<Error, Unit>> ClearMediaCollection(CancellationToken cancellationToken) =>
-            await EnsureMediaCollectionExists(cancellationToken)
-                .BindAsync(mediaCollectionId => ClearMediaCollectionImpl(mediaCollectionId, cancellationToken));
-
-        private async Task<Either<Error, int>> EnsureMediaCollectionExists(CancellationToken cancellationToken)
-        {
-            var mediaCollectionsApi = new MediaCollectionsApi(_serverUrl);
-            Option<MediaCollectionViewModel> maybeExisting =
-                (await mediaCollectionsApi.ApiMediaCollectionsGetAsync(cancellationToken))
-                .SingleOrDefault(mc => mc.Name == Name);
-            return await maybeExisting.MatchAsync(
-                existing => existing.Id,
-                async () =>
-                {
-                    var data = new CreateSimpleMediaCollection(Name);
-                    MediaCollectionViewModel result =
-                        await mediaCollectionsApi.ApiMediaCollectionsPostAsync(data, cancellationToken);
-                    return result.Id;
-                });
-        }
-
-        private async Task<Either<Error, Unit>> ClearMediaCollectionImpl(
-            int mediaCollectionId,
-            CancellationToken cancellationToken)
-        {
-            var mediaCollectionsApi = new MediaCollectionsApi(_serverUrl);
-            await mediaCollectionsApi.ApiMediaCollectionsIdItemsPutAsync(
-                mediaCollectionId,
-                new List<int>(),
-                cancellationToken);
-            return unit;
-        }
-    }
-}

ErsatzTV.CommandLine/Commands/MediaCollections/MediaCollectionCreateCommand.cs

@@ -1,72 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using CliFx;
-using CliFx.Attributes;
-using ErsatzTV.Api.Sdk.Api;
-using ErsatzTV.Api.Sdk.Model;
-using LanguageExt;
-using LanguageExt.Common;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-
-namespace ErsatzTV.CommandLine.Commands.MediaCollections
-{
-    [Command("collection create", Description = "Creates a new media collection")]
-    public class MediaCollectionCreateCommand : ICommand
-    {
-        private readonly ILogger<MediaCollectionCreateCommand> _logger;
-        private readonly string _serverUrl;
-
-        public MediaCollectionCreateCommand(IConfiguration configuration, ILogger<MediaCollectionCreateCommand> logger)
-        {
-            _logger = logger;
-            _serverUrl = configuration["ServerUrl"];
-        }
-
-        [CommandParameter(0, Name = "collection-name", Description = "The name of the media collection")]
-        public string Name { get; set; }
-
-        public async ValueTask ExecuteAsync(IConsole console)
-        {
-            try
-            {
-                CancellationToken cancellationToken = console.GetCancellationToken();
-
-                Either<Error, Unit> result = await CreateMediaCollection(cancellationToken);
-                result.IfLeft(error => _logger.LogError("Unable to create media collection: {Error}", error.Message));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError("Unable to create media collection: {Error}", ex.Message);
-            }
-        }
-
-        private async Task<Either<Error, Unit>> CreateMediaCollection(CancellationToken cancellationToken) =>
-            await EnsureMediaCollectionExists(cancellationToken);
-
-        private async Task<Either<Error, Unit>> EnsureMediaCollectionExists(CancellationToken cancellationToken)
-        {
-            var mediaCollectionsApi = new MediaCollectionsApi(_serverUrl);
-
-            bool needToAdd = await mediaCollectionsApi
-                .ApiMediaCollectionsGetAsync(cancellationToken)
-                .Map(list => list.All(mc => mc.Name != Name));
-
-            if (needToAdd)
-            {
-                var data = new CreateSimpleMediaCollection(Name);
-                await mediaCollectionsApi.ApiMediaCollectionsPostAsync(data, cancellationToken);
-                _logger.LogInformation("Successfully created media collection {MediaCollection}", Name);
-            }
-            else
-            {
-                _logger.LogInformation("Media collection {MediaCollection} is already present", Name);
-            }
-
-            return unit;
-        }
-    }
-}

ErsatzTV.CommandLine/Commands/PlayoutCommand.cs

@@ -1,107 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using CliFx;
-using CliFx.Attributes;
-using ErsatzTV.Api.Sdk.Api;
-using ErsatzTV.Api.Sdk.Model;
-using LanguageExt;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
-
-namespace ErsatzTV.CommandLine.Commands
-{
-    [Command("playout build", Description = "Builds a playout with the requested channel and schedule")]
-    public class PlayoutCommand : ICommand
-    {
-        private readonly ILogger<PlayoutCommand> _logger;
-        private readonly string _serverUrl;
-
-        public PlayoutCommand(IConfiguration configuration, ILogger<PlayoutCommand> logger)
-        {
-            _logger = logger;
-            _serverUrl = configuration["ServerUrl"];
-        }
-
-        [CommandParameter(0, Name = "channel-number", Description = "The channel number")]
-        public int ChannelNumber { get; set; }
-
-        [CommandParameter(1, Name = "schedule-name", Description = "The schedule name")]
-        public string ScheduleName { get; set; }
-
-        // [Option("--type <type>")]
-        // [Required]
-        // public ProgramSchedulePlayoutType PlayoutType { get; set; }
-
-        public async ValueTask ExecuteAsync(IConsole console)
-        {
-            try
-            {
-                CancellationToken cancellationToken = console.GetCancellationToken();
-
-                var channelsApi = new ChannelsApi(_serverUrl);
-                Option<ChannelViewModel> maybeChannel = await channelsApi.ApiChannelsGetAsync(cancellationToken)
-                    .Map(list => list.SingleOrDefault(c => c.Number == ChannelNumber));
-
-                await maybeChannel.Match(
-                    channel => BuildPlayout(cancellationToken, channel),
-                    () =>
-                    {
-                        _logger.LogError("Unable to locate channel number {ChannelNumber}", ChannelNumber);
-                        return ValueTask.CompletedTask;
-                    });
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError("Unable to build playout: {Error}", ex.Message);
-            }
-        }
-
-        private async ValueTask BuildPlayout(CancellationToken cancellationToken, ChannelViewModel channel)
-        {
-            var programScheduleApi = new ProgramScheduleApi(_serverUrl);
-            Option<ProgramScheduleViewModel> maybeSchedule = await programScheduleApi
-                .ApiSchedulesGetAsync(cancellationToken)
-                .Map(list => list.SingleOrDefault(s => s.Name == ScheduleName));
-
-            await maybeSchedule.Match(
-                schedule => SynchronizePlayoutAsync(channel.Id, schedule.Id, cancellationToken),
-                () =>
-                {
-                    _logger.LogError("Unable to locate schedule {Schedule}", ScheduleName);
-                    return ValueTask.CompletedTask;
-                });
-        }
-
-        private async ValueTask SynchronizePlayoutAsync(
-            int channelId,
-            int scheduleId,
-            CancellationToken cancellationToken)
-        {
-            var playoutApi = new PlayoutApi(_serverUrl);
-            Option<PlayoutViewModel> maybeExisting = await playoutApi.ApiPlayoutsGetAsync(cancellationToken)
-                .Map(list => list.SingleOrDefault(p => p.Channel.Id == channelId));
-            await maybeExisting.Match(
-                existing =>
-                {
-                    var data = new UpdatePlayout(existing.Id, channelId, scheduleId, ProgramSchedulePlayoutType.Flood);
-                    if (existing.Channel.Id != data.ChannelId ||
-                        existing.ProgramSchedule.Id != data.ProgramScheduleId ||
-                        existing.ProgramSchedulePlayoutType != data.ProgramSchedulePlayoutType)
-                    {
-                        return playoutApi.ApiPlayoutsPatchAsync(data, cancellationToken);
-                    }
-
-                    return Task.CompletedTask;
-                },
-                () =>
-                {
-                    var data = new CreatePlayout(channelId, scheduleId, ProgramSchedulePlayoutType.Flood);
-                    return playoutApi.ApiPlayoutsPostAsync(data, cancellationToken);
-                });
-
-            _logger.LogInformation("Successfully built playout for schedule {Schedule}", ScheduleName);
-        }
-    }
-}

ErsatzTV.CommandLine/Commands/Schedules/ScheduleAddItemCommand.cs

@@ -1,140 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using CliFx;
-using CliFx.Attributes;
-using ErsatzTV.Api.Sdk.Api;
-using ErsatzTV.Api.Sdk.Model;
-using LanguageExt;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
-
-namespace ErsatzTV.CommandLine.Commands.Schedules
-{
-    [Command("schedule add-item", Description = "Adds an item to the end of a schedule")]
-    public class ScheduleAddItemCommand : ICommand
-    {
-        private readonly ILogger<ScheduleAddItemCommand> _logger;
-        private readonly string _serverUrl;
-
-        public ScheduleAddItemCommand(IConfiguration configuration, ILogger<ScheduleAddItemCommand> logger)
-        {
-            _logger = logger;
-            _serverUrl = configuration["ServerUrl"];
-        }
-
-        [CommandParameter(0, Name = "schedule-name", Description = "The schedule name")]
-        public string ScheduleName { get; set; }
-
-        [CommandParameter(1, Name = "collection-name", Description = "The media collection name")]
-        public string CollectionName { get; set; }
-
-        // [CommandParameter(2, Description = "The collection playback order")]
-        // public PlaybackOrder Order { get; set; }
-
-        [CommandOption("start-type", 's', Description = "The playout start type")]
-        public StartType StartType { get; set; } = StartType.Dynamic;
-
-        [CommandOption("start-time", 't', Description = "The playout start time (of day)")]
-        public string StartTime { get; set; } = null;
-
-        [CommandOption("playout-mode", 'm', Description = "The playout mode")]
-        public PlayoutMode PlayoutMode { get; set; } = PlayoutMode.Flood;
-
-        [CommandOption(
-            "multiple-count",
-            'c',
-            Description = "How many items to play from the collection (for Multiple playout mode)")]
-        public int? MultipleCount { get; set; } = null;
-
-        [CommandOption(
-            "playout-duration",
-            'd',
-            Description = "How long to play items from the collection (for Duration playout mode)")]
-        public string PlayoutDuration { get; set; } = null;
-
-        [CommandOption(
-            "offline-tail",
-            'o',
-            Description =
-                "Whether to remain offline for the entire duration, or to start the next item immediately (for Duration playout mode)")]
-        public bool? OfflineTail { get; set; } = null;
-
-        public async ValueTask ExecuteAsync(IConsole console)
-        {
-            try
-            {
-                CancellationToken cancellationToken = console.GetCancellationToken();
-
-                Option<ProgramScheduleViewModel> maybeSchedule = await GetSchedule(cancellationToken);
-                await maybeSchedule.Match(
-                    programSchedule => AddItemToSchedule(cancellationToken, programSchedule),
-                    () =>
-                    {
-                        _logger.LogError("Unable to locate schedule {Schedule}", ScheduleName);
-                        return ValueTask.CompletedTask;
-                    });
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError("Unable to add item to schedule: {Error}", ex.Message);
-            }
-        }
-
-        private async ValueTask AddItemToSchedule(
-            CancellationToken cancellationToken,
-            ProgramScheduleViewModel programSchedule)
-        {
-            var mediaCollectionsApi = new MediaCollectionsApi(_serverUrl);
-            Option<MediaCollectionViewModel> maybeMediaCollection = await mediaCollectionsApi
-                .ApiMediaCollectionsGetAsync(cancellationToken)
-                .Map(list => list.SingleOrDefault(mc => mc.Name == CollectionName));
-
-            await maybeMediaCollection.Match(
-                collection =>
-                    AddScheduleItem(programSchedule.Id, collection.Id, cancellationToken),
-                () =>
-                {
-                    _logger.LogError(
-                        "Unable to locate collection {Collection}",
-                        CollectionName);
-                    return Task.CompletedTask;
-                });
-        }
-
-        private async Task<Option<ProgramScheduleViewModel>> GetSchedule(CancellationToken cancellationToken)
-        {
-            var programScheduleApi = new ProgramScheduleApi(_serverUrl);
-            return await programScheduleApi.ApiSchedulesGetAsync(cancellationToken)
-                .Map(list => list.SingleOrDefault(schedule => schedule.Name == ScheduleName));
-        }
-
-        private async Task AddScheduleItem(
-            int programScheduleId,
-            int mediaCollectionId,
-            CancellationToken cancellationToken)
-        {
-            var programScheduleApi = new ProgramScheduleApi(_serverUrl);
-
-            var request = new AddProgramScheduleItem
-            {
-                ProgramScheduleId = programScheduleId,
-                StartType = StartType,
-                StartTime = StartTime,
-                PlayoutMode = PlayoutMode,
-                MediaCollectionId = mediaCollectionId,
-                PlayoutDuration = PlayoutDuration,
-                MultipleCount = MultipleCount,
-                OfflineTail = OfflineTail
-            };
-
-            await programScheduleApi.ApiSchedulesItemsAddPostAsync(request, cancellationToken);
-
-            _logger.LogInformation(
-                "Collection {Collection} has been added to schedule {Schedule}",
-                CollectionName,
-                ScheduleName);
-        }
-    }
-}

ErsatzTV.CommandLine/Commands/Schedules/ScheduleCreateCommand.cs

@@ -1,86 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using CliFx;
-using CliFx.Attributes;
-using ErsatzTV.Api.Sdk.Api;
-using ErsatzTV.Api.Sdk.Model;
-using LanguageExt;
-using LanguageExt.Common;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-
-namespace ErsatzTV.CommandLine.Commands.Schedules
-{
-    [Command("schedule create", Description = "Creates a new schedule")]
-    public class ScheduleCreateCommand : ICommand
-    {
-        private readonly ILogger<ScheduleCreateCommand> _logger;
-        private readonly string _serverUrl;
-
-        public ScheduleCreateCommand(IConfiguration configuration, ILogger<ScheduleCreateCommand> logger)
-        {
-            _logger = logger;
-            _serverUrl = configuration["ServerUrl"];
-        }
-
-        [CommandParameter(0, Name = "schedule-name", Description = "The schedule name")]
-        public string Name { get; set; }
-
-        [CommandParameter(1, Name = "playback-order", Description = "The collection playback order")]
-        public PlaybackOrder Order { get; set; }
-
-        [CommandOption("reset", Description = "Resets the schedule to contain no items")]
-        public bool Reset { get; set; }
-
-        public async ValueTask ExecuteAsync(IConsole console)
-        {
-            try
-            {
-                CancellationToken cancellationToken = console.GetCancellationToken();
-
-                Either<Error, Unit> result = await EnsureScheduleExistsAsync(cancellationToken);
-                result.IfLeft(error => _logger.LogError("Unable to create schedule: {Error}", error.Message));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError("Unable to create schedule: {Error}", ex.Message);
-            }
-        }
-
-        private async Task<Either<Error, Unit>> EnsureScheduleExistsAsync(CancellationToken cancellationToken)
-        {
-            var programScheduleApi = new ProgramScheduleApi(_serverUrl);
-
-            Option<ProgramScheduleViewModel> maybeExisting = await programScheduleApi
-                .ApiSchedulesGetAsync(cancellationToken)
-                .Map(list => list.SingleOrDefault(schedule => schedule.Name == Name));
-
-            await maybeExisting.Match(
-                existing =>
-                {
-                    // TODO: update playback order if changed?
-                    _logger.LogInformation("Schedule {Schedule} is already present", Name);
-
-                    if (Reset)
-                    {
-                        return programScheduleApi
-                            .ApiSchedulesProgramScheduleIdItemsDeleteAsync(existing.Id, cancellationToken)
-                            .Iter(_ => _logger.LogInformation("Successfully reset schedule {Schedule}", Name));
-                    }
-
-                    return Task.CompletedTask;
-                },
-                () =>
-                {
-                    var data = new CreateProgramSchedule(Name, Order);
-                    return programScheduleApi.ApiSchedulesPostAsync(data, cancellationToken)
-                        .Iter(_ => _logger.LogInformation("Successfully created schedule {Schedule}", Name));
-                });
-
-            return unit;
-        }
-    }
-}

ErsatzTV.CommandLine/Config.cs

@@ -1,7 +0,0 @@
-namespace ErsatzTV.CommandLine
-{
-    public class Config
-    {
-        public string ServerUrl { get; set; }
-    }
-}

ErsatzTV.CommandLine/DesiredResolution.cs

@@ -1,10 +0,0 @@
-namespace ErsatzTV.CommandLine
-{
-    public enum DesiredResolution
-    {
-        W720H480 = 1,
-        W1280H720 = 2,
-        W1920H1080 = 3,
-        W3840H2160 = 4
-    }
-}

ErsatzTV.CommandLine/ErsatzTV.CommandLine.csproj

@@ -1,35 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <OutputType>Exe</OutputType>
-        <TargetFramework>net5.0</TargetFramework>
-        <AssemblyName>ersatztv-cli</AssemblyName>
-        <LangVersion>9</LangVersion>
-        <PackageVersion>0.0.1</PackageVersion>
-        <AssemblyVersion>0.0.1</AssemblyVersion>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <PackageReference Include="CliFx" Version="1.6.0" />
-      <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
-      <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="5.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Hosting" Version="5.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Logging" Version="5.0.0" />
-      <PackageReference Include="RestSharp" Version="106.11.7" />
-      <PackageReference Include="Serilog" Version="2.10.0" />
-      <PackageReference Include="Serilog.Extensions.Hosting" Version="4.1.2" />
-      <PackageReference Include="Serilog.Extensions.Logging" Version="3.0.1" />
-      <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\generated\ErsatzTV.Api.Sdk\src\ErsatzTV.Api.Sdk\ErsatzTV.Api.Sdk.csproj" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <Reference Include="Microsoft.Extensions.Hosting.Abstractions, Version=5.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60">
-        <HintPath>..\..\..\..\..\..\usr\share\dotnet\packs\Microsoft.AspNetCore.App.Ref\5.0.0\ref\net5.0\Microsoft.Extensions.Hosting.Abstractions.dll</HintPath>
-      </Reference>
-    </ItemGroup>
-
-</Project>

ErsatzTV.CommandLine/Program.cs

@@ -1,75 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using CliFx;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Serilog;
-using Serilog.Events;
-
-namespace ErsatzTV.CommandLine
-{
-    public class Program
-    {
-        public static async Task<int> Main(string[] args)
-        {
-            Log.Logger = new LoggerConfiguration()
-                .MinimumLevel.Information()
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
-                .Enrich.FromLogContext()
-                .WriteTo.Console()
-                .CreateLogger();
-
-            IHost host = CreateHostBuilder(args).Build();
-            try
-            {
-                return await new CliApplicationBuilder()
-                    .AddCommandsFromThisAssembly()
-                    .UseTypeActivator(host.Services.GetService)
-                    .Build()
-                    .RunAsync(args);
-            }
-            catch (Exception ex)
-            {
-                Log.Fatal(ex, "Host terminated unexpectedly");
-                return 1;
-            }
-            finally
-            {
-                Log.CloseAndFlush();
-            }
-        }
-
-        public static IHostBuilder CreateHostBuilder(string[] args) =>
-            Host.CreateDefaultBuilder(args)
-                .ConfigureServices(
-                    (_, services) =>
-                    {
-                        services.AddSingleton<IConsole, SystemConsole>();
-                        IEnumerable<Type> typesThatImplementICommand = typeof(Program).Assembly.GetTypes()
-                            .Where(x => typeof(ICommand).IsAssignableFrom(x))
-                            .Where(x => !x.IsAbstract);
-                        foreach (Type t in typesThatImplementICommand)
-                        {
-                            services.AddTransient(t);
-                        }
-                    })
-                .ConfigureAppConfiguration(
-                    (_, configuration) =>
-                    {
-                        configuration.Sources.Clear();
-
-                        string configFolder = Path.Combine(
-                            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
-                            "ersatztv");
-
-                        configuration.SetBasePath(configFolder);
-                        configuration.AddJsonFile("cli.json", true, true);
-                    })
-                .UseSerilog()
-                .UseConsoleLifetime();
-    }
-}

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

@@ -1,24 +1,24 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net5.0</TargetFramework>
+        <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="FluentAssertions" Version="6.2.0" />
+      <PackageReference Include="FluentAssertions" Version="6.3.0" />
       <PackageReference Include="LanguageExt.Core" Version="4.0.3" />
-      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
+      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.63">
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.64">
         <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.2" />
-      <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+      <PackageReference Include="NUnit3TestAdapter" Version="4.2.0" />
       <PackageReference Include="Serilog" Version="2.10.0" />
-      <PackageReference Include="Serilog.Extensions.Logging" Version="3.0.1" />
+      <PackageReference Include="Serilog.Extensions.Logging" Version="3.1.0" />
       <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" />
     </ItemGroup>
 

ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs

@@ -19,7 +19,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 var builder = new FFmpegComplexFilterBuilder();
 
-                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
                 result.IsNone.Should().BeTrue();
             }
@@ -27,17 +27,38 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             [Test]
             public void Should_Return_Audio_Filter_With_AudioDuration()
             {
-                var duration = TimeSpan.FromMinutes(54);
+                var duration = TimeSpan.FromMilliseconds(1000.1);
                 FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
                     .WithAlignedAudio(duration);
 
-                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
                     filter =>
                     {
-                        filter.ComplexFilter.Should().Be($"[0:1]apad=whole_dur={duration.TotalMilliseconds}ms[a]");
+                        filter.ComplexFilter.Should().Be("[0:1]apad=whole_dur=1000.1ms[a]");
+                        filter.AudioLabel.Should().Be("[a]");
+                        filter.VideoLabel.Should().Be("0:0");
+                    });
+            }
+            
+            [Test]
+            // this needs to be a culture where '.' is a group separator
+            [SetCulture("it-IT")] 
+            public void Should_Return_Audio_Filter_With_AudioDuration_Decimal()
+            {
+                var duration = TimeSpan.FromMilliseconds(1000.1);
+                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                    .WithAlignedAudio(duration);
+
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+
+                result.IsSome.Should().BeTrue();
+                result.IfSome(
+                    filter =>
+                    {
+                        filter.ComplexFilter.Should().Be("[0:1]apad=whole_dur=1000.1ms[a]");
                         filter.AudioLabel.Should().Be("[a]");
                         filter.VideoLabel.Should().Be("0:0");
                     });
@@ -51,7 +72,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     .WithAlignedAudio(duration)
                     .WithDeinterlace(true);
 
-                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
@@ -102,7 +123,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
                 }
 
-                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
@@ -253,11 +274,12 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                                 HorizontalMarginPercent = 7,
                                 VerticalMarginPercent = 5
                             }),
-                        new Resolution { Width = 1920, Height = 1080 })
+                        new Resolution { Width = 1920, Height = 1080 },
+                        None)
                     .WithDeinterlace(deinterlace)
                     .WithAlignedAudio(alignAudio ? Some(TimeSpan.FromMinutes(55)) : None);
 
-                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
@@ -275,37 +297,37 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 true,
                 false,
                 true,
-                "[0:0]deinterlace_qsv,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 true,
                 true,
                 true,
-                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 false,
-                "[0:0]scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
+                "[0:0]scale_qsv=w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 true,
-                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 true,
-                "[0:0]scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]scale_qsv=w=1920:h=1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             public void Should_Return_QSV_Video_Filter(
                 bool deinterlace,
@@ -328,7 +350,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
                 }
 
-                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
@@ -346,37 +368,37 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]yadif_cuda,scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
+                "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 true,
                 false,
                 true,
-                "[0:0]yadif_cuda,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]yadif_cuda,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 true,
                 true,
                 true,
-                "[0:0]yadif_cuda,scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 false,
-                "[0:0]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
+                "[0:0]scale_cuda=1920:1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 true,
-                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 true,
-                "[0:0]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             public void Should_Return_NVENC_Video_Filter(
                 bool deinterlace,
@@ -387,7 +409,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
                     .WithHardwareAcceleration(HardwareAccelerationKind.Nvenc)
-                    .WithDeinterlace(deinterlace);
+                    .WithDeinterlace(deinterlace)
+                    .WithInputPixelFormat("h264");
 
                 if (scale)
                 {
@@ -399,7 +422,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
                 }
 
-                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(
@@ -418,42 +441,42 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 true,
                 false,
                 true,
-                "[0:0]deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 true,
                 true,
                 true,
-                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 true,
                 false,
-                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 false,
                 true,
-                "[0:0]hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 true,
                 true,
-                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase("mpeg4", true, false, false, "[0:0]hwupload,deinterlace_vaapi[v]", "[v]")]
             [TestCase(
@@ -461,28 +484,28 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 true,
                 false,
                 true,
-                "[0:0]hwupload,deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 true,
                 true,
                 true,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 false,
                 true,
                 false,
-                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
@@ -496,7 +519,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 true,
                 true,
-                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             public void Should_Return_VAAPI_Video_Filter(
                 string codec,
@@ -521,7 +544,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
                 }
 
-                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
                 result.IsSome.Should().BeTrue();
                 result.IfSome(

ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs

@@ -12,7 +12,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
         public void HlsPlaylistFilter_ShouldRewriteProgramDateTime()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = @"#EXTM3U
+            string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -26,13 +26,13 @@ live001137.ts
 live001138.ts
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
-live001139.ts".Split(Environment.NewLine);
+live001139.ts").Split(Environment.NewLine);
 
             TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input);
 
             result.PlaylistStart.Should().Be(start);
             result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(
+            result.Playlist.Should().Be(NormalizeLineEndings(
                 @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
@@ -49,14 +49,14 @@ live001138.ts
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
-");
+"));
         }
         
         [Test]
         public void HlsPlaylistFilter_ShouldLimitSegments()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = @"#EXTM3U
+            string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -70,13 +70,13 @@ live001137.ts
 live001138.ts
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
-live001139.ts".Split(Environment.NewLine);
+live001139.ts").Split(Environment.NewLine);
 
             TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input, 2);
 
             result.PlaylistStart.Should().Be(start);
             result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(
+            result.Playlist.Should().Be(NormalizeLineEndings(
                 @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
@@ -90,14 +90,14 @@ live001137.ts
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:04.000-0500
 live001138.ts
-");
+"));
         }
         
         [Test]
         public void HlsPlaylistFilter_ShouldAddDiscontinuity()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = @"#EXTM3U
+            string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -111,7 +111,7 @@ live001137.ts
 live001138.ts
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
-live001139.ts".Split(Environment.NewLine);
+live001139.ts").Split(Environment.NewLine);
 
             TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(
                 start,
@@ -122,7 +122,7 @@ live001139.ts".Split(Environment.NewLine);
 
             result.PlaylistStart.Should().Be(start);
             result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(
+            result.Playlist.Should().Be(NormalizeLineEndings(
                 @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
@@ -140,14 +140,14 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
 #EXT-X-DISCONTINUITY
-");
+"));
         }
 
         [Test]
         public void HlsPlaylistFilter_ShouldFilterOldSegments()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = @"#EXTM3U
+            string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -161,13 +161,13 @@ live001137.ts
 live001138.ts
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
-live001139.ts".Split(Environment.NewLine);
+live001139.ts").Split(Environment.NewLine);
 
             TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
 
             result.PlaylistStart.Should().Be(start.AddSeconds(8));
             result.Sequence.Should().Be(1139);
-            result.Playlist.Should().Be(
+            result.Playlist.Should().Be(NormalizeLineEndings(
                 @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
@@ -178,14 +178,14 @@ live001139.ts".Split(Environment.NewLine);
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
-");
+"));
         }
         
         [Test]
         public void HlsPlaylistFilter_ShouldFilterOldDiscontinuity()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = @"#EXTM3U
+            string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -200,13 +200,13 @@ live001137.ts
 live001138.ts
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
-live001139.ts".Split(Environment.NewLine);
+live001139.ts").Split(Environment.NewLine);
 
             TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
 
             result.PlaylistStart.Should().Be(start.AddSeconds(8));
             result.Sequence.Should().Be(1139);
-            result.Playlist.Should().Be(
+            result.Playlist.Should().Be(NormalizeLineEndings(
                 @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
@@ -217,7 +217,15 @@ live001139.ts".Split(Environment.NewLine);
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
-");
+"));
+        }
+
+        private static string NormalizeLineEndings(string str)
+        {
+            return str
+                .Replace("\r\n", "\n")
+                .Replace("\r", "\n")
+                .Replace("\n", Environment.NewLine);
         }
     }
 }

ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Security.Cryptography;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
@@ -93,6 +94,17 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 HardwareAccelerationKind.Vaapi
             };
+
+            public static string[] VideoToolboxCodecs =
+            {
+                "h264_videotoolbox",
+                "hevc_videotoolbox"
+            };
+
+            public static HardwareAccelerationKind[] VideoToolboxAcceleration =
+            {
+                HardwareAccelerationKind.VideoToolbox
+            };
         }
 
         [Test, Combinatorial]
@@ -103,21 +115,27 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             string inputPixelFormat,
             [ValueSource(typeof(TestData), nameof(TestData.Resolutions))]
             Resolution profileResolution,
+            [Values(true, false)]
+            bool pad,
             // [ValueSource(typeof(TestData), nameof(TestData.SoftwareCodecs))] string profileCodec,
             // [ValueSource(typeof(TestData), nameof(TestData.NoAcceleration))] HardwareAccelerationKind profileAcceleration)
-            [ValueSource(typeof(TestData), nameof(TestData.NvidiaCodecs))] string profileCodec,
+            // [ValueSource(typeof(TestData), nameof(TestData.NvidiaCodecs))] string profileCodec,
-            [ValueSource(typeof(TestData), nameof(TestData.NvidiaAcceleration))] HardwareAccelerationKind profileAcceleration)
+            // [ValueSource(typeof(TestData), nameof(TestData.NvidiaAcceleration))] HardwareAccelerationKind profileAcceleration)
             // [ValueSource(typeof(TestData), nameof(TestData.VaapiCodecs))] string profileCodec,
             // [ValueSource(typeof(TestData), nameof(TestData.VaapiAcceleration))] HardwareAccelerationKind profileAcceleration)
+            [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxCodecs))] string profileCodec,
+            [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxAcceleration))] HardwareAccelerationKind profileAcceleration)
         {
             string name = GetStringSha256Hash(
-                $"{inputCodec}_{inputPixelFormat}_{profileResolution}_{profileCodec}_{profileAcceleration}");
+                $"{inputCodec}_{inputPixelFormat}_{pad}_{profileResolution}_{profileCodec}_{profileAcceleration}");
 
             string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
             if (!File.Exists(file))
             {
+                string resolution = pad ? "1920x1060" : "1920x1080";
+                
                 var args =
-                    $"-y -f lavfi -i anullsrc=channel_layout=stereo:sample_rate=44100 -f lavfi -i testsrc=duration=1:size=1920x1080:rate=30 -c:a aac -c:v {inputCodec} -shortest -pix_fmt {inputPixelFormat} -strict -2 {file}";
+                    $"-y -f lavfi -i anullsrc=channel_layout=stereo:sample_rate=44100 -f lavfi -i testsrc=duration=1:size={resolution}:rate=30 -c:a aac -c:v {inputCodec} -shortest -pix_fmt {inputPixelFormat} -strict -2 {file}";
                 var p1 = new Process
                 {
                     StartInfo = new ProcessStartInfo
@@ -138,14 +156,15 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 new FFmpegPlaybackSettingsCalculator(),
                 new FakeStreamSelector(),
                 new Mock<IImageCache>().Object,
+                new Mock<ITempFilePool>().Object,
                 new Mock<ILogger<FFmpegProcessService>>().Object);
 
             MediaVersion v = new MediaVersion();
 
             var metadataRepository = new Mock<IMetadataRepository>();
             metadataRepository
-                .Setup(r => r.UpdateLocalStatistics(It.IsAny<int>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
+                .Setup(r => r.UpdateLocalStatistics(It.IsAny<MediaItem>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
-                .Callback<int, MediaVersion, bool>((_, version, _) => v = version);
+                .Callback<MediaItem, MediaVersion, bool>((_, version, _) => v = version);
 
             var localStatisticsProvider = new LocalStatisticsProvider(
                 metadataRepository.Object,
@@ -183,6 +202,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     StreamingMode = StreamingMode.TransportStream
                 },
                 v,
+                v,
+                file,
                 file,
                 now,
                 now + TimeSpan.FromSeconds(5),
@@ -196,6 +217,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 TimeSpan.FromSeconds(5));
 
             process.StartInfo.RedirectStandardError = true;
+            
+            // Console.WriteLine($"ffmpeg arguments {string.Join(" ", process.StartInfo.ArgumentList)}");
 
             process.Start().Should().BeTrue();
 
@@ -237,7 +260,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 return string.Empty;
             }
 
-            using var sha = new System.Security.Cryptography.SHA256Managed();
+            using var sha = SHA256.Create();
             byte[] textData = System.Text.Encoding.UTF8.GetBytes(text);
             byte[] hash = sha.ComputeHash(textData);
             return BitConverter.ToString(hash).Replace("-", string.Empty);

ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs

@@ -44,7 +44,7 @@ namespace ErsatzTV.Core.Tests.Fakes
                 .IfNone(SystemTime.MinValueUtc);
 
         public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
-            _files.Any(f => f.Path.StartsWith(libraryPath.Path + Path.DirectorySeparatorChar));
+            _folders.Any(f => f.Path == libraryPath.Path);
 
         public IEnumerable<string> ListSubdirectories(string folder) =>
             _folders.Map(f => f.Path).Filter(f => f.StartsWith(folder) && Directory.GetParent(f)?.FullName == folder);
@@ -53,6 +53,7 @@ namespace ErsatzTV.Core.Tests.Fakes
             _files.Map(f => f.Path).Filter(f => Path.GetDirectoryName(f) == folder);
 
         public bool FileExists(string path) => _files.Any(f => f.Path == path);
+        public bool FolderExists(string folder) => false;
 
         public Task<byte[]> ReadAllBytes(string path) => TestBytes.AsTask();
 

ErsatzTV.Core.Tests/Jellyfin/JellyfinPathReplacementServiceTests.cs

@@ -0,0 +1,211 @@
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Runtime;
+using ErsatzTV.Core.Jellyfin;
+using FluentAssertions;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Jellyfin
+{
+    [TestFixture]
+    public class JellyfinPathReplacementServiceTests
+    {
+        [Test]
+        public async Task JellyfinWindows_To_EtvWindows()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"C:\Something\Some Shared Folder",
+                    LocalPath = @"C:\Something Else\Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinWindows_To_EtvLinux()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"C:\Something\Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinWindows_To_EtvLinux_UncPath()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinWindows_To_EtvLinux_UncPathWithTrailingSlash()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder\",
+                    LocalPath = @"/mnt/something else/Some Shared Folder/",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinLinux_To_EtvWindows()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"/mnt/something/Some Shared Folder",
+                    LocalPath = @"C:\Something Else\Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinLinux_To_EtvLinux()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"/mnt/something/Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+    }
+}

ErsatzTV.Core.Tests/Metadata/LocalStatisticsProviderTests.cs

@@ -25,7 +25,7 @@ namespace ErsatzTV.Core.Tests.Metadata
                 new Mock<ILogger<LocalStatisticsProvider>>().Object);
 
             var input = new LocalStatisticsProvider.FFprobe(
-                new LocalStatisticsProvider.FFprobeFormat("123.45"),
+                new LocalStatisticsProvider.FFprobeFormat("123.45", null),
                 new List<LocalStatisticsProvider.FFprobeStream>(),
                 new List<LocalStatisticsProvider.FFprobeChapter>());
 

ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs

@@ -6,6 +6,7 @@ using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
@@ -52,6 +53,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
                     .Returns(new List<string>().AsEnumerable().AsTask());
 
+                _mediaItemRepository = new Mock<IMediaItemRepository>();
+                _mediaItemRepository.Setup(x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()))
+                    .Returns(new List<int>().AsTask());
+
                 _localStatisticsProvider = new Mock<ILocalStatisticsProvider>();
                 _localMetadataProvider = new Mock<ILocalMetadataProvider>();
 
@@ -71,6 +76,7 @@ namespace ErsatzTV.Core.Tests.Metadata
             }
 
             private Mock<IMovieRepository> _movieRepository;
+            private Mock<IMediaItemRepository> _mediaItemRepository;
             private Mock<ILocalStatisticsProvider> _localStatisticsProvider;
             private Mock<ILocalMetadataProvider> _localMetadataProvider;
             private Mock<IImageCache> _imageCache;
@@ -533,6 +539,9 @@ namespace ErsatzTV.Core.Tests.Metadata
             [Test]
             public async Task RenamedMovie_Should_Delete_Old_Movie()
             {
+                // TODO: handle this case more elegantly
+                // ideally, detect that the movie was renamed and still delete the old one (or update the path?)
+
                 string movieFolder = Path.Combine(FakeRoot, "Movie (2020)");
                 string oldMoviePath = Path.Combine(movieFolder, "Movie (2020).avi");
 
@@ -555,12 +564,14 @@ namespace ErsatzTV.Core.Tests.Metadata
 
                 result.IsRight.Should().BeTrue();
 
-                _movieRepository.Verify(x => x.DeleteByPath(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+                _mediaItemRepository.Verify(
-                _movieRepository.Verify(x => x.DeleteByPath(libraryPath, oldMoviePath), Times.Once);
+                    x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()),
+                    Times.Once);
+                _mediaItemRepository.Verify(x => x.FlagFileNotFound(libraryPath, oldMoviePath), Times.Once);
             }
 
             [Test]
-            public async Task DeletedMovieAndFolder_Should_Delete_Old_Movie()
+            public async Task DeletedMovieAndFolder_Should_Flag_File_Not_Found()
             {
                 string movieFolder = Path.Combine(FakeRoot, "Movie (2020)");
                 string oldMoviePath = Path.Combine(movieFolder, "Movie (2020).avi");
@@ -568,10 +579,8 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
                     .Returns(new List<string> { oldMoviePath }.AsEnumerable().AsTask());
 
-                string moviePath = Path.Combine(movieFolder, "Movie (2020).mkv");
-
                 MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
+                    new FakeFolderEntry(FakeRoot)
                 );
                 var libraryPath = new LibraryPath
                     { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
@@ -584,11 +593,12 @@ namespace ErsatzTV.Core.Tests.Metadata
 
                 result.IsRight.Should().BeTrue();
 
-                _movieRepository.Verify(x => x.DeleteByPath(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+                _mediaItemRepository.Verify(
-                _movieRepository.Verify(x => x.DeleteByPath(libraryPath, oldMoviePath), Times.Once);
+                    x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()),
+                    Times.Once);
+                _mediaItemRepository.Verify(x => x.FlagFileNotFound(libraryPath, oldMoviePath), Times.Once);
             }
 
-
             private MovieFolderScanner GetService(params FakeFileEntry[] files) =>
                 new(
                     new FakeLocalFileSystem(new List<FakeFileEntry>(files)),
@@ -600,7 +610,28 @@ namespace ErsatzTV.Core.Tests.Metadata
                     new Mock<ISearchIndex>().Object,
                     new Mock<ISearchRepository>().Object,
                     new Mock<ILibraryRepository>().Object,
+                    _mediaItemRepository.Object,
                     new Mock<IMediator>().Object,
+                    null,
+                    new Mock<ITempFilePool>().Object,
+                    new Mock<ILogger<MovieFolderScanner>>().Object
+                );
+            
+            private MovieFolderScanner GetService(params FakeFolderEntry[] folders) =>
+                new(
+                    new FakeLocalFileSystem(new List<FakeFileEntry>(), new List<FakeFolderEntry>(folders)),
+                    _movieRepository.Object,
+                    _localStatisticsProvider.Object,
+                    _localMetadataProvider.Object,
+                    new Mock<IMetadataRepository>().Object,
+                    _imageCache.Object,
+                    new Mock<ISearchIndex>().Object,
+                    new Mock<ISearchRepository>().Object,
+                    new Mock<ILibraryRepository>().Object,
+                    _mediaItemRepository.Object,
+                    new Mock<IMediator>().Object,
+                    null,
+                    new Mock<ITempFilePool>().Object,
                     new Mock<ILogger<MovieFolderScanner>>().Object
                 );
         }

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerDurationTests.cs

@@ -76,6 +76,72 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
         }
         
+        [Test]
+        public void Should_Fill_Exact_Duration_CustomTitle()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+            var scheduleItem = new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.None,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                CustomTitle = "Custom Title"
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+            
+            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(2);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+            playoutItems[0].CustomTitle.Should().Be("Custom Title");
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].GuideGroup.Should().Be(1);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+            playoutItems[1].CustomTitle.Should().Be("Custom Title");
+
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].GuideGroup.Should().Be(1);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
+            playoutItems[2].CustomTitle.Should().Be("Custom Title");
+        }
+        
         [Test]
         public void Should_Not_Have_Gap_Duration_Tail_Mode_None()
         {

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerFloodTests.cs

@@ -73,6 +73,75 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].GuideGroup.Should().Be(3);
+            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        }
+        
+                [Test]
+        public void Should_Fill_Exactly_To_Next_Schedule_Item_Flood()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+            var scheduleItem = new ProgramScheduleItemFlood
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = null
+            };
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var sortedScheduleItems = new List<ProgramScheduleItem>
+            {
+                scheduleItem,
+                // this caused trouble with the peek logic and the IsFlood flag
+                new ProgramScheduleItemFlood
+                {
+                    StartTime = TimeSpan.FromHours(3),
+                }
+            };
+
+            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+                StartState,
+                CollectionEnumerators(scheduleItem, enumerator),
+                scheduleItem,
+                NextScheduleItem,
+                HardStop);
+
+            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+            playoutBuilderState.NextGuideGroup.Should().Be(4);
+            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+            playoutBuilderState.InFlood.Should().BeFalse();
+            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+            playoutBuilderState.InDurationFiller.Should().BeFalse();
+            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+
+            enumerator.State.Index.Should().Be(1);
+
+            playoutItems.Count.Should().Be(3);
+
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].GuideGroup.Should().Be(1);
+            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+            playoutItems[1].MediaItemId.Should().Be(2);
+            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].GuideGroup.Should().Be(2);
+            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
             playoutItems[2].MediaItemId.Should().Be(1);
             playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
             playoutItems[2].GuideGroup.Should().Be(3);
@@ -709,7 +778,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
 
         protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
         {
-            StartTime = TimeSpan.FromHours(3)
+            StartTime = TimeSpan.FromHours(3),
         };
     }
 }

ErsatzTV.Core.Tests/Scheduling/ShuffledMediaCollectionEnumeratorTests.cs

@@ -0,0 +1,90 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
+using FluentAssertions;
+using LanguageExt;
+using LanguageExt.UnsafeValueAccess;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Scheduling
+{
+    [TestFixture]
+    public class ShuffledMediaCollectionEnumeratorTests
+    {
+        private readonly List<GroupedMediaItem> _mediaItems = new()
+        {
+            new GroupedMediaItem(new MediaItem { Id = 1 }, new List<MediaItem>()),
+            new GroupedMediaItem(new MediaItem { Id = 2 }, new List<MediaItem>()),
+            new GroupedMediaItem(new MediaItem { Id = 3 }, new List<MediaItem>())
+        };
+        
+        [Test]
+        public void Peek_Zero_Should_Match_Current()
+        {
+            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+            Option<MediaItem> peek = enumerator.Peek(0);
+            Option<MediaItem> current = enumerator.Current;
+
+            peek.IsSome.Should().BeTrue();
+            current.IsSome.Should().BeTrue();
+            peek.ValueUnsafe().Id.Should().Be(1);
+            current.ValueUnsafe().Id.Should().Be(1);
+        }
+        
+        [Test]
+        public void Peek_One_Should_Match_Next()
+        {
+            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+            Option<MediaItem> peek = enumerator.Peek(1);
+
+            enumerator.MoveNext();
+            Option<MediaItem> next = enumerator.Current;
+
+            peek.IsSome.Should().BeTrue();
+            next.IsSome.Should().BeTrue();
+            peek.ValueUnsafe().Id.Should().Be(2);
+            next.ValueUnsafe().Id.Should().Be(2);
+        }
+        
+        [Test]
+        public void Peek_Two_Should_Match_NextNext()
+        {
+            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+            Option<MediaItem> peek = enumerator.Peek(2);
+
+            enumerator.MoveNext();
+            enumerator.MoveNext();
+            Option<MediaItem> next = enumerator.Current;
+
+            peek.IsSome.Should().BeTrue();
+            next.IsSome.Should().BeTrue();
+            peek.ValueUnsafe().Id.Should().Be(3);
+            next.ValueUnsafe().Id.Should().Be(3);
+        }
+        
+        [Test]
+        public void Peek_Three_Should_Match_NextNextNext()
+        {
+            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+            Option<MediaItem> peek = enumerator.Peek(3);
+
+            enumerator.MoveNext();
+            enumerator.MoveNext();
+            enumerator.MoveNext();
+            Option<MediaItem> next = enumerator.Current;
+
+            peek.IsSome.Should().BeTrue();
+            next.IsSome.Should().BeTrue();
+            peek.ValueUnsafe().Id.Should().Be(2);
+            next.ValueUnsafe().Id.Should().Be(2);
+        }
+    }
+}

ErsatzTV.Core/Domain/HardwareAccelerationKind.cs

@@ -5,6 +5,7 @@
         None = 0,
         Qsv = 1,
         Nvenc = 2,
-        Vaapi = 3
+        Vaapi = 3,
+        VideoToolbox = 4
     }
 }

ErsatzTV.Core/Domain/Library/LibraryMediaKind.cs

@@ -5,6 +5,7 @@
         Movies = 1,
         Shows = 2,
         MusicVideos = 3,
-        OtherVideos = 4
+        OtherVideos = 4,
+        Songs = 5
     }
 }

ErsatzTV.Core/Domain/MediaItem/BackgroundImageMediaVersion.cs

@@ -0,0 +1,6 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class BackgroundImageMediaVersion : MediaVersion
+    {
+    }
+}

ErsatzTV.Core/Domain/MediaItem/CoverArtMediaVersion.cs

@@ -0,0 +1,6 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class CoverArtMediaVersion : MediaVersion
+    {
+    }
+}

ErsatzTV.Core/Domain/MediaItem/FallbackMediaVersion.cs

@@ -0,0 +1,6 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class FallbackMediaVersion : MediaVersion
+    {
+    }
+}

ErsatzTV.Core/Domain/MediaItem/MediaItem.cs

@@ -1,14 +1,14 @@
 using System.Collections.Generic;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class MediaItem
 {
-    public class MediaItem
+    public int Id { get; set; }
-    {
+    public int LibraryPathId { get; set; }
-        public int Id { get; set; }
+    public LibraryPath LibraryPath { get; set; }
-        public int LibraryPathId { get; set; }
+    public List<Collection> Collections { get; set; }
-        public LibraryPath LibraryPath { get; set; }
+    public List<CollectionItem> CollectionItems { get; set; }
-        public List<Collection> Collections { get; set; }
+    public List<TraktListItem> TraktListItems { get; set; }
-        public List<CollectionItem> CollectionItems { get; set; }
+    public MediaItemState State { get; set; }
-        public List<TraktListItem> TraktListItems { get; set; }
+}
-    }
-}

ErsatzTV.Core/Domain/MediaItem/MediaItemState.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Core.Domain;
+
+public enum MediaItemState
+{
+    Normal = 0,
+    FileNotFound = 1
+}

ErsatzTV.Core/Domain/MediaItem/MediaStream.cs

@@ -12,6 +12,7 @@
         public string Title { get; set; }
         public bool Default { get; set; }
         public bool Forced { get; set; }
+        public bool AttachedPic { get; set; }
         public string PixelFormat { get; set; }
         public int BitsPerRawSample { get; set; }
         public int MediaVersionId { get; set; }

ErsatzTV.Core/Domain/MediaItem/Song.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class Song : MediaItem
+    {
+        public List<SongMetadata> SongMetadata { get; set; }
+        public List<MediaVersion> MediaVersions { get; set; }
+    }
+}

ErsatzTV.Core/Domain/Metadata/Artwork.cs

@@ -6,6 +6,10 @@ namespace ErsatzTV.Core.Domain
     {
         public int Id { get; set; }
         public string Path { get; set; }
+        public string SourcePath { get; set; }
+        public string BlurHash43 { get; set; }
+        public string BlurHash54 { get; set; }
+        public string BlurHash64 { get; set; }
         public ArtworkKind ArtworkKind { get; set; }
         public DateTime DateAdded { get; set; }
         public DateTime DateUpdated { get; set; }

ErsatzTV.Core/Domain/Metadata/MetadataKind.cs

@@ -4,6 +4,7 @@
     {
         Fallback = 0,
         Sidecar = 1,
-        External = 2
+        External = 2,
+        Embedded = 3
     }
 }

ErsatzTV.Core/Domain/Metadata/SongMetadata.cs

@@ -0,0 +1,12 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class SongMetadata : Metadata
+    {
+        public string Album { get; set; }
+        public string Artist { get; set; }
+        public string Date { get; set; }
+        public string Track { get; set; }
+        public int SongId { get; set; }
+        public Song Song { get; set; }
+    }
+}

ErsatzTV.Core/Domain/StreamingMode.cs

@@ -4,7 +4,8 @@
     {
         TransportStream = 1,
         HttpLiveStreamingDirect = 2,
-        HttpLiveStreamingHybrid = 3,
+//        HttpLiveStreamingHybrid = 3,
-        HttpLiveStreamingSegmenter = 4
+        HttpLiveStreamingSegmenter = 4,
+        TransportStreamHybrid = 5
     }
 }

ErsatzTV.Core/ErsatzTV.Core.csproj

@@ -1,24 +1,23 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net5.0</TargetFramework>
+        <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
-        <DebugType>embedded</DebugType>
     </PropertyGroup>
 
     <ItemGroup>
       <PackageReference Include="Flurl" Version="3.0.2" />
       <PackageReference Include="LanguageExt.Core" Version="4.0.3" />
       <PackageReference Include="MediatR" Version="9.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Http" Version="5.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Http" Version="6.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="5.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.63">
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.64">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
       <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
       <PackageReference Include="Serilog" Version="2.10.0" />
-      <PackageReference Include="Serilog.Sinks.Console" Version="4.0.0" />
+      <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
     </ItemGroup>
     
     <ItemGroup>

ErsatzTV.Core/Extensions/MediaItemExtensions.cs

@@ -0,0 +1,19 @@
+using System;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Core.Extensions
+{
+    public static class MediaItemExtensions
+    {
+        public static MediaVersion GetHeadVersion(this MediaItem mediaItem) =>
+            mediaItem switch
+            {
+                Movie m => m.MediaVersions.Head(),
+                Episode e => e.MediaVersions.Head(),
+                MusicVideo mv => mv.MediaVersions.Head(),
+                OtherVideo ov => ov.MediaVersions.Head(),
+                Song s => s.MediaVersions.Head(),
+                _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
+            };
+    }
+}

ErsatzTV.Core/FFmpeg/FFmpegComplexFilterBuilder.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
@@ -20,8 +22,11 @@ namespace ErsatzTV.Core.FFmpeg
         private IDisplaySize _resolution;
         private Option<IDisplaySize> _scaleToSize = None;
         private Option<ChannelWatermark> _watermark;
+        private Option<int> _watermarkIndex;
         private string _pixelFormat;
         private string _videoEncoder;
+        private Option<string> _subtitle;
+        private bool _boxBlur;
 
         public FFmpegComplexFilterBuilder WithHardwareAcceleration(HardwareAccelerationKind hardwareAccelerationKind)
         {
@@ -59,22 +64,64 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public FFmpegComplexFilterBuilder WithInputCodec(string codec)
+        public FFmpegComplexFilterBuilder WithInputCodec(Option<string> maybeCodec)
         {
-            _inputCodec = codec;
+            foreach (string codec in maybeCodec)
+            {
+                _inputCodec = codec;
+            }
+
             return this;
         }
 
-        public FFmpegComplexFilterBuilder WithInputPixelFormat(string pixelFormat)
+        public FFmpegComplexFilterBuilder WithInputPixelFormat(Option<string> maybePixelFormat)
         {
-            _pixelFormat = pixelFormat;
+            foreach (string pixelFormat in maybePixelFormat)
+            {
+                _pixelFormat = pixelFormat;
+            }
+
             return this;
         }
 
-        public FFmpegComplexFilterBuilder WithWatermark(Option<ChannelWatermark> watermark, IDisplaySize resolution)
+        public FFmpegComplexFilterBuilder WithWatermark(
+            Option<ChannelWatermark> watermark,
+            IDisplaySize resolution,
+            Option<int> watermarkIndex)
         {
             _watermark = watermark;
             _resolution = resolution;
+            _watermarkIndex = watermarkIndex;
+            return this;
+        }
+
+        public FFmpegComplexFilterBuilder WithBoxBlur(bool boxBlur)
+        {
+            _boxBlur = boxBlur;
+            return this;
+        }
+
+        public FFmpegComplexFilterBuilder WithSubtitleFile(Option<string> subtitleFile)
+        {
+            foreach (string file in subtitleFile)
+            {
+                string effectiveFile = file;
+                string fontsDir = FileSystemLayout.ResourcesCacheFolder;
+                
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    fontsDir = fontsDir
+                        .Replace(@"\", @"/\")
+                        .Replace(@":/", @"\\:/");
+                    
+                    effectiveFile = effectiveFile
+                        .Replace(@"\", @"/\")
+                        .Replace(@":/", @"\\:/");
+                }
+
+                _subtitle = $"subtitles={effectiveFile}:fontsdir={fontsDir}";
+            }
+
             return this;
         }
 
@@ -84,19 +131,25 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public Option<FFmpegComplexFilter> Build(int videoStreamIndex, Option<int> audioStreamIndex)
+        public Option<FFmpegComplexFilter> Build(bool videoOnly, int videoInput, int videoStreamIndex, int audioInput, Option<int> audioStreamIndex, bool isSong)
         {
             var complexFilter = new StringBuilder();
 
-            var videoLabel = $"0:{videoStreamIndex}";
+            var videoLabel = $"{videoInput}:{(isSong ? "v" : videoStreamIndex.ToString())}";
-            string audioLabel = audioStreamIndex.Match(index => $"0:{index}", () => "0:a");
+            string audioLabel = audioStreamIndex.Match(index => $"{audioInput}:{index}", () => "0:a");
 
             HardwareAccelerationKind acceleration = _hardwareAccelerationKind.IfNone(HardwareAccelerationKind.None);
             bool isHardwareDecode = acceleration switch
             {
-                HardwareAccelerationKind.Vaapi => _inputCodec != "mpeg4",
+                HardwareAccelerationKind.Vaapi => !isSong && _inputCodec != "mpeg4",
-                HardwareAccelerationKind.Nvenc => true,
+                
-                HardwareAccelerationKind.Qsv => true,
+                // we need an initial hwupload_cuda when only padding with these pixel formats
+                HardwareAccelerationKind.Nvenc when _scaleToSize.IsNone && _padToSize.IsSome =>
+                    !isSong && !_pixelFormat.Contains("p10le") && !_pixelFormat.Contains("444"),
+
+                HardwareAccelerationKind.Nvenc => !isSong,
+                HardwareAccelerationKind.Qsv => !isSong,
+                HardwareAccelerationKind.VideoToolbox => false,
                 _ => false
             };
 
@@ -104,20 +157,54 @@ namespace ErsatzTV.Core.FFmpeg
             var videoFilterQueue = new List<string>();
             string watermarkPreprocess = string.Empty;
             string watermarkOverlay = string.Empty;
-
+            
             if (_normalizeLoudness)
             {
                 audioFilterQueue.Add("loudnorm=I=-16:TP=-1.5:LRA=11");
             }
 
             _audioDuration.IfSome(
-                audioDuration => audioFilterQueue.Add($"apad=whole_dur={audioDuration.TotalMilliseconds}ms"));
+                audioDuration =>
+                {
+                    var durationString = audioDuration.TotalMilliseconds.ToString(NumberFormatInfo.InvariantInfo);
+                    audioFilterQueue.Add($"apad=whole_dur={durationString}ms");
+                });
 
-            bool usesHardwareFilters = acceleration != HardwareAccelerationKind.None && !isHardwareDecode &&
+            bool usesHardwareFilters = acceleration != HardwareAccelerationKind.None &&
+                                       acceleration != HardwareAccelerationKind.VideoToolbox &&
+                                       !isHardwareDecode &&
                                        (_deinterlace || _scaleToSize.IsSome);
-            if (usesHardwareFilters)
+
+            if (isSong)
             {
-                videoFilterQueue.Add("hwupload");
+                switch (acceleration)
+                {
+                    case HardwareAccelerationKind.Qsv:
+                        videoFilterQueue.Add("format=nv12");
+                        break;
+                    case HardwareAccelerationKind.Vaapi:
+                        videoFilterQueue.Add("format=nv12|vaapi");
+                        break;
+                    default:
+                        videoFilterQueue.Add("format=yuv420p");
+                        break;
+                }
+            }
+
+            switch (usesHardwareFilters || isSong, acceleration)
+            {
+                case (true, HardwareAccelerationKind.Nvenc):
+                    videoFilterQueue.Add("hwupload_cuda");
+                    break;
+                case (true, HardwareAccelerationKind.Qsv):
+                    videoFilterQueue.Add("hwupload=extra_hw_frames=64");
+                    break;
+                case (true, HardwareAccelerationKind.Vaapi):
+                    videoFilterQueue.Add("hwupload");
+                    break;
+                case (true, _) when usesHardwareFilters:
+                    videoFilterQueue.Add("hwupload");
+                    break;
             }
 
             if (_deinterlace)
@@ -158,8 +245,9 @@ namespace ErsatzTV.Core.FFmpeg
                         HardwareAccelerationKind.Qsv => $"scale_qsv=w={size.Width}:h={size.Height}",
                         HardwareAccelerationKind.Nvenc when _pixelFormat is "yuv420p10le" =>
                             $"hwupload_cuda,scale_cuda={size.Width}:{size.Height}",
-                        HardwareAccelerationKind.Nvenc => $"scale_npp={size.Width}:{size.Height}",
+                        HardwareAccelerationKind.Nvenc => $"scale_cuda={size.Width}:{size.Height}",
                         HardwareAccelerationKind.Vaapi => $"scale_vaapi=format=nv12:w={size.Width}:h={size.Height}",
+                        _ when videoOnly => $"scale={size.Width}:{size.Height}:force_original_aspect_ratio=increase,crop={size.Width}:{size.Height}",
                         _ => $"scale={size.Width}:{size.Height}:flags=fast_bilinear"
                     };
 
@@ -170,7 +258,12 @@ namespace ErsatzTV.Core.FFmpeg
                 });
 
             bool scaleOrPad = _scaleToSize.IsSome || _padToSize.IsSome;
-            bool usesSoftwareFilters = scaleOrPad || _watermark.IsSome;
+            bool usesSoftwareFilters = _padToSize.IsSome || _watermark.IsSome;
+
+            if (scaleOrPad && _boxBlur == false)
+            {
+                videoFilterQueue.Add("setsar=1");
+            }
 
             if (usesSoftwareFilters)
             {
@@ -182,14 +275,21 @@ namespace ErsatzTV.Core.FFmpeg
                         HardwareAccelerationKind.Vaapi => "format=nv12|vaapi",
                         HardwareAccelerationKind.Nvenc when _pixelFormat == "yuv420p10le" =>
                             "format=p010le,format=nv12",
+                        HardwareAccelerationKind.Qsv when isSong => "format=nv12,format=yuv420p",
+                        _ when isSong => "format=yuv420p",
                         _ => "format=nv12"
                     };
                     videoFilterQueue.Add(format);
                 }
-
+                
-                if (scaleOrPad)
+                if (_boxBlur)
                 {
-                    videoFilterQueue.Add("setsar=1");
+                    videoFilterQueue.Add("boxblur=40");
+                }
+
+                if (videoOnly)
+                {
+                    videoFilterQueue.Add("deband");
                 }
 
                 foreach (ChannelWatermark watermark in _watermark)
@@ -237,6 +337,11 @@ namespace ErsatzTV.Core.FFmpeg
             }
 
             _padToSize.IfSome(size => videoFilterQueue.Add($"pad={size.Width}:{size.Height}:(ow-iw)/2:(oh-ih)/2"));
+            
+            foreach (string subtitle in _subtitle)
+            {
+                videoFilterQueue.Add(subtitle);
+            }
 
             string outputPixelFormat = null;
             
@@ -301,7 +406,12 @@ namespace ErsatzTV.Core.FFmpeg
                         complexFilter.Append("[vt];");
                     }
 
-                    var watermarkLabel = "[1:v]";
+                    var watermarkLabel = $"[{audioInput+1}:v]";
+                    foreach (int index in _watermarkIndex)
+                    {
+                        watermarkLabel = $"[{audioInput+1}:{index}]";
+                    }
+
                     if (!string.IsNullOrWhiteSpace(watermarkPreprocess))
                     {
                         complexFilter.Append($"{watermarkLabel}{watermarkPreprocess}[wmp];");
@@ -315,10 +425,21 @@ namespace ErsatzTV.Core.FFmpeg
 
                     if (usesSoftwareFilters && acceleration != HardwareAccelerationKind.None)
                     {
-                        complexFilter.Append(",hwupload");
+                        switch (isSong, acceleration)
+                        {
+                            case (true, HardwareAccelerationKind.Nvenc):
+                                complexFilter.Append(",hwupload_cuda");
+                                break;
+                            case (_, HardwareAccelerationKind.Qsv):
+                                complexFilter.Append(",format=yuv420p,hwupload=extra_hw_frames=64");
+                                break;
+                            default:
+                                complexFilter.Append(",hwupload");
+                                break;
+                        }
                     }
                 }
-
+                
                 videoLabel = "[v]";
                 complexFilter.Append(videoLabel);
             }

ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs

@@ -45,8 +45,8 @@ namespace ErsatzTV.Core.FFmpeg
         public FFmpegPlaybackSettings CalculateSettings(
             StreamingMode streamingMode,
             FFmpegProfile ffmpegProfile,
-            MediaVersion version,
+            MediaVersion videoVersion,
-            MediaStream videoStream,
+            Option<MediaStream> videoStream,
             Option<MediaStream> audioStream,
             DateTimeOffset start,
             DateTimeOffset now,
@@ -71,15 +71,15 @@ namespace ErsatzTV.Core.FFmpeg
                     result.VideoCodec = "copy";
                     result.Deinterlace = false;
                     break;
-                case StreamingMode.HttpLiveStreamingHybrid:
+                case StreamingMode.TransportStreamHybrid:
                 case StreamingMode.HttpLiveStreamingSegmenter:
                 case StreamingMode.TransportStream:
                     result.HardwareAcceleration = ffmpegProfile.HardwareAcceleration;
 
-                    if (NeedToScale(ffmpegProfile, version))
+                    if (NeedToScale(ffmpegProfile, videoVersion))
                     {
-                        IDisplaySize scaledSize = CalculateScaledSize(ffmpegProfile, version);
+                        IDisplaySize scaledSize = CalculateScaledSize(ffmpegProfile, videoVersion);
-                        if (!scaledSize.IsSameSizeAs(version))
+                        if (!scaledSize.IsSameSizeAs(videoVersion))
                         {
                             int fixedHeight = scaledSize.Height + scaledSize.Height % 2;
                             int fixedWidth = scaledSize.Width + scaledSize.Width % 2;
@@ -87,7 +87,7 @@ namespace ErsatzTV.Core.FFmpeg
                         }
                     }
 
-                    IDisplaySize sizeAfterScaling = result.ScaledSize.IfNone(version);
+                    IDisplaySize sizeAfterScaling = result.ScaledSize.IfNone(videoVersion);
                     if (ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo && !sizeAfterScaling.IsSameSizeAs(ffmpegProfile.Resolution))
                     {
                         result.PadToDesiredResolution = true;
@@ -98,32 +98,41 @@ namespace ErsatzTV.Core.FFmpeg
                         result.VideoTrackTimeScale = 90000;
                     }
 
-                    if (result.ScaledSize.IsSome || result.PadToDesiredResolution ||
+                    foreach (MediaStream stream in videoStream.Where(s => s.AttachedPic == false))
-                        NeedToNormalizeVideoCodec(ffmpegProfile, videoStream))
                     {
-                        result.VideoCodec = ffmpegProfile.VideoCodec;
+                        if (result.ScaledSize.IsSome || result.PadToDesiredResolution ||
-                        result.VideoBitrate = ffmpegProfile.VideoBitrate;
+                            NeedToNormalizeVideoCodec(ffmpegProfile, stream))
-                        result.VideoBufferSize = ffmpegProfile.VideoBufferSize;
+                        {
+                            result.VideoCodec = ffmpegProfile.VideoCodec;
+                            result.VideoBitrate = ffmpegProfile.VideoBitrate;
+                            result.VideoBufferSize = ffmpegProfile.VideoBufferSize;
 
-                        result.VideoDecoder =
+                            result.VideoDecoder =
-                            (result.HardwareAcceleration, videoStream.Codec, videoStream.PixelFormat) switch
+                                (result.HardwareAcceleration, stream.Codec, stream.PixelFormat) switch
-                            {
+                                {
-                                (HardwareAccelerationKind.Nvenc, "h264", "yuv420p10le" or "yuv444p" or "yuv444p10le") =>
+                                    (HardwareAccelerationKind.Nvenc, "h264", "yuv420p10le" or "yuv444p" or "yuv444p10le"
-                                    "h264",
+                                        ) =>
-                                (HardwareAccelerationKind.Nvenc, "hevc", "yuv444p" or "yuv444p10le") => "hevc",
+                                        "h264",
-                                (HardwareAccelerationKind.Nvenc, "h264", _) => "h264_cuvid",
+                                    (HardwareAccelerationKind.Nvenc, "hevc", "yuv444p" or "yuv444p10le") => "hevc",
-                                (HardwareAccelerationKind.Nvenc, "hevc", _) => "hevc_cuvid",
+                                    (HardwareAccelerationKind.Nvenc, "h264", _) => "h264_cuvid",
-                                (HardwareAccelerationKind.Nvenc, "mpeg2video", _) => "mpeg2_cuvid",
+                                    (HardwareAccelerationKind.Nvenc, "hevc", _) => "hevc_cuvid",
-                                (HardwareAccelerationKind.Nvenc, "mpeg4", _) => "mpeg4_cuvid",
+                                    (HardwareAccelerationKind.Nvenc, "mpeg2video", _) => "mpeg2_cuvid",
-                                (HardwareAccelerationKind.Qsv, "h264", _) => "h264_qsv",
+                                    (HardwareAccelerationKind.Nvenc, "mpeg4", _) => "mpeg4_cuvid",
-                                (HardwareAccelerationKind.Qsv, "hevc", _) => "hevc_qsv",
+                                    (HardwareAccelerationKind.Qsv, "h264", _) => "h264_qsv",
-                                (HardwareAccelerationKind.Qsv, "mpeg2video", _) => "mpeg2_qsv",
+                                    (HardwareAccelerationKind.Qsv, "hevc", _) => "hevc_qsv",
-                                _ => null
+                                    (HardwareAccelerationKind.Qsv, "mpeg2video", _) => "mpeg2_qsv",
-                            };
+                                    
-                    }
+                                    // temp disable mpeg4 hardware decoding for all vaapi
-                    else
+                                    // TODO: check for codec support
-                    {
+                                    (HardwareAccelerationKind.Vaapi, "mpeg4", _) => "mpeg4",
-                        result.VideoCodec = "copy";
+                                    
+                                    _ => null
+                                };
+                        }
+                        else
+                        {
+                            result.VideoCodec = "copy";
+                        }
                     }
 
                     if (ffmpegProfile.Transcode && ffmpegProfile.NormalizeAudio)
@@ -150,7 +159,7 @@ namespace ErsatzTV.Core.FFmpeg
                         result.AudioCodec = "copy";
                     }
 
-                    if (version.VideoScanKind == VideoScanKind.Interlaced)
+                    if (videoVersion.VideoScanKind == VideoScanKind.Interlaced)
                     {
                         result.Deinterlace = true;
                     }

ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs

@@ -22,6 +22,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Runtime.InteropServices;
 using System.Text;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
@@ -42,6 +43,8 @@ namespace ErsatzTV.Core.FFmpeg
         private string _vaapiDevice;
         private HardwareAccelerationKind _hwAccel;
         private string _outputPixelFormat;
+        private bool _noAutoScale;
+        private Option<int> _outputFramerate;
 
         public FFmpegProcessBuilder(string ffmpegPath, bool saveReports, ILogger logger)
         {
@@ -71,7 +74,7 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public FFmpegProcessBuilder WithHardwareAcceleration(HardwareAccelerationKind hwAccel, string pixelFormat, string encoder)
+        public FFmpegProcessBuilder WithHardwareAcceleration(HardwareAccelerationKind hwAccel, Option<string> pixelFormat, string encoder)
         {
             _hwAccel = hwAccel;
 
@@ -84,7 +87,7 @@ namespace ErsatzTV.Core.FFmpeg
                     _arguments.Add("qsv=qsv:MFX_IMPL_hw_any");
                     break;
                 case HardwareAccelerationKind.Nvenc:
-                    string outputFormat = (encoder, pixelFormat) switch
+                    string outputFormat = (encoder, pixelFormat.IfNone("")) switch
                     {
                         ("hevc_nvenc", "yuv420p10le") => "p010le",
                         ("h264_nvenc", "yuv420p10le") => "p010le",
@@ -105,6 +108,10 @@ namespace ErsatzTV.Core.FFmpeg
                     _arguments.Add("-hwaccel_output_format");
                     _arguments.Add("vaapi");
                     break;
+                case HardwareAccelerationKind.VideoToolbox:
+                    _arguments.Add("-hwaccel");
+                    _arguments.Add("videotoolbox");
+                    break;
             }
 
             _complexFilterBuilder = _complexFilterBuilder.WithHardwareAcceleration(hwAccel);
@@ -147,6 +154,11 @@ namespace ErsatzTV.Core.FFmpeg
             {
                 _arguments.Add("-stream_loop");
                 _arguments.Add("-1");
+                
+                if (_hwAccel is HardwareAccelerationKind.Qsv or HardwareAccelerationKind.Vaapi)
+                {
+                    _noAutoScale = true;
+                }
             }
 
             return this;
@@ -183,35 +195,80 @@ namespace ErsatzTV.Core.FFmpeg
         public FFmpegProcessBuilder WithInput(string input)
         {
             _arguments.Add("-i");
-            _arguments.Add($"{input}");
+            _arguments.Add(input);
+            return this;
+        }
+
+        public FFmpegProcessBuilder WithMap(string map)
+        {
+            _arguments.Add("-map");
+            _arguments.Add(map);
+            return this;
+        }
+
+        public FFmpegProcessBuilder WithCopyCodec()
+        {
+            _arguments.Add("-c");
+            _arguments.Add("copy");
             return this;
         }
 
         public FFmpegProcessBuilder WithWatermark(
-            Option<ChannelWatermark> watermark,
+            Option<WatermarkOptions> watermarkOptions,
-            Option<string> maybePath,
+            IDisplaySize resolution)
-            IDisplaySize resolution,
-            bool isAnimated)
         {
-            foreach (string path in maybePath)
+            foreach (WatermarkOptions options in watermarkOptions)
             {
-                if (isAnimated)
+                foreach (string path in options.ImagePath)
                 {
-                    _arguments.Add("-ignore_loop");
+                    if (options.IsAnimated)
-                    _arguments.Add("0");
+                    {
+                        _arguments.Add("-ignore_loop");
+                        _arguments.Add("0");
+                    }
+
+                    _arguments.Add("-i");
+                    _arguments.Add(path);
+
+                    _complexFilterBuilder = _complexFilterBuilder.WithWatermark(
+                        options.Watermark,
+                        resolution,
+                        options.ImageStreamIndex);
                 }
-
-                _arguments.Add("-i");
-                _arguments.Add(path);
-
-                _complexFilterBuilder = _complexFilterBuilder.WithWatermark(watermark, resolution);
             }
-
+            
             return this;
         }
 
-        public FFmpegProcessBuilder WithInputCodec(string input, string decoder, string codec, string pixelFormat)
+        public FFmpegProcessBuilder WithSubtitleFile(Option<string> subtitleFile)
         {
+            _complexFilterBuilder = _complexFilterBuilder.WithSubtitleFile(subtitleFile);
+            return this;
+        }
+
+        public FFmpegProcessBuilder WithInputCodec(
+            Option<TimeSpan> maybeStart,
+            bool loop,
+            string videoPath,
+            string audioPath,
+            string decoder,
+            Option<string> codec,
+            Option<string> pixelFormat)
+        {
+            if (audioPath == videoPath)
+            {
+                WithSeek(maybeStart);
+                WithInfiniteLoop(loop);
+            }
+            else
+            {
+                _noAutoScale = true;
+                _outputFramerate = 30;
+                
+                _arguments.Add("-loop");
+                _arguments.Add("1");
+            }
+
             if (!string.IsNullOrWhiteSpace(decoder))
             {
                 _arguments.Add("-c:v");
@@ -223,25 +280,36 @@ namespace ErsatzTV.Core.FFmpeg
                 .WithInputPixelFormat(pixelFormat);
 
             _arguments.Add("-i");
-            _arguments.Add($"{input}");
+            _arguments.Add(videoPath);
+
+            if (audioPath != videoPath)
+            {
+                WithSeek(maybeStart);
+
+                _arguments.Add("-i");
+                _arguments.Add(audioPath);
+            }
+
             return this;
         }
-
+        
-        public FFmpegProcessBuilder WithFiltergraph(string graph)
+        public FFmpegProcessBuilder WithSongInput(
+            string videoPath,
+            Option<string> codec,
+            Option<string> pixelFormat,
+            bool boxBlur)
         {
-            _arguments.Add("-vf");
+            _noAutoScale = true;
-            _arguments.Add($"{graph}");
+            _outputFramerate = 30;
-            return this;
+
-        }
+            _complexFilterBuilder = _complexFilterBuilder
+                .WithInputCodec(codec)
+                .WithInputPixelFormat(pixelFormat)
+                .WithBoxBlur(boxBlur);
+
+            _arguments.Add("-i");
+            _arguments.Add(videoPath);
 
-        public FFmpegProcessBuilder WithFilterComplex(string filter, string finalVideo, string finalAudio)
-        {
-            _arguments.Add("-filter_complex");
-            _arguments.Add($"{filter}");
-            _arguments.Add("-map");
-            _arguments.Add(finalVideo);
-            _arguments.Add("-map");
-            _arguments.Add(finalAudio);
             return this;
         }
 
@@ -298,22 +366,6 @@ namespace ErsatzTV.Core.FFmpeg
             return this;
         }
 
-        public FFmpegProcessBuilder WithErrorText(IDisplaySize desiredResolution, string text)
-        {
-            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";
-
-            string fontSize = text.Length > 80 ? "fontsize=30" : text.Length > 60 ? "fontsize=40" : "fontsize=60";
-
-            return WithFilterComplex(
-                $"[0:0]scale={desiredResolution.Width}:{desiredResolution.Height},drawtext={fontFile}:{fontSize}:{FONT_COLOR}:{X}:{Y}:text='{text}'[v]",
-                "[v]",
-                "1:a");
-        }
-
         public FFmpegProcessBuilder WithDuration(TimeSpan duration)
         {
             _arguments.Add("-t");
@@ -327,7 +379,7 @@ namespace ErsatzTV.Core.FFmpeg
             _arguments.Add($"{format}");
             return this;
         }
-
+        
         public FFmpegProcessBuilder WithHls(string channelNumber, Option<MediaVersion> mediaVersion)
         {
             const int SEGMENT_SECONDS = 4;
@@ -430,6 +482,18 @@ namespace ErsatzTV.Core.FFmpeg
                 });
 
             _arguments.AddRange(arguments);
+
+            if (_noAutoScale)
+            {
+                _arguments.Add("-noautoscale");
+            }
+
+            foreach (int framerate in _outputFramerate)
+            {
+                _arguments.Add("-r");
+                _arguments.Add(framerate.ToString());
+            }
+
             return this;
         }
 
@@ -473,10 +537,23 @@ namespace ErsatzTV.Core.FFmpeg
             _complexFilterBuilder = _complexFilterBuilder.WithDeinterlace(deinterlace);
             return this;
         }
+        
+        public FFmpegProcessBuilder WithOutputFormat(string format, string output)
+        {
+            _arguments.Add("-f");
+            _arguments.Add(format);
+            
+            _arguments.Add("-y");
+            _arguments.Add(output);
+
+            return this;
+        }
 
         public FFmpegProcessBuilder WithFilterComplex(
             MediaStream videoStream,
             Option<MediaStream> maybeAudioStream,
+            string videoPath,
+            Option<string> audioPath,
             string videoCodec)
         {
             _complexFilterBuilder = _complexFilterBuilder.WithVideoEncoder(videoCodec);
@@ -484,10 +561,33 @@ namespace ErsatzTV.Core.FFmpeg
             int videoStreamIndex = videoStream.Index;
             Option<int> maybeIndex = maybeAudioStream.Map(ms => ms.Index);
 
-            var videoLabel = $"0:{videoStreamIndex}";
+            var videoIndex = 0;
-            var audioLabel = $"0:{maybeIndex.Match(i => i.ToString(), () => "a")}";
+            var audioIndex = 0;
+            if (audioPath.IsNone)
+            {
+                // no audio index, so use same as video
+                audioIndex = 0;
+            }
+            else if (audioPath.IfNone("NotARealPath") != videoPath)
+            {
+                audioIndex = 1;
+                if (_hwAccel == HardwareAccelerationKind.None)
+                {
+                    _outputPixelFormat = "yuv420p";
+                }
+            }
+
+            var videoLabel = $"{videoIndex}:{videoStreamIndex}";
+            var audioLabel = $"{audioIndex}:{maybeIndex.Match(i => i.ToString(), () => "a")}";
+
+            Option<FFmpegComplexFilter> maybeFilter = _complexFilterBuilder.Build(
+                audioPath.IsNone,
+                videoIndex,
+                videoStreamIndex,
+                audioIndex,
+                maybeIndex,
+                audioPath.IsSome && videoPath != audioPath.IfNone("NotARealPath"));
 
-            Option<FFmpegComplexFilter> maybeFilter = _complexFilterBuilder.Build(videoStreamIndex, maybeIndex);
             maybeFilter.IfSome(
                 filter =>
                 {
@@ -505,8 +605,11 @@ namespace ErsatzTV.Core.FFmpeg
             _arguments.Add("-map");
             _arguments.Add(videoLabel);
 
-            _arguments.Add("-map");
+            foreach (string _ in audioPath)
-            _arguments.Add(audioLabel);
+            {
+                _arguments.Add("-map");
+                _arguments.Add(audioLabel);
+            }
 
             return this;
         }
@@ -534,13 +637,13 @@ namespace ErsatzTV.Core.FFmpeg
                 switch (_vaapiDriver)
                 {
                     case VaapiDriver.i965:
-                        startInfo.EnvironmentVariables.Add("LIBVA_DRIVER_NAME", "i965");
+                        startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "i965";
                         break;
                     case VaapiDriver.iHD:
-                        startInfo.EnvironmentVariables.Add("LIBVA_DRIVER_NAME", "iHD");
+                        startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "iHD";
                         break;
                     case VaapiDriver.RadeonSI:
-                        startInfo.EnvironmentVariables.Add("LIBVA_DRIVER_NAME", "radeonsi");
+                        startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "radeonsi";
                         break;
                 }
             }
@@ -550,7 +653,18 @@ namespace ErsatzTV.Core.FFmpeg
                 string fileName = _isConcat
                     ? Path.Combine(FileSystemLayout.FFmpegReportsFolder, "ffmpeg-%t-concat.log")
                     : Path.Combine(FileSystemLayout.FFmpegReportsFolder, "ffmpeg-%t-transcode.log");
-                startInfo.EnvironmentVariables.Add("FFREPORT", $"file={fileName}:level=32");
+
+                // rework filename in a format that works on windows
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    // \ is escape, so use / for directory separators
+                    fileName = fileName.Replace(@"\", @"/");
+                    
+                    // colon after drive letter needs to be escaped
+                    fileName = fileName.Replace(@":/", @"\:/");
+                }
+
+                startInfo.EnvironmentVariables["FFREPORT"] = $"file={fileName}:level=32";
             }
 
             startInfo.ArgumentList.Add("-nostdin");

ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs

@@ -12,10 +12,11 @@ using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Core.FFmpeg
 {
-    public class FFmpegProcessService
+    public class FFmpegProcessService : IFFmpegProcessService
     {
         private readonly IFFmpegStreamSelector _ffmpegStreamSelector;
         private readonly IImageCache _imageCache;
+        private readonly ITempFilePool _tempFilePool;
         private readonly ILogger<FFmpegProcessService> _logger;
         private readonly FFmpegPlaybackSettingsCalculator _playbackSettingsCalculator;
 
@@ -23,11 +24,13 @@ namespace ErsatzTV.Core.FFmpeg
             FFmpegPlaybackSettingsCalculator ffmpegPlaybackSettingsService,
             IFFmpegStreamSelector ffmpegStreamSelector,
             IImageCache imageCache,
+            ITempFilePool tempFilePool,
             ILogger<FFmpegProcessService> logger)
         {
             _playbackSettingsCalculator = ffmpegPlaybackSettingsService;
             _ffmpegStreamSelector = ffmpegStreamSelector;
             _imageCache = imageCache;
+            _tempFilePool = tempFilePool;
             _logger = logger;
         }
 
@@ -35,8 +38,10 @@ namespace ErsatzTV.Core.FFmpeg
             string ffmpegPath,
             bool saveReports,
             Channel channel,
-            MediaVersion version,
+            MediaVersion videoVersion,
-            string path,
+            MediaVersion audioVersion,
+            string videoPath,
+            string audioPath,
             DateTimeOffset start,
             DateTimeOffset finish,
             DateTimeOffset now,
@@ -48,13 +53,13 @@ namespace ErsatzTV.Core.FFmpeg
             TimeSpan inPoint,
             TimeSpan outPoint)
         {
-            MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, version);
+            MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, videoVersion);
-            Option<MediaStream> maybeAudioStream = await _ffmpegStreamSelector.SelectAudioStream(channel, version);
+            Option<MediaStream> maybeAudioStream = await _ffmpegStreamSelector.SelectAudioStream(channel, audioVersion);
 
             FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.CalculateSettings(
                 channel.StreamingMode,
                 channel.FFmpegProfile,
-                version,
+                videoVersion,
                 videoStream,
                 maybeAudioStream,
                 start,
@@ -62,26 +67,30 @@ namespace ErsatzTV.Core.FFmpeg
                 inPoint,
                 outPoint);
 
-            (Option<ChannelWatermark> maybeWatermark, Option<string> maybeWatermarkPath) =
+            Option<WatermarkOptions> watermarkOptions =
-                GetWatermarkOptions(channel, globalWatermark);
+                await GetWatermarkOptions(channel, globalWatermark, videoVersion, None, None);
-
-            bool isAnimated = await maybeWatermarkPath.Match(
-                p => _imageCache.IsAnimated(p),
-                () => Task.FromResult(false));
 
             FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, saveReports, _logger)
                 .WithThreads(playbackSettings.ThreadCount)
                 .WithVaapiDriver(vaapiDriver, vaapiDevice)
-                .WithHardwareAcceleration(playbackSettings.HardwareAcceleration, videoStream.PixelFormat, playbackSettings.VideoCodec)
+                .WithHardwareAcceleration(
+                    playbackSettings.HardwareAcceleration,
+                    videoStream.PixelFormat,
+                    playbackSettings.VideoCodec)
                 .WithQuiet()
                 .WithFormatFlags(playbackSettings.FormatFlags)
                 .WithRealtimeOutput(playbackSettings.RealtimeOutput)
-                .WithSeek(playbackSettings.StreamSeek)
+                .WithInputCodec(
-                .WithInfiniteLoop(fillerKind == FillerKind.Fallback)
+                    playbackSettings.StreamSeek,
-                .WithInputCodec(path, playbackSettings.VideoDecoder, videoStream.Codec, videoStream.PixelFormat)
+                    fillerKind == FillerKind.Fallback,
-                .WithWatermark(maybeWatermark, maybeWatermarkPath, channel.FFmpegProfile.Resolution, isAnimated)
+                    videoPath,
+                    audioPath,
+                    playbackSettings.VideoDecoder,
+                    videoStream.Codec,
+                    videoStream.PixelFormat)
+                .WithWatermark(watermarkOptions, channel.FFmpegProfile.Resolution)
                 .WithVideoTrackTimeScale(playbackSettings.VideoTrackTimeScale)
-                .WithAlignedAudio(playbackSettings.AudioDuration)
+                .WithAlignedAudio(videoPath == audioPath ? playbackSettings.AudioDuration : Option<TimeSpan>.None)
                 .WithNormalizeLoudness(playbackSettings.NormalizeLoudness);
 
             playbackSettings.ScaledSize.Match(
@@ -96,7 +105,12 @@ namespace ErsatzTV.Core.FFmpeg
                     }
 
                     builder = builder
-                        .WithFilterComplex(videoStream, maybeAudioStream, channel.FFmpegProfile.VideoCodec);
+                        .WithFilterComplex(
+                            videoStream,
+                            maybeAudioStream,
+                            videoPath,
+                            audioPath,
+                            channel.FFmpegProfile.VideoCodec);
                 },
                 () =>
                 {
@@ -105,18 +119,33 @@ namespace ErsatzTV.Core.FFmpeg
                         builder = builder
                             .WithDeinterlace(playbackSettings.Deinterlace)
                             .WithBlackBars(channel.FFmpegProfile.Resolution)
-                            .WithFilterComplex(videoStream, maybeAudioStream, channel.FFmpegProfile.VideoCodec);
+                            .WithFilterComplex(
+                                videoStream,
+                                maybeAudioStream,
+                                videoPath,
+                                audioPath,
+                                channel.FFmpegProfile.VideoCodec);
                     }
                     else if (playbackSettings.Deinterlace)
                     {
                         builder = builder.WithDeinterlace(playbackSettings.Deinterlace)
                             .WithAlignedAudio(playbackSettings.AudioDuration)
-                            .WithFilterComplex(videoStream, maybeAudioStream, channel.FFmpegProfile.VideoCodec);
+                            .WithFilterComplex(
+                                videoStream,
+                                maybeAudioStream,
+                                videoPath,
+                                audioPath,
+                                channel.FFmpegProfile.VideoCodec);
                     }
                     else
                     {
                         builder = builder
-                            .WithFilterComplex(videoStream, maybeAudioStream, channel.FFmpegProfile.VideoCodec);
+                            .WithFilterComplex(
+                                videoStream,
+                                maybeAudioStream,
+                                videoPath,
+                                audioPath,
+                                channel.FFmpegProfile.VideoCodec);
                     }
                 });
 
@@ -128,7 +157,7 @@ namespace ErsatzTV.Core.FFmpeg
             {
                 // HLS needs to segment and generate playlist
                 case StreamingMode.HttpLiveStreamingSegmenter:
-                    return builder.WithHls(channel.Number, version)
+                    return builder.WithHls(channel.Number, videoVersion)
                         .WithRealtimeOutput(hlsRealtime)
                         .Build();
                 default:
@@ -138,7 +167,7 @@ namespace ErsatzTV.Core.FFmpeg
             }
         }
 
-        public Process ForError(
+        public async Task<Process> ForError(
             string ffmpegPath,
             Channel channel,
             Option<TimeSpan> duration,
@@ -150,6 +179,22 @@ namespace ErsatzTV.Core.FFmpeg
 
             IDisplaySize desiredResolution = channel.FFmpegProfile.Resolution;
 
+            var fontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 20.0);
+            var margin = (int)Math.Round(channel.FFmpegProfile.Resolution.Height * 0.05);
+            
+            string subtitleFile = await new SubtitleBuilder(_tempFilePool)
+                .WithResolution(desiredResolution)
+                .WithFontName("Roboto")
+                .WithFontSize(fontSize)
+                .WithAlignment(2)
+                .WithMarginV(margin)
+                .WithPrimaryColor("&HFFFFFF")
+                .WithFormattedContent(errorMessage.Replace(Environment.NewLine, "\\N"))
+                .BuildFile();
+
+            var videoStream = new MediaStream { Index = 0 };
+            var audioStream = new MediaStream { Index = 0 };
+
             FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, false, _logger)
                 .WithThreads(1)
                 .WithQuiet()
@@ -158,12 +203,18 @@ namespace ErsatzTV.Core.FFmpeg
                 .WithLoopedImage(Path.Combine(FileSystemLayout.ResourcesCacheFolder, "background.png"))
                 .WithLibavfilter()
                 .WithInput("anullsrc")
-                .WithErrorText(desiredResolution, errorMessage)
+                .WithSubtitleFile(subtitleFile)
+                .WithFilterComplex(
+                    videoStream,
+                    audioStream,
+                    Path.Combine(FileSystemLayout.ResourcesCacheFolder, "background.png"),
+                    "fake-audio-path",
+                    playbackSettings.VideoCodec)
                 .WithPixfmt("yuv420p")
                 .WithPlaybackArgs(playbackSettings)
                 .WithMetadata(channel, None);
 
-            duration.IfSome(d => builder = builder.WithDuration(d));
+            await duration.IfSomeAsync(d => builder = builder.WithDuration(d));
 
             switch (channel.StreamingMode)
             {
@@ -196,14 +247,167 @@ namespace ErsatzTV.Core.FFmpeg
                 .Build();
         }
 
+        public Process WrapSegmenter(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host)
+        {
+            FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.ConcatSettings;
+
+            return new FFmpegProcessBuilder(ffmpegPath, saveReports, _logger)
+                .WithThreads(1)
+                .WithQuiet()
+                .WithFormatFlags(playbackSettings.FormatFlags)
+                .WithRealtimeOutput(playbackSettings.RealtimeOutput)
+                .WithInput($"http://localhost:{Settings.ListenPort}/iptv/channel/{channel.Number}.m3u8?mode=segmenter")
+                .WithMap("0")
+                .WithCopyCodec()
+                .WithMetadata(channel, None)
+                .WithFormat("mpegts")
+                .WithPipe()
+                .Build();
+        }
+
+        public Process ConvertToPng(string ffmpegPath, string inputFile, string outputFile)
+        {
+            return new FFmpegProcessBuilder(ffmpegPath, false, _logger)
+                .WithThreads(1)
+                .WithQuiet()
+                .WithInput(inputFile)
+                .WithOutputFormat("apng", outputFile)
+                .Build();
+        }
+
+        public Process ExtractAttachedPicAsPng(string ffmpegPath, string inputFile, int streamIndex, string outputFile)
+        {
+            return new FFmpegProcessBuilder(ffmpegPath, false, _logger)
+                .WithThreads(1)
+                .WithQuiet()
+                .WithInput(inputFile)
+                .WithMap($"0:{streamIndex}")
+                .WithOutputFormat("apng", outputFile)
+                .Build();
+        }
+
+        public async Task<Either<BaseError, string>> GenerateSongImage(
+            string ffmpegPath,
+            Option<string> subtitleFile,
+            Channel channel,
+            Option<ChannelWatermark> globalWatermark,
+            MediaVersion videoVersion,
+            string videoPath,
+            bool boxBlur,
+            Option<string> watermarkPath,
+            ChannelWatermarkLocation watermarkLocation,
+            int horizontalMarginPercent,
+            int verticalMarginPercent,
+            int watermarkWidthPercent)
+        {
+            try
+            {
+                string outputFile = _tempFilePool.GetNextTempFile(TempFileCategory.SongBackground);
+
+                MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, videoVersion);
+
+                Option<ChannelWatermark> watermarkOverride =
+                    videoVersion is FallbackMediaVersion or CoverArtMediaVersion
+                        ? new ChannelWatermark
+                        {
+                            Mode = ChannelWatermarkMode.Permanent,
+                            HorizontalMarginPercent = horizontalMarginPercent,
+                            VerticalMarginPercent = verticalMarginPercent,
+                            Location = watermarkLocation,
+                            Size = ChannelWatermarkSize.Scaled,
+                            WidthPercent = watermarkWidthPercent,
+                            Opacity = 100
+                        }
+                        : None;
+
+                Option<WatermarkOptions> watermarkOptions =
+                    await GetWatermarkOptions(channel, globalWatermark, videoVersion, watermarkOverride, watermarkPath);
+
+                FFmpegPlaybackSettings playbackSettings =
+                    _playbackSettingsCalculator.CalculateErrorSettings(channel.FFmpegProfile);
+                
+                FFmpegPlaybackSettings scalePlaybackSettings = _playbackSettingsCalculator.CalculateSettings(
+                    StreamingMode.TransportStream,
+                    channel.FFmpegProfile,
+                    videoVersion,
+                    videoStream,
+                    None,
+                    DateTimeOffset.UnixEpoch,
+                    DateTimeOffset.UnixEpoch,
+                    TimeSpan.Zero,
+                    TimeSpan.Zero);
+
+                FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, false, _logger)
+                    .WithThreads(1)
+                    .WithQuiet()
+                    .WithFormatFlags(playbackSettings.FormatFlags)
+                    .WithSongInput(videoPath, videoStream.Codec, videoStream.PixelFormat, boxBlur)
+                    .WithWatermark(watermarkOptions, channel.FFmpegProfile.Resolution)
+                    .WithSubtitleFile(subtitleFile);
+
+                foreach (IDisplaySize scaledSize in scalePlaybackSettings.ScaledSize)
+                {
+                    builder = builder.WithScaling(scaledSize);
+                    
+                    if (NeedToPad(channel.FFmpegProfile.Resolution, scaledSize))
+                    {
+                        builder = builder.WithBlackBars(channel.FFmpegProfile.Resolution);
+                    }
+                }
+
+                using Process process = builder
+                    .WithFilterComplex(
+                        videoStream,
+                        None,
+                        videoPath,
+                        None,
+                        playbackSettings.VideoCodec)
+                    .WithOutputFormat("apng", outputFile)
+                    .Build();
+
+                _logger.LogInformation(
+                    "ffmpeg song arguments {FFmpegArguments}",
+                    string.Join(" ", process.StartInfo.ArgumentList));
+
+                process.Start();
+                await process.WaitForExitAsync();
+
+                return outputFile;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Error generating song image");
+                return Left(BaseError.New(ex.Message));
+            }
+        }
+
         private bool NeedToPad(IDisplaySize target, IDisplaySize displaySize) =>
             displaySize.Width != target.Width || displaySize.Height != target.Height;
 
-        private WatermarkOptions GetWatermarkOptions(Channel channel, Option<ChannelWatermark> globalWatermark)
+        private async Task<WatermarkOptions> GetWatermarkOptions(
+            Channel channel,
+            Option<ChannelWatermark> globalWatermark,
+            MediaVersion videoVersion,
+            Option<ChannelWatermark> watermarkOverride,
+            Option<string> watermarkPath)
         {
+            if (videoVersion is BackgroundImageMediaVersion)
+            {
+                return new WatermarkOptions(None, None, None, false);
+            }
+
             if (channel.StreamingMode != StreamingMode.HttpLiveStreamingDirect && channel.FFmpegProfile.Transcode &&
                 channel.FFmpegProfile.NormalizeVideo)
             {
+                if (videoVersion is CoverArtMediaVersion)
+                {
+                    return new WatermarkOptions(
+                        watermarkOverride,
+                        await watermarkPath.IfNoneAsync(videoVersion.MediaFiles.Head().Path),
+                        0,
+                        false);
+                }
+
                 // check for channel watermark
                 if (channel.Watermark != null)
                 {
@@ -214,13 +418,23 @@ namespace ErsatzTV.Core.FFmpeg
                                 channel.Watermark.Image,
                                 ArtworkKind.Watermark,
                                 Option<int>.None);
-                            return new WatermarkOptions(channel.Watermark, customPath);
+                            return new WatermarkOptions(
+                                await watermarkOverride.IfNoneAsync(channel.Watermark),
+                                customPath,
+                                None,
+                                await _imageCache.IsAnimated(customPath));
                         case ChannelWatermarkImageSource.ChannelLogo:
                             Option<string> maybeChannelPath = channel.Artwork
                                 .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
                                 .HeadOrNone()
                                 .Map(a => _imageCache.GetPathForImage(a.Path, ArtworkKind.Logo, Option<int>.None));
-                            return new WatermarkOptions(channel.Watermark, maybeChannelPath);
+                            return new WatermarkOptions(
+                                await watermarkOverride.IfNoneAsync(channel.Watermark),
+                                maybeChannelPath,
+                                None,
+                                await maybeChannelPath.Match(
+                                    p => _imageCache.IsAnimated(p),
+                                    () => Task.FromResult(false)));
                         default:
                             throw new NotSupportedException("Unsupported watermark image source");
                     }
@@ -236,22 +450,30 @@ namespace ErsatzTV.Core.FFmpeg
                                 watermark.Image,
                                 ArtworkKind.Watermark,
                                 Option<int>.None);
-                            return new WatermarkOptions(watermark, customPath);
+                            return new WatermarkOptions(
+                                await watermarkOverride.IfNoneAsync(watermark),
+                                customPath,
+                                None,
+                                await _imageCache.IsAnimated(customPath));
                         case ChannelWatermarkImageSource.ChannelLogo:
                             Option<string> maybeChannelPath = channel.Artwork
                                 .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
                                 .HeadOrNone()
                                 .Map(a => _imageCache.GetPathForImage(a.Path, ArtworkKind.Logo, Option<int>.None));
-                            return new WatermarkOptions(watermark, maybeChannelPath);
+                            return new WatermarkOptions(
+                                await watermarkOverride.IfNoneAsync(watermark),
+                                maybeChannelPath,
+                                None,
+                                await maybeChannelPath.Match(
+                                    p => _imageCache.IsAnimated(p),
+                                    () => Task.FromResult(false)));
                         default:
                             throw new NotSupportedException("Unsupported watermark image source");
                     }
                 }
             }
 
-            return new WatermarkOptions(None, None);
+            return new WatermarkOptions(None, None, None, false);
         }
-
-        private record WatermarkOptions(Option<ChannelWatermark> Watermark, Option<string> ImagePath);
     }
 }

ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs

@@ -0,0 +1,257 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.Images;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Core.FFmpeg
+{
+    public class SongVideoGenerator : ISongVideoGenerator
+    {
+        private static readonly Random Random = new();
+        private static readonly object RandomLock = new();
+        
+        private readonly ITempFilePool _tempFilePool;
+        private readonly IImageCache _imageCache;
+        private readonly IFFmpegProcessService _ffmpegProcessService;
+
+        public SongVideoGenerator(
+            ITempFilePool tempFilePool,
+            IImageCache imageCache,
+            IFFmpegProcessService ffmpegProcessService)
+        {
+            _tempFilePool = tempFilePool;
+            _imageCache = imageCache;
+            _ffmpegProcessService = ffmpegProcessService;
+        }
+
+        public async Task<Tuple<string, MediaVersion>> GenerateSongVideo(
+            Song song,
+            Channel channel,
+            Option<ChannelWatermark> maybeGlobalWatermark,
+            string ffmpegPath)
+        {
+            Option<string> subtitleFile = None;
+
+            MediaVersion videoVersion = new FallbackMediaVersion
+            {
+                Id = -1,
+                Chapters = new List<MediaChapter>(),
+                Width = 192,
+                Height = 108,
+                SampleAspectRatio = "1:1",
+                Streams = new List<MediaStream>
+                {
+                    new() { MediaStreamKind = MediaStreamKind.Video, Index = 0 }
+                }
+            };
+            
+            string[] backgrounds =
+            {
+                "song_background_1.png",
+                "song_background_2.png",
+                "song_background_3.png"
+            };
+
+            // use random ETV color by default
+            string backgroundPath = Path.Combine(
+                FileSystemLayout.ResourcesCacheFolder,
+                backgrounds[NextRandom(backgrounds.Length)]);
+
+            Option<string> watermarkPath = None;
+
+            var boxBlur = false;
+            
+            const int HORIZONTAL_MARGIN_PERCENT = 3;
+            const int VERTICAL_MARGIN_PERCENT = 5;
+            const int WATERMARK_WIDTH_PERCENT = 25;
+            ChannelWatermarkLocation watermarkLocation = NextRandom(2) == 0
+                ? ChannelWatermarkLocation.BottomLeft
+                : ChannelWatermarkLocation.BottomRight;
+            
+            foreach (SongMetadata metadata in song.SongMetadata)
+            {
+                var fontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 20.0);
+                var largeFontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 10.0);
+                bool detailsStyle = NextRandom(2) == 0;
+                
+                var sb = new StringBuilder();
+
+                if (detailsStyle)
+                {
+                    if (!string.IsNullOrWhiteSpace(metadata.Title))
+                    {
+                        sb.Append($"{{\\fs{largeFontSize}}}{metadata.Title}");
+                    }
+                    
+                    if (!string.IsNullOrWhiteSpace(metadata.Artist))
+                    {
+                        sb.Append($"\\N{{\\fs{fontSize}}}{metadata.Artist}");
+                    }
+                }
+                else
+                {
+                    if (!string.IsNullOrWhiteSpace(metadata.Artist))
+                    {
+                        sb.Append(metadata.Artist);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(metadata.Title))
+                    {
+                        sb.Append($"\\N\"{metadata.Title}\"");
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(metadata.Album))
+                    {
+                        sb.Append($"\\N{metadata.Album}");
+                    }
+                }
+
+                int leftMarginPercent = HORIZONTAL_MARGIN_PERCENT;
+                int rightMarginPercent = HORIZONTAL_MARGIN_PERCENT;
+
+                if (metadata.Artwork.Any(a => a.ArtworkKind == ArtworkKind.Thumbnail))
+                {
+                    switch (watermarkLocation)
+                    {
+                        case ChannelWatermarkLocation.BottomLeft:
+                            leftMarginPercent += WATERMARK_WIDTH_PERCENT + HORIZONTAL_MARGIN_PERCENT;
+                            break;
+                        case ChannelWatermarkLocation.BottomRight:
+                            leftMarginPercent = rightMarginPercent = HORIZONTAL_MARGIN_PERCENT;
+                            rightMarginPercent += WATERMARK_WIDTH_PERCENT + HORIZONTAL_MARGIN_PERCENT;
+                            break;
+                    }
+                }
+
+                var leftMargin = (int)Math.Round(leftMarginPercent / 100.0 * channel.FFmpegProfile.Resolution.Width);
+                var rightMargin = (int)Math.Round(rightMarginPercent / 100.0 * channel.FFmpegProfile.Resolution.Width);
+                var verticalMargin = (int)Math.Round(VERTICAL_MARGIN_PERCENT / 100.0 * channel.FFmpegProfile.Resolution.Height);
+
+                subtitleFile = await new SubtitleBuilder(_tempFilePool)
+                    .WithResolution(channel.FFmpegProfile.Resolution)
+                    .WithFontName("OPTIKabel-Heavy")
+                    .WithFontSize(fontSize)
+                    .WithPrimaryColor("&HFFFFFF")
+                    .WithOutlineColor("&H444444")
+                    .WithAlignment(0)
+                    .WithMarginRight(rightMargin)
+                    .WithMarginLeft(leftMargin)
+                    .WithMarginV(verticalMargin)
+                    .WithBorderStyle(1)
+                    .WithShadow(3)
+                    .WithFormattedContent(sb.ToString())
+                    .BuildFile();
+                
+                // use thumbnail (cover art) if present
+                foreach (Artwork artwork in Optional(
+                    metadata.Artwork.Find(a => a.ArtworkKind == ArtworkKind.Thumbnail)))
+                {
+                    // signal that we want to use cover art as watermark
+                    videoVersion = new CoverArtMediaVersion
+                    {
+                        Chapters = new List<MediaChapter>(),
+                        // always stretch cover art
+                        Width = 192,
+                        Height = 108,
+                        SampleAspectRatio = "1:1",
+                        Streams = new List<MediaStream>
+                        {
+                            new() { MediaStreamKind = MediaStreamKind.Video, Index = 0 }
+                        }
+                    };
+
+                    string customPath = _imageCache.GetPathForImage(
+                        artwork.Path,
+                        ArtworkKind.Thumbnail,
+                        Option<int>.None);
+                    
+                    watermarkPath = customPath;
+
+                    // randomize selected blur hash
+                    var hashes = new List<string>
+                    {
+                        artwork.BlurHash43,
+                        artwork.BlurHash54,
+                        artwork.BlurHash64
+                    }.Filter(s => !string.IsNullOrWhiteSpace(s)).ToList();
+
+                    if (hashes.Any())
+                    {
+                        string hash = hashes[NextRandom(hashes.Count)];
+                        
+                        backgroundPath = await _imageCache.WriteBlurHash(
+                            hash,
+                            channel.FFmpegProfile.Resolution);
+
+                        videoVersion.Height = channel.FFmpegProfile.Resolution.Height;
+                        videoVersion.Width = channel.FFmpegProfile.Resolution.Width;
+                    }
+                    else
+                    {
+                        backgroundPath = customPath;
+                        boxBlur = true;
+                    }
+                }
+            }
+
+            string videoPath = backgroundPath;
+
+            videoVersion.MediaFiles = new List<MediaFile>
+            {
+                new() { Path = videoPath }
+            };
+
+            Either<BaseError, string> maybeSongImage = await _ffmpegProcessService.GenerateSongImage(
+                ffmpegPath,
+                subtitleFile,
+                channel,
+                maybeGlobalWatermark,
+                videoVersion,
+                videoPath,
+                boxBlur,
+                watermarkPath,
+                watermarkLocation,
+                HORIZONTAL_MARGIN_PERCENT,
+                VERTICAL_MARGIN_PERCENT,
+                WATERMARK_WIDTH_PERCENT);
+
+            foreach (string si in maybeSongImage.RightToSeq())
+            {
+                videoPath = si;
+                videoVersion = new BackgroundImageMediaVersion
+                {
+                    Chapters = new List<MediaChapter>(),
+                    // song image has been pre-generated with correct size
+                    Height = channel.FFmpegProfile.Resolution.Height,
+                    Width = channel.FFmpegProfile.Resolution.Width,
+                    SampleAspectRatio = "1:1",
+                    Streams = new List<MediaStream>
+                    {
+                        new() { MediaStreamKind = MediaStreamKind.Video, Index = 0 },
+                    },
+                    MediaFiles = new List<MediaFile>
+                    {
+                        new() { Path = si }
+                    }
+                };
+            }
+
+            return Tuple(videoPath, videoVersion);
+        }
+        
+        private static int NextRandom(int max)
+        {
+            lock (RandomLock)
+            {
+                return Random.Next() % max;
+            }
+        }
+    }
+}

ErsatzTV.Core/FFmpeg/SubtitleBuilder.cs

@@ -0,0 +1,138 @@
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Core.FFmpeg
+{
+    public class SubtitleBuilder
+    {
+        private readonly ITempFilePool _tempFilePool;
+        private string _content;
+        private Option<IDisplaySize> _resolution = None;
+        private Option<string> _fontName;
+        private Option<int> _fontSize;
+        private Option<string> _primaryColor;
+        private Option<string> _outlineColor;
+        private Option<int> _alignment;
+        private int _marginRight;
+        private int _marginLeft;
+        private int _marginV;
+        private Option<int> _borderStyle;
+        private Option<int> _shadow;
+
+        public SubtitleBuilder(ITempFilePool tempFilePool)
+        {
+            _tempFilePool = tempFilePool;
+        }
+
+        public SubtitleBuilder WithResolution(IDisplaySize resolution)
+        {
+            _resolution = Some(resolution);
+            return this;
+        }
+
+        public SubtitleBuilder WithFontName(string fontName)
+        {
+            _fontName = fontName;
+            return this;
+        }
+
+        public SubtitleBuilder WithFontSize(int fontSize)
+        {
+            _fontSize = fontSize;
+            return this;
+        }
+
+        public SubtitleBuilder WithPrimaryColor(string primaryColor)
+        {
+            _primaryColor = primaryColor;
+            return this;
+        }
+
+        public SubtitleBuilder WithOutlineColor(string outlineColor)
+        {
+            _outlineColor = outlineColor;
+            return this;
+        }
+
+        public SubtitleBuilder WithAlignment(int alignment)
+        {
+            _alignment = alignment;
+            return this;
+        }
+
+        public SubtitleBuilder WithMarginRight(int marginRight)
+        {
+            _marginRight = marginRight;
+            return this;
+        }
+
+        public SubtitleBuilder WithMarginLeft(int marginLeft)
+        {
+            _marginLeft = marginLeft;
+            return this;
+        }
+        
+        public SubtitleBuilder WithMarginV(int marginV)
+        {
+            _marginV = marginV;
+            return this;
+        }
+
+        public SubtitleBuilder WithBorderStyle(int borderStyle)
+        {
+            _borderStyle = borderStyle;
+            return this;
+        }
+
+        public SubtitleBuilder WithShadow(int shadow)
+        {
+            _shadow = shadow;
+            return this;
+        }
+
+        public SubtitleBuilder WithFormattedContent(string content)
+        {
+            _content = content;
+            return this;
+        }
+        
+        public async Task<string> BuildFile()
+        {
+            string fileName = _tempFilePool.GetNextTempFile(TempFileCategory.Subtitle);
+
+            var sb = new StringBuilder();
+            sb.AppendLine("[Script Info]");
+            sb.AppendLine("ScriptType: v4.00+");
+            sb.AppendLine("WrapStyle: 0");
+            sb.AppendLine("ScaledBorderAndShadow: yes");
+            sb.AppendLine("YCbCr Matrix: None");
+
+            foreach (IDisplaySize resolution in _resolution)
+            {
+                sb.AppendLine($"PlayResX: {resolution.Width}");
+                sb.AppendLine($"PlayResY: {resolution.Height}");
+            }
+
+            sb.AppendLine("[V4+ Styles]");
+            sb.AppendLine("Format: Name, Fontname, Fontsize, PrimaryColour, OutlineColour, BorderStyle, Outline, Shadow, Alignment, Encoding");
+            sb.AppendLine($"Style: Default,{await _fontName.IfNoneAsync("")},{await _fontSize.IfNoneAsync(32)},{await _primaryColor.IfNoneAsync("")},{await _outlineColor.IfNoneAsync("")},{await _borderStyle.IfNoneAsync(0)},1,{await _shadow.IfNoneAsync(0)},{await _alignment.IfNoneAsync(0)},1");
+
+            sb.AppendLine("[Events]");
+            sb.AppendLine("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text");
+            sb.AppendLine($"Dialogue: 0,0:00:00.00,99:99:99.99,Default,,{_marginLeft},{_marginRight},{_marginV},,{_content}");
+
+            if (!string.IsNullOrWhiteSpace(_content))
+            {
+                sb.AppendLine(_content);
+            }
+
+            await File.WriteAllTextAsync(fileName, sb.ToString());
+
+            return fileName;
+        }
+    }
+}

ErsatzTV.Core/FFmpeg/TempFileCategory.cs

@@ -0,0 +1,10 @@
+namespace ErsatzTV.Core.FFmpeg
+{
+    public enum TempFileCategory
+    {
+        Subtitle = 0,
+        SongBackground = 1,
+        CoverArt = 2,
+        CachedArtwork = 3
+    }
+}

ErsatzTV.Core/FFmpeg/TempFilePool.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.IO;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+
+namespace ErsatzTV.Core.FFmpeg
+{
+    public class TempFilePool : ITempFilePool
+    {
+        private const int ItemLimit = 10;
+        private readonly Dictionary<TempFileCategory, int> _state = new();
+        private readonly object _lock = new();
+
+        public string GetNextTempFile(TempFileCategory category)
+        {
+            lock (_lock)
+            {
+                var index = 0;
+
+                if (_state.TryGetValue(category, out int current))
+                {
+                    index = (current + 1) % ItemLimit;
+                }
+
+                _state[category] = index;
+
+                return GetFileName(category, index);
+            }
+        }
+
+        private static string GetFileName(TempFileCategory category, int index)
+        {
+            return Path.Combine(FileSystemLayout.TempFilePoolFolder, $"{category}_{index}".ToLowerInvariant());
+        }
+    }
+}

ErsatzTV.Core/FFmpeg/WatermarkOptions.cs

@@ -0,0 +1,11 @@
+using ErsatzTV.Core.Domain;
+using LanguageExt;
+
+namespace ErsatzTV.Core.FFmpeg
+{
+    public record WatermarkOptions(
+        Option<ChannelWatermark> Watermark,
+        Option<string> ImagePath,
+        Option<int> ImageStreamIndex,
+        bool IsAnimated);
+}