update changelog for release v0.5.1-beta [no ci]

* fix subtitles using software encoders

* videotoolbox fixes

* fix some vaapi subtitle edge cases

.github/workflows/artifacts.yml

@@ -51,6 +51,16 @@ jobs:
         with:
           dotnet-version: 6.0.x
 
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+
+      - name: Cache NPM dependencies
+        uses: bahmutov/npm-install@v1.4.5
+        with:
+          working-directory: ErsatzTV/client-app
+
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
 
@@ -104,9 +114,9 @@ jobs:
       - name: Notarize
         shell: bash
         run: |
-          brew tap mitchellh/gon
-          brew install mitchellh/gon/gon
-          gon -log-level=debug -log-json ./gon.json
+          curl -o gon.zip -L -s "https://github.com/mitchellh/gon/releases/latest/download/gon_macos.zip"
+          unzip -o -q gon.zip
+          ./gon -log-level=debug -log-json ./gon.json
         env:
           AC_USERNAME: ${{ secrets.ac_username }}
           AC_PASSWORD: ${{ secrets.ac_password }}
@@ -166,6 +176,16 @@ jobs:
         with:
           dotnet-version: 6.0.x
 
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+
+      - name: Cache NPM dependencies
+        uses: bahmutov/npm-install@v1.4.5
+        with:
+          working-directory: ErsatzTV/client-app
+
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
 

.github/workflows/ci.yml

@@ -19,14 +19,14 @@ jobs:
           tag=$(git describe --tags --abbrev=0)
           tag2="${tag:1}"
           short=$(git rev-parse --short HEAD)
-          final="${tag2/alpha/$short}"
+          final="${tag2/beta/$short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
       - name: Extract Artifacts Version
         shell: bash
         run: |
           tag=$(git describe --tags --abbrev=0)
           short=$(git rev-parse --short HEAD)
-          final="${tag/alpha/$short}"
+          final="${tag/beta/$short}"
           echo "ARTIFACTS_VERSION=${final}" >> $GITHUB_ENV
           echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
     outputs:

.github/workflows/release.yml

@@ -16,7 +16,7 @@ jobs:
         run: |
           tag=$(git describe --tags --abbrev=0)
           echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
-          echo "DOCKER_TAG=${tag/-alpha/}" >> $GITHUB_ENV
+          echo "DOCKER_TAG=${tag/-beta/}" >> $GITHUB_ENV
       - name: Extract Artifacts Version
         shell: bash
         run: |

.github/workflows/vue-lint.yml

@@ -0,0 +1,22 @@
+name: Lint VueJS Files on PR Request
+on:
+  pull_request:
+jobs:
+  vue-lint:
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout the current repo
+      - name: Checkout current repository
+        uses: actions/checkout@v2
+      # Setup NodeJS version 14  
+      - name: Setup NodeJS V14.x.x
+        uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+      # CD into the current client directory and lint and build the client
+      - name: Lint and Build the client  
+        run: |
+          cd ./ErsatzTV/client-app/
+          npm ci --no-optional
+          npm run lint
+          npm run build --if-present

.gitignore

@@ -43,3 +43,4 @@ scripts/generate-api-sdk/swagger.json
 
 docker-compose.override.yml
 
+ErsatzTV/wwwroot/v2/

CHANGELOG.md

@@ -5,6 +5,80 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [0.5.1-beta] - 2022-04-17
+### Fixed
+- Fix subtitles edge case with NVENC
+- Only select picture subtitles (text subtitles are not yet supported)
+  - Supported picture subtitles are `hdmv_pgs_subtitle` and `dvd_subtitle`
+- Fix subtitles using software encoders, videotoolbox, VAAPI
+- Fix setting VAAPI driver name
+- Fix ffmpeg troubleshooting reports
+- Fix bug where filler would behave as if it were configured to pad even though a different mode was selected
+- Fix bug where mid-roll count filler would skip scheduling the final chapter in an episode 
+
+### Added
+- Add `Empty Trash` button to `Trash` page
+
+## [0.5.0-beta] - 2022-04-13
+### Fixed
+- Fix `HLS Segmenter` bug where it would drift off of the schedule if a playout was changed while the segmenter was running
+- Ensure clients that use HDHomeRun emulation (like Plex) always get an `MPEG-TS` stream, regardless of the configured streaming mode
+- Fix scheduling bug that caused some days to be skipped when fixed start times were used with fallback filler
+
+### Added
+- Add `Preferred Subtitle Language` and `Subtitle Mode` to channel settings
+  - `Preferred Subtitle Language` will filter all subtitle streams based on language
+  - `Subtitle Mode` will further filter subtitle streams based on attributes (forced, default)
+  - If picture-based subtitles are found after filtering, they will be burned into the video stream
+- Detect non-zero ffmpeg exit code from `HLS Segmenter` and `MPEG-TS`, log error output and display error output on stream
+- Add `Watermark` setting to schedule items; this allows override the channel watermark. Watermark priority is:
+  - Schedule Item
+  - Channel
+  - Global
+
+### Changed
+- Remove legacy transcoder logic option; all channels will use the new transcoder logic
+- Renamed channel setting `Preferred Language` to `Preferred Audio Language`
+- Reworked playout build logic to maintain collection progress in some scenarios. There are now three build modes:
+  - `Continue` - add new items to the end of an existing playout
+    - This mode is used when playouts are automatically extended in the background
+  - `Refresh` - this mode will try to maintain collection progress while rebuilding the entire playout
+    - This mode is used when a schedule is updated, or when collection modifications trigger a playout rebuild
+  - `Reset` - this mode will rebuild the entire playout and will NOT maintain progress
+    - This mode is only used when the `Reset Playout` button is clicked on the Playouts page
+  - **This requires rebuilding all playouts, which will happen on startup after upgrading**
+- Use ffmpeg to resize images; this should help reduce ErsatzTV's memory use
+- Use ffprobe to check for animated logos and watermarks; this should help reduce ErsatzTV's memory use
+- Allow two decimals in channel numbers (e.g. `5.73`)
+
+## [0.4.5-alpha] - 2022-03-29
+### Fixed
+- Fix streaming mode inconsistencies when `mode` parameter is unspecified
+- Fix startup on Windows 7
+
+### Added
+- Add option to automatically deinterlace video when transcoding
+  - Previously, this was always enabled; the purpose of the option is to allow disabling any deinterlace filters
+  - Note that there is no performance gain to disabling the option with progressive content; filters are only ever applied to interlaced content
+
+### Changed
+- Change FFmpeg Profile video codec and audio codec text fields to select fields
+  - The appropriate video encoder will be determined based on the video format and hardware acceleration selections
+- Remove FFmpeg Profile `Transcode`, `Normalize Video` and `Normalize Audio` settings
+  - All content will be transcoded and have audio and video normalized
+  - The only exception to this rule is `HLS Direct` streaming mode, which directly copies video and audio streams
+- Always try to connect to Plex at `http://localhost:32400` even if that address isn't advertised by the Plex API
+  - If Plex isn't on the localhost, all other addresses will be checked as with previous releases
+
+## [0.4.4-alpha] - 2022-03-10
+### Fixed
+- Fix `HLS Direct` streaming mode
+- Fix bug with `HLS Segmenter` (and `MPEG-TS`) on Windows that caused errors at program boundaries
+
+### Added
+- Perform additional duration analysis on files with missing duration metadata
+- Add `nouveau` VAAPI driver option
+
 ## [0.4.3-alpha] - 2022-03-05
 ### Fixed
 - Fix song sorting with `Chronological` and `Shuffle In Order` playback orders
@@ -1008,7 +1082,11 @@ 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.4.3-alpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.1-beta...HEAD
+[0.5.1-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.0-beta...v0.5.1-beta
+[0.5.0-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.5-alpha...v0.5.0-beta
+[0.4.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.4-alpha...v0.4.5-alpha
+[0.4.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.3-alpha...v0.4.4-alpha
 [0.4.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.2-alpha...v0.4.3-alpha
 [0.4.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.1-alpha...v0.4.2-alpha
 [0.4.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.0-alpha...v0.4.1-alpha

ErsatzTV-Windows/ErsatzTV-Windows.csproj

@@ -17,7 +17,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="Asmichi.ChildProcess" Version="0.11.0" />
+      <PackageReference Include="CliWrap" Version="3.4.2" />
     </ItemGroup>
 
     <ItemGroup>

ErsatzTV-Windows/TrayApplicationContext.cs

@@ -1,14 +1,13 @@
 using ErsatzTV.Core;
 using System.Diagnostics;
-using Asmichi.ProcessManagement;
-using System.Reflection;
+using CliWrap;
 
 namespace ErsatzTV_Windows;
 
 public class TrayApplicationContext : ApplicationContext
 {
     private readonly NotifyIcon _trayIcon;
-    private readonly IChildProcess? _childProcess;
+    private readonly CancellationTokenSource _tokenSource;
 
     public TrayApplicationContext()
     {
@@ -19,6 +18,8 @@ public class TrayApplicationContext : ApplicationContext
             Visible = true
         };
 
+        _tokenSource = new CancellationTokenSource();
+
         AddMenuItem("Launch Web UI", LaunchWebUI);
         AddMenuItem("Show Logs", ShowLogs);
         _trayIcon.ContextMenuStrip.Items.Add(new ToolStripSeparator());
@@ -29,8 +30,11 @@ public class TrayApplicationContext : ApplicationContext
 
         if (File.Exists(exe))
         {
-            var si = new ChildProcessStartInfo(exe);
-            _childProcess = ChildProcess.Start(si);
+
+            Cli.Wrap(exe)
+                .WithWorkingDirectory(folder)
+                .WithValidation(CommandResultValidation.None)
+                .ExecuteAsync(_tokenSource.Token);
         }
     }
 
@@ -64,7 +68,7 @@ public class TrayApplicationContext : ApplicationContext
 
     protected override void Dispose(bool disposing)
     {
-        _childProcess?.Dispose();
+        _tokenSource?.Cancel();
         base.Dispose(disposing);
     }
 

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -10,8 +10,10 @@ public record ChannelViewModel(
     string Categories,
     int FFmpegProfileId,
     string Logo,
-    string PreferredLanguageCode,
+    string PreferredAudioLanguageCode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
-    int PlayoutCount);
+    int PlayoutCount,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode);

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -11,7 +11,9 @@ public record CreateChannel
     string Categories,
     int FFmpegProfileId,
     string Logo,
-    string PreferredLanguageCode,
+    string PreferredAudioLanguageCode,
     StreamingMode StreamingMode,
     int? WatermarkId,
-    int? FallbackFillerId) : IRequest<Either<BaseError, CreateChannelResult>>;
+    int? FallbackFillerId,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode) : IRequest<Either<BaseError, CreateChannelResult>>;

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -21,7 +21,7 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => PersistChannel(dbContext, c));
+        return await validation.Apply(c => PersistChannel(dbContext, c));
     }
 
     private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
@@ -34,11 +34,19 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
     private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
         (ValidateName(request), await ValidateNumber(dbContext, request),
             await FFmpegProfileMustExist(dbContext, request),
-            ValidatePreferredLanguage(request),
+            ValidatePreferredAudioLanguage(request),
+            ValidatePreferredSubtitleLanguage(request),
             await WatermarkMustExist(dbContext, request),
             await FillerPresetMustExist(dbContext, request))
         .Apply(
-            (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId, fillerPresetId) =>
+            (
+                name,
+                number,
+                ffmpegProfileId,
+                preferredAudioLanguageCode,
+                preferredSubtitleLanguageCode,
+                watermarkId,
+                fillerPresetId) =>
             {
                 var artwork = new List<Artwork>();
                 if (!string.IsNullOrWhiteSpace(request.Logo))
@@ -62,7 +70,9 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
                     FFmpegProfileId = ffmpegProfileId,
                     StreamingMode = request.StreamingMode,
                     Artwork = artwork,
-                    PreferredLanguageCode = preferredLanguageCode
+                    PreferredAudioLanguageCode = preferredAudioLanguageCode,
+                    PreferredSubtitleLanguageCode = preferredSubtitleLanguageCode,
+                    SubtitleMode = request.SubtitleMode
                 };
 
                 foreach (int id in watermarkId)
@@ -82,12 +92,19 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
         createChannel.NotEmpty(c => c.Name)
             .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
 
-    private static Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
-        Optional(createChannel.PreferredLanguageCode ?? string.Empty)
+    private static Validation<BaseError, string> ValidatePreferredAudioLanguage(CreateChannel createChannel) =>
+        Optional(createChannel.PreferredAudioLanguageCode ?? string.Empty)
             .Filter(
                 lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
                     ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-            .ToValidation<BaseError>("Preferred language code is invalid");
+            .ToValidation<BaseError>("Preferred audio language code is invalid");
+
+    private static Validation<BaseError, string> ValidatePreferredSubtitleLanguage(CreateChannel createChannel) =>
+        Optional(createChannel.PreferredSubtitleLanguageCode ?? string.Empty)
+            .Filter(
+                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+            .ToValidation<BaseError>("Preferred subtitle language code is invalid");
 
     private static async Task<Validation<BaseError, string>> ValidateNumber(TvContext dbContext, CreateChannel createChannel)
     {
@@ -102,7 +119,7 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
                     return createChannel.Number;
                 }
 
-                return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
+                return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
             });
     }
 

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -12,7 +12,9 @@ public record UpdateChannel
     string Categories,
     int FFmpegProfileId,
     string Logo,
-    string PreferredLanguageCode,
+    string PreferredAudioLanguageCode,
     StreamingMode StreamingMode,
     int? WatermarkId,
-    int? FallbackFillerId) : IRequest<Either<BaseError, ChannelViewModel>>;
+    int? FallbackFillerId,
+    string PreferredSubtitleLanguageCode,
+    ChannelSubtitleMode SubtitleMode) : IRequest<Either<BaseError, ChannelViewModel>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -32,7 +32,9 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
         c.Group = update.Group;
         c.Categories = update.Categories;
         c.FFmpegProfileId = update.FFmpegProfileId;
-        c.PreferredLanguageCode = update.PreferredLanguageCode;
+        c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
+        c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
+        c.SubtitleMode = update.SubtitleMode;
         c.Artwork ??= new List<Artwork>();
 
         if (!string.IsNullOrWhiteSpace(update.Logo))
@@ -69,7 +71,7 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
     private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
         (await ChannelMustExist(dbContext, request), ValidateName(request),
             await ValidateNumber(dbContext, request),
-            ValidatePreferredLanguage(request))
+            ValidatePreferredAudioLanguage(request))
         .Apply((channelToUpdate, _, _, _) => channelToUpdate);
 
     private static Task<Validation<BaseError, Channel>> ChannelMustExist(
@@ -100,16 +102,16 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
                 return updateChannel.Number;
             }
 
-            return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
+            return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
         }
 
         return BaseError.New("Channel number must be unique");
     }
 
-    private static Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
-        Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
+    private static Validation<BaseError, string> ValidatePreferredAudioLanguage(UpdateChannel updateChannel) =>
+        Optional(updateChannel.PreferredAudioLanguageCode ?? string.Empty)
             .Filter(
                 lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
                     ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-            .ToValidation<BaseError>("Preferred language code is invalid");
+            .ToValidation<BaseError>("Preferred audio language code is invalid");
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
@@ -13,17 +14,34 @@ internal static class Mapper
             channel.Categories,
             channel.FFmpegProfileId,
             GetLogo(channel),
-            channel.PreferredLanguageCode,
+            channel.PreferredAudioLanguageCode,
             channel.StreamingMode,
             channel.WatermarkId,
             channel.FallbackFillerId,
-            channel.Playouts?.Count ?? 0);
+            channel.Playouts?.Count ?? 0,
+            channel.PreferredSubtitleLanguageCode,
+            channel.SubtitleMode);
+
+    internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
+        new(
+            channel.Id,
+            channel.Number,
+            channel.Name,
+            channel.FFmpegProfile.Name,
+            channel.PreferredAudioLanguageCode,
+            GetStreamingMode(channel));
 
     private static string GetLogo(Channel channel) =>
         Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
             .Match(a => a.Path, string.Empty);
 
-    private static string GetWatermark(Channel channel) =>
-        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Watermark))
-            .Match(a => a.Path, string.Empty);
+    private static string GetStreamingMode(Channel channel) =>
+        channel.StreamingMode switch
+        {
+            StreamingMode.TransportStream => "MPEG-TS (Legacy)",
+            StreamingMode.TransportStreamHybrid => "MPEG-TS",
+            StreamingMode.HttpLiveStreamingDirect => "HLS Direct",
+            StreamingMode.HttpLiveStreamingSegmenter => "HLS Segmenter",
+            _ => throw new ArgumentOutOfRangeException()
+        };
 }

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Channels;
+
+namespace ErsatzTV.Application.Channels;
+
+public record GetAllChannelsForApi : IRequest<List<ChannelResponseModel>>;

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

@@ -0,0 +1,21 @@
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using static ErsatzTV.Application.Channels.Mapper;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetAllChannelsForApiHandler : IRequestHandler<GetAllChannelsForApi, List<ChannelResponseModel>>
+{
+    private readonly IChannelRepository _channelRepository;
+
+    public GetAllChannelsForApiHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+
+    public async Task<List<ChannelResponseModel>> Handle(
+        GetAllChannelsForApi request,
+        CancellationToken cancellationToken)
+    {
+        IEnumerable<Channel> channels = Optional(await _channelRepository.GetAll()).Flatten();
+        return channels.Map(ProjectToResponseModel).ToList();
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelByNumber.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelByNumber(string ChannelNumber) : IRequest<Option<ChannelViewModel>>;

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

@@ -0,0 +1,14 @@
+using ErsatzTV.Core.Interfaces.Repositories;
+using static ErsatzTV.Application.Channels.Mapper;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelByNumberHandler : IRequestHandler<GetChannelByNumber, Option<ChannelViewModel>>
+{
+    private readonly IChannelRepository _channelRepository;
+
+    public GetChannelByNumberHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+
+    public Task<Option<ChannelViewModel>> Handle(GetChannelByNumber request, CancellationToken cancellationToken) =>
+        _channelRepository.GetByNumber(request.ChannelNumber).MapT(ProjectToViewModel);
+}

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs

@@ -3,13 +3,13 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Configuration;
 
-public class
-    UpdatePlayoutDaysToBuildHandler : MediatR.IRequestHandler<UpdatePlayoutDaysToBuild, Either<BaseError, Unit>>
+public class UpdatePlayoutDaysToBuildHandler : IRequestHandler<UpdatePlayoutDaysToBuild, Either<BaseError, Unit>>
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
@@ -37,16 +37,16 @@ public class
     private async Task<Unit> ApplyUpdate(TvContext dbContext, int daysToBuild)
     {
         await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, daysToBuild);
-            
-        // build all playouts to proper number of days
+
+        // continue all playouts to proper number of days
         List<Playout> playouts = await dbContext.Playouts
             .Include(p => p.Channel)
             .ToListAsync();
         foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)).Map(p => p.Id))
         {
-            await _workerChannel.WriteAsync(new BuildPlayout(playoutId));
+            await _workerChannel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Continue));
         }
-            
+
         return Unit.Default;
     }
 

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs

@@ -70,6 +70,7 @@ public class SynchronizeEmbyLibraryByIdHandler :
                         parameters.ConnectionParameters.ActiveConnection.Address,
                         parameters.ConnectionParameters.ApiKey,
                         parameters.Library,
+                        parameters.FFmpegPath,
                         parameters.FFprobePath);
                     break;
                 case LibraryMediaKind.Shows:
@@ -77,6 +78,7 @@ public class SynchronizeEmbyLibraryByIdHandler :
                         parameters.ConnectionParameters.ActiveConnection.Address,
                         parameters.ConnectionParameters.ApiKey,
                         parameters.Library,
+                        parameters.FFmpegPath,
                         parameters.FFprobePath);
                     break;
             }
@@ -98,15 +100,17 @@ public class SynchronizeEmbyLibraryByIdHandler :
     private async Task<Validation<BaseError, RequestParameters>> Validate(
         ISynchronizeEmbyLibraryById request) =>
         (await ValidateConnection(request), await EmbyLibraryMustExist(request),
-            await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
+            await ValidateLibraryRefreshInterval(), await ValidateFFmpegPath(), await ValidateFFprobePath())
         .Apply(
-            (connectionParameters, embyLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
-                connectionParameters,
-                embyLibrary,
-                request.ForceScan,
-                libraryRefreshInterval,
-                ffprobePath
-            ));
+            (connectionParameters, embyLibrary, libraryRefreshInterval, ffmpegPath, ffprobePath) =>
+                new RequestParameters(
+                    connectionParameters,
+                    embyLibrary,
+                    request.ForceScan,
+                    libraryRefreshInterval,
+                    ffmpegPath,
+                    ffprobePath
+                ));
 
     private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
         ISynchronizeEmbyLibraryById request) =>
