prep for release v25.5.0 [no ci]

* fix segmenter v2 with videotoolbox

* more capabilities checks

.config/dotnet-tools.json

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

.editorconfig

@@ -1,9 +1,8 @@
-
 [*]
 charset=utf-8
 end_of_line=lf
-trim_trailing_whitespace=false
-insert_final_newline=false
+trim_trailing_whitespace=true
+insert_final_newline=true
 indent_style=space
 indent_size=4
 
@@ -15,7 +14,7 @@ csharp_style_expression_bodied_constructors=true:none
 csharp_style_expression_bodied_methods=true:none
 csharp_style_expression_bodied_properties=true:suggestion
 csharp_style_var_elsewhere=false:suggestion
-csharp_style_var_for_built_in_types=false:suggestion
+csharp_style_var_for_built_in_types=false:none
 csharp_style_var_when_type_is_apparent=true:suggestion
 dotnet_naming_rule.local_constants_rule.severity=warning
 dotnet_naming_rule.local_constants_rule.style=all_upper_style
@@ -42,6 +41,8 @@ resharper_braces_for_for=required
 resharper_braces_for_foreach=required
 resharper_braces_for_ifelse=required
 resharper_braces_for_while=required
+resharper_csharp_arguments_literal=positional
+resharper_csharp_arguments_named=positional
 resharper_csharp_insert_final_newline=true
 resharper_csharp_max_attribute_length_for_same_line=0
 resharper_csharp_place_accessorholder_attribute_on_same_line=never
@@ -66,7 +67,7 @@ resharper_built_in_type_reference_style_highlighting=hint
 resharper_redundant_base_qualifier_highlighting=warning
 resharper_suggest_var_or_type_built_in_types_highlighting=hint
 resharper_suggest_var_or_type_elsewhere_highlighting=hint
-resharper_suggest_var_or_type_simple_types_highlighting=hint
+resharper_suggest_var_or_type_simple_types_highlighting=none
 resharper_web_config_module_not_resolved_highlighting=warning
 resharper_web_config_type_not_resolved_highlighting=warning
 resharper_web_config_wrong_module_highlighting=warning
@@ -84,7 +85,22 @@ tab_width=4
 indent_style = space
 indent_size = 2
 
+[*.json]
+ij_json_array_wrapping = normal
+ij_json_keep_blank_lines_in_code = 0
+ij_json_keep_indents_on_empty_lines = false
+ij_json_keep_line_breaks = true
+ij_json_keep_trailing_comma = false
+ij_json_object_wrapping = normal
+ij_json_property_alignment = do_not_align
+ij_json_space_after_colon = true
+ij_json_space_after_comma = true
+ij_json_space_before_colon = false
+ij_json_space_before_comma = false
+ij_json_spaces_within_braces = true
+ij_json_spaces_within_brackets = true
+ij_json_wrap_long_lines = false
 
 [*.cs]
 # disable CA1848: Use the LoggerMessage delegates`
-dotnet_diagnostic.ca1848.severity = none
+dotnet_diagnostic.ca1848.severity = none

.gitattributes

@@ -0,0 +1,8 @@
+# Auto detect text files and perform LF normalization
+*          text=auto
+
+*.cs       text diff=csharp
+*.cshtml   text diff=html
+*.csx      text diff=csharp
+*.sln      text eol=crlf
+*.csproj   text eol=crlf

.github/workflows/artifacts.yml

@@ -29,14 +29,13 @@ jobs:
   build_and_upload_mac:
     name: Mac Build & Upload
     runs-on: ${{ matrix.os }}
-    if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
-          - os: macos-11
+          - os: macos-14
             kind: macOS
             target: osx-x64
-          - os: macos-11
+          - os: macos-14
             kind: macOS
             target: osx-arm64
     steps:
@@ -46,10 +45,10 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Setup .NET Core
+      - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -73,8 +72,8 @@ jobs:
         shell: bash
         run: |
           sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net8.0 --runtime "${{ matrix.target }}" -c Release -o publish -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 net8.0 --runtime "${{ matrix.target }}" -c Release -o publish -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 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
 
       - name: Bundle
         shell: bash
@@ -87,7 +86,7 @@ jobs:
       - name: Sign
         shell: bash
         run: scripts/macOS/sign.sh
-      
+
       - name: Create DMG
         shell: bash
         run: |
@@ -102,6 +101,7 @@ jobs:
             --hide-extension "ErsatzTV.app" \
             --app-drop-link 600 185 \
             --skip-jenkins \
+            --no-internet-enable \
             "ErsatzTV.dmg" \
             "ErsatzTV.app/"
 
@@ -125,22 +125,20 @@ jobs:
           token: ${{ secrets.gh_token }}
           tag: ${{ inputs.release_tag }}
           fail-if-no-assets: false
-          assets: |
-            *${{ matrix.target }}.dmg
+          assets: "*${{ matrix.target }}.dmg"
 
       - name: Publish
         uses: softprops/action-gh-release@v1
         with:
-          prerelease: true
+          prerelease: false
           tag_name: ${{ inputs.release_tag }}
-          files: |
-            ${{ env.RELEASE_NAME }}.dmg
+          files: "${{ env.RELEASE_NAME }}.dmg"
         env:
           GITHUB_TOKEN: ${{ secrets.gh_token }}
-  build_and_upload:
-    name: Build & Upload
+
+  build_and_upload_linux:
+    name: Build & Upload Linux
     runs-on: ${{ matrix.os }}
-    if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
@@ -149,23 +147,23 @@ jobs:
             target: linux-x64
           - os: ubuntu-latest
             kind: linux
-            target: linux-arm
+            target: linux-musl-x64
           - os: ubuntu-latest
+            kind: linux
+            target: linux-arm
+          - os: ubuntu-24.04-arm
             kind: linux
             target: linux-arm64
-          - os: windows-latest
-            kind: windows
-            target: win-x64
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
-      - name: Setup .NET Core
+      - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -173,14 +171,6 @@ jobs:
       - name: Install dependencies
         run: dotnet restore -r "${{ matrix.target }}"
 
-      - uses: suisei-cn/actions-download-file@v1.3.0
-        if: ${{ matrix.kind == 'windows' }}
-        id: downloadffmpeg
-        name: Download ffmpeg
-        with:
-          url: "https://github.com/ErsatzTV/ErsatzTV-ffmpeg/releases/download/6.1-working-cuvid/ffmpeg-6.1-working-cuvid.7z"
-          target: ffmpeg/
-
       - name: Build
         shell: bash
         run: |
@@ -190,28 +180,12 @@ jobs:
 
           # Build everything
           sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net8.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -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 net8.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-
