fix database migration (#436 )

fix double scheduling (#435 )
fix other video playback
2021-10-15 11:31:40 -05:00 · 2021-10-15 09:14:53 -05:00 · 2021-10-14 22:53:32 -05:00 · 2021-10-14 15:00:24 -05:00 · 2021-10-14 14:41:12 -05:00 · 2021-10-14 13:24:54 -05:00
314 changed files with 51955 additions and 675 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -49,7 +49,7 @@ jobs:
          tag=$(git describe --tags --abbrev=0)
          tag2="${tag:1}"
          short=$(git rev-parse --short HEAD)
-          final="${tag2/prealpha/$short}"
+          final="${tag2/alpha/$short}"
          echo "GIT_TAG=${final}" >> $GITHUB_ENV

      - name: Set up Docker Buildx Base
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -1,71 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ main ]
-  schedule:
-    - cron: '30 3 * * 0'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'csharp' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
-        # Learn more:
-        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -82,7 +82,7 @@ jobs:
        run: |
          tag=$(git describe --tags --abbrev=0)
          echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
-          echo "DOCKER_TAG=${tag/-prealpha/}" >> $GITHUB_ENV
+          echo "DOCKER_TAG=${tag/-alpha/}" >> $GITHUB_ENV

      - name: Set up Docker Buildx Base
        uses: docker/setup-buildx-action@v1
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,140 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

 ## [Unreleased]
+### Fixed
+- Fix double scheduling; this could happen if the app was shutdown during a playout build
+
+## [0.1.4-alpha] - 2021-10-14
+### Fixed
+- Fix error message/offline stream continuity with channels that use HLS Segmenter
+- Fix removing items from search index when folders are removed from local libraries
+
+### Added
+- Add `Other Video` local libraries
+  - Other video items require no metadata or particular folder layout, and will have tags added for each containing folder
+  - For Example, a video at `commercials/sd/1990/whatever.mkv` will have the tags `commercials`, `sd` and `1990`, and the title `whatever`
+- Add filler `Tail Mode` option to `Duration` playout mode (in addition to existing `Offline` option)
+  - Filler collection will always be randomized (to fill as much time as possible)
+  - Filler will be hidden from channel guide, but visible in playout details in ErsatzTV
+  - Unfilled time will show offline image
+- Add `Guide Mode` option to all schedule items
+  - `Normal` guide mode will show all scheduled items in the channel guide (xmltv)
+  - `Filler` guide mode will hide all scheduled items from the channel guide, and extend the end time for the previous item in the guide
+
+## [0.1.3-alpha] - 2021-10-13
+### Fixed
+- Fix startup bug for some docker installations
+
+## [0.1.2-alpha] - 2021-10-12
+### Added
+- Include more cuda (nvidia) filters in docker image
+- Enable deinterlacing with nvidia using new `yadif_cuda` filter
+- Add two HLS Segmenter settings: idle timeout and work-ahead limit
+  - `HLS Segmenter Idle Timeout` - the number of seconds to keep transcoding a channel while no requests have been received from any client
+    - This setting must be greater than or equal to 30 (seconds)
+  - `Work-Ahead HLS Segmenter Limit` - the number of segmenters (channels) that will work-ahead simultaneously (if multiple channels are being watched)
+    - "working ahead" means transcoding at full speed, which can take a lot of resources
+    - This setting must be greater than or equal to 0
+- Add more watermark locations ("middle" of each side)
+- Add `VAAPI Device` setting to ffmpeg profile to support installations with multiple video cards
+- Add *experimental* `RadeonSI` option for `VAAPI Driver` and include mesa drivers in vaapi docker image
+
+### Changed
+- Upgrade ffmpeg from 4.3 to 4.4 in all docker images
+  - Upgrading from 4.3 to 4.4 is recommended for all installations
+- Move `VAAPI Driver` from settings page to ffmpeg profile to support installations with multiple video cards
+
+### Fixed
+- Fix some transcoding edge cases with nvidia and pixel format `yuv420p10le`
+
+## [0.1.1-alpha] - 2021-10-10
+### Added
+- Add music video album to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Remove forced initial delay from `HLS Segmenter` streaming mode
+- Upgrade nvidia docker image from 18.04 to 20.04
+
+## [0.1.0-alpha] - 2021-10-08
+### Added
+- Add *experimental* streaming mode `HLS Segmenter` (most similar to `HLS Hybrid`) 
+  - This mode is intended to increase client compatibility and reduce issues at program boundaries
+  - If you want the temporary transcode files to be located on a particular drive, the docker path is `/root/.local/share/etv-transcode`
+- Store frame rate with media statistics; this is needed to support HLS Segmenter
+  - This requires re-ingesting statistics for all media items the first time this version is launched
+
+### Changed
+- Use latest iHD driver (21.2.3 vs 20.1.1) in vaapi docker images
+
+### Fixed
+- Add downsampling to support transcoding 10-bit HEVC content with the h264_vaapi encoder
+- Fix updating statistics when media items are replaced
+- Fix XMLTV generation when scheduled episode is missing metadata
+
+## [0.0.62-alpha] - 2021-10-05
+### Added
+- Support IMDB ids from Plex libraries, which may improve Trakt matching for some items
+
+### Fixed
+- Include Specials/Season 0 `episode-num` entry in XMLTV
+- Fix some transcoding edge cases with VAAPI and pixel formats `yuv420p10le`, `yuv444p10le` and `yuv444p`
+- Update Plex movie and episode paths when they are changed within Plex
+- Always use `libx264` software encoder for error messages
+
+## [0.0.61-alpha] - 2021-09-30
+### Fixed
+- Revert nvenc/cuda filter change from v60
+
+## [0.0.60-alpha] - 2021-09-25
+### Added
+- Add Trakt list support under `Lists` > `Trakt Lists`
+  - Trakt lists can be added by url or by `user/list`
+  - To re-download a Trakt list, simply add it again (no need to delete)
+  - See `Logs` for unmatched item details
+  - Trakt lists can only be scheduled by using Smart Collections
+- Add seasons to search index
+  - This is needed because Trakt lists can contain seasons 
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Fixed
+- Fix local television scanner to properly update episode metadata when NFO files have been added/changed
+- Properly detect ffmpeg nvenc (cuda) support in Hardware Acceleration health check
+- Fix nvenc/cuda filter for some yuv420p content
+
+## [0.0.59-alpha] - 2021-09-18
+### Added
+- Add `Health Checks` table to home page to identify and surface common misconfigurations
+  - `FFmpeg Version` checks `ffmpeg` and `ffprobe` versions
+  - `FFmpeg Reports` checks whether ffmpeg troubleshooting reports are enabled since they can use a lot of disk space over time
+  - `Hardware Acceleration` checks whether channels that transcode are using acceleration methods that ffmpeg claims to support
+  - `Movie Metadata` checks whether all movies have metadata (fallback metadata counts as metadata)
+  - `Episode Metadata` checks whether all episodes have metadata (fallback metadata counts as metadata)
+  - `Zero Duration` checks whether all movies and episodes have a valid (non-zero) duration
+  - `VAAPI Driver` checks whether a vaapi driver preference is configured when using the vaapi docker image
+- Add setting to each playout to schedule an automatic daily rebuild
+  - This is useful if the playout uses a smart collection with `released_onthisday`
+
+### Fixed
+- Fix docker vaapi support for newer Intel platforms (Gen 8+)
+  - This includes a new setting to force a particular vaapi driver (`iHD` or `i965`), as some Gen 8 or 9 hardware that is supported by both drivers will perform better with one or the other
+- Fix scanning and indexing local movies and episodes without NFO metadata
+- Fix displaying seasons for shows with no year (in metadata or in folder name)
+- Fix "direct play" in MPEG-TS mode (copy audio and video stream when `Transcode` is unchecked)
+
+## [0.0.58-alpha] - 2021-09-15
+### Added
+- Add `released_notinthelast` search field for relative release date queries
+  - Syntax is a number and a unit (days, weeks, months, years) like `1 week` or `2 years`
+- Add `released_onthisday` search field for historical queries
+  - Syntax is `released_onthisday:1` and will search for items released on this month number and day number in prior years
+- Add tooltip explaining `Keep Multi-Part Episodes Together`
+
+### Fixed
+- Properly display watermark when no other video filters (like scaling or padding) are required
+- Fix building some playouts in timezones with positive offsets (like UTC+2)
+- Fix `Shuffle In Order` so all collections/shows start from the earliest episode
+  - You may need to rebuild playouts to see this fixed behavior more quickly

 ## [0.0.57-alpha] - 2021-09-10
 ### Added
@@ -580,7 +714,17 @@ 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.0.57-alpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.4-alpha...HEAD
+[0.1.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.3-alpha...v0.1.4-alpha
+[0.1.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.2-alpha...v0.1.3-alpha
+[0.1.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.1-alpha...v0.1.2-alpha
+[0.1.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.0-alpha...v0.1.1-alpha
+[0.1.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.62-alpha...v0.1.0-alpha
+[0.0.62-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.61-alpha...v0.0.62-alpha
+[0.0.61-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.60-alpha...v0.0.61-alpha
+[0.0.60-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.59-alpha...v0.0.60-alpha
+[0.0.59-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.58-alpha...v0.0.59-alpha
+[0.0.58-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.57-alpha...v0.0.58-alpha
 [0.0.57-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.56-alpha...v0.0.57-alpha
 [0.0.56-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.55-alpha...v0.0.56-alpha
 [0.0.55-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.54-alpha...v0.0.55-alpha
--- a/ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs
@@ -28,6 +28,10 @@ namespace ErsatzTV.Application.Channels.Queries
            {
                switch (mode.ToLowerInvariant())
                {
+                    case "segmenter":
+                        channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenter;
+                        result.Add(channel);
+                        break;
                    case "hls-direct":
                        channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
                        result.Add(channel);
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs
@@ -67,7 +67,7 @@ namespace ErsatzTV.Application.Emby.Commands

        private async Task<Unit> Synchronize(RequestParameters parameters)
        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
            {
--- a/ErsatzTV.Application/ErsatzTV.Application.csproj
+++ b/ErsatzTV.Application/ErsatzTV.Application.csproj
@@ -7,13 +7,9 @@
    </PropertyGroup>

    <ItemGroup>
-      <PackageReference Include="AsyncFixer" Version="1.5.1">
-        <PrivateAssets>all</PrivateAssets>
-        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      </PackageReference>
      <PackageReference Include="MediatR" Version="9.0.0" />
      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.10.56">
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.63">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      </PackageReference>
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs
@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
 using LanguageExt;
 using MediatR;

@@ -10,6 +11,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
        int ThreadCount,
        bool Transcode,
        HardwareAccelerationKind HardwareAcceleration,
+        VaapiDriver VaapiDriver,
+        string VaapiDevice,
        int ResolutionId,
        bool NormalizeVideo,
        string VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs
@@ -45,6 +45,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                    ThreadCount = threadCount,
                    Transcode = request.Transcode,
                    HardwareAcceleration = request.HardwareAcceleration,
+                    VaapiDriver = request.VaapiDriver,
+                    VaapiDevice = request.VaapiDevice,
                    ResolutionId = resolutionId,
                    NormalizeVideo = request.NormalizeVideo,
                    VideoCodec = request.VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs
@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
 using LanguageExt;
 using MediatR;

@@ -11,6 +12,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
        int ThreadCount,
        bool Transcode,
        HardwareAccelerationKind HardwareAcceleration,
+        VaapiDriver VaapiDriver,
+        string VaapiDevice,
        int ResolutionId,
        bool NormalizeVideo,
        string VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs
@@ -36,18 +36,20 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
            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.NormalizeVideo;
+            p.NormalizeVideo = update.Transcode && update.NormalizeVideo;
            p.VideoCodec = update.VideoCodec;
            p.VideoBitrate = update.VideoBitrate;
            p.VideoBufferSize = update.VideoBufferSize;
            p.AudioCodec = update.AudioCodec;
            p.AudioBitrate = update.AudioBitrate;
            p.AudioBufferSize = update.AudioBufferSize;
-            p.NormalizeLoudness = update.NormalizeLoudness;
+            p.NormalizeLoudness = update.Transcode && update.NormalizeLoudness;
            p.AudioChannels = update.AudioChannels;
            p.AudioSampleRate = update.AudioSampleRate;
-            p.NormalizeAudio = update.NormalizeAudio;
+            p.NormalizeAudio = update.Transcode && update.NormalizeAudio;
            await dbContext.SaveChangesAsync();
            return new UpdateFFmpegProfileResult(p.Id);
        }
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs
@@ -115,6 +115,14 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId);
            }

+            await _configElementRepository.Upsert(
+                ConfigElementKey.FFmpegSegmenterTimeout,
+                request.Settings.HlsSegmenterIdleTimeout);
+
+            await _configElementRepository.Upsert(
+                ConfigElementKey.FFmpegWorkAheadSegmenters,
+                request.Settings.WorkAheadSegmenterLimit);
+
            return Unit.Default;
        }
    }
--- a/ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs
@@ -1,5 +1,6 @@
 using ErsatzTV.Application.Resolutions;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;

 namespace ErsatzTV.Application.FFmpegProfiles
 {
@@ -9,6 +10,8 @@ namespace ErsatzTV.Application.FFmpegProfiles
        int ThreadCount,
        bool Transcode,
        HardwareAccelerationKind HardwareAcceleration,
+        VaapiDriver VaapiDriver,
+        string VaapiDevice,
        ResolutionViewModel Resolution,
        bool NormalizeVideo,
        string VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs
@@ -8,5 +8,7 @@
        public string PreferredLanguageCode { get; set; }
        public bool SaveReports { get; set; }
        public int? GlobalWatermarkId { get; set; }
+        public int HlsSegmenterIdleTimeout { get; set; }
+        public int WorkAheadSegmenterLimit { get; set; }
    }
 }
--- a/ErsatzTV.Application/FFmpegProfiles/Mapper.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Mapper.cs
@@ -12,6 +12,8 @@ namespace ErsatzTV.Application.FFmpegProfiles
                profile.ThreadCount,
                profile.Transcode,
                profile.HardwareAcceleration,
+                profile.VaapiDriver,
+                profile.VaapiDevice,
                Project(profile.Resolution),
                profile.NormalizeVideo,
                profile.VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs
@@ -28,6 +28,10 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
            Option<int> watermark =
                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId);
+            Option<int> hlsSegmenterIdleTimeout =
+                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout);
+            Option<int> workAheadSegmenterLimit =
+                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters);

            var result = new FFmpegSettingsViewModel
            {
@@ -36,6 +40,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
                SaveReports = await saveReports.IfNoneAsync(false),
                PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng"),
+                HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
+                WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),
            };

            foreach (int watermarkId in watermark)
--- a/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs
+++ b/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs
@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Health;
+using MediatR;
+
+namespace ErsatzTV.Application.Health.Queries
+{
+    public record GetAllHealthCheckResults : IRequest<List<HealthCheckResult>>;
+}
--- a/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs
+++ b/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs
@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Health;
+using MediatR;
+
+namespace ErsatzTV.Application.Health.Queries
+{
+    public class GetAllHealthCheckResultsHandler : IRequestHandler<GetAllHealthCheckResults, List<HealthCheckResult>>
+    {
+        private readonly IHealthCheckService _healthCheckService;
+
+        public GetAllHealthCheckResultsHandler(IHealthCheckService healthCheckService) =>
+            _healthCheckService = healthCheckService;
+
+        public async Task<List<HealthCheckResult>> Handle(
+            GetAllHealthCheckResults request,
+            CancellationToken cancellationToken)
+        {
+            List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks();
+            return results.Filter(r => r.Status != HealthCheckStatus.NotApplicable).ToList();
+        }
+    }
+}
--- a/ErsatzTV.Application/IFFmpegWorkerRequest.cs
+++ b/ErsatzTV.Application/IFFmpegWorkerRequest.cs
@@ -0,0 +1,6 @@
+namespace ErsatzTV.Application
+{
+    public interface IFFmpegWorkerRequest
+    {
+    }
+}
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs
@@ -67,7 +67,7 @@ namespace ErsatzTV.Application.Jellyfin.Commands

        private async Task<Unit> Synchronize(RequestParameters parameters)
        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
            {
--- a/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -8,6 +9,7 @@ using ErsatzTV.Application.MediaSources.Commands;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using LanguageExt;
@@ -22,15 +24,18 @@ namespace ErsatzTV.Application.Libraries.Commands
    {
        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
        private readonly IEntityLocker _entityLocker;
+        private readonly ISearchIndex _searchIndex;
        private readonly IDbContextFactory<TvContext> _dbContextFactory;

        public UpdateLocalLibraryHandler(
            ChannelWriter<IBackgroundServiceRequest> workerChannel,
            IEntityLocker entityLocker,
+            ISearchIndex searchIndex,
            IDbContextFactory<TvContext> dbContextFactory)
        {
            _workerChannel = workerChannel;
            _entityLocker = entityLocker;
+            _searchIndex = searchIndex;
            _dbContextFactory = dbContextFactory;
        }

@@ -56,10 +61,21 @@ namespace ErsatzTV.Application.Libraries.Commands
                .Filter(ep => incoming.Paths.All(p => NormalizePath(p.Path) != NormalizePath(ep.Path)))
                .ToList();

+            var toRemoveIds = toRemove.Map(lp => lp.Id).ToList();
+
+            List<int> itemsToRemove = await dbContext.MediaItems
+                .Filter(mi => toRemoveIds.Contains(mi.LibraryPathId))
+                .Map(mi => mi.Id)
+                .ToListAsync();
+            
            existing.Paths.RemoveAll(toRemove.Contains);
            existing.Paths.AddRange(toAdd);

-            await dbContext.SaveChangesAsync();
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                await _searchIndex.RemoveItems(itemsToRemove);
+                _searchIndex.Commit();
+            }

            if (toAdd.Count > 0 || toRemove.Count > 0 && _entityLocker.LockLibrary(existing.Id))
            {
--- a/ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs
@@ -9,7 +9,8 @@ namespace ErsatzTV.Application.MediaCards
        List<TelevisionSeasonCardViewModel> SeasonCards,
        List<TelevisionEpisodeCardViewModel> EpisodeCards,
        List<ArtistCardViewModel> ArtistCards,
-        List<MusicVideoCardViewModel> MusicVideoCards)
+        List<MusicVideoCardViewModel> MusicVideoCards,
+        List<OtherVideoCardViewModel> OtherVideoCards)
    {
        public bool UseCustomPlaybackOrder { get; set; }
    }
--- a/ErsatzTV.Application/MediaCards/Mapper.cs
+++ b/ErsatzTV.Application/MediaCards/Mapper.cs
@@ -1,5 +1,5 @@
-using System;
-using System.Linq;
+using System.Linq;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Jellyfin;
@@ -20,7 +20,7 @@ namespace ErsatzTV.Application.MediaCards
                showMetadata.Year?.ToString(),
                showMetadata.SortTitle,
                GetPoster(showMetadata, maybeJellyfin, maybeEmby));
-
+        
        internal static TelevisionSeasonCardViewModel ProjectToViewModel(
            Season season,
            Option<JellyfinMediaSource> maybeJellyfin,
@@ -36,6 +36,26 @@ namespace ErsatzTV.Application.MediaCards
                    .IfNone(string.Empty),
                season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString());

+        internal static TelevisionSeasonCardViewModel ProjectToViewModel(
+            SeasonMetadata seasonMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
+        {
+            string showTitle = seasonMetadata.Season.Show.ShowMetadata.HeadOrNone().Match(
+                m => m.Title ?? string.Empty,
+                () => string.Empty);
+
+            return new TelevisionSeasonCardViewModel(
+                showTitle,
+                seasonMetadata.SeasonId,
+                seasonMetadata.Season.SeasonNumber,
+                showTitle,
+                GetSeasonName(seasonMetadata.Season.SeasonNumber),
+                $"{showTitle}_{seasonMetadata.Season.SeasonNumber:0000}",
+                GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
+                seasonMetadata.Season.SeasonNumber == 0 ? "S" : seasonMetadata.Season.SeasonNumber.ToString());
+        }
+
        internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
            EpisodeMetadata episodeMetadata,
            Option<JellyfinMediaSource> maybeJellyfin,
@@ -43,7 +63,7 @@ namespace ErsatzTV.Application.MediaCards
            bool isSearchResult) =>
            new(
                episodeMetadata.EpisodeId,
-                episodeMetadata.ReleaseDate ?? DateTime.MinValue,
+                episodeMetadata.ReleaseDate ?? SystemTime.MinValueUtc,
                episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone().Match(
                    m => m.Title ?? string.Empty,
                    () => string.Empty),
@@ -80,8 +100,16 @@ namespace ErsatzTV.Application.MediaCards
                musicVideoMetadata.MusicVideo.Artist.ArtistMetadata.Head().Title,
                musicVideoMetadata.SortTitle,
                musicVideoMetadata.Plot,
+                musicVideoMetadata.Album,
                GetThumbnail(musicVideoMetadata, None, None));

+        internal static OtherVideoCardViewModel ProjectToViewModel(OtherVideoMetadata otherVideoMetadata) =>
+            new(
+                otherVideoMetadata.OtherVideoId,
+                otherVideoMetadata.Title,
+                otherVideoMetadata.OriginalTitle,
+                otherVideoMetadata.SortTitle);
+
        internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
            new(
                artistMetadata.ArtistId,
@@ -112,6 +140,8 @@ namespace ErsatzTV.Application.MediaCards
                    .ToList(),
                collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
                collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
+                    .ToList(),
+                collection.MediaItems.OfType<OtherVideo>().Map(mv => ProjectToViewModel(mv.OtherVideoMetadata.Head()))
                    .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };

        internal static ActorCardViewModel ProjectToViewModel(
--- a/ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs
@@ -7,6 +7,7 @@
        string Subtitle,
        string SortTitle,
        string Plot,
+        string Album,
        string Poster) : MediaCardViewModel(
        MusicVideoId,
        Title,
--- a/ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs
@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record OtherVideoCardResultsViewModel(
+        int Count,
+        List<OtherVideoCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
+}
--- a/ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs
@@ -0,0 +1,17 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record OtherVideoCardViewModel
+    (
+        int OtherVideoId,
+        string Title,
+        string Subtitle,
+        string SortTitle) : MediaCardViewModel(
+        OtherVideoId,
+        Title,
+        Subtitle,
+        SortTitle,
+        null)
+    {
+        public int CustomIndex { get; set; }
+    }
+}
--- a/ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs
@@ -80,6 +80,9 @@ namespace ErsatzTV.Application.MediaCards.Queries
                .Include(c => c.MediaItems)
                .ThenInclude(i => (i as Episode).Season)
                .ThenInclude(s => s.SeasonMetadata)
+                .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+                .ThenInclude(ovm => ovm.Artwork)
                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
                .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
                .MapT(c => ProjectToViewModel(c, maybeJellyfin, maybeEmby));
--- a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs
@@ -7,6 +7,7 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
+using static LanguageExt.Prelude;

 namespace ErsatzTV.Application.MediaCards.Queries
 {
@@ -41,7 +42,7 @@ namespace ErsatzTV.Application.MediaCards.Queries
                .GetPagedSeasons(request.TelevisionShowId, request.PageNumber, request.PageSize)
                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());

-            return new TelevisionSeasonCardResultsViewModel(count, results);
+            return new TelevisionSeasonCardResultsViewModel(count, results, None);
        }
    }
 }
--- a/ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs
@@ -1,6 +1,11 @@
 using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;

 namespace ErsatzTV.Application.MediaCards
 {
-    public record TelevisionSeasonCardResultsViewModel(int Count, List<TelevisionSeasonCardViewModel> Cards);
+    public record TelevisionSeasonCardResultsViewModel(
+        int Count,
+        List<TelevisionSeasonCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
 }
--- a/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs
@@ -9,7 +9,9 @@ namespace ErsatzTV.Application.MediaCollections.Commands
        int CollectionId,
        List<int> MovieIds,
        List<int> ShowIds,
+        List<int> SeasonIds,
        List<int> EpisodeIds,
        List<int> ArtistIds,
-        List<int> MusicVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
+        List<int> MusicVideoIds,
+        List<int> OtherVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
 }
--- a/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs
@@ -52,9 +52,11 @@ namespace ErsatzTV.Application.MediaCollections.Commands
        {
            var allItems = request.MovieIds
                .Append(request.ShowIds)
+                .Append(request.SeasonIds)
                .Append(request.EpisodeIds)
                .Append(request.ArtistIds)
                .Append(request.MusicVideoIds)
+                .Append(request.OtherVideoIds)
                .ToList();

            var toAddIds = allItems.Where(item => collection.MediaItems.All(mi => mi.Id != item)).ToList();
@@ -77,12 +79,15 @@ namespace ErsatzTV.Application.MediaCollections.Commands
            return Unit.Default;
        }

-        private async Task<Validation<BaseError, Collection>> Validate(TvContext dbContext, AddItemsToCollection request) =>
+        private async Task<Validation<BaseError, Collection>> Validate(
+            TvContext dbContext,
+            AddItemsToCollection request) =>
            (await CollectionMustExist(dbContext, request),
                await ValidateMovies(request),
                await ValidateShows(request),
+                await ValidateSeasons(request),
                await ValidateEpisodes(request))
-            .Apply((collection, _, _, _) => collection);
+            .Apply((collection, _, _, _, _) => collection);

        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
            TvContext dbContext,
@@ -106,6 +111,13 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                .MapT(_ => Unit.Default)
                .Map(v => v.ToValidation<BaseError>("Show does not exist"));

+        private Task<Validation<BaseError, Unit>> ValidateSeasons(AddItemsToCollection request) =>
+            _televisionRepository.AllSeasonsExist(request.SeasonIds)
+                .Map(Optional)
+                .Filter(v => v == true)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Season does not exist"));
+
        private Task<Validation<BaseError, Unit>> ValidateEpisodes(AddItemsToCollection request) =>
            _televisionRepository.AllEpisodesExist(request.EpisodeIds)
                .Map(Optional)
--- a/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs
@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddOtherVideoToCollection
+        (int CollectionId, int OtherVideoId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs
@@ -0,0 +1,80 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class AddOtherVideoToCollectionHandler :
+        MediatR.IRequestHandler<AddOtherVideoToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public AddOtherVideoToCollectionHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _dbContextFactory = dbContextFactory;
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            AddOtherVideoToCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+            return await validation.Apply(parameters => ApplyAddOtherVideoRequest(dbContext, parameters));
+        }
+
+        private async Task<Unit> ApplyAddOtherVideoRequest(TvContext dbContext, Parameters parameters)
+        {
+            parameters.Collection.MediaItems.Add(parameters.OtherVideo);
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private static async Task<Validation<BaseError, Parameters>> Validate(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            (await CollectionMustExist(dbContext, request), await ValidateOtherVideo(dbContext, request))
+            .Apply((collection, episode) => new Parameters(collection, episode));
+
+        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            dbContext.Collections
+                .Include(c => c.MediaItems)
+                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+        private static Task<Validation<BaseError, OtherVideo>> ValidateOtherVideo(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            dbContext.OtherVideos
+                .SelectOneAsync(m => m.Id, e => e.Id == request.OtherVideoId)
+                .Map(o => o.ToValidation<BaseError>("OtherVideo does not exist"));
+
+        private record Parameters(Collection Collection, OtherVideo OtherVideo);
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/AddTraktList.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddTraktList.cs
@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddTraktList(string TraktListUrl) : IRequest<Either<BaseError, Unit>>, IBackgroundServiceRequest;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs
@@ -0,0 +1,80 @@
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Trakt;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class AddTraktListHandler : TraktCommandBase, IRequestHandler<AddTraktList, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IEntityLocker _entityLocker;
+
+        public AddTraktListHandler(
+            ITraktApiClient traktApiClient,
+            ISearchRepository searchRepository,
+            ISearchIndex searchIndex,
+            IDbContextFactory<TvContext> dbContextFactory,
+            ILogger<AddTraktListHandler> logger,
+            IEntityLocker entityLocker)
+            : base(traktApiClient, searchRepository, searchIndex, logger)
+        {
+            _dbContextFactory = dbContextFactory;
+            _entityLocker = entityLocker;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(AddTraktList request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                Validation<BaseError, Parameters> validation = ValidateUrl(request);
+                return await validation.Match(
+                    DoAdd,
+                    error => Task.FromResult<Either<BaseError, Unit>>(error.Join()));
+            }
+            finally
+            {
+                _entityLocker.UnlockTrakt();
+            }
+        }
+        
+        private static Validation<BaseError, Parameters> ValidateUrl(AddTraktList request)
+        {
+            const string PATTERN = @"(?:https:\/\/trakt\.tv\/users\/)?([\w\-_]+)\/(?:lists\/)?([\w\-_]+)";
+            Match match = Regex.Match(request.TraktListUrl, PATTERN);
+            if (match.Success)
+            {
+                string user = match.Groups[1].Value;
+                string list = match.Groups[2].Value;
+                return new Parameters(user, list);
+            }
+
+            return BaseError.New("Invalid Trakt list url");
+        }
+
+        private async Task<Either<BaseError, Unit>> DoAdd(Parameters parameters)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            
+            return await TraktApiClient.GetUserList(parameters.User, parameters.List)
+                .BindT(list => SaveList(dbContext, list))
+                .BindT(list => SaveListItems(dbContext, list))
+                .BindT(list => MatchListItems(dbContext, list))
+                .MapT(_ => Unit.Default);
+            
+            // match list items (and update in search index)
+        }
+
+        private record Parameters(string User, string List);
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs
@@ -56,7 +56,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                name => new MultiCollection
                {
                    Name = name,
-                    MultiCollectionItems = request.Items.Map(
+                    MultiCollectionItems = request.Items.Bind(
                            i =>
                            {
                                if (i.CollectionId.HasValue)
@@ -70,12 +70,10 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                                        });
                                }

-                                return None;
+                                return Option<MultiCollectionItem>.None;
                            })
-                        .Sequence()
-                        .Flatten()
                        .ToList(),
-                    MultiCollectionSmartItems = request.Items.Map(
+                    MultiCollectionSmartItems = request.Items.Bind(
                            i =>
                            {
                                if (i.SmartCollectionId.HasValue)
@@ -89,10 +87,8 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                                        });
                                }

-                                return None;
+                                return Option<MultiCollectionSmartItem>.None;
                            })
-                        .Sequence()
-                        .Flatten()
                        .ToList()
                });