@@ -149,6 +153,13 @@ public class SynchronizeEmbyLibraryByIdHandler :
             .FilterT(lri => lri > 0)
             .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
 
+    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, string>> ValidateFFprobePath() =>
         _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
             .FilterT(File.Exists)
@@ -161,6 +172,7 @@ public class SynchronizeEmbyLibraryByIdHandler :
         EmbyLibrary Library,
         bool ForceScan,
         int LibraryRefreshInterval,
+        string FFmpegPath,
         string FFprobePath);
 
     private record ConnectionParameters(

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -7,7 +7,8 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Bugsnag" Version="3.0.0" />
+      <PackageReference Include="Bugsnag" Version="3.0.1" />
+      <PackageReference Include="CliWrap" Version="3.4.2" />
       <PackageReference Include="MediatR" Version="10.0.1" />
       <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
       <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.1.46">

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -7,20 +7,18 @@ namespace ErsatzTV.Application.FFmpegProfiles;
 public record CreateFFmpegProfile(
     string Name,
     int ThreadCount,
-    bool Transcode,
     HardwareAccelerationKind HardwareAcceleration,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     int ResolutionId,
-    bool NormalizeVideo,
-    string VideoCodec,
+    FFmpegProfileVideoFormat VideoFormat,
     int VideoBitrate,
     int VideoBufferSize,
-    string AudioCodec,
+    FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
     bool NormalizeLoudness,
     int AudioChannels,
     int AudioSampleRate,
-    bool NormalizeAudio,
-    bool NormalizeFramerate) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;
+    bool NormalizeFramerate,
+    bool DeinterlaceVideo) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -18,9 +18,9 @@ public class CreateFFmpegProfileHandler :
         CreateFFmpegProfile request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, profile => PersistFFmpegProfile(dbContext, profile));
+        return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
     }
 
     private static async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
@@ -39,23 +39,21 @@ public class CreateFFmpegProfileHandler :
             {
                 Name = name,
                 ThreadCount = threadCount,
-                Transcode = request.Transcode,
                 HardwareAcceleration = request.HardwareAcceleration,
                 VaapiDriver = request.VaapiDriver,
                 VaapiDevice = request.VaapiDevice,
                 ResolutionId = resolutionId,
-                NormalizeVideo = request.NormalizeVideo,
-                VideoCodec = request.VideoCodec,
+                VideoFormat = request.VideoFormat,
                 VideoBitrate = request.VideoBitrate,
                 VideoBufferSize = request.VideoBufferSize,
-                AudioCodec = request.AudioCodec,
+                AudioFormat = request.AudioFormat,
                 AudioBitrate = request.AudioBitrate,
                 AudioBufferSize = request.AudioBufferSize,
                 NormalizeLoudness = request.NormalizeLoudness,
                 AudioChannels = request.AudioChannels,
                 AudioSampleRate = request.AudioSampleRate,
-                NormalizeAudio = request.NormalizeAudio,
-                NormalizeFramerate = request.NormalizeFramerate
+                NormalizeFramerate = request.NormalizeFramerate,
+                DeinterlaceVideo = request.DeinterlaceVideo
             });
 
     private static Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -8,20 +8,18 @@ public record UpdateFFmpegProfile(
     int FFmpegProfileId,
     string Name,
     int ThreadCount,
-    bool Transcode,
     HardwareAccelerationKind HardwareAcceleration,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     int ResolutionId,
-    bool NormalizeVideo,
-    string VideoCodec,
+    FFmpegProfileVideoFormat VideoFormat,
     int VideoBitrate,
     int VideoBufferSize,
-    string AudioCodec,
+    FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
     bool NormalizeLoudness,
     int AudioChannels,
     int AudioSampleRate,
-    bool NormalizeAudio,
-    bool NormalizeFramerate) : IRequest<Either<BaseError, UpdateFFmpegProfileResult>>;
+    bool NormalizeFramerate,
+    bool DeinterlaceVideo) : IRequest<Either<BaseError, UpdateFFmpegProfileResult>>;

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -18,9 +18,9 @@ public class
         UpdateFFmpegProfile request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, p => ApplyUpdateRequest(dbContext, p, request));
+        return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request));
     }
 
     private async Task<UpdateFFmpegProfileResult> ApplyUpdateRequest(
@@ -30,23 +30,21 @@ public class
     {
         p.Name = update.Name;
         p.ThreadCount = update.ThreadCount;
-        p.Transcode = update.Transcode;
         p.HardwareAcceleration = update.HardwareAcceleration;
         p.VaapiDriver = update.VaapiDriver;
         p.VaapiDevice = update.VaapiDevice;
         p.ResolutionId = update.ResolutionId;
-        p.NormalizeVideo = update.Transcode && update.NormalizeVideo;
-        p.VideoCodec = update.VideoCodec;
+        p.VideoFormat = update.VideoFormat;
         p.VideoBitrate = update.VideoBitrate;
         p.VideoBufferSize = update.VideoBufferSize;
-        p.AudioCodec = update.AudioCodec;
+        p.AudioFormat = update.AudioFormat;
         p.AudioBitrate = update.AudioBitrate;
         p.AudioBufferSize = update.AudioBufferSize;
-        p.NormalizeLoudness = update.Transcode && update.NormalizeLoudness;
+        p.NormalizeLoudness = update.NormalizeLoudness;
         p.AudioChannels = update.AudioChannels;
         p.AudioSampleRate = update.AudioSampleRate;
-        p.NormalizeAudio = update.Transcode && update.NormalizeAudio;
-        p.NormalizeFramerate = update.Transcode && update.NormalizeFramerate;
+        p.NormalizeFramerate = update.NormalizeFramerate;
+        p.DeinterlaceVideo = update.DeinterlaceVideo;
         await dbContext.SaveChangesAsync();
         return new UpdateFFmpegProfileResult(p.Id);
     }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -6,7 +6,7 @@ using ErsatzTV.Core.Interfaces.Repositories;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public class UpdateFFmpegSettingsHandler : MediatR.IRequestHandler<UpdateFFmpegSettings, Either<BaseError, Unit>>
+public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings, Either<BaseError, Unit>>
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly ILocalFileSystem _localFileSystem;
@@ -81,13 +81,9 @@ public class UpdateFFmpegSettingsHandler : MediatR.IRequestHandler<UpdateFFmpegS
             Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
         }
 
-        await _configElementRepository.Upsert(
-            ConfigElementKey.FFmpegUseLegacyTranscoder,
-            request.Settings.UseLegacyTranscoder.ToString());
-
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegPreferredLanguageCode,
-            request.Settings.PreferredLanguageCode);
+            request.Settings.PreferredAudioLanguageCode);
 
         if (request.Settings.GlobalWatermarkId is not null)
         {

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -8,20 +8,18 @@ public record FFmpegProfileViewModel(
     int Id,
     string Name,
     int ThreadCount,
-    bool Transcode,
     HardwareAccelerationKind HardwareAcceleration,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     ResolutionViewModel Resolution,
-    bool NormalizeVideo,
-    string VideoCodec,
+    FFmpegProfileVideoFormat VideoFormat,
     int VideoBitrate,
     int VideoBufferSize,
-    string AudioCodec,
+    FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,
     bool NormalizeLoudness,
     int AudioChannels,
     int AudioSampleRate,
-    bool NormalizeAudio,
-    bool NormalizeFramerate);
+    bool NormalizeFramerate,
+    bool DeinterlaceVideo);

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -5,12 +5,11 @@ public class FFmpegSettingsViewModel
     public string FFmpegPath { get; set; }
     public string FFprobePath { get; set; }
     public int DefaultFFmpegProfileId { get; set; }
-    public string PreferredLanguageCode { get; set; }
+    public string PreferredAudioLanguageCode { get; set; }
     public bool SaveReports { get; set; }
     public int? GlobalWatermarkId { get; set; }
     public int? GlobalFallbackFillerId { get; set; }
     public int HlsSegmenterIdleTimeout { get; set; }
     public int WorkAheadSegmenterLimit { get; set; }
     public int InitialSegmentCount { get; set; }
-    public bool UseLegacyTranscoder { get; set; }
 }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -10,23 +10,21 @@ internal static class Mapper
             profile.Id,
             profile.Name,
             profile.ThreadCount,
-            profile.Transcode,
             profile.HardwareAcceleration,
             profile.VaapiDriver,
             profile.VaapiDevice,
             Project(profile.Resolution),
-            profile.NormalizeVideo,
-            profile.VideoCodec,
+            profile.VideoFormat,
             profile.VideoBitrate,
             profile.VideoBufferSize,
-            profile.AudioCodec,
+            profile.AudioFormat,
             profile.AudioBitrate,
             profile.AudioBufferSize,
             profile.NormalizeLoudness,
             profile.AudioChannels,
             profile.AudioSampleRate,
-            profile.NormalizeAudio,
-            profile.NormalizeVideo && profile.NormalizeFramerate);
+            profile.NormalizeFramerate,
+            profile.DeinterlaceVideo == true);
 
     private static ResolutionViewModel Project(Resolution resolution) =>
         new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdHandler.cs

@@ -16,7 +16,7 @@ public class GetFFmpegProfileByIdHandler : IRequestHandler<GetFFmpegProfileById,
         GetFFmpegProfileById request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         return await dbContext.FFmpegProfiles
             .Include(p => p.Resolution)
             .SelectOneAsync(p => p.Id, p => p.Id == request.Id)

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -20,7 +20,7 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
             await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId);
         Option<bool> saveReports =
             await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
-        Option<string> preferredLanguageCode =
+        Option<string> preferredAudioLanguageCode =
             await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
         Option<int> watermark =
             await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId);
@@ -32,8 +32,6 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
             await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters);
         Option<int> initialSegmentCount =
             await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount);
-        Option<bool> useLegacyTranscoder =
-            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegUseLegacyTranscoder);
 
         var result = new FFmpegSettingsViewModel
         {
@@ -41,11 +39,10 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
             FFprobePath = await ffprobePath.IfNoneAsync(string.Empty),
             DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
             SaveReports = await saveReports.IfNoneAsync(false),
-            PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng"),
+            PreferredAudioLanguageCode = await preferredAudioLanguageCode.IfNoneAsync("eng"),
             HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
             WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),
             InitialSegmentCount = await initialSegmentCount.IfNoneAsync(1),
-            UseLegacyTranscoder = await useLegacyTranscoder.IfNoneAsync(false)
         };
 
         foreach (int watermarkId in watermark)

ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs

@@ -13,7 +13,7 @@ public class GetAllHealthCheckResultsHandler : IRequestHandler<GetAllHealthCheck
         GetAllHealthCheckResults request,
         CancellationToken cancellationToken)
     {
-        List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks();
+        List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks(cancellationToken);
         return results.Filter(r => r.Status != HealthCheckStatus.NotApplicable).ToList();
     }
 }

ErsatzTV.Application/Images/Queries/GetCachedImagePathHandler.cs

@@ -1,5 +1,9 @@
-using ErsatzTV.Core;
+using CliWrap;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
+using ErsatzTV.Core.Interfaces.Repositories;
 using Winista.Mime;
 
 namespace ErsatzTV.Application.Images;
@@ -9,12 +13,32 @@ public class
 {
     private static readonly MimeTypes MimeTypes = new();
     private readonly IImageCache _imageCache;
+    private readonly IFFmpegProcessService _ffmpegProcessService;
+    private readonly IConfigElementRepository _configElementRepository;
 
-    public GetCachedImagePathHandler(IImageCache imageCache) => _imageCache = imageCache;
+    public GetCachedImagePathHandler(
+        IImageCache imageCache,
+        IFFmpegProcessService ffmpegProcessService,
+        IConfigElementRepository configElementRepository)
+    {
+        _imageCache = imageCache;
+        _ffmpegProcessService = ffmpegProcessService;
+        _configElementRepository = configElementRepository;
+    }
 
     public async Task<Either<BaseError, CachedImagePathViewModel>> Handle(
         GetCachedImagePath request,
         CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = await Validate();
+        return await validation.Match(
+            ffmpegPath => Handle(ffmpegPath, request),
+            error => Task.FromResult<Either<BaseError, CachedImagePathViewModel>>(error.Join()));
+    }
+
+    private async Task<Either<BaseError, CachedImagePathViewModel>> Handle(
+        string ffmpegPath,
+        GetCachedImagePath request)
     {
         try
         {
@@ -24,23 +48,41 @@ public class
                 request.FileName,
                 request.ArtworkKind,
                 Optional(request.MaxHeight));
+
+            if (cachePath == null)
+            {
+                return BaseError.New("Failed to generate cache path for image");
+            }
+
             if (!File.Exists(cachePath))
             {
                 if (request.MaxHeight.HasValue)
                 {
-                    string originalPath = _imageCache.GetPathForImage(request.FileName, request.ArtworkKind, None);
-                    byte[] contents = await File.ReadAllBytesAsync(originalPath, cancellationToken);
-                    Either<BaseError, byte[]> resizeResult =
-                        await _imageCache.ResizeImage(contents, request.MaxHeight.Value);
-                    resizeResult.IfRight(result => contents = result);
-
                     string baseFolder = Path.GetDirectoryName(cachePath);
                     if (baseFolder != null && !Directory.Exists(baseFolder))
                     {
                         Directory.CreateDirectory(baseFolder);
                     }
 
-                    await File.WriteAllBytesAsync(cachePath, contents, cancellationToken);
+                    // ffmpeg needs the extension to determine the output codec
+                    string withExtension = cachePath + ".jpg";
+
+                    string originalPath = _imageCache.GetPathForImage(request.FileName, request.ArtworkKind, None);
+
+                    Command process = _ffmpegProcessService.ResizeImage(
+                        ffmpegPath,
+                        originalPath,
+                        withExtension,
+                        request.MaxHeight.Value);
+
+                    CommandResult resize = await process.ExecuteAsync();
+
+                    if (resize.ExitCode != 0)
+                    {
+                        return BaseError.New($"Failed to resize image; exit code {resize.ExitCode}");
+                    }
+
+                    File.Move(withExtension, cachePath);
 
                     mimeType = new MimeType("image/jpeg");
                 }
@@ -61,4 +103,12 @@ public class
             return BaseError.New(ex.Message);
         }
     }
+
+    private async Task<Validation<BaseError, string>> Validate() =>
+        await ValidateFFmpegPath();
+    
+    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"));
 }

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs

@@ -70,6 +70,7 @@ public class SynchronizeJellyfinLibraryByIdHandler :
                         parameters.ConnectionParameters.ActiveConnection.Address,
                         parameters.ConnectionParameters.ApiKey,
                         parameters.Library,
+                        parameters.FFmpegPath,
                         parameters.FFprobePath);
                     break;
                 case LibraryMediaKind.Shows:
@@ -77,6 +78,7 @@ public class SynchronizeJellyfinLibraryByIdHandler :
                         parameters.ConnectionParameters.ActiveConnection.Address,
                         parameters.ConnectionParameters.ApiKey,
                         parameters.Library,
+                        parameters.FFmpegPath,
                         parameters.FFprobePath);
                     break;
             }
@@ -98,15 +100,17 @@ public class SynchronizeJellyfinLibraryByIdHandler :
     private async Task<Validation<BaseError, RequestParameters>> Validate(
         ISynchronizeJellyfinLibraryById request) =>
         (await ValidateConnection(request), await JellyfinLibraryMustExist(request),
-            await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
+            await ValidateLibraryRefreshInterval(), await ValidateFFmpegPath(), await ValidateFFprobePath())
         .Apply(
-            (connectionParameters, jellyfinLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
-                connectionParameters,
-                jellyfinLibrary,
-                request.ForceScan,
-                libraryRefreshInterval,
-                ffprobePath
-            ));
+            (connectionParameters, jellyfinLibrary, libraryRefreshInterval, ffmpegPath, ffprobePath) =>
+                new RequestParameters(
+                    connectionParameters,
+                    jellyfinLibrary,
+                    request.ForceScan,
+                    libraryRefreshInterval,
+                    ffmpegPath,
+                    ffprobePath
+                ));
 
     private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
         ISynchronizeJellyfinLibraryById request) =>
@@ -149,6 +153,13 @@ public class SynchronizeJellyfinLibraryByIdHandler :
             .FilterT(lri => lri > 0)
             .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
 
+    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, string>> ValidateFFprobePath() =>
         _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
             .FilterT(File.Exists)
@@ -161,6 +172,7 @@ public class SynchronizeJellyfinLibraryByIdHandler :
         JellyfinLibrary Library,
         bool ForceScan,
         int LibraryRefreshInterval,
+        string FFmpegPath,
         string FFprobePath);
 
     private record ConnectionParameters(

ErsatzTV.Application/Maintenance/Commands/EmptyTrash.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Maintenance;
+
+public record EmptyTrash : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Maintenance/Commands/EmptyTrashHandler.cs

@@ -0,0 +1,55 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using ErsatzTV.Infrastructure.Search;
+
+namespace ErsatzTV.Application.Maintenance;
+
+public class EmptyTrashHandler : IRequestHandler<EmptyTrash, Either<BaseError, Unit>>
+{
+    private readonly IMediaItemRepository _mediaItemRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public EmptyTrashHandler(
+        IMediaItemRepository mediaItemRepository,
+        ISearchIndex searchIndex)
+    {
+        _mediaItemRepository = mediaItemRepository;
+        _searchIndex = searchIndex;
+    }
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        EmptyTrash request,
+        CancellationToken cancellationToken)
+    {
+        string[] types =
+        {
+            SearchIndex.MovieType,
+            SearchIndex.ShowType,
+            SearchIndex.SeasonType,
+            SearchIndex.EpisodeType,
+            SearchIndex.MusicVideoType,
+            SearchIndex.OtherVideoType,
+            SearchIndex.SongType,
+            SearchIndex.ArtistType
+        };
+
+        var ids = new List<int>();
+
+        foreach (string type in types)
+        {
+            SearchResult result = await _searchIndex.Search($"type:{type} AND (state:FileNotFound)", 0, 0);
+            ids.AddRange(result.Items.Map(i => i.Id));
+        }
+
+        Either<BaseError, Unit> deleteResult = await _mediaItemRepository.DeleteItems(ids);
+        if (deleteResult.IsRight)
+        {
+            await _searchIndex.RemoveItems(ids);
+            _searchIndex.Commit();
+        }
+
+        return deleteResult;
+    }
+}

ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -10,7 +11,7 @@ using Microsoft.EntityFrameworkCore;
 namespace ErsatzTV.Application.MediaCollections;
 
 public class AddArtistToCollectionHandler :
-    MediatR.IRequestHandler<AddArtistToCollection, Either<BaseError, Unit>>
+    IRequestHandler<AddArtistToCollection, Either<BaseError, Unit>>
 {
     private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
@@ -30,9 +31,9 @@ public class AddArtistToCollectionHandler :
         AddArtistToCollection 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 LanguageExtensions.Apply(validation, parameters => ApplyAddArtistRequest(dbContext, parameters));
+        return await validation.Apply(parameters => ApplyAddArtistRequest(dbContext, parameters));
     }
 
     private async Task<Unit> ApplyAddArtistRequest(TvContext dbContext, Parameters parameters)
@@ -40,11 +41,11 @@ public class AddArtistToCollectionHandler :
         parameters.Collection.MediaItems.Add(parameters.Artist);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                .PlayoutIdsUsingCollection(parameters.Collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -30,9 +31,9 @@ public class AddEpisodeToCollectionHandler :
         AddEpisodeToCollection 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 LanguageExtensions.Apply(validation, parameters => ApplyAddTelevisionEpisodeRequest(dbContext, parameters));
+        return await validation.Apply(parameters => ApplyAddTelevisionEpisodeRequest(dbContext, parameters));
     }
 
     private async Task<Unit> ApplyAddTelevisionEpisodeRequest(TvContext dbContext, Parameters parameters)
@@ -40,11 +41,11 @@ public class AddEpisodeToCollectionHandler :
         parameters.Collection.MediaItems.Add(parameters.Episode);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                .PlayoutIdsUsingCollection(parameters.Collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -36,10 +37,9 @@ public class AddItemsToCollectionHandler :
         AddItemsToCollection request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => ApplyAddItemsRequest(dbContext, c, request));
+        return await validation.Apply(c => ApplyAddItemsRequest(dbContext, c, request));
     }
 
     private async Task<Unit> ApplyAddItemsRequest(TvContext dbContext, Collection collection, AddItemsToCollection request)