-          # Build Windows launcher
-          if [ "${{ matrix.kind }}" == "windows" ]; then
-            cargo build --manifest-path=ErsatzTV-Windows/Cargo.toml --release --all-features
-            ls -l ErsatzTV-Windows/target/release
-            mv ErsatzTV-Windows/target/release/ersatztv_windows.exe "$release_name/ErsatzTV-Windows.exe"
-          fi
-
-          # Download ffmpeg
-          if [ "${{ matrix.kind }}" == "windows" ]; then
-            7z e "ffmpeg/${{ steps.downloadffmpeg.outputs.filename }}" -o"$release_name" '*.exe' -r
-            rm -f "$release_name/ffplay.exe"
-          fi
-
-          # Pack files
-          if [ "${{ matrix.kind }}" == "windows" ]; then
-            7z a -tzip "${release_name}.zip" "./${release_name}/*"
-          else
-            tar czvf "${release_name}.tar.gz" "$release_name"
-          fi
+          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
+          mkdir "$release_name"
+          mv scanner/* "$release_name/"
+          mv main/* "$release_name/"
+          tar czvf "${release_name}.tar.gz" "$release_name"
 
           # Delete output directory
           rm -r "$release_name"
@@ -223,17 +197,128 @@ jobs:
           token: ${{ secrets.gh_token }}
           tag: ${{ inputs.release_tag }}
           fail-if-no-assets: false
-          assets: |
-            *${{ matrix.target }}.zip
-            *${{ matrix.target }}.tar.gz
+          assets: "*${{ matrix.target }}.tar.gz"
 
       - name: Publish
         uses: softprops/action-gh-release@v1
         with:
-          prerelease: true
+          prerelease: false
           tag_name: ${{ inputs.release_tag }}
-          files: |
-            ${{ env.RELEASE_NAME }}.zip
-            ${{ env.RELEASE_NAME }}.tar.gz
+          files: "${{ env.RELEASE_NAME }}.tar.gz"
+        env:
+          GITHUB_TOKEN: ${{ secrets.gh_token }}
+
+  build_dotnet_windows:
+    name: Build dotnet for Windows
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 9.0.203
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore -r "win-x64"
+
+      - name: Build dotnet projects
+        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
+
+      - name: Upload .NET Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dotnet-windows-build
+          path: |
+            scanner/
+            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]
+    steps:
+      - name: Download dotnet artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dotnet-windows-build
+          path: dotnet-build
+
+      - name: Download rust artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: rust-windows-build
+          path: rust-build
+
+      - name: Download ffmpeg
+        uses: suisei-cn/actions-download-file@v1.3.0
+        id: downloadffmpeg
+        with:
+          url: "https://github.com/ErsatzTV/ErsatzTV-ffmpeg/releases/download/7.1.1/ffmpeg-n7.1.1-56-gc2184b65d2-win64-gpl-7.1.zip"
+          target: ffmpeg/
+
+      - name: Package artifacts
+        shell: bash
+        run: |
+          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"
+          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}/*"
+
+      - name: Delete old release assets
+        uses: mknejp/delete-release-assets@v1
+        if: ${{ inputs.release_tag == 'develop' }}
+        with:
+          token: ${{ secrets.gh_token }}
+          tag: ${{ inputs.release_tag }}
+          fail-if-no-assets: false
+          assets: "*win-x64.zip"
+
+      - name: Publish
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: false
+          tag_name: ${{ inputs.release_tag }}
+          files: "${{ env.RELEASE_NAME }}.zip"
         env:
           GITHUB_TOKEN: ${{ secrets.gh_token }}

.github/workflows/ci.yml

@@ -19,14 +19,14 @@ jobs:
           tag=$(git describe --tags --abbrev=0)
           tag2="${tag:1}"
           short=$(git rev-parse --short HEAD)
-          final="${tag2/beta/$short}"
+          final="${tag2}-${short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
       - name: Extract Artifacts Version
         shell: bash
         run: |
           tag=$(git describe --tags --abbrev=0)
           short=$(git rev-parse --short HEAD)
-          final="${tag/beta/$short}"
+          final="${tag}-${short}"
           echo "ARTIFACTS_VERSION=${final}" >> $GITHUB_ENV
           echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
     outputs:
@@ -46,7 +46,7 @@ jobs:
       ac_username: ${{ secrets.AC_USERNAME }}
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
-  build_and_push:
+  build_images:
     uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version
     with:

.github/workflows/docker.yml

@@ -1,4 +1,4 @@
-name: Build & Publish to Docker Hub
+name: Build & Publish to Docker Hub
 on:
   workflow_call:
     inputs:
@@ -20,33 +20,28 @@ on:
       docker_hub_access_token:
         required: true
 jobs:
-  build_and_push:
-    name: Build & Publish
-    runs-on: ubuntu-latest
+  build_images:
+    name: Build ${{ matrix.name }} image
+    runs-on: ${{ matrix.os }}
     if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
-          - name: base
+          - name: amd64
+            os: ubuntu-latest
             path: ''
-            suffix: ''
-            qemu: false
-          - name: nvidia
-            path: 'nvidia/'
-            suffix: '-nvidia'
-            qemu: false
-          - name: vaapi
-            path: 'vaapi/'
-            suffix: '-vaapi'
-            qemu: false
+            suffix: '-amd64'
+            platform: 'linux/amd64'
           - name: arm32v7
+            os: ubuntu-latest
             path: 'arm32v7/'
             suffix: '-arm'
-            qemu: true
+            platform: 'linux/arm/v7'
           - name: arm64
+            os: ubuntu-24.04-arm
             path: 'arm64/'
             suffix: '-arm64'
-            qemu: true
+            platform: 'linux/arm64'
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -54,12 +49,11 @@ jobs:
           fetch-depth: 0
 
       - name: Set up QEMU
+        if: ${{ matrix.name == 'arm32v7' }}
         uses: docker/setup-qemu-action@v3
-        if: ${{ matrix.qemu == true }}
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
-        id: docker-buildx
 
       - name: Login to DockerHub
         uses: docker/login-action@v3
@@ -67,46 +61,81 @@ jobs:
           username: ${{ secrets.docker_hub_username }}
           password: ${{ secrets.docker_hub_access_token }}
 
-      - name: Build and push
-        uses: docker/build-push-action@v5
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
         with:
-          builder: ${{ steps.docker-buildx.outputs.name }}
-          context: .
-          file: ./docker/${{ matrix.path }}Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
-          tags: |
-            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
-            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
-        if: ${{ matrix.name != 'arm64' && matrix.name != 'arm32v7' }}
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push
+      - name: Build and push by digest
+        id: build
         uses: docker/build-push-action@v5
         with:
-          builder: ${{ steps.docker-buildx.outputs.name }}
           context: .
           file: ./docker/${{ matrix.path }}Dockerfile
           push: true
-          platforms: 'linux/arm64'
+          provenance: false
+          platforms: ${{ matrix.platform }}
           build-args: |
             INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
-          tags: |
-            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
-            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
-        if: ${{ matrix.name == 'arm64' }}
+          outputs: |
+            type=image,name=jasongdove/ersatztv,name-canonical=true,push-by-digest=true
+            type=image,name=ghcr.io/ersatztv/ersatztv,name-canonical=true,push-by-digest=true
 
-      - name: Build and push
-        uses: docker/build-push-action@v5
+      - name: Save digest to artifact
+        run: echo ${{ steps.build.outputs.digest }} > digest.txt
+
+      - name: Upload digest artifact
+        uses: actions/upload-artifact@v4
         with:
-          builder: ${{ steps.docker-buildx.outputs.name }}
-          context: .
-          file: ./docker/${{ matrix.path }}Dockerfile
-          push: true
-          platforms: 'linux/arm/v7'
-          build-args: |
-            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
-          tags: |
-            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
-            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
-        if: ${{ matrix.name == 'arm32v7' }}
+          name: digest-${{ matrix.name }}
+          path: digest.txt
+
+  merge_manifests:
+    name: Merge Manifests
+    runs-on: ubuntu-latest
+    needs: build_images
+    steps:
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.docker_hub_username }}
+          password: ${{ secrets.docker_hub_access_token }}
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download all digest artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: digests/
+
+      - name: Read digests from artifacts
+        id: digests
+        run: |
+          AMD64_HASH=$(cat digests/digest-amd64/digest.txt)
+          ARM32V7_HASH=$(cat digests/digest-arm32v7/digest.txt)
+          ARM64_HASH=$(cat digests/digest-arm64/digest.txt)
+
+          DOCKER_HUB_DIGESTS="jasongdove/ersatztv@${AMD64_HASH} jasongdove/ersatztv@${ARM64_HASH} jasongdove/ersatztv@${ARM32V7_HASH}"
+          GHCR_DIGESTS="ghcr.io/ersatztv/ersatztv@${AMD64_HASH} ghcr.io/ersatztv/ersatztv@${ARM64_HASH} ghcr.io/ersatztv/ersatztv@${ARM32V7_HASH}"
+
+          echo "docker_hub_digests=${DOCKER_HUB_DIGESTS}" >> $GITHUB_OUTPUT
+          echo "ghcr_digests=${GHCR_DIGESTS}" >> $GITHUB_OUTPUT
+
+      - name: Create and push manifests
+        run: |
+          docker manifest create jasongdove/ersatztv:${{ inputs.base_version }} ${{ steps.digests.outputs.docker_hub_digests }}
+          docker manifest push jasongdove/ersatztv:${{ inputs.base_version }}
+          docker manifest create jasongdove/ersatztv:${{ inputs.tag_version }} ${{ steps.digests.outputs.docker_hub_digests }}
+          docker manifest push jasongdove/ersatztv:${{ inputs.tag_version }}
+
+          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }} ${{ steps.digests.outputs.ghcr_digests }}
+          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}
+          docker manifest create ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }} ${{ steps.digests.outputs.ghcr_digests }}
+          docker manifest push ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}

.github/workflows/issue-stale.yml

@@ -0,0 +1,27 @@
+name: 'Close stale issues'
+
+on:
+  schedule:
+    - cron: '30 1 * * *'
+  workflow_dispatch:
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v9
+        with:
+          ascending: true
+          days-before-stale: 120
+          days-before-pr-stale: -1
+          days-before-close: 21
+          days-before-pr-close: -1
+          operations-per-run: 500
+          exempt-issue-labels: 'regression,security,roadmap,future,feature,enhancement,confirmed'
+          stale-issue-label: 'stale'
+          stale-issue-message: |-
+            This issue has gone 120 days without an update and will be closed within 21 days if there is no new activity. To prevent this issue from being closed, please confirm the issue has not already been fixed by providing updated examples or logs.
+
+            If you have any questions you can use one of several ways to [contact us](https://ersatztv.org).
+          close-issue-message: |-
+            This issue was closed due to inactivity.

.github/workflows/pr.yml

@@ -8,10 +8,10 @@ jobs:
       - name: Get the sources
         uses: actions/checkout@v4
 
-      - name: Setup .NET Core
+      - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -33,32 +33,43 @@ jobs:
           cd ErsatzTV-Windows
           cargo build --release --all-features
   build_and_test_linux:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: linux-x64
+          - os: ubuntu-latest
+            target: linux-musl-x64
+          - os: ubuntu-latest
+            target: linux-arm
+          - os: ubuntu-24.04-arm
+            target: linux-arm64
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
 
-      - name: Setup .NET Core
+      - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
 
       - name: Install dependencies
-        run: dotnet restore
+        run: dotnet restore -p:RestoreEnablePackagePruning=true -r "${{ matrix.target }}"
 
       - name: Prep project file
         run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
 
       - name: Build
-        run: dotnet build --configuration Release --no-restore
+        run: dotnet build ErsatzTV/ErsatzTV.csproj --runtime "${{ matrix.target }}" --configuration Release --no-restore && dotnet build --configuration Release --no-restore
 
       - name: Test
         run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
   build_and_test_mac:
-    runs-on: macos-11
+    runs-on: macos-14
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
@@ -66,10 +77,10 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Setup .NET Core
+      - name: Setup dotnet
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 9.0.203
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear

.github/workflows/release.yml

@@ -16,7 +16,7 @@ jobs:
         run: |
           tag=$(git describe --tags --abbrev=0)
           echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
-          echo "DOCKER_TAG=${tag/-beta/}" >> $GITHUB_ENV
+          echo "DOCKER_TAG=${tag}" >> $GITHUB_ENV
       - name: Extract Artifacts Version
         shell: bash
         run: |
@@ -41,7 +41,7 @@ jobs:
       ac_username: ${{ secrets.AC_USERNAME }}
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
-  build_and_push:
+  build_images:
     uses: ersatztv/ersatztv/.github/workflows/docker.yml@main
     needs: calculate_version
     with:

.gitignore

@@ -40,6 +40,7 @@ msbuild.wrn
 core
 
 scripts/generate-api-sdk/swagger.json
+scripts/download-test-content.sh
 
 docker-compose.override.yml
 

CHANGELOG.md

@@ -1,10 +1,764 @@
-# Changelog
+# Changelog
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [25.5.0] - 2025-09-01
+### Added
+- Add *experimental* graphics engine
+  - All watermarks will use new graphics engine
+- Add `Opacity Expression` watermark mode
+  - This allows specifying an expression that returns an opacity between 0.0 and 1.0
+  - The expression can use:
+    - `content_seconds` - the total number of seconds the frame is into the content
+    - `content_total_seconds` - the total number of seconds in the content
+    - `channel_seconds` - the total number of seconds the frame is from when the channel started/activated
+    - `time_of_day_seconds` - the total number of seconds the frame is since midnight
+  - The expression can also use functions:
+    - `LinearFadeDuration(time, start, fadeSeconds, peakSeconds)`
+    - `LinearFadePoints(time, start, peakStart, peakEnd, end)`
+- Add `Z-Index` to watermark editor
+  - The graphics engine will order by z-index when overlaying watermarks
+- Add *experimental* `Graphics Element` template system
+  - Graphics elements are defined in YAML files inside ETV config folder / templates / graphics-elements subfolder
+  - Add `text` graphics element type
+    - Supported in playback troubleshooting and YAML playouts
+    - Displays multi-line text in a specified font, color, location, z-index
+    - Supports constant opacity and opacity expression
+    - Supports EPG and Media Item variable replacement
+      - 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
+  - Add `image` graphics element type
+    - Supported in playback troubleshooting and YAML playouts
+    - Displays an image, similar to a watermark
+    - Supports constant opacity and opacity expression
+  - Add `subtitle` graphics element type
+    - Supported in playback troubleshooting and YAML playouts
+    - Supports SRT and SSA/ASS subtitle formats
+    - Supports EPG and Media Item variable replacement
+      - 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
+- YAML playout: add `graphics_on` and `graphics_off` instructions to control graphics elements
+  - `graphics_on` requires the name of a graphics element template, e.g. `text/cool_element.yml`
+    - The `variables` property can be used to dynamically replace text from the template
+  - `graphics_off` will turn off a specific element, or all elements if none are specified
+- Add `Seek Seconds` to playback troubleshooting to support capturing timing-related issues
+- Custom stream selector: add `content_condition` to allow channel and time-of-day based decisions
+  - `content_condition` expression can use
+    - `channel_number`
+    - `channel_name`
+    - `time_of_day_seconds` - the start time for the current item, represented in seconds since midnight
+- Add support for external chapter files next to video files
+  - Currently supports Matroska Chapter XML format
+    - Chapter files have .xml or .chapters extension
+- Add targeted (single-show) library scanning
+  - Supports quick and deep scans
+  - Can be triggered from the `Scan` button on show pages
+  - Can be triggered by API call to `/api/libraries/{library-id}/scan-show`
+- Add XMLTV setting `XMLTV Block Behavior` to control how block schedules appear in the EPG
+  - `Split Time Evenly` - default (existing) behavior; block time is split among all items that are visible in the EPG
+  - `Use Actual Times` - actual times are used for all items that are visible in the EPG
+    - This will introduce EPG gaps when filler is used, or when items are hidden from the EPG
+- Add *experimental* `Scripted Schedule` playout system
+  - This system uses python scripts to support the highest degree of customization
+  - The goal is to expose methods equivalent to all sequential schedule (YAML) instructions
+- YAML and Scripted schedules: add `offline_tail` and `stop_before_end` to `pad_to_next` instruction
+  - Both parameters default to `true`
+
+### Fix
+- Fix database operations that were slowing down playout builds
+  - YAML playouts in particular should build significantly faster
+- Fix channel playout mode `On Demand` for Block and YAML schedules
+- Fix QSV transitions when remote streaming from a media server
+- Fix green output when padding with VAAPI accel and i965 driver
+- Fix watermark custom image validation
+- Fix playback when using any watermarks that were saved with invalid state (no image)
+- Fix overlapping block playout items caused by `Stop scheduling block items` value `After Duration End`
+  - Existing overlapping items will not be removed, but no new overlapping items will be created
+  - Until these existing items age out, there will be warnings logged after each playout build/extension
+- Fix playback of anamorphic content from Jellyfin
+  - This fix requires a manual deep scan of any affected Jellyfin library
+- Fix bug where multiple Plex servers would mix their episodes
+- Fix incorrect media item counts after removing paths from local libraries
+- Fix song playback in playback troubleshooting
+- Fix seeking into extracted text subtitles
+- Fix error when changing default (lowest priority) alternate schedule
+- Fix remote library editing, tv shows, artists with MySql/MariaDB
+- Classic schedules: fix alternate schedule transitions (some edge cases would cause days to be skipped completely)
+- Classic schedules: always start new alternate schedules with the first schedule item
+- Classic Schedules: log offline gaps longer than 1 hour due to strict fixed start times
+- Fix `HLS Segmenter V2` streaming mode with AMF acceleration
+- Fix `HLS Segmenter V2` streaming mode with VideoToolbox acceleration
+- Fix startup process for database and search index initialization
+  - Redirect all pages to home page when initializing to prevent errors
+  - Clear stale sqlite migration lock on startup to prevent getting stuck on database initialization
+- Fix display of long season placeholder text (when season posters are unavailable)
+
+### Changed
+- Rename some schedule and playout terms for clarity
+  - Schedules are used to build playouts and are what actually differs
+  - The playout is the end result, and is the same no matter what schedule kind is used
+  - Supported schedule kinds:
+    - `Classic Schedules`
+    - `Block Schedules`
+    - `Sequential Schedules` (formerly `YAML Schedules` or `YAML Playouts`)
+    - `Scripted Schedules`
+    - `JSON (dizqueTV) Schedules` (formerly `External JSON Playouts`)
+- Allow multiple watermarks in playback troubleshooting
+- Classic schedules: allow selecting multiple watermarks on schedule items
+- Block schedules: allow selecting multiple watermarks on decos
+- Block schedules: change available watermark modes on decos. For reference, the levels from highest to lowest with block schedules are `Global` > `Channel` > `Playout Default Deco` > `Template Deco`.
+  - `Inherit` - Use watermarks configured at a higher level
+  - `Disable` - Disable watermarks at this level and above
+  - `Replace` - Replace all watermarks configured at a higher level with those on this deco
+    - This was renamed from `Override`
+  - `Merge` - Merge all watermarks configured at a higher level with those on this deco
+- YAML playout: `watermark` instruction changes:
+  - When value is `true`, will add named watermark to list of active watermarks
+  - When value is `false` and `name` is specified, will remove named watermark from list of active watermarks
+  - When value is `false` and `name` is not specified, will clear all active watermarks
+- Use consistent UI sorting and validation, and fix renaming errors for
+  - Block groups, blocks
+  - Template groups, templates
+  - Deco groups, decos
+  - Deco template groups, deco templates
+
+## [25.4.0] - 2025-08-05
+### Added
+- Add `Troubleshoot Playback` to overflow menu on all media cards
+  - This should eliminate the need to lookup media ids for content
+- Add subtitle selection to playback troubleshooting. This is limited to:
+  - Sidecar text subtitles (e.g. `srt` files)
+  - Embedded image subtitles
+  - Embedded text subtitles that have already been extracted by ETV
+- Add light mode and light/dark mode toggle to app bar
+- YAML playout: add `pre_roll` instruction to enable and disable a pre-roll sequence
+  - With value of `true` and `sequence` property, will enable automatic pre-roll for all content in the playout to the sequence with the provided key
+  - With value of `false`, will disable automatic pre-roll in the playout
+- YAML playout: add `post_roll` instruction to enable and disable a post-roll sequence
+  - With value of `true` and `sequence` property, will enable automatic post-roll for all content in the playout to the sequence with the provided key
+  - With value of `false`, will disable automatic post-roll in the playout
+- YAML playout: add `mid_roll` instruction to enable and disable a mid-roll sequence
+  - With value of `true` and `sequence` property, will enable automatic mid-roll for (`count` and `all`) content in the playout to the sequence with the provided key
+  - With value of `false`, will disable automatic post-roll in the playout
+  - `expression` can be used to influence which chapters are selected for mid roll (same as in filler preset)
+- YAML playout: add `rewind` instruction to set start of playout relative to the current time
+  - Value should be formatted as `HH:MM:SS` e.g. `00:05:30` for 5 minutes 30 seconds (before now)
+  - This is instruction is mostly useful for debugging transitions, and can only be used as a reset instruction
+- YAML playout: add `import` section to allow importing partial YAML definitions that include `content` and `sequence` entries
+- Add YAML playout validation (using JSON Schema)
+  - Invalid YAML playout definitions will fail to build and will log validation failures as warnings
+  - `content` is fully validated
+  - `sequence` is fully validated
+  - `reset` is fully validated
+  - `playout` is fully validated
+- Add `Playlist` collection type to filler presets
+  - This will force filler mode `Count`
+  - Whenever the filler is used, it will schedule `Count` times full time through the playlist
+    - If the playlist has 3 items and none set to play all, it will schedule 3 items when `Count = 1`
+    - If the playlist has 3 items and none set to play all, it will schedule 6 items when `Count = 2`
+  - Using the same playlist in the same schedule for anything other than filler may cause undesired behavior
+- Detect supported VideoToolbox hardware decoders and encoders
+  - Software decoders/encoders will automatically be used when hardware versions are unavailable
+- Add VideoToolbox Capabilities to Troubleshooting page
+- Add `Use Chapters As Media Items` option to filler preset
+  - This option allows scheduling individual chapters as filler
+  - The chapters are shuffled or otherwise sorted together just like normal filler would be
+- Add smart collection edit page to allow renaming smart collections
+  - Previous edit link behavior (performing search using smart collection query) now uses magnifying glass icon
+- Add channel `Transcode Mode` setting
+  - This setting is currently disabled and only has the value `On Demand`
+- Add channel `Idle Behavior` setting to control the transcoding behavior after all clients have disconnected
+  - `Stop On Disconnect` - stops the transcoder after all clients have disconnected + the global idle timeout
+  - `Keep Running` - transcoder will run until manually stopped
+- Add support for music video thumbnails that end in `-thumb`
+  - For example `Music Video.mkv` could have a corresponding thumbnail `Music Video-thumb.jpg`
+- Reorganize troubleshooting page
+  - Add `YAML Validation` tool in `Troubleshooting` > `Tools`
+
+### Fixed
+- Fix app startup with MySql/MariaDB
+- YAML playout: fix `pad_to_next` always running over time
+- Fix playback with text subtitles when seeking into content, i.e. when first joining a channel
+- Fix playback with `.ass` and `.ssa` text subtitles
+- Fix green padding with 10-bit source content and i965 VAAPI driver
+- Fix building playouts with empty schedules
+- Fix schedule start time calculation when daily playout build goes beyond midnight and into a different alternate schedule
+- Fix compatibility with older NVIDIA devices (compute capability 3.0+) in unified docker image
+- Fix transitions when using NVIDIA, QSV and VAAPI acceleration
+- Fix playback of remote streams on channels where framerate normalization is enabled
+
+### Changed
+- Always tell ffmpeg to stop encoding with a specific duration
+  - This was removed to try to improve transitions with ffmpeg 7.x, but has been causing issues with other content
+- Move search debug logging to its own log category; add `Searching Minimum Log Level` to `Settings` > `Logging`
+- Classic schedules: always schedule the full `Duration` amount instead of stopping mid-duration
+  - This allows duration items to be scheduled beyond midnight
+  - e.g. fixed start time 22:00 with 4 hour duration will schedule until 02:00 instead of stopping at midnight
+- Rename channel setting `Progress Mode` to `Playout Mode`
+  - This controls the progression of the channel's playout, and has nothing to do with transcoding
+  - `Always` is now called `Continuous` (playout progresses with wall clock)
+  - `On Demand` is unchanged (playout only progresses while a client is watching the channel)
+- Replace channel `Active Mode` setting with new `Is Enabled` and `Show In EPG` settings
+  - `Active` channels will be converted to `Is Enabled` = true and `Show In EPG` = true
+  - `Hidden` channels will be converted to `Is Enabled` = true and `Show In EPG` = false
+  - `Inactive` channels will be converted to `Is Enabled` = false and `Show In EPG` = false
+
+## [25.3.1] - 2025-07-24
+### Fixed
+- Fix fallback filler playback
+
+## [25.3.0] - 2025-07-24
+### Added
+- Add new channel stream (audio and subtitle) selector system
+  - Channel editor has a new field `Stream Selector Mode`
+    - `Default` maintains existing behavior
+    - `Custom` uses a YAML config file
+  - The YAML config contains a prioritized list of stream selector "items" (audio and subtitle criteria pairs)
+  - The items are tested against the media from top to bottom, and when (at least) a matching audio track is found, stream selection occurs
+  - As an example, the custom stream selector config can specify (in priority order):
+    - english audio (and disable subtitles)
+    - any other audio (and english subtitles, if they exist)
+  - Criteria can include
+    - Stream language
+    - Stream title (allowed title and/or blocked title)
+    - Stream condition, which is an expression that can use
+      - `id` (index)
+      - `title`
+      - `lang`
+      - `default`
+      - `forced`
+      - `sdh` (subtitle only)
+      - `external` (subtitle only)
+      - `codec`
+      - `channels` (audio only)
+    - An example subtitle condition: `lang like 'en%' and external`
+    - An example audio condition: `title like '%movie%' and channels > 2`
+- Add new channel setting `Active Mode`
+  - `Active` - default value, channel streams as normal and has normal visibility
+  - `Hidden` - channel streams as normal and is hidden from M3U/XMLTV/HDHR
+  - `Inactive` - channel cannot stream (will 404) and is hidden from M3U/XMLTV/HDHR
+- Synchronize Plex "network" metadata for Plex show libraries
+  - Shows will have new `network` search field
+  - Episodes will have new `show_network` search field
+- YAML playout: add `stop_before_end` setting to `pad_until` and `duration` instructions
+  - When `stop_before_end: false`, content can run over the desired time before executing the next instruction
+- YAML playout: add `offline_tail` setting to `pad_until` instruction
+  - This can be used to stop primary content before the desired time (`stop_before_end: true` and `offline_tail: false`)
+  - You can then have a second `pad_until` with the same target time and different content
+- YAML playout: make `tomorrow` an expression on `pad_until` instruction
+  - `true` and `false` still work as normal
+  - The current time (as a decimal) can also be used in the expression, e.g. `now > 23`
+    - `now = hours + minutes / 60.0 + seconds / 3600.0`
+    - So `10:30 AM` would be `10.5`, `10:45 PM` would be `22.75`, etc
+- YAML playout: make `skip_items` 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 start in the middle of the content
+    - `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
+- 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
+- YAML playout: add `watermark` instruction
+  - With value of `true` and `name` property, will override the watermark in the playout to the watermark with the provided name
+  - With value of `false`, will restore default watermark value (channel watermark, global watermark)
+- Show health check warning and error badges in nav menu
+- Add `Expression` for mid-roll filler to allow custom logic for using or skipping chapter markers
+  - The following parameters can be used:
+    - `total_points`: total number of potential mid-roll points
+    - `matched_points`: number of mid-roll points that have already matched the expression
+    - `total_duration`: total duration of the content, in seconds
+    - `total_progress`: normalized position from 0 to 1
+    - `last_mid_filler`: seconds since last mid-roll filler
+    - `remaining_duration`: duration of the content after this mid-roll point, in seconds
+    - `point`: the position of the mid-roll point, in seconds
+    - `num`: the mid-roll point number, starting with 1
+- Add `Disable Watermarks` checkbox to block items
+  - Block items that have this checked will never display a watermark, even with Deco set to override watermark
+- Add `ETV_MAXIMUM_UPLOAD_MB` environment variable to allow uploading large watermarks
+  - Default value is 10
+- Update ffmpeg health check to link to ErsatzTV-FFmpeg release that contains binaries for win64, linux64, linuxarm64
+- Add `Playback Troubleshooting` page
+  - This tool lets you play specific content without needing a test channel or schedule
+  - You can specify
+    - The media item id (found in ETV media info, and ETV movie URLs)
+    - The ffmpeg profile to use
+    - The watermark to use (if any)
+  - Clicking `Play` will play up to 30 seconds of the specified content using the desired settings
+  - Clicking `Download Results` will generate a zip archive containing:
+    - The FFmpeg report of the playback attempt
+    - The media info for the content
+    - The `Troubleshooting` > `General` output
+- Support `(Part [english number])` name suffixes for multi-part episode grouping, for example:
+  - `Awesome Episode (Part One)`
+  - `Better Episode (Part Two)`
+  - `Not So Great (Part Three)`
+- Add Trakt List option `Auto Refresh` to automatically update list from trakt.tv once each day
+- Add Trakt List option `Generate Playlist` to automatically generate ETV Playlist from matched Trakt List items
+- Read `country` field from movie NFO files and include in search index as `country`
+- Add *experimental* and *incomplete* `Remote Stream` library kind
+    - Remote Stream libraries have fallback metadata added like Other Video libraries (every folder is a tag)
+    - Remote Stream library items consist of YAML (`.yml`) files with the following fields
+      - `url`: the URL of the content that can be played directly by ffmpeg
+      - `script`: the process name and arguments for a command that will output content to stdout
+      - `is_live`: *required* property that indicates whether the remote stream contains live content
+          - When this is set to `true`, ETV cannot work ahead on transcoding this item, which is a necessary tradeoff for supporting live content
+          - When this is set to `false`, ETV will treat the stream as VOD and attempt to work ahead on transcoding like any other local item
+              - This *will* cause errors when the content is actually live, so it's important to configure this correctly
+      - `duration`: when the content is live and does not have duration metadata, this must be provided to allow scheduling
+    - The remote stream definition (YAML file) may provide either a `url` or a `script`
+      - If both are provided, `url` will be used
+- Include number of chapters in search index as `chapters`
+
+### Changed
+- Allow `Other Video` libraries and `Image` libraries to use the same folders
+- Try to mitigate inotify limit error by disabling automatic reloading of `appsettings.json` config files
+- Support `movie`, `musicvideo` and `episodedetails` top-level tags in other video NFO files
+  - Note that no change has been made to the metadata tags that are actually parsed, but this should help with various types of content
+- Remove some limits on multithreading that are no longer needed with latest ffmpeg
+  - Mixed transcoding (software decode, hardware filters/encode) can now use multiple decode threads
+- Split main `Settings` page into multiple pages
+- Update UI layout on all pages to be less cramped and to work better on mobile
+- Add CPU and Video Controller info to `Troubleshooting` > `General` output
+- Enable write-ahead logging (WAL) mode on SQLite databases
+- Add `Multiple Mode` option to schedule items editor and remove support for count values of zero
+  - `Count`: same behavior as before, requires a number of media items to play and will always schedule the same number
+  - `Collection Size`: similar to count of zero before, will play all media items from the collection before continuing to the next schedule item
+  - `Playlist Item Size`: will play all media items from the current playlist item before continuing to the next schedule item
+  - `Multi-Episode Group Size`: will play all media items from the current multi-part episode group, or one ungrouped media item
+- Change watermark width and margins to allow decimals
+- Move `Add To Collection` button to overflow menu on all media cards, and add `Show Media Info` to overflow menu
+  - This allows showing media info for all media kinds
+- Unify on a multi-platform base docker tag (`latest` and `develop`)
+  - `amd64`, `arm64`, `arm/v7` platforms are now all supported in the base docker tag
+  - Other docker platform tags are deprecated and will receive no new updates after the next release
+  - A health check has been added to notify users (on `-arm` or `-arm64` tags) of this change
+
+### Fixed
+- Fix QSV acceleration in docker with older Intel devices
+- Fix HDR transcoding with NVIDIA accel for:
+    - All NVIDIA docker users
+    - Windows NVIDIA users who have set the `ETV_DISABLE_VULKAN` env var
+- Fix audio sync issue with QSV acceleration
+- YAML playout: fix history for marathon and playlist content
+  - This allows playouts to be extended correctly, instead of always resetting to the earliest item in each group
+- Fix using channel External Logo URL as watermark
+- Fix display of SVG channel logo and watermark in admin UI
+  - Existing SVG logos and watermarks will have to be re-uploaded to display properly in the admin UI
+  - This does not affect streaming at all; existing artwork still works fine for streaming
+- Classify HDHR endpoints as streaming endpoints
+  - This allows these endpoints to be accessed through port `ETV_STREAMING_PORT` (default `8409`)
+  - This only matters if you configured `ETV_UI_PORT` to be a different value, which makes UI endpoints inaccessible on the streaming port
+- Update Plex movie/other video plot ("summary") during library deep scan
+- Fix compatibility with ffmpeg 7.2+ when using NVIDIA accel and 10-bit source content
+- Fix some NVIDIA edge cases when media servers don't provide video bit depth information
+- Fix VAAPI tonemap failure
+- Fix green bars after VAAPI tonemap
+- Fix bug where playout mode `Multiple` would ignore fixed start time
+- Fix block playout EPG generation to use `XMLTV Time Zone` setting
+- Fix adding "official" Trakt lists
+- Fix searching for `collection` names with spaces or other special characters, e.g. `collection:"Movies - Action"`
+- Fix QSV transcoding errors when scaling
+- Fix QSV frame freezing in browser
+- Fix some stream continuity issues, and some cases where audio sync is lost at transition
+- Fix HDR transcoding with AMD VAAPI accel
+- Allow paths longer than 255 characters in MySql databases
+
+## [25.2.0] - 2025-06-24
+### Added
+- Add `linux-musl-x64` artifact for users running Alpine x64
+- Add API endpoint to empty trash (POST to `/api/maintenance/empty_trash`)
+  - e.g. `curl -XPOST -d '' http://localhost:8409/api/maintenance/empty_trash`
+- Add remote IP and user agent to HTTP request logging
+- Add environment variables to allow ETV to run UI and streaming on separate ports
+    - `ETV_STREAMING_PORT`: port used for streaming requests, defaults to 8409
+    - `ETV_UI_PORT`: port used for admin UI, defaults to 8409
+- Publish docker images to ghcr.io (`ghcr.io/ersatztv/ersatztv`)
+- Add new option `Fixed Start Time Behavior` to Schedules and Schedule Items
+  - Schedules can set a default behavior for all items
+  - Schedule items can override this default behavior
+  - Possible values are:
+    - `Strict`: Always wait for the exact start time, even if that means waiting (adding unscheduled time) until the next day
+    - `Flexible`: Start scheduling immediately (do not wait) if waiting (adding unscheduled time) would go into the next day
+  - As an example, if the current scheduling time is 6:02 AM and the next schedule item has a fixed start time of 6:00 AM
+    - `Strict` will add nearly 24h (23:58) of unscheduled time so that it can start exactly at 6:00 AM the next day
+    - `Flexible` will NOT add unscheduled time, and will schedule its item at 6:02 AM (which may also affect the scheduling of later items)
+- Add basic HDR transcoding support
+  - VAAPI may use hardware-accelerated tone mapping (when opencl accel is also available)
+  - NVIDIA may use hardware-accelerated tone mapping (when vulkan accel and libplacebo filter are also available)
+  - QSV may use hardware-accelerated tone mapping (when hardware decoding is used)
+  - In all other cases, HDR content will use a software pipeline
+  - The tonemap algorithm can be configured in the ffmpeg profile
+- Use hardware-accelerated padding with VAAPI
+- Add environment variable `ETV_DISABLE_VULKAN`
+  - Any non-empty value will disable use of Vulkan acceleration and force software tonemapping
+  - This may be needed with misbehaving NVIDIA drivers on Windows
+- Add health check error when invalid VAAPI device and VAAPI driver combination is used in an active ffmpeg profile
+  - This makes it obvious when hardware acceleration will not work as configured
+- Add button in schedule editor to clone schedule item
+- Allow YAML playout sequence definitions to reference other sequences
+  - Cycles will be detected and logged, and sequences with cycles will prevent the playout from building
+- Add `repeat` property to YAML sequence instruction
+  - This tells the playout builder how many times this sequence should repeat
+  - Omitting this value is the same as setting it to `1`
+- Add `collection` (name) to search index for manual collections created within ETV
+  - Collections synchronized from media servers are still indexed as `tag`
+- Allow searching by `smart_collection` (name)
+  - Quotes are *always* required around each collection name when using this feature
+    - e.g. `smart_collection:"one" OR smart_collection:"two"`
+  - Cycles will be detected and logged, and searches with cycles will not work as expected
+- Add all `ETV_*` environment variables to Troubleshooting > General info
+- Add `External Logo URL` field to channel editor
+  - Using external (public) logos should fix channel logo display for clients that don't proxy artwork (such as Plex)
+  - Users who have customized the XMLTV channel template `channel.sbntxt` will need to update their templates again
+    - This is because the templates require different logic for external URLs vs ETV-hosted URLs
+
+### Changed
+- Start to make UI minimally responsive (functional on smaller screens)
+- Change how ETV determines which address to use for Plex connections
+  - The active Plex connection (address) will only be cached for 30 seconds
+  - When the connection is no longer cached, a ping will be sent to the last used address for Plex (the last address that had a successful ping)
+  - If the ping is successful, the address will be cached for another 30 seconds
+  - If the ping is not successful, all addresses will be checked again, and the first address to return a successful ping will be cached for 30 seconds
+- Remove requirement to have Jellyfin admin user; user id is no longer required on requests to latest Jellyfin server
+- Upgrade bundled ffmpeg on Windows from 6.1 to 7.1.1
+- Upgrade VAAPI docker image Ubuntu base from 22 to 24; bundled ffmpeg from 6.1 to 7.1.1
+- Upgrade NVIDIA docker image Ubuntu base from 20 to 24; bundled ffmpeg from 6.1 to 7.1.1
+- Upgrade base, arm, arm64 docker images bundled ffmpeg from 6.1 to 7.1.1
+- Unify all hardware acceleration methods in base docker images (`latest` and `develop`)
+  - VAAPI, QSV and NVIDIA are now all supported in the base docker image
+  - Other docker image tags are deprecated and will receive no new updates after the next release
+  - A health check has been added to notify users (on `-vaapi` or `-nvidia` tags) of this change
+- Schedule items editor: show currently selected row using background color instead of font weight
+
+### Fixed
+- Fix error message about synchronizing Plex collections from a Plex server that has zero collections
+- Fix navigation after form submission when using `ETV_BASE_URL` environment variable
+- Fix UI crashes when channel numbers contain a period `.` in locales that have a different decimal separator (e.g. `,`)
+- Fix playout detail table to only reload once when resetting a playout
+- Fix date formatting in playout detail table on reload (will now respect browser's `Accept-Language` header)
+- Use cache busting to avoid UI errors after upgrading the MudBlazor library
+- Fix multi-variant playlist to report more accurate `BANDWIDTH` value based on ffmpeg profile
+- Fix detecting NVIDIA capabilities on Blackwell GPUs
+- Fix decoder selection in NVIDIA pipeline
+- Prevent playback order `Shuffle In Order` from being used with `Fill With Group Mode` as they are incompatible
+- Fix XMLTV items not grouping properly (guide mode: `Filler`) due to post-roll filler
+
+## [25.1.0] - 2025-01-10
+### Added
+- Add `Reset All Playouts` button to top of playouts page
+- Add `rewind_on_reset` option to `wait_until` YAML playout instruction
+  - This option allows YAML playouts to start in the past
+- Add `advance` option to `epg_group` YAML playout instruction
+  - When set to `false`, this option will lock the guide group without starting a new guide group
+  - This can be helpful for "post roll" items that should be part of the previous item's guide group
+- Add `Song Video Mode` to channel settings
+  - `Default` - existing behavior
+  - `With Progress` - show animated progress bar at bottom of generated video
+    - Thanks to @JeckDev for the idea and the artwork
+- Add fallback album art image for songs that have no album art
+- Add `Vaapi Display` option to FFmpeg Profile
+  - Possible values will be install-specific and sourced from `vainfo`
+  - `drm` was the previous default value, and should be used in most cases
+- Test all `Vaapi Display` values in `Troubleshooting` > `VAAPI Capabilities`
+- Add `tag_full` field to search index
+  - This field contains the same values as the existing `tag` field, but it is not analyzed or tokenized
+
+### Changed
+- **BREAKING CHANGE**: Change channel identifiers used in XMLTV to work around bad behavior in Plex
+
+### Fixed
+- Fix startup error with MySql backend caused by database cleaner
+- Fix emptying trash with ElasticSearch backend
+- Fix double loading of trash UI elements, and fix reloading of all UI elements after emptying trash
+- Fix destroying channel preview player when preview dialog is closed
+  - This bug made it difficult to "stop" a channel after previewing it
+- Fix bug where deco default filler would never use hardware acceleration
+- Fix deleting local libraries with MySql backend
+- Fix `Scaling Behavior` `Crop` when content is smaller than FFmpeg Profile resolution
+  - Now, content will properly scale beyond the desired resolution before cropping
+- Fix displaying playout item durations that are greater than 24 hours
+- Fix building playouts when playlist has been changed to have fewer items
+- Fix selecting audio stream with preferred title
+- Fix synchronizing Plex collections
+  - If this breaks collection sync for you, you will need to update your Plex server
+- Fix guide group generation for `duration` YAML instructions
+- Fix default song background when targeting 4:3 resolutions
+  - Previously the background was always 16:9 and was padded, now it will fill 4:3
+
+## [0.8.8-beta] - 2024-09-19
+### Added
+- Add support for Plex Other Video libraries
+  - These libraries will now appear as ETV Other Video libraries
+  - Items in these libraries will have tag metadata added from folders just like local Other Video libraries
+  - Thanks @raknam for adding this feature!
+- Add *experimental* support for `On Demand` channel progress
+  - With `On Demand` channel progress, the playout will only advance when the channel is being streamed
+  - When the channel is idle, the playout is unmodified and will be shifted forward as needed so no content is missed
+  - Setting a channel to `On Demand` progress will disable alternate schedules
+  - The `On Demand` setting will only be used for `Flood` playouts (NOT `Block` or `External JSON`)
+  - It is NOT recommended to use fixed start times with `On Demand` progress
+    - This will probably be disabled with a future update
+- Add `Default Filler` to `Deco` system
+  - After all blocks are scheduled/added to the playout, a second pass will be made to insert filler
+  - Default filler will be shuffled and inserted in all unscheduled time between blocks
+  - Default filler will stop scheduling when the next item would extend into primary content
+  - Alternatively, default filler can be configured to `Trim To Fit`
+    - In this case, the last item that would extend into primary content is trimmed to end exactly when the primary content starts
+- Add **experimental** playout type `YAML`
+  - This playout type uses a YAML file to declare content and describe how the playout should be built
+  - Content currently supports search queries
+  - Playout instructions currently include `count`, `pad to next`, and `repeat`
+    - `count`: add the specified number of items (from the referenced content) to the playout
+    - `duration`: play the referenced content for the specified duration
+    - `pad to next`: add items from the referenced content until the wall clock is a multiple of the specified minutes value
+    - `repeat`: continue building the playout from the first instruction in the YAML file
+- Add channel logo generation by @raknam
+  - Channels without custom uploaded logos will automatically generate a logo that includes the channel name
+- Add two new API endpoints
+  - Reset playout for channel
+    - POST `/api/channels/{channelNumber}/playout/reset`
+  - Scan library
+    - POST `/api/libraries/{libraryId}/scan`
+- Add Deco setting to `Use Watermark During Filler`
+  - This setting is turned OFF by default, meaning filler will NOT use the configured watermark unless this is manually turned on
+- Add `Random Count` filler mode by @embolon
+  - This mode will randomly schedule between zero and the provided count number of items
+  - e.g. random count 3 will schedule between 0 and 3 filler items
+- Add `Random Rotation` playback order for block scheduling by @embolon
+  - This playback order will pick a random item from a randomly selected group (show or artist)
+  - It is somewhat similar to the `Fill With Group` mode used in flood scheduling
+
+### Fixed
+- Add basic cache busting to XMLTV image URLs
+  - This should help with clients not showing correct channel logos or posters
+- Fix artwork in other video libraries by @raknam
+- Fix adding items to empty playlists
+- Fix filler preset editor and deco dead air fallback editor to only show supported collection types
+- Fix infinite loop caused by impossible schedule (all collection items longer than schedule item duration)
+- Fix selecting audio and subtitle streams with two-letter language codes
+- Fix adding pad filler to content that is less than one minute in duration
+- Generate unique identifier for virtual HDHomeRun tuner by @raknam
+  - This allows a single Plex server to connect to multiple ETV instances
+- Include *all* language codes from media library in preferred audio and subtitle language options
+  - Language codes where an English name cannot be found will be at the bottom of the list
+- Fix local libraries to detect external subtitle files with unrecognized language codes
+- Fix playback selection of subtitles with unrecognized language codes
+- Fix incorrectly removing block items that are hidden from EPG when deco filler is applied
+- Fix deco selection when deco is scheduled until midnight
+  - Previously, this deco item would be ignored so watermark and filler would be missing
+- Fix movies with missing medata by generating fallback metadata
+  - This allows these movies to appear in the Trash where they can be deleted
+- Fix synchronizing trakt lists from users with special characters in their username
+  - Note that these lists MUST be added as URLs; the short-form `user/list` will NOT work with special characters
+- Fix local subtitle scanner to detect non-lowercase extensions (e.g. `Movie (2000).EN.SRT`)
+- Fix adding a single image to a manual collection from search results
+- Fix loading manual collection view when collection contains images
+- Fix edge case where block playout history would get stuck and repeat an item
+- Fix adjusting watermark opacity when watermark already contains alpha channel (is already transparent)
+
+### Changed
+- Remove some unnecessary API calls related to media server scanning and paging
+- Improve trakt list URL validation; non-trakt URLs will no longer be requested
+- Prevent saving block templates when blocks are overlapping
+  - This can happen if block durations are changed for blocks that are already on the template
+- Redirect variant playlist request to proper URL for starting `HLS Segmenter` session when no session is active
+  - This can happen when some clients "pause" long enough for the session to stop in ETV
+  - When the client resumes playback, it requests the temp playlist URL which is now invalid e.g. `/iptv/session/1/hls.m3u8` (not the original URL `/iptv/channel/1.m3u8`)
+  - To fix, the client will be redirected back to the original URL in this case which will create a new session
+
+## [0.8.7-beta] - 2024-06-26
+### Added
+- Add `Active Date Range` to block playout template editor to allow limiting templates to a specific date range
+  - This is year-agnostic, meaning the Month/Day range will apply to every year
+  - This also supports wrapping the end of the year (e.g., start 12/1 and end 1/15)
+- Add new `Deco` system for "decorating" channels with non-primary content
+  - Decos currently contain
+    - Watermarks
+    - Dead Air Fallback (i.e. fallback filler)
+  - Similar to blocks, decos have deco groups for organization
+  - Similar to blocks, decos have deco templates for filling a "day" with decos
+  - In the playout template editor, playout template items can have *both* a block template and a deco template
+    - This allows watermarks and dead air fallback to change at different times than primary content
+  - Block playouts can also have a default deco
+    - This will apply whenever a deco template is missing, or when a deco template item cannot be found for the current time
+    - Effectively, this sets a default watermark and dead air fallback for the entire playout
+- Add `XMLTV Days To Build` setting, which is distinct from the existing `Playout Days To Build` setting
+  - The value for `XMLTV Days To Build` cannot be larger than `Playout Days To Build`
+  - This allows, for example, a week of playout data while optimizing XMLTV data to only a day or two
+- Add health check to detect config folder issue on MacOS
+  - ETV versions through v0.8.4-beta (using dotnet 7) stored config data in `$HOME/.local/share/ersatztv`
+  - ETV versions starting with v0.8.5-beta (using dotnet 8) store config data in `$HOME/Library/Application Support/ersatztv`
+  - If a dotnet 8 version of ETV has NOT been launched on MacOS, it will automatically migrate the config folder on startup
+  - If a dotnet 8 version of ETV *has* been launched on MacOS, a failing health check will display with instructions on how to resolve the config issue to restore data
+- Add `Video Profile` setting to `FFmpeg Profile` editor when `h264` format is selected
+- Add `Video Preset` setting to `FFmpeg Profile` editor for some combinations of acceleration and video format:
+  - `Nvenc` / `h264`
+  - `Nvenc` / `hevc`
+  - `Qsv` / `h264`
+  - `Qsv` / `hevc`
+  - `None` / `h264`
+  - `None` / `hevc`
+- Add *experimental* list type `Playlist`
+  - Playlists contain an ordered list of:
+    - Collections
+    - Multi-Collections
+    - Smart Collections
+    - TV Shows
+    - TV Seasons
+    - Artists
+    - Movies
+    - Episodes
+    - Music Videos
+    - Other Videos
+    - Songs
+    - Images
+  - Playlists can be added to schedules as a schedule item
+  - Each time through the playlist, one item will be scheduled from each playlist item (if `Play All` is unchecked)
+    - NB: This does not mean every collection will always schedule one item; the normal flood playout restrictions like duration and fixed start times still apply here
+  - If `Play All` is checked, that playlist item will play all of its items each time through the playlist
+    - This can be helpful if you want to play entire collections in a specific order, e.g.
+      - Every episode from Show 1 Season 2
+      - Every episode from Show 2 Season 3
+      - Every episode from Show 1 Season 3
+  - Playlist items with fewer media items will be re-shuffled (if applicable) before those with more media items
+- Add two new environment variables to customize config and transcode folder locations
+  - `ETV_CONFIG_FOLDER`
+  - `ETV_TRANSCODE_FOLDER`
+- Add checkbox to allow use of B-frames in FFmpeg Profile (disabled by default)
+
+### Fixed
+- Fix some cases of 404s from Plex when files were replaced and scanning the library from ETV didn't help
+- Fix more wildcard search phrase queries (when wildcards are used in quotes, like `title:"law & order*"`)
+- Fix non-wildcard simple queries when asterisks are used in quotes, like `title:"m*a*s*h"`
+- Fix bug where channels would unnecessarily wait on each other
+  - e.g. in-progress streams would delay responding with a playlist when new streams were starting
+- Update Plex show title in ETV when changed in Plex
+- Reindex seasons and episodes when show is updated from media server
+  - This is needed to keep `show_*` tags accurate in the search index (e.g., `show_title`, `show_studio`)
+- Fix external subtitle detection to support forced/sdh subtitles with language tag before and after forced/sdh tag:
+  - `Something.forced.en.srt`
+  - `Something.sdh.en.srt`
+  - `Something.en.forced.srt`
+  - `Something.en.sdh.srt`
+- Fix playback from Jellyfin 10.9 by allowing playlist HTTP HEAD requests
+- Fix `HLS Segmenter V2` segment duration (previously 10s, now 4s)
+- Fix `HLS Segmenter V2` error video generation
+- Fix MySql database migrations
+- Fix Plex library scans with MySql/MariaDB
+- Fix block playout playback when no deco is configured
+- Fix `HLS Segmenter V2` to delete old segments (use less disk space while channel is active)
+- Fix template and deco template editors to prevent items that go beyond midnight
+- Fix block playout random seeds
+  - Different blocks within a single playout will now correctly use different random seeds (shuffles)
+  - Erasing block playout history will also generate new random seeds for the playout
+- Fix building playouts that use mid-roll filler and have content without chapter markers
+  - When this happens, mid-roll will be treated as post-roll
+- Fix VAAPI decoder capability check
+  - This caused some streams to incorrectly use software decoding
+- Fix scheduling loop/failure caused by some duration schedule items
+- Fix `video_bit_depth` search field for Plex media
+- Fix template and deco template editors with MariaDB/MySql backend
+- Fix transcoding 10-bit source content using QSV acceleration on Windows
+
+### Changed
+- Show health checks at top of home page; scroll release notes if needed
+- Improve `HLS Segmenter V2` compliance by:
+  - Serving fmp4 segments when `hevc` video format is selected
+    - > 1.5. The container format for HEVC video MUST be fMP4.
+  - Using accurate BANDWIDTH value in multi-variant playlist
+  - Using proper MIME types for statically-served `.m3u8` and `.ts` files
+  - Serving playlists with gzip compression
+- Use `HLS Segmenter V2` for channel preview when channel is configured for `HLS Segmenter V2`
+- Detect and use `/dev/dri/card*` devices in addition to `/dev/dri/render*` devices
+- Change default folder locations in docker using new environment variables
+    - `ETV_CONFIG_FOLDER` - now defaults to `/config`
+    - `ETV_TRANSCODE_FOLDER` - now defaults to `/transcode`
+    - If the old locations are still present in docker, these variables will be ignored, so you can migrate at your own pace
+      - Old config location: `/root/.local/share/ersatztv`
+      - Old transcode location: `/root/.local/share/etv-transcode`
+
+## [0.8.6-beta] - 2024-04-03
+### Added
+- Add `show_studio` and `show_content_rating` to search index for seasons and episodes
+- Add two new global subtitle settings:
+  - `Use embedded subtitles`
+    - Default value: `true`
+    - When disabled, embedded subtitles will not be considered for extraction (text subtitles), or playback (all embedded subtitles)
+  - `Extract and use embedded (text) subtitles`
+    - Default value: `false`
+    - When enabled, embedded text subtitles will be periodically extracted, and considered for playback
+- Add `sub_language` and `sub_language_tag` fields to search index
+- Add `/iptv` request logging in its own log category at debug level
+- Add channel guide (XMLTV) template system
+  - Templates should be copied from `_channel.sbntxt`, `_movie.sbntxt`, `_episode.sbntxt`, `_musicVideo.sbntxt`, `_song.sbntxt`, or `_otherVideo.sbntxt` which are located in the config subfolder `templates/channel-guide`
+    - Copy the file, remove the leading underscore from the name, and only make edits to the copied file
+  - The default templates will be extracted and overwritten every time ErsatzTV is started
+  - The templates use [scribian](https://github.com/scriban/scriban/tree/master/doc) template syntax
+  - The templates contain comments describing which fields are available for use in the templates
+- Add *experimental* and *incomplete* `Images` library kind
+  - Image libraries have fallback metadata added like Other Video libraries (every folder is a tag)
+  - Image library items currently default to a duration of 15 seconds
+    - The `Media` > `Images` page can be used to configure image durations at a folder level
+    - Child folders with unset durations will inherit the closest ancestor's duration
+- Add *experimental* new streaming mode `HLS Segmenter V2`
+  - In my initial testing, this streaming mode produces significantly fewer playback warnings/errors
+  - If it tests well for others, it *may* replace the current `HLS Segmenter` in a future release
+- Add setting to change XMLTV data from `Local` time zone to `UTC`
+  - This is needed because some clients (incorrectly) ignore time zone specifier and require UTC times
+- Support `.ogv` video files in local libraries
+
+### Fixed
+- Fix antiforgery error caused by reusing existing browser tabs across docker container restarts
+  - Data protection keys will now be persisted under ErsatzTV's config folder instead of being recreated at startup
+- Fix bug updating/replacing Jellyfin movies
+  - A deep scan can be used to fix all movies, otherwise any future updates made to JF movies will correctly sync to ETV
+- Automatically generate JWT tokens to allow channel previews of protected streams
+- Fix bug applying music video fallback metadata
+- Fix playback of media items with no audio streams
+- Fix timestamp continuity in `HLS Segmenter` sessions
+  - This should make *some* clients happier
+- Fix `Other Video`, `Song` and `Image` fallback metadata tags to always include parent folder (folder added to library)
+- Allow playback of items with any positive duration, including less than one second
+- Fix VAAPI transcoding of OTA content containing A53 CC data
+- Fix AV1 software decoder priority (`libdav1d`, `libaom-av1`, `av1`)
+- Fix some stream failures caused by loudnorm filter
+- Fix multi-collection editor improperly disabling collections/smart collections that haven't already been added to the multi-collection
+- Fix path replacement logic when media server paths use inconsistent casing (e.g. `\\SERVERNAME` AND `\\ServerName`)
+- Fix *many* search queries, including actors with the name `Will`
+- Fix sqlite `database is locked` error that would crash ETV on startup after search index corruption
+- Fix bug where replacing files in Plex would be missed by subsequent ETV library scans
+  - This fix will require a one-time re-scan of each Plex library in full
+  - After the initial full scan, incremental scans will behave as normal
+- Fix edge case where some local episodes, music videos, other videos, songs, images would not automatically be restored from trash
+- Fix `MPEG-TS` playback when JWT tokens are enabled for streaming endpoints
+
+### Changed
+- Log search index updates under scanner category at debug level, to indicate a potential cause for the UI being out of date
+- Batch search index updates to keep pace with library scans
+  - Previously, search index updates would slowly process over minutes/hours after library scans completed
+  - Search index updates should now complete at the same time as library scans
+- Do not unnecessarily update the search index during media server library scans
+- Use different library for reading song metadata that supports multiple tag entries
+- Update `/iptv` routing to make UI completely inaccessible from that path prefix
+- Use CUDA 11 instead of CUDA 12 in NVIDIA docker image to significantly lower required driver version
+- Allow block durations with 5-minute increments (e.g., 5 min, 10 min, 15 min, etc.)
+
 ## [0.8.5-beta] - 2024-01-30
 ### Added
 - Respect browser's `Accept-Language` header for date time display
@@ -35,11 +789,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - GET `/api/sessions`
     - Show brief info about all active sessions
   - DELETE `/api/session/{channel-number}`
-    - Stop the session for the given channel number 
+    - Stop the session for the given channel number
 - Add channel preview (web-based video player)
   - Channels MUST use `H264` video format and `AAC` audio format
   - Channels MUST use `MPEG-TS` or `HLS Segmenter` streaming modes
-    - Since `MPEG-TS` uses `HLS Segmenter` under the hood, the preview player will use `HLS Segmenter`, so it's not 100% equivalent, but it should be representative 
+    - Since `MPEG-TS` uses `HLS Segmenter` under the hood, the preview player will use `HLS Segmenter`, so it's not 100% equivalent, but it should be representative
 - Add button to stop transcoding session for each channel that has an active session
 - Add more log levels to `Settings` page, allowing more specific debug logging as needed
     - Default Minimum Log Level (applies when no other categories/level overrides match)
@@ -55,10 +809,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Update show year when changed within Plex
 - Fix crop scale behavior with NVIDIA, QSV acceleration
 - Fix bug that corrupted uploaded images (watermarks, channel logos)
-  - Re-uploading images should fix them 
+  - Re-uploading images should fix them
 - Recreate XMLTV channel list (including logos) when channels are edited in ErsatzTV
-  - This bug caused the ErsatzTV logo to be used instead of channel logos in some cases 
-- Update drop down search results in main search bar when items are created/edited/removed 
+  - This bug caused the ErsatzTV logo to be used instead of channel logos in some cases
+- Update drop down search results in main search bar when items are created/edited/removed
 - Fix green line at bottom of video when NVIDIA accel is used with intermittent watermark
 - Fix error starting streaming session when subtitles are still being extracted for the current item
 
@@ -178,7 +932,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Fixed
 - Only allow a single instance of ErsatzTV to run
   - This fixes some cases where the search index would become unusable
-- Fix VAAPI rate control mode capability check 
+- Fix VAAPI rate control mode capability check
 
 ### Changed
 - Rework startup process to show UI as early as possible
@@ -224,14 +978,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
     - `MKV` output format: stream copy any embedded subtitles
 
 ### Fixed
-- Fix extracting embedded text subtitles that had been incompletely extracted in the past 
+- Fix extracting embedded text subtitles that had been incompletely extracted in the past
 - Fix fallback filler looping by forcing software mode for this content
   - Other content will still use hardware acceleration as configured
   - Hardware-accelerated fallback filler may be re-enabled in the future
 - Fix playout building when shuffle in order is used with a single media item
 - Fix pgs subtitle burn in from media server libraries
 - Fix subtitle and watermark overlays with RadeonSI VAAPI driver
-- Fix NVIDIA pipeline to use hardware-accelerated decoder with 8-bit h264 content   
+- Fix NVIDIA pipeline to use hardware-accelerated decoder with 8-bit h264 content
 
 ### Changed
 - Timeout playout builds after 2 minutes; this should prevent playout bugs from blocking other functionality
@@ -281,7 +1035,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Changed
 - Use Poster artwork for XMLTV if available
   - If Poster artwork is unavailable, use Thumbnail
-- Improve XMLTV response time by caching data as playouts are updated 
+- Improve XMLTV response time by caching data as playouts are updated
 
 ## [0.7.6-beta] - 2023-03-24
 ### Added
@@ -375,13 +1129,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Changed
 - Merge generated `Other Video` folder tags with tags from sidecar NFO
 - Prioritize audio streams that are flagged as "default" when multiple candidate streams are available
-  - For example, a video with a stereo commentary track and a stereo "default" track will now prefer the "default" track 
+  - For example, a video with a stereo commentary track and a stereo "default" track will now prefer the "default" track
 
 ## [0.7.3-beta] - 2023-01-25
 ### Added
 - Attempt to release memory periodically
 - Add OpenID Connect (OIDC) support (e.g. Keycloak, Authelia, Auth0)
-  - This only protects the management UI; all streaming endpoints will continue to allow anonymous access 
+  - This only protects the management UI; all streaming endpoints will continue to allow anonymous access
   - This can be configured with the following env vars (note the double underscore separator `__`)
     - `OIDC__AUTHORITY`
     - `OIDC__CLIENTID`
@@ -399,7 +1153,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
     - Day of week
     - Day of month
     - Month
-  - The lowest priority (bottom) item will always match all parameters, and can be considered a "default" or "fallback" schedule 
+  - The lowest priority (bottom) item will always match all parameters, and can be considered a "default" or "fallback" schedule
 
 ### Fixed
 - Fix schedule editor crashing due to bad music video artist data
@@ -431,7 +1185,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Fix song playback with VAAPI and NVENC
 - Fix edge case where some local movies would not automatically be restored from trash
 - Fix synchronizing Jellyfin and Emby collection items
-- Fix saving some external subtitle records to database 
+- Fix saving some external subtitle records to database
 
 ### Changed
 - Upgrade to dotnet 7
@@ -509,7 +1263,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 - Add music video credits template system
-  - Templates are selected in each channel's settings 
+  - Templates are selected in each channel's settings
   - Templates should be copied from `_default.ass.sbntxt` which is located in the config subfolder `templates/music-video-credits`
     - Copy the file, give it any name ending with `.ass.sbntext`, and only make edits to the copied file
   - The default template will be extracted and overwritten every time ErsatzTV is started
@@ -584,7 +1338,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Replace `setsar` filter with `setdar` filter
   - `setsar` caused issues scaling between two different aspect ratios
     - For example, some 4:3 content would appear stretched when scaled to a 16:9 resolution
-  - `setdar` is now only used when aspect ratios match 
+  - `setdar` is now only used when aspect ratios match
 - Prioritize aspect ratio from container when video stream contains conflicting aspect ratio
   - This is usually caused by bad authoring, but the change should improve scaling behavior for edge cases
 
@@ -687,7 +1441,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Reduce memory use due to library scan operations
 - Fix some instances of filler getting "stuck" when a filler item is encountered that's too long for the gap
 - Properly ignore Plex `Other Videos` libraries (`movie` libraries where agent is `com.plexapp.agents.none`)
-- Fix `Custom Title` for schedule items with `One`, `Multiple` and `Flood` playout modes 
+- Fix `Custom Title` for schedule items with `One`, `Multiple` and `Flood` playout modes
 - Fix scheduling bug where flood items would sometimes fail to continue after midnight
 
 ### Added
@@ -717,7 +1471,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Fix occasional erroneous log messages when HLS channel playback times out because all clients have left
 - Fix fallback filler playback
 - Fix stream continuity when error messages are displayed
-- Fix duplicate scanning within `Other Video` libraries (i.e. folders would be scanned multiple times) 
+- Fix duplicate scanning within `Other Video` libraries (i.e. folders would be scanned multiple times)
 
 ### Added
 - Add `show_genre` and `show_tag` to search index for seasons and episodes
@@ -805,7 +1559,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Fix setting VAAPI driver name
 - Fix ffmpeg troubleshooting reports
 - Fix bug where filler would behave as if it were configured to pad even though a different mode was selected
-- Fix bug where mid-roll count filler would skip scheduling the final chapter in an episode 
+- Fix bug where mid-roll count filler would skip scheduling the final chapter in an episode
 
 ### Added
 - Add `Empty Trash` button to `Trash` page
@@ -1112,7 +1866,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - When streaming is attempted during an unscheduled gap, the resulting video will be determined using the following priority:
     - Channel fallback filler
     - Global fallback filler
-    - Generated `Channel Is Offline` error message video 
+    - Generated `Channel Is Offline` error message video
 
 ### Changed
 - Allow per-episode folders for local show libraries
@@ -1220,7 +1974,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [0.1.0-alpha] - 2021-10-08
 ### Added
-- Add *experimental* streaming mode `HLS Segmenter` (most similar to `HLS Hybrid`) 
+- Add *experimental* streaming mode `HLS Segmenter` (most similar to `HLS Hybrid`)
   - This mode is intended to increase client compatibility and reduce issues at program boundaries
   - If you want the temporary transcode files to be located on a particular drive, the docker path is `/root/.local/share/etv-transcode`
 - Store frame rate with media statistics; this is needed to support HLS Segmenter
@@ -1256,7 +2010,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - See `Logs` for unmatched item details
   - Trakt lists can only be scheduled by using Smart Collections
 - Add seasons to search index
-  - This is needed because Trakt lists can contain seasons 
+  - This is needed because Trakt lists can contain seasons
   - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
 
 ### Fixed
@@ -1608,7 +2362,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Limit channels to one playout per channel
     - Though more than one playout was previously possible it was unsupported and unlikely to work as expected, if at all
     - A future release may make this possible again
-    
+
 ## [0.0.32-prealpha] - 2021-04-09
 ### Added
 - `Add All To Collection` button to quickly add all search results to a collection
@@ -1873,7 +2627,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/v0.8.5-beta...HEAD
+[Unreleased]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.5.0...HEAD
+[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
+[25.3.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.2.0...v25.3.0
+[25.2.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v25.1.0...v25.2.0
+[25.1.0]: https://github.com/ErsatzTV/ErsatzTV/compare/v0.8.8-beta...v25.1.0
+[0.8.8-beta]: https://github.com/ErsatzTV/ErsatzTV/compare/v0.8.7-beta...v0.8.8-beta
+[0.8.7-beta]: https://github.com/ErsatzTV/ErsatzTV/compare/v0.8.6-beta...v0.8.7-beta
+[0.8.6-beta]: https://github.com/ErsatzTV/ErsatzTV/compare/v0.8.5-beta...v0.8.6-beta
 [0.8.5-beta]: https://github.com/ErsatzTV/ErsatzTV/compare/v0.8.4-beta...v0.8.5-beta
 [0.8.4-beta]: https://github.com/ErsatzTV/ErsatzTV/compare/v0.8.3-beta...v0.8.4-beta
 [0.8.3-beta]: https://github.com/ErsatzTV/ErsatzTV/compare/v0.8.2-beta...v0.8.3-beta

ErsatzTV-Windows/src/main.rs

@@ -1,6 +1,7 @@
 #![windows_subsystem = "windows"]
 
 use special_folder::SpecialFolder;
+use std::env;
 use std::fs;
 use std::os::windows::process::CommandExt;
 use std::process::Child;
@@ -21,11 +22,16 @@ fn main() {
     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("http://localhost:8409")
+            .arg(format!("http://localhost:{}", ui_port))
             .stdin(Stdio::null())
             .stdout(Stdio::null())
             .stderr(Stdio::null())

ErsatzTV.Application/Artists/Mapper.cs

@@ -29,9 +29,10 @@ internal static class Mapper
         CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
 
         return languages
-            .Map(
-                lang => allCultures.Filter(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+            .Map(lang => allCultures.Filter(ci => string.Equals(
+                ci.ThreeLetterISOLanguageName,
+                lang,
+                StringComparison.OrdinalIgnoreCase)))
             .Flatten()
             .Distinct()
             .ToList();

ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs

@@ -24,7 +24,7 @@ public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<Artist
             async artist =>
             {
                 List<string> mediaCodes = await _searchRepository.GetLanguagesForArtist(artist);
-                List<string> languageCodes = await _searchRepository.GetAllLanguageCodes(mediaCodes);
+                List<string> languageCodes = await _searchRepository.GetAllThreeLetterLanguageCodes(mediaCodes);
                 return ProjectToViewModel(artist, languageCodes);
             },
             () => Task.FromResult(Option<ArtistViewModel>.None));

ErsatzTV.Application/Artworks/ArtworkContentTypeModel.cs

@@ -0,0 +1,17 @@
+using System.Net;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+public record ArtworkContentTypeModel(string Path, string ContentType)
+{
+    public static readonly ArtworkContentTypeModel None = new(string.Empty, string.Empty);
+
+    public bool IsExternalUrl => Artwork.IsExternalUrl(Path);
+
+    public bool HasContentType => !string.IsNullOrWhiteSpace(ContentType);
+
+    public string UrlWithContentType => string.IsNullOrWhiteSpace(ContentType)
+        ? Path
+        : $"{Path}?contentType={WebUtility.UrlEncode(ContentType)}";
+}

ErsatzTV.Application/Artworks/Queries/GetArtwork.cs

@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+public record GetArtwork(int Id) : IRequest<Either<BaseError, Artwork>>;

ErsatzTV.Application/Artworks/Queries/GetArtworkHandler.cs

@@ -0,0 +1,42 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Artworks;
+
+public class GetArtworkHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetArtwork, Either<BaseError, Artwork>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Artwork>> Handle(
+        GetArtwork request,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            Option<Artwork> artwork = await dbContext.Artwork
+                .AsNoTracking()
+                .SelectOneAsync(a => a.Id, a => a.Id == request.Id, cancellationToken)
+                .MapT(Project);
+
+            return artwork.ToEither(BaseError.New("Artwork not found"));
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private static Artwork Project(Artwork artwork) =>
+        new()
+        {
+            Id = artwork.Id,
+            Path = artwork.Path,
+            ArtworkKind = artwork.ArtworkKind
+        };
+}

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -1,4 +1,6 @@
-using ErsatzTV.Core.Domain;
+using System.Net;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
@@ -9,9 +11,12 @@ public record ChannelViewModel(
     string Group,
     string Categories,
     int FFmpegProfileId,
-    string Logo,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelPlayoutMode PlayoutMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -19,4 +24,12 @@ public record ChannelViewModel(
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
-    string MusicVideoCreditsTemplate);
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool IsEnabled,
+    bool ShowInEpg)
+{
+    public string WebEncodedName => WebUtility.UrlEncode(Name);
+}

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -1,22 +1,30 @@
-using ErsatzTV.Core;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
-public record CreateChannel
-(
+public record CreateChannel(
     string Name,
     string Number,
     string Group,
     string Categories,
     int FFmpegProfileId,
-    string Logo,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelPlayoutMode PlayoutMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
-    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, CreateChannelResult>>;
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool IsEnabled,
+    bool ShowInEpg) : IRequest<Either<BaseError, CreateChannelResult>>;

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -1,5 +1,4 @@
-using System.Globalization;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -23,7 +22,7 @@ public class CreateChannelHandler(
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request, cancellationToken);
         return await validation.Apply(c => PersistChannel(dbContext, c));
     }
 
@@ -36,90 +35,89 @@ public class CreateChannelHandler(
         return new CreateChannelResult(channel.Id);
     }
 
-    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
-        (ValidateName(request), await ValidateNumber(dbContext, request),
-            await FFmpegProfileMustExist(dbContext, request),
-            ValidatePreferredAudioLanguage(request),
-            ValidatePreferredSubtitleLanguage(request),
-            await WatermarkMustExist(dbContext, request),
-            await FillerPresetMustExist(dbContext, request))
-        .Apply(
-            (
-                name,
-                number,
-                ffmpegProfileId,
-                preferredAudioLanguageCode,
-                preferredSubtitleLanguageCode,
-                watermarkId,
-                fillerPresetId) =>
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request, CancellationToken cancellationToken) =>
+        (ValidateName(request), await ValidateNumber(dbContext, request, cancellationToken),
+            await FFmpegProfileMustExist(dbContext, request, cancellationToken),
+            await WatermarkMustExist(dbContext, request, cancellationToken),
+            await FillerPresetMustExist(dbContext, request, cancellationToken))
+        .Apply((
+            name,
+            number,
+            ffmpegProfileId,
+            watermarkId,
+            fillerPresetId) =>
+        {
+            var artwork = new List<Artwork>();
+            if (!string.IsNullOrWhiteSpace(request.Logo?.Path))
             {
-                var artwork = new List<Artwork>();
-                if (!string.IsNullOrWhiteSpace(request.Logo))
+                string logo = request.Logo.Path;
+                if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
                 {
-                    artwork.Add(
-                        new Artwork
-                        {
-                            Path = request.Logo,
-                            ArtworkKind = ArtworkKind.Logo,
-                            DateAdded = DateTime.UtcNow,
-                            DateUpdated = DateTime.UtcNow
-                        });
+                    logo = logo.Replace("iptv/logos/", string.Empty);
                 }
 
-                var channel = new Channel(Guid.NewGuid())
-                {
-                    Name = name,
-                    Number = number,
-                    Group = request.Group,
-                    Categories = request.Categories,
-                    FFmpegProfileId = ffmpegProfileId,
-                    StreamingMode = request.StreamingMode,
-                    Artwork = artwork,
-                    PreferredAudioLanguageCode = preferredAudioLanguageCode,
-                    PreferredAudioTitle = request.PreferredAudioTitle,
-                    PreferredSubtitleLanguageCode = preferredSubtitleLanguageCode,
-                    SubtitleMode = request.SubtitleMode,
-                    MusicVideoCreditsMode = request.MusicVideoCreditsMode,
-                    MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate
-                };
+                artwork.Add(
+                    new Artwork
+                    {
+                        Path = logo,
+                        ArtworkKind = ArtworkKind.Logo,
+                        OriginalContentType = !string.IsNullOrEmpty(request.Logo.ContentType)
+                            ? request.Logo.ContentType
+                            : null,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = DateTime.UtcNow
+                    });
+            }
 
-                foreach (int id in watermarkId)
-                {
-                    channel.WatermarkId = id;
-                }
+            var channel = new Channel(Guid.NewGuid())
+            {
+                Name = name,
+                Number = number,
+                Group = request.Group,
+                Categories = request.Categories,
+                FFmpegProfileId = ffmpegProfileId,
+                PlayoutMode = request.PlayoutMode,
+                StreamingMode = request.StreamingMode,
+                Artwork = artwork,
+                StreamSelectorMode = request.StreamSelectorMode,
+                StreamSelector = request.StreamSelector,
+                PreferredAudioLanguageCode = request.PreferredAudioLanguageCode,
+                PreferredAudioTitle = request.PreferredAudioTitle,
+                PreferredSubtitleLanguageCode = request.PreferredSubtitleLanguageCode,
+                SubtitleMode = request.SubtitleMode,
+                MusicVideoCreditsMode = request.MusicVideoCreditsMode,
+                MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate,
+                SongVideoMode = request.SongVideoMode,
+                TranscodeMode = request.TranscodeMode,
+                IdleBehavior = request.IdleBehavior,
+                IsEnabled = request.IsEnabled,
+                ShowInEpg = request.IsEnabled && request.ShowInEpg
+            };
 
-                foreach (int id in fillerPresetId)
-                {
-                    channel.FallbackFillerId = id;
-                }
+            foreach (int id in watermarkId)
+            {
+                channel.WatermarkId = id;
+            }
 
-                return channel;
-            });
+            foreach (int id in fillerPresetId)
+            {
+                channel.FallbackFillerId = id;
+            }
+
+            return channel;
+        });
 
     private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
         createChannel.NotEmpty(c => c.Name)
             .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
 
-    private static Validation<BaseError, string> ValidatePreferredAudioLanguage(CreateChannel createChannel) =>
-        Optional(createChannel.PreferredAudioLanguageCode ?? string.Empty)
-            .Filter(
-                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-            .ToValidation<BaseError>("Preferred audio language code is invalid");
-
-    private static Validation<BaseError, string> ValidatePreferredSubtitleLanguage(CreateChannel createChannel) =>
-        Optional(createChannel.PreferredSubtitleLanguageCode ?? string.Empty)
-            .Filter(
-                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-            .ToValidation<BaseError>("Preferred subtitle language code is invalid");
-
     private static async Task<Validation<BaseError, string>> ValidateNumber(
         TvContext dbContext,
-        CreateChannel createChannel)
+        CreateChannel createChannel,
+        CancellationToken cancellationToken)
     {
         Option<Channel> maybeExistingChannel = await dbContext.Channels
-            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number);
+            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number, cancellationToken);
         return maybeExistingChannel.Match<Validation<BaseError, string>>(
             _ => BaseError.New("Channel number must be unique"),
             () =>
@@ -135,9 +133,10 @@ public class CreateChannelHandler(
 
     private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
         TvContext dbContext,
-        CreateChannel createChannel) =>
+        CreateChannel createChannel,
+        CancellationToken cancellationToken) =>
         dbContext.FFmpegProfiles
-            .CountAsync(p => p.Id == createChannel.FFmpegProfileId)
+            .CountAsync(p => p.Id == createChannel.FFmpegProfileId, cancellationToken)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => createChannel.FFmpegProfileId)
@@ -145,7 +144,8 @@ public class CreateChannelHandler(
 
     private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
         TvContext dbContext,
-        CreateChannel createChannel)
+        CreateChannel createChannel,
+        CancellationToken cancellationToken)
     {
         if (createChannel.WatermarkId is null)
         {
@@ -153,7 +153,7 @@ public class CreateChannelHandler(
         }
 
         return await dbContext.ChannelWatermarks
-            .CountAsync(w => w.Id == createChannel.WatermarkId)
+            .CountAsync(w => w.Id == createChannel.WatermarkId, cancellationToken)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => Optional(createChannel.WatermarkId))
@@ -162,7 +162,8 @@ public class CreateChannelHandler(
 
     private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
         TvContext dbContext,
-        CreateChannel createChannel)
+        CreateChannel createChannel,
+        CancellationToken cancellationToken)
     {
         if (createChannel.FallbackFillerId is null)
         {
@@ -171,12 +172,11 @@ public class CreateChannelHandler(
 
         return await dbContext.FillerPresets
             .Filter(fp => fp.FillerKind == FillerKind.Fallback)
-            .CountAsync(w => w.Id == createChannel.FallbackFillerId)
+            .CountAsync(w => w.Id == createChannel.FallbackFillerId, cancellationToken)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => Optional(createChannel.FallbackFillerId))
-            .Map(
-                o => o.ToValidation<BaseError>(
-                    $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
+            .Map(o => o.ToValidation<BaseError>(
+                $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
     }
 }

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -31,7 +31,7 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
     public async Task<Either<BaseError, Unit>> Handle(DeleteChannel request, CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Channel> validation = await ChannelMustExist(dbContext, request);
+        Validation<BaseError, Channel> validation = await ChannelMustExist(dbContext, request, cancellationToken);
         return await validation.Apply(c => DoDeletion(dbContext, c, cancellationToken));
     }
 
@@ -39,7 +39,7 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
     {
         dbContext.Channels.Remove(channel);
         await dbContext.SaveChangesAsync(cancellationToken);
-        
+
         _searchTargets.SearchTargetsChanged();
 
         // delete channel data from channel guide cache
@@ -57,10 +57,11 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
 
     private static async Task<Validation<BaseError, Channel>> ChannelMustExist(
         TvContext dbContext,
-        DeleteChannel deleteChannel)
+        DeleteChannel deleteChannel,
+        CancellationToken cancellationToken)
     {
         Option<Channel> maybeChannel = await dbContext.Channels
-            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId);
+            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId, cancellationToken);
         return maybeChannel.ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.");
     }
 }

ErsatzTV.Application/Channels/Commands/RefreshChannelListHandler.cs

@@ -1,11 +1,18 @@
 using System.Data.Common;
+using System.Net;
 using System.Xml;
 using Dapper;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Iptv;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using Microsoft.IO;
+using Scriban;
+using Scriban.Runtime;
+using WebMarkupMin.Core;
 
 namespace ErsatzTV.Application.Channels;
 
@@ -13,16 +20,19 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
     private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILogger<RefreshChannelListHandler> _logger;
     private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
 
     public RefreshChannelListHandler(
         RecyclableMemoryStreamManager recyclableMemoryStreamManager,
         IDbContextFactory<TvContext> dbContextFactory,
-        ILocalFileSystem localFileSystem)
+        ILocalFileSystem localFileSystem,
+        ILogger<RefreshChannelListHandler> logger)
     {
         _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
         _dbContextFactory = dbContextFactory;
         _localFileSystem = localFileSystem;
+        _logger = logger;
     }
 
     public async Task Handle(RefreshChannelList request, CancellationToken cancellationToken)
@@ -31,6 +41,36 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
 
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "channel.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_channel.sbntxt");
+        }
+
+        // fail if file doesn't exist
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            _logger.LogError(
+                "Unable to generate channel list without template file {File}; please restart ErsatzTV",
+                templateFileName);
+
+            return;
+        }
+
+        var minifier = new XmlMinifier(
+            new XmlMinificationSettings
+            {
+                MinifyWhitespace = true,
+                RemoveXmlComments = true,
+                CollapseTagsWithoutContent = true
+            });
+
+        string text = await File.ReadAllTextAsync(templateFileName, cancellationToken);
+        var template = Template.Parse(text, templateFileName);
+        var templateContext = new XmlTemplateContext();
+
         await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
         await using var xml = XmlWriter.Create(
             ms,
@@ -38,34 +78,30 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
 
         await foreach (ChannelResult channel in GetChannels(dbContext).WithCancellation(cancellationToken))
         {
-            await xml.WriteStartElementAsync(null, "channel", null);
-            await xml.WriteAttributeStringAsync(null, "id", null, $"{channel.Number}.etv");
+            bool hasLogo = !string.IsNullOrWhiteSpace(channel.ArtworkPath);
+            bool hasExternalLogo = hasLogo && Artwork.IsExternalUrl(channel.ArtworkPath);
 
-            await xml.WriteStartElementAsync(null, "display-name", null);
-            await xml.WriteStringAsync($"{channel.Number} {channel.Name}");
-            await xml.WriteEndElementAsync(); // display-name (number and name)
-
-            await xml.WriteStartElementAsync(null, "display-name", null);
-            await xml.WriteStringAsync(channel.Number);
-            await xml.WriteEndElementAsync(); // display-name (number)
-
-            await xml.WriteStartElementAsync(null, "display-name", null);
-            await xml.WriteStringAsync(channel.Name);
-            await xml.WriteEndElementAsync(); // display-name (name)
-
-            foreach (string category in GetCategories(channel.Categories))
+            var data = new
             {
-                await xml.WriteStartElementAsync(null, "category", null);
-                await xml.WriteAttributeStringAsync(null, "lang", null, "en");
-                await xml.WriteStringAsync(category);
-                await xml.WriteEndElementAsync(); // category
-            }
+                ChannelId = ChannelIdentifier.FromNumber(channel.Number),
+                ChannelIdLegacy = ChannelIdentifier.LegacyFromNumber(channel.Number),
+                ChannelNumber = channel.Number,
+                ChannelName = channel.Name,
+                ChannelCategories = GetCategories(channel.Categories),
+                ChannelHasExternalArtwork = hasExternalLogo,
+                ChannelHasArtwork = hasLogo,
+                ChannelArtworkPath = channel.ArtworkPath,
+                ChannelNameEncoded = WebUtility.UrlEncode(channel.Name)
+            };
 
-            await xml.WriteStartElementAsync(null, "icon", null);
-            await xml.WriteAttributeStringAsync(null, "src", null, GetIconUrl(channel));
-            await xml.WriteEndElementAsync(); // icon
+            var scriptObject = new ScriptObject();
+            scriptObject.Import(data);
+            templateContext.PushGlobal(scriptObject);
 
-            await xml.WriteEndElementAsync(); // channel
+            string result = await template.RenderAsync(templateContext);
+
+            MarkupMinificationResult minified = minifier.Minify(result);
+            await xml.WriteRawAsync(minified.MinifiedContent);
         }
 
         await xml.FlushAsync();
@@ -82,7 +118,7 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
         const string QUERY = @"select C.Number, C.Name, C.Categories, A.Path as ArtworkPath
                                from Channel C
                                left outer join Artwork A on C.Id = A.ChannelId and A.ArtworkKind = 2
-                               where C.Id in (select ChannelId from Playout)
+                               where C.Id in (select ChannelId from Playout) and C.IsEnabled = 1 and C.ShowInEPG = 1
                                order by CAST(C.Number as double)";
         // TODO: this needs to be fixed for sqlite/mariadb
 
@@ -106,11 +142,6 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
         .Distinct()
         .ToList();
 
-    private static string GetIconUrl(ChannelResult channel) =>
-        string.IsNullOrWhiteSpace(channel.ArtworkPath)
-            ? "{RequestBase}/iptv/images/ersatztv-500.png{AccessTokenUri}"
-            : $"{{RequestBase}}/iptv/logos/{channel.ArtworkPath}.jpg{{AccessTokenUri}}";
-
     // ReSharper disable once ClassNeverInstantiated.Local
     private sealed record ChannelResult(string Number, string Name, string Categories, string ArtworkPath);
 }

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -1,23 +1,31 @@
-using ErsatzTV.Core;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
-public record UpdateChannel
-(
+public record UpdateChannel(
     int ChannelId,
     string Name,
     string Number,
     string Group,
     string Categories,
     int FFmpegProfileId,
-    string Logo,
+    ArtworkContentTypeModel Logo,
+    ChannelStreamSelectorMode StreamSelectorMode,
+    string StreamSelector,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
+    ChannelPlayoutMode PlayoutMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
-    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, ChannelViewModel>>;
+    string MusicVideoCreditsTemplate,
+    ChannelSongVideoMode SongVideoMode,
+    ChannelTranscodeMode TranscodeMode,
+    ChannelIdleBehavior IdleBehavior,
+    bool IsEnabled,
+    bool ShowInEpg) : IRequest<Either<BaseError, ChannelViewModel>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -1,5 +1,4 @@
-using System.Globalization;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 using System.Threading.Channels;
 using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
@@ -24,85 +23,122 @@ public class UpdateChannelHandler(
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request, cancellationToken);
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
     }
 
-    private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
+    private async Task<ChannelViewModel> ApplyUpdateRequest(
+        TvContext dbContext,
+        Channel c,
+        UpdateChannel update,
+        CancellationToken cancellationToken)
     {
         c.Name = update.Name;
         c.Number = update.Number;
         c.Group = update.Group;
         c.Categories = update.Categories;
         c.FFmpegProfileId = update.FFmpegProfileId;
+        c.StreamSelectorMode = update.StreamSelectorMode;
+        c.StreamSelector = update.StreamSelector;
         c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
         c.PreferredAudioTitle = update.PreferredAudioTitle;
         c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
         c.SubtitleMode = update.SubtitleMode;
         c.MusicVideoCreditsMode = update.MusicVideoCreditsMode;
         c.MusicVideoCreditsTemplate = update.MusicVideoCreditsTemplate;
-        c.Artwork ??= new List<Artwork>();
+        c.SongVideoMode = update.SongVideoMode;
+        c.TranscodeMode = update.TranscodeMode;
+        c.IdleBehavior = update.IdleBehavior;
+        c.IsEnabled = update.IsEnabled;
+        c.ShowInEpg = update.IsEnabled && update.ShowInEpg;
+        c.Artwork ??= [];
 
-        if (!string.IsNullOrWhiteSpace(update.Logo))
+        if (!string.IsNullOrWhiteSpace(update.Logo?.Path))
         {
-            Option<Artwork> maybeLogo =
-                Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
+            string logo = update.Logo.Path;
+            if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
+            {
+                logo = logo.Replace("iptv/logos/", string.Empty);
+            }
 
-            maybeLogo.Match(
-                artwork =>
+            Option<Artwork> maybeLogo = c.Artwork.Where(a => a.ArtworkKind == ArtworkKind.Logo).HeadOrNone();
+            foreach (Artwork artwork in maybeLogo)
+            {
+                artwork.Path = logo;
+                artwork.OriginalContentType = !string.IsNullOrEmpty(update.Logo.ContentType)
+                    ? update.Logo.ContentType
+                    : null;
+                artwork.DateUpdated = DateTime.UtcNow;
+            }
+
+            if (maybeLogo.IsNone)
+            {
+                var artwork = new Artwork
                 {
-                    artwork.Path = update.Logo;
-                    artwork.DateUpdated = DateTime.UtcNow;
-                },
-                () =>
-                {
-                    var artwork = new Artwork
-                    {
-                        Path = update.Logo,
-                        DateAdded = DateTime.UtcNow,
-                        DateUpdated = DateTime.UtcNow,
-                        ArtworkKind = ArtworkKind.Logo
-                    };
-                    c.Artwork.Add(artwork);
-                });
+                    Path = logo,
+                    OriginalContentType = !string.IsNullOrEmpty(update.Logo.ContentType)
+                        ? update.Logo.ContentType
+                        : null,
+                    DateAdded = DateTime.UtcNow,
+                    DateUpdated = DateTime.UtcNow,
+                    ArtworkKind = ArtworkKind.Logo
+                };
+                c.Artwork.Add(artwork);
+            }
+        }
+        else
+        {
+            await dbContext.Entry(c)
+                .Collection(channel => channel.Artwork)
+                .LoadAsync(cancellationToken);
+
+            foreach (Artwork artwork in c.Artwork.Where(x => x.ArtworkKind is ArtworkKind.Logo).ToList())
+            {
+                c.Artwork.Remove(artwork);
+                dbContext.Artwork.Remove(artwork);
+            }
         }
 
+        c.PlayoutMode = update.PlayoutMode;
         c.StreamingMode = update.StreamingMode;
         c.WatermarkId = update.WatermarkId;
         c.FallbackFillerId = update.FallbackFillerId;
-        await dbContext.SaveChangesAsync();
-        
+        await dbContext.SaveChangesAsync(cancellationToken);
+
         searchTargets.SearchTargetsChanged();
 
         if (c.SubtitleMode != ChannelSubtitleMode.None)
         {
             Option<Playout> maybePlayout = await dbContext.Playouts
-                .SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id);
+                .SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id, cancellationToken);
 
             foreach (Playout playout in maybePlayout)
             {
-                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
+                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id), cancellationToken);
             }
         }
-        
-        await workerChannel.WriteAsync(new RefreshChannelList());
+
+        await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
 
         return ProjectToViewModel(c);
     }
 
-    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
-        (await ChannelMustExist(dbContext, request), ValidateName(request),
-            await ValidateNumber(dbContext, request),
-            ValidatePreferredAudioLanguage(request))
-        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+    private static async Task<Validation<BaseError, Channel>> Validate(
+        TvContext dbContext,
+        UpdateChannel request,
+        CancellationToken cancellationToken) =>
+        (await ChannelMustExist(dbContext, request, cancellationToken), ValidateName(request),
+            await ValidateNumber(dbContext, request, cancellationToken))
+        .Apply((channelToUpdate, _, _) => channelToUpdate);
 
     private static Task<Validation<BaseError, Channel>> ChannelMustExist(
         TvContext dbContext,
-        UpdateChannel updateChannel) =>
+        UpdateChannel updateChannel,
+        CancellationToken cancellationToken) =>
         dbContext.Channels
             .Include(c => c.Artwork)
             .Include(c => c.Watermark)
-            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
+            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
 
     private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
@@ -111,10 +147,11 @@ public class UpdateChannelHandler(
 
     private static async Task<Validation<BaseError, string>> ValidateNumber(
         TvContext dbContext,
-        UpdateChannel updateChannel)
+        UpdateChannel updateChannel,
+        CancellationToken cancellationToken)
     {
         int matchId = await dbContext.Channels
-            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
+            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number, cancellationToken)
             .Match(c => c.Id, () => updateChannel.ChannelId);
 
         if (matchId == updateChannel.ChannelId)
@@ -129,11 +166,4 @@ public class UpdateChannelHandler(
 
         return BaseError.New("Channel number must be unique");
     }
-
-    private static Validation<BaseError, string> ValidatePreferredAudioLanguage(UpdateChannel updateChannel) =>
-        Optional(updateChannel.PreferredAudioLanguageCode ?? string.Empty)
-            .Filter(
-                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-            .ToValidation<BaseError>("Preferred audio language code is invalid");
 }

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core.Api.Channels;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
@@ -14,8 +15,11 @@ internal static class Mapper
             channel.Categories,
             channel.FFmpegProfileId,
             GetLogo(channel),
+            channel.StreamSelectorMode,
+            channel.StreamSelector,
             channel.PreferredAudioLanguageCode,
             channel.PreferredAudioTitle,
+            channel.PlayoutMode,
             channel.StreamingMode,
             channel.WatermarkId,
             channel.FallbackFillerId,
@@ -23,7 +27,12 @@ internal static class Mapper
             channel.PreferredSubtitleLanguageCode,
             channel.SubtitleMode,
             channel.MusicVideoCreditsMode,
-            channel.MusicVideoCreditsTemplate);
+            channel.MusicVideoCreditsTemplate,
+            channel.SongVideoMode,
+            channel.TranscodeMode,
+            channel.IdleBehavior,
+            channel.IsEnabled,
+            channel.ShowInEpg);
 
     internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
         new(
@@ -34,9 +43,27 @@ internal static class Mapper
             channel.PreferredAudioLanguageCode,
             GetStreamingMode(channel));
 
-    private static string GetLogo(Channel channel) =>
-        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
-            .Match(a => a.Path, string.Empty);
+    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);
+
+    private static ArtworkContentTypeModel GetLogo(Channel channel)
+    {
+        Option<Artwork> maybeArtwork = channel.Artwork
+            .Where(a => a.ArtworkKind == ArtworkKind.Logo)
+            .HeadOrNone();
+
+        foreach (Artwork artwork in maybeArtwork)
+        {
+            return artwork.IsExternalUrl()
+                ? new ArtworkContentTypeModel(artwork.Path, string.Empty)
+                : new ArtworkContentTypeModel($"iptv/logos/{artwork.Path}", artwork.OriginalContentType);
+        }
+
+        return ArtworkContentTypeModel.None;
+    }
 
     private static string GetStreamingMode(Channel channel) =>
         channel.StreamingMode switch
@@ -45,6 +72,7 @@ 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/GetAllChannelsForApiHandler.cs

@@ -15,7 +15,7 @@ public class GetAllChannelsForApiHandler : IRequestHandler<GetAllChannelsForApi,
         GetAllChannelsForApi request,
         CancellationToken cancellationToken)
     {
-        IEnumerable<Channel> channels = Optional(await _channelRepository.GetAll()).Flatten();
+        IEnumerable<Channel> channels = Optional(await _channelRepository.GetAll(cancellationToken)).Flatten();
         return channels.Map(ProjectToResponseModel).ToList();
     }
 }

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

@@ -3,12 +3,10 @@ using static ErsatzTV.Application.Channels.Mapper;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetAllChannelsHandler : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
+public class GetAllChannelsHandler(IChannelRepository channelRepository)
+    : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
 {
-    private readonly IChannelRepository _channelRepository;
-
-    public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
-
     public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
-        Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
+        await channelRepository.GetAll(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 }

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

@@ -3,13 +3,10 @@ using static ErsatzTV.Application.Channels.Mapper;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelByIdHandler : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
+public class GetChannelByIdHandler(IChannelRepository channelRepository)
+    : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
 {
-    private readonly IChannelRepository _channelRepository;
-
-    public GetChannelByIdHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
-
     public Task<Option<ChannelViewModel>> Handle(GetChannelById request, CancellationToken cancellationToken) =>
-        _channelRepository.GetChannel(request.Id)
+        channelRepository.GetChannel(request.Id)
             .MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -21,82 +21,100 @@ public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, O
 
     public async Task<Option<int>> Handle(GetChannelFramerate request, CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-        FFmpegProfile ffmpegProfile = await dbContext.Channels
-            .Filter(c => c.Number == request.ChannelNumber)
-            .Include(c => c.FFmpegProfile)
-            .Map(c => c.FFmpegProfile)
-            .SingleAsync(cancellationToken);
-
-        if (!ffmpegProfile.NormalizeFramerate)
+        try
         {
-            return Option<int>.None;
-        }
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
-        // TODO: expand to check everything in collection rather than what's scheduled?
-        _logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
+            FFmpegProfile ffmpegProfile = await dbContext.Channels
+                .AsNoTracking()
+                .Filter(c => c.Number == request.ChannelNumber)
+                .Include(c => c.FFmpegProfile)
+                .Map(c => c.FFmpegProfile)
+                .SingleAsync(cancellationToken);
 
-        List<Playout> playouts = await dbContext.Playouts
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as Movie).MediaVersions)
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as Episode).MediaVersions)
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as Song).MediaVersions)
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
-            .Filter(p => p.Channel.Number == request.ChannelNumber)
-            .ToListAsync(cancellationToken);
-
-        var frameRates = playouts.Map(p => p.Items.Map(i => i.MediaItem.GetHeadVersion()))
-            .Flatten()
-            .Map(mv => 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)
+            if (!ffmpegProfile.NormalizeFramerate)
             {
-                _logger.LogInformation(
-                    "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate} instead of min value {MinFrameRate}",
-                    request.ChannelNumber,
-                    distinct,
-                    24,
-                    result);
-
-                return 24;
+                return Option<int>.None;
             }
 
-            _logger.LogInformation(
-                "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
-                request.ChannelNumber,
-                distinct,
-                result);
-            return result;
-        }
+            // TODO: expand to check everything in collection rather than what's scheduled?
+            _logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
 
-        if (distinct.Count != 0)
-        {
-            _logger.LogInformation(
-                "All content on channel {ChannelNumber} has the same frame rate of {FrameRate}; will not normalize",
-                request.ChannelNumber,
-                distinct[0]);
+            List<Playout> playouts = await dbContext.Playouts
+                .AsNoTracking()
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Movie).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Episode).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Song).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as Image).MediaVersions)
+                .Include(p => p.Items)
+                .ThenInclude(pi => pi.MediaItem)
+                .ThenInclude(mi => (mi as RemoteStream).MediaVersions)
+                .Filter(p => p.Channel.Number == request.ChannelNumber)
+                .ToListAsync(cancellationToken);
+
+            var frameRates = playouts.Map(p => p.Items.Map(i => i.MediaItem.GetHeadVersion()))
+                .Flatten()
+                .Map(mv => 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)
+                {
+                    _logger.LogInformation(
+                        "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate} instead of min value {MinFrameRate}",
+                        request.ChannelNumber,
+                        distinct,
+                        24,
+                        result);
+
+                    return 24;
+                }
+
+                _logger.LogInformation(
+                    "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
+                    request.ChannelNumber,
+                    distinct,
+                    result);
+                return result;
+            }
+
+            if (distinct.Count != 0)
+            {
+                _logger.LogInformation(
+                    "All content on channel {ChannelNumber} has the same frame rate of {FrameRate}; will not normalize",
+                    request.ChannelNumber,
+                    distinct[0]);
+            }
+            else
+            {
+                _logger.LogInformation(
+                    "No content on channel {ChannelNumber} has frame rate information; will not normalize",
+                    request.ChannelNumber);
+            }
         }
-        else
+        catch (Exception ex)
         {
-            _logger.LogInformation(
-                "No content on channel {ChannelNumber} has frame rate information; will not normalize",
+            _logger.LogWarning(
+                ex,
+                "Unexpected error checking frame rates on channel {ChannelNumber}",
                 request.ChannelNumber);
         }
 

ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs

@@ -3,5 +3,5 @@ using ErsatzTV.Core.Iptv;
 
 namespace ErsatzTV.Application.Channels;
 
-public record GetChannelGuide
-    (string Scheme, string Host, string BaseUrl, string AccessToken) : IRequest<Either<BaseError, ChannelGuide>>;
+public record GetChannelGuide(string Scheme, string Host, string BaseUrl, string AccessToken)
+    : IRequest<Either<BaseError, ChannelGuide>>;

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

@@ -1,3 +1,4 @@
+using System.Collections.Immutable;
 using System.Text;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Metadata;
@@ -29,6 +30,12 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<Ba
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        var hiddenChannelNumbers = dbContext.Channels
+            .Where(c => c.ShowInEpg == false)
+            .Select(c => c.Number)
+            .AsEnumerable()
+            .Select(n => $"{n}.xml")
+            .ToImmutableHashSet();
 
         string channelsFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, "channels.xml");
         if (!_localFileSystem.FileExists(channelsFile))
@@ -36,10 +43,12 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<Ba
             return BaseError.New($"Required file {channelsFile} is missing");
         }
 
-        string accessTokenUri = string.Empty;
+        long mtime = File.GetLastWriteTime(channelsFile).Ticks;
+
+        var accessTokenUri = $"?v={mtime}";
         if (!string.IsNullOrWhiteSpace(request.AccessToken))
         {
-            accessTokenUri = $"?access_token={request.AccessToken}";
+            accessTokenUri += $"&amp;access_token={request.AccessToken}";
         }
 
         string channelsFragment = await File.ReadAllTextAsync(channelsFile, Encoding.UTF8, cancellationToken);
@@ -58,6 +67,11 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, Either<Ba
                 continue;
             }
 
+            if (hiddenChannelNumbers.Contains(Path.GetFileName(fileName)))
+            {
+                continue;
+            }
+
             string channelDataFragment = await File.ReadAllTextAsync(fileName, Encoding.UTF8, cancellationToken);
 
             channelDataFragment = channelDataFragment

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

@@ -10,6 +10,7 @@ public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<Li
     public GetChannelLineupHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
     public Task<List<LineupItem>> Handle(GetChannelLineup request, CancellationToken cancellationToken) =>
-        _channelRepository.GetAll()
-            .Map(channels => channels.Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
+        _channelRepository.GetAll(cancellationToken)
+            .Map(channels => channels.Where(c => c.IsEnabled)
+                .Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
 }

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

@@ -16,7 +16,7 @@ public class GetChannelNameByPlayoutIdHandler : IRequestHandler<GetChannelNameBy
         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)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.PlayoutId, cancellationToken)
             .MapT(p => p.Channel.Name);
     }
 }

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -12,28 +12,36 @@ public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, Cha
         _channelRepository = channelRepository;
 
     public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
-        _channelRepository.GetAll()
+        _channelRepository.GetAll(cancellationToken)
             .Map(channels => EnsureMode(channels, request.Mode))
-            .Map(
-                channels => new ChannelPlaylist(
-                    request.Scheme,
-                    request.Host,
-                    request.BaseUrl,
-                    channels,
-                    request.UserAgent,
-                    request.AccessToken));
+            .Map(channels => new ChannelPlaylist(
+                request.Scheme,
+                request.Host,
+                request.BaseUrl,
+                channels,
+                request.UserAgent,
+                request.AccessToken));
 
     private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
     {
         var result = new List<Channel>();
         foreach (Channel channel in channels)
         {
+            if (!channel.IsEnabled)
+            {
+                continue;
+            }
+
             switch (mode.ToLowerInvariant())
             {
                 case "segmenter":
                     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

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

ErsatzTV.Application/Channels/Queries/GetChannelResolutionAndBitrateHandler.cs

@@ -0,0 +1,27 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelResolutionAndBitrateHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelResolutionAndBitrate, Option<ResolutionAndBitrateViewModel>>
+{
+    public async Task<Option<ResolutionAndBitrateViewModel>> Handle(
+        GetChannelResolutionAndBitrate request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        Option<Channel> maybeChannel = await dbContext.Channels
+            .AsNoTracking()
+            .Include(c => c.FFmpegProfile)
+            .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)));
+    }
+}

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectors.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectorsHandler.cs

@@ -0,0 +1,14 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
+
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelStreamSelectorsHandler(ILocalFileSystem localFileSystem)
+    : IRequestHandler<GetChannelStreamSelectors, List<string>>
+{
+    public Task<List<string>> Handle(GetChannelStreamSelectors request, CancellationToken cancellationToken) =>
+        localFileSystem.ListFiles(FileSystemLayout.ChannelStreamSelectorsFolder)
+            .Map(Path.GetFileName)
+            .ToList()
+            .AsTask();
+}

ErsatzTV.Application/Channels/ResolutionAndBitrateViewModel.cs

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

ErsatzTV.Application/Channels/ResolutionViewModel.cs

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

ErsatzTV.Application/Channels/XmlTemplateContext.cs

@@ -0,0 +1,14 @@
+using System.Net;
+using Scriban;
+using Scriban.Parsing;
+
+namespace ErsatzTV.Application.Channels;
+
+public class XmlTemplateContext : TemplateContext
+{
+    public override TemplateContext Write(SourceSpan span, object textAsObject)
+        => base.Write(span, textAsObject is string text ? WebUtility.HtmlEncode(text) : textAsObject);
+
+    public override ValueTask<TemplateContext> WriteAsync(SourceSpan span, object textAsObject)
+        => base.WriteAsync(span, textAsObject is string text ? WebUtility.HtmlEncode(text) : textAsObject);
+}

ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs

@@ -10,5 +10,5 @@ public class SaveConfigElementByKeyHandler : IRequestHandler<SaveConfigElementBy
         _configElementRepository = configElementRepository;
 
     public async Task Handle(SaveConfigElementByKey request, CancellationToken cancellationToken) =>
-        await _configElementRepository.Upsert(request.Key, request.Value);
+        await _configElementRepository.Upsert(request.Key, request.Value, cancellationToken);
 }

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

@@ -1,40 +0,0 @@
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
-
-namespace ErsatzTV.Application.Configuration;
-
-public class UpdateGeneralSettingsHandler : IRequestHandler<UpdateGeneralSettings, Either<BaseError, Unit>>
-{
-    private readonly IConfigElementRepository _configElementRepository;
-    private readonly LoggingLevelSwitches _loggingLevelSwitches;
-
-    public UpdateGeneralSettingsHandler(
-        LoggingLevelSwitches loggingLevelSwitches,
-        IConfigElementRepository configElementRepository)
-    {
-        _loggingLevelSwitches = loggingLevelSwitches;
-        _configElementRepository = configElementRepository;
-    }
-
-    public async Task<Either<BaseError, Unit>> Handle(
-        UpdateGeneralSettings request,
-        CancellationToken cancellationToken) => await ApplyUpdate(request.GeneralSettings);
-
-    private async Task<Unit> ApplyUpdate(GeneralSettingsViewModel generalSettings)
-    {
-        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, generalSettings.DefaultMinimumLogLevel);
-        _loggingLevelSwitches.DefaultLevelSwitch.MinimumLevel = generalSettings.DefaultMinimumLogLevel;
-
-        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevelScanning, generalSettings.ScanningMinimumLogLevel);
-        _loggingLevelSwitches.ScanningLevelSwitch.MinimumLevel = generalSettings.ScanningMinimumLogLevel;
-
-        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevelScheduling, generalSettings.SchedulingMinimumLogLevel);
-        _loggingLevelSwitches.SchedulingLevelSwitch.MinimumLevel = generalSettings.SchedulingMinimumLogLevel;
-        
-        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevelStreaming, generalSettings.StreamingMinimumLogLevel);
-        _loggingLevelSwitches.StreamingLevelSwitch.MinimumLevel = generalSettings.StreamingMinimumLogLevel;
-
-        return Unit.Default;
-    }
-}

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -16,10 +16,10 @@ public class UpdateLibraryRefreshIntervalHandler :
         UpdateLibraryRefreshInterval request,
         CancellationToken cancellationToken) =>
         Validate(request)
-            .MapT(
-                _ => _configElementRepository.Upsert(
-                    ConfigElementKey.LibraryRefreshInterval,
-                    request.LibraryRefreshInterval))
+            .MapT(_ => _configElementRepository.Upsert(
+                ConfigElementKey.LibraryRefreshInterval,
+                request.LibraryRefreshInterval,
+                cancellationToken))
             .Bind(v => v.ToEitherAsync());
 
     private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>

ErsatzTV.Application/Configuration/Commands/UpdateLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateLoggingSettingsHandler.cs

@@ -0,0 +1,56 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateLoggingSettingsHandler : IRequestHandler<UpdateLoggingSettings, Either<BaseError, Unit>>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly LoggingLevelSwitches _loggingLevelSwitches;
+
+    public UpdateLoggingSettingsHandler(
+        LoggingLevelSwitches loggingLevelSwitches,
+        IConfigElementRepository configElementRepository)
+    {
+        _loggingLevelSwitches = loggingLevelSwitches;
+        _configElementRepository = configElementRepository;
+    }
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateLoggingSettings request,
+        CancellationToken cancellationToken) => await ApplyUpdate(request.LoggingSettings, cancellationToken);
+
+    private async Task<Unit> ApplyUpdate(LoggingSettingsViewModel loggingSettings, CancellationToken cancellationToken)
+    {
+        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, loggingSettings.DefaultMinimumLogLevel, cancellationToken);
+        _loggingLevelSwitches.DefaultLevelSwitch.MinimumLevel = loggingSettings.DefaultMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelScanning,
+            loggingSettings.ScanningMinimumLogLevel, cancellationToken);
+        _loggingLevelSwitches.ScanningLevelSwitch.MinimumLevel = loggingSettings.ScanningMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelScheduling,
+            loggingSettings.SchedulingMinimumLogLevel, cancellationToken);
+        _loggingLevelSwitches.SchedulingLevelSwitch.MinimumLevel = loggingSettings.SchedulingMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelSearching,
+            loggingSettings.SearchingMinimumLogLevel, cancellationToken);
+        _loggingLevelSwitches.SearchingLevelSwitch.MinimumLevel = loggingSettings.SearchingMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelStreaming,
+            loggingSettings.StreamingMinimumLogLevel, cancellationToken);
+        _loggingLevelSwitches.StreamingLevelSwitch.MinimumLevel = loggingSettings.StreamingMinimumLogLevel;
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.MinimumLogLevelHttp,
+            loggingSettings.HttpMinimumLogLevel, cancellationToken);
+        _loggingLevelSwitches.HttpLevelSwitch.MinimumLevel = loggingSettings.HttpMinimumLogLevel;
+
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

@@ -32,24 +32,24 @@ 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));
+        return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(dbContext, request.PlayoutSettings, cancellationToken));
     }
 
-    private async Task<Unit> ApplyUpdate(TvContext dbContext, PlayoutSettingsViewModel playoutSettings)
+    private async Task<Unit> ApplyUpdate(TvContext dbContext, PlayoutSettingsViewModel playoutSettings, CancellationToken cancellationToken)
     {
-        await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, playoutSettings.DaysToBuild);
+        await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, playoutSettings.DaysToBuild, cancellationToken);
         await _configElementRepository.Upsert(
             ConfigElementKey.PlayoutSkipMissingItems,
-            playoutSettings.SkipMissingItems);
+            playoutSettings.SkipMissingItems, cancellationToken);
 
         // continue all playouts to proper number of days
         List<Playout> playouts = await dbContext.Playouts
             .Include(p => p.Channel)
-            .ToListAsync();
+            .ToListAsync(cancellationToken);
         foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number, CultureInfo.InvariantCulture))
                      .Map(p => p.Id))
         {
-            await _workerChannel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Continue));
+            await _workerChannel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Continue), cancellationToken);
         }
 
         return Unit.Default;

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettingsHandler.cs

@@ -0,0 +1,50 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateXmltvSettingsHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository,
+    ChannelWriter<IBackgroundServiceRequest> workerChannel)
+    : IRequestHandler<UpdateXmltvSettings, Either<BaseError, Unit>>
+{
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateXmltvSettings request,
+        CancellationToken cancellationToken)
+    {
+        int playoutDaysToBuild =
+            await configElementRepository
+                .GetValue<int>(ConfigElementKey.PlayoutDaysToBuild, cancellationToken)
+                .IfNoneAsync(2);
+
+        if (playoutDaysToBuild < request.XmltvSettings.DaysToBuild)
+        {
+            return BaseError.New(
+                $"XMLTV days to build ({request.XmltvSettings.DaysToBuild}) cannot be greater than Playout days to build ({playoutDaysToBuild})");
+        }
+
+        return await ApplyUpdate(request.XmltvSettings, cancellationToken);
+    }
+
+    private async Task<Unit> ApplyUpdate(XmltvSettingsViewModel xmltvSettings, CancellationToken cancellationToken)
+    {
+        await configElementRepository.Upsert(ConfigElementKey.XmltvTimeZone, xmltvSettings.TimeZone, cancellationToken);
+        await configElementRepository.Upsert(ConfigElementKey.XmltvDaysToBuild, xmltvSettings.DaysToBuild, cancellationToken);
+        await configElementRepository.Upsert(ConfigElementKey.XmltvBlockBehavior, xmltvSettings.BlockBehavior, cancellationToken);
+
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        foreach (string channelNumber in await dbContext.Channels.Map(c => c.Number).ToListAsync(cancellationToken))
+        {
+            await workerChannel.WriteAsync(new RefreshChannelData(channelNumber), cancellationToken);
+        }
+
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Configuration/LoggingSettingsViewModel.cs

@@ -2,10 +2,12 @@ using Serilog.Events;
 
 namespace ErsatzTV.Application.Configuration;
 
-public class GeneralSettingsViewModel
+public class LoggingSettingsViewModel
 {
     public LogEventLevel DefaultMinimumLogLevel { get; set; }
     public LogEventLevel ScanningMinimumLogLevel { get; set; }
     public LogEventLevel SchedulingMinimumLogLevel { get; set; }
+    public LogEventLevel SearchingMinimumLogLevel { get; set; }
     public LogEventLevel StreamingMinimumLogLevel { get; set; }
+    public LogEventLevel HttpMinimumLogLevel { get; set; }
 }

ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs

@@ -13,5 +13,5 @@ public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKe
     public Task<Option<ConfigElementViewModel>> Handle(
         GetConfigElementByKey request,
         CancellationToken cancellationToken) =>
-        _configElementRepository.GetConfigElement(request.Key).MapT(ProjectToViewModel);
+        _configElementRepository.GetConfigElement(request.Key, cancellationToken).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Configuration/Queries/GetGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

@@ -1,36 +0,0 @@
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
-using Serilog.Events;
-
-namespace ErsatzTV.Application.Configuration;
-
-public class GetGeneralSettingsHandler : IRequestHandler<GetGeneralSettings, GeneralSettingsViewModel>
-{
-    private readonly IConfigElementRepository _configElementRepository;
-
-    public GetGeneralSettingsHandler(IConfigElementRepository configElementRepository) =>
-        _configElementRepository = configElementRepository;
-
-    public async Task<GeneralSettingsViewModel> Handle(GetGeneralSettings request, CancellationToken cancellationToken)
-    {
-        Option<LogEventLevel> maybeDefaultLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel);
-        
-        Option<LogEventLevel> maybeScanningLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScanning);
-
-        Option<LogEventLevel> maybeSchedulingLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScheduling);
-        
-        Option<LogEventLevel> maybeStreamingLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelStreaming);
-        
-        return new GeneralSettingsViewModel
-        {
-            DefaultMinimumLogLevel = await maybeDefaultLevel.IfNoneAsync(LogEventLevel.Information),
-            ScanningMinimumLogLevel = await maybeScanningLevel.IfNoneAsync(LogEventLevel.Information),
-            SchedulingMinimumLogLevel = await maybeSchedulingLevel.IfNoneAsync(LogEventLevel.Information),
-            StreamingMinimumLogLevel = await maybeStreamingLevel.IfNoneAsync(LogEventLevel.Information),
-        };
-    }
-}

ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs

@@ -11,6 +11,6 @@ public class GetLibraryRefreshIntervalHandler : IRequestHandler<GetLibraryRefres
         _configElementRepository = configElementRepository;
 
     public Task<int> Handle(GetLibraryRefreshInterval request, CancellationToken cancellationToken) =>
-        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval, cancellationToken)
             .Map(result => result.IfNone(6));
 }

ErsatzTV.Application/Configuration/Queries/GetLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetLoggingSettingsHandler.cs

@@ -0,0 +1,54 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using Serilog.Events;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetLoggingSettingsHandler : IRequestHandler<GetLoggingSettings, LoggingSettingsViewModel>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public GetLoggingSettingsHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<LoggingSettingsViewModel> Handle(GetLoggingSettings request, CancellationToken cancellationToken)
+    {
+        Option<LogEventLevel> maybeDefaultLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel, cancellationToken);
+
+        Option<LogEventLevel> maybeScanningLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(
+                ConfigElementKey.MinimumLogLevelScanning,
+                cancellationToken);
+
+        Option<LogEventLevel> maybeSchedulingLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(
+                ConfigElementKey.MinimumLogLevelScheduling,
+                cancellationToken);
+
+        Option<LogEventLevel> maybeSearchingLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(
+                ConfigElementKey.MinimumLogLevelSearching,
+                cancellationToken);
+
+        Option<LogEventLevel> maybeStreamingLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(
+                ConfigElementKey.MinimumLogLevelStreaming,
+                cancellationToken);
+
+        Option<LogEventLevel> maybeHttpLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(
+                ConfigElementKey.MinimumLogLevelHttp,
+                cancellationToken);
+
+        return new LoggingSettingsViewModel
+        {
+            DefaultMinimumLogLevel = await maybeDefaultLevel.IfNoneAsync(LogEventLevel.Information),
+            ScanningMinimumLogLevel = await maybeScanningLevel.IfNoneAsync(LogEventLevel.Information),
+            SchedulingMinimumLogLevel = await maybeSchedulingLevel.IfNoneAsync(LogEventLevel.Information),
+            SearchingMinimumLogLevel = await maybeSearchingLevel.IfNoneAsync(LogEventLevel.Information),
+            StreamingMinimumLogLevel = await maybeStreamingLevel.IfNoneAsync(LogEventLevel.Information),
+            HttpMinimumLogLevel = await maybeHttpLevel.IfNoneAsync(LogEventLevel.Information)
+        };
+    }
+}

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettingsHandler.cs

@@ -12,10 +12,12 @@ public class GetPlayoutSettingsHandler : IRequestHandler<GetPlayoutSettings, Pla
 
     public async Task<PlayoutSettingsViewModel> Handle(GetPlayoutSettings request, CancellationToken cancellationToken)
     {
-        Option<int> daysToBuild = await _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild);
+        Option<int> daysToBuild = await _configElementRepository.GetValue<int>(
+            ConfigElementKey.PlayoutDaysToBuild,
+            cancellationToken);
 
         Option<bool> skipMissingItems =
-            await _configElementRepository.GetValue<bool>(ConfigElementKey.PlayoutSkipMissingItems);
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.PlayoutSkipMissingItems, cancellationToken);
 
         return new PlayoutSettingsViewModel
         {

ErsatzTV.Application/Configuration/Queries/GetXmltvSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetXmltvSettingsHandler.cs

@@ -0,0 +1,30 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetXmltvSettingsHandler(IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetXmltvSettings, XmltvSettingsViewModel>
+{
+    public async Task<XmltvSettingsViewModel> Handle(GetXmltvSettings request, CancellationToken cancellationToken)
+    {
+        Option<int> daysToBuild = await configElementRepository.GetValue<int>(
+            ConfigElementKey.XmltvDaysToBuild,
+            cancellationToken);
+
+        Option<XmltvTimeZone> maybeTimeZone =
+            await configElementRepository.GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken);
+
+        Option<XmltvBlockBehavior> maybeBlockBehavior =
+            await configElementRepository.GetValue<XmltvBlockBehavior>(
+                ConfigElementKey.XmltvBlockBehavior,
+                cancellationToken);
+
+        return new XmltvSettingsViewModel
+        {
+            DaysToBuild = await daysToBuild.IfNoneAsync(2),
+            TimeZone = await maybeTimeZone.IfNoneAsync(XmltvTimeZone.Local),
+            BlockBehavior = await maybeBlockBehavior.IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly)
+        };
+    }
+}

ErsatzTV.Application/Configuration/XmltvBlockBehavior.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Application.Configuration;
+
+public enum XmltvBlockBehavior
+{
+    SplitTimeEvenly = 0,
+    UseActualTimes = 1
+}

ErsatzTV.Application/Configuration/XmltvSettingsViewModel.cs

@@ -0,0 +1,8 @@
+namespace ErsatzTV.Application.Configuration;
+
+public class XmltvSettingsViewModel
+{
+    public int DaysToBuild { get; set; }
+    public XmltvTimeZone TimeZone { get; set; }
+    public XmltvBlockBehavior BlockBehavior { get; set; }
+}

ErsatzTV.Application/Configuration/XmltvTimeZone.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Application.Configuration;
+
+public enum XmltvTimeZone
+{
+    Local = 0,
+    Utc = 1
+}

ErsatzTV.Application/Emby/Commands/CallEmbyCollectionScannerHandler.cs

@@ -26,7 +26,7 @@ public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<Synchr
     public async Task<Either<BaseError, Unit>>
         Handle(SynchronizeEmbyCollections request, CancellationToken cancellationToken)
     {
-        Validation<BaseError, string> validation = await Validate(request);
+        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
         return await validation.Match(
             scanner => PerformScan(scanner, request, cancellationToken),
             error =>
@@ -40,10 +40,13 @@ public class CallEmbyCollectionScannerHandler : CallLibraryScannerHandler<Synchr
             });
     }
 
-    protected override async Task<DateTimeOffset> GetLastScan(TvContext dbContext, SynchronizeEmbyCollections request)
+    protected override async Task<DateTimeOffset> GetLastScan(
+        TvContext dbContext,
+        SynchronizeEmbyCollections request,
+        CancellationToken cancellationToken)
     {
         DateTime minDateTime = await dbContext.EmbyMediaSources
-            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyMediaSourceId)
+            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyMediaSourceId, cancellationToken)
             .Match(l => l.LastCollectionsScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
 
         return new DateTimeOffset(minDateTime, TimeSpan.Zero);

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

@@ -38,7 +38,7 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
         ISynchronizeEmbyLibraryById request,
         CancellationToken cancellationToken)
     {
-        Validation<BaseError, string> validation = await Validate(request);
+        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
         return await validation.Match(
             scanner => PerformScan(scanner, request, cancellationToken),
             error =>
@@ -77,10 +77,11 @@ public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler<ISynchron
 
     protected override async Task<DateTimeOffset> GetLastScan(
         TvContext dbContext,
-        ISynchronizeEmbyLibraryById request)
+        ISynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken)
     {
         DateTime minDateTime = await dbContext.EmbyLibraries
-            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId)
+            .SelectOneAsync(l => l.Id, l => l.Id == request.EmbyLibraryId, cancellationToken)
             .Match(l => l.LastScan ?? SystemTime.MinValueUtc, () => SystemTime.MaxValueUtc);
 
         return new DateTimeOffset(minDateTime, TimeSpan.Zero);

ErsatzTV.Application/Emby/Commands/CallEmbyShowScannerHandler.cs

@@ -0,0 +1,79 @@
+using System.Globalization;
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.FFmpeg.Runtime;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Emby;
+
+public class CallEmbyShowScannerHandler : CallLibraryScannerHandler<SynchronizeEmbyShowById>,
+    IRequestHandler<SynchronizeEmbyShowById, Either<BaseError, string>>
+{
+    public CallEmbyShowScannerHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository,
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(dbContextFactory, configElementRepository, channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizeEmbyShowById, Either<BaseError, string>>.Handle(
+        SynchronizeEmbyShowById request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(
+        SynchronizeEmbyShowById request,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = await Validate(request, cancellationToken);
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error =>
+            {
+                foreach (ScanIsNotRequired scanIsNotRequired in error.OfType<ScanIsNotRequired>())
+                {
+                    return Task.FromResult<Either<BaseError, string>>(scanIsNotRequired);
+                }
+
+                return Task.FromResult<Either<BaseError, string>>(error.Join());
+            });
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        SynchronizeEmbyShowById request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-emby-show",
+            request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture),
+            request.ShowId.ToString(CultureInfo.InvariantCulture)
+        };
+
+        if (request.DeepScan)
+        {
+            arguments.Add("--deep");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+
+    protected override Task<DateTimeOffset> GetLastScan(
+        TvContext dbContext,
+        SynchronizeEmbyShowById request,
+        CancellationToken cancellationToken) =>
+        Task.FromResult(DateTimeOffset.MinValue);
+
+    protected override bool ScanIsRequired(
+        DateTimeOffset lastScan,
+        int libraryRefreshInterval,
+        SynchronizeEmbyShowById request) =>
+        true;
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

@@ -33,18 +33,21 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
     public Task<Either<BaseError, Unit>> Handle(
         SynchronizeEmbyLibraries request,
         CancellationToken cancellationToken) =>
-        Validate(request)
-            .MapT(SynchronizeLibraries)
+        Validate(request, cancellationToken)
+            .MapT(p => SynchronizeLibraries(p, cancellationToken))
             .Bind(v => v.ToEitherAsync());
 
-    private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeEmbyLibraries request) =>
-        MediaSourceMustExist(request)
+    private Task<Validation<BaseError, ConnectionParameters>> Validate(
+        SynchronizeEmbyLibraries request,
+        CancellationToken cancellationToken) =>
+        MediaSourceMustExist(request, cancellationToken)
             .BindT(MediaSourceMustHaveActiveConnection)
             .BindT(MediaSourceMustHaveApiKey);
 
     private Task<Validation<BaseError, EmbyMediaSource>> MediaSourceMustExist(
-        SynchronizeEmbyLibraries request) =>
-        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
+        SynchronizeEmbyLibraries request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>("Emby media source does not exist."));
 
     private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
@@ -65,7 +68,9 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
             .ToValidation<BaseError>("Emby media source requires an api key");
     }
 
-    private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
+    private async Task<Unit> SynchronizeLibraries(
+        ConnectionParameters connectionParameters,
+        CancellationToken cancellationToken)
     {
         Either<BaseError, List<EmbyLibrary>> maybeLibraries = await _embyApiClient.GetLibraries(
             connectionParameters.ActiveConnection.Address,
@@ -91,7 +96,8 @@ public class SynchronizeEmbyLibrariesHandler : IRequestHandler<SynchronizeEmbyLi
                 connectionParameters.EmbyMediaSource.Id,
                 toAdd,
                 toRemove,
-                toUpdate);
+                toUpdate,
+                cancellationToken);
             if (ids.Count != 0)
             {
                 await _searchIndex.RemoveItems(ids);

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

@@ -23,10 +23,9 @@ public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmb
         SynchronizeEmbyMediaSources request,
         CancellationToken cancellationToken)
     {
-        List<EmbyMediaSource> mediaSources = await _mediaSourceRepository.GetAllEmby();
+        List<EmbyMediaSource> mediaSources = await _mediaSourceRepository.GetAllEmby(cancellationToken);
         foreach (EmbyMediaSource mediaSource in mediaSources)
         {
-            // await _channel.WriteAsync(new SynchronizeEmbyAdminUserId(mediaSource.Id), cancellationToken);
             await _scannerWorkerChannel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);
         }
 

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyShowById.cs

@@ -0,0 +1,6 @@
+using ErsatzTV.Core;
+
+namespace ErsatzTV.Application.Emby;
+
+public record SynchronizeEmbyShowById(int EmbyLibraryId, int ShowId, bool DeepScan)
+    : IRequest<Either<BaseError, string>>, IScannerBackgroundServiceRequest;

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs

@@ -2,7 +2,6 @@
 
 namespace ErsatzTV.Application.Emby;
 
-public record UpdateEmbyLibraryPreferences
-    (List<EmbyLibraryPreference> Preferences) : IRequest<Either<BaseError, Unit>>;
+public record UpdateEmbyLibraryPreferences(List<EmbyLibraryPreference> Preferences) : IRequest<Either<BaseError, Unit>>;
 
 public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);

ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs

@@ -6,7 +6,7 @@ namespace ErsatzTV.Application.Emby;
 
 public class
     UpdateEmbyLibraryPreferencesHandler : IRequestHandler<UpdateEmbyLibraryPreferences,
-        Either<BaseError, Unit>>
+    Either<BaseError, Unit>>
 {
     private readonly IMediaSourceRepository _mediaSourceRepository;
     private readonly ISearchIndex _searchIndex;
@@ -23,7 +23,7 @@ public class
         UpdateEmbyLibraryPreferences request,
         CancellationToken cancellationToken)
     {
-        var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
+        var toDisable = request.Preferences.Filter(p => !p.ShouldSyncItems).Map(p => p.Id).ToList();
         List<int> ids = await _mediaSourceRepository.DisableEmbyLibrarySync(toDisable);
         await _searchIndex.RemoveItems(ids);
         _searchIndex.Commit();

ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs

@@ -15,7 +15,7 @@ public class UpdateEmbyPathReplacementsHandler : IRequestHandler<UpdateEmbyPathR
     public Task<Either<BaseError, Unit>> Handle(
         UpdateEmbyPathReplacements request,
         CancellationToken cancellationToken) =>
-        Validate(request)
+        Validate(request, cancellationToken)
             .MapT(pms => MergePathReplacements(request, pms))
             .Bind(v => v.ToEitherAsync());
 
@@ -37,13 +37,12 @@ public class UpdateEmbyPathReplacementsHandler : IRequestHandler<UpdateEmbyPathR
     private static EmbyPathReplacement Project(EmbyPathReplacementItem vm) =>
         new() { Id = vm.Id, EmbyPath = vm.EmbyPath, LocalPath = vm.LocalPath };
 
-    private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request) =>
-        EmbyMediaSourceMustExist(request);
+    private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request, CancellationToken cancellationToken) =>
+        EmbyMediaSourceMustExist(request, cancellationToken);
 
     private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
-        UpdateEmbyPathReplacements request) =>
-        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
-            .Map(
-                v => v.ToValidation<BaseError>(
-                    $"Emby media source {request.EmbyMediaSourceId} does not exist."));
+        UpdateEmbyPathReplacements request, CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId, cancellationToken)
+            .Map(v => v.ToValidation<BaseError>(
+                $"Emby media source {request.EmbyMediaSourceId} does not exist."));
 }

ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs

@@ -4,9 +4,9 @@ using ErsatzTV.Core.Domain;
 namespace ErsatzTV.Application.Emby;
 
 public record EmbyLibraryViewModel(
-        int Id,
-        string Name,
-        LibraryMediaKind MediaKind,
-        bool ShouldSyncItems,
-        int MediaSourceId)
+    int Id,
+    string Name,
+    LibraryMediaKind MediaKind,
+    bool ShouldSyncItems,
+    int MediaSourceId)
     : LibraryViewModel("Emby", Id, Name, MediaKind, MediaSourceId, string.Empty);

ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs

@@ -13,5 +13,5 @@ public class GetAllEmbyMediaSourcesHandler : IRequestHandler<GetAllEmbyMediaSour
     public Task<List<EmbyMediaSourceViewModel>> Handle(
         GetAllEmbyMediaSources request,
         CancellationToken cancellationToken) =>
-        _mediaSourceRepository.GetAllEmby().Map(list => list.Map(ProjectToViewModel).ToList());
+        _mediaSourceRepository.GetAllEmby(cancellationToken).Map(list => list.Map(ProjectToViewModel).ToList());
 }

ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs

@@ -34,7 +34,7 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
         }
 
         Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
-            await Validate()
+            await Validate(cancellationToken)
                 .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address, cp.ApiKey))
                 .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
 
@@ -47,16 +47,16 @@ public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnect
             error => error);
     }
 
-    private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
-        EmbyMediaSourceMustExist()
+    private Task<Validation<BaseError, ConnectionParameters>> Validate(CancellationToken cancellationToken) =>
+        EmbyMediaSourceMustExist(cancellationToken)
             .BindT(MediaSourceMustHaveActiveConnection)
             .BindT(MediaSourceMustHaveApiKey);
 
-    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
-        _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
-            .Map(
-                v => v.ToValidation<BaseError>(
-                    "Emby media source does not exist."));
+    private Task<Validation<BaseError, EmbyMediaSource>>
+        EmbyMediaSourceMustExist(CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetAllEmby(cancellationToken).Map(list => list.HeadOrNone())
+            .Map(v => v.ToValidation<BaseError>(
+                "Emby media source does not exist."));
 
     private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
         EmbyMediaSource embyMediaSource)

ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs

@@ -14,5 +14,5 @@ public class
     public Task<Option<EmbyMediaSourceViewModel>> Handle(
         GetEmbyMediaSourceById request,
         CancellationToken cancellationToken) =>
-        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId, cancellationToken).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs

@@ -1,4 +1,3 @@
 namespace ErsatzTV.Application.Emby;
 
-public record GetEmbyPathReplacementsBySourceId
-    (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
+public record GetEmbyPathReplacementsBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
+        <TargetFramework>net9.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
         <ImplicitUsings>enable</ImplicitUsings>
         <AnalysisLevel>latest-Recommended</AnalysisLevel>
@@ -9,24 +9,25 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Bugsnag" Version="3.1.0" />
-      <PackageReference Include="CliWrap" Version="3.6.4" />
-      <PackageReference Include="Humanizer.Core" Version="2.14.1" />
-      <PackageReference Include="MediatR" Version="12.2.0" />
-      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.8.14">
-        <PrivateAssets>all</PrivateAssets>
-        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      </PackageReference>
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-      <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="3.0.0" />
-      <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
+        <PackageReference Include="Bugsnag" Version="4.1.0" />
+        <PackageReference Include="CliWrap" Version="3.9.0" />
+        <PackageReference Include="Humanizer.Core" Version="2.14.1" />
+        <PackageReference Include="MediatR" Version="[12.5.0]" />
+        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.8" />
+        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.8" />
+        <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="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
+        <PackageReference Include="WebMarkupMin.Core" Version="2.19.0" />
+        <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
     </ItemGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
-      <ProjectReference Include="..\ErsatzTV.Infrastructure\ErsatzTV.Infrastructure.csproj" />
+        <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
+        <ProjectReference Include="..\ErsatzTV.Infrastructure\ErsatzTV.Infrastructure.csproj" />
     </ItemGroup>
 
 </Project>

ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings

@@ -1,5 +1,6 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=artists_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=artworks_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=channels_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=channels_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=configuration_005Ccommands/@EntryIndexedValue">True</s:Boolean>
@@ -10,6 +11,8 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Cqueries/@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>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=graphics_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=hdhr_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=hdhr_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=health_005Cqueries/@EntryIndexedValue">True</s:Boolean>
@@ -44,5 +47,7 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=subtitles_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=television_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=templates_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=troubleshooting_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=validators/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Cqueries/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs

@@ -2,5 +2,4 @@
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public record CopyFFmpegProfile
-    (int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
+public record CopyFFmpegProfile(int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -8,15 +8,20 @@ public record CreateFFmpegProfile(
     string Name,
     int ThreadCount,
     HardwareAccelerationKind HardwareAcceleration,
+    string VaapiDisplay,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     int ResolutionId,
     ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
+    FFmpegProfileTonemapAlgorithm TonemapAlgorithm,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -24,7 +24,7 @@ public class CreateFFmpegProfileHandler :
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
+        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request, cancellationToken);
         return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
     }
 
@@ -40,32 +40,42 @@ public class CreateFFmpegProfileHandler :
 
     private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
         TvContext dbContext,
-        CreateFFmpegProfile request) =>
-        (ValidateName(request), ValidateThreadCount(request), await ResolutionMustExist(dbContext, request))
-        .Apply(
-            (name, threadCount, resolutionId) => new FFmpegProfile
-            {
-                Name = name,
-                ThreadCount = threadCount,
-                HardwareAcceleration = request.HardwareAcceleration,
-                VaapiDriver = request.VaapiDriver,
-                VaapiDevice = request.VaapiDevice,
-                QsvExtraHardwareFrames = request.QsvExtraHardwareFrames,
-                ResolutionId = resolutionId,
-                ScalingBehavior = request.ScalingBehavior,
-                VideoFormat = request.VideoFormat,
-                BitDepth = request.BitDepth,
-                VideoBitrate = request.VideoBitrate,
-                VideoBufferSize = request.VideoBufferSize,
-                AudioFormat = request.AudioFormat,
-                AudioBitrate = request.AudioBitrate,
-                AudioBufferSize = request.AudioBufferSize,
-                NormalizeLoudnessMode = request.NormalizeLoudnessMode,
-                AudioChannels = request.AudioChannels,
-                AudioSampleRate = request.AudioSampleRate,
-                NormalizeFramerate = request.NormalizeFramerate,
-                DeinterlaceVideo = request.DeinterlaceVideo
-            });
+        CreateFFmpegProfile request,
+        CancellationToken cancellationToken) =>
+        (ValidateName(request), ValidateThreadCount(request),
+            await ResolutionMustExist(dbContext, request, cancellationToken))
+        .Apply((name, threadCount, resolutionId) => new FFmpegProfile
+        {
+            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,
+
+            // 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.AudioFormat,
+            AudioBitrate = request.AudioBitrate,
+            AudioBufferSize = request.AudioBufferSize,
+            NormalizeLoudnessMode = request.NormalizeLoudnessMode,
+            AudioChannels = request.AudioChannels,
+            AudioSampleRate = request.AudioSampleRate,
+            NormalizeFramerate = request.NormalizeFramerate,
+            DeinterlaceVideo = request.DeinterlaceVideo
+        });
 
     private static Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>
         createFFmpegProfile.NotEmpty(x => x.Name)
@@ -76,9 +86,10 @@ public class CreateFFmpegProfileHandler :
 
     private static Task<Validation<BaseError, int>> ResolutionMustExist(
         TvContext dbContext,
-        CreateFFmpegProfile createFFmpegProfile) =>
+        CreateFFmpegProfile createFFmpegProfile,
+        CancellationToken cancellationToken) =>
         dbContext.Resolutions
-            .SelectOneAsync(r => r.Id, r => r.Id == createFFmpegProfile.ResolutionId)
+            .SelectOneAsync(r => r.Id, r => r.Id == createFFmpegProfile.ResolutionId, cancellationToken)
             .MapT(r => r.Id)
             .Map(o => o.ToValidation<BaseError>($"[Resolution] {createFFmpegProfile.ResolutionId} does not exist"));
 }

ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs

@@ -23,7 +23,7 @@ public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, E
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FFmpegProfile> validation = await FFmpegProfileMustExist(dbContext, request);
+        Validation<BaseError, FFmpegProfile> validation = await FFmpegProfileMustExist(dbContext, request, cancellationToken);
         return await validation.Apply(p => DoDeletion(dbContext, p));
     }
 
@@ -37,8 +37,9 @@ public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, E
 
     private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
         TvContext dbContext,
-        DeleteFFmpegProfile request) =>
+        DeleteFFmpegProfile request,
+        CancellationToken cancellationToken) =>
         dbContext.FFmpegProfiles
-            .SelectOneAsync(p => p.Id, p => p.Id == request.FFmpegProfileId)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.FFmpegProfileId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {request.FFmpegProfileId} does not exist"));
 }

ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfileHandler.cs

@@ -18,7 +18,7 @@ public class NewFFmpegProfileHandler : IRequestHandler<NewFFmpegProfile, FFmpegP
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
         int defaultResolutionId = await dbContext.ConfigElements
-            .GetValue<int>(ConfigElementKey.FFmpegDefaultResolutionId)
+            .GetValue<int>(ConfigElementKey.FFmpegDefaultResolutionId, cancellationToken)
             .IfNoneAsync(0);
 
         List<Resolution> allResolutions = await dbContext.Resolutions

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -9,15 +9,20 @@ public record UpdateFFmpegProfile(
     string Name,
     int ThreadCount,
     HardwareAccelerationKind HardwareAcceleration,
+    string VaapiDisplay,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     int ResolutionId,
     ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
+    FFmpegProfileTonemapAlgorithm TonemapAlgorithm,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -24,32 +24,38 @@ public class
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
-        return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request));
+        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request, cancellationToken);
+        return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request, cancellationToken));
     }
 
     private async Task<UpdateFFmpegProfileResult> ApplyUpdateRequest(
         TvContext dbContext,
         FFmpegProfile p,
-        UpdateFFmpegProfile update)
+        UpdateFFmpegProfile update,
+        CancellationToken cancellationToken)
     {
         p.Name = update.Name;
         p.ThreadCount = update.ThreadCount;
         p.HardwareAcceleration = update.HardwareAcceleration;
+        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.VideoProfile = update.VideoProfile;
+        p.VideoPreset = update.VideoPreset;
+        p.AllowBFrames = update.AllowBFrames;
 
         // mpeg2video only supports 8-bit content
-        p.BitDepth = update.VideoFormat == FFmpegProfileVideoFormat.Mpeg2Video
+        p.BitDepth = update.VideoFormat is FFmpegProfileVideoFormat.Mpeg2Video
             ? FFmpegProfileBitDepth.EightBit
             : update.BitDepth;
 
         p.VideoBitrate = update.VideoBitrate;
         p.VideoBufferSize = update.VideoBufferSize;
+        p.TonemapAlgorithm = update.TonemapAlgorithm;
         p.AudioFormat = update.AudioFormat;
         p.AudioBitrate = update.AudioBitrate;
         p.AudioBufferSize = update.AudioBufferSize;
@@ -58,25 +64,28 @@ public class
         p.AudioSampleRate = update.AudioSampleRate;
         p.NormalizeFramerate = update.NormalizeFramerate;
         p.DeinterlaceVideo = update.DeinterlaceVideo;
-        await dbContext.SaveChangesAsync();
-        
+        await dbContext.SaveChangesAsync(cancellationToken);
+
         _searchTargets.SearchTargetsChanged();
-        
+
         return new UpdateFFmpegProfileResult(p.Id);
     }
 
     private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
         TvContext dbContext,
-        UpdateFFmpegProfile request) =>
-        (await FFmpegProfileMustExist(dbContext, request), ValidateName(request), ValidateThreadCount(request),
-            await ResolutionMustExist(dbContext, request))
+        UpdateFFmpegProfile request,
+        CancellationToken cancellationToken) =>
+        (await FFmpegProfileMustExist(dbContext, request, cancellationToken), ValidateName(request),
+            ValidateThreadCount(request),
+            await ResolutionMustExist(dbContext, request, cancellationToken))
         .Apply((ffmpegProfileToUpdate, _, _, _) => ffmpegProfileToUpdate);
 
     private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
         TvContext dbContext,
-        UpdateFFmpegProfile updateFFmpegProfile) =>
+        UpdateFFmpegProfile updateFFmpegProfile,
+        CancellationToken cancellationToken) =>
         dbContext.FFmpegProfiles
-            .SelectOneAsync(p => p.Id, p => p.Id == updateFFmpegProfile.FFmpegProfileId)
+            .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) =>
@@ -88,9 +97,10 @@ public class
 
     private static Task<Validation<BaseError, int>> ResolutionMustExist(
         TvContext dbContext,
-        UpdateFFmpegProfile updateFFmpegProfile) =>
+        UpdateFFmpegProfile updateFFmpegProfile,
+        CancellationToken cancellationToken) =>
         dbContext.Resolutions
-            .SelectOneAsync(r => r.Id, r => r.Id == updateFFmpegProfile.ResolutionId)
+            .SelectOneAsync(r => r.Id, r => r.Id == updateFFmpegProfile.ResolutionId, cancellationToken)
             .MapT(r => r.Id)
             .Map(o => o.ToValidation<BaseError>($"[Resolution] {updateFFmpegProfile.ResolutionId} does not exist"));
 }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,5 +1,7 @@
 using System.Diagnostics;
 using System.Globalization;
+using System.Threading.Channels;
+using ErsatzTV.Application.Subtitles;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
@@ -11,20 +13,23 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly ILocalFileSystem _localFileSystem;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
 
     public UpdateFFmpegSettingsHandler(
         IConfigElementRepository configElementRepository,
-        ILocalFileSystem localFileSystem)
+        ILocalFileSystem localFileSystem,
+        ChannelWriter<IBackgroundServiceRequest> workerChannel)
     {
         _configElementRepository = configElementRepository;
         _localFileSystem = localFileSystem;
+        _workerChannel = workerChannel;
     }
 
     public Task<Either<BaseError, Unit>> Handle(
         UpdateFFmpegSettings request,
         CancellationToken cancellationToken) =>
         Validate(request)
-            .MapT(_ => ApplyUpdate(request))
+            .MapT(_ => ApplyUpdate(request, cancellationToken))
             .Bind(v => v.ToEitherAsync());
 
     private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
@@ -64,19 +69,22 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
             : BaseError.New($"Unable to verify {name} version");
     }
 
-    private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request)
+    private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request, CancellationToken cancellationToken)
     {
-        await _configElementRepository.Upsert(ConfigElementKey.FFmpegPath, request.Settings.FFmpegPath);
-        await _configElementRepository.Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath);
+        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));
+            request.Settings.DefaultFFmpegProfileId.ToString(CultureInfo.InvariantCulture),
+            cancellationToken);
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegSaveReports,
-            request.Settings.SaveReports.ToString());
+            request.Settings.SaveReports.ToString(),
+            cancellationToken);
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegHlsDirectOutputFormat,
-            request.Settings.HlsDirectOutputFormat);
+            request.Settings.HlsDirectOutputFormat,
+            cancellationToken);
 
         if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
         {
@@ -85,41 +93,69 @@ public class UpdateFFmpegSettingsHandler : IRequestHandler<UpdateFFmpegSettings,
 
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegPreferredLanguageCode,
-            request.Settings.PreferredAudioLanguageCode);
+            request.Settings.PreferredAudioLanguageCode,
+            cancellationToken);
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegUseEmbeddedSubtitles,
+            request.Settings.UseEmbeddedSubtitles,
+            cancellationToken);
+
+        // do not extract when subtitles are not used
+        if (!request.Settings.UseEmbeddedSubtitles)
+        {
+            request.Settings.ExtractEmbeddedSubtitles = false;
+        }
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegExtractEmbeddedSubtitles,
+            request.Settings.ExtractEmbeddedSubtitles,
+            cancellationToken);
+
+        // queue extracting all embedded subtitles
+        if (request.Settings.ExtractEmbeddedSubtitles)
+        {
+            await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(Option<int>.None), cancellationToken);
+        }
 
         if (request.Settings.GlobalWatermarkId is not null)
         {
             await _configElementRepository.Upsert(
                 ConfigElementKey.FFmpegGlobalWatermarkId,
-                request.Settings.GlobalWatermarkId.Value);
+                request.Settings.GlobalWatermarkId.Value,
+                cancellationToken);
         }
         else
         {
-            await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId);
+            await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId, cancellationToken);
         }
 
         if (request.Settings.GlobalFallbackFillerId is not null)
         {
             await _configElementRepository.Upsert(
                 ConfigElementKey.FFmpegGlobalFallbackFillerId,
-                request.Settings.GlobalFallbackFillerId.Value);
+                request.Settings.GlobalFallbackFillerId.Value,
+                cancellationToken);
         }
         else
         {
-            await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalFallbackFillerId);
+            await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalFallbackFillerId, cancellationToken);
         }
 
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegSegmenterTimeout,
-            request.Settings.HlsSegmenterIdleTimeout);
+            request.Settings.HlsSegmenterIdleTimeout,
+            cancellationToken);
 
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegWorkAheadSegmenters,
-            request.Settings.WorkAheadSegmenterLimit);
+            request.Settings.WorkAheadSegmenterLimit,
+            cancellationToken);
 
         await _configElementRepository.Upsert(
             ConfigElementKey.FFmpegInitialSegmentCount,
-            request.Settings.InitialSegmentCount);
+            request.Settings.InitialSegmentCount,
+            cancellationToken);
 
         return Unit.Default;
     }

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -9,15 +9,20 @@ public record FFmpegProfileViewModel(
     string Name,
     int ThreadCount,
     HardwareAccelerationKind HardwareAcceleration,
+    string VaapiDisplay,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
     int? QsvExtraHardwareFrames,
     ResolutionViewModel Resolution,
     ScalingBehavior ScalingBehavior,
     FFmpegProfileVideoFormat VideoFormat,
+    string VideoProfile,
+    string VideoPreset,
+    bool AllowBFrames,
     FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
+    FFmpegProfileTonemapAlgorithm TonemapAlgorithm,
     FFmpegProfileAudioFormat AudioFormat,
     int AudioBitrate,
     int AudioBufferSize,

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -8,6 +8,8 @@ public class FFmpegSettingsViewModel
     public string FFprobePath { get; set; }
     public int DefaultFFmpegProfileId { get; set; }
     public string PreferredAudioLanguageCode { get; set; }
+    public bool UseEmbeddedSubtitles { get; set; }
+    public bool ExtractEmbeddedSubtitles { get; set; }
     public bool SaveReports { get; set; }
     public int? GlobalWatermarkId { get; set; }
     public int? GlobalFallbackFillerId { get; set; }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -11,15 +11,20 @@ internal static class Mapper
             profile.Name,
             profile.ThreadCount,
             profile.HardwareAcceleration,
+            profile.VaapiDisplay ?? "drm",
             profile.VaapiDriver,
             profile.VaapiDevice,
             profile.QsvExtraHardwareFrames,
             Resolutions.Mapper.ProjectToViewModel(profile.Resolution),
             profile.ScalingBehavior,
             profile.VideoFormat,
+            profile.VideoProfile,
+            profile.VideoPreset ?? string.Empty,
+            profile.AllowBFrames,
             profile.BitDepth,
             profile.VideoBitrate,
             profile.VideoBufferSize,
+            profile.TonemapAlgorithm,
             profile.AudioFormat,
             profile.AudioBitrate,
             profile.AudioBufferSize,
@@ -43,12 +48,14 @@ internal static class Mapper
             ffmpegProfile.Name,
             ffmpegProfile.ThreadCount,
             (int)ffmpegProfile.HardwareAcceleration,
+            ffmpegProfile.VaapiDisplay,
             (int)ffmpegProfile.VaapiDriver,
             ffmpegProfile.VaapiDevice,
             ffmpegProfile.ResolutionId,
             (int)ffmpegProfile.VideoFormat,
             ffmpegProfile.VideoBitrate,
             ffmpegProfile.VideoBufferSize,
+            (int)ffmpegProfile.TonemapAlgorithm,
             (int)ffmpegProfile.AudioFormat,
             ffmpegProfile.AudioBitrate,
             ffmpegProfile.AudioBufferSize,

ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfilesHandler.cs

@@ -4,18 +4,14 @@ using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
 namespace ErsatzTV.Application.FFmpegProfiles;
 
-public class GetAllFFmpegProfilesHandler : IRequestHandler<GetAllFFmpegProfiles, List<FFmpegProfileViewModel>>
+public class GetAllFFmpegProfilesHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllFFmpegProfiles, List<FFmpegProfileViewModel>>
 {
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-    public GetAllFFmpegProfilesHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-        _dbContextFactory = dbContextFactory;
-
     public async Task<List<FFmpegProfileViewModel>> Handle(
         GetAllFFmpegProfiles 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)
             .ToListAsync(cancellationToken)

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdForApiHandler.cs

@@ -8,7 +8,7 @@ namespace ErsatzTV.Application.FFmpegProfiles;
 
 public class
     GetFFmpegProfileByIdForApiHandler : IRequestHandler<GetFFmpegFullProfileByIdForApi,
-        Option<FFmpegFullProfileResponseModel>>
+    Option<FFmpegFullProfileResponseModel>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
 
@@ -22,7 +22,7 @@ public class
         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)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.Id, cancellationToken)
             .MapT(ProjectToFullResponseModel);
     }
 }

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdHandler.cs

@@ -19,7 +19,7 @@ public class GetFFmpegProfileByIdHandler : IRequestHandler<GetFFmpegProfileById,
         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)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.Id, cancellationToken)
             .MapT(ProjectToViewModel);
     }
 }

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -15,26 +15,30 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
         GetFFmpegSettings request,
         CancellationToken cancellationToken)
     {
-        Option<string> ffmpegPath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath);
-        Option<string> ffprobePath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath);
+        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);
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId, cancellationToken);
         Option<bool> saveReports =
-            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports, cancellationToken);
         Option<string> preferredAudioLanguageCode =
-            await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
+            await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode, cancellationToken);
+        Option<bool> useEmbeddedSubtitles =
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegUseEmbeddedSubtitles, cancellationToken);
+        Option<bool> extractEmbeddedSubtitles =
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegExtractEmbeddedSubtitles, cancellationToken);
         Option<int> watermark =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId);
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId, cancellationToken);
         Option<int> fallbackFiller =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalFallbackFillerId);
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalFallbackFillerId, cancellationToken);
         Option<int> hlsSegmenterIdleTimeout =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout);
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout, cancellationToken);
         Option<int> workAheadSegmenterLimit =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters);
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters, cancellationToken);
         Option<int> initialSegmentCount =
-            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount);
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount, cancellationToken);
         Option<OutputFormatKind> outputFormatKind =
-            await _configElementRepository.GetValue<OutputFormatKind>(ConfigElementKey.FFmpegHlsDirectOutputFormat);
+            await _configElementRepository.GetValue<OutputFormatKind>(ConfigElementKey.FFmpegHlsDirectOutputFormat, cancellationToken);
 
         var result = new FFmpegSettingsViewModel
         {
@@ -42,6 +46,8 @@ public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpe
             FFprobePath = await ffprobePath.IfNoneAsync(string.Empty),
             DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
             SaveReports = await saveReports.IfNoneAsync(false),
+            UseEmbeddedSubtitles = await useEmbeddedSubtitles.IfNoneAsync(true),
+            ExtractEmbeddedSubtitles = await extractEmbeddedSubtitles.IfNoneAsync(false),
             PreferredAudioLanguageCode = await preferredAudioLanguageCode.IfNoneAsync("eng"),
             HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
             WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),

ErsatzTV.Application/FFmpegProfiles/Queries/GetSupportedHardwareAccelerationKindsHandler.cs

@@ -10,7 +10,7 @@ namespace ErsatzTV.Application.FFmpegProfiles;
 
 public class
     GetSupportedHardwareAccelerationKindsHandler : IRequestHandler<GetSupportedHardwareAccelerationKinds,
-        List<HardwareAccelerationKind>>
+    List<HardwareAccelerationKind>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
     private readonly IHardwareCapabilitiesFactory _hardwareCapabilitiesFactory;
@@ -28,7 +28,7 @@ public class
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, string> validation = await Validate(dbContext);
+        Validation<BaseError, string> validation = await Validate(dbContext, cancellationToken);
 
         return await validation.Match(
             GetHardwareAccelerationKinds,
@@ -69,11 +69,11 @@ public class
         return result;
     }
 
-    private static async Task<Validation<BaseError, string>> Validate(TvContext dbContext) =>
-        await FFmpegPathMustExist(dbContext);
+    private static async Task<Validation<BaseError, string>> Validate(TvContext dbContext, CancellationToken cancellationToken) =>
+            await FFmpegPathMustExist(dbContext, cancellationToken);
 
-    private static Task<Validation<BaseError, string>> FFmpegPathMustExist(TvContext dbContext) =>
-        dbContext.ConfigElements.GetValue<string>(ConfigElementKey.FFmpegPath)
+    private static Task<Validation<BaseError, string>> FFmpegPathMustExist(TvContext dbContext, CancellationToken cancellationToken) =>
+        dbContext.ConfigElements.GetValue<string>(ConfigElementKey.FFmpegPath, cancellationToken)
             .FilterT(File.Exists)
             .Map(maybePath => maybePath.ToValidation<BaseError>("FFmpeg path does not exist on filesystem"));
 }

ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs

@@ -16,5 +16,8 @@ public record CreateFillerPreset(
     int? CollectionId,
     int? MediaItemId,
     int? MultiCollectionId,
-    int? SmartCollectionId
+    int? SmartCollectionId,
+    int? PlaylistId,
+    string Expression,
+    bool UseChaptersAsMediaItems
 ) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs

@@ -36,7 +36,11 @@ public class CreateFillerPresetHandler : IRequestHandler<CreateFillerPreset, Eit
                 CollectionId = request.CollectionId,
                 MediaItemId = request.MediaItemId,
                 MultiCollectionId = request.MultiCollectionId,
-                SmartCollectionId = request.SmartCollectionId
+                SmartCollectionId = request.SmartCollectionId,
+                PlaylistId = request.PlaylistId,
+                Expression = request.FillerKind is FillerKind.MidRoll ? request.Expression : null,
+                UseChaptersAsMediaItems =
+                    request.FillerKind is not FillerKind.Fallback && request.UseChaptersAsMediaItems
             };
 
             await dbContext.FillerPresets.AddAsync(fillerPreset, cancellationToken);

ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs

@@ -18,7 +18,7 @@ public class DeleteFillerPresetHandler : IRequestHandler<DeleteFillerPreset, Eit
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
+        Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request, cancellationToken);
         return await validation.Apply(ps => DoDeletion(dbContext, ps));
     }
 
@@ -30,8 +30,9 @@ public class DeleteFillerPresetHandler : IRequestHandler<DeleteFillerPreset, Eit
 
     private static Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
         TvContext dbContext,
-        DeleteFillerPreset request) =>
+        DeleteFillerPreset request,
+        CancellationToken cancellationToken) =>
         dbContext.FillerPresets
-            .SelectOneAsync(fp => fp.Id, ps => ps.Id == request.FillerPresetId)
+            .SelectOneAsync(fp => fp.Id, ps => ps.Id == request.FillerPresetId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>($"FillerPreset {request.FillerPresetId} does not exist."));
 }