--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktList.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktList.cs
@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record DeleteTraktList(int TraktListId) : IRequest<Either<BaseError, LanguageExt.Unit>>,
+        IBackgroundServiceRequest;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs
@@ -0,0 +1,79 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Trakt;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class DeleteTraktListHandler : TraktCommandBase, MediatR.IRequestHandler<DeleteTraktList, Either<BaseError, Unit>>
+    {
+        private readonly ISearchRepository _searchRepository;
+        private readonly ISearchIndex _searchIndex;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IEntityLocker _entityLocker;
+
+        public DeleteTraktListHandler(
+            ITraktApiClient traktApiClient,
+            ISearchRepository searchRepository,
+            ISearchIndex searchIndex,
+            IDbContextFactory<TvContext> dbContextFactory,
+            ILogger<DeleteTraktListHandler> logger,
+            IEntityLocker entityLocker)
+            : base(traktApiClient, searchRepository, searchIndex, logger)
+        {
+            _searchRepository = searchRepository;
+            _searchIndex = searchIndex;
+            _dbContextFactory = dbContextFactory;
+            _entityLocker = entityLocker;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DeleteTraktList request,
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+                Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
+                return await validation.Apply(c => DoDeletion(dbContext, c));
+            }
+            finally
+            {
+                _entityLocker.UnlockTrakt();
+            }
+        }
+
+        private async Task<Unit> DoDeletion(TvContext dbContext, TraktList traktList)
+        {
+            var mediaItemIds = traktList.Items.Bind(i => Optional(i.MediaItemId)).ToList();
+
+            dbContext.TraktLists.Remove(traktList);
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                foreach (int mediaItemId in mediaItemIds)
+                {
+                    foreach (MediaItem mediaItem in await _searchRepository.GetItemToIndex(mediaItemId))
+                    {
+                        await _searchIndex.UpdateItems(_searchRepository, new[] { mediaItem }.ToList());
+                    }
+                }
+            }
+
+            _searchIndex.Commit();
+
+            return Unit.Default;
+        }
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItems.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItems.cs
@@ -0,0 +1,10 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record MatchTraktListItems(int TraktListId, bool Unlock = true) : IRequest<Either<BaseError, Unit>>,
+        IBackgroundServiceRequest;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs
@@ -0,0 +1,58 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Trakt;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class MatchTraktListItemsHandler : TraktCommandBase,
+        IRequestHandler<MatchTraktListItems, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IEntityLocker _entityLocker;
+
+        public MatchTraktListItemsHandler(
+            ITraktApiClient traktApiClient,
+            ISearchRepository searchRepository,
+            ISearchIndex searchIndex,
+            IDbContextFactory<TvContext> dbContextFactory,
+            ILogger<MatchTraktListItemsHandler> logger,
+            IEntityLocker entityLocker) : base(traktApiClient, searchRepository, searchIndex, logger)
+        {
+            _dbContextFactory = dbContextFactory;
+            _entityLocker = entityLocker;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            MatchTraktListItems request,
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+                Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
+                return await validation.Match(
+                    async l => await MatchListItems(dbContext, l).MapT(_ => Unit.Default),
+                    error => Task.FromResult<Either<BaseError, Unit>>(error.Join()));
+            }
+            finally
+            {
+                if (request.Unlock)
+                {
+                    _entityLocker.UnlockTrakt();
+                }
+            }
+        }
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs
@@ -0,0 +1,341 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Trakt;
+using ErsatzTV.Core.Trakt;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public abstract class TraktCommandBase
+    {
+        private readonly ISearchRepository _searchRepository;
+        private readonly ISearchIndex _searchIndex;
+        private readonly ILogger _logger;
+
+        protected TraktCommandBase(
+            ITraktApiClient traktApiClient,
+            ISearchRepository searchRepository,
+            ISearchIndex searchIndex,
+            ILogger logger)
+        {
+            _searchRepository = searchRepository;
+            _searchIndex = searchIndex;
+            _logger = logger;
+            TraktApiClient = traktApiClient;
+        }
+
+        protected ITraktApiClient TraktApiClient { get; }
+
+        protected static Task<Validation<BaseError, TraktList>>
+            TraktListMustExist(TvContext dbContext, int traktListId) =>
+            dbContext.TraktLists
+                .Include(l => l.Items)
+                .ThenInclude(i => i.Guids)
+                .SelectOneAsync(c => c.Id, c => c.Id == traktListId)
+                .Map(o => o.ToValidation<BaseError>($"TraktList {traktListId} does not exist."));
+
+        protected async Task<Either<BaseError, TraktList>> SaveList(TvContext dbContext, TraktList list)
+        {
+            Option<TraktList> maybeExisting = await dbContext.TraktLists
+                .Include(l => l.Items)
+                .ThenInclude(i => i.Guids)
+                .SelectOneAsync(tl => tl.Id, tl => tl.User == list.User && tl.List == list.List);
+
+            return await maybeExisting.Match(
+                async existing =>
+                {
+                    existing.Name = list.Name;
+                    existing.Description = list.Description;
+                    existing.ItemCount = list.ItemCount;
+
+                    await dbContext.SaveChangesAsync();
+
+                    return existing;
+                },
+                async () =>
+                {
+                    await dbContext.TraktLists.AddAsync(list);
+                    await dbContext.SaveChangesAsync();
+
+                    return list;
+                });
+        }
+
+        protected async Task<Either<BaseError, TraktList>> SaveListItems(TvContext dbContext, TraktList list)
+        {
+            Either<BaseError, List<TraktListItemWithGuids>> maybeItems =
+                await TraktApiClient.GetUserListItems(list.User, list.List);
+
+            return await maybeItems.Match<Task<Either<BaseError, TraktList>>>(
+                async items =>
+                {
+                    var toAdd = items.Filter(i => list.Items.All(i2 => i2.TraktId != i.TraktId)).ToList();
+                    var toRemove = list.Items.Filter(i => items.All(i2 => i2.TraktId != i.TraktId)).ToList();
+                    var toUpdate = list.Items.Filter(i => !toRemove.Contains(i)).ToList();
+                    
+                    list.Items.RemoveAll(toRemove.Contains);
+                    list.Items.AddRange(toAdd.Map(a => ProjectItem(list, a)));
+
+                    foreach (TraktListItem existing in toUpdate)
+                    {
+                        Option<TraktListItem> maybeIncoming = list.Items.Find(i => i.TraktId == existing.TraktId);
+                        foreach (TraktListItem incoming in maybeIncoming)
+                        {
+                            existing.Kind = incoming.Kind;
+                            existing.Rank = incoming.Rank;
+                            existing.Title = incoming.Title;
+                            existing.Year = incoming.Year;
+                            existing.Season = incoming.Season;
+                            existing.Episode = incoming.Episode;
+                            existing.Guids.Clear();
+                            existing.Guids.AddRange(incoming.Guids);
+                            existing.MediaItemId = null;
+                            existing.MediaItem = null;
+                        }
+                    }
+
+                    await dbContext.SaveChangesAsync();
+
+                    return list;
+                },
+                error => Task.FromResult(Left<BaseError, TraktList>(error)));
+        }
+
+        protected async Task<Either<BaseError, TraktList>> MatchListItems(TvContext dbContext, TraktList list)
+        {
+            try
+            {
+                var ids = new System.Collections.Generic.HashSet<int>();
+
+                foreach (TraktListItem item in list.Items
+                    .OrderBy(i => i.Title).ThenBy(i => i.Year).ThenBy(i => i.Season).ThenBy(i => i.Episode))
+                {
+                    switch (item.Kind)
+                    {
+                        case TraktListItemKind.Movie:
+                            Option<int> maybeMovieId = await IdentifyMovie(dbContext, item);
+                            foreach (int movieId in maybeMovieId)
+                            {
+                                ids.Add(movieId);
+                                item.MediaItemId = movieId;
+                            }
+
+                            break;
+                        case TraktListItemKind.Show:
+                            Option<int> maybeShowId = await IdentifyShow(dbContext, item);
+                            foreach (int showId in maybeShowId)
+                            {
+                                ids.Add(showId);
+                                item.MediaItemId = showId;
+                            }
+
+                            break;
+                        case TraktListItemKind.Season:
+                            Option<int> maybeSeasonId = await IdentifySeason(dbContext, item);
+                            foreach (int seasonId in maybeSeasonId)
+                            {
+                                ids.Add(seasonId);
+                                item.MediaItemId = seasonId;
+                            }
+
+                            break;
+                        default:
+                            Option<int> maybeEpisodeId = await IdentifyEpisode(dbContext, item);
+                            foreach (int episodeId in maybeEpisodeId)
+                            {
+                                ids.Add(episodeId);
+                                item.MediaItemId = episodeId;
+                            }
+
+                            break;
+                    }
+                }
+
+                await dbContext.SaveChangesAsync();
+
+                foreach (int mediaItemId in ids)
+                {
+                    Option<MediaItem> maybeItem = await _searchRepository.GetItemToIndex(mediaItemId);
+                    foreach (MediaItem item in maybeItem)
+                    {
+                        await _searchIndex.UpdateItems(_searchRepository, new[] { item }.ToList());
+                    }
+                }
+
+                _searchIndex.Commit();
+
+                return list;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error matching trakt list items");
+                return BaseError.New(ex.Message);
+            }
+        }
+
+        private static TraktListItem ProjectItem(TraktList list, TraktListItemWithGuids item)
+        {
+            var result = new TraktListItem
+            {
+                TraktList = list,
+                Kind = item.Kind,
+                TraktId = item.TraktId,
+                Rank = item.Rank,
+                Title = item.Title,
+                Year = item.Year,
+                Season = item.Season,
+                Episode = item.Episode,
+            };
+
+            result.Guids = item.Guids.Map(g => new TraktListItemGuid { Guid = g, TraktListItem = result }).ToList();
+
+            return result;
+        }
+        
+        private async Task<Option<int>> IdentifyMovie(TvContext dbContext, TraktListItem item)
+        {
+            var guids = item.Guids.Map(g => g.Guid).ToList();
+            
+            Option<int> maybeMovieByGuid = await dbContext.MovieMetadata
+                .Filter(mm => mm.Guids.Any(g => guids.Contains(g.Guid)))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(mm => mm.MovieId);
+
+            foreach (int movieId in maybeMovieByGuid)
+            {
+                _logger.LogDebug("Located trakt movie {Title} by id", item.DisplayTitle);
+                return movieId;
+            }
+
+            Option<int> maybeMovieByTitleYear = await dbContext.MovieMetadata
+                .Filter(mm => mm.Title == item.Title && mm.Year == item.Year)
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(mm => mm.MovieId);
+
+            foreach (int movieId in maybeMovieByTitleYear)
+            {
+                _logger.LogDebug("Located trakt movie {Title} by title/year", item.DisplayTitle);
+                return movieId;
+            }
+
+            _logger.LogDebug("Unable to locate trakt movie {Title}", item.DisplayTitle);
+
+            return None;
+        }
+
+        private async Task<Option<int>> IdentifyShow(TvContext dbContext, TraktListItem item)
+        {
+            var guids = item.Guids.Map(g => g.Guid).ToList();
+
+            Option<int> maybeShowByGuid = await dbContext.ShowMetadata
+                .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.ShowId);
+
+            foreach (int showId in maybeShowByGuid)
+            {
+                _logger.LogDebug("Located trakt show {Title} by id", item.DisplayTitle);
+                return showId;
+            }
+
+            Option<int> maybeShowByTitleYear = await dbContext.ShowMetadata
+                .Filter(sm => sm.Title == item.Title && sm.Year == item.Year)
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.ShowId);
+
+            foreach (int showId in maybeShowByTitleYear)
+            {
+                _logger.LogDebug("Located trakt show {Title} by title/year", item.Title);
+                return showId;
+            }
+
+            _logger.LogDebug("Unable to locate trakt show {Title}", item.DisplayTitle);
+
+            return None;
+        }
+        
+        private async Task<Option<int>> IdentifySeason(TvContext dbContext, TraktListItem item)
+        {
+            var guids = item.Guids.Map(g => g.Guid).ToList();
+
+            Option<int> maybeSeasonByGuid = await dbContext.SeasonMetadata
+                .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.SeasonId);
+
+            foreach (int seasonId in maybeSeasonByGuid)
+            {
+                _logger.LogDebug("Located trakt season {Title} by id", item.DisplayTitle);
+                return seasonId;
+            }
+
+            Option<int> maybeSeasonByTitleYear = await dbContext.SeasonMetadata
+                .Filter(sm => sm.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
+                .Filter(sm => sm.Season.SeasonNumber == item.Season)
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.SeasonId);
+
+            foreach (int seasonId in maybeSeasonByTitleYear)
+            {
+                _logger.LogDebug("Located trakt season {Title} by title/year/season", item.DisplayTitle);
+                return seasonId;
+            }
+
+            _logger.LogDebug("Unable to locate trakt season {Title}", item.DisplayTitle);
+
+            return None;
+        }
+        
+        private async Task<Option<int>> IdentifyEpisode(TvContext dbContext, TraktListItem item)
+        {
+            var guids = item.Guids.Map(g => g.Guid).ToList();
+
+            Option<int> maybeEpisodeByGuid = await dbContext.EpisodeMetadata
+                .Filter(em => em.Guids.Any(g => guids.Contains(g.Guid)))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.EpisodeId);
+
+            foreach (int episodeId in maybeEpisodeByGuid)
+            {
+                _logger.LogDebug("Located trakt episode {Title} by id", item.DisplayTitle);
+                return episodeId;
+            }
+
+            Option<int> maybeEpisodeByTitleYear = await dbContext.EpisodeMetadata
+                .Filter(sm => sm.Episode.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
+                .Filter(em => em.Episode.Season.SeasonNumber == item.Season)
+                .Filter(sm => sm.Episode.EpisodeMetadata.Any(e => e.EpisodeNumber == item.Episode))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.EpisodeId);
+
+            foreach (int episodeId in maybeEpisodeByTitleYear)
+            {
+                _logger.LogDebug("Located trakt episode {Title} by title/year/season/episode", item.DisplayTitle);
+                return episodeId;
+            }
+
+            _logger.LogDebug("Unable to locate trakt episode {Title}", item.DisplayTitle);
+
+            return None;
+        }
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Mapper.cs
+++ b/ErsatzTV.Application/MediaCollections/Mapper.cs
@@ -19,6 +19,15 @@ namespace ErsatzTV.Application.MediaCollections
        internal static SmartCollectionViewModel ProjectToViewModel(SmartCollection collection) =>
            new(collection.Id, collection.Name, collection.Query);