@@ -63,11 +63,11 @@ public class AddItemsToCollectionHandler :
 
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(request.CollectionId))
+                .PlayoutIdsUsingCollection(request.CollectionId))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddMovieToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -30,9 +31,9 @@ public class AddMovieToCollectionHandler :
         AddMovieToCollection 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 LanguageExtensions.Apply(validation, parameters => ApplyAddMovieRequest(dbContext, parameters));
+        return await validation.Apply(parameters => ApplyAddMovieRequest(dbContext, parameters));
     }
 
     private async Task<Unit> ApplyAddMovieRequest(TvContext dbContext, Parameters parameters)
@@ -40,11 +41,11 @@ public class AddMovieToCollectionHandler :
         parameters.Collection.MediaItems.Add(parameters.Movie);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                .PlayoutIdsUsingCollection(parameters.Collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -30,9 +31,9 @@ public class AddMusicVideoToCollectionHandler :
         AddMusicVideoToCollection 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 LanguageExtensions.Apply(validation, parameters => ApplyAddMusicVideoRequest(dbContext, parameters));
+        return await validation.Apply(parameters => ApplyAddMusicVideoRequest(dbContext, parameters));
     }
 
     private async Task<Unit> ApplyAddMusicVideoRequest(TvContext dbContext, Parameters parameters)
@@ -40,11 +41,11 @@ public class AddMusicVideoToCollectionHandler :
         parameters.Collection.MediaItems.Add(parameters.MusicVideo);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                .PlayoutIdsUsingCollection(parameters.Collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -30,9 +31,9 @@ public class AddOtherVideoToCollectionHandler :
         AddOtherVideoToCollection 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 LanguageExtensions.Apply(validation, parameters => ApplyAddOtherVideoRequest(dbContext, parameters));
+        return await validation.Apply(parameters => ApplyAddOtherVideoRequest(dbContext, parameters));
     }
 
     private async Task<Unit> ApplyAddOtherVideoRequest(TvContext dbContext, Parameters parameters)
@@ -40,11 +41,11 @@ public class AddOtherVideoToCollectionHandler :
         parameters.Collection.MediaItems.Add(parameters.OtherVideo);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                .PlayoutIdsUsingCollection(parameters.Collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -30,9 +31,9 @@ public class AddSeasonToCollectionHandler :
         AddSeasonToCollection 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 LanguageExtensions.Apply(validation, parameters => ApplyAddSeasonRequest(dbContext, parameters));
+        return await validation.Apply(parameters => ApplyAddSeasonRequest(dbContext, parameters));
     }
 
     private async Task<Unit> ApplyAddSeasonRequest(TvContext dbContext, Parameters parameters)
@@ -40,11 +41,11 @@ public class AddSeasonToCollectionHandler :
         parameters.Collection.MediaItems.Add(parameters.Season);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                .PlayoutIdsUsingCollection(parameters.Collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddShowToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -30,9 +31,9 @@ public class AddShowToCollectionHandler :
         AddShowToCollection 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 LanguageExtensions.Apply(validation, parameters => ApplyAddShowRequest(dbContext, parameters));
+        return await validation.Apply(parameters => ApplyAddShowRequest(dbContext, parameters));
     }
 
     private async Task<Unit> ApplyAddShowRequest(TvContext dbContext, Parameters parameters)
@@ -40,11 +41,11 @@ public class AddShowToCollectionHandler :
         parameters.Collection.MediaItems.Add(parameters.Show);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                .PlayoutIdsUsingCollection(parameters.Collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddSongToCollectionHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -40,11 +41,11 @@ public class AddSongToCollectionHandler :
         parameters.Collection.MediaItems.Add(parameters.Song);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
-                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                .PlayoutIdsUsingCollection(parameters.Collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollectionHandler.cs

@@ -3,14 +3,14 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.MediaCollections;
 
-public class RemoveItemsFromCollectionHandler :
-    MediatR.IRequestHandler<RemoveItemsFromCollection, Either<BaseError, Unit>>
+public class RemoveItemsFromCollectionHandler : IRequestHandler<RemoveItemsFromCollection, Either<BaseError, Unit>>
 {
     private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
@@ -30,9 +30,9 @@ public class RemoveItemsFromCollectionHandler :
         RemoveItemsFromCollection request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => ApplyRemoveItemsRequest(dbContext, request, c));
+        return await validation.Apply(c => ApplyRemoveItemsRequest(dbContext, request, c));
     }
 
     private async Task<Unit> ApplyRemoveItemsRequest(
@@ -48,10 +48,10 @@ public class RemoveItemsFromCollectionHandler :
 
         if (itemsToRemove.Any() && await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(collection.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrderHandler.cs

@@ -3,14 +3,14 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.MediaCollections;
 
-public class UpdateCollectionCustomOrderHandler :
-    MediatR.IRequestHandler<UpdateCollectionCustomOrder, Either<BaseError, Unit>>
+public class UpdateCollectionCustomOrderHandler : IRequestHandler<UpdateCollectionCustomOrder, Either<BaseError, Unit>>
 {
     private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
@@ -30,9 +30,9 @@ public class UpdateCollectionCustomOrderHandler :
         UpdateCollectionCustomOrder request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
     }
 
     private async Task<Unit> ApplyUpdateRequest(
@@ -53,11 +53,11 @@ public class UpdateCollectionCustomOrderHandler :
 
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository
                          .PlayoutIdsUsingCollection(request.CollectionId))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs

@@ -3,13 +3,14 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.MediaCollections;
 
-public class UpdateCollectionHandler : MediatR.IRequestHandler<UpdateCollection, Either<BaseError, Unit>>
+public class UpdateCollectionHandler : IRequestHandler<UpdateCollection, Either<BaseError, Unit>>
 {
     private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
@@ -29,9 +30,9 @@ public class UpdateCollectionHandler : MediatR.IRequestHandler<UpdateCollection,
         UpdateCollection request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
     }
 
     private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, Collection c, UpdateCollection request)
@@ -44,11 +45,11 @@ public class UpdateCollectionHandler : MediatR.IRequestHandler<UpdateCollection,
 
         if (await dbContext.SaveChangesAsync() > 0 && request.UseCustomPlaybackOrder.IsSome)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(
                          request.CollectionId))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollectionHandler.cs

@@ -3,13 +3,14 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.MediaCollections;
 
-public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiCollection, Either<BaseError, Unit>>
+public class UpdateMultiCollectionHandler : IRequestHandler<UpdateMultiCollection, Either<BaseError, Unit>>
 {
     private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
@@ -29,15 +30,15 @@ public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiC
         UpdateMultiCollection request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, MultiCollection> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
     }
 
     private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, MultiCollection c, UpdateMultiCollection request)
     {
         c.Name = request.Name;
-            
+
         // save name first so playouts don't get rebuilt for a name change
         await dbContext.SaveChangesAsync();
 
@@ -45,22 +46,23 @@ public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiC
             .Filter(i => i.CollectionId.HasValue)
             // ReSharper disable once PossibleInvalidOperationException
             .Filter(i => c.MultiCollectionItems.All(i2 => i2.CollectionId != i.CollectionId.Value))
-            .Map(i => new MultiCollectionItem
-            {
-                // ReSharper disable once PossibleInvalidOperationException
-                CollectionId = i.CollectionId.Value,
-                MultiCollectionId = c.Id,
-                ScheduleAsGroup = i.ScheduleAsGroup,
-                PlaybackOrder = i.PlaybackOrder
-            })
+            .Map(
+                i => new MultiCollectionItem
+                {
+                    // ReSharper disable once PossibleInvalidOperationException
+                    CollectionId = i.CollectionId.Value,
+                    MultiCollectionId = c.Id,
+                    ScheduleAsGroup = i.ScheduleAsGroup,
+                    PlaybackOrder = i.PlaybackOrder
+                })
             .ToList();
         var toRemove = c.MultiCollectionItems
             .Filter(i => request.Items.All(i2 => i2.CollectionId != i.CollectionId))
             .ToList();
-            
+
         // remove items that are no longer present
         c.MultiCollectionItems.RemoveAll(toRemove.Contains);
-            
+
         // update existing items
         foreach (MultiCollectionItem item in c.MultiCollectionItems)
         {
@@ -79,22 +81,23 @@ public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiC
             .Filter(i => i.SmartCollectionId.HasValue)
             // ReSharper disable once PossibleInvalidOperationException
             .Filter(i => c.MultiCollectionSmartItems.All(i2 => i2.SmartCollectionId != i.SmartCollectionId.Value))
-            .Map(i => new MultiCollectionSmartItem
-            {
-                // ReSharper disable once PossibleInvalidOperationException
-                SmartCollectionId = i.SmartCollectionId.Value,
-                MultiCollectionId = c.Id,
-                ScheduleAsGroup = i.ScheduleAsGroup,
-                PlaybackOrder = i.PlaybackOrder
-            })
+            .Map(
+                i => new MultiCollectionSmartItem
+                {
+                    // ReSharper disable once PossibleInvalidOperationException
+                    SmartCollectionId = i.SmartCollectionId.Value,
+                    MultiCollectionId = c.Id,
+                    ScheduleAsGroup = i.ScheduleAsGroup,
+                    PlaybackOrder = i.PlaybackOrder
+                })
             .ToList();
         var toRemoveSmart = c.MultiCollectionSmartItems
             .Filter(i => request.Items.All(i2 => i2.SmartCollectionId != i.SmartCollectionId))
             .ToList();
-            
+
         // remove items that are no longer present
         c.MultiCollectionSmartItems.RemoveAll(toRemoveSmart.Contains);
-            
+
         // update existing items
         foreach (MultiCollectionSmartItem item in c.MultiCollectionSmartItems)
         {
@@ -112,11 +115,11 @@ public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiC
         // rebuild playouts
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this collection
+            // refresh all playouts that use this collection
             foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingMultiCollection(
                          request.MultiCollectionId))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 
@@ -138,7 +141,9 @@ public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiC
             .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.MultiCollectionId)
             .Map(o => o.ToValidation<BaseError>("MultiCollection does not exist."));
 
-    private static async Task<Validation<BaseError, string>> ValidateName(TvContext dbContext, UpdateMultiCollection updateMultiCollection)
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        UpdateMultiCollection updateMultiCollection)
     {
         List<string> allNames = await dbContext.MultiCollections
             .Filter(mc => mc.Id != updateMultiCollection.MultiCollectionId)

ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollectionHandler.cs

@@ -3,13 +3,14 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.MediaCollections;
 
-public class UpdateSmartCollectionHandler : MediatR.IRequestHandler<UpdateSmartCollection, Either<BaseError, Unit>>
+public class UpdateSmartCollectionHandler : IRequestHandler<UpdateSmartCollection, Either<BaseError, Unit>>
 {
     private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
@@ -29,9 +30,9 @@ public class UpdateSmartCollectionHandler : MediatR.IRequestHandler<UpdateSmartC
         UpdateSmartCollection request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
     }
 
     private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, SmartCollection c, UpdateSmartCollection request)
@@ -41,10 +42,10 @@ public class UpdateSmartCollectionHandler : MediatR.IRequestHandler<UpdateSmartC
         // rebuild playouts
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            // rebuild all playouts that use this smart collection
+            // refresh all playouts that use this smart collection
             foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingSmartCollection(request.Id))
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -47,21 +47,20 @@ public class ScanLocalLibraryHandler : IRequestHandler<ForceScanLocalLibrary, Ei
         _logger = logger;
     }
 
-    public Task<Either<BaseError, string>> Handle(
+    Task<Either<BaseError, string>> IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>.Handle(
         ForceScanLocalLibrary request,
-        CancellationToken cancellationToken) => Handle(request);
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
 
-    public Task<Either<BaseError, string>> Handle(
+    Task<Either<BaseError, string>> IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>.Handle(
         ScanLocalLibraryIfNeeded request,
-        CancellationToken cancellationToken) => Handle(request);
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
 
-    private Task<Either<BaseError, string>>
-        Handle(IScanLocalLibrary request) =>
+    private Task<Either<BaseError, string>> Handle(IScanLocalLibrary request, CancellationToken cancellationToken) =>
         Validate(request)
-            .MapT(parameters => PerformScan(parameters).Map(_ => parameters.LocalLibrary.Name))
+            .MapT(parameters => PerformScan(parameters, cancellationToken).Map(_ => parameters.LocalLibrary.Name))
             .Bind(v => v.ToEitherAsync());
 
-    private async Task<Unit> PerformScan(RequestParameters parameters)
+    private async Task<Unit> PerformScan(RequestParameters parameters, CancellationToken cancellationToken)
     {
         (LocalLibrary localLibrary, string ffprobePath, string ffmpegPath, bool forceScan,
             int libraryRefreshInterval) = parameters;
@@ -89,27 +88,34 @@ public class ScanLocalLibraryHandler : IRequestHandler<ForceScanLocalLibrary, Ei
                     case LibraryMediaKind.Movies:
                         await _movieFolderScanner.ScanFolder(
                             libraryPath,
+                            ffmpegPath,
                             ffprobePath,
                             progressMin,
-                            progressMax);
+                            progressMax,
+                            cancellationToken);
                         break;
                     case LibraryMediaKind.Shows:
                         await _televisionFolderScanner.ScanFolder(
                             libraryPath,
+                            ffmpegPath,
                             ffprobePath,
                             progressMin,
-                            progressMax);
+                            progressMax,
+                            cancellationToken);
                         break;
                     case LibraryMediaKind.MusicVideos:
                         await _musicVideoFolderScanner.ScanFolder(
                             libraryPath,
+                            ffmpegPath,
                             ffprobePath,
                             progressMin,
-                            progressMax);
+                            progressMax,
+                            cancellationToken);
                         break;
                     case LibraryMediaKind.OtherVideos:
                         await _otherVideoFolderScanner.ScanFolder(
                             libraryPath,
+                            ffmpegPath,
                             ffprobePath,
                             progressMin,
                             progressMax);
@@ -120,7 +126,8 @@ public class ScanLocalLibraryHandler : IRequestHandler<ForceScanLocalLibrary, Ei
                             ffprobePath,
                             ffmpegPath,
                             progressMin,
-                            progressMax);
+                            progressMax,
+                            cancellationToken);
                         break;
                 }
 

ErsatzTV.Application/Playouts/Commands/BuildPlayout.cs

@@ -1,6 +1,7 @@
 using ErsatzTV.Core;
+using ErsatzTV.Core.Scheduling;
 
 namespace ErsatzTV.Application.Playouts;
 
-public record BuildPlayout(int PlayoutId, bool Rebuild = false) : MediatR.IRequest<Either<BaseError, Unit>>,
+public record BuildPlayout(int PlayoutId, PlayoutBuildMode Mode) : IRequest<Either<BaseError, Unit>>,
     IBackgroundServiceRequest;

ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs

@@ -1,6 +1,7 @@
 using Bugsnag;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -13,12 +14,18 @@ public class BuildPlayoutHandler : MediatR.IRequestHandler<BuildPlayout, Either<
     private readonly IClient _client;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
     private readonly IPlayoutBuilder _playoutBuilder;
+    private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
 
-    public BuildPlayoutHandler(IClient client, IDbContextFactory<TvContext> dbContextFactory, IPlayoutBuilder playoutBuilder)
+    public BuildPlayoutHandler(
+        IClient client,
+        IDbContextFactory<TvContext> dbContextFactory,
+        IPlayoutBuilder playoutBuilder,
+        IFFmpegSegmenterService ffmpegSegmenterService)
     {
         _client = client;
         _dbContextFactory = dbContextFactory;
         _playoutBuilder = playoutBuilder;
+        _ffmpegSegmenterService = ffmpegSegmenterService;
     }
 
     public async Task<Either<BaseError, Unit>> Handle(BuildPlayout request, CancellationToken cancellationToken)
@@ -32,8 +39,11 @@ public class BuildPlayoutHandler : MediatR.IRequestHandler<BuildPlayout, Either<
     {
         try
         {
-            await _playoutBuilder.BuildPlayoutItems(playout, request.Rebuild);
-            await dbContext.SaveChangesAsync();
+            await _playoutBuilder.Build(playout, request.Mode);
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                _ffmpegSegmenterService.PlayoutUpdated(playout.Channel.Number);
+            }
         }
         catch (Exception ex)
         {
@@ -42,7 +52,6 @@ public class BuildPlayoutHandler : MediatR.IRequestHandler<BuildPlayout, Either<
 
         return Unit.Default;
     }
-
     private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, BuildPlayout request) =>
         PlayoutMustExist(dbContext, request);
 

ErsatzTV.Application/Playouts/Commands/CreatePlayoutHandler.cs

@@ -1,6 +1,7 @@
 using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -25,17 +26,16 @@ public class CreatePlayoutHandler : IRequestHandler<CreatePlayout, Either<BaseEr
         CreatePlayout request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Playout> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, playout => PersistPlayout(dbContext, playout));
+        return await validation.Apply(playout => PersistPlayout(dbContext, playout));
     }
 
     private async Task<CreatePlayoutResponse> PersistPlayout(TvContext dbContext, Playout playout)
     {
         await dbContext.Playouts.AddAsync(playout);
         await dbContext.SaveChangesAsync();
-        await _channel.WriteAsync(new BuildPlayout(playout.Id));
+        await _channel.WriteAsync(new BuildPlayout(playout.Id, PlayoutBuildMode.Reset));
         return new CreatePlayoutResponse(playout.Id);
     }
 

ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs

@@ -68,6 +68,7 @@ public class
                         parameters.ConnectionParameters.ActiveConnection,
                         parameters.ConnectionParameters.PlexServerAuthToken,
                         parameters.Library,
+                        parameters.FFmpegPath,
                         parameters.FFprobePath);
                     break;
                 case LibraryMediaKind.Shows:
@@ -75,6 +76,7 @@ public class
                         parameters.ConnectionParameters.ActiveConnection,
                         parameters.ConnectionParameters.PlexServerAuthToken,
                         parameters.Library,
+                        parameters.FFmpegPath,
                         parameters.FFprobePath);
                     break;
             }
@@ -95,15 +97,17 @@ public class
 
     private async Task<Validation<BaseError, RequestParameters>> Validate(ISynchronizePlexLibraryById request) =>
         (await ValidateConnection(request), await PlexLibraryMustExist(request),
-            await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
+            await ValidateLibraryRefreshInterval(), await ValidateFFmpegPath(), await ValidateFFprobePath())
         .Apply(
-            (connectionParameters, plexLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
-                connectionParameters,
-                plexLibrary,
-                request.ForceScan,
-                libraryRefreshInterval,
-                ffprobePath
-            ));
+            (connectionParameters, plexLibrary, libraryRefreshInterval, ffmpegPath, ffprobePath) =>
+                new RequestParameters(
+                    connectionParameters,
+                    plexLibrary,
+                    request.ForceScan,
+                    libraryRefreshInterval,
+                    ffmpegPath,
+                    ffprobePath
+                ));
 
     private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
         ISynchronizePlexLibraryById request) =>
@@ -146,6 +150,13 @@ public class
             .FilterT(lri => lri > 0)
             .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
         
+    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, string>> ValidateFFprobePath() =>
         _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
             .FilterT(File.Exists)
@@ -158,6 +169,7 @@ public class
         PlexLibrary Library,
         bool ForceScan,
         int LibraryRefreshInterval,
+        string FFmpegPath,
         string FFprobePath);
 
     private record ConnectionParameters(PlexMediaSource PlexMediaSource, PlexConnection ActiveConnection)

ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs

@@ -9,10 +9,11 @@ using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Plex;
 
