prep for release v26.3.0 [no ci]

* output progress/speed even when copying video

* nvidia - decode 10-bit h264 in software

* fixes

* fix tests

.config/dotnet-tools.json

@@ -3,11 +3,11 @@
   "isRoot": true,
   "tools": {
     "jetbrains.resharper.globaltools": {
-      "version": "2025.2.1",
+      "version": "2025.3.0.2",
       "commands": [
         "jb"
       ],
       "rollForward": false
     }
   }
-}
+}

.github/ISSUE_TEMPLATE/config.yml

@@ -3,9 +3,9 @@ contact_links:
   - name: Feature Requests
     url: https://features.ersatztv.org
     about: Features
-  - name: Discord
-    url: https://discord.ersatztv.org
-    about: Chat
+  - name: Contact
+    url: https://ersatztv.org/contact
+    about: Chat Options
   - name: Community
     url: https://discuss.ersatztv.org
     about: Forum

.github/ISSUE_TEMPLATE/issue.yml

@@ -12,7 +12,7 @@ body:
       label: "This issue respects the following points:"
       description: All conditions are **required**. Failure to comply with any of these conditions may cause your issue to be closed without comment.
       options:
-        - label: This is a **bug**, not a question or a configuration issue; Please visit our [forum](https://discuss.ersatztv.org) or [chat](https://discord.ersatztv.org) first to troubleshoot with volunteers before creating a report.
+        - label: This is a **bug**, not a question or a configuration issue; Please visit our [forum](https://discuss.ersatztv.org) or [chat](https://ersatztv.org/contact) first to troubleshoot with volunteers before creating a report.
           required: true
         - label: This issue is **not** already reported on [GitHub](https://github.com/ErsatzTV/ErsatzTV/issues?q=is%3Aopen+is%3Aissue) _(I've searched it)_.
           required: true
@@ -31,11 +31,20 @@ body:
   - type: textarea
     id: repro-steps
     attributes:
-      label: Steps to reproduce the problem
+      label: Steps to reproduce the problem.
       description: |
         1. Step 1
         2. Step 2
         3. Step 3
+
+        If this is a playback issue, follow these steps and post the resulting zip:
+          1. Search for the required content using the search bar.
+          2. Use the overflow/three dots menu on the content and select Troubleshoot Playback.
+          3. Select the appropriate Playback Settings that trigger the undesired behavior.
+          4. Click Play to start playback.
+          5. Repeat steps 3 and 4 until the undesired behavior is reproduced.
+          6. Click Download Results to have ErsatzTV collect relevant troubleshooting logs (ffmpeg log, ffmpeg profile, hardware capabilities, media info, etc) and compress them in a zip file.
+          7. Attach the zip to this field.
     validations:
       required: true
   - type: textarea

.github/workflows/artifacts.yml

@@ -25,6 +25,15 @@ on:
         required: true
       gh_token:
         required: true
+      azure_client_id:
+        required: true
+      azure_tenant_id:
+        required: true
+      azure_subscription_id:
+        required: true
+permissions:
+  id-token: write
+  contents: write
 jobs:
   build_and_upload_mac:
     name: Mac Build & Upload
@@ -48,7 +57,7 @@ jobs:
       - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.203
+          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -72,8 +81,8 @@ jobs:
         shell: bash
         run: |
           sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
 
       - name: Bundle
         shell: bash
@@ -163,7 +172,7 @@ jobs:
       - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.203
+          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -180,8 +189,8 @@ jobs:
 
           # Build everything
           sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net9.0 --runtime "${{ matrix.target }}" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
           mkdir "$release_name"
           mv scanner/* "$release_name/"
           mv main/* "$release_name/"
@@ -220,7 +229,7 @@ jobs:
       - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.203
+          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -232,8 +241,8 @@ jobs:
         shell: bash
         run: |
           sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net9.0 --runtime "win-x64" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net9.0 --runtime "win-x64" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "win-x64" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "win-x64" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
 
       - name: Upload .NET Artifact
         uses: actions/upload-artifact@v4
@@ -244,28 +253,10 @@ jobs:
             main/
           retention-days: 1
 
-  build_rust_windows:
-    name: Build rust for Windows
-    runs-on: windows-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-
-      - name: Build Windows Launcher
-        shell: bash
-        run: cargo build --manifest-path=ErsatzTV-Windows/Cargo.toml --release --all-features
-
-      - name: Upload Rust Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: rust-windows-build
-          path: ErsatzTV-Windows/target/release/ersatztv_windows.exe
-          retention-days: 1
-
   package_and_upload_windows:
     name: Package & Upload Windows
-    runs-on: ubuntu-latest
-    needs: [build_dotnet_windows, build_rust_windows]
+    runs-on: windows-latest
+    needs: build_dotnet_windows
     steps:
       - name: Download dotnet artifacts
         uses: actions/download-artifact@v4
@@ -273,11 +264,32 @@ jobs:
           name: dotnet-windows-build
           path: dotnet-build
 
-      - name: Download rust artifacts
-        uses: actions/download-artifact@v4
+      - name: Azure login
+        uses: azure/login@v2
         with:
-          name: rust-windows-build
-          path: rust-build
+          client-id: ${{ secrets.azure_client_id }}
+          tenant-id: ${{ secrets.azure_tenant_id }}
+          subscription-id: ${{ secrets.azure_subscription_id }}
+          enable-AzPSSession: true
+
+      - name: Sign dotnet artifacts
+        uses: azure/trusted-signing-action@v0
+        with:
+          endpoint: https://eus.codesigning.azure.net/
+          trusted-signing-account-name: ArtifactSigning
+          certificate-profile-name: ErsatzTV
+          files-folder: ${{ github.workspace }}/dotnet-build
+          files-folder-recurse: true
+          files-folder-filter: ErsatzTV.exe,ErsatzTV.Scanner.exe
+          file-digest: SHA256
+          timestamp-rfc3161: http://timestamp.acs.microsoft.com
+          timestamp-digest: SHA256
+
+      - name: Download rust launcher
+        uses: suisei-cn/actions-download-file@v1.3.0
+        with:
+          url: "https://github.com/ErsatzTV/ErsatzTV-Windows/releases/download/v1.0.0/ErsatzTV-Windows.exe"
+          target: rust-build/
 
       - name: Download ffmpeg
         uses: suisei-cn/actions-download-file@v1.3.0
@@ -292,18 +304,18 @@ jobs:
           release_name="ErsatzTV-${{ inputs.release_version }}-win-x64"
           echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
           mkdir "$release_name"
-          
+
           mv dotnet-build/scanner/* "$release_name/"
           mv dotnet-build/main/* "$release_name/"
 
           # dotnet shouldn't copy the resources here, but it does
           rm -rf "$release_name/Resources"
 
-          mv rust-build/ersatztv_windows.exe "$release_name/ErsatzTV-Windows.exe"
+          mv rust-build/ErsatzTV-Windows.exe "$release_name/ErsatzTV-Windows.exe"
           7z e "ffmpeg/${{ steps.downloadffmpeg.outputs.filename }}" -o"$release_name" '*.exe' -r
           rm -f "$release_name/ffplay.exe"
-          
-          7z a -tzip "${release_name}.zip" "./${release_name}/*"
+
+          (cd "${release_name}" && 7z a "../${release_name}.zip" .)
 
       - name: Delete old release assets
         uses: mknejp/delete-release-assets@v1

.github/workflows/ci.yml

@@ -46,6 +46,10 @@ jobs:
       ac_username: ${{ secrets.AC_USERNAME }}
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
+      azure_client_id: ${{ secrets.AZURE_CLIENT_ID }}
+      azure_tenant_id: ${{ secrets.AZURE_TENANT_ID }}
+      azure_subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+
   build_images:
     uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version

.github/workflows/pr.yml

@@ -2,6 +2,31 @@
 on:
   pull_request:
 jobs:
+  build_and_analyze:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore /p:EnableThreadingAnalyzers=true
   build_and_test_windows:
     runs-on: windows-latest
     steps:
@@ -11,7 +36,7 @@ jobs:
       - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.203
+          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -27,11 +52,6 @@ jobs:
 
       - name: Test
         run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
-
-      - name: Build Windows
-        run: |
-          cd ErsatzTV-Windows
-          cargo build --release --all-features
   build_and_test_linux:
     runs-on: ${{ matrix.os }}
     strategy:
@@ -52,7 +72,7 @@ jobs:
       - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.203
+          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -80,7 +100,7 @@ jobs:
       - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 9.0.203
+          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear

.github/workflows/release.yml

@@ -41,6 +41,9 @@ jobs:
       ac_username: ${{ secrets.AC_USERNAME }}
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
+      azure_client_id: ${{ secrets.AZURE_CLIENT_ID }}
+      azure_tenant_id: ${{ secrets.AZURE_TENANT_ID }}
+      azure_subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
   build_images:
     uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version

CHANGELOG.md

@@ -5,6 +5,498 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [26.3.0] - 2026-02-24
+### Added
+- Add log warnings when actual transcoding speed is potentially insufficient to support smooth playback
+  - Log messages will include media item id, channel number and transcoding speed
+- Add UI language setting to **Settings** > **UI**
+  - A small number of translations have been added for `Português (Brasil)` and `Polski`
+  - Translation contributions are always welcome!
+- Add `Troubleshoot` button to playout details table to show info that may be helpful in determining the source of a playout item
+  - Classic schedule info includes schedule, schedule item, scheduler, filler, playback order, random seed, collection index
+  - Block schedule info includes block, block item, playback order, random seed, collection index
+  - E.g. items with the same random seed are part of the same shuffle
+- Add channel setting `Slug Seconds`
+  - This controls how many (optional) seconds of black video and silent audio to insert between *every* playout item
+  - This will drift playback from the wall clock as slugs are not scheduled in the playout, but are inserted dynamically during playback
+  - If this feature turns out to be popular, methods to correct the drift may be investigated
+- Add `ETV_INSTANCE_ID` environment variable to disambiguate EPG data from multiple ErsatzTV instances
+  - When set, the value will be used in channel identifiers before the final `.ersatztv.org`
+- Show warning message when selecting audio format `aac (latm)` for general streaming use when it is only intended for DVB-C
+
+### Changed
+- Move dark/light mode toggle to **Settings** > **UI**
+- Use latest (non-deprecated) authorization method with Jellyfin API
+- Replace direct Discord links with new contact page https://ersatztv.org/contact which also includes other options like Matrix
+- Lower GOP size and keyframe interval from four seconds to two seconds in accordance with HLS2 draft spec recommendations
+
+### Fixed
+- Improve stability of playback orders `Shuffle` and `Shuffle in Order` over time
+- Fix Trakt list sync
+- Fix some cases of QSV audio/video desync when *not* seeking by using software decode
+  - This only applies to content that *might* be problematic (using a heuristic)
+- NVIDIA: force software decode of 10-bit h264 content since hardware decode is unsupported by ffmpeg until version 8
+- Graphics engine: fix stream seek value used throughout graphics engine
+  - This should fix loading EPG data when used with chapters/mid-roll
+  - This should also fix graphics element visibility when using start_seconds on content with chapters/mid-roll
+  - This bug was caused by stream seek including the playout item in-point (the chapter start time)
+    - Stream seek should only be non-zero when first joining a channel (i.e. in the middle of a playout item or chapter)
+
+## [26.2.0] - 2026-02-02
+### Added
+- Channel stream selector: add zero-based culture-specific `day_of_week` to `content_condition`, for example:
+  - en-US can match sunday using `day_of_week = 0`
+  - fr-FR can match sunday using `day_of_week = 6`
+  - As a complete example, to match Saturday from 9pm (inclusive) to 11pm (exclusive), based on content start time
+    - `content_condition: day_of_week = 6 and (time_of_day_seconds >= 75600 and time_of_day_seconds < 82800)`
+- Add `Pad Mode` to ffmpeg profile. Options are:
+  - `Hardware If Possible` - default/existing behavior when hardware acceleration is properly configured
+  - `Software` - force software padding
+    - This can be used to work around buggy GPU driver behavior where padding is green instead of black
+    - This is most often seen with VAAPI acceleration (radeonsi or i965 drivers)
+- Add API endpoint to clean artwork cache folder (on demand)
+  - POST `/api/maintenance/clean_artwork`
+- Add health check to warn about unsupported empty (classic) schedules
+- Add health check to warn about incompatible ffmpeg due to missing filters
+  - This is directly applicable to homebrew `ffmpeg` on MacOS, which is no longer compatible with ErsatzTV
+    - `ffmpeg@7` or `ffmpeg-full` should be used instead
+- Add `Marathon Group By` option `Director`
+  - This groups the *first* director on Movies, Episodes, Music Videos and Other Videos
+  - This is supported in classic schedules and sequential schedules
+- Add FFmpeg Profile options:
+  - `Normalize Audio` (default: true) - normalizes audio streams, or stream copies when disabled
+  - `Normalize Video` (default: true) - normalizes video streams, or stream copies when disabled
+  - `Normalize Colors` (default: true) - normalizes color parameters when enabled
+  - Disabling any of these options may have a significant performance benefit *at the expense of stream stability*
+- Add chapter `title` to filler expression
+  - This can be used to include or exclude chapters with specific (case-insensitive) titles
+  - E.g. `title == 'here'`, `title != 'not here'`, `title like '%here%'`
+- Local movie libraries: load fanart from `backdrop` files (created by Jellyfin)
+
+### Changed
+- Disable automatic artwork database cleanup
+  - This will be re-enabled at some point in the future (after more testing)
+  - For now, the API should be used to clean as needed
+- Classic Schedules: make multiple `count` an expression
+  - The following parameters can be used:
+    - `count`: the total number of items in the collection
+    - `random`: a random number between zero and (count - 1)
+  - For example:
+    - `count / 2` will play half of the items in the collection
+    - `random % 4 + 1` will play between 1 and 4 items
+    - `2` (similar to before this change) will play exactly two items
+
+### Fixed
+- Use code signing on all Windows executables (`ErsatzTV-Windows.exe`, `ErsatzTV.exe`, `ErsatzTV.Scanner.exe`)
+- Graphics engine:
+  - Respect `z_index` (draw order) on all graphics element types
+  - Fix bug with `z_index` sorting
+- Restore default UI font that was erroneously removed in v26.1.1
+- Classic schedules: fix building playouts when `Fill With Group Mode` schedule items also have graphics elements
+- Use configured searching log level on startup, instead of the default log level of `Information`
+- MySql: fix searching for shows and seasons in schedule items editor
+- Fix 500 errors when serving XMLTV due to concurrent file reads and writes
+- Fix playback of AC3 audio when targeting stereo output and input layout changes mid-stream
+- Use other video artwork in XMLTV template
+- Properly update (add or remove) artwork for all local media libraries when files have changed
+- Sync Plex library name changes
+- Sync Plex episode title, plot, year, date added, release date, episode number changes
+- Sync Jellyfin and Emby library name and type changes
+  - Library type (movies, shows) can only be changed when synchronization is *disabled* for the library in ETV
+- Fix some sequential and scripted playout build failures when using playlists or marathons
+- Fix erasing playout items and history so all related data is also erased
+  - This includes rerun history, unscheduled gaps, build status
+- Fix indexing collections when using Elasticsearch backend
+
+## [26.1.1] - 2026-01-08
+### Fixed
+- Use code signing on Windows launcher (`ErsatzTV-Windows.exe`) to avoid antivirus false positive
+
+### Changed
+- Optimize database check for orphaned artwork
+- Include web resources (CSS, JS) locally instead of relying on CDNs
+
+## [26.1.0] - 2026-01-06
+### Added
+- Graphics Engine:
+  - Add `script` graphics element type
+    - Supported in playback troubleshooting and all scheduling types
+    - Supports arbitrary scripts or executables that output graphics to ETV via stdout
+    - Supports EPG and Media Item replacement in entire template
+      - EPG data is sourced from XMLTV for the current time
+        - EPG data can also load a configurable number of subsequent (up next) entries
+      - Media Item data is sourced from the currently playing media item
+    - All template data will also be passed as JSON to the stdin stream of the command
+    - Template supports:
+      - Script and arguments (`command` and `args`)
+      - Draw order (`z_index`)
+      - Timing (`start_seconds` and `duration_seconds`)
+      - Data format (`format`)
+        - `raw` format means full frames of BGRA data to stdout
+        - `packet` format means ETV graphics packets to stdout
+  - Add framerate template data
+    - `RFrameRate` - the real content framerate (or channel normalized framerate) as reported by ffmpeg, e.g. `30000/1001`
+    - `FrameRate` - the decimal representation of `RFrameRate`, e.g. `29.97002997`
+  - Add `Channel_StartTime` template data
+    - This indicates the time that the transcode session started for the current channel
+- Add remote stream metadata
+  - Remote stream definitions (yaml files) can now contain `title`, `plot`, `year` and `content_rating` fields
+  - Remote streams can now have thumbnails (same name as yaml file but with image extension)
+  - This metadata will be used in generated XMLTV entries, using a template that can be customized like other media kinds
+- Add `Download Media Sample` button to playback troubleshooting
+  - This button will extract up to 30 seconds of the media item and zip it
+- Add `Target Loudness` (LUFS/LKFS) to ffmpeg profile when loudness normalization is enabled
+  - Default value is `-16`; some sources normalize to a quieter value, e.g. `-24`
+- Add environment variables to help troubleshoot performance
+  - `ETV_SLOW_DB_MS` - milliseconds threshold for logging slow database queries (at DEBUG level)
+    - e.g. if this is set to `1000`, queries taking longer than 1 second will be logged
+  - `ETV_SLOW_API_MS` - milliseconds threshold for logging slow API calls (at DEBUG level)
+    - This is currently limited to *Jellyfin*
+  - `ETV_JF_PAGE_SIZE` - page size for library scan API calls to Jellyfin; default value is 10
+  - `ETV_JF_ENABLE_STATS` - enables logging timing information related to Jellyfin show library scans
+- Add `Select All` button to media pages by @Erotemic
+
+### Fixed
+- Fix startup on systems unsupported by NvEncSharp
+- Fix detection of Plex Other Video libraries using `Plex Personal Media` agent
+  - If the library is already detected as a Movies library in ETV, synchronization must be disabled for the library to change it to an Other Videos library
+  - A warning will be logged when this scenario is detected
+- Graphics Engine:
+  - Optimize graphics engine to generate element frames in parallel and to eliminate redundant frame copies
+  - Match graphics engine framerate with source content (or channel normalized) framerate
+  - Fix loading requested number of epg entries for motion graphics elements
+- Fix bug with mirror channels where seemingly random content would be played every ~40 seconds
+- Fix chronological sorting for Other Videos that have release date metadata
+- Fix playout sorting after using channel number editor
+- VAAPI: Only include `-sei a53_cc` flags when misc packed headers are supported by the encoder
+  - This should fix playback in some cases, e.g. AMD VAAPI h264 encoder
+- AMD VAAPI:
+  - work around buggy ffmpeg behavior where hevc_vaapi encoder with RadeonSI driver incorrectly outputs height of 1088 instead of 1080
+  - fix green padding when encoding h264 using main profile
+- Automatically kill playback troubleshooting ffmpeg process if it hasn't completed after two minutes
+- Fix playback of certain BT.2020 content
+- Use playlist item count when using a playlist as filler (instead of a fixed count of 1 for each playlist item)
+- NVIDIA:
+  - Fix stream failure with certain content that should decode in hardware but falls back to software
+  - Fix stream failure with content that changes color metadata mid-stream
+- Fix stream failure when configured fallback filler collection is empty
+- Fix high CPU when errors are displayed; errors will now work ahead before throttling to realtime, similar to primary content
+- Fix startup error caused by duplicate smart collection names (and no longer allow duplicate smart collection names)
+- Fix erroneous downgrade health check failure with some installations that use MariaDB
+- Sequential schedules: fix `count` instruction validation to accept integer (constant) or string (expression)
+- Fix multi-part episode grouping logic so that it does NOT require release date metadata for episodes within a single show
+  - When **Treat Collections As Shows** is enabled (i.e. for crossover episodes) release date metadata is required for proper grouping
+- Fix *many* cases of duplicate names; enforce case-insensitive unique names at the db schema level
+- Fix playback when using `ETV_BASE_URL` by @JamesDearlove
+
+### Changed
+- No longer round framerate to nearest integer when normalizing framerate
+- Allow playlists to have no items included in EPG
+- Change how fallback filler works
+  - Items will no longer loop; instead, a sequence of random items will be selected from the collection
+  - Items may still be cut as needed
+  - Hardware acceleration will now be used
+  - Items can "work ahead" (transcode faster than realtime) when less than 3 minutes in duration
+- Optimize Jellyfin database fields and indexes
+- Optimize Jellyfin show library scans by only requesting `People` (actors, directors, writers) when etags don't match
+  - This should significantly speed up periodic library scans, particularly against Jellyfin 10.11.x
+- Lazy load media item images in UI
+- Align alternate schedule and template handling (between classic schedules and block schedules)
+  - Both systems now support limiting to a date range
+  - This date range can be repeating (when year is not specified for start or end dates)
+  - This date range can be exact (when year is specified for start and end dates)
+
+## [25.9.0] - 2025-11-29
+### Added
+- Show playout warnings count badge in left menu
+- Graphics Engine:
+  - Add `MediaItem_Resolution` template data (the current `Resolution` variable is the FFmpeg Profile resolution)
+  - Add `MediaItem_Start` template data (DateTimeOffset)
+  - Add `MediaItem_Stop` template data (DateTimeOffset)
+  - Add `ScaledResolution` template data (the final size of the frame before padding)
+  - Add `place_within_source_content` (true/false) field to image graphics element
+  - Add `name` field to all graphics elements to display in the UI
+- Classic and block schedules: add collection type `Search Query`
+  - This allows defining search queries directly on schedule items without creating smart collections beforehand
+  - As an example, this can be used to filter or combine existing smart collections
+    - Filter: `smart_collection:"sd movies" AND plot:"christmas"`
+    - Combine: `smart_collection:"old commercials" OR smart_collection:"nick promos"`
+- Scripted schedules: add `custom_title` to `start_epg_group`
+- Add MPEG-TS Script system
+  - This allows using something other than ffmpeg (e.g. streamlink) to concatenate segments back together when using MPEG-TS streaming mode
+  - Scripts live in config / scripts / mpegts
+  - Each script gets its own subfolder which contains an `mpegts.yml` definition and corresponding windows (batch) and linux (bash) scripts
+  - The global MPEG-TS script can be configured in **Settings** > **FFmpeg** > **Default MPEG-TS Script**
+- Add `.avs` AviSynth Script support to all local libraries
+  - `.avs` was added as a valid extension, so they should behave the same any other video file
+  - There are two requirements for AviSynth Scripts to work:
+    - FFmpeg needs to be compiled with AviSynth support (not currently available in Docker)
+    - AviSynth itself needs to be installed
+- Add `Troubleshoot` button to classic schedule list
+  - This generates JSON representing the entire schedule which can be shared when requested for troubleshooting
+- Add **Settings** > **FFmpeg** > **Probe For Interlaced Frames**
+  - When enabled, this will probe *local content* for interlaced frames on demand (immediately before playback)
+  - This will be used as a more accurate check for interlaced content
+  - The result will be cached (only probed once and stored) in the database along with all other media item statistics (e.g. duration)
+  - This feature will currently ignore content that is not streamed from disk
+- Add error/offline background customization
+  - Default error background is now named `_background.png`
+  - Error streams will prioritize using `background.png` if it exists
+    - Replacing this `background.png` file will allow custom error/offline backgrounds
+- Add `Troubleshoot Playback` buttons on movie and episode detail pages
+- Add song background and missing album art customization
+  - Default files start with an underscore; custom versions must remove the underscore
+- Expose arbitrary EPG data to graphics engine via channel guide templates
+  - XML nodes using the `etv:` namespace will be passed to the graphics engine EPG template data
+  - For example, adding `<etv:episode_number_key>{{ episode_number }}</etv:episode_number_key>` to `episode.sbntxt` will also add the `episode_number_key` field to all EPG items in the graphics engine
+  - All values parsed from XMLTV will be available as strings in the graphics engine (not numbers)
+  - All `etv:` nodes will be stripped from the XMLTV data when requested by a client
+- Add channel troubleshooting button to channels list
+  - This will open the playback troubleshooting tool in "channel" mode
+  - This mode requires entering a date and time, and will play up to 30 seconds of *one item from that channel's playout* starting at the entered date and time
+- Block schedules: add copy template button to templates table
+
+### Fixed
+- Fix HLS Direct playback with Jellyfin 10.11
+- Fix remote stream scripts (parsing issue with spaces and quotes)
+- Fix block history being removed when it is still needed for mirror channel
+  - This caused playout build errors like "Unable to locate history for playout item"
+- Fix crashes due to invalid smart collection searches, e.g. `smart_collection:"this collection does not exist"`
+- Fix UI crash when editing block playout that has default deco
+- Fix playback failure when seeking content with certain DTS audio (e.g. DTS-HD MA)
+- Properly set explicit audio decoder on combined audio and video input file
+- Fix building sequential schedules across a UTC offset change
+- Fix block start time calculation across a UTC offset change
+- Fix classic schedule start time calculation across a UTC offset change
+- Fix XMLTV generation for channels using on-demand playout mode
+- Fix some file not found songs missing from trash view
+- Fix error/offline screen generation
+- Fix subtitle title sync from Jellyfin libraries
+  - Deep scans will be required to update subtitle titles on existing media items
+- Fix saving subtitle title changes to the database
+  - This fixes e.g. where stream selection would continue to use the original title
+  - This fix applies to all libraries (local and media server)
+- Fix (3 year old) bug removing tags from local libraries when they are removed from NFO files (all content types)
+  - New scans will properly remove old tags; NFO files may need to be touched to force updating during a scan
+- Fix bug where looping motion graphics wouldn't be displayed when seeking into second half of content
+- Fix `content_total_duration` value in graphics engine opacity expressions
+  - This bug caused some graphics elements to display too early after first joining a channel
+- Optimize database calls made for search index rebuilds and updates
+  - This should improve performance of library scans
+- Add toggle to hide/show disabled channels in channel list
+- Add disabled text color and `(D)` and `(H)` labels for disabled and hidden channels in channel list
+- Graphics engine: fix subtitle path escaping and font loading
+- Fix corrupt output (green artifacts) when decoding certain 10-bit content using AMD Polaris GPUs
+- Work around sequential schedule validation limit (1000/hr by Newtonsoft.Json.Schema library)
+  - Playout builds now use JsonSchema.Net library which has no validation limit
+  - Validation tool in the UI still uses Newtonsoft.Json.Schema (with 1000/hr limit) as the error output is easier to understand
+- Fix editing scripted and sequential playouts when using MySql
+- Fix HLS Direct streams remaining open after client disconnect
+- Always log scanner exit code when it is non-zero
+
+### Changed
+- Classic schedules: `Refresh` classic playouts from playout list; do not `Reset` them
+  - This mode maintains progress; progress can be reset by editing the playout and clicking `Erase Items and History`
+- Use smaller batch size for search index updates (100, down from 1000)
+  - This should help newly scanned items appear in the UI more quickly
+- Replace favicon and logo in background image used for error streams
+- Block schedules:
+  - Auto scroll day view to block item time when adding and removing block items from template
+  - Allow keyboard selection of
+    - Block groups in block list
+    - Template groups in template list
+    - Block groups and blocks in template editor
+  - Replace template tree view with searchable table (like blocks)
+- Upgrade to dotnet 10
+
+## [25.8.0] - 2025-10-26
+### Added
+- Graphics engine:
+  - Add template data (like `MediaItem_Title`) for other video files
+  - Add `MediaItem_Path` for movies, episodes, music videos and other videos
+  - Add `get_directory_name` and `get_filename_without_extension` functions for path processing
+  - Add `text_align` property to text graphics elements (values: `left`, `right` and `center`)
+  - Add `MiddleCenter` value to `location` property on all graphics elements
+    - Positive and negative margins can be used to offset from center as desired
+  - Add `line_height` property to text element style definition
+    - This is a multiplier that defaults to 1.0 when unspecified
+  - Add `halo_color`, `halo_width` and `halo_blur` properties to text element style definition
+    - These can be used to "outline" text with the configured color (e.g. `#000000`), width (e.g. `10`) and amount of blur (e.g. `2`)
+- Add `Block Playout Troubleshooting` tool to help investigate block playout history
+- Add sequential schedule file and scripted schedule file names to playouts table
+- Add empty (but already up-to-date) sqlite3 database to greatly speed up initial startup for fresh installs
+- Add button to copy/clone block from blocks table
+- Add playback speed to playback troubleshooting output
+  - Speed is relative to realtime (1.0x is realtime)
+  - Speeds < 0.9x will be colored red, between 0.9x and 1.1x colored yellow, and > 1.1x colored green
+- Add episode thumbnail artwork URL to XMLTV template
+  - By default, poster will be added as image with type "poster" and thumbnail will be added as image with type "still"
+  - Poster will continue to be added as icon by default
+- Add buttons to edit Jellyfin and Emby connection information in **Media Sources** > **Jellyfin** and **Media Sources** > **Emby**
+- Add audio format `aac (latm)` for DVB-C compatibility; `aac` uses ADTS by default which is required in most cases
+- Add deep scan option for external collections (Plex, Jellyfin, Emby)
+  - Jellyfin and Emby collection scans have always been deep scans
+  - Now, by default, they will be quick scans that trust Jellyfin and Emby's etags for detecting changes
+  - If a quick scan misses updating a collection, deep scans can be triggered manually
+
+### Fixed
+- Fix NVIDIA startup errors on arm64
+- Fix remote stream durations in playouts created using block, sequential or scripted schedules
+- Fix playback troubleshooting selecting a subtitle even with no subtitle stream selected in the UI
+- Fix intermittent watermark opacity
+- Improve reliability of live remote streams; they should transcode closer to realtime in most cases
+- Dramatically improve stream startup time
+- VAAPI: fix scaling image-based subtitles (e.g. dvdsub)
+- VAAPI: fix overlaying picture subtitles with scaling behavior crop
+- Fix HLS Segmenter (fmp4) on Windows
+- Playback troubleshooting: wait for at least 2 initial segments (up to configured initial segment count) to reduce stalls
+- Fix Trakt List sync
+- Fix QSV audio sync
+- Fix QSV capability detection on Linux using non-drm displays (e.g. wayland)
+- Fix playlist filtering bug that made HLS Segmenter more likely to fail when streaming for multiple hours
+- Fix NVIDIA overlaying text subtitles and permanent watermark on 10-bit content
+- Fix UI error adding deco
+- Fix UI error editing watermarks and graphics elements on blocks
+- Fix showing playout build failure details when resetting a playout
+- Fix scheduling auto-generated trakt list playlists that contain shows
+- Fix playout builder getting stuck (forever) on block item with an empty collection
+- Fix HLS Direct playback when using custom stream selector or preferred audio language/title
+- Fix selecting embedded subtitles (text and picture) with HLS Direct
+- Fix building scripted schedules across a UTC offset change
+
+### Changed
+- Do not use graphics engine for single, permanent watermark
+- Rename `YAML Validation` tool to `Sequential Schedule Validation`
+- Greatly reduce debug log spam during playout builds by logging summaries of certain warnings at the end
+- Remove *experimental* `HLS Segmenter V2` streaming mode; it is not possible to maintain quality output using this mode
+- Remove *experimental* `HLS Segmenter (fmp4)` streaming mode; this mode only worked properly in a browser, many clients did not like it
+- Change how scanner process and main process communicate, which should improve reliability of search index updates when scanning
+
+## [25.7.1] - 2025-10-09
+### Added
+- Add search field to filter blocks table
+- Show full error/exception details in playback troubleshooting logs
+- Add basic free space validation on startup
+  - ETV will now fail to start with less than 128 MB free space in config or transcode folders
+- Add downgrade health check to inform users when they are doing something that WILL impact stability
+
+### Fixed
+- Do not allow deleting ffmpeg profiles that are used by channels
+- Do not allow deleting default ffmpeg profile
+- Allow ffmpeg profiles using VAAPI accel to set h264 video profile
+- Fix HLS Direct playback, and make it accessible on separate streaming port
+- Fix playback troubleshooting when using multiple watermarks or multiple graphics elements
+
+### Changed
+- Use table instead of tree view on blocks page
+- Use different release packaging system to workaround false positive from Windows Defender
+
+## [25.7.0] - 2025-10-03
+### Added
+- Add new collection type `Rerun Collection`
+  - This collection type will show up as *two* collection types in classic schedules
+    - `Rerun (First Run)`
+    - `Rerun (Rerun)`
+  - The playback order for each of these collection types can be set on the rerun collection itself
+    - e.g. `Season, Episode` order for first run, `Shuffle` for rerun
+  - When a first run item is added to a playout, it will immediately be made available in the rerun collection
+  - Rerun history is currently scoped to the playout, and only supported in classic schedules
+    - This means resetting the playout will reset the rerun history
+  - Items will still be scheduled from the rerun collection if it is used before the first run collection
+    - Otherwise, the rerun collection would be considered "empty" which prevents the playout build altogether
+- Add `Rkmpp` hardware acceleration by @peterdey
+  - This is supported using jellyfin-ffmpeg7 on devices like Orange Pi 5 Plus and NanoPi R6S
+- Block schedules: allow selecting multiple watermarks on block items
+- Block schedules: allow selecting multiple graphics elements on block items
+- Add `motion` graphics element type
+  - Supported in playback troubleshooting and all scheduling types
+  - Supports video files with alpha channel (e.g. vp8/vp9 webm, apple prores 4444)
+  - Supports EPG and Media Item replacement in entire template
+    - EPG data is sourced from XMLTV for the current time
+      - EPG data can also load a configurable number of subsequent (up next) entries
+    - Media Item data is sourced from the currently playing media item
+  - Template supports:
+    - Content (`video_path`)
+    - Placement (`location`, `horizontal_margin_percent`, `vertical_margin_percent`)
+    - Scaling (`scale`, `scale_width_percent`)
+    - Timing (`start_seconds`)
+    - End behavior (`end_behavior`)
+      - `disappear` (default) - disappear after playing once
+      - `loop` - loop forever
+      - `hold` - hold last frame forever, or `hold_seconds`
+    - Draw order (`z_index`)
+- Add search fields to filter collections, schedules and playouts tables
+- Add selected row background color to schedules and playouts tables
+- Graphics engine text element: add `width_percent` and `text_fit` to support wrapping and scaling text
+  - `text_fit: none` or unspecified will keep existing behavior (render text exactly as configured)
+  - `text_fit: wrap` will wrap text to the given `width_percent`
+  - `text_fit: scale` will scale text *smaller* to fit the given `width_percent`
+    - Text that already fits with the configured style will not be adjusted
+- Block schedules: add **experimental** `Break Content` to decos
+  - Break content is similar to filler from classic schedules
+  - Break content is currently limited to placement `Block Start` (play before anything else in the block)
+    - Future work will add other placement options
+  - Break content is currently limited to playlists (which do *not* pad - they simply play through the playlist one time)
+    - Future work will add other collection options which will pad to the full block duration
+- Add page to reorder channels (edit channel numbers) using drag and drop
+  - New page is at **Channels** > **Edit Channel Numbers**
+- Scripted schedules: add setting to configure timeout of scripted playout build
+  - New setting is at **Settings** > **Playout** > **Scripted Schedule Timeout**
+- Add *experimental* streaming mode `HLS Segmenter (fmp4)`
+  - This mode is required for better compliance with HLS spec, and to support new output codecs
+  - This mode *will replace* `HLS Segmenter` when it has received more testing
+- Allow HEVC playback in channel preview
+  - This is restricted to compatible browsers
+  - Preview button will be red when preview is disabled due to browser incompatibility
+- Add AV1 encoding support with NVIDIA, VAAPI and QSV acceleration
+  - This also requires `HLS Segmenter (fmp4)`
+- Add `Stream Selector` option to playback troubleshooting tool
+  - This can be helpful for validating stream selector behavior with specific content
+  - Manual subtitle selection will be disabled when using a stream selector
+- Add basic log viewer to playback troubleshooting tool
+  - Streaming log level will be forced to `Debug` during troubleshooting
+  - Streaming log level will be restored to its previous value after troubleshooting completes
+- Add playout build status to UI
+  - Playouts that fail to build will be highlighted yellow in the playouts table
+  - Clicking on the failed playout will display the warning or error that caused the playout build to fail
+
+### Fixed
+- Fix green output when libplacebo tonemapping is used with NVIDIA acceleration and 10-bit output in FFmpeg Profile
+- Fix playback when invalid video preset has been saved in FFmpegProfile
+  - This can happen when NVIDIA accel falls back to libx264 software encoder for 10-bit h264 output
+- Fix 10-bit output when using NVIDIA and graphics engine (watermark or other overlays)
+- Fix playback of Jellyfin content with unknown color range
+- Block schedules: skip collections (block items) that will never fit in block duration
+- Block schedules: skip media items that will never fit in block duration
+- Fix HLS playlist generation for clients that actually care about discontinuities (like hls.js)
+  - This should resolve most playback issues with built-in channel preview
+- Fix deco dead air fallback selection and duration on mirror channels
+- Fix fallback filler duration on mirror channels
+- Fix slow startup caused by check for overlapping playout items
+- Fix green line in *most* cases when overlaying content using NVIDIA acceleration and H264 output
+- Fix non-SRT (e.g. SSA/ASS) external subtitle playback from media servers
+- Fix extracted text subtitle playback from media servers
+- Fix extracted text subtitles getting into invalid state after media server deep scans
+  - Targeted deep scans will now extract text subtitles for the scanned show
+- Fix playlist preview
+- Use NVIDIA NvEnc API to detect encoder capability instead of heuristic based on GPU model/architecture
+- Use NVIDIA Cuvid API to detect decoder capability instead of heuristic based on GPU model/architecture
+- Fix filler expression not being respected when using a playlist as filler
+- Use "repeat count" metadata from animated GIFs in graphics engine (i.e. watermarks)
+  - GIFs flagged to loop forever will loop forever
+  - GIFs with a specific loop count will loop the specified number of times and then hold the final frame
+    - Note that looping is relative to the start of the content, so this works best with permanent watermarks
+- Fix some more hls.js warnings by adding codec information to multi-variant playlists
+- Fix hardware decode of h264 constrained baseline content using VAAPI accel
+- Custom stream selector: ignore embedded text subtitles that have not been extracted
+- Fix cropping Jellyfin and Emby content that is smaller than the crop resolution
+- Sync movies with non-file media sources (e.g. http/nfs) from Emby movie libraries by @jasonarends
+
+### Changed
+- Filler presets: use separate text fields for `hours`, `minutes` and `seconds` duration
+- Use autocomplete fields for collection searching in deco editor
+  - This greatly improves the editor performance
+
 ## [25.6.0] - 2025-09-14
 ### Added
 - Classic schedules: allow selecting multiple graphics elements on schedule items
@@ -337,13 +829,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
     - `random` will start at a random point in the content
     - `2` (similar to before this change) will skip the first two items in the content
 - YAML playout: make `count` an expression
-    - The following parameters can be used:
-        - `count`: the total number of items in the content
-        - `random`: a random number between zero and (count - 1)
-    - For example:
-        - `count / 2` will play half of the items in the content
-        - `random % 4 + 1` will play between 1 and 4 items
-        - `2` (similar to before this change) will play exactly two items
+  - The following parameters can be used:
+    - `count`: the total number of items in the content
+    - `random`: a random number between zero and (count - 1)
+  - For example:
+    - `count / 2` will play half of the items in the content
+    - `random % 4 + 1` will play between 1 and 4 items
+    - `2` (similar to before this change) will play exactly two items
 - YAML playout: add `disable_watermarks` property to all content instructions
   - This property defaults to `false` (meaning watermarks are allowed by default)
   - Setting to `true` will prevent watermarks from ever appearing over the content
@@ -2700,8 +3192,16 @@ 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/ErsatzTV/ErsatzTV/compare/v25.6.0...HEAD
-[25.6.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.6.0...v25.5.0
+[Unreleased]: https://github.com/ErsatzTV/ErsatzTV/compare/v26.3.0...HEAD
+[26.3.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v26.2.0...v26.3.0
+[26.2.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v26.1.1...v26.2.0
+[26.1.1]: https://github.com/ErsatzTV/ErsatzTV/compare/v26.1.0...v26.1.1
+[26.1.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.9.0...v26.1.0
+[25.9.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.8.0...v25.9.0
+[25.8.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.7.1...v25.8.0
+[25.7.1]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.7.0...v25.7.1
+[25.7.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.6.0...v25.7.0
+[25.6.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.5.0...v25.6.0
 [25.5.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.4.0...v25.5.0
 [25.4.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.3.1...v25.4.0
 [25.3.1]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.3.0...v25.3.1

Directory.Build.props

@@ -2,5 +2,6 @@
     <PropertyGroup>
         <InformationalVersion>develop</InformationalVersion>
         <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <AllowMissingPrunePackageData>true</AllowMissingPrunePackageData>
     </PropertyGroup>
-</Project>
+</Project>

Directory.Build.targets

@@ -0,0 +1,15 @@
+<Project>
+    <PropertyGroup>
+        <EnableThreadingAnalyzers Condition="'$(EnableThreadingAnalyzers)' == ''">false</EnableThreadingAnalyzers>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference
+            Include="Microsoft.VisualStudio.Threading.Analyzers"
+            Version="17.14.15"
+            Condition="'$(EnableThreadingAnalyzers)' == 'true'">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+</Project>

ErsatzTV-Windows/.gitignore

@@ -1,2 +0,0 @@
-target/
-

ErsatzTV-Windows/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "ersatztv_windows"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-tray-item = { git = "https://github.com/olback/tray-item-rs" }
-special-folder = { git = "https://github.com/masinc/special-folder-rs" }
-process_path = "0.1.4"
-
-[dependencies.windows]
-version = "0.43.0"
-features = [
-    "Win32_System_Console",
-    "Win32_Foundation"
-]
-
-[build-dependencies]
-windres = "*"
-static_vcruntime = "2.0"

ErsatzTV-Windows/build.rs

@@ -1,6 +0,0 @@
-use windres::Build;
-
-fn main() {
-    static_vcruntime::metabuild();
-    Build::new().compile("ersatztv_windows.rc").unwrap();
-}

ErsatzTV-Windows/ersatztv_windows.rc

@@ -1,2 +0,0 @@
-id ICON "ersatztv.ico"
-ersatztv-icon ICON "ersatztv.ico"

ErsatzTV-Windows/src/main.rs

@@ -1,115 +0,0 @@
-#![windows_subsystem = "windows"]
-
-use special_folder::SpecialFolder;
-use std::env;
-use std::fs;
-use std::os::windows::process::CommandExt;
-use std::process::Child;
-use std::process::Command;
-use std::process::Stdio;
-use windows::Win32::System::Console;
-use {std::sync::mpsc, tray_item::TrayItem};
-
-const CREATE_NO_WINDOW: u32 = 0x08000000;
-
-enum Message {
-    Exit,
-}
-
-fn main() {
-    let mut tray = TrayItem::new("ErsatzTV", "ersatztv-icon").unwrap();
-
-    let (tx, rx) = mpsc::channel();
-
-    tray.add_menu_item("Launch Web UI", || {
-        let ui_port = env::var("ETV_UI_PORT")
-            .ok()
-            .and_then(|val| val.parse::<u16>().ok())
-            .unwrap_or(8409);
-
-        let _ = Command::new("cmd")
-            .creation_flags(CREATE_NO_WINDOW)
-            .arg("/C")
-            .arg("start")
-            .arg(format!("http://localhost:{}", ui_port))
-            .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn();
-    })
-        .unwrap();
-
-    tray.add_menu_item("Show Logs", || {
-        let path = SpecialFolder::LocalApplicationData
-            .get()
-            .unwrap()
-            .join("ersatztv")
-            .join("logs");
-        match path.to_str() {
-            None => {}
-            Some(folder) => {
-                fs::create_dir_all(folder).unwrap();
-                let _ = Command::new("explorer.exe")
-                    .arg(folder)
-                    .stdin(Stdio::null())
-                    .stdout(Stdio::null())
-                    .stderr(Stdio::null())
-                    .spawn();
-            }
-        }
-    })
-        .unwrap();
-
-    tray.inner_mut().add_separator().unwrap();
-
-    tray.add_menu_item("Exit", move || {
-        tx.send(Message::Exit).unwrap();
-    })
-        .unwrap();
-
-    let path = process_path::get_executable_path();
-    let mut child: Option<Child> = None;
-    match path {
-        None => {}
-        Some(path) => {
-            let etv = path.parent().unwrap().join("ErsatzTV.exe");
-            if etv.exists() {
-                match etv.to_str() {
-                    None => {}
-                    Some(etv) => {
-                        child = Some(
-                            Command::new(etv)
-                                .creation_flags(CREATE_NO_WINDOW)
-                                .stdin(Stdio::null())
-                                .stdout(Stdio::null())
-                                .stderr(Stdio::null())
-                                .spawn()
-                                .unwrap(),
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    loop {
-        match rx.recv() {
-            Ok(Message::Exit) => {
-                match child {
-                    None => {}
-                    Some(mut child) => {
-                        unsafe {
-                            if Console::AttachConsole(child.id()) == true
-                            {
-                                Console::GenerateConsoleCtrlEvent(Console::CTRL_C_EVENT, 0);
-                            }
-                        }
-                        child.wait().unwrap();
-                    }
-                }
-                break;
-            }
-            _ => {}
-        }
-    }
-}

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

@@ -1,30 +1,26 @@
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Artists.Mapper;
 
 namespace ErsatzTV.Application.Artists;
 
-public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<ArtistViewModel>>
+public class GetArtistByIdHandler(
+    IArtistRepository artistRepository,
+    ISearchRepository searchRepository,
+    ILanguageCodeService languageCodeService)
+    : IRequestHandler<GetArtistById, Option<ArtistViewModel>>
 {
-    private readonly IArtistRepository _artistRepository;
-    private readonly ISearchRepository _searchRepository;
-
-    public GetArtistByIdHandler(IArtistRepository artistRepository, ISearchRepository searchRepository)
-    {
-        _artistRepository = artistRepository;
-        _searchRepository = searchRepository;
-    }
-
     public async Task<Option<ArtistViewModel>> Handle(
         GetArtistById request,
         CancellationToken cancellationToken)
     {
-        Option<Artist> maybeArtist = await _artistRepository.GetArtist(request.ArtistId);
+        Option<Artist> maybeArtist = await artistRepository.GetArtist(request.ArtistId);
         return await maybeArtist.Match<Task<Option<ArtistViewModel>>>(
             async artist =>
             {
-                List<string> mediaCodes = await _searchRepository.GetLanguagesForArtist(artist);
-                List<string> languageCodes = await _searchRepository.GetAllThreeLetterLanguageCodes(mediaCodes);
+                List<string> mediaCodes = await searchRepository.GetLanguagesForArtist(artist);
+                List<string> languageCodes = languageCodeService.GetAllLanguageCodes(mediaCodes);
                 return ProjectToViewModel(artist, languageCodes);
             },
             () => Task.FromResult(Option<ArtistViewModel>.None));

ErsatzTV.Application/Channels/ChannelSortViewModel.cs

@@ -0,0 +1,10 @@
+namespace ErsatzTV.Application.Channels;
+
+public class ChannelSortViewModel
+{
+    public int Id { get; set; }
+    public string Number { get; set; }
+    public string Name { get; set; }
+    public string OriginalNumber { get; set; }
+    public bool HasChanged => OriginalNumber != Number;
+}

ErsatzTV.Application/Channels/ChannelStreamingSpecsViewModel.cs

@@ -0,0 +1,11 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Channels;
+
+public record ChannelStreamingSpecsViewModel(
+    int Height,
+    int Width,
+    int Bitrate,
+    FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    FFmpegProfileAudioFormat AudioFormat);

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -11,6 +11,7 @@ public record ChannelViewModel(
     string Group,
     string Categories,
     int FFmpegProfileId,
+    double? SlugSeconds,
     ArtworkContentTypeModel Logo,
     ChannelStreamSelectorMode StreamSelectorMode,
     string StreamSelector,

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -10,6 +10,7 @@ public record CreateChannel(
     string Group,
     string Categories,
     int FFmpegProfileId,
+    double? SlugSeconds,
     ArtworkContentTypeModel Logo,
     ChannelStreamSelectorMode StreamSelectorMode,
     string StreamSelector,

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,4 +1,5 @@
-using System.Text.RegularExpressions;
+using System.Globalization;
+using System.Text.RegularExpressions;
 using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -75,9 +76,11 @@ public class CreateChannelHandler(
             {
                 Name = name,
                 Number = number,
+                SortNumber = double.Parse(number, CultureInfo.InvariantCulture),
                 Group = request.Group,
                 Categories = request.Categories,
                 FFmpegProfileId = ffmpegProfileId,
+                SlugSeconds = request.SlugSeconds,
                 PlayoutSource = request.PlayoutSource,
                 PlayoutMode = request.PlayoutMode,
                 MirrorSourceChannelId = request.MirrorSourceChannelId,

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -1,6 +1,6 @@
+using System.IO.Abstractions;
 using System.Threading.Channels;
 using ErsatzTV.Core;
-using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -12,19 +12,19 @@ namespace ErsatzTV.Application.Channels;
 public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Unit>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ILocalFileSystem _localFileSystem;
+    private readonly IFileSystem _fileSystem;
     private readonly ISearchTargets _searchTargets;
     private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
 
     public DeleteChannelHandler(
         ChannelWriter<IBackgroundServiceRequest> workerChannel,
         IDbContextFactory<TvContext> dbContextFactory,
-        ILocalFileSystem localFileSystem,
+        IFileSystem fileSystem,
         ISearchTargets searchTargets)
     {
         _workerChannel = workerChannel;
         _dbContextFactory = dbContextFactory;
-        _localFileSystem = localFileSystem;
+        _fileSystem = fileSystem;
         _searchTargets = searchTargets;
     }
 
@@ -44,7 +44,7 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
 
         // delete channel data from channel guide cache
         string cacheFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{channel.Number}.xml");
-        if (_localFileSystem.FileExists(cacheFile))
+        if (_fileSystem.File.Exists(cacheFile))
         {
             File.Delete(cacheFile);
         }

ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs

@@ -1,4 +1,5 @@
 using System.Globalization;
+using System.IO.Abstractions;
 using System.Xml;
 using ErsatzTV.Application.Configuration;
 using ErsatzTV.Core;
@@ -26,6 +27,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IFileSystem _fileSystem;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<RefreshChannelDataHandler> _logger;
     private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
@@ -33,12 +35,14 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
     public RefreshChannelDataHandler(
         RecyclableMemoryStreamManager recyclableMemoryStreamManager,
         IDbContextFactory<TvContext> dbContextFactory,
+        IFileSystem fileSystem,
         ILocalFileSystem localFileSystem,
         IConfigElementRepository configElementRepository,
         ILogger<RefreshChannelDataHandler> logger)
     {
         _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
         _dbContextFactory = dbContextFactory;
+        _fileSystem = fileSystem;
         _localFileSystem = localFileSystem;
         _configElementRepository = configElementRepository;
         _logger = logger;
@@ -46,247 +50,278 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     public async Task Handle(RefreshChannelData request, CancellationToken cancellationToken)
     {
-        _logger.LogDebug("Refreshing channel data (XMLTV) for channel {Channel}", request.ChannelNumber);
-
-        _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
-
-        string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-        int hiddenCount = await dbContext.Channels
-            .Where(c => c.Number == request.ChannelNumber && c.ShowInEpg == false)
-            .CountAsync(cancellationToken);
-        if (hiddenCount > 0)
+        try
         {
-            File.Delete(targetFile);
-            return;
-        }
+            _logger.LogDebug("Refreshing channel data (XMLTV) for channel {Channel}", request.ChannelNumber);
 
-        string movieTemplateFileName = GetMovieTemplateFileName();
-        string episodeTemplateFileName = GetEpisodeTemplateFileName();
-        string musicVideoTemplateFileName = GetMusicVideoTemplateFileName();
-        string songTemplateFileName = GetSongTemplateFileName();
-        string otherVideoTemplateFileName = GetOtherVideoTemplateFileName();
-        if (movieTemplateFileName is null || episodeTemplateFileName is null || musicVideoTemplateFileName is null ||
-            songTemplateFileName is null || otherVideoTemplateFileName is null)
-        {
-            return;
-        }
+            _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
 
-        var minifier = new XmlMinifier(
-            new XmlMinificationSettings
+            string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            int hiddenCount = await dbContext.Channels
+                .Where(c => c.Number == request.ChannelNumber && c.ShowInEpg == false)
+                .CountAsync(cancellationToken);
+            if (hiddenCount > 0)
             {
-                MinifyWhitespace = true,
-                RemoveXmlComments = true,
-                CollapseTagsWithoutContent = true
-            });
-
-        var templateContext = new XmlTemplateContext();
-
-        string movieText = await File.ReadAllTextAsync(movieTemplateFileName, cancellationToken);
-        var movieTemplate = Template.Parse(movieText, movieTemplateFileName);
-
-        string episodeText = await File.ReadAllTextAsync(episodeTemplateFileName, cancellationToken);
-        var episodeTemplate = Template.Parse(episodeText, episodeTemplateFileName);
-
-        string musicVideoText = await File.ReadAllTextAsync(musicVideoTemplateFileName, cancellationToken);
-        var musicVideoTemplate = Template.Parse(musicVideoText, musicVideoTemplateFileName);
-
-        string songText = await File.ReadAllTextAsync(songTemplateFileName, cancellationToken);
-        var songTemplate = Template.Parse(songText, songTemplateFileName);
-
-        string otherVideoText = await File.ReadAllTextAsync(otherVideoTemplateFileName, cancellationToken);
-        var otherVideoTemplate = Template.Parse(otherVideoText, otherVideoTemplateFileName);
-
-        TimeSpan playoutOffset = TimeSpan.Zero;
-        string mirrorChannelNumber = null;
-        Option<Channel> maybeChannel = await dbContext.Channels
-            .AsNoTracking()
-            .Include(c => c.MirrorSourceChannel)
-            .Filter(c => c.PlayoutSource == ChannelPlayoutSource.Mirror && c.MirrorSourceChannelId != null)
-            .SelectOneAsync(c => c.Number == request.ChannelNumber, c => c.Number == request.ChannelNumber, cancellationToken);
-        foreach (Channel channel in maybeChannel)
-        {
-            mirrorChannelNumber = channel.MirrorSourceChannel.Number;
-            playoutOffset = channel.PlayoutOffset ?? TimeSpan.Zero;
-        }
-
-        List<Playout> playouts = await dbContext.Playouts
-            .AsNoTracking()
-            .Filter(pi => pi.Channel.Number == (mirrorChannelNumber ?? request.ChannelNumber))
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Episode).EpisodeMetadata)
-            .ThenInclude(em => em.Guids)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Episode).Season)
-            .ThenInclude(s => s.Show)
-            .ThenInclude(s => s.ShowMetadata)
-            .ThenInclude(sm => sm.Artwork)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Episode).Season)
-            .ThenInclude(s => s.Show)
-            .ThenInclude(s => s.ShowMetadata)
-            .ThenInclude(sm => sm.Genres)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Episode).Season)
-            .ThenInclude(s => s.Show)
-            .ThenInclude(s => s.ShowMetadata)
-            .ThenInclude(sm => sm.Guids)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Movie).MovieMetadata)
-            .ThenInclude(mm => mm.Artwork)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Movie).MovieMetadata)
-            .ThenInclude(mm => mm.Genres)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Movie).MovieMetadata)
-            .ThenInclude(mm => mm.Guids)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-            .ThenInclude(mm => mm.Artwork)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-            .ThenInclude(mvm => mvm.Genres)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-            .ThenInclude(mvm => mvm.Studios)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-            .ThenInclude(mvm => mvm.Directors)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-            .ThenInclude(mvm => mvm.Artists)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as MusicVideo).Artist)
-            .ThenInclude(a => a.ArtistMetadata)
-            .ThenInclude(am => am.Genres)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
-            .ThenInclude(vm => vm.Artwork)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Song).SongMetadata)
-            .ThenInclude(vm => vm.Artwork)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Song).SongMetadata)
-            .ThenInclude(sm => sm.Genres)
-            .Include(p => p.Items)
-            .ThenInclude(i => i.MediaItem)
-            .ThenInclude(i => (i as Song).SongMetadata)
-            .ThenInclude(sm => sm.Studios)
-            .ToListAsync(cancellationToken);
-
-        await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
-        await using var xml = XmlWriter.Create(
-            ms,
-            new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
-
-        int daysToBuild = await _configElementRepository
-            .GetValue<int>(ConfigElementKey.XmltvDaysToBuild, cancellationToken)
-            .IfNoneAsync(2);
-
-        DateTimeOffset finish = DateTimeOffset.UtcNow.AddDays(daysToBuild);
-
-        foreach (Playout playout in playouts)
-        {
-            switch (playout.ScheduleKind)
-            {
-                case PlayoutScheduleKind.Classic:
-                case PlayoutScheduleKind.Sequential:
-                case PlayoutScheduleKind.Scripted:
-                    var floodSorted = playouts
-                        .Collect(p => p.Items)
-                        .OrderBy(pi => pi.Start)
-                        .Filter(pi => pi.StartOffset <= finish)
-                        .ToList();
-                    foreach (var item in floodSorted)
-                    {
-                        item.Start += playoutOffset;
-                        item.Finish += playoutOffset;
-                    }
-                    await WritePlayoutXml(
-                        request,
-                        floodSorted,
-                        templateContext,
-                        movieTemplate,
-                        episodeTemplate,
-                        musicVideoTemplate,
-                        songTemplate,
-                        otherVideoTemplate,
-                        minifier,
-                        xml,
-                        cancellationToken);
-                    break;
-                case PlayoutScheduleKind.Block:
-                    var blockSorted = playouts
-                        .Collect(p => p.Items)
-                        .OrderBy(pi => pi.Start)
-                        .Filter(pi => pi.StartOffset <= finish)
-                        .ToList();
-                    foreach (var item in blockSorted)
-                    {
-                        item.Start += playoutOffset;
-                        item.Finish += playoutOffset;
-                    }
-                    await WriteBlockPlayoutXml(
-                        request,
-                        blockSorted,
-                        templateContext,
-                        movieTemplate,
-                        episodeTemplate,
-                        musicVideoTemplate,
-                        songTemplate,
-                        otherVideoTemplate,
-                        minifier,
-                        xml,
-                        cancellationToken);
-                    break;
-                case PlayoutScheduleKind.ExternalJson:
-                    var externalJsonSorted = (await CollectExternalJsonItems(playout.ScheduleFile))
-                        .Filter(pi => pi.StartOffset <= finish)
-                        .ToList();
-                    foreach (var item in externalJsonSorted)
-                    {
-                        item.Start += playoutOffset;
-                        item.Finish += playoutOffset;
-                    }
-                    await WritePlayoutXml(
-                        request,
-                        externalJsonSorted,
-                        templateContext,
-                        movieTemplate,
-                        episodeTemplate,
-                        musicVideoTemplate,
-                        songTemplate,
-                        otherVideoTemplate,
-                        minifier,
-                        xml,
-                        cancellationToken);
-                    break;
+                File.Delete(targetFile);
+                return;
             }
+
+            string movieTemplateFileName = GetMovieTemplateFileName();
+            string episodeTemplateFileName = GetEpisodeTemplateFileName();
+            string musicVideoTemplateFileName = GetMusicVideoTemplateFileName();
+            string songTemplateFileName = GetSongTemplateFileName();
+            string otherVideoTemplateFileName = GetOtherVideoTemplateFileName();
+            string remoteStreamTemplateFileName = GetRemoteStreamTemplateFileName();
+            if (movieTemplateFileName is null || episodeTemplateFileName is null ||
+                musicVideoTemplateFileName is null ||
+                songTemplateFileName is null || otherVideoTemplateFileName is null ||
+                remoteStreamTemplateFileName is null)
+            {
+                return;
+            }
+
+            var minifier = new XmlMinifier(
+                new XmlMinificationSettings
+                {
+                    MinifyWhitespace = true,
+                    RemoveXmlComments = true,
+                    CollapseTagsWithoutContent = true
+                });
+
+            var templateContext = new XmlTemplateContext();
+
+            string movieText = await File.ReadAllTextAsync(movieTemplateFileName, cancellationToken);
+            var movieTemplate = Template.Parse(movieText, movieTemplateFileName);
+
+            string episodeText = await File.ReadAllTextAsync(episodeTemplateFileName, cancellationToken);
+            var episodeTemplate = Template.Parse(episodeText, episodeTemplateFileName);
+
+            string musicVideoText = await File.ReadAllTextAsync(musicVideoTemplateFileName, cancellationToken);
+            var musicVideoTemplate = Template.Parse(musicVideoText, musicVideoTemplateFileName);
+
+            string songText = await File.ReadAllTextAsync(songTemplateFileName, cancellationToken);
+            var songTemplate = Template.Parse(songText, songTemplateFileName);
+
+            string otherVideoText = await File.ReadAllTextAsync(otherVideoTemplateFileName, cancellationToken);
+            var otherVideoTemplate = Template.Parse(otherVideoText, otherVideoTemplateFileName);
+
+            string remoteStreamText = await File.ReadAllTextAsync(remoteStreamTemplateFileName, cancellationToken);
+            var remoteStreamTemplate = Template.Parse(remoteStreamText, remoteStreamTemplateFileName);
+
+            TimeSpan playoutOffset = TimeSpan.Zero;
+            string mirrorChannelNumber = null;
+            Option<Channel> maybeChannel = await dbContext.Channels
+                .AsNoTracking()
+                .Include(c => c.MirrorSourceChannel)
+                .Filter(c => c.PlayoutSource == ChannelPlayoutSource.Mirror && c.MirrorSourceChannelId != null)
+                .SelectOneAsync(
+                    c => c.Number == request.ChannelNumber,
+                    c => c.Number == request.ChannelNumber,
+                    cancellationToken);
+            foreach (Channel channel in maybeChannel)
+            {
+                mirrorChannelNumber = channel.MirrorSourceChannel.Number;
+                playoutOffset = channel.PlayoutOffset ?? TimeSpan.Zero;
+            }
+
+            List<Playout> playouts = await dbContext.Playouts
+                .AsNoTracking()
+                .Filter(pi => pi.Channel.Number == (mirrorChannelNumber ?? request.ChannelNumber))
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Episode).EpisodeMetadata)
+                .ThenInclude(em => em.Guids)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Episode).EpisodeMetadata)
+                .ThenInclude(em => em.Artwork)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Episode).Season)
+                .ThenInclude(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
+                .ThenInclude(sm => sm.Artwork)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Episode).Season)
+                .ThenInclude(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
+                .ThenInclude(sm => sm.Genres)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Episode).Season)
+                .ThenInclude(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
+                .ThenInclude(sm => sm.Guids)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Movie).MovieMetadata)
+                .ThenInclude(mm => mm.Artwork)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Movie).MovieMetadata)
+                .ThenInclude(mm => mm.Genres)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Movie).MovieMetadata)
+                .ThenInclude(mm => mm.Guids)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+                .ThenInclude(mm => mm.Artwork)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+                .ThenInclude(mvm => mvm.Genres)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+                .ThenInclude(mvm => mvm.Studios)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+                .ThenInclude(mvm => mvm.Directors)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+                .ThenInclude(mvm => mvm.Artists)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as MusicVideo).Artist)
+                .ThenInclude(a => a.ArtistMetadata)
+                .ThenInclude(am => am.Genres)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+                .ThenInclude(vm => vm.Artwork)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as RemoteStream).RemoteStreamMetadata)
+                .ThenInclude(vm => vm.Artwork)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Song).SongMetadata)
+                .ThenInclude(vm => vm.Artwork)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Song).SongMetadata)
+                .ThenInclude(sm => sm.Genres)
+                .Include(p => p.Items)
+                .ThenInclude(i => i.MediaItem)
+                .ThenInclude(i => (i as Song).SongMetadata)
+                .ThenInclude(sm => sm.Studios)
+                .AsSplitQuery()
+                .ToListAsync(cancellationToken);
+
+            await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
+            await using var xml = XmlWriter.Create(
+                ms,
+                new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
+
+            int daysToBuild = await _configElementRepository
+                .GetValue<int>(ConfigElementKey.XmltvDaysToBuild, cancellationToken)
+                .IfNoneAsync(2);
+
+            DateTimeOffset finish = DateTimeOffset.UtcNow.AddDays(daysToBuild);
+
+            foreach (Playout playout in playouts)
+            {
+                switch (playout.ScheduleKind)
+                {
+                    case PlayoutScheduleKind.Classic:
+                    case PlayoutScheduleKind.Sequential:
+                    case PlayoutScheduleKind.Scripted:
+                        var floodSorted = playouts
+                            .Collect(p => p.Items)
+                            .OrderBy(pi => pi.Start)
+                            .Filter(pi => pi.StartOffset <= finish)
+                            .ToList();
+                        foreach (var item in floodSorted)
+                        {
+                            item.Start += playoutOffset;
+                            item.Finish += playoutOffset;
+                        }
+
+                        await WritePlayoutXml(
+                            request,
+                            floodSorted,
+                            templateContext,
+                            movieTemplate,
+                            episodeTemplate,
+                            musicVideoTemplate,
+                            songTemplate,
+                            otherVideoTemplate,
+                            remoteStreamTemplate,
+                            minifier,
+                            xml,
+                            cancellationToken);
+                        break;
+                    case PlayoutScheduleKind.Block:
+                        var blockSorted = playouts
+                            .Collect(p => p.Items)
+                            .OrderBy(pi => pi.Start)
+                            .Filter(pi => pi.StartOffset <= finish)
+                            .ToList();
+                        foreach (var item in blockSorted)
+                        {
+                            item.Start += playoutOffset;
+                            item.Finish += playoutOffset;
+                        }
+
+                        await WriteBlockPlayoutXml(
+                            request,
+                            blockSorted,
+                            templateContext,
+                            movieTemplate,
+                            episodeTemplate,
+                            musicVideoTemplate,
+                            songTemplate,
+                            otherVideoTemplate,
+                            remoteStreamTemplate,
+                            minifier,
+                            xml,
+                            cancellationToken);
+                        break;
+                    case PlayoutScheduleKind.ExternalJson:
+                        var externalJsonSorted = (await CollectExternalJsonItems(playout.ScheduleFile))
+                            .Filter(pi => pi.StartOffset <= finish)
+                            .ToList();
+                        foreach (var item in externalJsonSorted)
+                        {
+                            item.Start += playoutOffset;
+                            item.Finish += playoutOffset;
+                        }
+
+                        await WritePlayoutXml(
+                            request,
+                            externalJsonSorted,
+                            templateContext,
+                            movieTemplate,
+                            episodeTemplate,
+                            musicVideoTemplate,
+                            songTemplate,
+                            otherVideoTemplate,
+                            remoteStreamTemplate,
+                            minifier,
+                            xml,
+                            cancellationToken);
+                        break;
+                }
+            }
+
+            await xml.FlushAsync();
+
+            string tempFile = Path.GetTempFileName();
+            await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
+
+            File.Move(tempFile, targetFile, true);
+        }
+        catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
+        {
+            // do nothing
         }
-
-        await xml.FlushAsync();
-
-        string tempFile = Path.GetTempFileName();
-        await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
-
-        File.Move(tempFile, targetFile, true);
     }
 
     private async Task WritePlayoutXml(
@@ -298,6 +333,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
+        Template remoteStreamTemplate,
         XmlMinifier minifier,
         XmlWriter xml,
         CancellationToken cancellationToken)
@@ -372,6 +408,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 musicVideoTemplate,
                 songTemplate,
                 otherVideoTemplate,
+                remoteStreamTemplate,
                 minifier,
                 xml);
 
@@ -388,6 +425,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
+        Template remoteStreamTemplate,
         XmlMinifier minifier,
         XmlWriter xml,
         CancellationToken cancellationToken)
@@ -443,6 +481,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                             musicVideoTemplate,
                             songTemplate,
                             otherVideoTemplate,
+                            remoteStreamTemplate,
                             minifier,
                             xml);
                     }
@@ -482,6 +521,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                             musicVideoTemplate,
                             songTemplate,
                             otherVideoTemplate,
+                            remoteStreamTemplate,
                             minifier,
                             xml);
 
@@ -505,6 +545,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
+        Template remoteStreamTemplate,
         XmlMinifier minifier,
         XmlWriter xml)
     {
@@ -566,6 +607,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 title,
                 templateContext,
                 otherVideoTemplate),
+            RemoteStream templateRemoteStream => await ProcessRemoteStreamTemplate(
+                request,
+                templateRemoteStream,
+                start,
+                stop,
+                hasCustomTitle,
+                displayItem,
+                title,
+                templateContext,
+                remoteStreamTemplate),
             _ => Option<string>.None
         };
 
@@ -653,6 +704,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 showMetadata.Guids ??= [];
 
                 string artworkPath = GetPrioritizedArtworkPath(showMetadata);
+                string thumbnailPath = GetPrioritizedArtworkPath(metadata);
 
                 var data = new
                 {
@@ -673,6 +725,8 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                     ShowGenres = showMetadata.Genres.Map(g => g.Name).OrderBy(n => n),
                     EpisodeHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
                     EpisodeArtworkUrl = artworkPath,
+                    EpisodeHasThumbnail = !string.IsNullOrWhiteSpace(thumbnailPath),
+                    EpisodeThumbnailUrl = thumbnailPath,
                     SeasonNumber = templateEpisode.Season?.SeasonNumber ?? 0,
                     metadata.EpisodeNumber,
                     ShowHasContentRating = !string.IsNullOrWhiteSpace(showMetadata.ContentRating),
@@ -829,6 +883,8 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
             metadata.Genres ??= [];
             metadata.Guids ??= [];
 
+            string artworkPath = GetPrioritizedArtworkPath(metadata);
+
             var data = new
             {
                 ProgrammeStart = start,
@@ -843,6 +899,8 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 OtherVideoPlot = metadata.Plot,
                 OtherVideoHasYear = metadata.Year.HasValue,
                 OtherVideoYear = metadata.Year,
+                OtherVideoHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
+                OtherVideoArtworkUrl = artworkPath,
                 OtherVideoGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
                 OtherVideoHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
                 OtherVideoContentRating = metadata.ContentRating
@@ -858,18 +916,63 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         return Option<string>.None;
     }
 
-    private string GetMovieTemplateFileName()
+    private static async Task<Option<string>> ProcessRemoteStreamTemplate(
+        RefreshChannelData request,
+        RemoteStream templateRemoteStream,
+        string start,
+        string stop,
+        bool hasCustomTitle,
+        PlayoutItem displayItem,
+        string title,
+        XmlTemplateContext templateContext,
+        Template remoteStreamTemplate)
     {
-        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "movie.sbntxt");
-
-        // fall back to default template
-        if (!_localFileSystem.FileExists(templateFileName))
+        foreach (RemoteStreamMetadata metadata in templateRemoteStream.RemoteStreamMetadata.HeadOrNone())
         {
-            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_movie.sbntxt");
+            metadata.Genres ??= [];
+            metadata.Guids ??= [];
+
+            string artworkPath = GetPrioritizedArtworkPath(metadata);
+
+            var data = new
+            {
+                ProgrammeStart = start,
+                ProgrammeStop = stop,
+                ChannelId = ChannelIdentifier.FromNumber(request.ChannelNumber),
+                ChannelIdLegacy = ChannelIdentifier.LegacyFromNumber(request.ChannelNumber),
+                request.ChannelNumber,
+                HasCustomTitle = hasCustomTitle,
+                displayItem.CustomTitle,
+                RemoteStreamTitle = title,
+                RemoteStreamHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
+                RemoteStreamPlot = metadata.Plot,
+                RemoteStreamHasYear = metadata.Year.HasValue,
+                RemoteStreamYear = metadata.Year,
+                RemoteStreamHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
+                RemoteStreamArtworkUrl = artworkPath,
+                RemoteStreamGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
+                RemoteStreamHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
+                RemoteStreamContentRating = metadata.ContentRating
+            };
+
+            var scriptObject = new ScriptObject();
+            scriptObject.Import(data);
+            templateContext.PushGlobal(scriptObject);
+
+            return await remoteStreamTemplate.RenderAsync(templateContext);
         }
 
+        return Option<string>.None;
+    }
+
+    private string GetMovieTemplateFileName()
+    {
+        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
+            FileSystemLayout.ChannelGuideTemplatesFolder,
+            "movie.sbntxt");
+
         // fail if file doesn't exist
-        if (!_localFileSystem.FileExists(templateFileName))
+        if (!_fileSystem.File.Exists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate movie XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -883,16 +986,12 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetEpisodeTemplateFileName()
     {
-        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "episode.sbntxt");
-
-        // fall back to default template
-        if (!_localFileSystem.FileExists(templateFileName))
-        {
-            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_episode.sbntxt");
-        }
+        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
+            FileSystemLayout.ChannelGuideTemplatesFolder,
+            "episode.sbntxt");
 
         // fail if file doesn't exist
-        if (!_localFileSystem.FileExists(templateFileName))
+        if (!_fileSystem.File.Exists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate episode XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -906,16 +1005,12 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetMusicVideoTemplateFileName()
     {
-        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "musicVideo.sbntxt");
-
-        // fall back to default template
-        if (!_localFileSystem.FileExists(templateFileName))
-        {
-            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_musicVideo.sbntxt");
-        }
+        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
+            FileSystemLayout.ChannelGuideTemplatesFolder,
+            "musicVideo.sbntxt");
 
         // fail if file doesn't exist
-        if (!_localFileSystem.FileExists(templateFileName))
+        if (!_fileSystem.File.Exists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate music video XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -929,16 +1024,12 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetSongTemplateFileName()
     {
-        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "song.sbntxt");
-
-        // fall back to default template
-        if (!_localFileSystem.FileExists(templateFileName))
-        {
-            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_song.sbntxt");
-        }
+        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
+            FileSystemLayout.ChannelGuideTemplatesFolder,
+            "song.sbntxt");
 
         // fail if file doesn't exist
-        if (!_localFileSystem.FileExists(templateFileName))
+        if (!_fileSystem.File.Exists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate song XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -952,16 +1043,12 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetOtherVideoTemplateFileName()
     {
-        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "otherVideo.sbntxt");
-
-        // fall back to default template
-        if (!_localFileSystem.FileExists(templateFileName))
-        {
-            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_otherVideo.sbntxt");
-        }
+        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
+            FileSystemLayout.ChannelGuideTemplatesFolder,
+            "otherVideo.sbntxt");
 
         // fail if file doesn't exist
-        if (!_localFileSystem.FileExists(templateFileName))
+        if (!_fileSystem.File.Exists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate other video XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -973,6 +1060,25 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         return templateFileName;
     }
 
+    private string GetRemoteStreamTemplateFileName()
+    {
+        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
+            FileSystemLayout.ChannelGuideTemplatesFolder,
+            "remoteStream.sbntxt");
+
+        // fail if file doesn't exist
+        if (!_fileSystem.File.Exists(templateFileName))
+        {
+            _logger.LogError(
+                "Unable to generate remote stream XMLTV fragment without template file {File}; please restart ErsatzTV",
+                templateFileName);
+
+            return null;
+        }
+
+        return templateFileName;
+    }
+
     private static string GetArtworkUrl(Artwork artwork, ArtworkKind artworkKind)
     {
         string artworkPath = artwork.Path;
@@ -1028,6 +1134,8 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 .IfNone("[unknown artist]"),
             OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
                 .IfNone("[unknown video]"),
+            RemoteStream rs => rs.RemoteStreamMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
+                .IfNone("[unknown remote stream]"),
             _ => "[unknown]"
         };
     }
@@ -1076,7 +1184,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
     {
         var result = new List<PlayoutItem>();
 
-        if (_localFileSystem.FileExists(path))
+        if (_fileSystem.File.Exists(path))
         {
             Option<ExternalJsonChannel> maybeChannel = JsonConvert.DeserializeObject<ExternalJsonChannel>(
                 await File.ReadAllTextAsync(path));

ErsatzTV.Application/Channels/Commands/RefreshChannelListHandler.cs

@@ -1,4 +1,5 @@
 using System.Data.Common;
+using System.IO.Abstractions;
 using System.Net;
 using System.Xml;
 using Dapper;
@@ -19,6 +20,7 @@ namespace ErsatzTV.Application.Channels;
 public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IFileSystem _fileSystem;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<RefreshChannelListHandler> _logger;
     private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
@@ -26,11 +28,13 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
     public RefreshChannelListHandler(
         RecyclableMemoryStreamManager recyclableMemoryStreamManager,
         IDbContextFactory<TvContext> dbContextFactory,
+        IFileSystem fileSystem,
         ILocalFileSystem localFileSystem,
         ILogger<RefreshChannelListHandler> logger)
     {
         _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
         _dbContextFactory = dbContextFactory;
+        _fileSystem = fileSystem;
         _localFileSystem = localFileSystem;
         _logger = logger;
     }
@@ -44,13 +48,13 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
         string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "channel.sbntxt");
 
         // fall back to default template
-        if (!_localFileSystem.FileExists(templateFileName))
+        if (!_fileSystem.File.Exists(templateFileName))
         {
             templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_channel.sbntxt");
         }
 
         // fail if file doesn't exist
-        if (!_localFileSystem.FileExists(templateFileName))
+        if (!_fileSystem.File.Exists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate channel list without template file {File}; please restart ErsatzTV",

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -11,6 +11,7 @@ public record UpdateChannel(
     string Group,
     string Categories,
     int FFmpegProfileId,
+    double? SlugSeconds,
     ArtworkContentTypeModel Logo,
     ChannelStreamSelectorMode StreamSelectorMode,
     string StreamSelector,

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,4 +1,5 @@
-using System.Text.RegularExpressions;
+using System.Globalization;
+using System.Text.RegularExpressions;
 using System.Threading.Channels;
 using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
@@ -47,9 +48,11 @@ public class UpdateChannelHandler(
 
         c.Name = update.Name;
         c.Number = update.Number;
+        c.SortNumber = double.Parse(update.Number, CultureInfo.InvariantCulture);
         c.Group = update.Group;
         c.Categories = update.Categories;
         c.FFmpegProfileId = update.FFmpegProfileId;
+        c.SlugSeconds = update.SlugSeconds;
         c.StreamSelectorMode = update.StreamSelectorMode;
         c.StreamSelector = update.StreamSelector;
         c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbers.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Channels;
+
+public record UpdateChannelNumbers(List<ChannelSortViewModel> Channels) : IRequest<Option<BaseError>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbersHandler.cs

@@ -0,0 +1,72 @@
+using System.Globalization;
+using System.Threading.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Channel = ErsatzTV.Core.Domain.Channel;
+
+namespace ErsatzTV.Application.Channels;
+
+public class UpdateChannelNumbersHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    ChannelWriter<IBackgroundServiceRequest> workerChannel)
+    : IRequestHandler<UpdateChannelNumbers, Option<BaseError>>
+{
+    public async Task<Option<BaseError>> Handle(UpdateChannelNumbers request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken);
+
+        try
+        {
+            var numberUpdates = request.Channels.ToDictionary(c => c.Id, c => c.Number);
+            var channelIds = numberUpdates.Keys;
+
+            List<Channel> channelsToUpdate = await dbContext.Channels
+                .Where(c => channelIds.Contains(c.Id))
+                .ToListAsync(cancellationToken);
+
+            // give every channel a non-conflicting number
+            foreach (var channel in channelsToUpdate)
+            {
+                channel.Number = $"-{channel.Id}";
+            }
+
+            // save those changes
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            // give every channel the proper new number
+            foreach (var channel in channelsToUpdate)
+            {
+                channel.Number = numberUpdates[channel.Id];
+                if (double.TryParse(channel.Number, CultureInfo.InvariantCulture, out double sortNumber))
+                {
+                    channel.SortNumber = sortNumber;
+                }
+                else
+                {
+                    return BaseError.New($"Failed to parse channel number {channel.Number}");
+                }
+            }
+
+            // save those changes
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            // commit the transaction
+            await transaction.CommitAsync(cancellationToken);
+
+            // update channel list and xmltv
+            await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
+            foreach (var channel in channelsToUpdate)
+            {
+                await workerChannel.WriteAsync(new RefreshChannelData(channel.Number), cancellationToken);
+            }
+
+            return Option<BaseError>.None;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New("Failed to update channel numbers: " + ex.Message);
+        }
+    }
+}

ErsatzTV.Application/Channels/Mapper.cs

@@ -14,6 +14,7 @@ internal static class Mapper
             channel.Group,
             channel.Categories,
             channel.FFmpegProfileId,
+            channel.SlugSeconds,
             GetLogo(channel),
             channel.StreamSelectorMode,
             channel.StreamSelector,
@@ -49,8 +50,14 @@ internal static class Mapper
     internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
         new(resolution.Height, resolution.Width);
 
-    internal static ResolutionAndBitrateViewModel ProjectToViewModel(Resolution resolution, int bitrate) =>
-        new(resolution.Height, resolution.Width, bitrate);
+    internal static ChannelStreamingSpecsViewModel ProjectToSpecsViewModel(Channel channel) =>
+        new(
+            channel.FFmpegProfile.Resolution.Height,
+            channel.FFmpegProfile.Resolution.Width,
+            (int)((channel.FFmpegProfile.VideoBitrate * 1000 + channel.FFmpegProfile.AudioBitrate * 1000) * 1.2),
+            channel.FFmpegProfile.VideoFormat,
+            channel.FFmpegProfile.VideoProfile,
+            channel.FFmpegProfile.AudioFormat);
 
     private static ArtworkContentTypeModel GetLogo(Channel channel)
     {
@@ -75,7 +82,6 @@ internal static class Mapper
             StreamingMode.TransportStreamHybrid => "MPEG-TS",
             StreamingMode.HttpLiveStreamingDirect => "HLS Direct",
             StreamingMode.HttpLiveStreamingSegmenter => "HLS Segmenter",
-            StreamingMode.HttpLiveStreamingSegmenterV2 => "HLS Segmenter V2",
             _ => throw new ArgumentOutOfRangeException(nameof(channel))
         };
 }

ErsatzTV.Application/Channels/Queries/GetAllChannels.cs

@@ -1,3 +1,3 @@
 namespace ErsatzTV.Application.Channels;
 
-public record GetAllChannels : IRequest<List<ChannelViewModel>>;
+public record GetAllChannels(bool ShowDisabled = true) : IRequest<List<ChannelViewModel>>;

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForSort.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetAllChannelsForSort : IRequest<List<ChannelSortViewModel>>;

ErsatzTV.Application/Channels/Queries/GetAllChannelsForSortHandler.cs

@@ -0,0 +1,31 @@
+using System.Globalization;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetAllChannelsForSortHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllChannelsForSort, List<ChannelSortViewModel>>
+{
+    public async Task<List<ChannelSortViewModel>> Handle(
+        GetAllChannelsForSort request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Channels
+            .AsNoTracking()
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToSortViewModel)
+                .OrderBy(c => decimal.Parse(c.Number, CultureInfo.InvariantCulture)).ToList());
+    }
+
+    private static ChannelSortViewModel ProjectToSortViewModel(Channel channel)
+        => new()
+        {
+            Id = channel.Id,
+            Number = channel.Number,
+            Name = channel.Name,
+            OriginalNumber = channel.Number
+        };
+}

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

@@ -9,7 +9,8 @@ public class GetAllChannelsHandler(IChannelRepository channelRepository)
 {
     public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
         await channelRepository.GetAll(cancellationToken)
-            .Map(list => list.Map(c => ProjectToViewModel(c, GetPlayoutsCount(c))).ToList());
+            .Map(list => list.Where(c => c.IsEnabled || request.ShowDisabled)
+                .Map(c => ProjectToViewModel(c, GetPlayoutsCount(c))).ToList());
 
     private static int GetPlayoutsCount(Channel channel)
     {

ErsatzTV.Application/Channels/Queries/GetChannelByPlayoutId.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelByPlayoutId(int PlayoutId) : IRequest<Option<ChannelViewModel>>;

ErsatzTV.Application/Channels/Queries/GetChannelByPlayoutIdHandler.cs

@@ -0,0 +1,21 @@
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Channels.Mapper;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelByPlayoutId, Option<ChannelViewModel>>
+{
+    public async Task<Option<ChannelViewModel>> Handle(
+        GetChannelByPlayoutId request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Playouts
+            .Include(p => p.Channel)
+            .ThenInclude(c => c.Artwork)
+            .SingleOrDefaultAsync(p => p.Id == request.PlayoutId, cancellationToken)
+            .Map(p => ProjectToViewModel(p.Channel, 1));
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

@@ -1,3 +1,5 @@
-namespace ErsatzTV.Application.Channels;
+using ErsatzTV.FFmpeg;
 
-public record GetChannelFramerate(string ChannelNumber) : IRequest<Option<int>>;
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelFramerate(string ChannelNumber) : IRequest<Option<FrameRate>>;

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -1,29 +1,22 @@
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
+using ErsatzTV.FFmpeg;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, Option<int>>
+public class GetChannelFramerateHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    ILogger<GetChannelFramerateHandler> logger)
+    : IRequestHandler<GetChannelFramerate, Option<FrameRate>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ILogger<GetChannelFramerateHandler> _logger;
-
-    public GetChannelFramerateHandler(
-        IDbContextFactory<TvContext> dbContextFactory,
-        ILogger<GetChannelFramerateHandler> logger)
-    {
-        _dbContextFactory = dbContextFactory;
-        _logger = logger;
-    }
-
-    public async Task<Option<int>> Handle(GetChannelFramerate request, CancellationToken cancellationToken)
+    public async Task<Option<FrameRate>> Handle(GetChannelFramerate request, CancellationToken cancellationToken)
     {
         try
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
 
             FFmpegProfile ffmpegProfile = await dbContext.Channels
                 .AsNoTracking()
@@ -34,11 +27,11 @@ public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, O
 
             if (!ffmpegProfile.NormalizeFramerate)
             {
-                return Option<int>.None;
+                return Option<FrameRate>.None;
             }
 
             // TODO: expand to check everything in collection rather than what's scheduled?
-            _logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
+            logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
 
             List<Playout> playouts = await dbContext.Playouts
                 .AsNoTracking()
@@ -68,51 +61,53 @@ public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, O
 
             var frameRates = playouts.Map(p => p.Items.Map(i => i.MediaItem.GetHeadVersion()))
                 .Flatten()
-                .Map(mv => mv.RFrameRate)
+                .Map(mv => new FrameRate(mv.RFrameRate))
                 .ToList();
 
             var distinct = frameRates.Distinct().ToList();
             if (distinct.Count > 1)
             {
                 // TODO: something more intelligent than minimum framerate?
-                int result = frameRates.Map(ParseFrameRate).Min();
-                if (result < 24)
+                var validFrameRates = frameRates.Where(fr => fr.ParsedFrameRate > 23).ToList();
+                if (validFrameRates.Count > 0)
                 {
-                    _logger.LogInformation(
-                        "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate} instead of min value {MinFrameRate}",
+                    FrameRate result = validFrameRates.MinBy(fr => fr.ParsedFrameRate);
+                    logger.LogInformation(
+                        "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
                         request.ChannelNumber,
-                        distinct,
-                        24,
-                        result);
-
-                    return 24;
+                        distinct.Map(fr => fr.RFrameRate),
+                        result.RFrameRate);
+                    return result;
                 }
 
-                _logger.LogInformation(
-                    "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
+                FrameRate minFrameRate = frameRates.MinBy(fr => fr.ParsedFrameRate);
+                logger.LogInformation(
+                    "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate} instead of min value {MinFrameRate}",
                     request.ChannelNumber,
-                    distinct,
-                    result);
-                return result;
+                    distinct.Map(fr => fr.RFrameRate),
+                    FrameRate.DefaultFrameRate.RFrameRate,
+                    minFrameRate.RFrameRate);
+
+                return FrameRate.DefaultFrameRate;
             }
 
             if (distinct.Count != 0)
             {
-                _logger.LogInformation(
+                logger.LogInformation(
                     "All content on channel {ChannelNumber} has the same frame rate of {FrameRate}; will not normalize",
                     request.ChannelNumber,
-                    distinct[0]);
+                    distinct[0].RFrameRate);
             }
             else
             {
-                _logger.LogInformation(
+                logger.LogInformation(
                     "No content on channel {ChannelNumber} has frame rate information; will not normalize",
                     request.ChannelNumber);
             }
         }
         catch (Exception ex)
         {
-            _logger.LogWarning(
+            logger.LogWarning(
                 ex,
                 "Unexpected error checking frame rates on channel {ChannelNumber}",
                 request.ChannelNumber);
@@ -120,22 +115,4 @@ public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, O
 
         return None;
     }
-
-    private int ParseFrameRate(string frameRate)
-    {
-        if (!int.TryParse(frameRate, out int fr))
-        {
-            string[] split = (frameRate ?? string.Empty).Split("/");
-            if (int.TryParse(split[0], out int left) && int.TryParse(split[1], out int right))
-            {
-                fr = (int)Math.Round(left / (double)right);
-            }
-            else
-            {
-                fr = 24;
-            }
-        }
-
-        return fr;
-    }
 }

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

@@ -1,5 +1,7 @@
 using System.Collections.Immutable;
+using System.IO.Abstractions;
 using System.Text;
+using System.Text.RegularExpressions;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Iptv;
@@ -9,27 +11,18 @@ using Microsoft.IO;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<BaseError, ChannelGuide>>
+public partial class GetChannelGuideHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    RecyclableMemoryStreamManager recyclableMemoryStreamManager,
+    IFileSystem fileSystem,
+    ILocalFileSystem localFileSystem)
+    : IRequestHandler<GetChannelGuide, Either<BaseError, ChannelGuide>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ILocalFileSystem _localFileSystem;
-    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
-
-    public GetChannelGuideHandler(
-        IDbContextFactory<TvContext> dbContextFactory,
-        RecyclableMemoryStreamManager recyclableMemoryStreamManager,
-        ILocalFileSystem localFileSystem)
-    {
-        _dbContextFactory = dbContextFactory;
-        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
-        _localFileSystem = localFileSystem;
-    }
-
     public async Task<Either<BaseError, ChannelGuide>> Handle(
         GetChannelGuide request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         var hiddenChannelNumbers = dbContext.Channels
             .Where(c => c.ShowInEpg == false)
             .Select(c => c.Number)
@@ -37,13 +30,13 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<Ba
             .Select(n => $"{n}.xml")
             .ToImmutableHashSet();
 
-        string channelsFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
-        if (!_localFileSystem.FileExists(channelsFile))
+        string channelsFile = fileSystem.Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
+        if (!fileSystem.File.Exists(channelsFile))
         {
             return BaseError.New($"Required file {channelsFile} is missing");
         }
 
-        long mtime = File.GetLastWriteTime(channelsFile).Ticks;
+        long mtime = fileSystem.File.GetLastWriteTime(channelsFile).Ticks;
 
         var accessTokenUri = $"?v={mtime}";
         if (!string.IsNullOrWhiteSpace(request.AccessToken))
@@ -51,7 +44,7 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<Ba
             accessTokenUri += $"&amp;access_token={request.AccessToken}";
         }
 
-        string channelsFragment = await File.ReadAllTextAsync(channelsFile, Encoding.UTF8, cancellationToken);
+        string channelsFragment = await ReadAllTextShared(channelsFile, cancellationToken);
 
         // TODO: is regex faster?
         channelsFragment = channelsFragment
@@ -60,27 +53,54 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<Ba
 
         var channelDataFragments = new Dictionary<string, string>();
 
-        foreach (string fileName in _localFileSystem.ListFiles(FileSystemLayout.ChannelGuideCacheFolder))
+        foreach (string fileName in localFileSystem.ListFiles(FileSystemLayout.ChannelGuideCacheFolder))
         {
             if (fileName.Contains("channels"))
             {
                 continue;
             }
 
-            if (hiddenChannelNumbers.Contains(Path.GetFileName(fileName)))
+            if (hiddenChannelNumbers.Contains(fileSystem.Path.GetFileName(fileName)))
             {
                 continue;
             }
 
-            string channelDataFragment = await File.ReadAllTextAsync(fileName, Encoding.UTF8, cancellationToken);
+            try
+            {
+                string channelDataFragment = await ReadAllTextShared(fileName, cancellationToken);
 
-            channelDataFragment = channelDataFragment
-                .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
-                .Replace("{AccessTokenUri}", accessTokenUri);
+                channelDataFragment = channelDataFragment
+                    .Replace("{RequestBase}", $"{request.Scheme}://{request.Host}{request.BaseUrl}")
+                    .Replace("{AccessTokenUri}", accessTokenUri);
 
-            channelDataFragments.Add(Path.GetFileNameWithoutExtension(fileName), channelDataFragment);
+                channelDataFragment = EtvTagRegex().Replace(channelDataFragment, string.Empty);
+
+                channelDataFragments.Add(fileSystem.Path.GetFileNameWithoutExtension(fileName), channelDataFragment);
+            }
+            catch (FileNotFoundException)
+            {
+                // ignore this channel fragment
+            }
+            catch (IOException)
+            {
+                // ignore this channel fragment
+            }
         }
 
-        return new ChannelGuide(_recyclableMemoryStreamManager, channelsFragment, channelDataFragments);
+        return new ChannelGuide(recyclableMemoryStreamManager, channelsFragment, channelDataFragments);
     }
+
+    private async Task<string> ReadAllTextShared(string fileName, CancellationToken cancellationToken)
+    {
+        await using var stream = fileSystem.FileStream.New(
+            fileName,
+            FileMode.Open,
+            FileAccess.Read,
+            FileShare.ReadWrite);
+        using var reader = new StreamReader(stream, Encoding.UTF8, leaveOpen: true);
+        return await reader.ReadToEndAsync(cancellationToken);
+    }
+
+    [GeneratedRegex(@"<etv:[^>]+?>.*?<\/etv:[^>]+?>|<etv:[^>]+?\/>", RegexOptions.Singleline)]
+    private static partial Regex EtvTagRegex();
 }

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

@@ -4,16 +4,12 @@ using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelNameByPlayoutIdHandler : IRequestHandler<GetChannelNameByPlayoutId, Option<string>>
+public class GetChannelNameByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelNameByPlayoutId, Option<string>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-    public GetChannelNameByPlayoutIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-        _dbContextFactory = dbContextFactory;
-
     public async Task<Option<string>> Handle(GetChannelNameByPlayoutId request, CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         return await dbContext.Playouts
             .Include(p => p.Channel)
             .SelectOneAsync(p => p.Id, p => p.Id == request.PlayoutId, cancellationToken)

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -4,15 +4,11 @@ using ErsatzTV.Core.Iptv;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
+public class GetChannelPlaylistHandler(IChannelRepository channelRepository)
+    : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
 {
-    private readonly IChannelRepository _channelRepository;
-
-    public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
-        _channelRepository = channelRepository;
-
     public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
-        _channelRepository.GetAll(cancellationToken)
+        channelRepository.GetAll(cancellationToken)
             .Map(channels => EnsureMode(channels, request.Mode))
             .Map(channels => new ChannelPlaylist(
                 request.Scheme,
@@ -38,10 +34,6 @@ public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, Cha
                     channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenter;
                     result.Add(channel);
                     break;
-                case "segmenter-v2":
-                    channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenterV2;
-                    result.Add(channel);
-                    break;
                 case "hls-direct":
                     channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
                     result.Add(channel);

ErsatzTV.Application/Channels/Queries/GetChannelResolutionAndBitrate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelStreamingSpecs.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelStreamingSpecsHandler.cs

@@ -5,11 +5,11 @@ using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelResolutionAndBitrateHandler(IDbContextFactory<TvContext> dbContextFactory)
-    : IRequestHandler<GetChannelResolutionAndBitrate, Option<ResolutionAndBitrateViewModel>>
+public class GetChannelStreamingSpecsHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelStreamingSpecs, Option<ChannelStreamingSpecsViewModel>>
 {
-    public async Task<Option<ResolutionAndBitrateViewModel>> Handle(
-        GetChannelResolutionAndBitrate request,
+    public async Task<Option<ChannelStreamingSpecsViewModel>> Handle(
+        GetChannelStreamingSpecs request,
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
@@ -20,8 +20,6 @@ public class GetChannelResolutionAndBitrateHandler(IDbContextFactory<TvContext>
             .ThenInclude(ff => ff.Resolution)
             .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber, cancellationToken);
 
-        return maybeChannel.Map(c => Mapper.ProjectToViewModel(
-            c.FFmpegProfile.Resolution,
-            (int)((c.FFmpegProfile.VideoBitrate * 1000 + c.FFmpegProfile.AudioBitrate * 1000) * 1.2)));
+        return maybeChannel.Map(Mapper.ProjectToSpecsViewModel);
     }
 }

ErsatzTV.Application/Channels/Queries/GetSlugSecondsByChannelNumber.cs

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

ErsatzTV.Application/Channels/Queries/GetSlugSecondsByChannelNumberHandler.cs

@@ -0,0 +1,17 @@
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetSlugSecondsByChannelNumberHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetSlugSecondsByChannelNumber, Option<double>>
+{
+    public async Task<Option<double>> Handle(GetSlugSecondsByChannelNumber request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Channels
+            .AsNoTracking()
+            .SingleOrDefaultAsync(c => c.Number == request.ChannelNumber, cancellationToken)
+            .Map(c => Optional(c?.SlugSeconds));
+    }
+}

ErsatzTV.Application/Channels/ResolutionAndBitrateViewModel.cs

@@ -1,3 +0,0 @@
-namespace ErsatzTV.Application.Channels;
-
-public record ResolutionAndBitrateViewModel(int Height, int Width, int Bitrate);

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -26,6 +26,6 @@ public class UpdateLibraryRefreshIntervalHandler :
         Optional(request.LibraryRefreshInterval)
             .Where(lri => lri is >= 0 and < 1_000_000)
             .Map(_ => Unit.Default)
-            .ToValidation<BaseError>("Library refresh interval must be zero or greated")
+            .ToValidation<BaseError>("Library refresh interval must be zero or greater")
             .AsTask();
 }

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

@@ -32,15 +32,31 @@ public class UpdatePlayoutSettingsHandler : IRequestHandler<UpdatePlayoutSetting
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Unit> validation = await Validate(request);
-        return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(dbContext, request.PlayoutSettings, cancellationToken));
+        return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(
+            dbContext,
+            request.PlayoutSettings,
+            cancellationToken));
     }
 
-    private async Task<Unit> ApplyUpdate(TvContext dbContext, PlayoutSettingsViewModel playoutSettings, CancellationToken cancellationToken)
+    private async Task<Unit> ApplyUpdate(
+        TvContext dbContext,
+        PlayoutSettingsViewModel playoutSettings,
+        CancellationToken cancellationToken)
     {
-        await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, playoutSettings.DaysToBuild, cancellationToken);
+        await _configElementRepository.Upsert(
+            ConfigElementKey.PlayoutDaysToBuild,
+            playoutSettings.DaysToBuild,
+            cancellationToken);
+
         await _configElementRepository.Upsert(
             ConfigElementKey.PlayoutSkipMissingItems,
-            playoutSettings.SkipMissingItems, cancellationToken);
+            playoutSettings.SkipMissingItems,
+            cancellationToken);
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.PlayoutScriptedScheduleTimeoutSeconds,
+            playoutSettings.ScriptedScheduleTimeoutSeconds,
+            cancellationToken);
 
         // continue all playouts to proper number of days
         List<Playout> playouts = await dbContext.Playouts

ErsatzTV.Application/Configuration/Commands/UpdateUiSettings.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Configuration;
+
+public record UpdateUiSettings(UiSettingsViewModel UiSettings) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Configuration/Commands/UpdateUiSettingsHandler.cs

@@ -0,0 +1,28 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateUiSettingsHandler(IConfigElementRepository configElementRepository)
+    : IRequestHandler<UpdateUiSettings, Either<BaseError, Unit>>
+{
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateUiSettings request,
+        CancellationToken cancellationToken)
+    {
+        return await ApplyUpdate(request.UiSettings, cancellationToken);
+    }
+
+    private async Task<Unit> ApplyUpdate(UiSettingsViewModel uiSettings, CancellationToken cancellationToken)
+    {
+        await configElementRepository.Upsert(
+            ConfigElementKey.PagesIsDarkMode,
+            uiSettings.IsDarkMode,
+            cancellationToken);
+
+        await configElementRepository.Upsert(ConfigElementKey.PagesLanguage, uiSettings.Language, cancellationToken);
+
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Configuration/PlayoutSettingsViewModel.cs

@@ -4,4 +4,5 @@ public class PlayoutSettingsViewModel
 {
     public int DaysToBuild { get; set; }
     public bool SkipMissingItems { get; set; }
+    public int ScriptedScheduleTimeoutSeconds { get; set; }
 }

ErsatzTV.Application/Configuration/Queries/GetMpegTsScripts.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.FFmpeg;
+
+namespace ErsatzTV.Application.Configuration;
+
+public record GetMpegTsScripts : IRequest<List<MpegTsScript>>;

ErsatzTV.Application/Configuration/Queries/GetMpegTsScriptsHandler.cs

@@ -0,0 +1,14 @@
+using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetMpegTsScriptsHandler(IMpegTsScriptService mpegTsScriptService)
+    : IRequestHandler<GetMpegTsScripts, List<MpegTsScript>>
+{
+    public async Task<List<MpegTsScript>> Handle(GetMpegTsScripts request, CancellationToken cancellationToken)
+    {
+        await mpegTsScriptService.RefreshScripts();
+        return mpegTsScriptService.GetScripts().OrderBy(x => x.Name).ToList();
+    }
+}

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettingsHandler.cs

@@ -19,10 +19,16 @@ public class GetPlayoutSettingsHandler : IRequestHandler<GetPlayoutSettings, Pla
         Option<bool> skipMissingItems =
             await _configElementRepository.GetValue<bool>(ConfigElementKey.PlayoutSkipMissingItems, cancellationToken);
 
+        Option<int> scriptedScheduleTimeoutSeconds =
+            await _configElementRepository.GetValue<int>(
+                ConfigElementKey.PlayoutScriptedScheduleTimeoutSeconds,
+                cancellationToken);
+
         return new PlayoutSettingsViewModel
         {
             DaysToBuild = await daysToBuild.IfNoneAsync(2),
-            SkipMissingItems = await skipMissingItems.IfNoneAsync(false)
+            SkipMissingItems = await skipMissingItems.IfNoneAsync(false),
+            ScriptedScheduleTimeoutSeconds = await scriptedScheduleTimeoutSeconds.IfNoneAsync(30)
         };
     }
 }

ErsatzTV.Application/Configuration/Queries/GetUiSettings.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.Configuration;
+
+public record GetUiSettings : IRequest<UiSettingsViewModel>;

ErsatzTV.Application/Configuration/Queries/GetUiSettingsHandler.cs

@@ -0,0 +1,25 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetUiSettingsHandler(IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetUiSettings, UiSettingsViewModel>
+{
+    public async Task<UiSettingsViewModel> Handle(GetUiSettings request, CancellationToken cancellationToken)
+    {
+        Option<bool> pagesIsDarkMode = await configElementRepository.GetValue<bool>(
+            ConfigElementKey.PagesIsDarkMode,
+            cancellationToken);
+
+        Option<string> pagesLanguage = await configElementRepository.GetValue<string>(
+            ConfigElementKey.PagesLanguage,
+            cancellationToken);
+
+        return new UiSettingsViewModel
+        {
+            IsDarkMode = await pagesIsDarkMode.IfNoneAsync(true),
+            Language = await pagesLanguage.IfNoneAsync("en")
+        };
+    }
+}

ErsatzTV.Application/Configuration/UiSettingsViewModel.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Application.Configuration;
+
+public class UiSettingsViewModel
+{
+    public bool IsDarkMode { get; set; }
+
+    public string Language { get; set; }
+}

ErsatzTV.Application/Emby/Commands/CallEmbyCollectionScannerHandler.cs

@@ -1,34 +1,43 @@
 using System.Globalization;
-using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
 using ErsatzTV.FFmpeg.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Emby;
 
 public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<SynchronizeEmbyCollections>,
     IRequestHandler<SynchronizeEmbyCollections, Either<BaseError, Unit>>
 {
+    private readonly IScannerProxyService _scannerProxyService;
+
     public CallEmbyCollectionScannerHandler(
         IDbContextFactory<TvContext> dbContextFactory,
         IConfigElementRepository configElementRepository,
-        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
-        IMediator mediator,
-        IRuntimeInfo runtimeInfo) : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+        IScannerProxyService scannerProxyService,
+        IRuntimeInfo runtimeInfo,
+        ILogger<CallEmbyCollectionScannerHandler> logger) : base(
+        dbContextFactory,
+        configElementRepository,
+        runtimeInfo,
+        logger)
     {
+        _scannerProxyService = scannerProxyService;
     }
 
     public async Task<Either<BaseError, Unit>>
         Handle(SynchronizeEmbyCollections request, CancellationToken cancellationToken)
     {
-        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
+        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
         return await validation.Match(
-            scanner => PerformScan(scanner, request, cancellationToken),
+            parameters => PerformScan(parameters, request, cancellationToken),
             error =>
             {
                 foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
@@ -40,7 +49,7 @@ public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<Synchr
             });
     }
 
-    protected override async Task<DateTimeOffset> GetLastScan(
+    protected override async Task<Tuple<string, DateTimeOffset>> GetLastScan(
         TvContext dbContext,
         SynchronizeEmbyCollections request,
         CancellationToken cancellationToken)
@@ -49,7 +58,7 @@ public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<Synchr
             .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyMediaSourceId, cancellationToken)
             .Match(l => l.LastCollectionsScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
 
-        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
+        return new Tuple<string, DateTimeOffset>(string.Empty, new DateTimeOffset(minDateTime, TimeSpan.Zero));
     }
 
     protected override bool ScanIsRequired(
@@ -67,20 +76,40 @@ public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<Synchr
     }
 
     private async Task<Either<BaseError, Unit>> PerformScan(
-        string scanner,
+        ScanParameters parameters,
         SynchronizeEmbyCollections request,
         CancellationToken cancellationToken)
     {
-        var arguments = new List<string>
+        Option<Guid> maybeScanId = _scannerProxyService.StartScan(FakeLibraryId.EmbyCollections);
+        foreach (var scanId in maybeScanId)
         {
-            "scan-emby-collections", request.EmbyMediaSourceId.ToString(CultureInfo.InvariantCulture)
-        };
+            try
+            {
+                var arguments = new List<string>
+                {
+                    "scan-emby-collections",
+                    request.EmbyMediaSourceId.ToString(CultureInfo.InvariantCulture),
+                    GetBaseUrl(scanId)
+                };
 
-        if (request.ForceScan)
-        {
-            arguments.Add("--force");
+                if (request.ForceScan)
+                {
+                    arguments.Add("--force");
+                }
+
+                if (request.DeepScan)
+                {
+                    arguments.Add("--deep");
+                }
+
+                return await base.PerformScan(parameters, arguments, cancellationToken).MapT(_ => Unit.Default);
+            }
+            finally
+            {
+                _scannerProxyService.EndScan(scanId);
+            }
         }
 
-        return await base.PerformScan(scanner, arguments, cancellationToken).MapT(_ => Unit.Default);
+        return BaseError.New("Emby collections are already scanning");
     }
 }

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

@@ -1,13 +1,15 @@
 using System.Globalization;
-using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.FFmpeg.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Emby;
 
@@ -15,14 +17,17 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
     IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
     IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
 {
+    private readonly IScannerProxyService _scannerProxyService;
+
     public CallEmbyLibraryScannerHandler(
         IDbContextFactory<TvContext> dbContextFactory,
         IConfigElementRepository configElementRepository,
-        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
-        IMediator mediator,
-        IRuntimeInfo runtimeInfo)
-        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+        IScannerProxyService scannerProxyService,
+        IRuntimeInfo runtimeInfo,
+        ILogger<CallEmbyLibraryScannerHandler> logger)
+        : base(dbContextFactory, configElementRepository, runtimeInfo, logger)
     {
+        _scannerProxyService = scannerProxyService;
     }
 
     Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>.Handle(
@@ -38,9 +43,9 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
         ISynchronizeEmbyLibraryById request,
         CancellationToken cancellationToken)
     {
-        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
+        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
         return await validation.Match(
-            scanner => PerformScan(scanner, request, cancellationToken),
+            parameters => PerformScan(parameters, request, cancellationToken),
             error =>
             {
                 foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
@@ -53,38 +58,58 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
     }
 
     private async Task<Either<BaseError, string>> PerformScan(
-        string scanner,
+        ScanParameters parameters,
         ISynchronizeEmbyLibraryById request,
         CancellationToken cancellationToken)
     {
-        var arguments = new List<string>
+        Option<Guid> maybeScanId = _scannerProxyService.StartScan(request.EmbyLibraryId);
+        foreach (var scanId in maybeScanId)
         {
-            "scan-emby", request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture)
-        };
+            try
+            {
+                var arguments = new List<string>
+                {
+                    "scan-emby",
+                    request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture),
+                    GetBaseUrl(scanId)
+                };
 
-        if (request.ForceScan)
-        {
-            arguments.Add("--force");
+                if (request.ForceScan)
+                {
+                    arguments.Add("--force");
+                }
+
+                if (request.DeepScan)
+                {
+                    arguments.Add("--deep");
+                }
+
+                return await base.PerformScan(parameters, arguments, cancellationToken);
+            }
+            finally
+            {
+                _scannerProxyService.EndScan(scanId);
+            }
         }
 
-        if (request.DeepScan)
-        {
-            arguments.Add("--deep");
-        }
-
-        return await base.PerformScan(scanner, arguments, cancellationToken);
+        return BaseError.New($"Library {request.EmbyLibraryId} is already scanning");
     }
 
-    protected override async Task<DateTimeOffset> GetLastScan(
+    protected override async Task<Tuple<string, DateTimeOffset>> GetLastScan(
         TvContext dbContext,
         ISynchronizeEmbyLibraryById request,
         CancellationToken cancellationToken)
     {
-        DateTime minDateTime = await dbContext.EmbyLibraries
-            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId, cancellationToken)
-            .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
+        Option<EmbyLibrary> maybeLibrary = await dbContext.EmbyLibraries
+            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId, cancellationToken);
 
-        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
+        DateTime minDateTime = maybeLibrary.Match(
+            l => l.LastScan ?? SystemTime.MinValueUtc,
+            () => SystemTime.MaxValueUtc);
+
+        string libraryName = maybeLibrary.Match(l => l.Name, string.Empty);
+
+        return new Tuple<string, DateTimeOffset>(libraryName, new DateTimeOffset(minDateTime, TimeSpan.Zero));
     }
 
     protected override bool ScanIsRequired(

ErsatzTV.Application/Emby/Commands/CallEmbyShowScannerHandler.cs

@@ -1,26 +1,30 @@
 using System.Globalization;
-using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.FFmpeg.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Emby;
 
 public class CallEmbyShowScannerHandler : CallLibraryScannerHandler<SynchronizeEmbyShowById>,
     IRequestHandler<SynchronizeEmbyShowById, Either<BaseError, string>>
 {
+    private readonly IScannerProxyService _scannerProxyService;
+
     public CallEmbyShowScannerHandler(
         IDbContextFactory<TvContext> dbContextFactory,
         IConfigElementRepository configElementRepository,
-        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
-        IMediator mediator,
-        IRuntimeInfo runtimeInfo)
-        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+        IScannerProxyService scannerProxyService,
+        IRuntimeInfo runtimeInfo,
+        ILogger<CallEmbyShowScannerHandler> logger)
+        : base(dbContextFactory, configElementRepository, runtimeInfo, logger)
     {
+        _scannerProxyService = scannerProxyService;
     }
 
     Task<Either<BaseError, string>> IRequestHandler<SynchronizeEmbyShowById, Either<BaseError, string>>.Handle(
@@ -31,9 +35,9 @@ public class CallEmbyShowScannerHandler : CallLibraryScannerHandler<SynchronizeE
         SynchronizeEmbyShowById request,
         CancellationToken cancellationToken)
     {
-        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
+        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
         return await validation.Match(
-            scanner => PerformScan(scanner, request, cancellationToken),
+            parameters => PerformScan(parameters, request, cancellationToken),
             error =>
             {
                 foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
@@ -46,30 +50,44 @@ public class CallEmbyShowScannerHandler : CallLibraryScannerHandler<SynchronizeE
     }
 
     private async Task<Either<BaseError, string>> PerformScan(
-        string scanner,
+        ScanParameters parameters,
         SynchronizeEmbyShowById request,
         CancellationToken cancellationToken)
     {
-        var arguments = new List<string>
+        Option<Guid> maybeScanId = _scannerProxyService.StartScan(request.EmbyLibraryId);
+        foreach (var scanId in maybeScanId)
         {
-            "scan-emby-show",
-            request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture),
-            request.ShowId.ToString(CultureInfo.InvariantCulture)
-        };
+            try
+            {
+                var arguments = new List<string>
+                {
+                    "scan-emby-show",
+                    request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture),
+                    request.ShowId.ToString(CultureInfo.InvariantCulture),
+                    GetBaseUrl(scanId)
+                };
 
-        if (request.DeepScan)
-        {
-            arguments.Add("--deep");
+                if (request.DeepScan)
+                {
+                    arguments.Add("--deep");
+                }
+
+                return await base.PerformScan(parameters, arguments, cancellationToken);
+            }
+            finally
+            {
+                _scannerProxyService.EndScan(scanId);
+            }
         }
 
-        return await base.PerformScan(scanner, arguments, cancellationToken);
+        return BaseError.New($"Library {request.EmbyLibraryId} is already scanning");
     }
 
-    protected override Task<DateTimeOffset> GetLastScan(
+    protected override Task<Tuple<string, DateTimeOffset>> GetLastScan(
         TvContext dbContext,
         SynchronizeEmbyShowById request,
         CancellationToken cancellationToken) =>
-        Task.FromResult(DateTimeOffset.MinValue);
+        Task.FromResult(new Tuple<string, DateTimeOffset>(string.Empty, DateTimeOffset.MinValue));
 
     protected override bool ScanIsRequired(
         DateTimeOffset lastScan,

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Core;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace ErsatzTV.Application.Emby;
 
@@ -12,16 +13,19 @@ public class SaveEmbySecretsHandler : IRequestHandler<SaveEmbySecrets, Either<Ba
     private readonly IEmbyApiClient _embyApiClient;
     private readonly IEmbySecretStore _embySecretStore;
     private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMemoryCache _memoryCache;
 
     public SaveEmbySecretsHandler(
         IEmbySecretStore embySecretStore,
         IEmbyApiClient embyApiClient,
         IMediaSourceRepository mediaSourceRepository,
+        IMemoryCache memoryCache,
         ChannelWriter<IEmbyBackgroundServiceRequest> channel)
     {
         _embySecretStore = embySecretStore;
         _embyApiClient = embyApiClient;
         _mediaSourceRepository = mediaSourceRepository;
+        _memoryCache = memoryCache;
         _channel = channel;
     }
 
@@ -47,6 +51,7 @@ public class SaveEmbySecretsHandler : IRequestHandler<SaveEmbySecrets, Either<Ba
             parameters.Secrets.Address,
             parameters.ServerInformation.ServerName,
             parameters.ServerInformation.OperatingSystem);
+        _memoryCache.Remove(new GetEmbyConnectionParameters());
         await _channel.WriteAsync(new SynchronizeEmbyMediaSources());
 
         return Unit.Default;

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyCollections.cs

@@ -2,5 +2,6 @@ using ErsatzTV.Core;
 
 namespace ErsatzTV.Application.Emby;
 
-public record SynchronizeEmbyCollections(int EmbyMediaSourceId, bool ForceScan) : IRequest<Either<BaseError, Unit>>,
-    IScannerBackgroundServiceRequest;
+public record SynchronizeEmbyCollections(int EmbyMediaSourceId, bool ForceScan, bool DeepScan)
+    : IRequest<Either<BaseError, Unit>>,
+        IScannerBackgroundServiceRequest;

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,27 +1,24 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
-        <NoWarn>VSTHRD200</NoWarn>
+        <TargetFramework>net10.0</TargetFramework>
+        <NoWarn>VSTHRD200,CA1873</NoWarn>
         <ImplicitUsings>enable</ImplicitUsings>
         <AnalysisLevel>latest-Recommended</AnalysisLevel>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <Configurations>Debug;Release;Debug No Sync</Configurations>
     </PropertyGroup>
 
     <ItemGroup>
         <PackageReference Include="Bugsnag" Version="4.1.0" />
-        <PackageReference Include="CliWrap" Version="3.9.0" />
-        <PackageReference Include="Humanizer.Core" Version="2.14.1" />
+        <PackageReference Include="CliWrap" Version="3.10.0" />
+        <PackageReference Include="Humanizer.Core" Version="3.0.1" />
         <PackageReference Include="MediatR" Version="[12.5.0]" />
-        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.9" />
-        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.9" />
-        <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.14.15">
-            <PrivateAssets>all</PrivateAssets>
-            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-        </PackageReference>
-        <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.2" />
+        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.2" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
         <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
-        <PackageReference Include="WebMarkupMin.Core" Version="2.19.0" />
+        <PackageReference Include="WebMarkupMin.Core" Version="2.20.1" />
         <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
     </ItemGroup>
 

ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings

@@ -9,6 +9,7 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=emby_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpeg_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=filler_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=filler_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=graphics_005Ccommands/@EntryIndexedValue">True</s:Boolean>

ErsatzTV.Application/FFmpeg/Commands/RefreshFFmpegCapabilities.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Application.FFmpeg;
+
+public record RefreshFFmpegCapabilities : IRequest, IBackgroundServiceRequest;

ErsatzTV.Application/FFmpeg/Commands/RefreshFFmpegCapabilitiesHandler.cs

@@ -0,0 +1,45 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.FFmpeg.Capabilities;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.FFmpeg;
+
+public class RefreshFFmpegCapabilitiesHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IHardwareCapabilitiesFactory hardwareCapabilitiesFactory,
+    ILocalStatisticsProvider localStatisticsProvider)
+    : IRequestHandler<RefreshFFmpegCapabilities>
+{
+    public async Task Handle(RefreshFFmpegCapabilities request, CancellationToken cancellationToken)
+    {
+        hardwareCapabilitiesFactory.ClearCache();
+
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        Option<string> maybeFFmpegPath = await dbContext.ConfigElements
+            .GetValue<string>(ConfigElementKey.FFmpegPath, cancellationToken)
+            .FilterT(File.Exists);
+
+        foreach (string ffmpegPath in maybeFFmpegPath)
+        {
+            _ = await hardwareCapabilitiesFactory.GetFFmpegCapabilities(ffmpegPath, cancellationToken);
+
+            Option<string> maybeFFprobePath = await dbContext.ConfigElements
+                .GetValue<string>(ConfigElementKey.FFprobePath, cancellationToken)
+                .FilterT(File.Exists);
+
+            foreach (string ffprobePath in maybeFFprobePath)
+            {
+                Either<BaseError, MediaVersion> result = await localStatisticsProvider.GetStatistics(
+                    ffprobePath,
+                    Path.Combine(FileSystemLayout.ResourcesCacheFolder, "test.avs"));
+
+                hardwareCapabilitiesFactory.SetAviSynthInstalled(result.IsRight);
+            }
+        }
+    }
+}

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -7,6 +7,8 @@ namespace ErsatzTV.Application.FFmpegProfiles;
 public record CreateFFmpegProfile(
     string Name,
     int ThreadCount,
+    bool NormalizeAudio,
+    bool NormalizeVideo,
     HardwareAccelerationKind HardwareAcceleration,
     string VaapiDisplay,
     VaapiDriver VaapiDriver,
@@ -14,6 +16,7 @@ public record CreateFFmpegProfile(
     int? QsvExtraHardwareFrames,
     int ResolutionId,
     ScalingBehavior ScalingBehavior,
+    FilterMode PadMode,
     FFmpegProfileVideoFormat VideoFormat,
     string VideoProfile,
     string VideoPreset,
@@ -26,7 +29,9 @@ public record CreateFFmpegProfile(
     int AudioBitrate,
     int AudioBufferSize,
     NormalizeLoudnessMode NormalizeLoudnessMode,
+    double? TargetLoudness,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,
+    bool NormalizeColors,
     bool DeinterlaceVideo) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -44,37 +44,63 @@ public class CreateFFmpegProfileHandler :
         CancellationToken cancellationToken) =>
         (ValidateName(request), ValidateThreadCount(request),
             await ResolutionMustExist(dbContext, request, cancellationToken))
-        .Apply((name, threadCount, resolutionId) => new FFmpegProfile
+        .Apply((name, threadCount, resolutionId) =>
         {
-            Name = name,
-            ThreadCount = threadCount,
-            HardwareAcceleration = request.HardwareAcceleration,
-            VaapiDriver = request.VaapiDriver,
-            VaapiDevice = request.VaapiDevice,
-            QsvExtraHardwareFrames = request.QsvExtraHardwareFrames,
-            ResolutionId = resolutionId,
-            ScalingBehavior = request.ScalingBehavior,
-            VideoFormat = request.VideoFormat,
-            VideoProfile = request.VideoProfile,
-            VideoPreset = request.VideoPreset,
-            AllowBFrames = request.AllowBFrames,
+            var hwAccel = request.NormalizeVideo
+                ? request.HardwareAcceleration
+                : HardwareAccelerationKind.None;
 
-            // mpeg2video only supports 8-bit content
-            BitDepth = request.VideoFormat is FFmpegProfileVideoFormat.Mpeg2Video
-                ? FFmpegProfileBitDepth.EightBit
-                : request.BitDepth,
+            return new FFmpegProfile
+            {
+                Name = name,
+                ThreadCount = threadCount,
 
-            VideoBitrate = request.VideoBitrate,
-            VideoBufferSize = request.VideoBufferSize,
-            TonemapAlgorithm = request.TonemapAlgorithm,
-            AudioFormat = request.AudioFormat,
-            AudioBitrate = request.AudioBitrate,
-            AudioBufferSize = request.AudioBufferSize,
-            NormalizeLoudnessMode = request.NormalizeLoudnessMode,
-            AudioChannels = request.AudioChannels,
-            AudioSampleRate = request.AudioSampleRate,
-            NormalizeFramerate = request.NormalizeFramerate,
-            DeinterlaceVideo = request.DeinterlaceVideo
+                NormalizeAudio = request.NormalizeAudio,
+                NormalizeVideo = request.NormalizeVideo,
+
+                HardwareAcceleration = hwAccel,
+                VaapiDriver = request.VaapiDriver,
+                VaapiDevice = request.VaapiDevice,
+                QsvExtraHardwareFrames = request.QsvExtraHardwareFrames,
+                ResolutionId = resolutionId,
+                ScalingBehavior = request.ScalingBehavior,
+
+                // only allow customization with VAAPI accel
+                PadMode = hwAccel switch
+                {
+                    HardwareAccelerationKind.None => FilterMode.Software,
+                    HardwareAccelerationKind.Vaapi => request.PadMode,
+                    _ => FilterMode.HardwareIfPossible
+                },
+
+                VideoFormat = request.NormalizeVideo ? request.VideoFormat : FFmpegProfileVideoFormat.Copy,
+                VideoProfile = request.VideoProfile,
+                VideoPreset = request.VideoPreset,
+                AllowBFrames = request.AllowBFrames,
+
+                // mpeg2video only supports 8-bit content
+                BitDepth = request.VideoFormat is FFmpegProfileVideoFormat.Mpeg2Video
+                    ? FFmpegProfileBitDepth.EightBit
+                    : request.BitDepth,
+
+                VideoBitrate = request.VideoBitrate,
+                VideoBufferSize = request.VideoBufferSize,
+                TonemapAlgorithm = request.TonemapAlgorithm,
+                AudioFormat = request.NormalizeAudio ? request.AudioFormat : FFmpegProfileAudioFormat.Copy,
+                AudioBitrate = request.AudioBitrate,
+                AudioBufferSize = request.AudioBufferSize,
+
+                NormalizeLoudnessMode = request.NormalizeLoudnessMode,
+                TargetLoudness = request.NormalizeLoudnessMode is NormalizeLoudnessMode.LoudNorm
+                    ? request.TargetLoudness
+                    : null,
+
+                AudioChannels = request.AudioChannels,
+                AudioSampleRate = request.AudioSampleRate,
+                NormalizeFramerate = request.NormalizeFramerate,
+                NormalizeColors = request.NormalizeColors,
+                DeinterlaceVideo = request.DeinterlaceVideo
+            };
         });
 
     private static Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>

ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -7,23 +8,18 @@ using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, Either<BaseError, Unit>>
+public class DeleteFFmpegProfileHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository,
+    ISearchTargets searchTargets)
+    : IRequestHandler<DeleteFFmpegProfile, Either<BaseError, Unit>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ISearchTargets _searchTargets;
-
-    public DeleteFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
-    {
-        _dbContextFactory = dbContextFactory;
-        _searchTargets = searchTargets;
-    }
-
     public async Task<Either<BaseError, Unit>> Handle(
         DeleteFFmpegProfile request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FFmpegProfile> validation = await FFmpegProfileMustExist(dbContext, request, cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request, cancellationToken);
         return await validation.Apply(p => DoDeletion(dbContext, p));
     }
 
@@ -31,10 +27,19 @@ public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, E
     {
         dbContext.FFmpegProfiles.Remove(ffmpegProfile);
         await dbContext.SaveChangesAsync();
-        _searchTargets.SearchTargetsChanged();
+        searchTargets.SearchTargetsChanged();
         return Unit.Default;
     }
 
+    private async Task<Validation<BaseError, FFmpegProfile>> Validate(
+        TvContext dbContext,
+        DeleteFFmpegProfile request,
+        CancellationToken cancellationToken) =>
+        (await FFmpegProfileMustNotBeUsed(dbContext, request, cancellationToken),
+            await FFmpegProfileMustNotBeDefault(request, cancellationToken),
+            await FFmpegProfileMustExist(dbContext, request, cancellationToken))
+        .Apply((_, _, ffmpegProfile) => ffmpegProfile);
+
     private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
         TvContext dbContext,
         DeleteFFmpegProfile request,
@@ -42,4 +47,38 @@ public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, E
         dbContext.FFmpegProfiles
             .SelectOneAsync(p => p.Id, p => p.Id == request.FFmpegProfileId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {request.FFmpegProfileId} does not exist"));
+
+    private static async Task<Validation<BaseError, Unit>> FFmpegProfileMustNotBeUsed(
+        TvContext dbContext,
+        DeleteFFmpegProfile request,
+        CancellationToken cancellationToken)
+    {
+        int count = await dbContext.Channels
+            .AsNoTracking()
+            .Where(c => c.FFmpegProfileId == request.FFmpegProfileId)
+            .CountAsync(cancellationToken);
+
+        if (count > 0)
+        {
+            return BaseError.New(
+                $"Cannot delete FFmpeg Profile that is used by {count} {(count > 1 ? "channels" : "channel")}");
+        }
+
+        return Unit.Default;
+    }
+
+    private async Task<Validation<BaseError, Unit>> FFmpegProfileMustNotBeDefault(
+        DeleteFFmpegProfile request,
+        CancellationToken cancellationToken)
+    {
+        Option<int> defaultFFmpegProfileId =
+            await configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId, cancellationToken);
+
+        if (defaultFFmpegProfileId.Any(id => id == request.FFmpegProfileId))
+        {
+            return BaseError.New("Cannot delete default FFmpeg Profile");
+        }
+
+        return Unit.Default;
+    }
 }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -8,6 +8,8 @@ public record UpdateFFmpegProfile(
     int FFmpegProfileId,
     string Name,
     int ThreadCount,
+    bool NormalizeAudio,
+    bool NormalizeVideo,
     HardwareAccelerationKind HardwareAcceleration,
     string VaapiDisplay,
     VaapiDriver VaapiDriver,
@@ -15,6 +17,7 @@ public record UpdateFFmpegProfile(
     int? QsvExtraHardwareFrames,
     int ResolutionId,
     ScalingBehavior ScalingBehavior,
+    FilterMode PadMode,
     FFmpegProfileVideoFormat VideoFormat,
     string VideoProfile,
     string VideoPreset,
@@ -27,7 +30,9 @@ public record UpdateFFmpegProfile(
     int AudioBitrate,
     int AudioBufferSize,
     NormalizeLoudnessMode NormalizeLoudnessMode,
+    double? TargetLoudness,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,
+    bool NormalizeColors,
     bool DeinterlaceVideo) : IRequest<Either<BaseError, UpdateFFmpegProfileResult>>;

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -1,29 +1,22 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.FFmpeg.Preset;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public class
-    UpdateFFmpegProfileHandler : IRequestHandler<UpdateFFmpegProfile, Either<BaseError, UpdateFFmpegProfileResult>>
+public class UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
+    : IRequestHandler<UpdateFFmpegProfile, Either<BaseError, UpdateFFmpegProfileResult>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ISearchTargets _searchTargets;
-
-    public UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory, ISearchTargets searchTargets)
-    {
-        _dbContextFactory = dbContextFactory;
-        _searchTargets = searchTargets;
-    }
-
     public async Task<Either<BaseError, UpdateFFmpegProfileResult>> Handle(
         UpdateFFmpegProfile request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request, cancellationToken);
         return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request, cancellationToken));
     }
@@ -34,16 +27,23 @@ public class
         UpdateFFmpegProfile update,
         CancellationToken cancellationToken)
     {
+        var hwAccel = update.NormalizeVideo
+            ? update.HardwareAcceleration
+            : HardwareAccelerationKind.None;
+
         p.Name = update.Name;
         p.ThreadCount = update.ThreadCount;
-        p.HardwareAcceleration = update.HardwareAcceleration;
+        p.NormalizeAudio = update.NormalizeAudio;
+        p.NormalizeVideo = update.NormalizeVideo;
+        p.HardwareAcceleration = hwAccel;
         p.VaapiDisplay = update.VaapiDisplay;
         p.VaapiDriver = update.VaapiDriver;
         p.VaapiDevice = update.VaapiDevice;
         p.QsvExtraHardwareFrames = update.QsvExtraHardwareFrames;
         p.ResolutionId = update.ResolutionId;
         p.ScalingBehavior = update.ScalingBehavior;
-        p.VideoFormat = update.VideoFormat;
+        p.PadMode = update.PadMode;
+        p.VideoFormat = update.NormalizeVideo ? update.VideoFormat : FFmpegProfileVideoFormat.Copy;
         p.VideoProfile = update.VideoProfile;
         p.VideoPreset = update.VideoPreset;
         p.AllowBFrames = update.AllowBFrames;
@@ -53,20 +53,55 @@ public class
             ? FFmpegProfileBitDepth.EightBit
             : update.BitDepth;
 
+        if (p.HardwareAcceleration is not (HardwareAccelerationKind.Nvenc or HardwareAccelerationKind.Vaapi
+                or HardwareAccelerationKind.Qsv) &&
+            p.VideoFormat is FFmpegProfileVideoFormat.Av1)
+        {
+            p.VideoFormat = FFmpegProfileVideoFormat.Hevc;
+        }
+
+        // only allow customization with VAAPI accel
+        if (p.HardwareAcceleration is HardwareAccelerationKind.None)
+        {
+            p.PadMode = FilterMode.Software;
+        }
+        else if (p.HardwareAcceleration is not HardwareAccelerationKind.Vaapi)
+        {
+            p.PadMode = FilterMode.HardwareIfPossible;
+        }
+
         p.VideoBitrate = update.VideoBitrate;
         p.VideoBufferSize = update.VideoBufferSize;
         p.TonemapAlgorithm = update.TonemapAlgorithm;
-        p.AudioFormat = update.AudioFormat;
+        p.AudioFormat = update.NormalizeAudio ? update.AudioFormat : FFmpegProfileAudioFormat.Copy;
         p.AudioBitrate = update.AudioBitrate;
         p.AudioBufferSize = update.AudioBufferSize;
+
         p.NormalizeLoudnessMode = update.NormalizeLoudnessMode;
+        p.TargetLoudness = update.NormalizeLoudnessMode is NormalizeLoudnessMode.LoudNorm
+            ? update.TargetLoudness
+            : null;
+
         p.AudioChannels = update.AudioChannels;
         p.AudioSampleRate = update.AudioSampleRate;
         p.NormalizeFramerate = update.NormalizeFramerate;
+        p.NormalizeColors = update.NormalizeColors;
         p.DeinterlaceVideo = update.DeinterlaceVideo;
+
+        // don't save invalid preset
+        ICollection<string> presets = FFmpegLibraryHelper.PresetsForFFmpegProfile(
+            p.HardwareAcceleration,
+            p.VideoFormat,
+            p.BitDepth);
+
+        if (!presets.Contains(p.VideoPreset))
+        {
+            p.VideoPreset = VideoPreset.Unset;
+        }
+
         await dbContext.SaveChangesAsync(cancellationToken);
 
-        _searchTargets.SearchTargetsChanged();
+        searchTargets.SearchTargetsChanged();
 
         return new UpdateFFmpegProfileResult(p.Id);
     }
@@ -75,7 +110,8 @@ public class
         TvContext dbContext,
         UpdateFFmpegProfile request,
         CancellationToken cancellationToken) =>
-        (await FFmpegProfileMustExist(dbContext, request, cancellationToken), ValidateName(request),
+        (await FFmpegProfileMustExist(dbContext, request, cancellationToken),
+            await ValidateName(dbContext, request),
             ValidateThreadCount(request),
             await ResolutionMustExist(dbContext, request, cancellationToken))
         .Apply((ffmpegProfileToUpdate, _, _, _) => ffmpegProfileToUpdate);
@@ -88,9 +124,25 @@ public class
             .SelectOneAsync(p => p.Id, p => p.Id == updateFFmpegProfile.FFmpegProfileId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>("FFmpegProfile does not exist."));
 
-    private static Validation<BaseError, string> ValidateName(UpdateFFmpegProfile updateFFmpegProfile) =>
-        updateFFmpegProfile.NotEmpty(x => x.Name)
-            .Bind(_ => updateFFmpegProfile.NotLongerThan(50)(x => x.Name));
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        UpdateFFmpegProfile updateFFmpegProfile)
+    {
+        if (updateFFmpegProfile.Name.Length > 50)
+        {
+            return BaseError.New($"FFmpeg profile name \"{updateFFmpegProfile.Name}\" is invalid");
+        }
+
+        Option<FFmpegProfile> maybeExisting = await dbContext.FFmpegProfiles
+            .AsNoTracking()
+            .FirstOrDefaultAsync(ff =>
+                ff.Id != updateFFmpegProfile.FFmpegProfileId && ff.Name == updateFFmpegProfile.Name)
+            .Map(Optional);
+
+        return maybeExisting.IsSome
+            ? BaseError.New($"An ffmpeg profile named \"{updateFFmpegProfile.Name}\" already exists in the database")
+            : Success<BaseError, string>(updateFFmpegProfile.Name);
+    }
 
     private static Validation<BaseError, int> ValidateThreadCount(UpdateFFmpegProfile updateFFmpegProfile) =>
         updateFFmpegProfile.AtLeast(0)(p => p.ThreadCount);

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,30 +1,21 @@
 using System.Diagnostics;
 using System.Globalization;
+using System.IO.Abstractions;
 using System.Threading.Channels;
+using ErsatzTV.Application.FFmpeg;
 using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings, Either<BaseError, Unit>>
+public class UpdateFFmpegSettingsHandler(
+    IConfigElementRepository configElementRepository,
+    IFileSystem fileSystem,
+    ChannelWriter<IBackgroundServiceRequest> workerChannel)
+    : IRequestHandler<UpdateFFmpegSettings, Either<BaseError, Unit>>
 {
-    private readonly IConfigElementRepository _configElementRepository;
-    private readonly ILocalFileSystem _localFileSystem;
-    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
-
-    public UpdateFFmpegSettingsHandler(
-        IConfigElementRepository configElementRepository,
-        ILocalFileSystem localFileSystem,
-        ChannelWriter<IBackgroundServiceRequest> workerChannel)
-    {
-        _configElementRepository = configElementRepository;
-        _localFileSystem = localFileSystem;
-        _workerChannel = workerChannel;
-    }
-
     public Task<Either<BaseError, Unit>> Handle(
         UpdateFFmpegSettings request,
         CancellationToken cancellationToken) =>
@@ -44,7 +35,7 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
 
     private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
     {
-        if (!_localFileSystem.FileExists(path))
+        if (!fileSystem.File.Exists(path))
         {
             return BaseError.New($"{name} path does not exist");
         }
@@ -71,32 +62,36 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
 
     private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request, CancellationToken cancellationToken)
     {
-        await _configElementRepository.Upsert(ConfigElementKey.FFmpegPath, request.Settings.FFmpegPath, cancellationToken);
-        await _configElementRepository.Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath, cancellationToken);
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(ConfigElementKey.FFmpegPath, request.Settings.FFmpegPath, cancellationToken);
+        await configElementRepository.Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath, cancellationToken);
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegDefaultProfileId,
             request.Settings.DefaultFFmpegProfileId.ToString(CultureInfo.InvariantCulture),
             cancellationToken);
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegSaveReports,
             request.Settings.SaveReports.ToString(),
             cancellationToken);
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegHlsDirectOutputFormat,
             request.Settings.HlsDirectOutputFormat,
             cancellationToken);
+        await configElementRepository.Upsert(
+            ConfigElementKey.FFmpegDefaultMpegTsScript,
+            request.Settings.DefaultMpegTsScript,
+            cancellationToken);
 
         if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
         {
             Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
         }
 
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegPreferredLanguageCode,
             request.Settings.PreferredAudioLanguageCode,
             cancellationToken);
 
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegUseEmbeddedSubtitles,
             request.Settings.UseEmbeddedSubtitles,
             cancellationToken);
@@ -107,7 +102,7 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
             request.Settings.ExtractEmbeddedSubtitles = false;
         }
 
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegExtractEmbeddedSubtitles,
             request.Settings.ExtractEmbeddedSubtitles,
             cancellationToken);
@@ -115,48 +110,55 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
         // queue extracting all embedded subtitles
         if (request.Settings.ExtractEmbeddedSubtitles)
         {
-            await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(Option<int>.None), cancellationToken);
+            await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(Option<int>.None), cancellationToken);
         }
 
+        await configElementRepository.Upsert(
+            ConfigElementKey.FFmpegProbeForInterlacedFrames,
+            request.Settings.ProbeForInterlacedFrames,
+            cancellationToken);
+
         if (request.Settings.GlobalWatermarkId is not null)
         {
-            await _configElementRepository.Upsert(
+            await configElementRepository.Upsert(
                 ConfigElementKey.FFmpegGlobalWatermarkId,
                 request.Settings.GlobalWatermarkId.Value,
                 cancellationToken);
         }
         else
         {
-            await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId, cancellationToken);
+            await configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId, cancellationToken);
         }
 
         if (request.Settings.GlobalFallbackFillerId is not null)
         {
-            await _configElementRepository.Upsert(
+            await configElementRepository.Upsert(
                 ConfigElementKey.FFmpegGlobalFallbackFillerId,
                 request.Settings.GlobalFallbackFillerId.Value,
                 cancellationToken);
         }
         else
         {
-            await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalFallbackFillerId, cancellationToken);
+            await configElementRepository.Delete(ConfigElementKey.FFmpegGlobalFallbackFillerId, cancellationToken);
         }
 
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegSegmenterTimeout,
             request.Settings.HlsSegmenterIdleTimeout,
             cancellationToken);
 
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegWorkAheadSegmenters,
             request.Settings.WorkAheadSegmenterLimit,
             cancellationToken);
 
-        await _configElementRepository.Upsert(
+        await configElementRepository.Upsert(
             ConfigElementKey.FFmpegInitialSegmentCount,
             request.Settings.InitialSegmentCount,
             cancellationToken);
 
+        await workerChannel.WriteAsync(new RefreshFFmpegCapabilities(), cancellationToken);
+
         return Unit.Default;
     }
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -8,6 +8,8 @@ public record FFmpegProfileViewModel(
     int Id,
     string Name,
     int ThreadCount,
+    bool NormalizeAudio,
+    bool NormalizeVideo,
     HardwareAccelerationKind HardwareAcceleration,
     string VaapiDisplay,
     VaapiDriver VaapiDriver,
@@ -15,6 +17,7 @@ public record FFmpegProfileViewModel(
     int? QsvExtraHardwareFrames,
     ResolutionViewModel Resolution,
     ScalingBehavior ScalingBehavior,
+    FilterMode PadMode,
     FFmpegProfileVideoFormat VideoFormat,
     string VideoProfile,
     string VideoPreset,
@@ -27,7 +30,9 @@ public record FFmpegProfileViewModel(
     int AudioBitrate,
     int AudioBufferSize,
     NormalizeLoudnessMode NormalizeLoudnessMode,
+    double? TargetLoudness,
     int AudioChannels,
     int AudioSampleRate,
     bool NormalizeFramerate,
+    bool NormalizeColors,
     bool DeinterlaceVideo);

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -10,6 +10,7 @@ public class FFmpegSettingsViewModel
     public string PreferredAudioLanguageCode { get; set; }
     public bool UseEmbeddedSubtitles { get; set; }
     public bool ExtractEmbeddedSubtitles { get; set; }
+    public bool ProbeForInterlacedFrames { get; set; }
     public bool SaveReports { get; set; }
     public int? GlobalWatermarkId { get; set; }
     public int? GlobalFallbackFillerId { get; set; }
@@ -17,4 +18,5 @@ public class FFmpegSettingsViewModel
     public int WorkAheadSegmenterLimit { get; set; }
     public int InitialSegmentCount { get; set; }
     public OutputFormatKind HlsDirectOutputFormat { get; set; }
+    public string DefaultMpegTsScript { get; set; }
 }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -10,6 +10,8 @@ internal static class Mapper
             profile.Id,
             profile.Name,
             profile.ThreadCount,
+            profile.NormalizeAudio,
+            profile.NormalizeVideo,
             profile.HardwareAcceleration,
             profile.VaapiDisplay ?? "drm",
             profile.VaapiDriver,
@@ -17,6 +19,7 @@ internal static class Mapper
             profile.QsvExtraHardwareFrames,
             Resolutions.Mapper.ProjectToViewModel(profile.Resolution),
             profile.ScalingBehavior,
+            profile.PadMode,
             profile.VideoFormat,
             profile.VideoProfile,
             profile.VideoPreset ?? string.Empty,
@@ -29,9 +32,11 @@ internal static class Mapper
             profile.AudioBitrate,
             profile.AudioBufferSize,
             profile.NormalizeLoudnessMode,
+            profile.TargetLoudness,
             profile.AudioChannels,
             profile.AudioSampleRate,
             profile.NormalizeFramerate,
+            profile.NormalizeColors,
             profile.DeinterlaceVideo == true);
 
     internal static FFmpegProfileResponseModel ProjectToResponseModel(FFmpegProfile ffmpegProfile) =>
@@ -47,19 +52,25 @@ internal static class Mapper
             ffmpegProfile.Id,
             ffmpegProfile.Name,
             ffmpegProfile.ThreadCount,
-            (int)ffmpegProfile.HardwareAcceleration,
+            ffmpegProfile.HardwareAcceleration,
             ffmpegProfile.VaapiDisplay,
-            (int)ffmpegProfile.VaapiDriver,
+            ffmpegProfile.VaapiDriver,
             ffmpegProfile.VaapiDevice,
-            ffmpegProfile.ResolutionId,
-            (int)ffmpegProfile.VideoFormat,
+            ffmpegProfile.QsvExtraHardwareFrames,
+            ffmpegProfile.Resolution.Name,
+            ffmpegProfile.ScalingBehavior,
+            ffmpegProfile.VideoFormat,
+            ffmpegProfile.VideoProfile,
+            ffmpegProfile.VideoPreset,
+            ffmpegProfile.AllowBFrames,
+            ffmpegProfile.BitDepth,
             ffmpegProfile.VideoBitrate,
             ffmpegProfile.VideoBufferSize,
-            (int)ffmpegProfile.TonemapAlgorithm,
-            (int)ffmpegProfile.AudioFormat,
+            ffmpegProfile.TonemapAlgorithm,
+            ffmpegProfile.AudioFormat,
             ffmpegProfile.AudioBitrate,
             ffmpegProfile.AudioBufferSize,
-            (int)ffmpegProfile.NormalizeLoudnessMode,
+            ffmpegProfile.NormalizeLoudnessMode,
             ffmpegProfile.AudioChannels,
             ffmpegProfile.AudioSampleRate,
             ffmpegProfile.NormalizeFramerate,

ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfilesForApi.cs

@@ -2,4 +2,4 @@
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public record GetAllFFmpegProfilesForApi : IRequest<List<FFmpegProfileResponseModel>>;
+public record GetAllFFmpegProfilesForApi : IRequest<List<FFmpegFullProfileResponseModel>>;

ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfilesForApiHandler.cs

@@ -6,23 +6,18 @@ using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public class
-    GetAllFFmpegProfilesForApiHandler : IRequestHandler<GetAllFFmpegProfilesForApi, List<FFmpegProfileResponseModel>>
+public class GetAllFFmpegProfilesForApiHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllFFmpegProfilesForApi, List<FFmpegFullProfileResponseModel>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-    public GetAllFFmpegProfilesForApiHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-        _dbContextFactory = dbContextFactory;
-
-    public async Task<List<FFmpegProfileResponseModel>> Handle(
+    public async Task<List<FFmpegFullProfileResponseModel>> Handle(
         GetAllFFmpegProfilesForApi request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         List<FFmpegProfile> ffmpegProfiles = await dbContext.FFmpegProfiles
             .AsNoTracking()
             .Include(p => p.Resolution)
             .ToListAsync(cancellationToken);
-        return ffmpegProfiles.Map(ProjectToResponseModel).ToList();
+        return ffmpegProfiles.Map(ProjectToFullResponseModel).ToList();
     }
 }

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdHandler.cs

@@ -5,18 +5,14 @@ using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public class GetFFmpegProfileByIdHandler : IRequestHandler<GetFFmpegProfileById, Option<FFmpegProfileViewModel>>
+public class GetFFmpegProfileByIdHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetFFmpegProfileById, Option<FFmpegProfileViewModel>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-    public GetFFmpegProfileByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-        _dbContextFactory = dbContextFactory;
-
     public async Task<Option<FFmpegProfileViewModel>> Handle(
         GetFFmpegProfileById request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         return await dbContext.FFmpegProfiles
             .Include(p => p.Resolution)
             .SelectOneAsync(p => p.Id, p => p.Id == request.Id, cancellationToken)

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -4,41 +4,59 @@ using ErsatzTV.FFmpeg.OutputFormat;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpegSettingsViewModel>
+public class GetFFmpegSettingsHandler(IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetFFmpegSettings, FFmpegSettingsViewModel>
 {
-    private readonly IConfigElementRepository _configElementRepository;
-
-    public GetFFmpegSettingsHandler(IConfigElementRepository configElementRepository) =>
-        _configElementRepository = configElementRepository;
-
     public async Task<FFmpegSettingsViewModel> Handle(
         GetFFmpegSettings request,
         CancellationToken cancellationToken)
     {
-        Option<string> ffmpegPath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath, cancellationToken);
-        Option<string> ffprobePath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath, cancellationToken);
+        Option<string> ffmpegPath = await configElementRepository.GetValue<string>(
+            ConfigElementKey.FFmpegPath,
+            cancellationToken);
+        Option<string> ffprobePath = await configElementRepository.GetValue<string>(
+            ConfigElementKey.FFprobePath,
+            cancellationToken);
         Option<int> defaultFFmpegProfileId =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId, cancellationToken);
+            await configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId, cancellationToken);
         Option<bool> saveReports =
-            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports, cancellationToken);
+            await configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports, cancellationToken);
         Option<string> preferredAudioLanguageCode =
-            await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode, cancellationToken);
+            await configElementRepository.GetValue<string>(
+                ConfigElementKey.FFmpegPreferredLanguageCode,
+                cancellationToken);
         Option<bool> useEmbeddedSubtitles =
-            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegUseEmbeddedSubtitles, cancellationToken);
+            await configElementRepository.GetValue<bool>(
+                ConfigElementKey.FFmpegUseEmbeddedSubtitles,
+                cancellationToken);
         Option<bool> extractEmbeddedSubtitles =
-            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegExtractEmbeddedSubtitles, cancellationToken);
+            await configElementRepository.GetValue<bool>(
+                ConfigElementKey.FFmpegExtractEmbeddedSubtitles,
+                cancellationToken);
+        Option<bool> probeForInterlacedFrames =
+            await configElementRepository.GetValue<bool>(
+                ConfigElementKey.FFmpegProbeForInterlacedFrames,
+                cancellationToken);
         Option<int> watermark =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId, cancellationToken);
+            await configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId, cancellationToken);
         Option<int> fallbackFiller =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalFallbackFillerId, cancellationToken);
+            await configElementRepository.GetValue<int>(
+                ConfigElementKey.FFmpegGlobalFallbackFillerId,
+                cancellationToken);
         Option<int> hlsSegmenterIdleTimeout =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout, cancellationToken);
+            await configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout, cancellationToken);
         Option<int> workAheadSegmenterLimit =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters, cancellationToken);
+            await configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters, cancellationToken);
         Option<int> initialSegmentCount =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount, cancellationToken);
+            await configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount, cancellationToken);
         Option<OutputFormatKind> outputFormatKind =
-            await _configElementRepository.GetValue<OutputFormatKind>(ConfigElementKey.FFmpegHlsDirectOutputFormat, cancellationToken);
+            await configElementRepository.GetValue<OutputFormatKind>(
+                ConfigElementKey.FFmpegHlsDirectOutputFormat,
+                cancellationToken);
+        Option<string> defaultMpegTsScript =
+            await configElementRepository.GetValue<string>(
+                ConfigElementKey.FFmpegDefaultMpegTsScript,
+                cancellationToken);
 
         var result = new FFmpegSettingsViewModel
         {
@@ -48,11 +66,13 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
             SaveReports = await saveReports.IfNoneAsync(false),
             UseEmbeddedSubtitles = await useEmbeddedSubtitles.IfNoneAsync(true),
             ExtractEmbeddedSubtitles = await extractEmbeddedSubtitles.IfNoneAsync(false),
+            ProbeForInterlacedFrames = await probeForInterlacedFrames.IfNoneAsync(false),
             PreferredAudioLanguageCode = await preferredAudioLanguageCode.IfNoneAsync("eng"),
             HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
             WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),
             InitialSegmentCount = await initialSegmentCount.IfNoneAsync(1),
-            HlsDirectOutputFormat = await outputFormatKind.IfNoneAsync(OutputFormatKind.MpegTs)
+            HlsDirectOutputFormat = await outputFormatKind.IfNoneAsync(OutputFormatKind.MpegTs),
+            DefaultMpegTsScript = await defaultMpegTsScript.IfNoneAsync("Default"),
         };
 
         foreach (int watermarkId in watermark)

ErsatzTV.Application/FFmpegProfiles/Queries/GetSupportedHardwareAccelerationKindsHandler.cs

@@ -31,15 +31,18 @@ public class
         Validation<BaseError, string> validation = await Validate(dbContext, cancellationToken);
 
         return await validation.Match(
-            GetHardwareAccelerationKinds,
+            ffmpegPath => GetHardwareAccelerationKinds(ffmpegPath, cancellationToken),
             _ => Task.FromResult(new List<HardwareAccelerationKind> { HardwareAccelerationKind.None }));
     }
 
-    private async Task<List<HardwareAccelerationKind>> GetHardwareAccelerationKinds(string ffmpegPath)
+    private async Task<List<HardwareAccelerationKind>> GetHardwareAccelerationKinds(
+        string ffmpegPath,
+        CancellationToken cancellationToken)
     {
         var result = new List<HardwareAccelerationKind> { HardwareAccelerationKind.None };
 
-        IFFmpegCapabilities ffmpegCapabilities = await _hardwareCapabilitiesFactory.GetFFmpegCapabilities(ffmpegPath);
+        IFFmpegCapabilities ffmpegCapabilities =
+            await _hardwareCapabilitiesFactory.GetFFmpegCapabilities(ffmpegPath, cancellationToken);
 
         if (ffmpegCapabilities.HasHardwareAcceleration(HardwareAccelerationMode.Nvenc))
         {
@@ -72,6 +75,11 @@ public class
         //     result.Add(HardwareAccelerationKind.V4l2m2m);
         // }
 
+        if (ffmpegCapabilities.HasHardwareAcceleration(HardwareAccelerationMode.Rkmpp))
+        {
+            result.Add(HardwareAccelerationKind.Rkmpp);
+        }
+
         return result;
     }
 

ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs

@@ -12,7 +12,7 @@ public record CreateFillerPreset(
     int? Count,
     int? PadToNearestMinute,
     bool AllowWatermarks,
-    ProgramScheduleItemCollectionType CollectionType,
+    CollectionType CollectionType,
     int? CollectionId,
     int? MediaItemId,
     int? MultiCollectionId,

ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs

@@ -1,57 +1,67 @@
-using Bugsnag;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Filler;
 
-public class CreateFillerPresetHandler : IRequestHandler<CreateFillerPreset, Either<BaseError, Unit>>
+public class CreateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<CreateFillerPreset, Either<BaseError, Unit>>
 {
-    private readonly IClient _client;
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-    public CreateFillerPresetHandler(IClient client, IDbContextFactory<TvContext> dbContextFactory)
-    {
-        _client = client;
-        _dbContextFactory = dbContextFactory;
-    }
-
     public async Task<Either<BaseError, Unit>> Handle(CreateFillerPreset request, CancellationToken cancellationToken)
     {
-        try
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, FillerPreset> validation = await Validate(dbContext, request);
+        return await validation.Apply(fp => Persist(dbContext, fp, cancellationToken));
+    }
+
+    private static async Task<Unit> Persist(
+        TvContext dbContext,
+        FillerPreset fillerPreset,
+        CancellationToken cancellationToken)
+    {
+        await dbContext.FillerPresets.AddAsync(fillerPreset, cancellationToken);
+        await dbContext.SaveChangesAsync(cancellationToken);
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, FillerPreset>> Validate(
+        TvContext dbContext,
+        CreateFillerPreset request) =>
+        ValidateName(dbContext, request).MapT(name => new FillerPreset
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            Name = name,
+            FillerKind = request.FillerKind,
+            FillerMode = request.FillerMode,
+            Duration = request.Duration,
+            Count = request.Count,
+            PadToNearestMinute = request.PadToNearestMinute,
+            AllowWatermarks = request.AllowWatermarks,
+            CollectionType = request.CollectionType,
+            CollectionId = request.CollectionId,
+            MediaItemId = request.MediaItemId,
+            MultiCollectionId = request.MultiCollectionId,
+            SmartCollectionId = request.SmartCollectionId,
+            PlaylistId = request.PlaylistId,
+            Expression = request.FillerKind is FillerKind.MidRoll ? request.Expression : null,
+            UseChaptersAsMediaItems =
+                request.FillerKind is not FillerKind.Fallback && request.UseChaptersAsMediaItems
+        });
 
-            var fillerPreset = new FillerPreset
-            {
-                Name = request.Name,
-                FillerKind = request.FillerKind,
-                FillerMode = request.FillerMode,
-                Duration = request.Duration,
-                Count = request.Count,
-                PadToNearestMinute = request.PadToNearestMinute,
-                AllowWatermarks = request.AllowWatermarks,
-                CollectionType = request.CollectionType,
-                CollectionId = request.CollectionId,
-                MediaItemId = request.MediaItemId,
-                MultiCollectionId = request.MultiCollectionId,
-                SmartCollectionId = request.SmartCollectionId,
-                PlaylistId = request.PlaylistId,
-                Expression = request.FillerKind is FillerKind.MidRoll ? request.Expression : null,
-                UseChaptersAsMediaItems =
-                    request.FillerKind is not FillerKind.Fallback && request.UseChaptersAsMediaItems
-            };
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        CreateFillerPreset request)
+    {
+        Validation<BaseError, string> result1 = request.NotEmpty(fp => fp.Name)
+            .Bind(_ => request.NotLongerThan(50)(fp => fp.Name));
 
-            await dbContext.FillerPresets.AddAsync(fillerPreset, cancellationToken);
-            await dbContext.SaveChangesAsync(cancellationToken);
+        bool duplicateName = await dbContext.FillerPresets
+            .AnyAsync(fp => fp.Name == request.Name);
 
-            return Unit.Default;
-        }
-        catch (Exception ex)
-        {
-            _client.Notify(ex);
-            return BaseError.New(ex.Message);
-        }
+        Validation<BaseError, Unit> result2 = duplicateName
+            ? Fail<BaseError, Unit>("Filler preset name must be unique")
+            : Success<BaseError, Unit>(Unit.Default);
+
+        return (result1, result2).Apply((_, _) => request.Name);
     }
 }

ErsatzTV.Application/Filler/Commands/UpdateFillerPreset.cs

@@ -13,7 +13,7 @@ public record UpdateFillerPreset(
     int? Count,
     int? PadToNearestMinute,
     bool AllowWatermarks,
-    ProgramScheduleItemCollectionType CollectionType,
+    CollectionType CollectionType,
     int? CollectionId,
     int? MediaItemId,
     int? MultiCollectionId,

ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs

@@ -6,27 +6,21 @@ using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Filler;
 
-public class UpdateFillerPresetHandler : IRequestHandler<UpdateFillerPreset, Either<BaseError, Unit>>
+public class UpdateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<UpdateFillerPreset, Either<BaseError, Unit>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-    public UpdateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-        _dbContextFactory = dbContextFactory;
-
     public async Task<Either<BaseError, Unit>> Handle(UpdateFillerPreset request, CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(
-            dbContext,
-            request,
-            cancellationToken);
-        return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, FillerPreset> validation = await Validate(dbContext, request, cancellationToken);
+        return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request, cancellationToken));
     }
 
     private static async Task<Unit> ApplyUpdateRequest(
         TvContext dbContext,
         FillerPreset existing,
-        UpdateFillerPreset request)
+        UpdateFillerPreset request,
+        CancellationToken cancellationToken)
     {
         existing.Name = request.Name;
         existing.FillerKind = request.FillerKind;
@@ -45,16 +39,40 @@ public class UpdateFillerPresetHandler : IRequestHandler<UpdateFillerPreset, Eit
         existing.UseChaptersAsMediaItems =
             request.FillerKind is not FillerKind.Fallback && request.UseChaptersAsMediaItems;
 
-        await dbContext.SaveChangesAsync();
+        await dbContext.SaveChangesAsync(cancellationToken);
 
         return Unit.Default;
     }
 
+    private static async Task<Validation<BaseError, FillerPreset>> Validate(
+        TvContext dbContext,
+        UpdateFillerPreset request,
+        CancellationToken cancellationToken) =>
+        (await FillerPresetMustExist(dbContext, request, cancellationToken), await ValidateName(dbContext, request))
+        .Apply((collectionToUpdate, _) => collectionToUpdate);
+
     private static Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
         TvContext dbContext,
         UpdateFillerPreset request,
         CancellationToken cancellationToken) =>
         dbContext.FillerPresets
             .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id, cancellationToken)
-            .Map(o => o.ToValidation<BaseError>("FillerPreset does not exist"));
+            .Map(o => o.ToValidation<BaseError>("Filler preset does not exist"));
+
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        UpdateFillerPreset request)
+    {
+        Validation<BaseError, string> result1 = request.NotEmpty(fp => fp.Name)
+            .Bind(_ => request.NotLongerThan(50)(fp => fp.Name));
+
+        bool duplicateName = await dbContext.FillerPresets
+            .AnyAsync(c => c.Id != request.Id && c.Name == request.Name);
+
+        Validation<BaseError, Unit> result2 = duplicateName
+            ? Fail<BaseError, Unit>("Filler preset name must be unique")
+            : Success<BaseError, Unit>(Unit.Default);
+
+        return (result1, result2).Apply((_, _) => request.Name);
+    }
 }

ErsatzTV.Application/Filler/FillerPresetViewModel.cs

@@ -13,7 +13,7 @@ public record FillerPresetViewModel(
     int? Count,
     int? PadToNearestMinute,
     bool AllowWatermarks,
-    ProgramScheduleItemCollectionType CollectionType,
+    CollectionType CollectionType,
     int? CollectionId,
     int? MediaItemId,
     int? MultiCollectionId,

ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs

@@ -4,22 +4,18 @@ using static ErsatzTV.Application.Filler.Mapper;
 
 namespace ErsatzTV.Application.Filler;
 
-public class GetPagedFillerPresetsHandler : IRequestHandler<GetPagedFillerPresets, PagedFillerPresetsViewModel>
+public class GetPagedFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetPagedFillerPresets, PagedFillerPresetsViewModel>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-    public GetPagedFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-        _dbContextFactory = dbContextFactory;
-
     public async Task<PagedFillerPresetsViewModel> Handle(
         GetPagedFillerPresets request,
         CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         int count = await dbContext.FillerPresets.CountAsync(cancellationToken);
         List<FillerPresetViewModel> page = await dbContext.FillerPresets
             .AsNoTracking()
-            .OrderBy(f => EF.Functions.Collate(f.Name, TvContext.CaseInsensitiveCollation))
+            .OrderBy(f => f.Name)
             .Skip(request.PageNum * request.PageSize)
             .Take(request.PageSize)
             .ToListAsync(cancellationToken)

ErsatzTV.Application/Graphics/Commands/RefreshGraphicsElementsHandler.cs

@@ -1,6 +1,8 @@
+using System.IO.Abstractions;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Streaming;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
@@ -9,7 +11,9 @@ namespace ErsatzTV.Application.Graphics;
 
 public class RefreshGraphicsElementsHandler(
     IDbContextFactory<TvContext> dbContextFactory,
+    IFileSystem fileSystem,
     ILocalFileSystem localFileSystem,
+    IGraphicsElementLoader graphicsElementLoader,
     ILogger<RefreshGraphicsElementsHandler> logger)
     : IRequestHandler<RefreshGraphicsElements>
 {
@@ -21,7 +25,11 @@ public class RefreshGraphicsElementsHandler(
         List<GraphicsElement> allExisting = await dbContext.GraphicsElements
             .ToListAsync(cancellationToken);
 
-        foreach (GraphicsElement existing in allExisting.Where(e => !localFileSystem.FileExists(e.Path)))
+        var missing = allExisting
+            .Where(e => !fileSystem.File.Exists(e.Path) || (Path.GetExtension(e.Path) != ".yml" && Path.GetExtension(e.Path) != ".yaml"))
+            .ToList();
+
+        foreach (GraphicsElement existing in missing)
         {
             logger.LogWarning(
                 "Removing graphics element that references non-existing file {File}",
@@ -30,8 +38,13 @@ public class RefreshGraphicsElementsHandler(
             dbContext.GraphicsElements.Remove(existing);
         }
 
+        foreach (GraphicsElement existing in allExisting.Except(missing))
+        {
+            await TryRefreshName(existing, cancellationToken);
+        }
+
         // add new text elements
-        var newTextPaths = localFileSystem.ListFiles(FileSystemLayout.GraphicsElementsTextTemplatesFolder)
+        var newTextPaths = localFileSystem.ListFiles(FileSystemLayout.GraphicsElementsTextTemplatesFolder, "*.yml", "*.yaml")
             .Where(f => allExisting.All(e => e.Path != f))
             .ToList();
 
@@ -45,11 +58,13 @@ public class RefreshGraphicsElementsHandler(
                 Kind = GraphicsElementKind.Text
             };
 
+            await TryRefreshName(graphicsElement, cancellationToken);
+
             await dbContext.AddAsync(graphicsElement, cancellationToken);
         }
 
         // add new image elements
-        var newImagePaths = localFileSystem.ListFiles(FileSystemLayout.GraphicsElementsImageTemplatesFolder)
+        var newImagePaths = localFileSystem.ListFiles(FileSystemLayout.GraphicsElementsImageTemplatesFolder, "*.yml", "*.yaml")
             .Where(f => allExisting.All(e => e.Path != f))
             .ToList();
 
@@ -63,11 +78,33 @@ public class RefreshGraphicsElementsHandler(
                 Kind = GraphicsElementKind.Image
             };
 
+            await TryRefreshName(graphicsElement, cancellationToken);
+
+            await dbContext.AddAsync(graphicsElement, cancellationToken);
+        }
+
+        // add new motion elements
+        var newMotionPaths = localFileSystem.ListFiles(FileSystemLayout.GraphicsElementsMotionTemplatesFolder, "*.yml", "*.yaml")
+            .Where(f => allExisting.All(e => e.Path != f))
+            .ToList();
+
+        foreach (string path in newMotionPaths)
+        {
+            logger.LogDebug("Adding new graphics element from file {File}", path);
+
+            var graphicsElement = new GraphicsElement
+            {
+                Path = path,
+                Kind = GraphicsElementKind.Motion
+            };
+
+            await TryRefreshName(graphicsElement, cancellationToken);
+
             await dbContext.AddAsync(graphicsElement, cancellationToken);
         }
 
         // add new subtitle elements
-        var newSubtitlePaths = localFileSystem.ListFiles(FileSystemLayout.GraphicsElementsSubtitleTemplatesFolder)
+        var newSubtitlePaths = localFileSystem.ListFiles(FileSystemLayout.GraphicsElementsSubtitleTemplatesFolder, "*.yml", "*.yaml")
             .Where(f => allExisting.All(e => e.Path != f))
             .ToList();
 
@@ -81,9 +118,41 @@ public class RefreshGraphicsElementsHandler(
                 Kind = GraphicsElementKind.Subtitle
             };
 
+            await TryRefreshName(graphicsElement, cancellationToken);
+
+            await dbContext.AddAsync(graphicsElement, cancellationToken);
+        }
+
+        // add new script elements
+        var newScriptPaths = localFileSystem.ListFiles(FileSystemLayout.GraphicsElementsScriptTemplatesFolder, "*.yml", "*.yaml")
+            .Where(f => allExisting.All(e => e.Path != f))
+            .ToList();
+
+        foreach (string path in newScriptPaths)
+        {
+            logger.LogDebug("Adding new graphics element from file {File}", path);
+
+            var graphicsElement = new GraphicsElement
+            {
+                Path = path,
+                Kind = GraphicsElementKind.Script
+            };
+
+            await TryRefreshName(graphicsElement, cancellationToken);
+
             await dbContext.AddAsync(graphicsElement, cancellationToken);
         }
 
         await dbContext.SaveChangesAsync(cancellationToken);
     }
+
+    private async Task TryRefreshName(GraphicsElement graphicsElement, CancellationToken cancellationToken)
+    {
+        graphicsElement.Name = null;
+        Option<string> maybeName = await graphicsElementLoader.TryLoadName(graphicsElement.Path, cancellationToken);
+        foreach (string name in maybeName)
+        {
+            graphicsElement.Name = name;
+        }
+    }
 }

ErsatzTV.Application/Graphics/GraphicsElementViewModel.cs

@@ -1,3 +1,3 @@
 namespace ErsatzTV.Application.Graphics;
 
-public record GraphicsElementViewModel(int Id, string Name);
+public record GraphicsElementViewModel(int Id, string Name, string FileName);

ErsatzTV.Application/Graphics/Mapper.cs

@@ -7,12 +7,22 @@ public static class Mapper
     public static GraphicsElementViewModel ProjectToViewModel(GraphicsElement graphicsElement)
     {
         string fileName = Path.GetFileName(graphicsElement.Path);
-        return graphicsElement.Kind switch
+        fileName = graphicsElement.Kind switch
         {
-            GraphicsElementKind.Text => new GraphicsElementViewModel(graphicsElement.Id, $"text/{fileName}"),
-            GraphicsElementKind.Image => new GraphicsElementViewModel(graphicsElement.Id, $"image/{fileName}"),
-            GraphicsElementKind.Subtitle => new GraphicsElementViewModel(graphicsElement.Id, $"subtitle/{fileName}"),
-            _ => new GraphicsElementViewModel(graphicsElement.Id, graphicsElement.Path)
+            GraphicsElementKind.Text => $"text/{fileName}",
+            GraphicsElementKind.Image => $"image/{fileName}",
+            GraphicsElementKind.Subtitle => $"subtitle/{fileName}",
+            GraphicsElementKind.Motion => $"motion/{fileName}",
+            GraphicsElementKind.Script => $"script/{fileName}",
+            _ => graphicsElement.Path
         };
+
+        string name = fileName;
+        if (!string.IsNullOrWhiteSpace(graphicsElement.Name))
+        {
+            name = $"{graphicsElement.Name} ({fileName})";
+        }
+
+        return new GraphicsElementViewModel(graphicsElement.Id, name, fileName);
     }
 }

ErsatzTV.Application/Graphics/Queries/GetAllGraphicsElementsHandler.cs

@@ -14,6 +14,6 @@ public class GetAllGraphicsElementsHandler(IDbContextFactory<TvContext> dbContex
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
         return await dbContext.GraphicsElements
             .ToListAsync(cancellationToken)
-            .Map(list => list.Map(ProjectToViewModel).ToList());
+            .Map(list => list.Map(ProjectToViewModel).OrderBy(e => e.Name == e.FileName).ThenBy(e => e.Name).ToList());
     }
 }

ErsatzTV.Application/Images/Queries/GetCachedImagePathHandler.cs

@@ -74,7 +74,8 @@ public class
                         ffmpegPath,
                         originalPath,
                         withExtension,
-                        request.MaxHeight.Value);
+                        request.MaxHeight.Value,
+                        cancellationToken);
 
                     CommandResult resize = await process.ExecuteAsync(cancellationToken);
 

ErsatzTV.Application/Jellyfin/Commands/CallJellyfinCollectionScannerHandler.cs

@@ -1,34 +1,43 @@
 using System.Globalization;
-using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
 using ErsatzTV.FFmpeg.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Jellyfin;
 
 public class CallJellyfinCollectionScannerHandler : CallLibraryScannerHandler<SynchronizeJellyfinCollections>,
     IRequestHandler<SynchronizeJellyfinCollections, Either<BaseError, Unit>>
 {
+    private readonly IScannerProxyService _scannerProxyService;
+
     public CallJellyfinCollectionScannerHandler(
         IDbContextFactory<TvContext> dbContextFactory,
         IConfigElementRepository configElementRepository,
-        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
-        IMediator mediator,
-        IRuntimeInfo runtimeInfo) : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+        IScannerProxyService scannerProxyService,
+        IRuntimeInfo runtimeInfo,
+        ILogger<CallJellyfinCollectionScannerHandler> logger) : base(
+        dbContextFactory,
+        configElementRepository,
+        runtimeInfo,
+        logger)
     {
+        _scannerProxyService = scannerProxyService;
     }
 
     public async Task<Either<BaseError, Unit>>
         Handle(SynchronizeJellyfinCollections request, CancellationToken cancellationToken)
     {
-        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
+        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
         return await validation.Match(
-            scanner => PerformScan(scanner, request, cancellationToken),
+            parameters => PerformScan(parameters, request, cancellationToken),
             error =>
             {
                 foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
@@ -40,7 +49,7 @@ public class CallJellyfinCollectionScannerHandler : CallLibraryScannerHandler<Sy
             });
     }
 
-    protected override async Task<DateTimeOffset> GetLastScan(
+    protected override async Task<Tuple<string, DateTimeOffset>> GetLastScan(
         TvContext dbContext,
         SynchronizeJellyfinCollections request,
         CancellationToken cancellationToken)
@@ -49,7 +58,7 @@ public class CallJellyfinCollectionScannerHandler : CallLibraryScannerHandler<Sy
             .SelectOneAsync(l => l.Id, l => l.Id == request.JellyfinMediaSourceId, cancellationToken)
             .Match(l => l.LastCollectionsScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
 
-        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
+        return new Tuple<string, DateTimeOffset>(string.Empty, new DateTimeOffset(minDateTime, TimeSpan.Zero));
     }
 
     protected override bool ScanIsRequired(
@@ -67,20 +76,40 @@ public class CallJellyfinCollectionScannerHandler : CallLibraryScannerHandler<Sy
     }
 
     private async Task<Either<BaseError, Unit>> PerformScan(
-        string scanner,
+        ScanParameters parameters,
         SynchronizeJellyfinCollections request,
         CancellationToken cancellationToken)
     {
-        var arguments = new List<string>
+        Option<Guid> maybeScanId = _scannerProxyService.StartScan(FakeLibraryId.JellyfinCollections);
+        foreach (var scanId in maybeScanId)
         {
-            "scan-jellyfin-collections", request.JellyfinMediaSourceId.ToString(CultureInfo.InvariantCulture)
-        };
+            try
+            {
+                var arguments = new List<string>
+                {
+                    "scan-jellyfin-collections",
+                    request.JellyfinMediaSourceId.ToString(CultureInfo.InvariantCulture),
+                    GetBaseUrl(scanId),
+                };
 
-        if (request.ForceScan)
-        {
-            arguments.Add("--force");
+                if (request.ForceScan)
+                {
+                    arguments.Add("--force");
+                }
+
+                if (request.DeepScan)
+                {
+                    arguments.Add("--deep");
+                }
+
+                return await base.PerformScan(parameters, arguments, cancellationToken).MapT(_ => Unit.Default);
+            }
+            finally
+            {
+                _scannerProxyService.EndScan(scanId);
+            }
         }
 
-        return await base.PerformScan(scanner, arguments, cancellationToken).MapT(_ => Unit.Default);
+        return BaseError.New("Jellyfin collections are already scanning");
     }
 }

ErsatzTV.Application/Jellyfin/Commands/CallJellyfinLibraryScannerHandler.cs

@@ -1,13 +1,15 @@
 using System.Globalization;
-using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.FFmpeg.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Jellyfin;
 
@@ -15,14 +17,17 @@ public class CallJellyfinLibraryScannerHandler : CallLibraryScannerHandler<ISync
     IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>,
     IRequestHandler<SynchronizeJellyfinLibraryByIdIfNeeded, Either<BaseError, string>>
 {
+    private readonly IScannerProxyService _scannerProxyService;
+
     public CallJellyfinLibraryScannerHandler(
         IDbContextFactory<TvContext> dbContextFactory,
         IConfigElementRepository configElementRepository,
-        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
-        IMediator mediator,
-        IRuntimeInfo runtimeInfo)
-        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+        IScannerProxyService scannerProxyService,
+        IRuntimeInfo runtimeInfo,
+        ILogger<CallJellyfinLibraryScannerHandler> logger)
+        : base(dbContextFactory, configElementRepository, runtimeInfo, logger)
     {
+        _scannerProxyService = scannerProxyService;
     }
 
     Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>.
@@ -39,9 +44,9 @@ public class CallJellyfinLibraryScannerHandler : CallLibraryScannerHandler<ISync
         ISynchronizeJellyfinLibraryById request,
         CancellationToken cancellationToken)
     {
-        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
+        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
         return await validation.Match(
-            scanner => PerformScan(scanner, request, cancellationToken),
+            parameters => PerformScan(parameters, request, cancellationToken),
             error =>
             {
                 foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
@@ -54,38 +59,58 @@ public class CallJellyfinLibraryScannerHandler : CallLibraryScannerHandler<ISync
     }
 
     private async Task<Either<BaseError, string>> PerformScan(
-        string scanner,
+        ScanParameters parameters,
         ISynchronizeJellyfinLibraryById request,
         CancellationToken cancellationToken)
     {
-        var arguments = new List<string>
+        Option<Guid> maybeScanId = _scannerProxyService.StartScan(request.JellyfinLibraryId);
+        foreach (var scanId in maybeScanId)
         {
-            "scan-jellyfin", request.JellyfinLibraryId.ToString(CultureInfo.InvariantCulture)
-        };
+            try
+            {
+                var arguments = new List<string>
+                {
+                    "scan-jellyfin",
+                    request.JellyfinLibraryId.ToString(CultureInfo.InvariantCulture),
+                    GetBaseUrl(scanId)
+                };
 
-        if (request.ForceScan)
-        {
-            arguments.Add("--force");
+                if (request.ForceScan)
+                {
+                    arguments.Add("--force");
+                }
+
+                if (request.DeepScan)
+                {
+                    arguments.Add("--deep");
+                }
+
+                return await base.PerformScan(parameters, arguments, cancellationToken);
+            }
+            finally
+            {
+                _scannerProxyService.EndScan(scanId);
+            }
         }
 
-        if (request.DeepScan)
-        {
-            arguments.Add("--deep");
-        }
-
-        return await base.PerformScan(scanner, arguments, cancellationToken);
+        return BaseError.New($"Library {request.JellyfinLibraryId} is already scanning");
     }
 
-    protected override async Task<DateTimeOffset> GetLastScan(
+    protected override async Task<Tuple<string, DateTimeOffset>> GetLastScan(
         TvContext dbContext,
         ISynchronizeJellyfinLibraryById request,
         CancellationToken cancellationToken)
     {
-        DateTime minDateTime = await dbContext.JellyfinLibraries
-            .SelectOneAsync(l => l.Id, l => l.Id == request.JellyfinLibraryId, cancellationToken)
-            .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
+        Option<JellyfinLibrary> maybeLibrary = await dbContext.JellyfinLibraries
+            .SelectOneAsync(l => l.Id, l => l.Id == request.JellyfinLibraryId, cancellationToken);
 
-        return new DateTimeOffset(minDateTime, TimeSpan.Zero);
+        DateTime minDateTime = maybeLibrary.Match(
+            l => l.LastScan ?? SystemTime.MinValueUtc,
+            () => SystemTime.MaxValueUtc);
+
+        string libraryName = maybeLibrary.Match(l => l.Name, string.Empty);
+
+        return new Tuple<string, DateTimeOffset>(libraryName, new DateTimeOffset(minDateTime, TimeSpan.Zero));
     }
 
     protected override bool ScanIsRequired(

ErsatzTV.Application/Jellyfin/Commands/CallJellyfinShowScannerHandler.cs

@@ -1,26 +1,30 @@
 using System.Globalization;
-using System.Threading.Channels;
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.FFmpeg.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Jellyfin;
 
 public class CallJellyfinShowScannerHandler : CallLibraryScannerHandler<SynchronizeJellyfinShowById>,
     IRequestHandler<SynchronizeJellyfinShowById, Either<BaseError, string>>
 {
+    private readonly IScannerProxyService _scannerProxyService;
+
     public CallJellyfinShowScannerHandler(
         IDbContextFactory<TvContext> dbContextFactory,
         IConfigElementRepository configElementRepository,
-        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
-        IMediator mediator,
-        IRuntimeInfo runtimeInfo)
-        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+        IScannerProxyService scannerProxyService,
+        IRuntimeInfo runtimeInfo,
+        ILogger<CallJellyfinShowScannerHandler> logger)
+        : base(dbContextFactory, configElementRepository, runtimeInfo, logger)
     {
+        _scannerProxyService = scannerProxyService;
     }
 
     Task<Either<BaseError, string>> IRequestHandler<SynchronizeJellyfinShowById, Either<BaseError, string>>.Handle(
@@ -31,9 +35,9 @@ public class CallJellyfinShowScannerHandler : CallLibraryScannerHandler<Synchron
         SynchronizeJellyfinShowById request,
         CancellationToken cancellationToken)
     {
-        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
+        Validation<BaseError, ScanParameters> validation = await Validate(request, cancellationToken);
         return await validation.Match(
-            scanner => PerformScan(scanner, request, cancellationToken),
+            parameters => PerformScan(parameters, request, cancellationToken),
             error =>
             {
                 foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
@@ -46,30 +50,44 @@ public class CallJellyfinShowScannerHandler : CallLibraryScannerHandler<Synchron
     }
 
     private async Task<Either<BaseError, string>> PerformScan(
-        string scanner,
+        ScanParameters parameters,
         SynchronizeJellyfinShowById request,
         CancellationToken cancellationToken)
     {
-        var arguments = new List<string>
+        Option<Guid> maybeScanId = _scannerProxyService.StartScan(request.JellyfinLibraryId);
+        foreach (var scanId in maybeScanId)
         {
-            "scan-jellyfin-show",
-            request.JellyfinLibraryId.ToString(CultureInfo.InvariantCulture),
-            request.ShowId.ToString(CultureInfo.InvariantCulture)
-        };
+            try
+            {
+                var arguments = new List<string>
+                {
+                    "scan-jellyfin-show",
+                    request.JellyfinLibraryId.ToString(CultureInfo.InvariantCulture),
+                    request.ShowId.ToString(CultureInfo.InvariantCulture),
+                    GetBaseUrl(scanId)
+                };
 
-        if (request.DeepScan)
-        {
-            arguments.Add("--deep");
+                if (request.DeepScan)
+                {
+                    arguments.Add("--deep");
+                }
+
+                return await base.PerformScan(parameters, arguments, cancellationToken);
+            }
+            finally
+            {
+                _scannerProxyService.EndScan(scanId);
+            }
         }
 
-        return await base.PerformScan(scanner, arguments, cancellationToken);
+        return BaseError.New($"Library {request.JellyfinLibraryId} is already scanning");
     }
 
-    protected override Task<DateTimeOffset> GetLastScan(
+    protected override Task<Tuple<string, DateTimeOffset>> GetLastScan(
         TvContext dbContext,
         SynchronizeJellyfinShowById request,
         CancellationToken cancellationToken) =>
-        Task.FromResult(DateTimeOffset.MinValue);
+        Task.FromResult(new Tuple<string, DateTimeOffset>(string.Empty, DateTimeOffset.MinValue));
 
     protected override bool ScanIsRequired(
         DateTimeOffset lastScan,

ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecretsHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Jellyfin;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace ErsatzTV.Application.Jellyfin;
 
@@ -12,16 +13,19 @@ public class SaveJellyfinSecretsHandler : IRequestHandler<SaveJellyfinSecrets, E
     private readonly IJellyfinApiClient _jellyfinApiClient;
     private readonly IJellyfinSecretStore _jellyfinSecretStore;
     private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMemoryCache _memoryCache;
 
     public SaveJellyfinSecretsHandler(
         IJellyfinSecretStore jellyfinSecretStore,
         IJellyfinApiClient jellyfinApiClient,
         IMediaSourceRepository mediaSourceRepository,
+        IMemoryCache memoryCache,
         ChannelWriter<IJellyfinBackgroundServiceRequest> channel)
     {
         _jellyfinSecretStore = jellyfinSecretStore;
         _jellyfinApiClient = jellyfinApiClient;
         _mediaSourceRepository = mediaSourceRepository;
+        _memoryCache = memoryCache;
         _channel = channel;
     }
 
@@ -32,8 +36,10 @@ public class SaveJellyfinSecretsHandler : IRequestHandler<SaveJellyfinSecrets, E
 
     private async Task<Validation<BaseError, Parameters>> Validate(SaveJellyfinSecrets request)
     {
+        var connectionParameters = new JellyfinConnectionParameters(request.Secrets.Address, request.Secrets.ApiKey, 0);
+
         Either<BaseError, JellyfinServerInformation> maybeServerInformation = await _jellyfinApiClient
-            .GetServerInformation(request.Secrets.Address, request.Secrets.ApiKey);
+            .GetServerInformation(connectionParameters.Address, connectionParameters.AuthorizationHeader);
 
         return maybeServerInformation.Match(
             info => Validation<BaseError, Parameters>.Success(new Parameters(request.Secrets, info)),
@@ -47,6 +53,7 @@ public class SaveJellyfinSecretsHandler : IRequestHandler<SaveJellyfinSecrets, E
             parameters.Secrets.Address,
             parameters.ServerInformation.ServerName,
             parameters.ServerInformation.OperatingSystem);
+        _memoryCache.Remove(new GetJellyfinConnectionParameters());
         await _channel.WriteAsync(new SynchronizeJellyfinMediaSources());
 
         return Unit.Default;

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinCollections.cs

@@ -2,6 +2,6 @@ using ErsatzTV.Core;
 
 namespace ErsatzTV.Application.Jellyfin;
 
-public record SynchronizeJellyfinCollections(int JellyfinMediaSourceId, bool ForceScan) :
+public record SynchronizeJellyfinCollections(int JellyfinMediaSourceId, bool ForceScan, bool DeepScan) :
     IRequest<Either<BaseError, Unit>>,
     IScannerBackgroundServiceRequest;