+        internal static TraktListViewModel ProjectToViewModel(TraktList traktList) =>
+            new(
+                traktList.Id,
+                traktList.TraktId,
+                $"{traktList.User}/{traktList.List}",
+                traktList.Name,
+                traktList.ItemCount,
+                traktList.Items.Count(i => i.MediaItemId.HasValue));
+
        private static MultiCollectionItemViewModel ProjectToViewModel(MultiCollectionItem multiCollectionItem) =>
            new(
                multiCollectionItem.MultiCollectionId,
--- a/ErsatzTV.Application/MediaCollections/PagedTraktListsViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/PagedTraktListsViewModel.cs
@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record PagedTraktListsViewModel(int TotalCount, List<TraktListViewModel> Page);
+}
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktLists.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktLists.cs
@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public record GetPagedTraktLists(int PageNum, int PageSize) : IRequest<PagedTraktListsViewModel>;
+}
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktListsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktListsHandler.cs
@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public class GetPagedTraktListsHandler : IRequestHandler<GetPagedTraktLists, PagedTraktListsViewModel>
+    {
+        private readonly IDbConnection _dbConnection;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetPagedTraktListsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+        }
+
+        public async Task<PagedTraktListsViewModel> Handle(
+            GetPagedTraktLists request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM TraktList");
+
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            List<TraktListViewModel> page = await dbContext.TraktLists.FromSqlRaw(
+                    @"SELECT * FROM TraktList
+                    ORDER BY Name
+                    COLLATE NOCASE
+                    LIMIT {0} OFFSET {1}",
+                    request.PageSize,
+                    request.PageNum * request.PageSize)
+                .Include(l => l.Items)
+                .ToListAsync(cancellationToken)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new PagedTraktListsViewModel(count, page);
+        }
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/TraktListViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/TraktListViewModel.cs
@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record TraktListViewModel(int Id, int TraktId, string Slug, string Name, int ItemCount, int MatchCount);
+}
--- a/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
@@ -26,6 +26,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
        private readonly IMediator _mediator;
        private readonly IMovieFolderScanner _movieFolderScanner;
        private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
+        private readonly IOtherVideoFolderScanner _otherVideoFolderScanner;
        private readonly ITelevisionFolderScanner _televisionFolderScanner;

        public ScanLocalLibraryHandler(
@@ -34,6 +35,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
            IMovieFolderScanner movieFolderScanner,
            ITelevisionFolderScanner televisionFolderScanner,
            IMusicVideoFolderScanner musicVideoFolderScanner,
+            IOtherVideoFolderScanner otherVideoFolderScanner,
            IEntityLocker entityLocker,
            IMediator mediator,
            ILogger<ScanLocalLibraryHandler> logger)
@@ -43,6 +45,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
            _movieFolderScanner = movieFolderScanner;
            _televisionFolderScanner = televisionFolderScanner;
            _musicVideoFolderScanner = musicVideoFolderScanner;
+            _otherVideoFolderScanner = otherVideoFolderScanner;
            _entityLocker = entityLocker;
            _mediator = mediator;
            _logger = logger;
@@ -78,7 +81,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
                decimal progressMin = (decimal) i / localLibrary.Paths.Count;
                decimal progressMax = (decimal) (i + 1) / localLibrary.Paths.Count;

-                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
                DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
                if (forceScan || nextScan < DateTimeOffset.Now)
                {
@@ -107,6 +110,13 @@ namespace ErsatzTV.Application.MediaSources.Commands
                                progressMin,
                                progressMax);
                            break;
+                        case LibraryMediaKind.OtherVideos:
+                            await _otherVideoFolderScanner.ScanFolder(
+                                libraryPath,
+                                ffprobePath,
+                                progressMin,
+                                progressMax);
+                            break;
                    }

                    libraryPath.LastScan = DateTime.UtcNow;
--- a/ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs
+++ b/ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs
@@ -0,0 +1,10 @@
+using System;
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Playouts.Commands
+{
+    public record UpdatePlayout
+        (int PlayoutId, Option<TimeSpan> DailyRebuildTime) : IRequest<Either<BaseError, PlayoutNameViewModel>>;
+}
--- a/ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs
+++ b/ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Playouts.Commands
+{
+    public class UpdatePlayoutHandler : IRequestHandler<UpdatePlayout, Either<BaseError, PlayoutNameViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public UpdatePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Either<BaseError, PlayoutNameViewModel>> Handle(
+            UpdatePlayout request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, Playout> validation = await Validate(dbContext, request);
+            return await validation.Apply(playout => ApplyUpdateRequest(dbContext, request, playout));
+        }
+
+        private static async Task<PlayoutNameViewModel> ApplyUpdateRequest(
+            TvContext dbContext,
+            UpdatePlayout request,
+            Playout playout)
+        {
+            playout.DailyRebuildTime = null;
+
+            foreach (TimeSpan dailyRebuildTime in request.DailyRebuildTime)
+            {
+                playout.DailyRebuildTime = dailyRebuildTime;
+            }
+
+            await dbContext.SaveChangesAsync();
+
+            return new PlayoutNameViewModel(
+                playout.Id,
+                playout.Channel.Name,
+                playout.Channel.Number,
+                playout.ProgramSchedule.Name,
+                Optional(playout.DailyRebuildTime));
+        }
+
+        private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, UpdatePlayout request) =>
+            PlayoutMustExist(dbContext, request);
+
+        private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
+            TvContext dbContext,
+            UpdatePlayout updatePlayout) =>
+            dbContext.Playouts
+                .Include(p => p.Channel)
+                .Include(p => p.ProgramSchedule)
+                .SelectOneAsync(p => p.Id, p => p.Id == updatePlayout.PlayoutId)
+                .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+    }
+}
--- a/ErsatzTV.Application/Playouts/Mapper.cs
+++ b/ErsatzTV.Application/Playouts/Mapper.cs
@@ -37,6 +37,9 @@ namespace ErsatzTV.Application.Playouts
                    return mv.MusicVideoMetadata.HeadOrNone()
                        .Map(mvm => $"{artistName}{mvm.Title}")
                        .IfNone("[unknown music video]");