-public class
-    SynchronizePlexMediaSourcesHandler : IRequestHandler<SynchronizePlexMediaSources,
-        Either<BaseError, List<PlexMediaSource>>>
+public class SynchronizePlexMediaSourcesHandler : IRequestHandler<SynchronizePlexMediaSources,
+    Either<BaseError, List<PlexMediaSource>>>
 {
+    private const string LocalhostUri = "http://localhost:32400";
+
     private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
     private readonly IEntityLocker _entityLocker;
     private readonly ILogger<SynchronizePlexMediaSourcesHandler> _logger;
@@ -72,6 +73,18 @@ public class
 
     private async Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
     {
+        if (server.Connections.All(c => c.Uri != LocalhostUri))
+        {
+            var localhost = new PlexConnection
+            {
+                PlexMediaSource = server,
+                PlexMediaSourceId = server.Id,
+                Uri = LocalhostUri
+            };
+
+            server.Connections.Add(localhost);
+        }
+
         Option<PlexMediaSource> maybeExisting =
             allExisting.Find(s => s.ClientIdentifier == server.ClientIdentifier);
 
@@ -98,7 +111,11 @@ public class
 
     private async Task FindConnectionToActivate(PlexMediaSource server)
     {
-        var prioritized = server.Connections.OrderBy(pc => pc.IsActive ? 0 : 1).ToList();
+        var prioritized = server.Connections
+            .OrderByDescending(pc => pc.Uri == LocalhostUri)
+            .ThenByDescending(pc => pc.IsActive)
+            .ToList();
+
         foreach (PlexConnection connection in server.Connections)
         {
             connection.IsActive = false;

ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs

@@ -23,4 +23,5 @@ public record AddProgramScheduleItem(
     int? MidRollFillerId,
     int? PostRollFillerId,
     int? TailFillerId,
-    int? FallbackFillerId) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
+    int? FallbackFillerId,
+    int? WatermarkId) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;

ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItemHandler.cs

@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.ProgramSchedules.Mapper;
@@ -26,9 +27,9 @@ public class AddProgramScheduleItemHandler : ProgramScheduleItemCommandBase,
         AddProgramScheduleItem request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, ps => PersistItem(dbContext, request, ps));
+        return await validation.Apply(ps => PersistItem(dbContext, request, ps));
     }
 
     private async Task<ProgramScheduleItemViewModel> PersistItem(
@@ -43,10 +44,10 @@ public class AddProgramScheduleItemHandler : ProgramScheduleItemCommandBase,
 
         await dbContext.SaveChangesAsync();
 
-        // rebuild any playouts that use this schedule
+        // refresh any playouts that use this schedule
         foreach (Playout playout in programSchedule.Playouts)
         {
-            await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
+            await _channel.WriteAsync(new BuildPlayout(playout.Id, PlayoutBuildMode.Refresh));
         }
 
         return ProjectToViewModel(item);

ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs

@@ -22,4 +22,5 @@ public interface IProgramScheduleItemRequest
     int? PostRollFillerId { get; }
     int? TailFillerId { get; }
     int? FallbackFillerId { get; }
+    int? WatermarkId { get; }
 }

ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs

@@ -176,7 +176,8 @@ public abstract class ProgramScheduleItemCommandBase
                 MidRollFillerId = item.MidRollFillerId,
                 PostRollFillerId = item.PostRollFillerId,
                 TailFillerId = item.TailFillerId,
-                FallbackFillerId = item.FallbackFillerId
+                FallbackFillerId = item.FallbackFillerId,
+                WatermarkId = item.WatermarkId
             },
             PlayoutMode.One => new ProgramScheduleItemOne
             {
@@ -195,7 +196,8 @@ public abstract class ProgramScheduleItemCommandBase
                 MidRollFillerId = item.MidRollFillerId,
                 PostRollFillerId = item.PostRollFillerId,
                 TailFillerId = item.TailFillerId,
-                FallbackFillerId = item.FallbackFillerId
+                FallbackFillerId = item.FallbackFillerId,
+                WatermarkId = item.WatermarkId
             },
             PlayoutMode.Multiple => new ProgramScheduleItemMultiple
             {
@@ -215,7 +217,8 @@ public abstract class ProgramScheduleItemCommandBase
                 MidRollFillerId = item.MidRollFillerId,
                 PostRollFillerId = item.PostRollFillerId,
                 TailFillerId = item.TailFillerId,
-                FallbackFillerId = item.FallbackFillerId
+                FallbackFillerId = item.FallbackFillerId,
+                WatermarkId = item.WatermarkId
             },
             PlayoutMode.Duration => new ProgramScheduleItemDuration
             {
@@ -236,7 +239,8 @@ public abstract class ProgramScheduleItemCommandBase
                 MidRollFillerId = item.MidRollFillerId,
                 PostRollFillerId = item.PostRollFillerId,
                 TailFillerId = item.TailFillerId,
-                FallbackFillerId = item.FallbackFillerId
+                FallbackFillerId = item.FallbackFillerId,
+                WatermarkId = item.WatermarkId
             },
             _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
         };

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs

@@ -23,7 +23,8 @@ public record ReplaceProgramScheduleItem(
     int? MidRollFillerId,
     int? PostRollFillerId,
     int? TailFillerId,
-    int? FallbackFillerId) : IProgramScheduleItemRequest;
+    int? FallbackFillerId,
+    int? WatermarkId) : IProgramScheduleItemRequest;
 
 public record ReplaceProgramScheduleItems
     (int ProgramScheduleId, List<ReplaceProgramScheduleItem> Items) : IRequest<

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItemsHandler.cs

@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.ProgramSchedules.Mapper;
@@ -26,9 +27,9 @@ public class ReplaceProgramScheduleItemsHandler : ProgramScheduleItemCommandBase
         ReplaceProgramScheduleItems request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, ps => PersistItems(dbContext, request, ps));
+        return await validation.Apply(ps => PersistItems(dbContext, request, ps));
     }
 
     private async Task<IEnumerable<ProgramScheduleItemViewModel>> PersistItems(
@@ -41,10 +42,10 @@ public class ReplaceProgramScheduleItemsHandler : ProgramScheduleItemCommandBase
 
         await dbContext.SaveChangesAsync();
 
-        // rebuild any playouts that use this schedule
+        // refresh any playouts that use this schedule
         foreach (Playout playout in programSchedule.Playouts)
         {
-            await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
+            await _channel.WriteAsync(new BuildPlayout(playout.Id, PlayoutBuildMode.Refresh));
         }
 
         return programSchedule.Items.Map(ProjectToViewModel);

ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleHandler.cs

@@ -2,6 +2,7 @@
 using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -27,9 +28,8 @@ public class UpdateProgramScheduleHandler :
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
         Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, ps => ApplyUpdateRequest(dbContext, ps, request));
+        return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
     }
 
     private async Task<UpdateProgramScheduleResult> ApplyUpdateRequest(
@@ -37,8 +37,8 @@ public class UpdateProgramScheduleHandler :
         ProgramSchedule programSchedule,
         UpdateProgramSchedule request)
     {
-        // we need to rebuild playouts if the playback order or keep multi-episodes has been modified
-        bool needToRebuildPlayout =
+        // we need to refresh playouts if the playback order or keep multi-episodes has been modified
+        bool needToRefreshPlayout =
             programSchedule.KeepMultiPartEpisodesTogether != request.KeepMultiPartEpisodesTogether ||
             programSchedule.TreatCollectionsAsShows != request.TreatCollectionsAsShows ||
             programSchedule.ShuffleScheduleItems != request.ShuffleScheduleItems;
@@ -51,7 +51,7 @@ public class UpdateProgramScheduleHandler :
 
         await dbContext.SaveChangesAsync();
 
-        if (needToRebuildPlayout)
+        if (needToRefreshPlayout)
         {
             List<int> playoutIds = await dbContext.Playouts
                 .Filter(p => p.ProgramScheduleId == programSchedule.Id)
@@ -60,7 +60,7 @@ public class UpdateProgramScheduleHandler :
 
             foreach (int playoutId in playoutIds)
             {
-                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
             }
         }
 

ErsatzTV.Application/ProgramSchedules/Mapper.cs

@@ -57,6 +57,9 @@ internal static class Mapper
                         : null,
                     duration.FallbackFiller != null
                         ? Filler.Mapper.ProjectToViewModel(duration.FallbackFiller)
+                        : null,
+                    duration.Watermark != null
+                        ? Watermarks.Mapper.ProjectToViewModel(duration.Watermark)
                         : null),
             ProgramScheduleItemFlood flood =>
                 new ProgramScheduleItemFloodViewModel(
@@ -98,6 +101,9 @@ internal static class Mapper
                         : null,
                     flood.FallbackFiller != null
                         ? Filler.Mapper.ProjectToViewModel(flood.FallbackFiller)
+                        : null,
+                    flood.Watermark != null
+                        ? Watermarks.Mapper.ProjectToViewModel(flood.Watermark)
                         : null),
             ProgramScheduleItemMultiple multiple =>
                 new ProgramScheduleItemMultipleViewModel(
@@ -140,6 +146,9 @@ internal static class Mapper
                         : null,
                     multiple.FallbackFiller != null
                         ? Filler.Mapper.ProjectToViewModel(multiple.FallbackFiller)
+                        : null,
+                    multiple.Watermark != null
+                        ? Watermarks.Mapper.ProjectToViewModel(multiple.Watermark)
                         : null),
             ProgramScheduleItemOne one =>
                 new ProgramScheduleItemOneViewModel(
@@ -181,6 +190,9 @@ internal static class Mapper
                         : null,
                     one.FallbackFiller != null
                         ? Filler.Mapper.ProjectToViewModel(one.FallbackFiller)
+                        : null,
+                    one.Watermark != null
+                        ? Watermarks.Mapper.ProjectToViewModel(one.Watermark)
                         : null),
             _ => throw new NotSupportedException(
                 $"Unsupported program schedule item type {programScheduleItem.GetType().Name}")

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs

@@ -1,6 +1,7 @@
 using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Application.Watermarks;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.ProgramSchedules;
@@ -26,7 +27,8 @@ public record ProgramScheduleItemDurationViewModel : ProgramScheduleItemViewMode
         FillerPresetViewModel midRollFiller,
         FillerPresetViewModel postRollFiller,
         FillerPresetViewModel tailFiller,
-        FillerPresetViewModel fallbackFiller) : base(
+        FillerPresetViewModel fallbackFiller,
+        WatermarkViewModel watermark) : base(
         id,
         index,
         startType,
@@ -44,7 +46,8 @@ public record ProgramScheduleItemDurationViewModel : ProgramScheduleItemViewMode
         midRollFiller,
         postRollFiller,
         tailFiller,
-        fallbackFiller)
+        fallbackFiller,
+        watermark)
     {
         PlayoutDuration = playoutDuration;
         TailMode = tailMode;

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs

@@ -1,6 +1,7 @@
 using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Application.Watermarks;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.ProgramSchedules;
@@ -24,7 +25,8 @@ public record ProgramScheduleItemFloodViewModel : ProgramScheduleItemViewModel
         FillerPresetViewModel midRollFiller,
         FillerPresetViewModel postRollFiller,
         FillerPresetViewModel tailFiller,
-        FillerPresetViewModel fallbackFiller) : base(
+        FillerPresetViewModel fallbackFiller,
+        WatermarkViewModel watermark) : base(
         id,
         index,
         startType,
@@ -42,7 +44,8 @@ public record ProgramScheduleItemFloodViewModel : ProgramScheduleItemViewModel
         midRollFiller,
         postRollFiller,
         tailFiller,
-        fallbackFiller)
+        fallbackFiller,
+        watermark)
     {
     }
 }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs

@@ -1,6 +1,7 @@
 using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Application.Watermarks;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.ProgramSchedules;
@@ -25,7 +26,8 @@ public record ProgramScheduleItemMultipleViewModel : ProgramScheduleItemViewMode
         FillerPresetViewModel midRollFiller,
         FillerPresetViewModel postRollFiller,
         FillerPresetViewModel tailFiller,
-        FillerPresetViewModel fallbackFiller) : base(
+        FillerPresetViewModel fallbackFiller,
+        WatermarkViewModel watermark) : base(
         id,
         index,
         startType,
@@ -43,7 +45,8 @@ public record ProgramScheduleItemMultipleViewModel : ProgramScheduleItemViewMode
         midRollFiller,
         postRollFiller,
         tailFiller,
-        fallbackFiller) =>
+        fallbackFiller,
+        watermark) =>
         Count = count;
 
     public int Count { get; }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs

@@ -1,6 +1,7 @@
 using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Application.Watermarks;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.ProgramSchedules;
@@ -24,7 +25,8 @@ public record ProgramScheduleItemOneViewModel : ProgramScheduleItemViewModel
         FillerPresetViewModel midRollFiller,
         FillerPresetViewModel postRollFiller,
         FillerPresetViewModel tailFiller,
-        FillerPresetViewModel fallbackFiller) : base(
+        FillerPresetViewModel fallbackFiller,
+        WatermarkViewModel watermark) : base(
         id,
         index,
         startType,
@@ -42,7 +44,8 @@ public record ProgramScheduleItemOneViewModel : ProgramScheduleItemViewModel
         midRollFiller,
         postRollFiller,
         tailFiller,
-        fallbackFiller)
+        fallbackFiller,
+        watermark)
     {
     }
 }

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs

@@ -1,6 +1,7 @@
 using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Application.Watermarks;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.ProgramSchedules;
@@ -23,7 +24,8 @@ public abstract record ProgramScheduleItemViewModel(
     FillerPresetViewModel MidRollFiller,
     FillerPresetViewModel PostRollFiller,
     FillerPresetViewModel TailFiller,
-    FillerPresetViewModel FallbackFiller)
+    FillerPresetViewModel FallbackFiller,
+    WatermarkViewModel Watermark)
 {
     public string Name => CollectionType switch
     {

ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs

@@ -49,6 +49,7 @@ public class GetProgramScheduleItemsHandler :
             .Include(i => i.PostRollFiller)
             .Include(i => i.TailFiller)
             .Include(i => i.FallbackFiller)
+            .Include(i => i.Watermark)
             .ToListAsync(cancellationToken)
             .Map(
                 programScheduleItems => programScheduleItems.Map(ProjectToViewModel)

ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs

@@ -10,13 +10,12 @@ using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Streaming;
 
-public class StartFFmpegSessionHandler : MediatR.IRequestHandler<StartFFmpegSession, Either<BaseError, Unit>>
+public class StartFFmpegSessionHandler : IRequestHandler<StartFFmpegSession, Either<BaseError, Unit>>
 {
     private readonly ILogger<StartFFmpegSessionHandler> _logger;
     private readonly IServiceScopeFactory _serviceScopeFactory;
     private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
     private readonly IConfigElementRepository _configElementRepository;
-    private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
     private readonly ILocalFileSystem _localFileSystem;
 
     public StartFFmpegSessionHandler(
@@ -24,15 +23,13 @@ public class StartFFmpegSessionHandler : MediatR.IRequestHandler<StartFFmpegSess
         ILogger<StartFFmpegSessionHandler> logger,
         IServiceScopeFactory serviceScopeFactory,
         IFFmpegSegmenterService ffmpegSegmenterService,
-        IConfigElementRepository configElementRepository,
-        IHlsPlaylistFilter hlsPlaylistFilter)
+        IConfigElementRepository configElementRepository)
     {
         _localFileSystem = localFileSystem;
         _logger = logger;
         _serviceScopeFactory = serviceScopeFactory;
         _ffmpegSegmenterService = ffmpegSegmenterService;
         _configElementRepository = configElementRepository;
-        _hlsPlaylistFilter = hlsPlaylistFilter;
     }
 
     public Task<Either<BaseError, Unit>> Handle(StartFFmpegSession request, CancellationToken cancellationToken) =>
@@ -54,7 +51,7 @@ public class StartFFmpegSessionHandler : MediatR.IRequestHandler<StartFFmpegSess
         _ffmpegSegmenterService.SessionWorkers.AddOrUpdate(request.ChannelNumber, _ => worker, (_, _) => worker);
 
         // fire and forget worker
-        _ = worker.Run(request.ChannelNumber, idleTimeout)
+        _ = worker.Run(request.ChannelNumber, idleTimeout, cancellationToken)
             .ContinueWith(
                 _ => _ffmpegSegmenterService.SessionWorkers.TryRemove(
                     request.ChannelNumber,

ErsatzTV.Application/Streaming/HlsSessionWorker.cs

@@ -1,11 +1,14 @@
-using System.Diagnostics;
+using System.Text;
 using System.Timers;
 using Bugsnag;
+using CliWrap;
+using CliWrap.Buffered;
 using ErsatzTV.Application.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -27,6 +30,7 @@ public class HlsSessionWorker : IHlsSessionWorker
     private DateTimeOffset _playlistStart;
     private Option<int> _targetFramerate;
     private string _channelNumber;
+    private bool _firstProcess;
 
     public HlsSessionWorker(
         IHlsPlaylistFilter hlsPlaylistFilter,
@@ -55,19 +59,29 @@ public class HlsSessionWorker : IHlsSessionWorker
         DateTimeOffset filterBefore,
         CancellationToken cancellationToken)
     {
-        Option<string[]> maybeLines = await ReadPlaylistLines(cancellationToken);
-        return maybeLines.Map(input => _hlsPlaylistFilter.TrimPlaylist(PlaylistStart, filterBefore, input));
+        await Slim.WaitAsync(cancellationToken);
+        try
+        {
+            Option<string[]> maybeLines = await ReadPlaylistLines(cancellationToken);
+            return maybeLines.Map(input => _hlsPlaylistFilter.TrimPlaylist(PlaylistStart, filterBefore, input));
+        }
+        finally
+        {
+            Slim.Release();
+        }
     }
 
-    public async Task Run(string channelNumber, TimeSpan idleTimeout)
+    public void PlayoutUpdated() => _firstProcess = true;
+
+    public async Task Run(string channelNumber, TimeSpan idleTimeout, CancellationToken incomingCancellationToken)
     {
-        var cts = new CancellationTokenSource();
+        var cts = CancellationTokenSource.CreateLinkedTokenSource(incomingCancellationToken);
         void Cancel(object o, ElapsedEventArgs e) => cts.Cancel();
-        
+
         try
         {
             _channelNumber = channelNumber;
-            
+
             lock (_sync)
             {
                 _timer = new Timer(idleTimeout.TotalMilliseconds) { AutoReset = false };
@@ -77,9 +91,14 @@ public class HlsSessionWorker : IHlsSessionWorker
             CancellationToken cancellationToken = cts.Token;
 
             _logger.LogInformation("Starting HLS session for channel {Channel}", channelNumber);
-                
+
             using IServiceScope scope = _serviceScopeFactory.CreateScope();
             IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+            ILocalFileSystem localFileSystem = scope.ServiceProvider.GetRequiredService<ILocalFileSystem>();
+            if (localFileSystem.ListFiles(Path.Combine(FileSystemLayout.TranscodeFolder, _channelNumber)).Any())
+            {
+                _logger.LogError("Transcode folder is NOT empty!");
+            }
 
             _targetFramerate = await mediator.Send(
                 new GetChannelFramerate(channelNumber),
@@ -89,8 +108,10 @@ public class HlsSessionWorker : IHlsSessionWorker
             _transcodedUntil = DateTimeOffset.Now;
             _playlistStart = _transcodedUntil;
 
+            _firstProcess = true;
+
             bool initialWorkAhead = Volatile.Read(ref _workAheadCount) < await GetWorkAheadLimit();
-            if (!await Transcode(true, !initialWorkAhead, cancellationToken))
+            if (!await Transcode(!initialWorkAhead, cancellationToken))
             {
                 return;
             }
@@ -111,7 +132,7 @@ public class HlsSessionWorker : IHlsSessionWorker
                     bool realtime = transcodedBuffer >= TimeSpan.FromSeconds(30);
                     bool subsequentWorkAhead =
                         !realtime && Volatile.Read(ref _workAheadCount) < await GetWorkAheadLimit();
-                    if (!await Transcode(false, !subsequentWorkAhead, cancellationToken))
+                    if (!await Transcode(!subsequentWorkAhead, cancellationToken))
                     {
                         return;
                     }
@@ -133,7 +154,6 @@ public class HlsSessionWorker : IHlsSessionWorker
     }
 
     private async Task<bool> Transcode(
-        bool firstProcess,
         bool realtime,
         CancellationToken cancellationToken)
     {
@@ -161,8 +181,8 @@ public class HlsSessionWorker : IHlsSessionWorker
             var request = new GetPlayoutItemProcessByChannelNumber(
                 _channelNumber,
                 "segmenter",
-                firstProcess ? DateTimeOffset.Now : _transcodedUntil.AddSeconds(1),
-                !firstProcess,
+                _firstProcess ? DateTimeOffset.Now : _transcodedUntil.AddSeconds(1),
+                !_firstProcess,
                 realtime,
                 ptsOffset,
                 _targetFramerate);
@@ -187,36 +207,83 @@ public class HlsSessionWorker : IHlsSessionWorker
             {
                 await TrimAndDelete(cancellationToken);
 
-                Process process = processModel.Process;
+                Command process = processModel.Process;
 
-                _logger.LogInformation(
-                    "ffmpeg hls arguments {FFmpegArguments}",
-                    string.Join(" ", process.StartInfo.ArgumentList));
+                _logger.LogInformation("ffmpeg hls arguments {FFmpegArguments}", process.Arguments);
 
-                process.Start();
                 try
                 {
-                    await process.WaitForExitAsync(cancellationToken);
-                    process.WaitForExit();
+                    BufferedCommandResult commandResult = await process
+                        .WithValidation(CommandResultValidation.None)
+                        .ExecuteBufferedAsync(Encoding.UTF8, cancellationToken);
+
+                    if (commandResult.ExitCode == 0)
+                    {
+                        _logger.LogInformation("HLS process has completed for channel {Channel}", _channelNumber);
+                        _transcodedUntil = processModel.Until;
+                        _firstProcess = false;
+                        return true;
+                    }
+                    else
+                    {
+                        // detect the non-zero exit code and transcode the ffmpeg error message instead
+
+                        string errorMessage = commandResult.StandardError;
+                        if (string.IsNullOrWhiteSpace(errorMessage))
+                        {
+                            errorMessage = $"Unknown FFMPEG error; exit code {commandResult.ExitCode}";
+                        }
+
+                        _logger.LogError(
+                            "HLS process for channel {Channel} has terminated unsuccessfully with exit code {ExitCode}: {StandardError}",
+                            _channelNumber,
+                            commandResult.ExitCode,
+                            commandResult.StandardError);
+
+                        Either<BaseError, PlayoutItemProcessModel> maybeOfflineProcess = await mediator.Send(
+                            new GetErrorProcess(
+                                _channelNumber,
+                                "segmenter",
+                                realtime,
+                                ptsOffset,
+                                processModel.MaybeDuration,
+                                processModel.Until,
+                                errorMessage),
+                            cancellationToken);
+
+                        foreach (PlayoutItemProcessModel errorProcessModel in maybeOfflineProcess.RightAsEnumerable())
+                        {
+                            Command errorProcess = errorProcessModel.Process;
+
+                            _logger.LogInformation(
+                                "ffmpeg hls error arguments {FFmpegArguments}",
+                                errorProcess.Arguments);
+
+                            commandResult = await errorProcess
+                                .WithValidation(CommandResultValidation.None)
+                                .ExecuteBufferedAsync(Encoding.UTF8, cancellationToken);
+
+                            if (commandResult.ExitCode == 0)
+                            {
+                                _firstProcess = false;
+                                return true;
+                            }
+                        }
+
+                        return false;
+                    }
                 }
                 catch (TaskCanceledException)
                 {
                     _logger.LogInformation("Terminating HLS process for channel {Channel}", _channelNumber);
-                    process.Kill();
-                    process.WaitForExit();
-
                     return false;
                 }
-
-                _logger.LogInformation("HLS process has completed for channel {Channel}", _channelNumber);
-
-                _transcodedUntil = processModel.Until;
             }
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Error transcoding channel {Channel}", _channelNumber);
-            
+
             try
             {
                 IClient client = scope.ServiceProvider.GetRequiredService<IClient>();
@@ -234,73 +301,87 @@ public class HlsSessionWorker : IHlsSessionWorker
             Interlocked.Decrement(ref _workAheadCount);
         }
 
-        return true;
+        return false;
     }
 
     private async Task TrimAndDelete(CancellationToken cancellationToken)
     {
-        Option<string[]> maybeLines = await ReadPlaylistLines(cancellationToken);
-        foreach (string[] lines in maybeLines)
+        await Slim.WaitAsync(cancellationToken);
+        try
         {
-            // trim playlist and insert discontinuity before appending with new ffmpeg process
-            TrimPlaylistResult trimResult = _hlsPlaylistFilter.TrimPlaylistWithDiscontinuity(
-                _playlistStart,
-                DateTimeOffset.Now.AddMinutes(-1),
-                lines);
-            await WritePlaylist(trimResult.Playlist, cancellationToken);
 
-            // delete old segments
-            var allSegments = Directory.GetFiles(
-                    Path.Combine(FileSystemLayout.TranscodeFolder, _channelNumber),
-                    "live*.ts")
-                .Map(
-                    file =>
-                    {
-                        string fileName = Path.GetFileName(file);
-                        var sequenceNumber = int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]);
-                        return new Segment(file, sequenceNumber);
-                    })
-                .ToList();
-
-            var toDelete = allSegments.Filter(s => s.SequenceNumber < trimResult.Sequence).ToList();
-            // if (toDelete.Count > 0)
-            // {
-            // _logger.LogInformation(
-            //     "Deleting HLS segments {Min} to {Max} (less than {StartSequence})",
-            //     toDelete.Map(s => s.SequenceNumber).Min(),
-            //     toDelete.Map(s => s.SequenceNumber).Max(),
-            //     trimResult.Sequence);
-            // }
-
-            foreach (Segment segment in toDelete)
+            Option<string[]> maybeLines = await ReadPlaylistLines(cancellationToken);
+            foreach (string[] lines in maybeLines)
             {
-                File.Delete(segment.File);
-            }
+                // trim playlist and insert discontinuity before appending with new ffmpeg process
+                TrimPlaylistResult trimResult = _hlsPlaylistFilter.TrimPlaylistWithDiscontinuity(
+                    _playlistStart,
+                    DateTimeOffset.Now.AddMinutes(-1),
+                    lines);
+                await WritePlaylist(trimResult.Playlist, cancellationToken);
 
-            _playlistStart = trimResult.PlaylistStart;
+                // delete old segments
+                var allSegments = Directory.GetFiles(
+                        Path.Combine(FileSystemLayout.TranscodeFolder, _channelNumber),
+                        "live*.ts")
+                    .Map(
+                        file =>
+                        {
+                            string fileName = Path.GetFileName(file);
+                            var sequenceNumber = int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]);
+                            return new Segment(file, sequenceNumber);
+                        })
+                    .ToList();
+
+                var toDelete = allSegments.Filter(s => s.SequenceNumber < trimResult.Sequence).ToList();
+                // if (toDelete.Count > 0)
+                // {
+                // _logger.LogInformation(
+                //     "Deleting HLS segments {Min} to {Max} (less than {StartSequence})",
+                //     toDelete.Map(s => s.SequenceNumber).Min(),
+                //     toDelete.Map(s => s.SequenceNumber).Max(),
+                //     trimResult.Sequence);
+                // }
+
+                foreach (Segment segment in toDelete)
+                {
+                    File.Delete(segment.File);
+                }
+
+                _playlistStart = trimResult.PlaylistStart;
+            }
+        }
+        finally
+        {
+            Slim.Release();
         }
     }
 
-    private async Task<long> GetPtsOffset(IMediator mediator, string channelNumber, CancellationToken cancellationToken)
+    private static async Task<long> GetPtsOffset(
+        IMediator mediator,
+        string channelNumber,
+        CancellationToken cancellationToken)
     {
-        var directory = new DirectoryInfo(Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber));
-        Option<FileInfo> lastSegment =
-            Optional(directory.GetFiles("*.ts").OrderByDescending(f => f.Name).FirstOrDefault());
-
-        long result = 0;
-        foreach (FileInfo segment in lastSegment)
+        await Slim.WaitAsync(cancellationToken);
+        try
         {
+            long result = 0;
+
             Either<BaseError, PtsAndDuration> queryResult = await mediator.Send(
-                new GetLastPtsDuration(segment.FullName),
+                new GetLastPtsDuration(channelNumber),
                 cancellationToken);
 
-            foreach (PtsAndDuration ptsAndDuration in queryResult.RightToSeq())
+            foreach ((long pts, long duration) in queryResult.RightToSeq())
             {
-                result = ptsAndDuration.Pts + ptsAndDuration.Duration;
+                result = pts + duration;
             }
-        }
 
-        return result;
+            return result;
+        }
+        finally
+        {
+            Slim.Release();
+        }
     }
 
     private async Task<int> GetWorkAheadLimit()
@@ -313,41 +394,25 @@ public class HlsSessionWorker : IHlsSessionWorker
 
     private async Task<Option<string[]>> ReadPlaylistLines(CancellationToken cancellationToken)
     {
-        await Slim.WaitAsync(cancellationToken);
-        try
+        string fileName = PlaylistFileName();
+        if (File.Exists(fileName))
         {
-            string fileName = PlaylistFileName();
-            if (File.Exists(fileName))
-            {
-                return await File.ReadAllLinesAsync(fileName, cancellationToken);
-            }
+            return await File.ReadAllLinesAsync(fileName, cancellationToken);
+        }
 
-            return None;
-        }
-        finally
-        {
-            Slim.Release();
-        }
+        return None;
     }
-    
+
     private async Task WritePlaylist(string playlist, CancellationToken cancellationToken)
     {
-        await Slim.WaitAsync(cancellationToken);
-        try
-        {
-            string fileName = PlaylistFileName();
-            await File.WriteAllTextAsync(fileName, playlist, cancellationToken);
-        }
-        finally
-        {
-            Slim.Release();
-        }
+        string fileName = PlaylistFileName();
+        await File.WriteAllTextAsync(fileName, playlist, cancellationToken);
     }
 
     private string PlaylistFileName() => Path.Combine(
         FileSystemLayout.TranscodeFolder,
         _channelNumber,
         "live.m3u8");
-    
+
     private record Segment(string File, int SequenceNumber);
 }

ErsatzTV.Application/Streaming/PlayoutItemProcessModel.cs

@@ -1,5 +1,8 @@
-using System.Diagnostics;
+using CliWrap;
 
 namespace ErsatzTV.Application.Streaming;
 
-public record PlayoutItemProcessModel(Process Process, DateTimeOffset Until);
+public record PlayoutItemProcessModel(
+    Command Process,
+    Option<TimeSpan> MaybeDuration,
+    DateTimeOffset Until);

ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs

@@ -17,9 +17,9 @@ public abstract class FFmpegProcessHandler<T> : IRequestHandler<T, Either<BaseEr
     public async Task<Either<BaseError, PlayoutItemProcessModel>> Handle(T request, CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Tuple<Channel, string>> validation = await Validate(dbContext, request);
+        Validation<BaseError, Tuple<Channel, string, string>> validation = await Validate(dbContext, request);
         return await validation.Match(
-            tuple => GetProcess(dbContext, request, tuple.Item1, tuple.Item2),
+            tuple => GetProcess(dbContext, request, tuple.Item1, tuple.Item2, tuple.Item3, cancellationToken),
             error => Task.FromResult<Either<BaseError, PlayoutItemProcessModel>>(error.Join()));
     }
 
@@ -27,13 +27,16 @@ public abstract class FFmpegProcessHandler<T> : IRequestHandler<T, Either<BaseEr
         TvContext dbContext,
         T request,
         Channel channel,
-        string ffmpegPath);
+        string ffmpegPath,
+        string ffprobePath,
+        CancellationToken cancellationToken);
 
-    private static async Task<Validation<BaseError, Tuple<Channel, string>>> Validate(
+    private static async Task<Validation<BaseError, Tuple<Channel, string, string>>> Validate(
         TvContext dbContext,
         T request) =>
-        (await ChannelMustExist(dbContext, request), await FFmpegPathMustExist(dbContext))
-        .Apply((channel, ffmpegPath) => Tuple(channel, ffmpegPath));
+        (await ChannelMustExist(dbContext, request), await FFmpegPathMustExist(dbContext),
+            await FFprobePathMustExist(dbContext))
+        .Apply((channel, ffmpegPath, ffprobePath) => Tuple(channel, ffmpegPath, ffprobePath));
 
     private static Task<Validation<BaseError, Channel>> ChannelMustExist(TvContext dbContext, T request) =>
         dbContext.Channels
@@ -62,4 +65,9 @@ public abstract class FFmpegProcessHandler<T> : IRequestHandler<T, Either<BaseEr
         dbContext.ConfigElements.GetValue<string>(ConfigElementKey.FFmpegPath)
             .FilterT(File.Exists)
             .Map(maybePath => maybePath.ToValidation<BaseError>("FFmpeg path does not exist on filesystem"));
+
+    private static Task<Validation<BaseError, string>> FFprobePathMustExist(TvContext dbContext) =>
+        dbContext.ConfigElements.GetValue<string>(ConfigElementKey.FFprobePath)
+            .FilterT(File.Exists)
+            .Map(maybePath => maybePath.ToValidation<BaseError>("FFprobe path does not exist on filesystem"));
 }

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs

@@ -1,7 +1,6 @@
-using System.Diagnostics;
+using CliWrap;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -11,34 +10,35 @@ namespace ErsatzTV.Application.Streaming;
 
 public class GetConcatProcessByChannelNumberHandler : FFmpegProcessHandler<GetConcatProcessByChannelNumber>
 {
-    private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+    private readonly IFFmpegProcessService _ffmpegProcessService;
 
     public GetConcatProcessByChannelNumberHandler(
         IDbContextFactory<TvContext> dbContextFactory,
-        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
+        IFFmpegProcessService ffmpegProcessService)
         : base(dbContextFactory)
     {
-        _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
+        _ffmpegProcessService = ffmpegProcessService;
     }
 
     protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
         TvContext dbContext,
         GetConcatProcessByChannelNumber request,
         Channel channel,
-        string ffmpegPath)
+        string ffmpegPath,
+        string ffprobePath,
+        CancellationToken cancellationToken)
     {
         bool saveReports = await dbContext.ConfigElements
             .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
             .Map(result => result.IfNone(false));
 
-        IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-        Process process = ffmpegProcessService.ConcatChannel(
+        Command process = _ffmpegProcessService.ConcatChannel(
             ffmpegPath,
             saveReports,
             channel,
             request.Scheme,
             request.Host);
 
-        return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
+        return new PlayoutItemProcessModel(process, Option<TimeSpan>.None, DateTimeOffset.MaxValue);
     }
 }

ErsatzTV.Application/Streaming/Queries/GetErrorProcess.cs

@@ -0,0 +1,16 @@
+namespace ErsatzTV.Application.Streaming;
+
+public record GetErrorProcess(
+    string ChannelNumber,
+    string Mode,
+    bool HlsRealtime,
+    long PtsOffset,
+    Option<TimeSpan> MaybeDuration,
+    DateTimeOffset Until,
+    string ErrorMessage) : FFmpegProcessRequest(
+    ChannelNumber,
+    Mode,
+    DateTimeOffset.Now,
+    true,
+    HlsRealtime,
+    PtsOffset);

ErsatzTV.Application/Streaming/Queries/GetErrorProcessHandler.cs

@@ -0,0 +1,40 @@
+using CliWrap;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Streaming;
+
+public class GetErrorProcessHandler : FFmpegProcessHandler<GetErrorProcess>
+{
+    private readonly IFFmpegProcessService _ffmpegProcessService;
+
+    public GetErrorProcessHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IFFmpegProcessService ffmpegProcessService)
+        : base(dbContextFactory)
+    {
+        _ffmpegProcessService = ffmpegProcessService;
+    }
+
+    protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
+        TvContext dbContext,
+        GetErrorProcess request,
+        Channel channel,
+        string ffmpegPath,
+        string ffprobePath,
+        CancellationToken cancellationToken)
+    {
+        Command process = await _ffmpegProcessService.ForError(
+            ffmpegPath,
+            channel,
+            request.MaybeDuration,
+            request.ErrorMessage,
+            request.HlsRealtime,
+            request.PtsOffset);
+
+        return new PlayoutItemProcessModel(process, request.MaybeDuration, request.Until);
+    }
+}

ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumberHandler.cs

@@ -25,10 +25,10 @@ public class GetHlsPlaylistByChannelNumberHandler :
         GetHlsPlaylistByChannelNumber request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         DateTimeOffset now = DateTimeOffset.Now;
         Validation<BaseError, Parameters> validation = await Validate(dbContext, request, now);
-        return await LanguageExtensions.Apply(validation, parameters => GetPlaylist(dbContext, request, parameters, now));
+        return await validation.Apply(parameters => GetPlaylist(dbContext, request, parameters, now));
     }
 
     private Task<string> GetPlaylist(

ErsatzTV.Application/Streaming/Queries/GetLastPtsDuration.cs

@@ -2,4 +2,4 @@
 
 namespace ErsatzTV.Application.Streaming;
 
-public record GetLastPtsDuration(string FileName) : IRequest<Either<BaseError, PtsAndDuration>>;
+public record GetLastPtsDuration(string ChannelNumber) : IRequest<Either<BaseError, PtsAndDuration>>;

ErsatzTV.Application/Streaming/Queries/GetLastPtsDurationHandler.cs

@@ -1,18 +1,38 @@
-using System.Diagnostics;
-using System.Text;
+using System.Text;
+using Bugsnag;
+using CliWrap;
+using CliWrap.Buffered;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
 
 namespace ErsatzTV.Application.Streaming;
 
 public class GetLastPtsDurationHandler : IRequestHandler<GetLastPtsDuration, Either<BaseError, PtsAndDuration>>
 {
+    private readonly IClient _client;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ITempFilePool _tempFilePool;
     private readonly IConfigElementRepository _configElementRepository;
+    private readonly ILogger<GetLastPtsDurationHandler> _logger;
 
-    public GetLastPtsDurationHandler(IConfigElementRepository configElementRepository)
+    public GetLastPtsDurationHandler(
+        IClient client,
+        ILocalFileSystem localFileSystem,
+        ITempFilePool tempFilePool,
+        IConfigElementRepository configElementRepository,
+        ILogger<GetLastPtsDurationHandler> logger)
     {
+        _client = client;
+        _localFileSystem = localFileSystem;
+        _tempFilePool = tempFilePool;
         _configElementRepository = configElementRepository;
+        _logger = logger;
     }
 
     public async Task<Either<BaseError, PtsAndDuration>> Handle(
@@ -21,61 +41,118 @@ public class GetLastPtsDurationHandler : IRequestHandler<GetLastPtsDuration, Eit
     {
         Validation<BaseError, RequestParameters> validation = await Validate(request);
         return await validation.Match(
-            Handle,
+            parameters => Handle(parameters, cancellationToken),
             error => Task.FromResult<Either<BaseError, PtsAndDuration>>(error.Join()));
     }
 
     private async Task<Validation<BaseError, RequestParameters>> Validate(GetLastPtsDuration request) =>
-        await ValidateFFprobePath()
-            .MapT(
-                ffprobePath => new RequestParameters(
-                    request.FileName,
-                    ffprobePath));
+        await ValidateFFprobePath().MapT(ffprobePath => new RequestParameters(request.ChannelNumber, ffprobePath));
 
-    private async Task<Either<BaseError, PtsAndDuration>> Handle(RequestParameters parameters)
+    private async Task<Either<BaseError, PtsAndDuration>> Handle(
+        RequestParameters parameters,
+        CancellationToken cancellationToken)
     {
-        var startInfo = new ProcessStartInfo
+        Option<FileInfo> maybeLastSegment = GetLastSegment(parameters.ChannelNumber);
+        foreach (FileInfo segment in maybeLastSegment)
         {
-            FileName = parameters.FFprobePath,
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
-            UseShellExecute = false,
-            StandardOutputEncoding = Encoding.UTF8,
-            StandardErrorEncoding = Encoding.UTF8
-        };
-
-        startInfo.ArgumentList.Add("-v");
-        startInfo.ArgumentList.Add("0");
-        startInfo.ArgumentList.Add("-show_entries");
-        startInfo.ArgumentList.Add("packet=pts,duration");
-        startInfo.ArgumentList.Add("-of");
-        startInfo.ArgumentList.Add("compact=p=0:nk=1");
-        startInfo.ArgumentList.Add("-read_intervals");
-        startInfo.ArgumentList.Add("-999999");
-        startInfo.ArgumentList.Add(parameters.FileName);
-
-        var probe = new Process
-        {
-            StartInfo = startInfo
-        };
-
-        probe.Start();
-        return await probe.StandardOutput.ReadToEndAsync().MapAsync<string, Either<BaseError, PtsAndDuration>>(
-            async output =>
+            string[] argumentList =
             {
-                await probe.WaitForExitAsync();
-                return probe.ExitCode == 0
-                    ? PtsAndDuration.From(output.Split("\n").Filter(s => !string.IsNullOrWhiteSpace(s)).Last().Trim())
-                    : BaseError.New($"FFprobe at {parameters.FFprobePath} exited with code {probe.ExitCode}");
-            });
+                "-v", "0",
+                "-show_entries",
+                "packet=pts,duration",
+                "-of", "compact=p=0:nk=1",
+                // "-read_intervals", "999999", // read_intervals causes inconsistent behavior on windows
+                segment.FullName
+            };
+
+            string lastLine = string.Empty;
+            Action<string> replaceLine = s =>
+            {
+                if (!string.IsNullOrWhiteSpace(s))
+                {
+                    lastLine = s.Trim();
+                }
+            };
+
+            CommandResult probe = await Cli.Wrap(parameters.FFprobePath)
+                .WithArguments(argumentList)
+                .WithValidation(CommandResultValidation.None)
+                .WithStandardOutputPipe(PipeTarget.ToDelegate(replaceLine))
+                .ExecuteAsync(cancellationToken);
+
+            if (probe.ExitCode != 0)
+            {
+                return BaseError.New($"FFprobe at {parameters.FFprobePath} exited with code {probe.ExitCode}");
+            }
+
+            try
+            {
+                return PtsAndDuration.From(lastLine);
+            }
+            catch (Exception ex)
+            {
+                _client.Notify(ex);
+                await SaveTroubleshootingData(parameters.ChannelNumber, lastLine);
+            }
+        }
+
+        return BaseError.New($"Failed to determine last pts duration for channel {parameters.ChannelNumber}");
     }
 
+    private static Option<FileInfo> GetLastSegment(string channelNumber)
+    {
+        var directory = new DirectoryInfo(Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber));
+        return Optional(directory.GetFiles("*.ts").OrderByDescending(f => f.Name).FirstOrDefault());
+    }
+    
     private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
         _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
             .FilterT(File.Exists)