+                case OtherVideo ov:
+                    return ov.OtherVideoMetadata.HeadOrNone().Map(ovm => ovm.Title ?? string.Empty)
+                        .IfNone("[unknown video]");
                default:
                    return string.Empty;
            }
@@ -49,6 +52,7 @@ namespace ErsatzTV.Application.Playouts
                Movie m => m.MediaVersions.Head(),
                Episode e => e.MediaVersions.Head(),
                MusicVideo mv => mv.MediaVersions.Head(),
+                OtherVideo ov => ov.MediaVersions.Head(),
                _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
            };

--- a/ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs
+++ b/ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs
@@ -1,8 +1,12 @@
-namespace ErsatzTV.Application.Playouts
+using System;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Playouts
 {
    public record PlayoutNameViewModel(
        int PlayoutId,
        string ChannelName,
        string ChannelNumber,
-        string ScheduleName);
+        string ScheduleName,
+        Option<TimeSpan> DailyRebuildTime);
 }
--- a/ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs
@@ -4,6 +4,7 @@ using System.Threading.Tasks;
 using ErsatzTV.Infrastructure.Data;
 using MediatR;
 using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;

 namespace ErsatzTV.Application.Playouts.Queries
 {
@@ -21,7 +22,13 @@ namespace ErsatzTV.Application.Playouts.Queries
            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
            return await dbContext.Playouts
                .Filter(p => p.Channel != null && p.ProgramSchedule != null)
-                .Map(p => new PlayoutNameViewModel(p.Id, p.Channel.Name, p.Channel.Number, p.ProgramSchedule.Name))
+                .Map(
+                    p => new PlayoutNameViewModel(
+                        p.Id,
+                        p.Channel.Name,
+                        p.Channel.Number,
+                        p.ProgramSchedule.Name,
+                        Optional(p.DailyRebuildTime)))
                .ToListAsync(cancellationToken);
        }
    }
--- a/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs
@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Playouts.Queries
+{
+    public record GetFuturePlayoutItemsById(int PlayoutId, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
+}
--- a/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -11,21 +12,23 @@ using static ErsatzTV.Application.Playouts.Mapper;

 namespace ErsatzTV.Application.Playouts.Queries
 {
-    public class GetPlayoutItemsByIdHandler : IRequestHandler<GetPlayoutItemsById, PagedPlayoutItemsViewModel>
+    public class GetFuturePlayoutItemsByIdHandler : IRequestHandler<GetFuturePlayoutItemsById, PagedPlayoutItemsViewModel>
    {
        private readonly IDbContextFactory<TvContext> _dbContextFactory;

-        public GetPlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        public GetFuturePlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
            _dbContextFactory = dbContextFactory;

        public async Task<PagedPlayoutItemsViewModel> Handle(
-            GetPlayoutItemsById request,
+            GetFuturePlayoutItemsById request,
            CancellationToken cancellationToken)
        {
            await using TvContext dbContext = _dbContextFactory.CreateDbContext();

            int totalCount = await dbContext.PlayoutItems
                .CountAsync(i => i.PlayoutId == request.PlayoutId, cancellationToken);
+
+            DateTime now = DateTimeOffset.Now.UtcDateTime;
            
            List<PlayoutItemViewModel> page = await dbContext.PlayoutItems
                .Include(i => i.MediaItem)
@@ -49,7 +52,12 @@ namespace ErsatzTV.Application.Playouts.Queries
                .Include(i => i.MediaItem)
                .ThenInclude(mi => (mi as Episode).Season.Show)
                .ThenInclude(s => s.ShowMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
                .Filter(i => i.PlayoutId == request.PlayoutId)
+                .Filter(i => i.Finish >= now)
                .OrderBy(i => i.Start)
                .Skip(request.PageNum * request.PageSize)
                .Take(request.PageSize)
--- a/ErsatzTV.Application/Playouts/Queries/GetPlayoutItemsById.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetPlayoutItemsById.cs
@@ -1,7 +0,0 @@
-using System.Collections.Generic;
-using MediatR;
-
-namespace ErsatzTV.Application.Playouts.Queries
-{
-    public record GetPlayoutItemsById(int PlayoutId, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
-}
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs
@@ -65,7 +65,7 @@ namespace ErsatzTV.Application.Plex.Commands

        private async Task<Unit> Synchronize(RequestParameters parameters)
        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
            {
--- a/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs
@@ -19,6 +19,12 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
        PlaybackOrder PlaybackOrder,
        int? MultipleCount,
        TimeSpan? PlayoutDuration,
-        bool? OfflineTail,
-        string CustomTitle) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
+        TailMode TailMode,
+        ProgramScheduleItemCollectionType TailCollectionType,
+        int? TailCollectionId,
+        int? TailMultiCollectionId,
+        int? TailSmartCollectionId,
+        int? TailMediaItemId,
+        string CustomTitle,
+        GuideMode GuideMode) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
 }
--- a/ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs
@@ -15,7 +15,13 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
        PlaybackOrder PlaybackOrder { get; }
        int? MultipleCount { get; }
        TimeSpan? PlayoutDuration { get; }
-        bool? OfflineTail { get; }
+        TailMode TailMode { get; }
+        ProgramScheduleItemCollectionType TailCollectionType { get; }
+        int? TailCollectionId { get; }
+        int? TailMultiCollectionId { get; }
+        int? TailSmartCollectionId { get; }
+        int? TailMediaItemId { get; }
        string CustomTitle { get; }
+        GuideMode GuideMode { get; }
    }
 }
--- a/ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs
@@ -55,11 +55,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                        return BaseError.New("[PlayoutDuration] is required for playout mode 'duration'");
                    }

-                    if (item.OfflineTail is null)
-                    {
-                        return BaseError.New("[OfflineTail] is required for playout mode 'duration'");
-                    }
-
                    break;
                default:
                    return BaseError.New("[PlayoutMode] is invalid");
@@ -140,7 +135,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                    SmartCollectionId = item.SmartCollectionId,
                    MediaItemId = item.MediaItemId,
                    PlaybackOrder = item.PlaybackOrder,
-                    CustomTitle = item.CustomTitle
+                    CustomTitle = item.CustomTitle,
+                    GuideMode = item.GuideMode
                },
                PlayoutMode.One => new ProgramScheduleItemOne
                {
@@ -153,7 +149,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                    SmartCollectionId = item.SmartCollectionId,
                    MediaItemId = item.MediaItemId,
                    PlaybackOrder = item.PlaybackOrder,
-                    CustomTitle = item.CustomTitle
+                    CustomTitle = item.CustomTitle,
+                    GuideMode = item.GuideMode
                },
                PlayoutMode.Multiple => new ProgramScheduleItemMultiple
                {
@@ -167,7 +164,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                    MediaItemId = item.MediaItemId,
                    PlaybackOrder = item.PlaybackOrder,
                    Count = item.MultipleCount.GetValueOrDefault(),
-                    CustomTitle = item.CustomTitle
+                    CustomTitle = item.CustomTitle,
+                    GuideMode = item.GuideMode
                },
                PlayoutMode.Duration => new ProgramScheduleItemDuration
                {
@@ -181,8 +179,14 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                    MediaItemId = item.MediaItemId,
                    PlaybackOrder = item.PlaybackOrder,
                    PlayoutDuration = FixDuration(item.PlayoutDuration.GetValueOrDefault()),
-                    OfflineTail = item.OfflineTail.GetValueOrDefault(),
-                    CustomTitle = item.CustomTitle
+                    TailMode = item.TailMode,
+                    TailCollectionType = item.TailCollectionType,
+                    TailCollectionId = item.TailCollectionId,
+                    TailMultiCollectionId = item.TailMultiCollectionId,
+                    TailSmartCollectionId = item.TailSmartCollectionId,
+                    TailMediaItemId = item.TailMediaItemId,
+                    CustomTitle = item.CustomTitle,
+                    GuideMode = item.GuideMode
                },
                _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
            };
--- a/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs
@@ -20,8 +20,14 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
        PlaybackOrder PlaybackOrder,
        int? MultipleCount,
        TimeSpan? PlayoutDuration,
-        bool? OfflineTail,
-        string CustomTitle) : IProgramScheduleItemRequest;
+        TailMode TailMode,
+        ProgramScheduleItemCollectionType TailCollectionType,
+        int? TailCollectionId,
+        int? TailMultiCollectionId,
+        int? TailSmartCollectionId,
+        int? TailMediaItemId,
+        string CustomTitle,
+        GuideMode GuideMode) : IProgramScheduleItemRequest;

    public record ReplaceProgramScheduleItems
        (int ProgramScheduleId, List<ReplaceProgramScheduleItem> Items) : IRequest<
--- a/ErsatzTV.Application/ProgramSchedules/Mapper.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Mapper.cs
@@ -40,8 +40,26 @@ namespace ErsatzTV.Application.ProgramSchedules
                        },
                        duration.PlaybackOrder,
                        duration.PlayoutDuration,
-                        duration.OfflineTail,
-                        duration.CustomTitle),
+                        duration.TailMode,
+                        duration.TailCollectionType,
+                        duration.TailCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(duration.TailCollection)
+                            : null,
+                        duration.TailMultiCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(duration.TailMultiCollection)
+                            : null,
+                        duration.TailSmartCollection != null
+                            ? MediaCollections.Mapper.ProjectToViewModel(duration.TailSmartCollection)
+                            : null,
+                        duration.TailMediaItem switch
+                        {
+                            Show show => MediaItems.Mapper.ProjectToViewModel(show),
+                            Season season => MediaItems.Mapper.ProjectToViewModel(season),
+                            Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
+                            _ => null
+                        },
+                        duration.CustomTitle,
+                        duration.GuideMode),
                ProgramScheduleItemFlood flood =>
                    new ProgramScheduleItemFloodViewModel(
                        flood.Id,
@@ -66,7 +84,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                            _ => null
                        },
                        flood.PlaybackOrder,
-                        flood.CustomTitle),
+                        flood.CustomTitle,
+                        flood.GuideMode),
                ProgramScheduleItemMultiple multiple =>
                    new ProgramScheduleItemMultipleViewModel(
                        multiple.Id,
@@ -92,7 +111,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                        },
                        multiple.PlaybackOrder,
                        multiple.Count,
-                        multiple.CustomTitle),
+                        multiple.CustomTitle,
+                        multiple.GuideMode),
                ProgramScheduleItemOne one =>
                    new ProgramScheduleItemOneViewModel(
                        one.Id,
@@ -117,7 +137,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                            _ => null
                        },
                        one.PlaybackOrder,
-                        one.CustomTitle),
+                        one.CustomTitle,
+                        one.GuideMode),
                _ => throw new NotSupportedException(
                    $"Unsupported program schedule item type {programScheduleItem.GetType().Name}")
            };
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs
@@ -19,8 +19,14 @@ namespace ErsatzTV.Application.ProgramSchedules
            NamedMediaItemViewModel mediaItem,
            PlaybackOrder playbackOrder,
            TimeSpan playoutDuration,
-            bool offlineTail,
-            string customTitle) : base(
+            TailMode tailMode,
+            ProgramScheduleItemCollectionType tailCollectionType,
+            MediaCollectionViewModel tailCollection,
+            MultiCollectionViewModel tailMultiCollection,
+            SmartCollectionViewModel tailSmartCollection,
+            NamedMediaItemViewModel tailMediaItem,
+            string customTitle,
+            GuideMode guideMode) : base(
            id,
            index,
            startType,
@@ -32,13 +38,26 @@ namespace ErsatzTV.Application.ProgramSchedules
            smartCollection,
            mediaItem,
            playbackOrder,
-            customTitle)
+            customTitle,
+            guideMode)
        {
            PlayoutDuration = playoutDuration;
-            OfflineTail = offlineTail;
+            TailMode = tailMode;
+            TailCollectionType = tailCollectionType;
+            TailCollection = tailCollection;
+            TailMultiCollection = tailMultiCollection;
+            TailSmartCollection = tailSmartCollection;
+            TailMediaItem = tailMediaItem;
        }

        public TimeSpan PlayoutDuration { get; }
-        public bool OfflineTail { get; }
+        public TailMode TailMode { get; }
+        public ProgramScheduleItemCollectionType TailCollectionType { get; }
+
+        public MediaCollectionViewModel TailCollection { get; }
+        public MultiCollectionViewModel TailMultiCollection { get; }
+        public SmartCollectionViewModel TailSmartCollection { get; }
+        public NamedMediaItemViewModel TailMediaItem { get; }
+
    }
 }
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs
@@ -18,7 +18,8 @@ namespace ErsatzTV.Application.ProgramSchedules
            SmartCollectionViewModel smartCollection,
            NamedMediaItemViewModel mediaItem,
            PlaybackOrder playbackOrder,
-            string customTitle) : base(
+            string customTitle,
+            GuideMode guideMode) : base(
            id,
            index,
            startType,
@@ -30,7 +31,8 @@ namespace ErsatzTV.Application.ProgramSchedules
            smartCollection,
            mediaItem,
            playbackOrder,
-            customTitle)
+            customTitle,
+            guideMode)
        {
        }
    }
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs
@@ -19,7 +19,8 @@ namespace ErsatzTV.Application.ProgramSchedules
            NamedMediaItemViewModel mediaItem,
            PlaybackOrder playbackOrder,
            int count,
-            string customTitle) : base(
+            string customTitle,
+            GuideMode guideMode) : base(
            id,
            index,
            startType,
@@ -31,7 +32,8 @@ namespace ErsatzTV.Application.ProgramSchedules
            smartCollection,
            mediaItem,
            playbackOrder,
-            customTitle) =>
+            customTitle,
+            guideMode) =>
            Count = count;

        public int Count { get; }
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs
@@ -18,7 +18,8 @@ namespace ErsatzTV.Application.ProgramSchedules
            SmartCollectionViewModel smartCollection,
            NamedMediaItemViewModel mediaItem,
            PlaybackOrder playbackOrder,
-            string customTitle) : base(
+            string customTitle,
+            GuideMode guideMode) : base(
            id,
            index,
            startType,
@@ -30,7 +31,8 @@ namespace ErsatzTV.Application.ProgramSchedules
            smartCollection,
            mediaItem,
            playbackOrder,
-            customTitle)
+            customTitle,
+            guideMode)
        {
        }
    }
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs
@@ -17,7 +17,8 @@ namespace ErsatzTV.Application.ProgramSchedules
        SmartCollectionViewModel SmartCollection,
        NamedMediaItemViewModel MediaItem,
        PlaybackOrder PlaybackOrder,