-            .Map(
-                ffprobePath =>
-                    ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
+            .Map(ffprobePath => ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
 
-    private record RequestParameters(string FileName, string FFprobePath);
+    private async Task SaveTroubleshootingData(string channelNumber, string output)
+    {
+        try
+        {
+            var directory = new DirectoryInfo(Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber));
+            FileInfo[] allFiles = directory.GetFiles();
+
+            string playlistFileName = Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber, "live.m3u8");
+            string playlistContents = string.Empty;
+            if (_localFileSystem.FileExists(playlistFileName))
+            {
+                playlistContents = await File.ReadAllTextAsync(playlistFileName);
+            }
+
+            var data = new TroubleshootingData(allFiles, playlistContents, output);
+            string serialized = data.Serialize();
+
+            string file = _tempFilePool.GetNextTempFile(TempFileCategory.BadTranscodeFolder);
+            await File.WriteAllTextAsync(file, serialized);
+
+            _logger.LogWarning("Transcode folder is in bad state; troubleshooting info saved to {File}", file);
+        }
+        catch (Exception ex)
+        {
+            _client.Notify(ex);
+        }
+    }
+
+    private record RequestParameters(string ChannelNumber, string FFprobePath);
+
+    private record TroubleshootingData(IEnumerable<FileInfo> Files, string Playlist, string ProbeOutput)
+    {
+        private record FileData(string FileName, long Bytes, DateTime LastWriteTimeUtc);
+        private record InternalData(List<FileData> Files, string EncodedPlaylist, string EncodedProbeOutput);
+
+        public string Serialize()
+        {
+            var data = new InternalData(
+                Files.Map(f => new FileData(f.FullName, f.Length, f.LastWriteTimeUtc)).ToList(),
+                Convert.ToBase64String(Encoding.UTF8.GetBytes(Playlist)),
+                Convert.ToBase64String(Encoding.UTF8.GetBytes(ProbeOutput)));
+
+            return JsonConvert.SerializeObject(data);
+        }
+    }
 }

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -1,10 +1,9 @@
-using System.Diagnostics;
+using CliWrap;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Extensions;
-using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Jellyfin;
@@ -25,14 +24,14 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
     private readonly ITelevisionRepository _televisionRepository;
     private readonly IArtistRepository _artistRepository;
     private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
-    private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+    private readonly IFFmpegProcessService _ffmpegProcessService;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly IPlexPathReplacementService _plexPathReplacementService;
     private readonly ISongVideoGenerator _songVideoGenerator;
 
     public GetPlayoutItemProcessByChannelNumberHandler(
         IDbContextFactory<TvContext> dbContextFactory,
-        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
+        IFFmpegProcessService ffmpegProcessService,
         ILocalFileSystem localFileSystem,
         IPlexPathReplacementService plexPathReplacementService,
         IJellyfinPathReplacementService jellyfinPathReplacementService,
@@ -43,7 +42,7 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
         ISongVideoGenerator songVideoGenerator)
         : base(dbContextFactory)
     {
-        _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
+        _ffmpegProcessService = ffmpegProcessService;
         _localFileSystem = localFileSystem;
         _plexPathReplacementService = plexPathReplacementService;
         _jellyfinPathReplacementService = jellyfinPathReplacementService;
@@ -58,7 +57,9 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
         TvContext dbContext,
         GetPlayoutItemProcessByChannelNumber request,
         Channel channel,
-        string ffmpegPath)
+        string ffmpegPath,
+        string ffprobePath,
+        CancellationToken cancellationToken)
     {
         DateTimeOffset now = request.Now;
 
@@ -96,6 +97,7 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
             .Include(i => i.MediaItem)
             .ThenInclude(mi => (mi as Song).SongMetadata)
             .ThenInclude(sm => sm.Artwork)
+            .Include(i => i.Watermark)
             .ForChannelAndTime(channel.Id, now)
             .Map(o => o.ToEither<BaseError>(new UnableToLocatePlayoutItem()))
             .BindT(ValidatePlayoutItemPath);
@@ -105,8 +107,6 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
             maybePlayoutItem = await CheckForFallbackFiller(dbContext, channel, now);
         }
 
-        IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-
         foreach (PlayoutItemWithPath playoutItemWithPath in maybePlayoutItem.RightToSeq())
         {
             MediaVersion version = playoutItemWithPath.PlayoutItem.MediaItem.GetHeadVersion();
@@ -128,16 +128,20 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
                 (videoPath, videoVersion) = await _songVideoGenerator.GenerateSongVideo(
                     song,
                     channel,
+                    Optional(playoutItemWithPath.PlayoutItem.Watermark),
                     maybeGlobalWatermark,
-                    ffmpegPath);
+                    ffmpegPath,
+                    ffprobePath,
+                    cancellationToken);
             }
 
             bool saveReports = await dbContext.ConfigElements
                 .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
                 .Map(result => result.IfNone(false));
 
-            Process process = await ffmpegProcessService.ForPlayoutItem(
+            Command process = await _ffmpegProcessService.ForPlayoutItem(
                 ffmpegPath,
+                ffprobePath,
                 saveReports,
                 channel,
                 videoVersion,
@@ -147,6 +151,7 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
                 playoutItemWithPath.PlayoutItem.StartOffset,
                 playoutItemWithPath.PlayoutItem.FinishOffset,
                 request.StartAtZero ? playoutItemWithPath.PlayoutItem.StartOffset : now,
+                Optional(playoutItemWithPath.PlayoutItem.Watermark),
                 maybeGlobalWatermark,
                 channel.FFmpegProfile.VaapiDriver,
                 channel.FFmpegProfile.VaapiDevice,
@@ -157,92 +162,58 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
                 request.PtsOffset,
                 request.TargetFramerate);
 
-            var result = new PlayoutItemProcessModel(process, playoutItemWithPath.PlayoutItem.FinishOffset);
+            var result = new PlayoutItemProcessModel(
+                process,
+                playoutItemWithPath.PlayoutItem.FinishOffset - (request.StartAtZero ? playoutItemWithPath.PlayoutItem.StartOffset : now),
+                playoutItemWithPath.PlayoutItem.FinishOffset);
 
             return Right<BaseError, PlayoutItemProcessModel>(result);
         }
 
         foreach (BaseError error in maybePlayoutItem.LeftToSeq())
         {
-            var offlineTranscodeMessage =
-                $"offline image is unavailable because transcoding is disabled in ffmpeg profile '{channel.FFmpegProfile.Name}'";
-
-            Option<TimeSpan> maybeDuration = await Optional(channel.FFmpegProfile.Transcode)
-                .Where(transcode => transcode)
-                .Match(
-                    _ => dbContext.PlayoutItems
+            Option<TimeSpan> maybeDuration = await dbContext.PlayoutItems
                         .Filter(pi => pi.Playout.ChannelId == channel.Id)
                         .Filter(pi => pi.Start > now.UtcDateTime)
                         .OrderBy(pi => pi.Start)
-                        .FirstOrDefaultAsync()
+                        .FirstOrDefaultAsync(cancellationToken)
                         .Map(Optional)
-                        .MapT(pi => pi.StartOffset - now),
-                    () => Option<TimeSpan>.None.AsTask());
+                        .MapT(pi => pi.StartOffset - now);
 
             DateTimeOffset finish = maybeDuration.Match(d => now.Add(d), () => now);
 
             switch (error)
             {
                 case UnableToLocatePlayoutItem:
-                    if (channel.FFmpegProfile.Transcode)
-                    {
-                        Process errorProcess = await ffmpegProcessService.ForError(
-                            ffmpegPath,
-                            channel,
-                            maybeDuration,
-                            "Channel is Offline",
-                            request.HlsRealtime,
-                            request.PtsOffset);
+                    Command offlineProcess = await _ffmpegProcessService.ForError(
+                        ffmpegPath,
+                        channel,
+                        maybeDuration,
+                        "Channel is Offline",
+                        request.HlsRealtime,
+                        request.PtsOffset);
 
-                        return new PlayoutItemProcessModel(errorProcess, finish);
-                    }
-                    else
-                    {
-                        var message =
-                            $"Unable to locate playout item for channel {channel.Number}; {offlineTranscodeMessage}";
-
-                        return BaseError.New(message);
-                    }
+                    return new PlayoutItemProcessModel(offlineProcess, maybeDuration, finish);
                 case PlayoutItemDoesNotExistOnDisk:
-                    if (channel.FFmpegProfile.Transcode)
-                    {
-                        Process errorProcess = await ffmpegProcessService.ForError(
-                            ffmpegPath,
-                            channel,
-                            maybeDuration,
-                            error.Value,
-                            request.HlsRealtime,
-                            request.PtsOffset);
+                    Command doesNotExistProcess = await _ffmpegProcessService.ForError(
+                        ffmpegPath,
+                        channel,
+                        maybeDuration,
+                        error.Value,
+                        request.HlsRealtime,
+                        request.PtsOffset);
 
-                        return new PlayoutItemProcessModel(errorProcess, finish);
-                    }
-                    else
-                    {
-                        var message =
-                            $"Playout item does not exist on disk for channel {channel.Number}; {offlineTranscodeMessage}";
-
-                        return BaseError.New(message);
-                    }
+                    return new PlayoutItemProcessModel(doesNotExistProcess, maybeDuration, finish);
                 default:
-                    if (channel.FFmpegProfile.Transcode)
-                    {
-                        Process errorProcess = await ffmpegProcessService.ForError(
-                            ffmpegPath,
-                            channel,
-                            maybeDuration,
-                            "Channel is Offline",
-                            request.HlsRealtime,
-                            request.PtsOffset);
+                    Command errorProcess = await _ffmpegProcessService.ForError(
+                        ffmpegPath,
+                        channel,
+                        maybeDuration,
+                        "Channel is Offline",
+                        request.HlsRealtime,
+                        request.PtsOffset);
 
-                        return new PlayoutItemProcessModel(errorProcess, finish);
-                    }
-                    else
-                    {
-                        var message =
-                            $"Unexpected error locating playout item for channel {channel.Number}; {offlineTranscodeMessage}";
-
-                        return BaseError.New(message);
-                    }
+                    return new PlayoutItemProcessModel(errorProcess, maybeDuration, finish);
             }
         }
 
@@ -280,17 +251,13 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
             // TODO: shuffle? does it really matter since we loop anyway
             MediaItem item = items[new Random().Next(items.Count)];
                 
-            Option<TimeSpan> maybeDuration = await Optional(channel.FFmpegProfile.Transcode)
-                .Where(transcode => transcode)
-                .Match(
-                    _ => dbContext.PlayoutItems
+            Option<TimeSpan> maybeDuration = await dbContext.PlayoutItems
                         .Filter(pi => pi.Playout.ChannelId == channel.Id)
                         .Filter(pi => pi.Start > now.UtcDateTime)
                         .OrderBy(pi => pi.Start)
                         .FirstOrDefaultAsync()
                         .Map(Optional)
-                        .MapT(pi => pi.StartOffset - now),
-                    () => Option<TimeSpan>.None.AsTask());
+                        .MapT(pi => pi.StartOffset - now);
 
             MediaVersion version = item.GetHeadVersion();
 

ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumberHandler.cs

@@ -1,7 +1,6 @@
-using System.Diagnostics;
+using CliWrap;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -11,34 +10,35 @@ namespace ErsatzTV.Application.Streaming;
 
 public class GetWrappedProcessByChannelNumberHandler : FFmpegProcessHandler<GetWrappedProcessByChannelNumber>
 {
-    private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+    private readonly IFFmpegProcessService _ffmpegProcessService;
 
     public GetWrappedProcessByChannelNumberHandler(
         IDbContextFactory<TvContext> dbContextFactory,
-        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
+        IFFmpegProcessService ffmpegProcessService)
         : base(dbContextFactory)
     {
-        _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
+        _ffmpegProcessService = ffmpegProcessService;
     }
 
     protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
         TvContext dbContext,
         GetWrappedProcessByChannelNumber request,
         Channel channel,
-        string ffmpegPath)
+        string ffmpegPath,
+        string ffprobePath,
+        CancellationToken cancellationToken)
     {
         bool saveReports = await dbContext.ConfigElements
             .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
             .Map(result => result.IfNone(false));
 
-        IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-        Process process = ffmpegProcessService.WrapSegmenter(
+        Command process = _ffmpegProcessService.WrapSegmenter(
             ffmpegPath,
             saveReports,
             channel,
             request.Scheme,
             request.Host);
 
-        return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
+        return new PlayoutItemProcessModel(process, Option<TimeSpan>.None, DateTimeOffset.MaxValue);
     }
 }

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

@@ -7,20 +7,22 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Bugsnag" Version="3.0.0" />
-      <PackageReference Include="FluentAssertions" Version="6.5.1" />
-      <PackageReference Include="LanguageExt.Core" Version="4.0.3" />
+      <PackageReference Include="Bugsnag" Version="3.0.1" />
+      <PackageReference Include="CliWrap" Version="3.4.2" />
+      <PackageReference Include="FluentAssertions" Version="6.6.0" />
+      <PackageReference Include="LanguageExt.Core" Version="4.0.4" />
+      <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="6.0.1" />
       <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
       <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.1" />
       <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="6.0.0" />
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
       <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.1.46">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Moq" Version="4.17.1" />
-      <PackageReference Include="NUnit" Version="3.13.2" />
+      <PackageReference Include="Moq" Version="4.17.2" />
+      <PackageReference Include="NUnit" Version="3.13.3" />
       <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.Extensions.Logging" Version="3.1.0" />
@@ -35,6 +37,9 @@
       <Content Include="Resources\ErsatzTV.png">
         <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       </Content>
+      <Content Include="Resources\test.sup">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </Content>
     </ItemGroup>
 
 </Project>

ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs

@@ -9,13 +9,15 @@ namespace ErsatzTV.Core.Tests.FFmpeg;
 [TestFixture]
 public class FFmpegPlaybackSettingsCalculatorTests
 {
+    private static readonly MediaVersion TestVersion = new() { SampleAspectRatio = "1:1", Width = 1920, Height = 1080 };
+
     [TestFixture]
     public class CalculateSettings
     {
         private readonly FFmpegPlaybackSettingsCalculator _calculator;
 
         public CalculateSettings() => _calculator = new FFmpegPlaybackSettingsCalculator();
-            
+
         [Test]
         public void Should_Not_GenPts_ForHlsSegmenter()
         {
@@ -24,7 +26,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.HttpLiveStreamingSegmenter,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 DateTimeOffset.Now,
@@ -47,7 +49,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 DateTimeOffset.Now,
@@ -68,7 +70,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.HttpLiveStreamingSegmenter,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 DateTimeOffset.Now,
@@ -89,7 +91,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 DateTimeOffset.Now,
@@ -112,7 +114,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.HttpLiveStreamingDirect,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 DateTimeOffset.Now,
@@ -135,7 +137,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 DateTimeOffset.Now,
@@ -156,7 +158,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.HttpLiveStreamingDirect,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 DateTimeOffset.Now,
@@ -179,7 +181,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 now,
@@ -203,7 +205,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.HttpLiveStreamingDirect,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 now,
@@ -217,33 +219,11 @@ public class FFmpegPlaybackSettingsCalculatorTests
             actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
         }
 
-        [Test]
-        public void ShouldNot_SetScaledSize_When_NotNormalizingVideo_ForTransportStream()
-        {
-            FFmpegProfile ffmpegProfile = TestProfile() with { NormalizeVideo = false };
-
-            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                StreamingMode.TransportStream,
-                ffmpegProfile,
-                new MediaVersion(),
-                new MediaStream(),
-                new MediaStream(),
-                DateTimeOffset.Now,
-                DateTimeOffset.Now,
-                TimeSpan.Zero,
-                TimeSpan.Zero,
-                false,
-                None);
-
-            actual.ScaledSize.IsNone.Should().BeTrue();
-        }
-
         [Test]
         public void ShouldNot_SetScaledSize_When_ContentIsCorrectSize_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 }
             };
 
@@ -271,7 +251,6 @@ public class FFmpegPlaybackSettingsCalculatorTests
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 }
             };
 
@@ -299,7 +278,6 @@ public class FFmpegPlaybackSettingsCalculatorTests
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 }
             };
 
@@ -328,8 +306,6 @@ public class FFmpegPlaybackSettingsCalculatorTests
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 }
             };
 
@@ -358,8 +334,6 @@ public class FFmpegPlaybackSettingsCalculatorTests
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1280, Height = 720 }
             };
 
@@ -389,8 +363,6 @@ public class FFmpegPlaybackSettingsCalculatorTests
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 }
             };
 
@@ -414,45 +386,14 @@ public class FFmpegPlaybackSettingsCalculatorTests
             actual.PadToDesiredResolution.Should().BeFalse();
         }
 
-        [Test]
-        public void Should_NotPadToDesiredResolution_When_NotNormalizingVideo()
-        {
-            FFmpegProfile ffmpegProfile = TestProfile() with
-            {
-                Transcode = true,
-                NormalizeVideo = false,
-                Resolution = new Resolution { Width = 1920, Height = 1080 }
-            };
-
-            // not anamorphic
-            var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
-
-            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                StreamingMode.TransportStream,
-                ffmpegProfile,
-                version,
-                new MediaStream(),
-                new MediaStream(),
-                DateTimeOffset.Now,
-                DateTimeOffset.Now,
-                TimeSpan.Zero,
-                TimeSpan.Zero,
-                false,
-                None);
-
-            actual.ScaledSize.IsNone.Should().BeTrue();
-            actual.PadToDesiredResolution.Should().BeFalse();
-        }
 
         [Test]
-        public void Should_SetDesiredVideoCodec_When_ContentIsPadded_ForTransportStream()
+        public void Should_SetDesiredVideoFormat_When_ContentIsPadded_ForTransportStream()
         {
             var ffmpegProfile = new FFmpegProfile
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 },
-                VideoCodec = "testCodec"
+                VideoFormat = FFmpegProfileVideoFormat.H264
             };
 
             // not anamorphic
@@ -473,19 +414,17 @@ public class FFmpegPlaybackSettingsCalculatorTests
 
             actual.ScaledSize.IsNone.Should().BeTrue();
             actual.PadToDesiredResolution.Should().BeTrue();
-            actual.VideoCodec.Should().Be("testCodec");
+            actual.VideoFormat.Should().Be(FFmpegProfileVideoFormat.H264);
         }
 
         [Test]
         public void
-            Should_SetDesiredVideoCodec_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
+            Should_SetDesiredVideoFormat_When_ContentIsCorrectSize_ForTransportStream()
         {
             var ffmpegProfile = new FFmpegProfile
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 },
-                VideoCodec = "testCodec"
+                VideoFormat = FFmpegProfileVideoFormat.H264
             };
 
             // not anamorphic
@@ -507,19 +446,16 @@ public class FFmpegPlaybackSettingsCalculatorTests
 
             actual.ScaledSize.IsNone.Should().BeTrue();
             actual.PadToDesiredResolution.Should().BeFalse();
-            actual.VideoCodec.Should().Be("testCodec");
+            actual.VideoFormat.Should().Be(FFmpegProfileVideoFormat.H264);
         }
 
         [Test]
-        public void
-            Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NormalizingVideo_ForHttpLiveStreaming()
+        public void Should_SetCopyVideoFormat_When_ContentIsCorrectSize_ForHttpLiveStreamingDirect()
         {
             var ffmpegProfile = new FFmpegProfile
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 },
-                VideoCodec = "testCodec"
+                VideoFormat = FFmpegProfileVideoFormat.H264
             };
 
             // not anamorphic
@@ -541,18 +477,16 @@ public class FFmpegPlaybackSettingsCalculatorTests
 
             actual.ScaledSize.IsNone.Should().BeTrue();
             actual.PadToDesiredResolution.Should().BeFalse();
-            actual.VideoCodec.Should().Be("copy");
+            actual.VideoFormat.Should().Be(FFmpegProfileVideoFormat.Copy);
         }
 
         [Test]