-        string CustomTitle)
+        string CustomTitle,
+        GuideMode GuideMode)
    {
        public string Name => CollectionType switch
        {
--- a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs
@@ -30,6 +30,10 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
                .Include(i => i.MultiCollection)
                .Include(i => i.SmartCollection)
                .Include(i => i.MediaItem)
+                .Include(i => (i as ProgramScheduleItemDuration).TailCollection)
+                .Include(i => (i as ProgramScheduleItemDuration).TailMultiCollection)
+                .Include(i => (i as ProgramScheduleItemDuration).TailSmartCollection)
+                .Include(i => (i as ProgramScheduleItemDuration).TailMediaItem)
                .ThenInclude(i => (i as Movie).MovieMetadata)
                .ThenInclude(mm => mm.Artwork)
                .Include(i => i.MediaItem)
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs
@@ -3,6 +3,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Infrastructure.Search;
 using LanguageExt;
 using MediatR;

@@ -19,11 +20,13 @@ namespace ErsatzTV.Application.Search.Queries
            QuerySearchIndexAllItems request,
            CancellationToken cancellationToken) =>
            new(
-                await GetIds("movie", request.Query),
-                await GetIds("show", request.Query),
-                await GetIds("episode", request.Query),
-                await GetIds("artist", request.Query),
-                await GetIds("music_video", request.Query));
+                await GetIds(SearchIndex.MovieType, request.Query),
+                await GetIds(SearchIndex.ShowType, request.Query),
+                await GetIds(SearchIndex.SeasonType, request.Query),
+                await GetIds(SearchIndex.EpisodeType, request.Query),
+                await GetIds(SearchIndex.ArtistType, request.Query),
+                await GetIds(SearchIndex.MusicVideoType, request.Query),
+                await GetIds(SearchIndex.OtherVideoType, request.Query));

        private Task<List<int>> GetIds(string type, string query) =>
            _searchIndex.Search($"type:{type} AND ({query})", 0, 0)
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideos.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideos.cs
@@ -0,0 +1,8 @@
+using ErsatzTV.Application.MediaCards;
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public record QuerySearchIndexOtherVideos
+        (string Query, int PageNumber, int PageSize) : IRequest<OtherVideoCardResultsViewModel>;
+}
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs
@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class
+        QuerySearchIndexOtherVideosHandler : IRequestHandler<QuerySearchIndexOtherVideos,
+            OtherVideoCardResultsViewModel>
+    {
+        private readonly IOtherVideoRepository _otherVideoRepository;
+        private readonly ISearchIndex _searchIndex;
+
+        public QuerySearchIndexOtherVideosHandler(ISearchIndex searchIndex, IOtherVideoRepository otherVideoRepository)
+        {
+            _searchIndex = searchIndex;
+            _otherVideoRepository = otherVideoRepository;
+        }
+
+        public async Task<OtherVideoCardResultsViewModel> Handle(
+            QuerySearchIndexOtherVideos request,
+            CancellationToken cancellationToken)
+        {
+            SearchResult searchResult = await _searchIndex.Search(
+                request.Query,
+                (request.PageNumber - 1) * request.PageSize,
+                request.PageSize);
+
+            List<OtherVideoCardViewModel> items = await _otherVideoRepository
+                .GetOtherVideosForCards(searchResult.Items.Map(i => i.Id).ToList())
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new OtherVideoCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+        }
+    }
+}
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasons.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasons.cs
@@ -0,0 +1,8 @@
+using ErsatzTV.Application.MediaCards;
+using MediatR;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public record QuerySearchIndexSeasons
+        (string Query, int PageNumber, int PageSize) : IRequest<TelevisionSeasonCardResultsViewModel>;
+}
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasonsHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasonsHandler.cs
@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.MediaCards.Mapper;
+
+namespace ErsatzTV.Application.Search.Queries
+{
+    public class
+        QuerySearchIndexSeasonsHandler : IRequestHandler<QuerySearchIndexSeasons, TelevisionSeasonCardResultsViewModel>
+    {
+        private readonly IMediaSourceRepository _mediaSourceRepository;
+        private readonly ISearchIndex _searchIndex;
+        private readonly ITelevisionRepository _televisionRepository;
+
+        public QuerySearchIndexSeasonsHandler(
+            ISearchIndex searchIndex,
+            ITelevisionRepository televisionRepository,
+            IMediaSourceRepository mediaSourceRepository)
+        {
+            _searchIndex = searchIndex;
+            _televisionRepository = televisionRepository;
+            _mediaSourceRepository = mediaSourceRepository;
+        }
+
+        public async Task<TelevisionSeasonCardResultsViewModel> Handle(
+            QuerySearchIndexSeasons request,
+            CancellationToken cancellationToken)
+        {
+            SearchResult searchResult = await _searchIndex.Search(
+                request.Query,
+                (request.PageNumber - 1) * request.PageSize,
+                request.PageSize);
+
+            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+                .Map(list => list.HeadOrNone());
+
+            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                .Map(list => list.HeadOrNone());
+
+            List<TelevisionSeasonCardViewModel> items = await _televisionRepository
+                .GetSeasonsForCards(searchResult.Items.Map(i => i.Id).ToList())
+                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
+
+            return new TelevisionSeasonCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+        }
+    }
+}
--- a/ErsatzTV.Application/Search/SearchResultAllItemsViewModel.cs
+++ b/ErsatzTV.Application/Search/SearchResultAllItemsViewModel.cs
@@ -5,7 +5,9 @@ namespace ErsatzTV.Application.Search
    public record SearchResultAllItemsViewModel(
        List<int> MovieIds,
        List<int> ShowIds,
+        List<int> SeasonIds,
        List<int> EpisodeIds,
        List<int> ArtistIds,
-        List<int> MusicVideoIds);
+        List<int> MusicVideoIds,
+        List<int> OtherVideoIds);
 }
--- a/ErsatzTV.Application/Streaming/Commands/StartFFmpegSession.cs
+++ b/ErsatzTV.Application/Streaming/Commands/StartFFmpegSession.cs
@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Streaming.Commands
+{
+    public record StartFFmpegSession(string ChannelNumber, bool StartAtZero) :
+        MediatR.IRequest<Either<BaseError, Unit>>,
+        IFFmpegWorkerRequest;
+}
--- a/ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs
+++ b/ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs
@@ -0,0 +1,111 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Streaming.Commands
+{
+    public class StartFFmpegSessionHandler : MediatR.IRequestHandler<StartFFmpegSession, Either<BaseError, Unit>>
+    {
+        private readonly ILogger<StartFFmpegSessionHandler> _logger;
+        private readonly IServiceScopeFactory _serviceScopeFactory;
+        private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
+        private readonly IConfigElementRepository _configElementRepository;
+        private readonly ILocalFileSystem _localFileSystem;
+
+        public StartFFmpegSessionHandler(
+            ILocalFileSystem localFileSystem,
+            ILogger<StartFFmpegSessionHandler> logger,
+            IServiceScopeFactory serviceScopeFactory,
+            IFFmpegSegmenterService ffmpegSegmenterService,
+            IConfigElementRepository configElementRepository)
+        {
+            _localFileSystem = localFileSystem;
+            _logger = logger;
+            _serviceScopeFactory = serviceScopeFactory;
+            _ffmpegSegmenterService = ffmpegSegmenterService;
+            _configElementRepository = configElementRepository;
+        }
+
+        public Task<Either<BaseError, Unit>> Handle(StartFFmpegSession request, CancellationToken cancellationToken) =>
+            Validate(request)
+                .MapT(_ => StartProcess(request))
+                // this weirdness is needed to maintain the error type (.ToEitherAsync() just gives BaseError)
+#pragma warning disable VSTHRD103
+                .Bind(v => v.ToEither().MapLeft(seq => seq.Head()).MapAsync<BaseError, Task<Unit>, Unit>(identity));
+#pragma warning restore VSTHRD103
+
+        private async Task<Unit> StartProcess(StartFFmpegSession request)
+        {
+            TimeSpan idleTimeout = await _configElementRepository
+                .GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout)
+                .Map(maybeTimeout => maybeTimeout.Match(i => TimeSpan.FromSeconds(i), () => TimeSpan.FromMinutes(1)));
+            
+            using IServiceScope scope = _serviceScopeFactory.CreateScope();
+            HlsSessionWorker worker = scope.ServiceProvider.GetRequiredService<HlsSessionWorker>();
+            _ffmpegSegmenterService.SessionWorkers.AddOrUpdate(request.ChannelNumber, _ => worker, (_, _) => worker);
+
+            // fire and forget worker
+            _ = worker.Run(request.ChannelNumber, idleTimeout)
+                .ContinueWith(
+                    _ => _ffmpegSegmenterService.SessionWorkers.TryRemove(
+                        request.ChannelNumber,
+                        out IHlsSessionWorker _),
+                    TaskScheduler.Default);
+
+            string playlistFileName = Path.Combine(
+                FileSystemLayout.TranscodeFolder,
+                request.ChannelNumber,
+                "live.m3u8");
+
+            while (!File.Exists(playlistFileName))
+            {
+                await Task.Delay(TimeSpan.FromMilliseconds(100));
+            }
+
+            return Unit.Default;
+        }
+
+        private Task<Validation<BaseError, Unit>> Validate(StartFFmpegSession request) =>
+            SessionMustBeInactive(request)
+                .BindT(_ => FolderMustBeEmpty(request));
+
+        private Task<Validation<BaseError, Unit>> SessionMustBeInactive(StartFFmpegSession request)
+        {
+            var result = Optional(_ffmpegSegmenterService.SessionWorkers.TryAdd(request.ChannelNumber, null))
+                .Filter(success => success)
+                .Map(_ => Unit.Default)
+                .ToValidation<BaseError>(new ChannelSessionAlreadyActive());
+
+            if (result.IsFail && _ffmpegSegmenterService.SessionWorkers.TryGetValue(
+                request.ChannelNumber,
+                out IHlsSessionWorker worker))
+            {
+                worker?.Touch();
+            }
+
+            return result.AsTask();
+        }
+
+        private Task<Validation<BaseError, Unit>> FolderMustBeEmpty(StartFFmpegSession request)
+        {
+            string folder = Path.Combine(FileSystemLayout.TranscodeFolder, request.ChannelNumber);
+            _logger.LogDebug("Preparing transcode folder {Folder}", folder);
+
+            _localFileSystem.EnsureFolderExists(folder);
+            _localFileSystem.EmptyFolder(folder);
+
+            return Task.FromResult<Validation<BaseError, Unit>>(Unit.Default);
+        }
+    }
+}
--- a/ErsatzTV.Application/Streaming/Commands/TouchFFmpegSession.cs
+++ b/ErsatzTV.Application/Streaming/Commands/TouchFFmpegSession.cs
@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Streaming.Commands
+{
+    public record TouchFFmpegSession(string Path) : IRequest<Either<BaseError, Unit>>, IFFmpegWorkerRequest;
+}
--- a/ErsatzTV.Application/Streaming/HlsSessionWorker.cs
+++ b/ErsatzTV.Application/Streaming/HlsSessionWorker.cs
@@ -0,0 +1,243 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Timers;
+using ErsatzTV.Application.Streaming.Queries;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Timer = System.Timers.Timer;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Streaming
+{
+    public class HlsSessionWorker : IHlsSessionWorker
+    {
+        private static int _workAheadCount;
+        private readonly IServiceScopeFactory _serviceScopeFactory;
+        private readonly ILogger<HlsSessionWorker> _logger;
+        private DateTimeOffset _lastAccess;
+        private DateTimeOffset _transcodedUntil;
+        private Timer _timer;
+        private readonly object _sync = new();
+        private DateTimeOffset _playlistStart;
+
+        public HlsSessionWorker(IServiceScopeFactory serviceScopeFactory, ILogger<HlsSessionWorker> logger)
+        {
+            _serviceScopeFactory = serviceScopeFactory;
+            _logger = logger;
+        }
+
+        public DateTimeOffset PlaylistStart => _playlistStart;
+
+        public void Touch()
+        {
+            lock (_sync)
+            {
+                _lastAccess = DateTimeOffset.Now;
+
+                _timer?.Stop();
+                _timer?.Start();
+            }
+        }
+
+        public async Task Run(string channelNumber, TimeSpan idleTimeout)
+        {
+            var cts = new CancellationTokenSource();
+            void Cancel(object o, ElapsedEventArgs e) => cts.Cancel();
+
+            try
+            {
+                lock (_sync)
+                {
+                    _timer = new Timer(idleTimeout.TotalMilliseconds) { AutoReset = false };
+                    _timer.Elapsed += Cancel;
+                }
+
+                CancellationToken cancellationToken = cts.Token;
+
+                _logger.LogInformation("Starting HLS session for channel {Channel}", channelNumber);
+
+                Touch();
+                _transcodedUntil = DateTimeOffset.Now;
+                _playlistStart = _transcodedUntil;
+
+                bool initialWorkAhead = Volatile.Read(ref _workAheadCount) < await GetWorkAheadLimit();
+                if (!await Transcode(channelNumber, true, !initialWorkAhead, cancellationToken))
+                {
+                    return;
+                }
+
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    if (DateTimeOffset.Now - _lastAccess > idleTimeout)
+                    {
+                        _logger.LogInformation("Stopping idle HLS session for channel {Channel}", channelNumber);
+                        return;
+                    }
+
+                    var transcodedBuffer = TimeSpan.FromSeconds(
+                        Math.Max(0, _transcodedUntil.Subtract(DateTimeOffset.Now).TotalSeconds));
+                    if (transcodedBuffer <= TimeSpan.FromMinutes(1))
+                    {
+                        // only use realtime encoding when we're at least 30 seconds ahead
+                        bool realtime = transcodedBuffer >= TimeSpan.FromSeconds(30);
+                        bool subsequentWorkAhead =
+                            !realtime && Volatile.Read(ref _workAheadCount) < await GetWorkAheadLimit();
+                        if (!await Transcode(channelNumber, false, !subsequentWorkAhead, cancellationToken))
+                        {
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        await TrimAndDelete(channelNumber, cancellationToken);
+                        await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
+                    }
+                }
+            }
+            finally
+            {
+                lock (_sync)
+                {
+                    _timer.Elapsed -= Cancel;
+                }
+            }
+        }
+
+        private async Task<bool> Transcode(string channelNumber, bool firstProcess, bool realtime, CancellationToken cancellationToken)
+        {
+            try
+            {
+                if (!realtime)
+                {
+                    Interlocked.Increment(ref _workAheadCount);
+                    _logger.LogInformation("HLS segmenter will work ahead for channel {Channel}", channelNumber);
+                }
+                else
+                {
+                    _logger.LogInformation(
+                        "HLS segmenter will NOT work ahead for channel {Channel}",
+                        channelNumber);
+                }
+
+                using IServiceScope scope = _serviceScopeFactory.CreateScope();
+                IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+                var request = new GetPlayoutItemProcessByChannelNumber(
+                    channelNumber,
+                    "segmenter",
+                    firstProcess ? DateTimeOffset.Now : _transcodedUntil.AddSeconds(1),
+                    !firstProcess,
+                    realtime);
+
+                // _logger.LogInformation("Request {@Request}", request);
+
+                Either<BaseError, PlayoutItemProcessModel> result = await mediator.Send(request, cancellationToken);
+
+                // _logger.LogInformation("Result {Result}", result.ToString());
+
+                foreach (BaseError error in result.LeftAsEnumerable())
+                {
+                    _logger.LogWarning(
+                        "Failed to create process for HLS session on channel {Channel}: {Error}",
+                        channelNumber,
+                        error.ToString());
+
+                    return false;
+                }
+
+                foreach (PlayoutItemProcessModel processModel in result.RightAsEnumerable())
+                {
+                    await TrimAndDelete(channelNumber, cancellationToken);
+
+                    Process process = processModel.Process;
+
+                    _logger.LogDebug(
+                        "ffmpeg hls arguments {FFmpegArguments}",
+                        string.Join(" ", process.StartInfo.ArgumentList));
+
+                    process.Start();
+                    try
+                    {
+                        await process.WaitForExitAsync(cancellationToken);
+                        process.WaitForExit();
+                    }
+                    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);
+                return false;
+            }
+            finally
+            {
+                Interlocked.Decrement(ref _workAheadCount);
+            }
+
+            return true;
+        }
+        
+        private async Task TrimAndDelete(string channelNumber, CancellationToken cancellationToken)
+        {
+            string playlistFileName = Path.Combine(
+                FileSystemLayout.TranscodeFolder,
+                channelNumber,
+                "live.m3u8");
+
+            if (File.Exists(playlistFileName))
+            {
+                // trim playlist and insert discontinuity before appending with new ffmpeg process
+                string[] lines = await File.ReadAllLinesAsync(playlistFileName, cancellationToken);
+                TrimPlaylistResult trimResult = HlsPlaylistFilter.TrimPlaylistWithDiscontinuity(
+                    _playlistStart,
+                    DateTimeOffset.Now.AddMinutes(-1),
+                    lines);
+                await File.WriteAllTextAsync(playlistFileName, trimResult.Playlist, cancellationToken);
+
+                // delete old segments
+                foreach (string file in Directory.GetFiles(
+                    Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber),
+                    "*.ts"))
+                {
+                    string fileName = Path.GetFileName(file);
+                    if (fileName.StartsWith("live") && int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]) <
+                        trimResult.Sequence)
+                    {
+                        File.Delete(file);
+                    }
+                }
+
+                _playlistStart = trimResult.PlaylistStart;
+            }
+        }
+
+        private async Task<int> GetWorkAheadLimit()
+        {
+            using IServiceScope scope = _serviceScopeFactory.CreateScope();
+            IConfigElementRepository repo = scope.ServiceProvider.GetRequiredService<IConfigElementRepository>();
+            return await repo.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters)
+                .Map(maybeCount => maybeCount.Match(identity, () => 1));
+        }
+    }
+}
--- a/ErsatzTV.Application/Streaming/PlayoutItemProcessModel.cs
+++ b/ErsatzTV.Application/Streaming/PlayoutItemProcessModel.cs
@@ -0,0 +1,7 @@
+using System;
+using System.Diagnostics;
+
+namespace ErsatzTV.Application.Streaming
+{
+    public record PlayoutItemProcessModel(Process Process, DateTimeOffset Until);
+}
--- a/ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,7 +13,7 @@ using static LanguageExt.Prelude;

 namespace ErsatzTV.Application.Streaming.Queries
 {
-    public abstract class FFmpegProcessHandler<T> : IRequestHandler<T, Either<BaseError, Process>>
+    public abstract class FFmpegProcessHandler<T> : IRequestHandler<T, Either<BaseError, PlayoutItemProcessModel>>
        where T : FFmpegProcessRequest
    {
        private readonly IDbContextFactory<TvContext> _dbContextFactory;
@@ -22,16 +21,16 @@ namespace ErsatzTV.Application.Streaming.Queries
        protected FFmpegProcessHandler(IDbContextFactory<TvContext> dbContextFactory) =>
            _dbContextFactory = dbContextFactory;

-        public async Task<Either<BaseError, Process>> Handle(T request, CancellationToken cancellationToken)
+        public async Task<Either<BaseError, PlayoutItemProcessModel>> Handle(T request, CancellationToken cancellationToken)
        {
            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
            Validation<BaseError, Tuple<Channel, string>> validation = await Validate(dbContext, request);
            return await validation.Match(
                tuple => GetProcess(dbContext, request, tuple.Item1, tuple.Item2),
-                error => Task.FromResult<Either<BaseError, Process>>(error.Join()));
+                error => Task.FromResult<Either<BaseError, PlayoutItemProcessModel>>(error.Join()));
        }

-        protected abstract Task<Either<BaseError, Process>> GetProcess(
+        protected abstract Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
            TvContext dbContext,
            T request,
            Channel channel,
@@ -56,6 +55,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                        channel.StreamingMode = request.Mode.ToLowerInvariant() switch
                        {
                            "hls-direct" => StreamingMode.HttpLiveStreamingDirect,
+                            "segmenter" => StreamingMode.HttpLiveStreamingSegmenter,
                            "ts" => StreamingMode.TransportStream,
                            _ => channel.StreamingMode
                        };
--- a/ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs
+++ b/ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs
@@ -1,9 +1,15 @@
-using System.Diagnostics;
+using System;
 using ErsatzTV.Core;
 using LanguageExt;
 using MediatR;

 namespace ErsatzTV.Application.Streaming.Queries
 {
-    public record FFmpegProcessRequest(string ChannelNumber, string Mode) : IRequest<Either<BaseError, Process>>;
+    public record FFmpegProcessRequest
+    (
+        string ChannelNumber,
+        string Mode,
+        DateTimeOffset Now,
+        bool StartAtZero,
+        bool HlsRealtime) : IRequest<Either<BaseError, PlayoutItemProcessModel>>;
 }
--- a/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs
@@ -1,10 +1,15 @@
-namespace ErsatzTV.Application.Streaming.Queries
+using System;
+
+namespace ErsatzTV.Application.Streaming.Queries
 {
    public record GetConcatProcessByChannelNumber : FFmpegProcessRequest
    {
        public GetConcatProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
            channelNumber,
-            "ts")
+            "ts",
+            DateTimeOffset.Now,
+            false,
+            true)
        {
            Scheme = scheme;
            Host = host;
--- a/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs
@@ -1,4 +1,5 @@
-using System.Diagnostics;
+using System;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
@@ -27,7 +28,7 @@ namespace ErsatzTV.Application.Streaming.Queries
            _runtimeInfo = runtimeInfo;
        }

-        protected override async Task<Either<BaseError, Process>> GetProcess(
+        protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
            TvContext dbContext,
            GetConcatProcessByChannelNumber request,
            Channel channel,
@@ -37,12 +38,14 @@ namespace ErsatzTV.Application.Streaming.Queries
                .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
                .Map(result => result.IfNone(false));

-            return _ffmpegProcessService.ConcatChannel(
+            Process process = _ffmpegProcessService.ConcatChannel(
                ffmpegPath,
                saveReports,
                channel,
                request.Scheme,
                request.Host);
+
+            return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
        }
    }
 }
--- a/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumber.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumber.cs
@@ -1,8 +1,20 @@
-namespace ErsatzTV.Application.Streaming.Queries
+using System;
+
+namespace ErsatzTV.Application.Streaming.Queries
 {
    public record GetPlayoutItemProcessByChannelNumber : FFmpegProcessRequest
    {
-        public GetPlayoutItemProcessByChannelNumber(string channelNumber, string mode) : base(channelNumber, mode)
+        public GetPlayoutItemProcessByChannelNumber(
+            string channelNumber,
+            string mode,
+            DateTimeOffset now,
+            bool startAtZero,
+            bool hlsRealtime) : base(
+            channelNumber,
+            mode,
+            now,
+            startAtZero,
+            hlsRealtime)
        {
        }
    }
--- a/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs
@@ -48,13 +48,14 @@ namespace ErsatzTV.Application.Streaming.Queries
            _runtimeInfo = runtimeInfo;
        }

-        protected override async Task<Either<BaseError, Process>> GetProcess(
+        protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
            TvContext dbContext,
-            GetPlayoutItemProcessByChannelNumber _,
+            GetPlayoutItemProcessByChannelNumber request,
            Channel channel,
            string ffmpegPath)
        {
-            DateTimeOffset now = DateTimeOffset.Now;
+            DateTimeOffset now = request.Now;
+            
            Either<BaseError, PlayoutItemWithPath> maybePlayoutItem = await dbContext.PlayoutItems
                .Include(i => i.MediaItem)
                .ThenInclude(mi => (mi as Episode).MediaVersions)
@@ -74,6 +75,12 @@ namespace ErsatzTV.Application.Streaming.Queries
                .Include(i => i.MediaItem)
                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
                .ThenInclude(mv => mv.Streams)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+                .ThenInclude(ov => ov.MediaFiles)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+                .ThenInclude(ov => ov.Streams)
                .ForChannelAndTime(channel.Id, now)
                .Map(o => o.ToEither<BaseError>(new UnableToLocatePlayoutItem()))
                .BindT(ValidatePlayoutItemPath);
@@ -86,6 +93,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                        Movie m => m.MediaVersions.Head(),
                        Episode e => e.MediaVersions.Head(),
                        MusicVideo mv => mv.MediaVersions.Head(),
+                        OtherVideo ov => ov.MediaVersions.Head(),
                        _ => throw new ArgumentOutOfRangeException(nameof(playoutItemWithPath))
                    };

@@ -99,16 +107,22 @@ namespace ErsatzTV.Application.Streaming.Queries
                            watermarkId => dbContext.ChannelWatermarks
                                .SelectOneAsync(w => w.Id, w => w.Id == watermarkId));

-                    return Right<BaseError, Process>(
-                        await _ffmpegProcessService.ForPlayoutItem(
-                            ffmpegPath,
-                            saveReports,
-                            channel,
-                            version,
-                            playoutItemWithPath.Path,
-                            playoutItemWithPath.PlayoutItem.StartOffset,
-                            now,
-                            maybeGlobalWatermark));
+                    Process process = await _ffmpegProcessService.ForPlayoutItem(
+                        ffmpegPath,
+                        saveReports,
+                        channel,
+                        version,
+                        playoutItemWithPath.Path,
+                        playoutItemWithPath.PlayoutItem.StartOffset,
+                        request.StartAtZero ? playoutItemWithPath.PlayoutItem.StartOffset : now,
+                        maybeGlobalWatermark,
+                        channel.FFmpegProfile.VaapiDriver,
+                        channel.FFmpegProfile.VaapiDevice,
+                        request.HlsRealtime);
+
+                    var result = new PlayoutItemProcessModel(process, playoutItemWithPath.PlayoutItem.FinishOffset);
+
+                    return Right<BaseError, PlayoutItemProcessModel>(result);
                },
                async error =>
                {
@@ -127,16 +141,22 @@ namespace ErsatzTV.Application.Streaming.Queries
                                .MapT(pi => pi.StartOffset - now),
                            () => Option<TimeSpan>.None.AsTask());