-        public void Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_CorrectCodec_ForTransportStream()
+        public void Should_NotSetCopyVideoFormat_When_ContentIsCorrectSize_And_CorrectFormat_ForTransportStream()
         {
             var ffmpegProfile = new FFmpegProfile
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 },
-                VideoCodec = "libx264"
+                VideoFormat = FFmpegProfileVideoFormat.H264
             };
 
             // not anamorphic
@@ -563,7 +497,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
                 StreamingMode.TransportStream,
                 ffmpegProfile,
                 version,
-                new MediaStream { Codec = "libx264" },
+                new MediaStream { Codec = "h264" },
                 new MediaStream(),
                 DateTimeOffset.Now,
                 DateTimeOffset.Now,
@@ -574,79 +508,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
 
             actual.ScaledSize.IsNone.Should().BeTrue();
             actual.PadToDesiredResolution.Should().BeFalse();
-            actual.VideoCodec.Should().Be("copy");
-        }
-
-        [Test]
-        public void
-            Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NotNormalizingVideo_ForTransportStream()
-        {
-            var ffmpegProfile = new FFmpegProfile
-            {
-                Transcode = true,
-                NormalizeVideo = false,
-                Resolution = new Resolution { Width = 1920, Height = 1080 },
-                VideoCodec = "libx264"
-            };
-
-            // not anamorphic
-            var version = new MediaVersion
-                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                StreamingMode.TransportStream,
-                ffmpegProfile,
-                version,
-                new MediaStream { Codec = "mpeg2video" },
-                new MediaStream(),
-                DateTimeOffset.Now,
-                DateTimeOffset.Now,
-                TimeSpan.Zero,
-                TimeSpan.Zero,
-                false,
-                None);
-
-            actual.ScaledSize.IsNone.Should().BeTrue();
-            actual.PadToDesiredResolution.Should().BeFalse();
-            actual.VideoCodec.Should().Be("copy");
-        }
-            
-        [Test]
-        public void
-            Should_SetCopyVideoCodec_AndCopyAudioCodec_When_NotTranscoding_ForTransportStream()
-        {
-            var ffmpegProfile = new FFmpegProfile
-            {
-                Transcode = false,
-                NormalizeVideo = true,
-                NormalizeAudio = true,
-                NormalizeLoudness = true,
-                Resolution = new Resolution { Width = 1920, Height = 1080 },
-                VideoCodec = "libx264"
-            };
-
-            // not anamorphic
-            var version = new MediaVersion
-                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                StreamingMode.TransportStream,
-                ffmpegProfile,
-                version,
-                new MediaStream { Codec = "mpeg2video" },
-                new MediaStream(),
-                DateTimeOffset.Now,
-                DateTimeOffset.Now,
-                TimeSpan.Zero,
-                TimeSpan.Zero,
-                false,
-                None);
-
-            actual.ScaledSize.IsNone.Should().BeTrue();
-            actual.PadToDesiredResolution.Should().BeFalse();
-            actual.VideoCodec.Should().Be("copy");
-            actual.NormalizeLoudness.Should().BeFalse();
-            actual.AudioCodec.Should().Be("copy");
+            actual.VideoFormat.Should().Be(FFmpegProfileVideoFormat.H264);
         }
 
         [Test]
@@ -654,8 +516,6 @@ public class FFmpegPlaybackSettingsCalculatorTests
         {
             var ffmpegProfile = new FFmpegProfile
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 },
                 VideoBitrate = 2525
             };
@@ -682,12 +542,10 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetVideoBitrate_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
+        public void Should_SetVideoBitrate_When_ContentIsCorrectSize_ForTransportStream()
         {
             var ffmpegProfile = new FFmpegProfile
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 },
                 VideoBitrate = 2525
             };
@@ -719,8 +577,6 @@ public class FFmpegPlaybackSettingsCalculatorTests
         {
             var ffmpegProfile = new FFmpegProfile
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 },
                 VideoBufferSize = 2525
             };
@@ -747,13 +603,10 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void
-            Should_SetVideoBufferSize_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
+        public void Should_SetVideoBufferSize_When_ContentIsCorrectSize_ForTransportStream()
         {
             var ffmpegProfile = new FFmpegProfile
             {
-                Transcode = true,
-                NormalizeVideo = true,
                 Resolution = new Resolution { Width = 1920, Height = 1080 },
                 VideoBufferSize = 2525
             };
@@ -781,21 +634,17 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetDesiredAudioCodec_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        public void Should_SetDesiredAudioFormat_With_CorrectFormat_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
-                AudioCodec = "aac"
+                AudioFormat = FFmpegProfileAudioFormat.Aac
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "aac" },
                 DateTimeOffset.Now,
@@ -805,24 +654,21 @@ public class FFmpegPlaybackSettingsCalculatorTests
                 false,
                 None);
 
-            actual.AudioCodec.Should().Be("aac");
+            actual.AudioFormat.Should().Be(FFmpegProfileAudioFormat.Aac);
         }
 
         [Test]
-        public void Should_SetCopyAudioCodec_When_NotNormalizingAudio_ForTransportStream()
+        public void Should_SetDesiredAudioFormat_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                NormalizeAudio = false,
-                AudioCodec = "aac"
+                AudioFormat = FFmpegProfileAudioFormat.Aac
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -832,53 +678,21 @@ public class FFmpegPlaybackSettingsCalculatorTests
                 false,
                 None);
 
-            actual.AudioCodec.Should().Be("copy");
+            actual.AudioFormat.Should().Be(FFmpegProfileAudioFormat.Aac);
         }
 
         [Test]
-        public void Should_SetDesiredAudioCodec_When_NormalizingAudio_ForTransportStream()
+        public void Should_SetCopyAudioFormat_ForHttpLiveStreamingDirect()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
-                AudioCodec = "aac"
+                AudioFormat = FFmpegProfileAudioFormat.Aac
             };
 
-            var version = new MediaVersion();
-
-            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                StreamingMode.TransportStream,
-                ffmpegProfile,
-                version,
-                new MediaStream(),
-                new MediaStream { Codec = "ac3" },
-                DateTimeOffset.Now,
-                DateTimeOffset.Now,
-                TimeSpan.Zero,
-                TimeSpan.Zero,
-                false,
-                None);
-
-            actual.AudioCodec.Should().Be("aac");
-        }
-
-        [Test]
-        public void Should_SetCopyAudioCodec_When_NormalizingAudio_ForHttpLiveStreaming()
-        {
-            FFmpegProfile ffmpegProfile = TestProfile() with
-            {
-                Transcode = true,
-                NormalizeAudio = true,
-                AudioCodec = "aac"
-            };
-
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.HttpLiveStreamingDirect,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -888,26 +702,22 @@ public class FFmpegPlaybackSettingsCalculatorTests
                 false,
                 None);
 
-            actual.AudioCodec.Should().Be("copy");
+            actual.AudioFormat.Should().Be(FFmpegProfileAudioFormat.Copy);
         }
 
         [Test]
-        public void Should_SetAudioBitrate_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        public void Should_SetAudioBitrate_With_CorrectFormat_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
                 AudioBitrate = 2424,
-                AudioCodec = "ac3"
+                AudioFormat = FFmpegProfileAudioFormat.Ac3
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -921,22 +731,18 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetAudioBufferSize_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        public void Should_SetAudioBufferSize_With_CorrectFormat_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
                 AudioBufferSize = 2424,
-                AudioCodec = "ac3"
+                AudioFormat = FFmpegProfileAudioFormat.Ac3
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -950,22 +756,18 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetAudioChannels_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        public void Should_SetAudioChannels_With_CorrectFormat_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
-                AudioCodec = "ac3",
+                AudioFormat = FFmpegProfileAudioFormat.Ac3,
                 AudioChannels = 6
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -979,22 +781,18 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetAudioSampleRate_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        public void Should_SetAudioSampleRate_With_CorrectFormat_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
-                AudioCodec = "ac3",
+                AudioFormat = FFmpegProfileAudioFormat.Ac3,
                 AudioSampleRate = 48
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -1008,21 +806,17 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetAudioChannels_When_NormalizingAudio_ForTransportStream()
+        public void Should_SetAudioChannels_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
                 AudioChannels = 6
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -1036,21 +830,17 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetAudioSampleRate_When_NormalizingAudio_ForTransportStream()
+        public void Should_SetAudioSampleRate_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
                 AudioSampleRate = 48
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -1064,17 +854,15 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetAudioDuration_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        public void Should_SetAudioDuration_With_CorrectFormat_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
                 AudioSampleRate = 48,
-                AudioCodec = "ac3"
+                AudioFormat = FFmpegProfileAudioFormat.Ac3
             };
 
-            var version = new MediaVersion { Duration = TimeSpan.FromMinutes(5) }; // not pulled from here
+            var version = new MediaVersion { SampleAspectRatio = "1:1", Width = 1920, Height = 1080, Duration = TimeSpan.FromMinutes(5) }; // not pulled from here
 
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
@@ -1093,21 +881,17 @@ public class FFmpegPlaybackSettingsCalculatorTests
         }
 
         [Test]
-        public void Should_SetNormalizeLoudness_When_NormalizingAudio_ForTransportStream()
+        public void Should_SetNormalizeLoudness_ForTransportStream()
         {
             FFmpegProfile ffmpegProfile = TestProfile() with
             {
-                Transcode = true,
-                NormalizeAudio = true,
                 NormalizeLoudness = true
             };
 
-            var version = new MediaVersion();
-
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                version,
+                TestVersion,
                 new MediaStream(),
                 new MediaStream { Codec = "ac3" },
                 DateTimeOffset.Now,
@@ -1119,34 +903,6 @@ public class FFmpegPlaybackSettingsCalculatorTests
 
             actual.NormalizeLoudness.Should().BeTrue();
         }
-
-        [Test]
-        public void Should_NotSetNormalizeLoudness_When_NotNormalizingAudio_ForTransportStream()
-        {
-            FFmpegProfile ffmpegProfile = TestProfile() with
-            {
-                Transcode = true,
-                NormalizeAudio = false,
-                NormalizeLoudness = true
-            };
-
-            var version = new MediaVersion();
-
-            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                StreamingMode.TransportStream,
-                ffmpegProfile,
-                version,
-                new MediaStream(),
-                new MediaStream { Codec = "ac3" },
-                DateTimeOffset.Now,
-                DateTimeOffset.Now,
-                TimeSpan.Zero,
-                TimeSpan.Zero,
-                false,
-                None);
-
-            actual.NormalizeLoudness.Should().BeFalse();
-        }
     }
 
     [TestFixture]
@@ -1165,7 +921,7 @@ public class FFmpegPlaybackSettingsCalculatorTests
             FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
                 StreamingMode.TransportStream,
                 ffmpegProfile,
-                new MediaVersion(),
+                TestVersion,
                 new MediaStream(),
                 new MediaStream(),
                 DateTimeOffset.Now,

ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs

@@ -2,6 +2,7 @@
 using System.Security.Cryptography;
 using System.Text;
 using Bugsnag;
+using CliWrap;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.FFmpeg;
@@ -10,6 +11,7 @@ using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
 using FluentAssertions;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
@@ -63,6 +65,12 @@ public class TranscodingTests
         // TODO: animated vs static
     }
 
+    public enum Subtitle
+    {
+        None,
+        Picture
+    }
+
     private class TestData
     {
         public static Watermark[] Watermarks =
@@ -71,6 +79,12 @@ public class TranscodingTests
             Watermark.PermanentOpaque,
             Watermark.PermanentTransparent
         };
+
+        public static Subtitle[] Subtitles =
+        {
+            Subtitle.None,
+            Subtitle.Picture
+        };
             
         public static Padding[] Paddings =
         {
@@ -117,21 +131,15 @@ public class TranscodingTests
             new() { Width = 1280, Height = 720 }
         };
 
-        public static string[] SoftwareCodecs =
-        {
-            "libx264",
-            "libx265"
-        };
-
         public static HardwareAccelerationKind[] NoAcceleration =
         {
             HardwareAccelerationKind.None
         };
 
-        public static string[] NvidiaCodecs =
+        public static FFmpegProfileVideoFormat[] VideoFormats =
         {
-            "h264_nvenc",
-            "hevc_nvenc"
+            FFmpegProfileVideoFormat.H264,
+            FFmpegProfileVideoFormat.Hevc
         };
 
         public static HardwareAccelerationKind[] NvidiaAcceleration =
@@ -139,34 +147,16 @@ public class TranscodingTests
             HardwareAccelerationKind.Nvenc
         };
 
-        public static string[] VaapiCodecs =
-        {
-            "h264_vaapi",
-            "hevc_vaapi"
-        };
-
         public static HardwareAccelerationKind[] VaapiAcceleration =
         {
             HardwareAccelerationKind.Vaapi
         };
 
-        public static string[] VideoToolboxCodecs =
-        {
-            "h264_videotoolbox",
-            "hevc_videotoolbox"
-        };
-
         public static HardwareAccelerationKind[] VideoToolboxAcceleration =
         {
             HardwareAccelerationKind.VideoToolbox
         };
 
-        public static string[] QsvCodecs =
-        {
-            "h264_qsv",
-            "hevc_qsv"
-        };
-
         public static HardwareAccelerationKind[] QsvAcceleration =
         {
             HardwareAccelerationKind.Qsv
@@ -175,25 +165,17 @@ public class TranscodingTests
 
     [Test, Combinatorial]
     public async Task Transcode(
-            [ValueSource(typeof(TestData), nameof(TestData.InputFormats))]
-            InputFormat inputFormat,
-            [ValueSource(typeof(TestData), nameof(TestData.Resolutions))]
-            Resolution profileResolution,
-            [ValueSource(typeof(TestData), nameof(TestData.Paddings))]
-            Padding padding,
-            [ValueSource(typeof(TestData), nameof(TestData.VideoScanKinds))]
-            VideoScanKind videoScanKind,
-            [ValueSource(typeof(TestData), nameof(TestData.Watermarks))]
-            Watermark watermark,
-            // [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.NvidiaAcceleration))] HardwareAccelerationKind profileAcceleration)
-        // [ValueSource(typeof(TestData), nameof(TestData.VaapiCodecs))] string profileCodec,
+        [ValueSource(typeof(TestData), nameof(TestData.InputFormats))] InputFormat inputFormat,
+        [ValueSource(typeof(TestData), nameof(TestData.Resolutions))] Resolution profileResolution,
+        [ValueSource(typeof(TestData), nameof(TestData.Paddings))] Padding padding,
+        [ValueSource(typeof(TestData), nameof(TestData.VideoScanKinds))] VideoScanKind videoScanKind,
+        [ValueSource(typeof(TestData), nameof(TestData.Watermarks))] Watermark watermark,
+        [ValueSource(typeof(TestData), nameof(TestData.Subtitles))] Subtitle subtitle,
+        [ValueSource(typeof(TestData), nameof(TestData.VideoFormats))] FFmpegProfileVideoFormat profileVideoFormat,
+        // [ValueSource(typeof(TestData), nameof(TestData.NoAcceleration))] HardwareAccelerationKind profileAcceleration)
+        [ValueSource(typeof(TestData), nameof(TestData.NvidiaAcceleration))] HardwareAccelerationKind profileAcceleration)
         // [ValueSource(typeof(TestData), nameof(TestData.VaapiAcceleration))] HardwareAccelerationKind profileAcceleration)
-        // [ValueSource(typeof(TestData), nameof(TestData.QsvCodecs))] string profileCodec,
         // [ValueSource(typeof(TestData), nameof(TestData.QsvAcceleration))] HardwareAccelerationKind profileAcceleration)
-        // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxCodecs))] string profileCodec,
         // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxAcceleration))] HardwareAccelerationKind profileAcceleration)
     {
         if (inputFormat.Encoder is "mpeg1video" or "msmpeg4v2" or "msmpeg4v3")
@@ -206,16 +188,18 @@ public class TranscodingTests
         }
 
         string name = GetStringSha256Hash(
-            $"{inputFormat.Encoder}_{inputFormat.PixelFormat}_{videoScanKind}_{padding}_{profileResolution}_{profileCodec}_{profileAcceleration}");
+            $"{inputFormat.Encoder}_{inputFormat.PixelFormat}_{videoScanKind}_{padding}_{watermark}_{subtitle}_{profileResolution}_{profileVideoFormat}_{profileAcceleration}");
 
         string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
         if (!File.Exists(file))
         {
             string resolution = padding == Padding.WithPadding ? "1920x1060" : "1920x1080";
 
-            string videoFilter = videoScanKind == VideoScanKind.Interlaced ? "-vf tinterlace=interleave_top,fieldorder=tff" : string.Empty;
+            string videoFilter = videoScanKind == VideoScanKind.Interlaced
+                ? "-vf tinterlace=interleave_top,fieldorder=tff"
+                : string.Empty;
             string flags = videoScanKind == VideoScanKind.Interlaced ? "-flags +ildct+ilme" : string.Empty;
-                
+
             string args =
                 $"-y -f lavfi -i anoisesrc=color=brown -f lavfi -i testsrc=duration=1:size={resolution}:rate=30 {videoFilter} -c:a aac -c:v {inputFormat.Encoder} -shortest -pix_fmt {inputFormat.PixelFormat} -strict -2 {flags} {file}";
             var p1 = new Process
@@ -232,10 +216,50 @@ public class TranscodingTests
             // ReSharper disable once MethodHasAsyncOverload
             p1.WaitForExit();
             p1.ExitCode.Should().Be(0);
+
+            switch (subtitle)
+            {
+                case Subtitle.Picture:
+                    string sourceFile = Path.GetTempFileName() + ".mkv";
+                    File.Move(file, sourceFile, true);
+                    
+                    string tempFileName = Path.GetTempFileName() + ".mkv";
+                    string subPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "test.sup");
+                    var p2 = new Process
+                    {
+                        StartInfo = new ProcessStartInfo
+                        {
+                            FileName = ExecutableName("mkvmerge"),
+                            Arguments = $"-o {tempFileName} {sourceFile} {subPath}"
+                        }
+                    };
+
+                    p2.Start();
+                    await p2.WaitForExitAsync();
+                    // ReSharper disable once MethodHasAsyncOverload
+                    p2.WaitForExit();
+                    if (p2.ExitCode != 0)
+                    {
+                        if (File.Exists(sourceFile))
+                        {
+                            File.Delete(sourceFile);
+                        }
+
+                        if (File.Exists(file))
+                        {
+                            File.Delete(file);
+                        }
+                    }
+
+                    p2.ExitCode.Should().Be(0);
+
+                    File.Move(tempFileName, file, true);
+                    break;
+            }
         }
 
         var imageCache = new Mock<IImageCache>();