+                    DateTimeOffset finish = maybeDuration.Match(d => now.Add(d), () => now);
+
                    switch (error)
                    {
                        case UnableToLocatePlayoutItem:
                            if (channel.FFmpegProfile.Transcode)
                            {
-                                return _ffmpegProcessService.ForError(
+                                Process errorProcess = _ffmpegProcessService.ForError(
                                    ffmpegPath,
                                    channel,
                                    maybeDuration,
-                                    "Channel is Offline");
+                                    "Channel is Offline",
+                                    request.HlsRealtime);
+
+
+                                return new PlayoutItemProcessModel(errorProcess, finish);
                            }
                            else
                            {
@@ -148,7 +168,14 @@ namespace ErsatzTV.Application.Streaming.Queries
                        case PlayoutItemDoesNotExistOnDisk:
                            if (channel.FFmpegProfile.Transcode)
                            {
-                                return _ffmpegProcessService.ForError(ffmpegPath, channel, maybeDuration, error.Value);
+                                Process errorProcess = _ffmpegProcessService.ForError(
+                                    ffmpegPath,
+                                    channel,
+                                    maybeDuration,
+                                    error.Value,
+                                    request.HlsRealtime);
+
+                                return new PlayoutItemProcessModel(errorProcess, finish);
                            }
                            else
                            {
@@ -160,11 +187,14 @@ namespace ErsatzTV.Application.Streaming.Queries
                        default:
                            if (channel.FFmpegProfile.Transcode)
                            {
-                                return _ffmpegProcessService.ForError(
+                                Process errorProcess = _ffmpegProcessService.ForError(
                                    ffmpegPath,
                                    channel,
                                    maybeDuration,
-                                    "Channel is Offline");
+                                    "Channel is Offline",
+                                    request.HlsRealtime);
+
+                                return new PlayoutItemProcessModel(errorProcess, finish);
                            }
                            else
                            {
@@ -196,6 +226,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                Movie m => m.MediaVersions.Head(),
                Episode e => e.MediaVersions.Head(),
                MusicVideo mv => mv.MediaVersions.Head(),
+                OtherVideo ov => ov.MediaVersions.Head(),
                _ => throw new ArgumentOutOfRangeException(nameof(playoutItem))
            };

--- a/ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj
+++ b/ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj
@@ -6,15 +6,11 @@
    </PropertyGroup>

    <ItemGroup>
-      <PackageReference Include="AsyncFixer" Version="1.5.1">
-        <PrivateAssets>all</PrivateAssets>
-        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      </PackageReference>
      <PackageReference Include="FluentAssertions" Version="6.1.0" />
      <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.10.56">
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.63">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      </PackageReference>
--- a/ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs
@@ -4,6 +4,7 @@ using ErsatzTV.Core.FFmpeg;
 using FluentAssertions;
 using LanguageExt;
 using NUnit.Framework;
+using static LanguageExt.Prelude;

 namespace ErsatzTV.Core.Tests.FFmpeg
 {
@@ -113,6 +114,161 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                    });
            }

+            [Test]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.BottomLeft,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=134:y=H-h-54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.BottomRight,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=W-w-134:y=H-h-54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.TopRight,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=W-w-134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                true,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:0][1:v]overlay=x=134:y=54:enable='lt(mod(mod(time(0),60*60),10*60),15)'[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                true,
+                100,
+                "[1:v]scale=384:-1[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                false,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                90,
+                "[1:v]format=yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8,colorchannelmixer=aa=0.90[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                true,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                false,
+                true,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                true,
+                100,
+                "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
+                "0:1",
+                "[v]")]
+            [TestCase(
+                true,
+                true,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:1]apad=whole_dur=3300000ms[a];[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
+                "[a]",
+                "[v]")]
+            [TestCase(
+                true,
+                false,
+                false,
+                ChannelWatermarkLocation.TopLeft,
+                false,
+                100,
+                "[0:1]apad=whole_dur=3300000ms[a];[0:0][1:v]overlay=x=134:y=54[v]",
+                "[a]",
+                "[v]")]
+            public void Should_Return_Watermark(
+                bool alignAudio,
+                bool deinterlace,
+                bool intermittent,
+                ChannelWatermarkLocation location,
+                bool scaled,
+                int opacity,
+                string expectedVideoFilter,
+                string expectedAudioLabel,
+                string expectedVideoLabel)
+            {
+                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                    .WithWatermark(
+                        Some(
+                            new ChannelWatermark
+                            {
+                                Mode = intermittent
+                                    ? ChannelWatermarkMode.Intermittent
+                                    : ChannelWatermarkMode.Permanent,
+                                DurationSeconds = intermittent ? 15 : 0,
+                                FrequencyMinutes = intermittent ? 10 : 0,
+                                Location = location,
+                                Size = scaled ? ChannelWatermarkSize.Scaled : ChannelWatermarkSize.ActualSize,
+                                WidthPercent = scaled ? 20 : 0,
+                                Opacity = opacity,
+                                HorizontalMarginPercent = 7,
+                                VerticalMarginPercent = 5
+                            }),
+                        new Resolution { Width = 1920, Height = 1080 })
+                    .WithDeinterlace(deinterlace)
+                    .WithAlignedAudio(alignAudio ? Some(TimeSpan.FromMinutes(55)) : None);
+
+                Option<FFmpegComplexFilter> result = builder.Build(0, 1);
+
+                result.IsSome.Should().BeTrue();
+                result.IfSome(
+                    filter =>
+                    {
+                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
+                        filter.AudioLabel.Should().Be(expectedAudioLabel);
+                        filter.VideoLabel.Should().Be(expectedVideoLabel);
+                    });
+            }
+
            [Test]
            [TestCase(true, false, false, "[0:0]deinterlace_qsv[v]", "[v]")]
            [TestCase(
@@ -185,43 +341,24 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            }

            [Test]
-            // TODO: get yadif_cuda working in docker
-            // [TestCase(true, false, false, "[0:V]yadif_cuda[v]", "[v]")]
-            // [TestCase(
-            //     true,
-            //     true,
-            //     false,
-            //     "[0:V]yadif_cuda,scale_npp=1920:1000:format=yuv420p,hwdownload,setsar=1,hwupload[v]",
-            //     "[v]")]
-            // [TestCase(
-            //     true,
-            //     false,
-            //     true,
-            //     "[0:V]yadif_cuda,hwdownload,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-            //     "[v]")]
-            // [TestCase(
-            //     true,
-            //     true,
-            //     true,
-            //     "[0:V]yadif_cuda,scale_npp=1920:1000:format=yuv420p,hwdownload,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-            //     "[v]")]
+            [TestCase(true, false, false, "[0:0]yadif_cuda[v]", "[v]")]
            [TestCase(
                true,
                true,
                false,
-                "[0:0]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
+                "[0:0]yadif_cuda,scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
                "[v]")]
            [TestCase(
                true,
                false,
                true,
-                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]yadif_cuda,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                "[v]")]
            [TestCase(
                true,
                true,
                true,
-                "[0:0]scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]yadif_cuda,scale_npp=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                "[v]")]
            [TestCase(
                false,
@@ -281,7 +418,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                true,
                true,
                false,
-                "[0:0]deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                "[v]")]
            [TestCase(
                "h264",
@@ -295,14 +432,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                true,
                true,
                true,
-                "[0:0]deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                "[v]")]
            [TestCase(
                "h264",
                false,
                true,
                false,
-                "[0:0]scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                "[v]")]
            [TestCase(
                "h264",
@@ -316,7 +453,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                false,
                true,
                true,
-                "[0:0]scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                "[v]")]
            [TestCase("mpeg4", true, false, false, "[0:0]hwupload,deinterlace_vaapi[v]", "[v]")]
            [TestCase(
@@ -324,7 +461,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                true,
                true,
                false,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                "[v]")]
            [TestCase(
                "mpeg4",
@@ -338,14 +475,14 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                true,
                true,
                true,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                "[v]")]
            [TestCase(
                "mpeg4",
                false,
                true,
                false,
-                "[0:0]hwupload,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                "[v]")]
            [TestCase(
                "mpeg4",
@@ -359,7 +496,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                false,
                true,
                true,
-                "[0:0]hwupload,scale_vaapi=w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                "[v]")]
            public void Should_Return_VAAPI_Video_Filter(
                string codec,
--- a/ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs
@@ -258,6 +258,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 }
                };
@@ -283,6 +284,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1280, Height = 720 }
                };
@@ -309,6 +311,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 }
                };
@@ -334,6 +337,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeVideo = false,
                    Resolution = new Resolution { Width = 1920, Height = 1080 }
                };
@@ -359,6 +363,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoCodec = "testCodec"
@@ -387,6 +392,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoCodec = "testCodec"
@@ -416,6 +422,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoCodec = "testCodec"
@@ -444,6 +451,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoCodec = "libx264"
@@ -473,6 +481,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = false,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoCodec = "libx264"
@@ -495,12 +504,47 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                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);
+
+                actual.ScaledSize.IsNone.Should().BeTrue();
+                actual.PadToDesiredResolution.Should().BeFalse();
+                actual.VideoCodec.Should().Be("copy");
+                actual.NormalizeLoudness.Should().BeFalse();
+                actual.AudioCodec.Should().Be("copy");
+            }

            [Test]
            public void Should_SetVideoBitrate_When_ContentIsPadded_ForTransportStream()
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoBitrate = 2525
@@ -528,6 +572,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoBitrate = 2525
@@ -556,6 +601,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoBufferSize = 2525
@@ -584,6 +630,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                var ffmpegProfile = new FFmpegProfile
                {
+                    Transcode = true,
                    NormalizeVideo = true,
                    Resolution = new Resolution { Width = 1920, Height = 1080 },
                    VideoBufferSize = 2525
@@ -612,6 +659,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioCodec = "aac"
                };
@@ -658,6 +706,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioCodec = "aac"
                };
@@ -681,6 +730,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioCodec = "aac"
                };
@@ -704,6 +754,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioBitrate = 2424,
                    AudioCodec = "ac3"
@@ -728,6 +779,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioBufferSize = 2424,
                    AudioCodec = "ac3"
@@ -752,6 +804,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioCodec = "ac3",
                    AudioChannels = 6
@@ -776,6 +829,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioCodec = "ac3",
                    AudioSampleRate = 48
@@ -800,6 +854,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioChannels = 6
                };
@@ -823,6 +878,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioSampleRate = 48
                };
@@ -846,6 +902,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    AudioSampleRate = 48,
                    AudioCodec = "ac3"
@@ -870,6 +927,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = true,
                    NormalizeLoudness = true
                };
@@ -893,6 +951,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
            {
                FFmpegProfile ffmpegProfile = TestProfile() with
                {
+                    Transcode = true,
                    NormalizeAudio = false,
                    NormalizeLoudness = true
                };
--- a/ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs
@@ -0,0 +1,223 @@
+using System;
+using ErsatzTV.Core.FFmpeg;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.FFmpeg
+{
+    [TestFixture]
+    public class HlsPlaylistFilterTests
+    {
+        [Test]
+        public void HlsPlaylistFilter_ShouldRewriteProgramDateTime()
+        {
+            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+            string[] input = @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:49.320-0500
+live001137.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:53.320-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
+live001139.ts".Split(Environment.NewLine);
+
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input);
+
+            result.PlaylistStart.Should().Be(start);
+            result.Sequence.Should().Be(1137);
+            result.Playlist.Should().Be(
+                @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-DISCONTINUITY-SEQUENCE:0
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:00.000-0500
+live001137.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:04.000-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
+live001139.ts
+");
+        }
+        
+        [Test]
+        public void HlsPlaylistFilter_ShouldLimitSegments()
+        {
+            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+            string[] input = @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:49.320-0500
+live001137.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:53.320-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
+live001139.ts".Split(Environment.NewLine);
+
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input, 2);
+
+            result.PlaylistStart.Should().Be(start);
+            result.Sequence.Should().Be(1137);
+            result.Playlist.Should().Be(
+                @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-DISCONTINUITY-SEQUENCE:0
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:00.000-0500
+live001137.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:04.000-0500
+live001138.ts
+");
+        }
+        
+        [Test]
+        public void HlsPlaylistFilter_ShouldAddDiscontinuity()
+        {
+            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+            string[] input = @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:49.320-0500
+live001137.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:53.320-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
+live001139.ts".Split(Environment.NewLine);
+
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(
+                start,
+                start.AddSeconds(-30),
+                input,
+                int.MaxValue,
+                true);
+
+            result.PlaylistStart.Should().Be(start);
+            result.Sequence.Should().Be(1137);
+            result.Playlist.Should().Be(
+                @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-DISCONTINUITY-SEQUENCE:0
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:00.000-0500
+live001137.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:04.000-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
+live001139.ts
+#EXT-X-DISCONTINUITY
+");
+        }
+
+        [Test]
+        public void HlsPlaylistFilter_ShouldFilterOldSegments()
+        {
+            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+            string[] input = @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:49.320-0500
+live001137.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:53.320-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
+live001139.ts".Split(Environment.NewLine);
+
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+
+            result.PlaylistStart.Should().Be(start.AddSeconds(8));
+            result.Sequence.Should().Be(1139);
+            result.Playlist.Should().Be(
+                @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1139
+#EXT-X-DISCONTINUITY-SEQUENCE:0
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
+live001139.ts
+");
+        }
+        
+        [Test]
+        public void HlsPlaylistFilter_ShouldFilterOldDiscontinuity()
+        {
+            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+            string[] input = @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:49.320-0500
+live001137.ts
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:53.320-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
+live001139.ts".Split(Environment.NewLine);
+
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+
+            result.PlaylistStart.Should().Be(start.AddSeconds(8));
+            result.Sequence.Should().Be(1139);
+            result.Playlist.Should().Be(
+                @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1139
+#EXT-X-DISCONTINUITY-SEQUENCE:1
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
+live001139.ts
+");
+        }
+    }
+}
--- a/ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs
@@ -0,0 +1,250 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.Images;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
+using FluentAssertions;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Core.Tests.FFmpeg
+{
+    [TestFixture]
+    [Explicit]
+    public class TranscodingTests
+    {
+        [Test]
+        [Explicit]
+        public void DeleteTestVideos()
+        {
+            foreach (string file in Directory.GetFiles(TestContext.CurrentContext.TestDirectory, "*.mkv"))
+            {
+                File.Delete(file);
+            }
+
+            Assert.Pass();
+        }
+
+        private class TestData
+        {
+            public static string[] InputCodecs =
+            {
+                "h264",
+                "mpeg2video",
+                "hevc",
+                "mpeg4"
+            };
+
+            public static string[] InputPixelFormats =
+            {
+                "yuv420p",
+                "yuv420p10le",
+                "yuvj420p",
+                "yuv444p",
+                "yuv444p10le"
+            };
+            
+            public static Resolution[] Resolutions =
+            {
+                new() { Width = 1920, Height = 1080 },
+                new() { Width = 1280, Height = 720 }
+            };
+
+            public static string[] SoftwareCodecs =
+            {
+                "libx264",
+                "libx265"
+            };
+
+            public static HardwareAccelerationKind[] NoAcceleration =
+            {
+                HardwareAccelerationKind.None
+            };
+
+            public static string[] NvidiaCodecs =
+            {
+                "h264_nvenc",
+                "hevc_nvenc"
+            };
+
+            public static HardwareAccelerationKind[] NvidiaAcceleration =
+            {
+                HardwareAccelerationKind.Nvenc
+            };
+
+            public static string[] VaapiCodecs =
+            {
+                "h264_vaapi",
+                "hevc_vaapi"
+            };
+
+            public static HardwareAccelerationKind[] VaapiAcceleration =
+            {
+                HardwareAccelerationKind.Vaapi
+            };
+        }
+
+        [Test, Combinatorial]
+        public async Task Transcode(
+            [ValueSource(typeof(TestData), nameof(TestData.InputCodecs))]
+            string inputCodec,
+            [ValueSource(typeof(TestData), nameof(TestData.InputPixelFormats))]
+            string inputPixelFormat,
+            [ValueSource(typeof(TestData), nameof(TestData.Resolutions))]
+            Resolution profileResolution,
+            // [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.VaapiAcceleration))] HardwareAccelerationKind profileAcceleration)
+        {
+            string name = GetStringSha256Hash(
+                $"{inputCodec}_{inputPixelFormat}_{profileResolution}_{profileCodec}_{profileAcceleration}");
+
+            string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
+            if (!File.Exists(file))
+            {
+                var args =
+                    $"-y -f lavfi -i anullsrc=channel_layout=stereo:sample_rate=44100 -f lavfi -i testsrc=duration=1:size=1920x1080:rate=30 -c:a aac -c:v {inputCodec} -shortest -pix_fmt {inputPixelFormat} -strict -2 {file}";
+                var p1 = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = "ffmpeg",
+                        Arguments = args
+                    }
+                };
+
+                p1.Start();
+                await p1.WaitForExitAsync();
+                // ReSharper disable once MethodHasAsyncOverload
+                p1.WaitForExit();
+                p1.ExitCode.Should().Be(0);
+            }
+
+            var service = new FFmpegProcessService(
+                new FFmpegPlaybackSettingsCalculator(),
+                new FakeStreamSelector(),
+                new Mock<IImageCache>().Object,
+                new Mock<ILogger<FFmpegProcessService>>().Object);
+
+            MediaVersion v = new MediaVersion();
+
+            var metadataRepository = new Mock<IMetadataRepository>();
+            metadataRepository
+                .Setup(r => r.UpdateLocalStatistics(It.IsAny<int>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
+                .Callback<int, MediaVersion, bool>((_, version, _) => v = version);
+
+            var localStatisticsProvider = new LocalStatisticsProvider(
+                metadataRepository.Object,
+                new LocalFileSystem(new Mock<ILogger<LocalFileSystem>>().Object),
+                new Mock<ILogger<LocalStatisticsProvider>>().Object);
+
+            await localStatisticsProvider.RefreshStatistics(
+                "ffprobe",
+                new Movie
+                {
+                    MediaVersions = new List<MediaVersion>
+                    {
+                        new()
+                        {
+                            MediaFiles = new List<MediaFile>
+                            {
+                                new() { Path = file }
+                            }
+                        }
+                    }
+                });
+
+            DateTimeOffset now = DateTimeOffset.Now;
+
+            Process process = await service.ForPlayoutItem(
+                "ffmpeg",
+                false,
+                new Channel(Guid.NewGuid())
+                {
+                    FFmpegProfile = FFmpegProfile.New("test", profileResolution) with
+                    {
+                        HardwareAcceleration = profileAcceleration,
+                        VideoCodec = profileCodec
+                    },
+                    StreamingMode = StreamingMode.TransportStream
+                },
+                v,
+                file,
+                now,
+                now,
+                None,
+                VaapiDriver.Default,
+                "/dev/dri/renderD128",
+                false);
+
+            process.StartInfo.RedirectStandardError = true;
+
+            process.Start().Should().BeTrue();
+
+            process.BeginOutputReadLine();
+            string error = await process.StandardError.ReadToEndAsync();
+            await process.WaitForExitAsync();
+            // ReSharper disable once MethodHasAsyncOverload
+            process.WaitForExit();
+
+            string[] unsupportedMessages =
+            {
+                "No support for codec",
+                "No usable",
+                "Provided device doesn't support"
+            };
+            
+            if (profileAcceleration != HardwareAccelerationKind.None && unsupportedMessages.Any(error.Contains))
+            {
+                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)}");
+            }
+            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)}");
+            }
+            else
+            {
+                IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
+                process.ExitCode.Should().Be(0, error + Environment.NewLine + string.Join(" ", quotedArgs));
+            }
+        }
+        
+        private static string GetStringSha256Hash(string text)
+        {
+            if (string.IsNullOrEmpty(text))
+            {
+                return string.Empty;
+            }
+
+            using var sha = new System.Security.Cryptography.SHA256Managed();
+            byte[] textData = System.Text.Encoding.UTF8.GetBytes(text);
+            byte[] hash = sha.ComputeHash(textData);
+            return BitConverter.ToString(hash).Replace("-", string.Empty);
+        }
+
+        private class FakeStreamSelector : IFFmpegStreamSelector
+        {
+            public Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version) =>
+                version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Video).AsTask();
+
+            public Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version) =>
+                Optional(version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Audio)).AsTask();
+        }
+    }
+}
--- a/ErsatzTV.Core.Tests/Fakes/FakeFileEntry.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeFileEntry.cs
@@ -4,6 +4,6 @@ namespace ErsatzTV.Core.Tests.Fakes
 {
    public record FakeFileEntry(string Path)
    {
-        public DateTime LastWriteTime { get; set; } = DateTime.MinValue;
+        public DateTime LastWriteTime { get; set; } = SystemTime.MinValueUtc;
    }
 }
--- a/ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs
@@ -41,7 +41,7 @@ namespace ErsatzTV.Core.Tests.Fakes
        public DateTime GetLastWriteTime(string path) =>
            Optional(_files.SingleOrDefault(f => f.Path == path))
                .Map(f => f.LastWriteTime)
-                .IfNone(DateTime.MinValue);
+                .IfNone(SystemTime.MinValueUtc);

        public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
            _files.Any(f => f.Path.StartsWith(libraryPath.Path + Path.DirectorySeparatorChar));
@@ -59,6 +59,8 @@ namespace ErsatzTV.Core.Tests.Fakes
        public Task<Either<BaseError, Unit>> CopyFile(string source, string destination) =>
            Task.FromResult(Right<BaseError, Unit>(Unit.Default));

+        public Unit EmptyFolder(string folder) => Unit.Default;
+
        private static List<DirectoryInfo> Split(DirectoryInfo path)
        {
            var result = new List<DirectoryInfo>();
--- a/ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs
@@ -11,6 +11,8 @@ namespace ErsatzTV.Core.Tests.Fakes
    public class FakeTelevisionRepository : ITelevisionRepository
    {
        public Task<bool> AllShowsExist(List<int> showIds) => throw new NotSupportedException();
+        public Task<bool> AllSeasonsExist(List<int> seasonIds) => throw new NotSupportedException();
+
        public Task<bool> AllEpisodesExist(List<int> episodeIds) => throw new NotSupportedException();

        public Task<List<Show>> GetAllShows() => throw new NotSupportedException();
@@ -18,6 +20,8 @@ namespace ErsatzTV.Core.Tests.Fakes
        public Task<Option<Show>> GetShow(int showId) => throw new NotSupportedException();

        public Task<List<ShowMetadata>> GetShowsForCards(List<int> ids) => throw new NotSupportedException();
+        public Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids) => throw new NotSupportedException();
+
        public Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids) => throw new NotSupportedException();

        public Task<List<Episode>> GetShowItems(int showId) => throw new NotSupportedException();
@@ -33,8 +37,6 @@ namespace ErsatzTV.Core.Tests.Fakes

        public Task<List<Episode>> GetSeasonItems(int seasonId) => throw new NotSupportedException();

-        public Task<Option<Episode>> GetEpisode(int episodeId) => throw new NotSupportedException();
-
        public Task<int> GetEpisodeCount(int seasonId) => throw new NotSupportedException();

        public Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize) =>
@@ -95,5 +97,6 @@ namespace ErsatzTV.Core.Tests.Fakes
        public Task<bool> AddDirector(EpisodeMetadata metadata, Director director) => throw new NotSupportedException();

        public Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer) => throw new NotSupportedException();
+        public Task<Unit> UpdatePath(int mediaFileId, string path) => throw new NotSupportedException();
    }
 }
--- a/ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs
@@ -709,7 +709,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
                    CollectionId = fixedCollection.Id,
                    StartTime = TimeSpan.FromHours(2),
                    PlayoutDuration = TimeSpan.FromHours(2),
-                    OfflineTail = false, // immediately continue
+                    TailMode = TailMode.None, // immediately continue
                    PlaybackOrder = PlaybackOrder.Chronological
                }
            };
@@ -807,7 +807,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
                    CollectionId = dynamicCollection.Id,
                    StartTime = null,
                    PlayoutDuration = TimeSpan.FromHours(2),
-                    OfflineTail = false, // immediately continue
+                    TailMode = TailMode.None, // immediately continue
                    PlaybackOrder = PlaybackOrder.Chronological
                }
            };
@@ -1089,7 +1089,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
                    CollectionId = collectionOne.Id,
                    StartTime = null,
                    PlayoutDuration = TimeSpan.FromHours(3),
-                    OfflineTail = false,
+                    TailMode = TailMode.None,
                    PlaybackOrder = PlaybackOrder.Chronological
                },
                new ProgramScheduleItemDuration
@@ -1100,7 +1100,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
                    CollectionId = collectionTwo.Id,
                    StartTime = null,
                    PlayoutDuration = TimeSpan.FromHours(3),
-                    OfflineTail = false,
+                    TailMode = TailMode.None,
                    PlaybackOrder = PlaybackOrder.Chronological
                }
            };
--- a/ErsatzTV.Core/Domain/ChannelWatermark.cs
+++ b/ErsatzTV.Core/Domain/ChannelWatermark.cs
@@ -22,7 +22,11 @@
        BottomRight = 0,
        BottomLeft = 1,
        TopRight = 2,
-        TopLeft = 3
+        TopLeft = 3,
+        TopMiddle = 4,
+        RightMiddle = 5,
+        BottomMiddle = 6,
+        LeftMiddle = 7
    }

    public enum ChannelWatermarkSize
--- a/ErsatzTV.Core/Domain/Collection/TraktList.cs
+++ b/ErsatzTV.Core/Domain/Collection/TraktList.cs
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class TraktList
+    {
+        public int Id { get; set; }
+        public int TraktId { get; set; }
+        public string User { get; set; }
+        public string List { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public int ItemCount { get; set; }
+        public List<TraktListItem> Items { get; set; }
+    }
+}
--- a/ErsatzTV.Core/Domain/Collection/TraktListItem.cs
+++ b/ErsatzTV.Core/Domain/Collection/TraktListItem.cs
@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Core.Domain
+{
+    public class TraktListItem
+    {
+        public int Id { get; set; }
+        public int TraktListId { get; set; }
+        public TraktList TraktList { get; set; }
+
+        public TraktListItemKind Kind { get; set; }
+        public int TraktId { get; set; }
+        public int Rank { get; set; }
+        public string Title { get; set; }
+        public int? Year { get; set; }
+        public int? Season { get; set; }
+        public int? Episode { get; set; }
+        public List<TraktListItemGuid> Guids { get; set; }
+
+        public int? MediaItemId { get; set; }
+        public MediaItem MediaItem { get; set; }
+
+        public string DisplayTitle => Kind switch
+        {
+            TraktListItemKind.Movie => $"{Title} ({Year})",
+            TraktListItemKind.Show => $"{Title} ({Year})",
+            TraktListItemKind.Season => $"{Title} ({Year}) S{Season:00}",
+            _ => $"{Title} ({Year}) S{Season:00}E{Episode:00}"
+        };
+    }
+}
--- a/ErsatzTV.Core/Domain/Collection/TraktListItemGuid.cs
+++ b/ErsatzTV.Core/Domain/Collection/TraktListItemGuid.cs
@@ -0,0 +1,10 @@
+namespace ErsatzTV.Core.Domain
+{
+    public class TraktListItemGuid
+    {
+        public int Id { get; set; }
+        public string Guid { get; set; }
+        public int TraktListItemId { get; set; }
+        public TraktListItem TraktListItem { get; set; }
+    }
+}
--- a/ErsatzTV.Core/Domain/Collection/TraktListItemKind.cs
+++ b/ErsatzTV.Core/Domain/Collection/TraktListItemKind.cs
@@ -0,0 +1,10 @@
+namespace ErsatzTV.Core.Domain
+{
+    public enum TraktListItemKind
+    {
+        Movie,
+        Show,
+        Season,
+        Episode
+    }
+}
--- a/ErsatzTV.Core/Domain/ConfigElementKey.cs
+++ b/ErsatzTV.Core/Domain/ConfigElementKey.cs
@@ -13,6 +13,8 @@
        public static ConfigElementKey FFmpegSaveReports => new("ffmpeg.save_reports");
        public static ConfigElementKey FFmpegPreferredLanguageCode => new("ffmpeg.preferred_language_code");
        public static ConfigElementKey FFmpegGlobalWatermarkId => new("ffmpeg.global_watermark_id");
+        public static ConfigElementKey FFmpegSegmenterTimeout => new("ffmpeg.segmenter.timeout_seconds");
+        public static ConfigElementKey FFmpegWorkAheadSegmenters => new("ffmpeg.segmenter.work_ahead_limit");
        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");
@@ -24,6 +26,7 @@
        public static ConfigElementKey PlayoutsPageSize => new("pages.playouts.page_size");
        public static ConfigElementKey PlayoutsDetailPageSize => new("pages.playouts.detail_page_size");
        public static ConfigElementKey LogsPageSize => new("pages.logs.page_size");
+        public static ConfigElementKey TraktListsPageSize => new("pages.trakt.lists_page_size");
        public static ConfigElementKey LibraryRefreshInterval => new("scanner.library_refresh_interval");
        public static ConfigElementKey PlayoutDaysToBuild => new("playout.days_to_build");
    }
--- a/ErsatzTV.Core/Domain/FFmpegProfile.cs
+++ b/ErsatzTV.Core/Domain/FFmpegProfile.cs
@@ -1,4 +1,6 @@
-namespace ErsatzTV.Core.Domain
+using ErsatzTV.Core.FFmpeg;
+
+namespace ErsatzTV.Core.Domain
 {
    public record FFmpegProfile
    {
@@ -7,6 +9,8 @@
        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; }
@@ -39,7 +43,8 @@
                AudioChannels = 2,
                AudioSampleRate = 48,
                NormalizeVideo = true,
-                NormalizeAudio = true
+                NormalizeAudio = true,
+                HardwareAcceleration = HardwareAccelerationKind.None
            };
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jason Dove	1802f9d797	fix database migration (#436 )	2021-10-15 11:31:40 -05:00
Jason Dove	69354c9296	fix double scheduling (#435 )	2021-10-15 09:14:53 -05:00
Jason Dove	0021e21b50	fix other video playback	2021-10-14 22:53:32 -05:00
Jason Dove	cdf7765059	update changelog for release v0.1.4-alpha [no ci]	2021-10-14 15:00:24 -05:00
Jason Dove	71658c448f	update docs (#431 )	2021-10-14 14:41:12 -05:00
Jason Dove	3ecdd741a5	add guide mode to schedule items (#430 )	2021-10-14 13:24:54 -05:00
Jason Dove	0daeb844b9	add other videos library kind (#429 )	2021-10-14 12:58:37 -05:00
Jason Dove	22da19845b	add filler option to duration playout mode (#428 ) * add duration tail options to schedule items editor * add naive filler scheduling * fix duration item length in xmltv * show offline image for unfilled duration tail * fix tests * update changelog * update dependencies	2021-10-13 21:15:16 -05:00
Jason Dove	3a6d9e9f39	update changelog for release v0.1.3-alpha [no ci]	2021-10-13 15:17:23 -05:00
Jason Dove	7ed4b8ae3c	fix startup bug (#426 )	2021-10-13 13:30:26 -05:00
Jason Dove	be7311e620	update changelog for release v0.1.2-alpha [no ci]	2021-10-12 19:00:30 -05:00
Jason Dove	03be372070	update changelog [no ci]	2021-10-12 18:57:02 -05:00
Jason Dove	d196308ee9	fix ffmpeg profile editing (#421 )	2021-10-12 18:39:51 -05:00
Jason Dove	3d68b0f055	fix vaapi migration	2021-10-12 18:22:09 -05:00
Jason Dove	37e32f06ad	update changelog [no ci]	2021-10-12 17:56:56 -05:00
Jason Dove	c43ca2837d	support radeon vaapi acceleration (#420 )	2021-10-12 17:51:55 -05:00
Jason Dove	992121f308	add more watermark locations (#419 )	2021-10-12 07:19:52 -05:00
Jason Dove	04adbfeffa	add hls segmenter settings to optimize performance (#418 ) * add hls segmenter settings to optimize performance * use consistent setting defaults	2021-10-12 06:31:11 -05:00
Jason Dove	1fc905c6ad	upgrade vaapi to ffmpeg 4.4 (#417 )	2021-10-11 22:26:32 -05:00
Jason Dove	4b5dff2159	ffnvcodec fixes (#416 )	2021-10-11 22:14:43 -05:00
Jason Dove	2a5edf8214	ffmpeg 4.4 llvm nvidia fixes (#415 )	2021-10-11 21:31:59 -05:00
Jason Dove	69912c8cae	support ffmpeg 4.4 (#414 ) * support ffmpeg 4.4 * update changelog	2021-10-11 20:16:15 -05:00
Jason Dove	fd3de2d82a	nvidia 10 bit fixes (#413 )	2021-10-11 16:00:35 -05:00
Jason Dove	6ba9404752	nvidia transcoding improvements (#412 ) * nvidia transcoding fixes * use yadif_cuda to deinterlace	2021-10-10 22:40:43 -05:00
Jason Dove	db080375c5	update changelog for release v0.1.1-alpha [no ci]	2021-10-10 12:54:46 -05:00
Jason Dove	9abc7ad8b7	try to fix tests on windows	2021-10-10 12:39:08 -05:00
Jason Dove	9e531a82d7	add some hls playlist filter tests (#411 )	2021-10-10 12:33:02 -05:00
Jason Dove	d84bd2b948	upgrade nvidia docker image (#410 )	2021-10-10 11:45:02 -05:00
Jason Dove	d7d3ec1235	add music video album to search index (#409 ) * add music video album to search index * update search docs	2021-10-10 10:28:35 -05:00
Jason Dove	742ac21ad7	update collection docs [no docker]	2021-10-10 07:53:29 -05:00
Jason Dove	819b55e21f	increase max hls segments (#408 )	2021-10-10 06:47:24 -05:00
Jason Dove	cf5718c288	rework hls segmenter (#407 ) * rework hls segmenter to start more quickly * don't use realtime encoding for hls until we're at least a minute ahead * ugly but functional playlist filtering	2021-10-09 22:46:38 -05:00
Jason Dove	adc7982955	reduce initial hls segmenter delay (#406 )	2021-10-09 10:26:57 -05:00
Jason Dove	67a6f554d0	rename v0.0.63-alpha v0.1.0-alpha [no ci]	2021-10-08 18:44:49 -05:00
Jason Dove	609df217ae	update changelog for release 63 [no ci]	2021-10-08 18:39:03 -05:00
Jason Dove	d3086264c7	unraid doc fixes (#405 )	2021-10-08 18:31:22 -05:00
Jason Dove	8cd9b23787	fix transcode folder preparation (#404 )	2021-10-08 15:29:19 -05:00
dependabot[bot]	dc5c9e42ff	Bump Serilog.Settings.Configuration from 3.2.0 to 3.3.0 (#403 ) Bumps [Serilog.Settings.Configuration](https://github.com/serilog/serilog-settings-configuration) from 3.2.0 to 3.3.0. - [Release notes](https://github.com/serilog/serilog-settings-configuration/releases) - [Changelog](https://github.com/serilog/serilog-settings-configuration/blob/dev/CHANGES.md) - [Commits](https://github.com/serilog/serilog-settings-configuration/commits) --- updated-dependencies: - dependency-name: Serilog.Settings.Configuration dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-10-08 09:09:57 -05:00
Jason Dove	2dd267e4db	fix xmltv generation with missing episode metadata (#402 )	2021-10-07 22:31:46 -05:00
Jason Dove	b069a21473	allow hls segmenter to run before framerate is known (#401 )	2021-10-07 22:07:54 -05:00
Jason Dove	6c8813ce22	add hls segmenter streaming mode (#400 ) * hls segmenter wip * log message * close unused transcode sessions after 2 minutes * use frame rate for 2s keyframes in hls segmenter * add frame rate to media version * fix segmenter framerate calculation * automatically restart hls segmenter with next scheduled item * cleanup * update changelog * decrease segmenter start delay	2021-10-07 21:42:29 -05:00
Jason Dove	b5de5e2b7f	fix statistic updates (#399 )	2021-10-07 19:56:41 -05:00
Jason Dove	4b7da4e468	speed up builds by using base images (#398 )	2021-10-06 06:06:13 -05:00
Jason Dove	ae8e795228	vaapi downsample 10bit hevc 8bit h264 (#397 ) * vaapi downsample 10bit hevc to 8bit h264 * update changelog	2021-10-05 22:16:57 -05:00
Jason Dove	334781485d	use latest intel driver in vaapi docker images (#396 ) * compile latest iHD driver * cleanup to reduce image size * update changelog	2021-10-05 20:24:26 -05:00
Jason Dove	27fefa1b38	update changelog for release 62 [no ci]	2021-10-05 15:28:45 -05:00
Jason Dove	fc3175591e	use libx264 for all errors (#395 )	2021-10-05 15:13:35 -05:00
Jason Dove	3363d2c9d7	update plex paths when they are changed (#394 )	2021-10-05 06:27:05 -05:00
Jason Dove	1d5217fa84	support imdb ids from plex (#393 )	2021-10-05 06:01:53 -05:00
Jason Dove	904cdb8780	vaapi improvements (#392 ) * add transcoding tests * dont use full paths for transcoding tests * add error details * use 1-second videos for transcoding tests * vaapi fixes * include format in scale_vaapi * more vaapi fixes * unsupported errors * fix unsupported checks * maybe not failure? * fix formatting * ignore nvdec warnings * update changelog * fix tests	2021-10-02 13:42:44 -05:00
Jason Dove	85fee64565	update changelog [no ci]	2021-10-01 13:44:04 -05:00
Jason Dove	13cfb9728f	include season zero episode-num in xmltv (#391 )	2021-10-01 13:42:46 -05:00
Jason Dove	60b82876ea	mudblazor updates (#390 )	2021-09-30 17:40:26 -05:00
Jason Dove	a99249c375	revert nvenc changes (#389 )	2021-09-30 17:35:44 -05:00
Jason Dove	36e6ef4c18	update changelog for release 60	2021-09-25 15:12:47 -05:00
Jason Dove	21e53532c1	trakt season bug fixes (#386 )	2021-09-25 14:55:42 -05:00
Jason Dove	a864d53327	add seasons to search index (#385 ) * update trakt list items when re-adding existing list * add seasons to search index	2021-09-25 14:01:35 -05:00
Jason Dove	e6446f9983	better trakt lists (#384 ) * better trakt list support * update dependencies * revert unneeded brackets	2021-09-25 09:12:25 -05:00
Jason Dove	ad40213f90	fix synchronizing trakt lists that contain unreleased movies (#382 )	2021-09-21 21:14:27 -05:00
Jason Dove	45c6d20fd0	sync trakt list to collection (#381 ) * sync trakt list to collection * move trakt client id	2021-09-20 18:46:03 -05:00
Jason Dove	5439db89a7	nvidia fixes (#380 ) * nvidia fixes * fix tests	2021-09-19 21:39:36 -05:00
Jason Dove	a39231bb5a	fix local episode metadata update (#379 )	2021-09-19 20:57:12 -05:00
Jason Dove	4c8584b517	try to fix develop versioning	2021-09-18 18:08:19 -05:00
Jason Dove	ca8bcacbd3	update changelog for release 59 [no ci]	2021-09-18 14:35:01 -05:00
Jason Dove	f27286d1dd	properly disable transcoding when unchecked in mpeg-ts mode (#378 ) * properly disable transcoding in MPEG-TS mode * update changelog	2021-09-18 14:21:49 -05:00
Jason Dove	23870b75f7	update changelog [no ci]	2021-09-18 14:02:49 -05:00
Jason Dove	7f5a91c643	include libva-x11-2 in vaapi docker image	2021-09-18 13:25:01 -05:00
Jason Dove	f1f50e883c	add vaapi driver setting and health check (#377 ) * add vaapi driver option * add vaapi driver setting and health check	2021-09-18 13:00:36 -05:00
Jason Dove	7506f49f5b	remove codeql [no docker]	2021-09-18 11:30:16 -05:00
Jason Dove	944f1e4307	add scheduled playout rebuild (#376 ) * configure scheduled playout rebuild * implement scheduled playout rebuild * remove variable	2021-09-18 11:23:58 -05:00
Jason Dove	f7de9ac5ea	include intel-media-va-driver-non-free in vaapi image (#375 ) * include intel-media-va-driver-non-free in vaapi image * tweak changelog	2021-09-17 21:13:27 -05:00
Jason Dove	1eb51ad2f4	add some health checks to home page (#374 )	2021-09-17 17:59:59 -05:00
Jason Dove	c3e0aaf0b7	missing metadata fixes (#373 )	2021-09-17 08:53:41 -05:00
Jason Dove	b9912b47df	update changelog for release 58 [no ci]	2021-09-15 21:53:34 -05:00
Jason Dove	55fb2624e7	add multi-part grouping tooltip (#371 )	2021-09-15 21:18:41 -05:00
Jason Dove	8ced20dc39	dont offset collections during shuffle in order (#370 )	2021-09-15 20:54:32 -05:00
Jason Dove	e718cb0faf	fix building playouts in timezones with positive offsets (#368 )	2021-09-15 09:07:35 -05:00
Jason Dove	e218ff9a6d	fix watermark when no video filters are required (#367 )	2021-09-15 05:12:23 -05:00
Jason Dove	c2a49cbaea	update dependencies (#365 )	2021-09-14 18:10:59 -05:00
Jason Dove	17e74f7314	add more release date search options (#362 )	2021-09-12 18:32:38 -05:00
Long-Man	2032bb4777	Update search.md (#361 ) Add release_date and released_nointhelast to music video search	2021-09-12 12:18:07 -05:00