-            
+
         // always return the static watermark resource
         imageCache.Setup(
                 ic => ic.GetPathForImage(
@@ -250,6 +274,7 @@ public class TranscodingTests
             imageCache.Object,
             new Mock<ITempFilePool>().Object,
             new Mock<IClient>().Object,
+            new MemoryCache(new MemoryCacheOptions()),
             LoggerFactory.CreateLogger<FFmpegProcessService>());
 
         var service = new FFmpegLibraryProcessService(
@@ -269,11 +294,12 @@ public class TranscodingTests
         var metadataRepository = new Mock<IMetadataRepository>();
         metadataRepository
             .Setup(r => r.UpdateLocalStatistics(It.IsAny<MediaItem>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
-            .Callback<MediaItem, MediaVersion, bool>((_, version, _) =>
-            {
-                version.MediaFiles = v.MediaFiles;
-                v = version;
-            });
+            .Callback<MediaItem, MediaVersion, bool>(
+                (_, version, _) =>
+                {
+                    version.MediaFiles = v.MediaFiles;
+                    v = version;
+                });
 
         var localStatisticsProvider = new LocalStatisticsProvider(
             metadataRepository.Object,
@@ -282,6 +308,7 @@ public class TranscodingTests
             LoggerFactory.CreateLogger<LocalStatisticsProvider>());
 
         await localStatisticsProvider.RefreshStatistics(
+            ExecutableName("ffmpeg"),
             ExecutableName("ffprobe"),
             new Movie
             {
@@ -344,8 +371,15 @@ public class TranscodingTests
                 break;
         }
 
-        Process process = await service.ForPlayoutItem(
+        ChannelSubtitleMode subtitleMode = subtitle switch
+        {
+            Subtitle.Picture => ChannelSubtitleMode.Any,
+            _ => ChannelSubtitleMode.None 
+        };
+
+        Command process = await service.ForPlayoutItem(
             ExecutableName("ffmpeg"),
+            ExecutableName("ffprobe"),
             false,
             new Channel(Guid.NewGuid())
             {
@@ -353,10 +387,12 @@ public class TranscodingTests
                 FFmpegProfile = FFmpegProfile.New("test", profileResolution) with
                 {
                     HardwareAcceleration = profileAcceleration,
-                    VideoCodec = profileCodec,
-                    AudioCodec = "aac"
+                    VideoFormat = profileVideoFormat,
+                    AudioFormat = FFmpegProfileAudioFormat.Aac,
+                    DeinterlaceVideo = true
                 },
-                StreamingMode = StreamingMode.TransportStream
+                StreamingMode = StreamingMode.TransportStream,
+                SubtitleMode = subtitleMode
             },
             v,
             v,
@@ -365,6 +401,7 @@ public class TranscodingTests
             now,
             now + TimeSpan.FromSeconds(5),
             now,
+            Option<ChannelWatermark>.None,
             channelWatermark,
             VaapiDriver.Default,
             "/dev/dri/renderD128",
@@ -375,13 +412,8 @@ public class TranscodingTests
             0,
             None);
 
-        process.StartInfo.RedirectStandardError = true;
-        process.EnableRaisingEvents = true;
-            
         // Console.WriteLine($"ffmpeg arguments {string.Join(" ", process.StartInfo.ArgumentList)}");
 
-        process.Start().Should().BeTrue();
-
         string[] unsupportedMessages =
         {
             "No support for codec",
@@ -389,59 +421,44 @@ public class TranscodingTests
             "Provided device doesn't support"
         };
 
-        var errorBuffer = new StringBuilder();
-            
-        process.ErrorDataReceived += (_, errorLine) =>
-        {
-            string data = errorLine.Data ?? string.Empty;
-            errorBuffer.AppendLine(data);
-        };
-
-        process.BeginOutputReadLine();
-        process.BeginErrorReadLine();
-        // string error = await process.StandardError.ReadToEndAsync();
-
+        var sb = new StringBuilder();
+        CommandResult result;
         var timeoutSignal = new CancellationTokenSource(TimeSpan.FromSeconds(30));
         try
         {
-            await process.WaitForExitAsync(timeoutSignal.Token);
-            // ReSharper disable once MethodHasAsyncOverload
-            process.WaitForExit();
+            result = await process
+                .WithStandardOutputPipe(PipeTarget.ToStream(Stream.Null))
+                .WithStandardErrorPipe(PipeTarget.ToStringBuilder(sb))
+                .ExecuteAsync(timeoutSignal.Token);
         }
         catch (OperationCanceledException)
         {
-            process.Kill();
-
-            IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
-            Assert.Fail($"Transcode failure (timeout): ffmpeg {string.Join(" ", quotedArgs)}");
+            Assert.Fail($"Transcode failure (timeout): ffmpeg {process.Arguments}");
             return;
         }
 
-        var error = errorBuffer.ToString();
-        bool isUnsupported = unsupportedMessages.Any(error.Contains); 
+        string error = sb.ToString();
+        bool isUnsupported = unsupportedMessages.Any(error.Contains);
 
         if (profileAcceleration != HardwareAccelerationKind.None && isUnsupported)
         {
-            var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
-            process.ExitCode.Should().Be(1, $"Error message with successful exit code? {string.Join(" ", quotedArgs)}");
-            Assert.Warn($"Unsupported on this hardware: ffmpeg {string.Join(" ", quotedArgs)}");
+            result.ExitCode.Should().Be(1, $"Error message with successful exit code? {process.Arguments}");
+            Assert.Warn($"Unsupported on this hardware: ffmpeg {process.Arguments}");
         }
         else if (error.Contains("Impossible to convert between"))
         {
-            IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
-            Assert.Fail($"Transcode failure: ffmpeg {string.Join(" ", quotedArgs)}");
+            Assert.Fail($"Transcode failure: ffmpeg {process.Arguments}");
         }
         else
         {
-            var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
-            process.ExitCode.Should().Be(0, errorBuffer + Environment.NewLine + string.Join(" ", quotedArgs));
-            if (process.ExitCode == 0)
+            result.ExitCode.Should().Be(0, error + Environment.NewLine + process.Arguments);
+            if (result.ExitCode == 0)
             {
-                Console.WriteLine(string.Join(" ", quotedArgs));
+                Console.WriteLine(process.Arguments);
             }
         }
     }
-        
+
     private static string GetStringSha256Hash(string text)
     {
         if (string.IsNullOrEmpty(text))
@@ -462,6 +479,9 @@ public class TranscodingTests
 
         public Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version) =>
             Optional(version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Audio)).AsTask();
+
+        public Task<Option<MediaStream>> SelectSubtitleStream(Channel channel, MediaVersion version) =>
+            Optional(version.Streams.Find(s => s.MediaStreamKind == MediaStreamKind.Subtitle)).AsTask();
     }
 
     private static string ExecutableName(string baseName) =>

ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs

@@ -27,6 +27,10 @@ public class MovieFolderScannerTests
         ? @"C:\Movies"
         : "/movies";
 
+    private static readonly string FFmpegPath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+        ? @"C:\bin\ffmpeg.exe"
+        : "/bin/ffmpeg";
+
     private static readonly string FFprobePath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
         ? @"C:\bin\ffprobe.exe"
         : "/bin/ffprobe";
@@ -52,8 +56,9 @@ public class MovieFolderScannerTests
             _localStatisticsProvider = new Mock<ILocalStatisticsProvider>();
             _localMetadataProvider = new Mock<ILocalMetadataProvider>();
 
-            _localStatisticsProvider.Setup(x => x.RefreshStatistics(It.IsAny<string>(), It.IsAny<MediaItem>()))
-                .Returns<string, MediaItem>((_, _) => Right<BaseError, bool>(true).AsTask());
+            _localStatisticsProvider.Setup(
+                    x => x.RefreshStatistics(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaItem>()))
+                .Returns<string, string, MediaItem>((_, _, _) => Right<BaseError, bool>(true).AsTask());
 
             // fallback metadata adds metadata to a movie, so we need to replicate that here
             _localMetadataProvider.Setup(x => x.RefreshFallbackMetadata(It.IsAny<Movie>()))
@@ -90,9 +95,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -101,6 +108,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -131,9 +139,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -142,6 +152,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -173,9 +184,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -184,6 +197,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -219,9 +233,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -230,6 +246,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -268,9 +285,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -279,6 +298,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -317,9 +337,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -328,6 +350,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -365,9 +388,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -376,6 +401,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -407,9 +433,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -418,6 +446,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -451,9 +480,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -462,6 +493,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -489,9 +521,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -500,6 +534,7 @@ public class MovieFolderScannerTests
 
             _localStatisticsProvider.Verify(
                 x => x.RefreshStatistics(
+                    FFmpegPath,
                     FFprobePath,
                     It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
                 Times.Once);
@@ -532,9 +567,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 
@@ -561,9 +598,11 @@ public class MovieFolderScannerTests
 
             Either<BaseError, Unit> result = await service.ScanFolder(
                 libraryPath,
+                FFmpegPath,
                 FFprobePath,
                 0,
-                1);
+                1,
+                CancellationToken.None);
 
             result.IsRight.Should().BeTrue();
 

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerBaseTests.cs

@@ -6,6 +6,7 @@ using FluentAssertions;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
+using Serilog;
 
 namespace ErsatzTV.Core.Tests.Scheduling;
 
@@ -223,7 +224,7 @@ public class PlayoutModeSchedulerBaseTests : SchedulerTestBase
 
             PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
-            List<PlayoutItem> playoutItems = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            List<PlayoutItem> playoutItems = Scheduler()
                 .AddFiller(
                     startState,
                     CollectionEnumerators(scheduleItem, enumerator),
@@ -274,7 +275,7 @@ public class PlayoutModeSchedulerBaseTests : SchedulerTestBase
             // too lazy to make another enumerator for the filler that we don't want
             enumerators.Add(CollectionKey.ForFillerPreset(scheduleItem.MidRollFiller), enumerator);
 
-            List<PlayoutItem> playoutItems = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            List<PlayoutItem> playoutItems = Scheduler()
                 .AddFiller(
                     startState,
                     enumerators,
@@ -284,6 +285,106 @@ public class PlayoutModeSchedulerBaseTests : SchedulerTestBase
 
             playoutItems.Count.Should().Be(1);
         }
+
+        [Test]
+        public void Should_Schedule_Mid_Roll_Count_Filler_Correctly()
+        {
+            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailFiller = null,
+                FallbackFiller = null,
+                MidRollFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.MidRoll,
+                    FillerMode = FillerMode.Count,
+                    PadToNearestMinute = 60, // this should be ignored
+                    Count = 1
+                }
+            };
+
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
+
+            var enumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionOne.MediaItems,
+                new CollectionEnumeratorState());
+
+            var fillerEnumerator = new ChronologicalMediaCollectionEnumerator(
+                collectionTwo.MediaItems,
+                new CollectionEnumeratorState());
+
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+            Dictionary<CollectionKey, IMediaCollectionEnumerator> enumerators = CollectionEnumerators(
+                scheduleItem,
+                enumerator);
+            
+            enumerators.Add(CollectionKey.ForFillerPreset(scheduleItem.MidRollFiller), fillerEnumerator);
+
+            List<PlayoutItem> playoutItems = Scheduler()
+                .AddFiller(
+                    startState,
+                    enumerators,
+                    scheduleItem,
+                    new PlayoutItem
+                    {
+                        MediaItemId = 1,
+                        Start = startState.CurrentTime.UtcDateTime,
+                        Finish = startState.CurrentTime.AddHours(1).UtcDateTime
+                    },
+                    new List<MediaChapter>
+                        {
+                            new() { StartTime = TimeSpan.Zero, EndTime = TimeSpan.FromMinutes(6) },
+                            new() { StartTime = TimeSpan.FromMinutes(6), EndTime = TimeSpan.FromMinutes(60) }
+                        });
+
+            playoutItems.Count.Should().Be(3);
+            playoutItems[0].MediaItemId.Should().Be(1);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+            playoutItems[1].MediaItemId.Should().Be(3);
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime + TimeSpan.FromMinutes(6));
+            playoutItems[2].MediaItemId.Should().Be(1);
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime + TimeSpan.FromMinutes(11));
+        }
+    }
+
+    [TestFixture]
+    public class GetStartTimeAfter
+    {
+        [Test]
+        public void Should_Compare_Time_As_Local_Time()
+        {
+            var enumerator = new Mock<IScheduleItemsEnumerator>();
+
+            var state = new PlayoutBuilderState(
+                enumerator.Object,
+                None,
+                None,
+                false,
+                false,
+                0,
+                DateTime.Today.AddHours(6).ToUniversalTime());
+
+            var scheduleItem = new ProgramScheduleItemOne
+            {
+                StartTime = TimeSpan.FromHours(6)
+            };
+
+            DateTimeOffset result =
+                PlayoutModeSchedulerBase<ProgramScheduleItem>.GetStartTimeAfter(state, scheduleItem);
+
+            result.Should().Be(DateTime.Today.AddHours(6));
+        }
     }
 
     private static Movie TestMovie(int id, TimeSpan duration, DateTime aired) =>
@@ -296,4 +397,34 @@ public class PlayoutModeSchedulerBaseTests : SchedulerTestBase
                 new() { Duration = duration }
             }
         };
+
+    private static PlayoutModeSchedulerBase<ProgramScheduleItem> Scheduler() =>
+        new TestScheduler();
+
+    private class TestScheduler : PlayoutModeSchedulerBase<ProgramScheduleItem>
+    {
+        private static readonly ILoggerFactory LoggerFactory;
+
+        static TestScheduler()
+        {
+            Log.Logger = new LoggerConfiguration()
+                .MinimumLevel.Debug()
+                .WriteTo.Console()
+                .CreateLogger();
+
+            LoggerFactory = new LoggerFactory().AddSerilog(Log.Logger);
+        }
+
+        public TestScheduler() : base(LoggerFactory.CreateLogger<TestScheduler>())
+        {
+        }
+
+        public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
+            PlayoutBuilderState playoutBuilderState,
+            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+            ProgramScheduleItem scheduleItem,
+            ProgramScheduleItem nextScheduleItem,
+            DateTimeOffset hardStop) =>
+            throw new NotSupportedException();
+    }
 }

ErsatzTV.Core/Api/Channels/ChannelResponseModel.cs

@@ -0,0 +1,9 @@
+namespace ErsatzTV.Core.Api.Channels;
+
+public record ChannelResponseModel(
+    int Id,
+    string Number,
+    string Name,
+    string FFmpegProfile,
+    string Language,
+    string StreamingMode);

ErsatzTV.Core/Domain/Channel.cs

@@ -4,7 +4,7 @@ namespace ErsatzTV.Core.Domain;
 
 public class Channel
 {
-    public static string NumberValidator = @"^[0-9]+(\.[0-9])?$";
+    public static string NumberValidator = @"^[0-9]+(\.[0-9]{1,2})?$";
 
     public Channel(Guid uniqueId) => UniqueId = uniqueId;
     public int Id { get; set; }
@@ -22,5 +22,7 @@ public class Channel
     public StreamingMode StreamingMode { get; set; }
     public List<Playout> Playouts { get; set; }
     public List<Artwork> Artwork { get; set; }
-    public string PreferredLanguageCode { get; set; }
+    public string PreferredAudioLanguageCode { get; set; }
+    public string PreferredSubtitleLanguageCode { get; set; }
+    public ChannelSubtitleMode SubtitleMode { get; set; }
 }

ErsatzTV.Core/Domain/ChannelSubtitleMode.cs

@@ -0,0 +1,9 @@
+namespace ErsatzTV.Core.Domain;
+
+public enum ChannelSubtitleMode
+{
+    None = 0,
+    Forced = 1,
+    Default = 2,
+    Any = 3
+}

ErsatzTV.Core/Domain/ConfigElementKey.cs

@@ -17,7 +17,6 @@ public class ConfigElementKey
     public static ConfigElementKey FFmpegSegmenterTimeout => new("ffmpeg.segmenter.timeout_seconds");
     public static ConfigElementKey FFmpegWorkAheadSegmenters => new("ffmpeg.segmenter.work_ahead_limit");
     public static ConfigElementKey FFmpegInitialSegmentCount => new("ffmpeg.segmenter.initial_segment_count");
-    public static ConfigElementKey FFmpegUseLegacyTranscoder => new("ffmpeg.use_legacy_transcoder");
     public static ConfigElementKey SearchIndexVersion => new("search_index.version");
     public static ConfigElementKey HDHRTunerCount => new("hdhr.tuner_count");
     public static ConfigElementKey ChannelsPageSize => new("pages.channels.page_size");

ErsatzTV.Core/Domain/FFmpegProfile.cs

@@ -7,35 +7,32 @@ public record FFmpegProfile
     public int Id { get; set; }
     public string Name { get; set; }
     public int ThreadCount { get; set; }
-    public bool Transcode { get; set; }
     public HardwareAccelerationKind HardwareAcceleration { get; set; }
     public VaapiDriver VaapiDriver { get; set; }
     public string VaapiDevice { get; set; }
     public int ResolutionId { get; set; }
     public Resolution Resolution { get; set; }
-    public string VideoCodec { get; set; }
-    public bool NormalizeVideo { get; set; }
+    public FFmpegProfileVideoFormat VideoFormat { get; set; }
     public int VideoBitrate { get; set; }
     public int VideoBufferSize { get; set; }
-    public string AudioCodec { get; set; }
+    public FFmpegProfileAudioFormat AudioFormat { get; set; }
     public int AudioBitrate { get; set; }
     public int AudioBufferSize { get; set; }
     public bool NormalizeLoudness { get; set; }
     public int AudioChannels { get; set; }
     public int AudioSampleRate { get; set; }
-    public bool NormalizeAudio { get; set; }
     public bool NormalizeFramerate { get; set; }
+    public bool? DeinterlaceVideo { get; set; }
 
     public static FFmpegProfile New(string name, Resolution resolution) =>
         new()
         {
             Name = name,
             ThreadCount = 0,
-            Transcode = true,
             ResolutionId = resolution.Id,
             Resolution = resolution,
-            VideoCodec = "libx264",
-            AudioCodec = "ac3",
+            VideoFormat = FFmpegProfileVideoFormat.H264,
+            AudioFormat = FFmpegProfileAudioFormat.Ac3,
             VideoBitrate = 2000,
             VideoBufferSize = 4000,
             AudioBitrate = 192,
@@ -43,8 +40,8 @@ public record FFmpegProfile
             NormalizeLoudness = true,
             AudioChannels = 2,
             AudioSampleRate = 48,
-            NormalizeVideo = true,
-            NormalizeAudio = true,
+            DeinterlaceVideo = true,
+            NormalizeFramerate = false,
             HardwareAcceleration = HardwareAccelerationKind.None
         };
 }

ErsatzTV.Core/Domain/FFmpegProfileAudioFormat.cs

@@ -0,0 +1,11 @@
+namespace ErsatzTV.Core.Domain;
+
+public enum FFmpegProfileAudioFormat
+{
+    None = 0,
+    
+    Aac = 1,
+    Ac3 = 2,
+    
+    Copy = 99
+}

ErsatzTV.Core/Domain/FFmpegProfileVideoFormat.cs

@@ -0,0 +1,12 @@
+namespace ErsatzTV.Core.Domain;
+
+public enum FFmpegProfileVideoFormat
+{
+    None = 0,
+    
+    H264 = 1,
+    Hevc = 2,
+    Mpeg2Video = 3,
+    
+    Copy = 99
+}

ErsatzTV.Core/Domain/PlayoutItem.cs

@@ -3,7 +3,7 @@ using ErsatzTV.Core.Domain.Filler;
 
 namespace ErsatzTV.Core.Domain;
 
-[DebuggerDisplay("{MediaItemId} - {Start} - {Finish}")]
+[DebuggerDisplay("{MediaItemId} - {StartOffset} - {FinishOffset}")]
 public class PlayoutItem
 {
     public int Id { get; set; }
@@ -20,9 +20,12 @@ public class PlayoutItem
     public TimeSpan InPoint { get; set; }
     public TimeSpan OutPoint { get; set; }
     public string ChapterTitle { get; set; }
+    public ChannelWatermark Watermark { get; set; }
+    public int? WatermarkId { get; set; }
 
     public DateTimeOffset StartOffset => new DateTimeOffset(Start, TimeSpan.Zero).ToLocalTime();
     public DateTimeOffset FinishOffset => new DateTimeOffset(Finish, TimeSpan.Zero).ToLocalTime();
+
     public DateTimeOffset? GuideFinishOffset => GuideFinish.HasValue
         ? new DateTimeOffset(GuideFinish.Value, TimeSpan.Zero).ToLocalTime()
         : null;

ErsatzTV.Core/Domain/PlayoutProgramScheduleAnchor.cs

@@ -1,12 +1,26 @@
-namespace ErsatzTV.Core.Domain;
+using Destructurama.Attributed;
+
+namespace ErsatzTV.Core.Domain;
 
 public class PlayoutProgramScheduleAnchor
 {
     public int Id { get; set; }
     public int PlayoutId { get; set; }
+
+    [NotLogged]
     public Playout Playout { get; set; }
+
     public int ProgramScheduleId { get; set; }
+    
+    [NotLogged]
     public ProgramSchedule ProgramSchedule { get; set; }
+
+    public DateTime? AnchorDate { get; set; }
+
+    public DateTimeOffset? AnchorDateOffset => AnchorDate.HasValue
+        ? new DateTimeOffset(AnchorDate.Value, TimeSpan.Zero).ToLocalTime()
+        : null;
+
     public ProgramScheduleItemCollectionType CollectionType { get; set; }
     public int? CollectionId { get; set; }
     public Collection Collection { get; set; }

ErsatzTV.Core/Domain/ProgramScheduleItem.cs

@@ -32,4 +32,6 @@ public abstract class ProgramScheduleItem
     public FillerPreset TailFiller { get; set; }
     public int? FallbackFillerId { get; set; }
     public FillerPreset FallbackFiller { get; set; }
+    public ChannelWatermark Watermark { get; set; }
+    public int? WatermarkId { get; set; }
 }

ErsatzTV.Core/Emby/EmbyMovieLibraryScanner.cs

@@ -51,6 +51,7 @@ public class EmbyMovieLibraryScanner : IEmbyMovieLibraryScanner
         string address,
         string apiKey,
         EmbyLibrary library,
+        string ffmpegPath,
         string ffprobePath)
     {
         List<EmbyItemEtag> existingMovies = await _movieRepository.GetExistingEmbyMovies(library);
@@ -172,7 +173,11 @@ public class EmbyMovieLibraryScanner : IEmbyMovieLibraryScanner
 
                         _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
                         Either<BaseError, bool> refreshResult =
-                            await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingMovie, localPath);
+                            await _localStatisticsProvider.RefreshStatistics(
+                                ffmpegPath,
+                                ffprobePath,
+                                incomingMovie,
+                                localPath);
 
                         await refreshResult.Match(
                             async _ =>